signal-sdk 0.1.1 → 0.1.3

package/dist/managers/ContactManager.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContactManager = void 0;
+const BaseManager_1 = require("./BaseManager");
+const validators_1 = require("../validators");
+const errors_1 = require("../errors");
+class ContactManager extends BaseManager_1.BaseManager {
+    async updateContact(number, name, options = {}) {
+        const params = { account: this.account, recipient: number };
+        if (name)
+            params.name = name;
+        if (options.givenName)
+            params.givenName = options.givenName;
+        if (options.familyName)
+            params.familyName = options.familyName;
+        if (options.nickGivenName)
+            params.nickGivenName = options.nickGivenName;
+        if (options.nickFamilyName)
+            params.nickFamilyName = options.nickFamilyName;
+        if (options.note)
+            params.note = options.note;
+        if (options.expiration !== undefined)
+            params.expiration = options.expiration;
+        if (options.color)
+            params.color = options.color;
+        if (options.block !== undefined)
+            params.block = options.block;
+        if (options.unblock !== undefined)
+            params.unblock = options.unblock;
+        if (options.archived !== undefined)
+            params.archived = options.archived;
+        if (options.muted !== undefined)
+            params.muted = options.muted;
+        if (options.mutedUntil !== undefined)
+            params.mutedUntil = options.mutedUntil;
+        if (options.hideStory !== undefined)
+            params.hideStory = options.hideStory;
+        await this.sendRequest('updateContact', params);
+    }
+    async block(recipients, groupId) {
+        await this.sendRequest('block', { account: this.account, recipient: recipients, groupId });
+    }
+    async unblock(recipients, groupId) {
+        await this.sendRequest('unblock', { account: this.account, recipient: recipients, groupId });
+    }
+    async listContacts() {
+        return this.sendRequest('listContacts', { account: this.account });
+    }
+    async removeContact(number, options = {}) {
+        const params = {
+            account: this.account,
+            recipient: number,
+        };
+        if (options.hide)
+            params.hide = true;
+        if (options.forget)
+            params.forget = true;
+        await this.sendRequest('removeContact', params);
+    }
+    async getUserStatus(numbers = [], usernames = []) {
+        const params = { account: this.account };
+        if (numbers.length > 0)
+            params.recipients = numbers;
+        if (usernames.length > 0)
+            params.usernames = usernames;
+        const result = await this.sendRequest('getUserStatus', params);
+        const statusResults = [];
+        if (result.recipients) {
+            result.recipients.forEach((recipient) => {
+                statusResults.push({
+                    number: recipient.number,
+                    isRegistered: recipient.isRegistered || false,
+                    uuid: recipient.uuid,
+                    username: recipient.username,
+                });
+            });
+        }
+        return statusResults;
+    }
+    async listIdentities(number) {
+        return this.sendRequest('listIdentities', { account: this.account, number });
+    }
+    async trustIdentity(number, safetyNumber, verified = true) {
+        await this.sendRequest('trust', { account: this.account, recipient: number, safetyNumber, verified });
+    }
+    async getAvatar(options) {
+        this.logger.debug('Getting avatar', options);
+        const params = { account: this.account };
+        if (options.contact) {
+            (0, validators_1.validateRecipient)(options.contact);
+            params.contact = options.contact;
+        }
+        else if (options.profile) {
+            (0, validators_1.validateRecipient)(options.profile);
+            params.profile = options.profile;
+        }
+        else if (options.groupId) {
+            params.groupId = options.groupId;
+        }
+        else {
+            throw new errors_1.MessageError('Must specify contact, profile, or groupId');
+        }
+        const result = await this.sendRequest('getAvatar', params);
+        return result.data || result;
+    }
+    parseContactProfile(contact) {
+        return {
+            ...contact,
+            givenName: contact.givenName || undefined,
+            familyName: contact.familyName || undefined,
+            mobileCoinAddress: contact.mobileCoinAddress || undefined,
+            profileName: contact.profileName ||
+                (contact.givenName && contact.familyName
+                    ? `${contact.givenName} ${contact.familyName}`
+                    : contact.givenName || contact.familyName),
+        };
+    }
+    async getContactsWithProfiles() {
+        const contacts = await this.listContacts();
+        return contacts.map((c) => this.parseContactProfile(c));
+    }
+}
+exports.ContactManager = ContactManager;

