czech-data-box 0.1.2 → 0.2.0

package/dist/lib/ISDSBox.js

@@ -0,0 +1,662 @@
+import forge from 'node-forge';
+import DataMessage from '../models/DataMessage.js';
+import { DEBUG, getConnectionModeFromLegacyLoginType, getServiceSoapVersion, getServiceURL, getServiceWSDL, } from './config.js';
+import ISDSSentOutFiles from './ISDSSentOutFiles.js';
+import ISDSSoapClient from './ISDSSoapClient.js';
+function toError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function createAbortError() {
+    const error = new Error('Operation aborted');
+    error.name = 'AbortError';
+    return error;
+}
+class ISDSBox {
+    productionMode;
+    connectionMode;
+    loginName;
+    password;
+    certfilename;
+    privateKey;
+    publicKey;
+    passPhrase;
+    pkcs12Certificate;
+    debug;
+    operationsWS;
+    infoWS;
+    manipulationsWS;
+    accessWS;
+    searchWS;
+    archiveWS;
+    vodzWS;
+    constructor(loginTypeOrConnectionMode = 0, loginName = '', password = '', certfilename = '', privateKey = '', publicKey = '', passPhrase = '', pkcs12Certificate = '', production = true, debug = DEBUG) {
+        this.productionMode = production;
+        this.connectionMode =
+            typeof loginTypeOrConnectionMode === 'string'
+                ? loginTypeOrConnectionMode
+                : getConnectionModeFromLegacyLoginType(loginTypeOrConnectionMode);
+        this.loginName = loginName;
+        this.password = password;
+        this.certfilename = certfilename;
+        this.privateKey = privateKey;
+        this.publicKey = publicKey;
+        this.passPhrase = passPhrase;
+        this.pkcs12Certificate = pkcs12Certificate;
+        this.debug = debug;
+        this.initClients();
+    }
+    logDebug(message, ...payload) {
+        if (this.debug) {
+            console.log(message, ...payload);
+        }
+    }
+    createClient(serviceType) {
+        return new ISDSSoapClient(getServiceWSDL(serviceType), {
+            login: this.loginName,
+            password: this.password,
+            location: getServiceURL(serviceType, this.connectionMode, this.productionMode),
+            connectionMode: this.connectionMode,
+            soapVersion: getServiceSoapVersion(serviceType),
+            privateKey: this.privateKey,
+            publicKey: this.publicKey,
+            passPhrase: this.passPhrase,
+            debug: this.debug,
+        });
+    }
+    normalizeDateTime(value) {
+        if (value === undefined || value === null) {
+            return null;
+        }
+        return value instanceof Date ? value.toISOString() : value;
+    }
+    normalizeDate(value) {
+        if (value === undefined || value === null) {
+            return null;
+        }
+        if (value instanceof Date) {
+            return value.toISOString().slice(0, 10);
+        }
+        return value;
+    }
+    normalizeMessageListInput(input, orgUnitNum, recipientOrSenderKey) {
+        return {
+            dmFromTime: this.normalizeDateTime(input.dmFromTime),
+            dmToTime: this.normalizeDateTime(input.dmToTime),
+            [recipientOrSenderKey]: orgUnitNum ?? null,
+            dmStatusFilter: input.dmStatusFilter ?? '',
+            dmOffset: input.dmOffset ?? null,
+            dmLimit: input.dmLimit ?? null,
+        };
+    }
+    async buildOutgoingFiles(outFilesParams) {
+        const files = new ISDSSentOutFiles();
+        for (const file of outFilesParams) {
+            if ('dmFilePath' in file) {
+                const success = await files.addFileFromFilePath(file.dmFilePath, file.dmMimeType, file.dmFileMetaType, file.dmFileDescr, file.dmFileGuid ?? null, file.dmUpFileGuid ?? null, file.dmFormat ?? null);
+                if (!success) {
+                    throw new Error(`Failed to add file from path: ${file.dmFilePath}`);
+                }
+                continue;
+            }
+            files.addFileFromMemory(file.dmEncodedContent, file.dmMimeType, file.dmFileMetaType, file.dmFileDescr, file.dmFileGuid ?? null, file.dmUpFileGuid ?? null, file.dmFormat ?? null);
+        }
+        return files.build();
+    }
+    buildMessageEnvelope(dataMessageParams) {
+        return (dataMessageParams instanceof DataMessage
+            ? dataMessageParams
+            : new DataMessage(dataMessageParams)).build();
+    }
+    extractMessageId(record) {
+        if (typeof record.dmID === 'string' && record.dmID.trim()) {
+            return record.dmID;
+        }
+        throw new Error('Message record does not contain a valid dmID');
+    }
+    getMessageId(record) {
+        return typeof record.dmID === 'string' && record.dmID.trim() ? record.dmID : null;
+    }
+    extractNotificationRecords(result) {
+        const records = result.ntfRecords?.ntfRecord;
+        if (!records) {
+            return [];
+        }
+        return Array.isArray(records) ? records : [records];
+    }
+    assertNotAborted(signal) {
+        if (signal?.aborted) {
+            throw createAbortError();
+        }
+    }
+    async sleep(ms, signal) {
+        this.assertNotAborted(signal);
+        if (ms <= 0) {
+            return;
+        }
+        await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                signal?.removeEventListener('abort', onAbort);
+                resolve();
+            }, ms);
+            const onAbort = () => {
+                clearTimeout(timeout);
+                signal?.removeEventListener('abort', onAbort);
+                reject(createAbortError());
+            };
+            signal?.addEventListener('abort', onAbort, { once: true });
+        });
+    }
+    initializeNotificationCursor(notifications) {
+        if (!notifications) {
+            return null;
+        }
+        return this.normalizeDateTime(notifications.fromTime) ?? new Date().toISOString();
+    }
+    async shouldPollInboxFromNotifications(notifications, notificationCursor) {
+        if (!notifications || !notificationCursor) {
+            return {
+                shouldPollInbox: false,
+                nextCursor: notificationCursor,
+            };
+        }
+        const notificationResult = await this.listNotifications({
+            ntfFromTime: notificationCursor,
+            ntfScope: notifications.scope,
+        });
+        const records = this.extractNotificationRecords(notificationResult);
+        return {
+            shouldPollInbox: records.length > 0 || notificationResult.ntfListContinues === true,
+            nextCursor: new Date().toISOString(),
+        };
+    }
+    filterSeenItems(items, seenMessageIds, seenMessageOrder, maxSeenMessageIds) {
+        return items.filter((item) => {
+            const dmID = this.getMessageId(item.record);
+            if (!dmID) {
+                return true;
+            }
+            if (seenMessageIds.has(dmID)) {
+                return false;
+            }
+            seenMessageIds.add(dmID);
+            seenMessageOrder.push(dmID);
+            while (seenMessageOrder.length > maxSeenMessageIds) {
+                const oldest = seenMessageOrder.shift();
+                if (oldest) {
+                    seenMessageIds.delete(oldest);
+                }
+            }
+            return true;
+        });
+    }
+    isVodzMessage(record) {
+        if (typeof record.dmVODZ === 'boolean') {
+            return record.dmVODZ;
+        }
+        const attributesCandidates = [record.attributes, record.$attributes, record.$attr];
+        for (const candidate of attributesCandidates) {
+            if (!isRecord(candidate)) {
+                continue;
+            }
+            const rawValue = candidate.dmVODZ;
+            if (typeof rawValue === 'boolean') {
+                return rawValue;
+            }
+            if (typeof rawValue === 'string') {
+                return rawValue === 'true' || rawValue === '1';
+            }
+        }
+        return false;
+    }
+    async requestOn(client, context, method, args) {
+        try {
+            return await client.request(method, args);
+        }
+        catch (error) {
+            const normalizedError = toError(error);
+            console.error(`Error in ${context}:`, normalizedError.message);
+            throw normalizedError;
+        }
+    }
+    setConnectionMode(connectionMode) {
+        this.connectionMode = connectionMode;
+        this.initClients();
+        return this;
+    }
+    setProductionMode() {
+        this.productionMode = true;
+        this.initClients();
+        return this;
+    }
+    setTestMode() {
+        this.productionMode = false;
+        this.initClients();
+        return this;
+    }
+    setDebugMode() {
+        this.debug = true;
+        this.initClients();
+        return this;
+    }
+    setPublicKey(cert) {
+        this.publicKey = cert;
+        return this;
+    }
+    setPrivateKey(privateKey) {
+        this.privateKey = privateKey;
+        return this;
+    }
+    setPassPhrase(passPhrase) {
+        this.passPhrase = passPhrase;
+        return this;
+    }
+    setPkcs12Certificate(pkcs12Certificate, passPhrase) {
+        const p12Der = forge.util.decode64(pkcs12Certificate);
+        const p12Asn1 = forge.asn1.fromDer(p12Der);
+        const p12 = forge.pkcs12.pkcs12FromAsn1(p12Asn1, passPhrase);
+        let cert;
+        let key;
+        for (const safeContents of p12.safeContents) {
+            for (const safeBag of safeContents.safeBags) {
+                if (safeBag.type === forge.pki.oids.certBag && safeBag.cert) {
+                    cert = forge.pki.certificateToPem(safeBag.cert);
+                }
+                else if (safeBag.type === forge.pki.oids.pkcs8ShroudedKeyBag && safeBag.key) {
+                    key = forge.pki.privateKeyToPem(safeBag.key);
+                }
+            }
+        }
+        if (!cert || !key) {
+            throw new Error('Invalid PKCS12 certificate bundle');
+        }
+        this.pkcs12Certificate = pkcs12Certificate;
+        this.setPublicKey(cert).setPrivateKey(key).setPassPhrase(passPhrase);
+        return this;
+    }
+    loginWithUsernameAndPassword(loginName, password, productionMode = true) {
+        this.productionMode = productionMode;
+        this.connectionMode = 'basic';
+        this.loginName = loginName;
+        this.password = password;
+        this.initClients();
+        return this;
+    }
+    loginWithPkcs12Certificate(certFile, passPhrase, productionMode = true) {
+        this.productionMode = productionMode;
+        this.connectionMode = 'cert';
+        this.loginName = '';
+        this.password = '';
+        this.setPkcs12Certificate(certFile, passPhrase);
+        this.initClients();
+        return this;
+    }
+    loginWithUsernamePasswordAndCertificate(loginName, password, certFile, passPhrase, productionMode = true) {
+        this.productionMode = productionMode;
+        this.connectionMode = 'certds';
+        this.loginName = loginName;
+        this.password = password;
+        this.setPkcs12Certificate(certFile, passPhrase);
+        this.initClients();
+        return this;
+    }
+    loginWithHostedSpisServiceCertificate(dataBoxId, certFile, passPhrase, productionMode = true) {
+        this.productionMode = productionMode;
+        this.connectionMode = 'hspis';
+        this.loginName = dataBoxId;
+        this.password = '';
+        this.setPkcs12Certificate(certFile, passPhrase);
+        this.initClients();
+        return this;
+    }
+    initClients() {
+        const clients = [
+            ['Operations Service URL', 0],
+            ['Info Service URL', 1],
+            ['Manipulations Service URL', 2],
+            ['Access Service URL', 3],
+            ['Search Service URL', 4],
+            ['Archive Service URL', 5],
+            ['VoDZ Service URL', 6],
+        ];
+        this.logDebug('Service URLs:');
+        for (const [label, serviceType] of clients) {
+            this.logDebug(`${label}:`, getServiceURL(serviceType, this.connectionMode, this.productionMode));
+        }
+        this.operationsWS = this.createClient(0);
+        this.infoWS = this.createClient(1);
+        this.manipulationsWS = this.createClient(2);
+        this.accessWS = this.createClient(3);
+        this.searchWS = this.createClient(4);
+        this.archiveWS = this.createClient(5);
+        this.vodzWS = this.createClient(6);
+    }
+    extractMessageRecords(result) {
+        const records = result.dmRecords?.dmRecord;
+        if (!records) {
+            return [];
+        }
+        return Array.isArray(records) ? records : [records];
+    }
+    async createMessage(dataMessageParams, outFilesParams) {
+        const message = this.buildMessageEnvelope(dataMessageParams);
+        if (!message.dbIDRecipient?.trim()) {
+            throw new Error('Missing required field: dbIDRecipient');
+        }
+        if (!message.dmAnnotation?.trim()) {
+            throw new Error('Missing required field: dmAnnotation');
+        }
+        const input = {
+            dmEnvelope: message,
+            dmFiles: await this.buildOutgoingFiles(outFilesParams),
+        };
+        this.logDebug('Final SOAP request body:', JSON.stringify(input, null, 2));
+        return this.requestOn(this.operationsWS, 'createMessage', 'CreateMessage', input);
+    }
+    async createMultipleMessage(envelopeParams, recipients, outFilesParams) {
+        if (recipients.length === 0) {
+            throw new Error('At least one recipient is required for createMultipleMessage');
+        }
+        const builtEnvelope = this.buildMessageEnvelope(envelopeParams);
+        if (!builtEnvelope.dmAnnotation?.trim()) {
+            throw new Error('Missing required field: dmAnnotation');
+        }
+        const multipleEnvelope = Object.fromEntries(Object.entries(builtEnvelope).filter(([key]) => ![
+            'dbIDRecipient',
+            'dmRecipientOrgUnit',
+            'dmRecipientOrgUnitNum',
+            'dmToHands',
+        ].includes(key)));
+        return this.requestOn(this.operationsWS, 'createMultipleMessage', 'CreateMultipleMessage', {
+            dmRecipients: {
+                dmRecipient: recipients.map((recipient) => ({
+                    dbIDRecipient: recipient.dbIDRecipient,
+                    dmRecipientOrgUnit: recipient.dmRecipientOrgUnit ?? null,
+                    dmRecipientOrgUnitNum: recipient.dmRecipientOrgUnitNum ?? null,
+                    dmToHands: recipient.dmToHands ?? null,
+                })),
+            },
+            dmEnvelope: multipleEnvelope,
+            dmFiles: await this.buildOutgoingFiles(outFilesParams),
+        });
+    }
+    async findDataBox(dbOwnerInfo) {
+        return this.requestOn(this.searchWS, 'findDataBox', 'FindDataBox', dbOwnerInfo.build());
+    }
+    async getDataBoxAddress(dbID) {
+        return this.requestOn(this.searchWS, 'getDataBoxAddress', 'GetDataBoxAddress', { dbID });
+    }
+    async getOwnerInfoFromLogin() {
+        return this.requestOn(this.accessWS, 'getOwnerInfoFromLogin', 'GetOwnerInfoFromLogin', { dbDummy: '' });
+    }
+    async getPasswordInfo() {
+        return this.requestOn(this.accessWS, 'getPasswordInfo', 'GetPasswordInfo', { dbDummy: '' });
+    }
+    async verifyMessage(dmID) {
+        return this.requestOn(this.infoWS, 'verifyMessage', 'VerifyMessage', { dmID });
+    }
+    async getDeliveryInfo(dmID) {
+        return this.requestOn(this.infoWS, 'getDeliveryInfo', 'GetDeliveryInfo', { dmID });
+    }
+    async getSignedDeliveryInfo(dmID) {
+        return this.requestOn(this.infoWS, 'getSignedDeliveryInfo', 'GetSignedDeliveryInfo', { dmID });
+    }
+    async listSentMessages(input = {}) {
+        return this.requestOn(this.infoWS, 'listSentMessages', 'GetListOfSentMessages', this.normalizeMessageListInput(input, input.dmSenderOrgUnitNum, 'dmSenderOrgUnitNum'));
+    }
+    async listReceivedMessages(input = {}) {
+        return this.requestOn(this.infoWS, 'listReceivedMessages', 'GetListOfReceivedMessages', this.normalizeMessageListInput(input, input.dmRecipientOrgUnitNum, 'dmRecipientOrgUnitNum'));
+    }
+    async downloadMessage(dmID) {
+        return this.requestOn(this.operationsWS, 'downloadMessage', 'MessageDownload', { dmID });
+    }
+    async downloadMessageEnvelope(dmID) {
+        return this.requestOn(this.infoWS, 'downloadMessageEnvelope', 'MessageEnvelopeDownload', { dmID });
+    }
+    async downloadSignedMessage(dmID) {
+        return this.requestOn(this.operationsWS, 'downloadSignedMessage', 'SignedMessageDownload', { dmID });
+    }
+    async markMessageAsDownloaded(dmID) {
+        return this.requestOn(this.infoWS, 'markMessageAsDownloaded', 'MarkMessageAsDownloaded', { dmID });
+    }
+    async downloadSignedSentMessage(dmID) {
+        return this.requestOn(this.operationsWS, 'downloadSignedSentMessage', 'SignedSentMessageDownload', { dmID });
+    }
+    async getMessageStateChanges(input = {}) {
+        return this.requestOn(this.infoWS, 'getMessageStateChanges', 'GetMessageStateChanges', {
+            dmFromTime: this.normalizeDateTime(input.dmFromTime),
+            dmToTime: this.normalizeDateTime(input.dmToTime),
+        });
+    }
+    async getMessageAuthor(dmID) {
+        return this.requestOn(this.infoWS, 'getMessageAuthor', 'GetMessageAuthor', { dmID });
+    }
+    async getMessageAuthorDetails(dmID) {
+        return this.requestOn(this.infoWS, 'getMessageAuthorDetails', 'GetMessageAuthor2', { dmID });
+    }
+    async eraseMessage(input) {
+        return this.requestOn(this.infoWS, 'eraseMessage', 'EraseMessage', input);
+    }
+    async getErasedMessages(input) {
+        const payload = 'dmFromDate' in input
+            ? {
+                dmFromDate: this.normalizeDate(input.dmFromDate),
+                dmToDate: this.normalizeDate(input.dmToDate),
+                dmMessageType: input.dmMessageType,
+                dmOutFormat: input.dmOutFormat,
+            }
+            : {
+                dmYear: input.dmYear,
+                dmMonth: input.dmMonth ?? null,
+                dmMessageType: input.dmMessageType,
+                dmOutFormat: input.dmOutFormat,
+            };
+        return this.requestOn(this.infoWS, 'getErasedMessages', 'GetListOfErasedMessages', payload);
+    }
+    async pickUpAsyncResponse(input) {
+        return this.requestOn(this.infoWS, 'pickUpAsyncResponse', 'PickUpAsyncResponse', input);
+    }
+    async listNotifications(input) {
+        return this.requestOn(this.infoWS, 'listNotifications', 'GetListForNotifications', {
+            ntfFromTime: this.normalizeDateTime(input.ntfFromTime),
+            ntfScope: input.ntfScope,
+        });
+    }
+    async registerForNotifications(action) {
+        return this.requestOn(this.infoWS, 'registerForNotifications', 'RegisterForNotifications', { action });
+    }
+    async getSentMessageEnvelope(dmID) {
+        return this.requestOn(this.infoWS, 'getSentMessageEnvelope', 'SentMessageEnvelopeDownload', { dmID });
+    }
+    async reportSuspiciousMessage(input) {
+        return this.requestOn(this.infoWS, 'reportSuspiciousMessage', 'SuspMessageReport', {
+            dmID: input.dmID,
+            repName: input.repName ?? null,
+            repMail: input.repMail ?? null,
+            repTel: input.repTel ?? null,
+            allowComplete: input.allowComplete,
+            note: input.note ?? null,
+        });
+    }
+    async authenticateMessage(dmMessage) {
+        return this.requestOn(this.operationsWS, 'authenticateMessage', 'AuthenticateMessage', { dmMessage });
+    }
+    async reSignIsdsDocument(dmDoc) {
+        return this.requestOn(this.operationsWS, 'reSignIsdsDocument', 'Re-signISDSDocument', { dmDoc });
+    }
+    async dummyOperation(value = '') {
+        return this.requestOn(this.operationsWS, 'dummyOperation', 'DummyOperation', { DummyOperation: value });
+    }
+    async uploadAttachment(input) {
+        return this.requestOn(this.vodzWS, 'uploadAttachment', 'UploadAttachment', {
+            dmFile: {
+                dmEncodedContent: input.dmEncodedContent,
+                attributes: {
+                    dmMimeType: input.dmMimeType,
+                    dmFileDescr: input.dmFileDescr,
+                },
+            },
+        });
+    }
+    async downloadAttachment(input) {
+        return this.requestOn(this.vodzWS, 'downloadAttachment', 'DownloadAttachment', input);
+    }
+    async createBigMessage(input) {
+        const dmExtFile = input.dmFiles.dmExtFile?.map((file) => ({
+            attributes: {
+                dmFileMetaType: file.dmFileMetaType,
+                dmAttID: file.dmAttID,
+                dmAttHash1: file.dmAttHash1,
+                dmAttHash1Alg: file.dmAttHash1Alg,
+                dmAttHash2: file.dmAttHash2,
+                dmAttHash2Alg: file.dmAttHash2Alg,
+                ...(file.dmFileGuid ? { dmFileGuid: file.dmFileGuid } : {}),
+                ...(file.dmUpFileGuid ? { dmUpFileGuid: file.dmUpFileGuid } : {}),
+            },
+        }));
+        const dmFile = input.dmFiles.dmFile?.map((file) => ({
+            dmEncodedContent: file.dmEncodedContent,
+            attributes: {
+                dmFileMetaType: file.dmFileMetaType,
+                dmFileDescr: file.dmFileDescr,
+                dmMimeType: file.dmMimeType,
+                ...(file.dmFileGuid ? { dmFileGuid: file.dmFileGuid } : {}),
+                ...(file.dmUpFileGuid ? { dmUpFileGuid: file.dmUpFileGuid } : {}),
+            },
+        }));
+        return this.requestOn(this.vodzWS, 'createBigMessage', 'CreateBigMessage', {
+            dmEnvelope: input.dmEnvelope,
+            dmFiles: {
+                ...(dmExtFile ? { dmExtFile } : {}),
+                ...(dmFile ? { dmFile } : {}),
+            },
+        });
+    }
+    async authenticateBigMessage(dmMessage) {
+        return this.requestOn(this.vodzWS, 'authenticateBigMessage', 'AuthenticateBigMessage', { dmMessage });
+    }
+    async downloadSignedBigMessage(dmID) {
+        return this.requestOn(this.vodzWS, 'downloadSignedBigMessage', 'SignedBigMessageDownload', { dmID });
+    }
+    async downloadSignedSentBigMessage(dmID) {
+        return this.requestOn(this.vodzWS, 'downloadSignedSentBigMessage', 'SignedSentBigMessageDownload', { dmID });
+    }
+    async downloadBigMessage(dmID) {
+        return this.requestOn(this.vodzWS, 'downloadBigMessage', 'BigMessageDownload', { dmID });
+    }
+    async archiveIsdsDocument(dmMessage) {
+        return this.requestOn(this.archiveWS, 'archiveIsdsDocument', 'ArchiveISDSDocument', { dmMessage });
+    }
+    async pollReceivedMessages(options = {}) {
+        const list = await this.listReceivedMessages(options);
+        const records = this.extractMessageRecords(list);
+        const items = [];
+        for (const record of records) {
+            const dmID = this.extractMessageId(record);
+            const envelope = options.includeEnvelope
+                ? (await this.downloadMessageEnvelope(dmID)).dmReturnedMessageEnvelope
+                : undefined;
+            const message = options.includeMessage
+                ? this.isVodzMessage(record)
+                    ? (await this.downloadBigMessage(dmID)).dmReturnedMessage
+                    : (await this.downloadMessage(dmID)).dmReturnedMessage
+                : undefined;
+            const deliveryInfo = options.includeDeliveryInfo
+                ? (await this.getDeliveryInfo(dmID)).dmDelivery
+                : undefined;
+            let markedAsDownloaded = false;
+            if (options.markAsDownloaded) {
+                await this.markMessageAsDownloaded(dmID);
+                markedAsDownloaded = true;
+            }
+            const item = {
+                record,
+                markedAsDownloaded,
+            };
+            if (envelope !== undefined) {
+                item.envelope = envelope;
+            }
+            if (message !== undefined) {
+                item.message = message;
+            }
+            if (deliveryInfo !== undefined) {
+                item.deliveryInfo = deliveryInfo;
+            }
+            items.push(item);
+        }
+        return {
+            list,
+            items,
+        };
+    }
+    async waitForNewMessages(options = {}) {
+        const { intervalMs = 30_000, timeoutMs = null, signal, notifications = null, ...pollOptions } = options;
+        this.assertNotAborted(signal);
+        if (notifications?.registerAction !== undefined &&
+            notifications.registerAction !== null) {
+            await this.registerForNotifications(notifications.registerAction);
+        }
+        const startedAt = Date.now();
+        let firstIteration = true;
+        let notificationCursor = this.initializeNotificationCursor(notifications);
+        for (;;) {
+            this.assertNotAborted(signal);
+            let shouldPollInbox = !notifications || firstIteration;
+            if (notifications) {
+                const notificationDecision = await this.shouldPollInboxFromNotifications(notifications, notificationCursor);
+                shouldPollInbox ||= notificationDecision.shouldPollInbox;
+                notificationCursor = notificationDecision.nextCursor;
+            }
+            if (shouldPollInbox) {
+                const batch = await this.pollReceivedMessages(pollOptions);
+                if (batch.items.length > 0) {
+                    return batch;
+                }
+            }
+            if (timeoutMs !== null && Date.now() - startedAt >= timeoutMs) {
+                throw new Error('Timed out waiting for new ISDS messages');
+            }
+            firstIteration = false;
+            await this.sleep(intervalMs, signal);
+        }
+    }
+    async *watchReceivedMessages(options = {}) {
+        const { intervalMs = 30_000, signal, notifications = null, dedupeByMessageId = true, maxSeenMessageIds = 1000, ...pollOptions } = options;
+        this.assertNotAborted(signal);
+        if (notifications?.registerAction !== undefined &&
+            notifications.registerAction !== null) {
+            await this.registerForNotifications(notifications.registerAction);
+        }
+        const seenMessageIds = new Set();
+        const seenMessageOrder = [];
+        let firstIteration = true;
+        let notificationCursor = this.initializeNotificationCursor(notifications);
+        for (;;) {
+            this.assertNotAborted(signal);
+            let shouldPollInbox = !notifications || firstIteration;
+            if (notifications) {
+                const notificationDecision = await this.shouldPollInboxFromNotifications(notifications, notificationCursor);
+                shouldPollInbox ||= notificationDecision.shouldPollInbox;
+                notificationCursor = notificationDecision.nextCursor;
+            }
+            if (shouldPollInbox) {
+                const batch = await this.pollReceivedMessages(pollOptions);
+                const items = dedupeByMessageId
+                    ? this.filterSeenItems(batch.items, seenMessageIds, seenMessageOrder, maxSeenMessageIds)
+                    : batch.items;
+                if (items.length > 0) {
+                    yield {
+                        list: batch.list,
+                        items,
+                    };
+                }
+            }
+            firstIteration = false;
+            await this.sleep(intervalMs, signal);
+        }
+    }
+}
+export default ISDSBox;
+//# sourceMappingURL=ISDSBox.js.map