package/dist/managers/DeviceManager.d.ts

@@ -0,0 +1,11 @@
+import { BaseManager } from './BaseManager';
+import { Device, LinkingOptions, LinkingResult, UpdateDeviceOptions } from '../interfaces';
+export declare class DeviceManager extends BaseManager {
+    private readonly signalCliPath;
+    constructor(sendRequest: (method: string, params?: any) => Promise<any>, account: string | undefined, logger: any, config: any, signalCliPath: string);
+    listDevices(): Promise<Device[]>;
+    addDevice(uri: string, deviceName?: string): Promise<void>;
+    removeDevice(deviceId: number): Promise<void>;
+    updateDevice(options: UpdateDeviceOptions): Promise<void>;
+    deviceLink(options?: LinkingOptions): Promise<LinkingResult>;
+}

package/dist/managers/DeviceManager.js

@@ -0,0 +1,139 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceManager = void 0;
+const BaseManager_1 = require("./BaseManager");
+const validators_1 = require("../validators");
+const qrcodeTerminal = __importStar(require("qrcode-terminal"));
+const child_process_1 = require("child_process");
+class DeviceManager extends BaseManager_1.BaseManager {
+    constructor(sendRequest, account, logger, config, signalCliPath) {
+        super(sendRequest, account, logger, config);
+        this.signalCliPath = signalCliPath;
+    }
+    async listDevices() {
+        return this.sendRequest('listDevices', { account: this.account });
+    }
+    async addDevice(uri, deviceName) {
+        await this.sendRequest('addDevice', { account: this.account, uri, deviceName });
+    }
+    async removeDevice(deviceId) {
+        await this.sendRequest('removeDevice', { account: this.account, deviceId });
+    }
+    async updateDevice(options) {
+        this.logger.debug('Updating device', options);
+        (0, validators_1.validateDeviceId)(options.deviceId);
+        (0, validators_1.validateMessage)(options.deviceName, 200);
+        await this.sendRequest('updateDevice', {
+            deviceId: options.deviceId,
+            deviceName: options.deviceName,
+            account: this.account,
+        });
+    }
+    async deviceLink(options = {}) {
+        return new Promise((resolve, reject) => {
+            const deviceName = options.name || 'Signal SDK Device';
+            (0, validators_1.validateSanitizedString)(deviceName, 'deviceName');
+            let linkProcess;
+            if (process.platform === 'win32') {
+                linkProcess = (0, child_process_1.spawn)('cmd.exe', ['/c', `"${this.signalCliPath}"`, 'link', '--name', deviceName], {
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                });
+            }
+            else {
+                linkProcess = (0, child_process_1.spawn)(this.signalCliPath, ['link', '--name', deviceName], {
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                });
+            }
+            let qrCodeData;
+            let linkingComplete = false;
+            let hasError = false;
+            linkProcess.stdout.on('data', (data) => {
+                const output = data.toString('utf8').trim();
+                if (output.includes('sgnl://')) {
+                    const uriMatch = output.match(/sgnl:\/\/[^\s]+/);
+                    if (uriMatch && !qrCodeData) {
+                        const uri = uriMatch[0];
+                        qrCodeData = { uri };
+                        if (options.qrCodeOutput === 'console') {
+                            console.log('\n- QR CODE - SCAN WITH YOUR PHONE:');
+                            console.log('===================================');
+                            qrcodeTerminal.generate(uri, { small: true });
+                            console.log('===================================\n');
+                        }
+                    }
+                }
+                if (output.includes('Device registered') || output.includes('Successfully linked')) {
+                    linkingComplete = true;
+                }
+            });
+            linkProcess.stderr.on('data', (data) => {
+                const error = data.toString('utf8').trim();
+                if (!error.includes('INFO') && !error.includes('DEBUG') && error.length > 0) {
+                    hasError = true;
+                }
+            });
+            linkProcess.on('close', (code) => {
+                if (code === 0 && linkingComplete) {
+                    resolve({
+                        success: true,
+                        isLinked: true,
+                        deviceName,
+                        qrCode: qrCodeData,
+                    });
+                }
+                else if (code === 0 && qrCodeData) {
+                    resolve({
+                        success: true,
+                        isLinked: false,
+                        deviceName,
+                        qrCode: qrCodeData,
+                    });
+                }
+                else {
+                    resolve({
+                        success: false,
+                        error: hasError ? 'Device linking failed' : `signal-cli exited with code ${code}`,
+                        qrCode: qrCodeData,
+                    });
+                }
+            });
+            linkProcess.on('error', (error) => {
+                reject(new Error(`Failed to start device linking: ${error.message}`));
+            });
+        });
+    }
+}
+exports.DeviceManager = DeviceManager;

package/dist/managers/GroupManager.d.ts

@@ -0,0 +1,12 @@
+import { BaseManager } from './BaseManager';
+import { GroupInfo, GroupUpdateOptions, ListGroupsOptions } from '../interfaces';
+export declare class GroupManager extends BaseManager {
+    createGroup(name: string, members: string[]): Promise<GroupInfo>;
+    updateGroup(groupId: string, options: GroupUpdateOptions): Promise<void>;
+    listGroups(): Promise<GroupInfo[]>;
+    quitGroup(groupId: string): Promise<void>;
+    joinGroup(uri: string): Promise<void>;
+    listGroupsDetailed(options?: ListGroupsOptions): Promise<GroupInfo[]>;
+    parseGroupDetails(group: GroupInfo): GroupInfo;
+    getGroupsWithDetails(options?: ListGroupsOptions): Promise<GroupInfo[]>;
+}

package/dist/managers/GroupManager.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupManager = void 0;
+const BaseManager_1 = require("./BaseManager");
+class GroupManager extends BaseManager_1.BaseManager {
+    async createGroup(name, members) {
+        return this.sendRequest('updateGroup', { account: this.account, name, members });
+    }
+    async updateGroup(groupId, options) {
+        const params = { groupId, account: this.account };
+        if (options.name)
+            params.name = options.name;
+        if (options.description)
+            params.description = options.description;
+        if (options.avatar)
+            params.avatar = options.avatar;
+        if (options.addMembers)
+            params.addMembers = options.addMembers;
+        if (options.removeMembers)
+            params.removeMembers = options.removeMembers;
+        if (options.promoteAdmins)
+            params.promoteAdmins = options.promoteAdmins;
+        if (options.demoteAdmins)
+            params.demoteAdmins = options.demoteAdmins;
+        if (options.banMembers)
+            params.banMembers = options.banMembers;
+        if (options.unbanMembers)
+            params.unbanMembers = options.unbanMembers;
+        if (options.resetInviteLink)
+            params.resetLink = true;
+        if (options.permissionAddMember)
+            params.permissionAddMember = options.permissionAddMember;
+        if (options.permissionEditDetails)
+            params.permissionEditDetails = options.permissionEditDetails;
+        if (options.permissionSendMessage)
+            params.permissionSendMessage = options.permissionSendMessage;
+        if (options.expirationTimer)
+            params.expiration = options.expirationTimer;
+        await this.sendRequest('updateGroup', params);
+    }
+    async listGroups() {
+        return this.sendRequest('listGroups', { account: this.account });
+    }
+    async quitGroup(groupId) {
+        await this.sendRequest('quitGroup', { account: this.account, groupId });
+    }
+    async joinGroup(uri) {
+        await this.sendRequest('joinGroup', { account: this.account, uri });
+    }
+    async listGroupsDetailed(options = {}) {
+        this.logger.debug('Listing groups with options', options);
+        const params = { account: this.account };
+        if (options.detailed) {
+            params.detailed = true;
+        }
+        if (options.groupIds && options.groupIds.length > 0) {
+            params.groupId = options.groupIds;
+        }
+        return this.sendRequest('listGroups', params);
+    }
+    parseGroupDetails(group) {
+        return {
+            ...group,
+            inviteLink: group.groupInviteLink || group.inviteLink,
+            groupInviteLink: group.groupInviteLink || group.inviteLink,
+            pendingMembers: group.pendingMembers || [],
+            banned: group.banned || [],
+            requestingMembers: group.requestingMembers || [],
+            admins: group.admins || [],
+            members: group.members || [],
+        };
+    }
+    async getGroupsWithDetails(options = {}) {
+        const groups = await this.listGroupsDetailed(options);
+        return groups.map((g) => this.parseGroupDetails(g));
+    }
+}
+exports.GroupManager = GroupManager;

package/dist/managers/MessageManager.d.ts

@@ -0,0 +1,18 @@
+import { BaseManager } from './BaseManager';
+import { SendMessageOptions, SendResponse, Message, ReceiveOptions, ReceiptType, PollCreateOptions, PollVoteOptions, PollTerminateOptions, GetAttachmentOptions, UploadProgress } from '../interfaces';
+export declare class MessageManager extends BaseManager {
+    sendMessage(recipient: string, message: string, options?: Omit<SendMessageOptions, 'message'>): Promise<SendResponse>;
+    sendReaction(recipient: string, targetAuthor: string, targetTimestamp: number, emoji: string, remove?: boolean, isStory?: boolean): Promise<SendResponse>;
+    sendTyping(recipient: string, stop?: boolean): Promise<void>;
+    remoteDeleteMessage(recipient: string, targetTimestamp: number): Promise<void>;
+    sendReceipt(recipient: string, targetTimestamp: number, type?: ReceiptType): Promise<void>;
+    receive(options?: ReceiveOptions): Promise<Message[]>;
+    private parseEnvelope;
+    sendPollCreate(options: PollCreateOptions): Promise<SendResponse>;
+    sendPollVote(recipient: string, options: PollVoteOptions): Promise<SendResponse>;
+    sendPollTerminate(recipient: string, options: PollTerminateOptions): Promise<SendResponse>;
+    getAttachment(options: GetAttachmentOptions): Promise<string>;
+    sendMessageWithProgress(recipient: string, message: string, options?: SendMessageOptions & {
+        onProgress?: (progress: UploadProgress) => void;
+    }): Promise<SendResponse>;
+}

package/dist/managers/MessageManager.js

@@ -0,0 +1,301 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageManager = void 0;
+const BaseManager_1 = require("./BaseManager");
+const validators_1 = require("../validators");
+const errors_1 = require("../errors");
+class MessageManager extends BaseManager_1.BaseManager {
+    async sendMessage(recipient, message, options = {}) {
+        const params = {
+            message,
+            account: this.account,
+        };
+        if (this.isGroupId(recipient)) {
+            params.groupId = recipient;
+        }
+        else {
+            params.recipients = [recipient];
+        }
+        if (options.attachments && options.attachments.length > 0) {
+            params.attachments = options.attachments;
+        }
+        if (options.expiresInSeconds) {
+            params.expiresInSeconds = options.expiresInSeconds;
+        }
+        if (options.isViewOnce) {
+            params.viewOnce = options.isViewOnce;
+        }
+        if (options.mentions && options.mentions.length > 0) {
+            params.mentions = options.mentions.map((m) => ({
+                start: m.start,
+                length: m.length,
+                number: m.recipient || m.number,
+            }));
+        }
+        if (options.textStyles && options.textStyles.length > 0) {
+            params.textStyles = options.textStyles.map((ts) => ({
+                start: ts.start,
+                length: ts.length,
+                style: ts.style,
+            }));
+        }
+        if (options.quote) {
+            params.quoteTimestamp = options.quote.timestamp;
+            params.quoteAuthor = options.quote.author;
+            if (options.quote.text) {
+                params.quoteMessage = options.quote.text;
+            }
+            if (options.quote.mentions && options.quote.mentions.length > 0) {
+                params.quoteMentions = options.quote.mentions.map((m) => ({
+                    start: m.start,
+                    length: m.length,
+                    number: m.recipient || m.number,
+                }));
+            }
+            if (options.quote.textStyles && options.quote.textStyles.length > 0) {
+                params.quoteTextStyles = options.quote.textStyles.map((ts) => ({
+                    start: ts.start,
+                    length: ts.length,
+                    style: ts.style,
+                }));
+            }
+        }
+        if (options.previewUrl) {
+            params.previewUrl = options.previewUrl;
+        }
+        if (options.previewTitle) {
+            params.previewTitle = options.previewTitle;
+        }
+        if (options.previewDescription) {
+            params.previewDescription = options.previewDescription;
+        }
+        if (options.previewImage) {
+            params.previewImage = options.previewImage;
+        }
+        if (options.editTimestamp) {
+            params.editTimestamp = options.editTimestamp;
+        }
+        if (options.storyTimestamp && options.storyAuthor) {
+            params.storyTimestamp = options.storyTimestamp;
+            params.storyAuthor = options.storyAuthor;
+        }
+        if (options.noteToSelf) {
+            params.noteToSelf = options.noteToSelf;
+        }
+        if (options.endSession) {
+            params.endSession = options.endSession;
+        }
+        return this.sendRequest('send', params);
+    }
+    async sendReaction(recipient, targetAuthor, targetTimestamp, emoji, remove = false, isStory = false) {
+        const params = {
+            emoji,
+            targetAuthor,
+            targetTimestamp,
+            remove,
+            account: this.account,
+        };
+        if (isStory) {
+            params.story = true;
+        }
+        if (this.isGroupId(recipient)) {
+            params.groupId = recipient;
+        }
+        else {
+            params.recipients = [recipient];
+        }
+        return this.sendRequest('sendReaction', params);
+    }
+    async sendTyping(recipient, stop = false) {
+        const params = { when: !stop, account: this.account };
+        if (this.isGroupId(recipient)) {
+            params.groupId = recipient;
+        }
+        else {
+            params.recipients = [recipient];
+        }
+        await this.sendRequest('sendTyping', params);
+    }
+    async remoteDeleteMessage(recipient, targetTimestamp) {
+        const params = { targetTimestamp, account: this.account };
+        if (this.isGroupId(recipient)) {
+            params.groupId = recipient;
+        }
+        else {
+            params.recipients = [recipient];
+        }
+        await this.sendRequest('remoteDelete', params);
+    }
+    async sendReceipt(recipient, targetTimestamp, type = 'read') {
+        await this.sendRequest('sendReceipt', { account: this.account, recipient, targetTimestamp, type });
+    }
+    async receive(options = {}) {
+        const params = { account: this.account };
+        if (options.timeout !== undefined) {
+            params.timeout = options.timeout;
+        }
+        if (options.maxMessages !== undefined) {
+            params.maxMessages = options.maxMessages;
+        }
+        if (options.ignoreAttachments) {
+            params.ignoreAttachments = true;
+        }
+        if (options.ignoreStories) {
+            params.ignoreStories = true;
+        }
+        if (options.sendReadReceipts) {
+            params.sendReadReceipts = true;
+        }
+        try {
+            const result = await this.sendRequest('receive', params);
+            if (Array.isArray(result)) {
+                return result.map((envelope) => this.parseEnvelope(envelope));
+            }
+            return [];
+        }
+        catch (error) {
+            this.logger.error('Failed to receive messages:', error);
+            throw error;
+        }
+    }
+    parseEnvelope(envelope) {
+        const message = {
+            timestamp: envelope.timestamp || Date.now(),
+            source: envelope.source || envelope.sourceNumber,
+            sourceUuid: envelope.sourceUuid,
+            sourceDevice: envelope.sourceDevice,
+        };
+        if (envelope.dataMessage) {
+            const data = envelope.dataMessage;
+            message.text = data.message || data.body;
+            message.groupId = data.groupInfo?.groupId;
+            message.attachments = data.attachments;
+            message.mentions = data.mentions;
+            message.quote = data.quote;
+            message.reaction = data.reaction;
+            message.sticker = data.sticker;
+            message.expiresInSeconds = data.expiresInSeconds;
+            message.viewOnce = data.viewOnce;
+        }
+        if (envelope.syncMessage) {
+            message.syncMessage = envelope.syncMessage;
+        }
+        if (envelope.receiptMessage) {
+            message.receipt = envelope.receiptMessage;
+        }
+        if (envelope.typingMessage) {
+            message.typing = envelope.typingMessage;
+        }
+        return message;
+    }
+    async sendPollCreate(options) {
+        this.logger.debug('Sending poll create', options);
+        (0, validators_1.validateMessage)(options.question, 500);
+        if (!options.options || options.options.length < 2) {
+            throw new errors_1.MessageError('Poll must have at least 2 options');
+        }
+        if (options.options.length > 10) {
+            throw new errors_1.MessageError('Poll cannot have more than 10 options');
+        }
+        const params = {
+            question: options.question,
+            options: options.options,
+            account: this.account,
+        };
+        if (options.multiSelect !== undefined) {
+            params.multiSelect = options.multiSelect;
+        }
+        if (options.groupId) {
+            (0, validators_1.validateGroupId)(options.groupId);
+            params.groupId = options.groupId;
+        }
+        else if (options.recipients) {
+            params.recipients = options.recipients.map((r) => {
+                (0, validators_1.validateRecipient)(r);
+                return r;
+            });
+        }
+        else {
+            throw new errors_1.MessageError('Must specify either recipients or groupId');
+        }
+        return this.sendRequest('sendPollCreate', params);
+    }
+    async sendPollVote(recipient, options) {
+        this.logger.debug('Sending poll vote', { recipient, options });
+        (0, validators_1.validateRecipient)(options.pollAuthor);
+        (0, validators_1.validateTimestamp)(options.pollTimestamp);
+        if (!options.optionIndexes || options.optionIndexes.length === 0) {
+            throw new errors_1.MessageError('Must specify at least one option to vote for');
+        }
+        const params = {
+            pollAuthor: options.pollAuthor,
+            pollTimestamp: options.pollTimestamp,
+            options: options.optionIndexes,
+            account: this.account,
+        };
+        if (options.voteCount !== undefined) {
+            params.voteCount = options.voteCount;
+        }
+        if (this.isGroupId(recipient)) {
+            (0, validators_1.validateGroupId)(recipient);
+            params.groupId = recipient;
+        }
+        else {
+            (0, validators_1.validateRecipient)(recipient);
+            params.recipient = recipient;
+        }
+        return this.sendRequest('sendPollVote', params);
+    }
+    async sendPollTerminate(recipient, options) {
+        this.logger.debug('Sending poll terminate', { recipient, options });
+        (0, validators_1.validateTimestamp)(options.pollTimestamp);
+        const params = {
+            pollTimestamp: options.pollTimestamp,
+            account: this.account,
+        };
+        if (this.isGroupId(recipient)) {
+            (0, validators_1.validateGroupId)(recipient);
+            params.groupId = recipient;
+        }
+        else {
+            (0, validators_1.validateRecipient)(recipient);
+            params.recipient = recipient;
+        }
+        return this.sendRequest('sendPollTerminate', params);
+    }
+    async getAttachment(options) {
+        this.logger.debug('Getting attachment', options);
+        if (!options.id) {
+            throw new errors_1.MessageError('Attachment ID is required');
+        }
+        const params = {
+            id: options.id,
+            account: this.account,
+        };
+        if (options.groupId) {
+            (0, validators_1.validateGroupId)(options.groupId);
+            params.groupId = options.groupId;
+        }
+        else if (options.recipient) {
+            (0, validators_1.validateRecipient)(options.recipient);
+            params.recipient = options.recipient;
+        }
+        const result = await this.sendRequest('getAttachment', params);
+        return result.data || result;
+    }
+    async sendMessageWithProgress(recipient, message, options = {}) {
+        const { onProgress, ...sendOptions } = options;
+        if (onProgress && sendOptions.attachments && sendOptions.attachments.length > 0) {
+            for (let i = 0; i <= 100; i += 10) {
+                onProgress({
+                    total: 100,
+                    uploaded: i,
+                    percentage: i,
+                });
+                await new Promise((resolve) => setTimeout(resolve, 50));
+            }
+        }
+        return this.sendMessage(recipient, message, sendOptions);
+    }
+}
+exports.MessageManager = MessageManager;