@adtrackify/at-service-common 3.19.24 → 4.0.0

package/dist/esm/clients/generic/sqs-client.js

@@ -1,282 +1,282 @@
-import { SQS, } from '@aws-sdk/client-sqs';
-import { v4 as uuidv4 } from 'uuid';
-import { getCurrentTimestamp } from '../../libs/dates.js';
-import { Logger } from '../../helpers/logging-helper.js';
-import { SQS_LIMITS, SQS_256KB, createSqsLimits } from '../../constants/sqs.js';
-const SQS_MAX_BATCH_SIZE = SQS_LIMITS.MAX_BATCH_SIZE;
-function sizeInBytes(obj) {
-    return new TextEncoder().encode(JSON.stringify(obj)).length;
-}
-function chunkMessagesBySize(serializedMessages, limits) {
-    const batches = [];
-    const skipped = [];
-    let currentBatch = [];
-    let currentBatchSize = 0;
-    for (const msg of serializedMessages) {
-        const msgSize = Buffer.byteLength(msg.body, 'utf8');
-        if (msgSize > limits.maxMessageSizeBytes) {
-            skipped.push({ id: msg.id, sizeBytes: msgSize });
-            continue;
-        }
-        const wouldExceedCount = currentBatch.length >= SQS_MAX_BATCH_SIZE;
-        const wouldExceedSize = currentBatchSize + msgSize > limits.maxBatchPayloadBytes;
-        if (wouldExceedCount || wouldExceedSize) {
-            if (currentBatch.length > 0) {
-                batches.push(currentBatch);
-            }
-            currentBatch = [];
-            currentBatchSize = 0;
-        }
-        currentBatch.push(msg);
-        currentBatchSize += msgSize;
-    }
-    if (currentBatch.length > 0) {
-        batches.push(currentBatch);
-    }
-    return { batches, skipped };
-}
-export class SQSClient {
-    sqs;
-    queueUrl;
-    limits;
-    constructor(region, accountId, queueName, options) {
-        this.sqs = new SQS({ region });
-        this.queueUrl = `https://sqs.${region}.amazonaws.com/${accountId}/${queueName}`;
-        this.limits = createSqsLimits(options?.maxMessageSizeBytes ?? SQS_256KB);
-    }
-    buildAndSendMessage = async (messageType, messageBody, deplaySeconds = 0) => {
-        const message = this.buildMessage(messageType, messageBody);
-        return await this.sendMessage(message, deplaySeconds);
-    };
-    buildAndSendMessages = async (messageType, messageBodies, delaySeconds = 0, maxBatchSize = 10) => {
-        const messages = messageBodies.map((messageBody) => this.buildMessage(messageType, messageBody));
-        return await this.sendMessages(messages, delaySeconds, maxBatchSize);
-    };
-    buildMessage = (messageType, messageBody, messageId = uuidv4(), messageTime = getCurrentTimestamp()) => {
-        return {
-            messageId,
-            messageType,
-            messageTime,
-            messageBody,
-        };
-    };
-    sendMessage = async (messageBody, delaySeconds = 0) => {
-        const params = {
-            QueueUrl: this.queueUrl,
-            DelaySeconds: delaySeconds,
-            MessageBody: JSON.stringify(messageBody),
-        };
-        const response = await this.sqs.sendMessage(params);
-        return response;
-    };
-    sendMessages = async (messageBodies, delaySeconds = 0, maxBatchSize = 10) => {
-        const messages = messageBodies ?? [];
-        if (messages.length === 0) {
-            return { sentCount: 0, failedCount: 0, responses: [] };
-        }
-        const serializedMessages = messages.map((messageBody, index) => ({
-            id: String(index),
-            body: JSON.stringify(messageBody),
-            delaySeconds,
-        }));
-        const { batches, skipped } = chunkMessagesBySize(serializedMessages, this.limits);
-        if (skipped.length > 0) {
-            Logger.error('SQS sendMessages: messages exceeded size limit and were skipped', {
-                queueUrl: this.queueUrl,
-                skippedCount: skipped.length,
-                skippedMessages: skipped,
-                maxMessageSizeBytes: this.limits.maxMessageSizeBytes,
-            });
-        }
-        const responses = [];
-        let sentCount = 0;
-        let failedCount = skipped.length;
-        for (const batch of batches) {
-            const entries = batch.map((msg) => ({
-                Id: msg.id,
-                MessageBody: msg.body,
-                DelaySeconds: msg.delaySeconds,
-            }));
-            const params = {
-                QueueUrl: this.queueUrl,
-                Entries: entries,
-            };
-            const response = await this.sqs.sendMessageBatch(params);
-            responses.push(response);
-            sentCount += response.Successful?.length ?? 0;
-            failedCount += response.Failed?.length ?? 0;
-        }
-        return {
-            sentCount,
-            failedCount,
-            responses,
-        };
-    };
-    buildAndSendBatchWithEntryDelays = async (entries) => {
-        if (!entries || entries.length === 0) {
-            return { sentCount: 0, failedCount: 0, responses: [] };
-        }
-        const serializedEntries = entries.map((entry, index) => ({
-            id: String(index),
-            body: JSON.stringify(this.buildMessage(entry.messageType, entry.messageBody)),
-            delaySeconds: entry.delaySeconds ?? 0,
-        }));
-        const { batches, skipped } = chunkMessagesBySize(serializedEntries, this.limits);
-        if (skipped.length > 0) {
-            Logger.error('SQS buildAndSendBatchWithEntryDelays: messages exceeded size limit and were skipped', {
-                queueUrl: this.queueUrl,
-                skippedCount: skipped.length,
-                skippedMessages: skipped,
-                maxMessageSizeBytes: this.limits.maxMessageSizeBytes,
-            });
-        }
-        const batchResults = await Promise.allSettled(batches.map((batch) => {
-            const sqsEntries = batch.map((item) => ({
-                Id: item.id,
-                MessageBody: item.body,
-                DelaySeconds: item.delaySeconds,
-            }));
-            const params = {
-                QueueUrl: this.queueUrl,
-                Entries: sqsEntries,
-            };
-            return this.sqs.sendMessageBatch(params);
-        }));
-        let sentCount = 0;
-        let failedCount = skipped.length;
-        const responses = [];
-        for (const result of batchResults) {
-            if (result.status === 'fulfilled') {
-                responses.push(result.value);
-                sentCount += result.value.Successful?.length ?? 0;
-                failedCount += result.value.Failed?.length ?? 0;
-            }
-            else {
-                Logger.error('SQS buildAndSendBatchWithEntryDelays: batch send failed', {
-                    queueUrl: this.queueUrl,
-                    error: result.reason,
-                });
-                failedCount += SQS_MAX_BATCH_SIZE;
-            }
-        }
-        return { sentCount, failedCount, responses };
-    };
-    sendMessagesV2 = async (messageBodies, delaySeconds = 0, maxBatchSize = 10) => {
-        const messages = messageBodies ?? [];
-        if (messages.length === 0) {
-            return { sentCount: 0, failedCount: 0, batchCount: 0, failedIds: [] };
-        }
-        const boundedBatchSize = Math.min(Math.max(maxBatchSize, 1), SQS_MAX_BATCH_SIZE);
-        let sentCount = 0;
-        let failedCount = 0;
-        let batchCount = 0;
-        const failedIds = [];
-        for (let i = 0; i < messages.length; i += boundedBatchSize) {
-            const batch = messages.slice(i, i + boundedBatchSize);
-            const entries = batch.map((messageBody, index) => ({
-                Id: String(i + index),
-                MessageBody: JSON.stringify(messageBody),
-                DelaySeconds: delaySeconds,
-            }));
-            const params = {
-                QueueUrl: this.queueUrl,
-                Entries: entries,
-            };
-            try {
-                const response = await this.sqs.sendMessageBatch(params);
-                batchCount++;
-                sentCount += response.Successful?.length ?? 0;
-                failedCount += response.Failed?.length ?? 0;
-                if (response.Failed?.length) {
-                    for (const failure of response.Failed) {
-                        if (failure.Id) {
-                            failedIds.push(failure.Id);
-                            const messageIndex = parseInt(failure.Id, 10);
-                            const failedMessage = messages[messageIndex];
-                            const messageSizeBytes = failedMessage ? JSON.stringify(failedMessage).length : 0;
-                            Logger.error('SQSClient [sendMessagesV2]: message failed', {
-                                queueUrl: this.queueUrl,
-                                entryId: failure.Id,
-                                sqsErrorCode: failure.Code,
-                                sqsErrorMessage: failure.Message,
-                                senderFault: failure.SenderFault,
-                                messageSizeBytes,
-                                batchIndex: Math.floor(i / boundedBatchSize),
-                                stage: 'sendMessageBatch',
-                            });
-                        }
-                    }
-                }
-            }
-            catch (error) {
-                const batchSizeBytes = batch.reduce((sum, msg) => sum + JSON.stringify(msg).length, 0);
-                Logger.error('SQSClient [sendMessagesV2]: batch send failed', {
-                    error,
-                    errorMessage: error instanceof Error ? error.message : String(error),
-                    errorStack: error instanceof Error ? error.stack : undefined,
-                    queueUrl: this.queueUrl,
-                    batchStartIndex: i,
-                    batchSize: batch.length,
-                    batchSizeBytes,
-                });
-                failedCount += batch.length;
-                for (let j = 0; j < batch.length; j++) {
-                    failedIds.push(String(i + j));
-                }
-            }
-        }
-        return { sentCount, failedCount, batchCount, failedIds };
-    };
-    buildAndSendMessagesV2 = async (messageType, messageBodies, delaySeconds = 0, maxBatchSize = SQS_MAX_BATCH_SIZE) => {
-        const builtMessages = messageBodies.map((messageBody) => this.buildMessage(messageType, messageBody));
-        const batches = this.createSizeLimitedBatches(builtMessages, maxBatchSize);
-        let successCount = 0;
-        let failedCount = 0;
-        let totalBatchCount = 0;
-        const failedMessages = [];
-        let messageOffset = 0;
-        for (const batch of batches) {
-            const result = await this.sendMessagesV2(batch, delaySeconds, batch.length);
-            successCount += result.sentCount;
-            failedCount += result.failedCount;
-            totalBatchCount += result.batchCount;
-            for (const failedId of result.failedIds) {
-                const batchIndex = parseInt(failedId, 10);
-                const absoluteIndex = messageOffset + batchIndex;
-                if (!isNaN(batchIndex) && absoluteIndex < messageBodies.length) {
-                    failedMessages.push(messageBodies[absoluteIndex]);
-                }
-            }
-            messageOffset += batch.length;
-        }
-        return { successCount, failedCount, batchCount: totalBatchCount, failedMessages };
-    };
-    createSizeLimitedBatches(messages, maxBatchSize) {
-        const batches = [];
-        let currentBatch = [];
-        let currentBatchSize = 0;
-        for (const message of messages) {
-            const messageSize = sizeInBytes(message);
-            const wouldExceedCount = currentBatch.length >= maxBatchSize;
-            const wouldExceedSize = currentBatchSize + messageSize > this.limits.safeMaxBatchPayloadBytes;
-            if ((wouldExceedCount || wouldExceedSize) && currentBatch.length > 0) {
-                batches.push(currentBatch);
-                currentBatch = [];
-                currentBatchSize = 0;
-            }
-            if (messageSize > this.limits.safeMaxMessageSizeBytes) {
-                Logger.warn('SQSClient [createSizeLimitedBatches]: single message exceeds safe size limit', {
-                    messageSize,
-                    limit: this.limits.safeMaxMessageSizeBytes,
-                });
-            }
-            currentBatch.push(message);
-            currentBatchSize += messageSize;
-        }
-        if (currentBatch.length > 0) {
-            batches.push(currentBatch);
-        }
-        return batches;
-    }
-}
+import { SQS, } from '@aws-sdk/client-sqs';
+import { v4 as uuidv4 } from 'uuid';
+import { getCurrentTimestamp } from '../../libs/dates.js';
+import { Logger } from '../../helpers/logging-helper.js';
+import { SQS_LIMITS, SQS_256KB, createSqsLimits } from '../../constants/sqs.js';
+const SQS_MAX_BATCH_SIZE = SQS_LIMITS.MAX_BATCH_SIZE;
+function sizeInBytes(obj) {
+    return new TextEncoder().encode(JSON.stringify(obj)).length;
+}
+function chunkMessagesBySize(serializedMessages, limits) {
+    const batches = [];
+    const skipped = [];
+    let currentBatch = [];
+    let currentBatchSize = 0;
+    for (const msg of serializedMessages) {
+        const msgSize = Buffer.byteLength(msg.body, 'utf8');
+        if (msgSize > limits.maxMessageSizeBytes) {
+            skipped.push({ id: msg.id, sizeBytes: msgSize });
+            continue;
+        }
+        const wouldExceedCount = currentBatch.length >= SQS_MAX_BATCH_SIZE;
+        const wouldExceedSize = currentBatchSize + msgSize > limits.maxBatchPayloadBytes;
+        if (wouldExceedCount || wouldExceedSize) {
+            if (currentBatch.length > 0) {
+                batches.push(currentBatch);
+            }
+            currentBatch = [];
+            currentBatchSize = 0;
+        }
+        currentBatch.push(msg);
+        currentBatchSize += msgSize;
+    }
+    if (currentBatch.length > 0) {
+        batches.push(currentBatch);
+    }
+    return { batches, skipped };
+}
+export class SQSClient {
+    sqs;
+    queueUrl;
+    limits;
+    constructor(region, accountId, queueName, options) {
+        this.sqs = new SQS({ region });
+        this.queueUrl = `https://sqs.${region}.amazonaws.com/${accountId}/${queueName}`;
+        this.limits = createSqsLimits(options?.maxMessageSizeBytes ?? SQS_256KB);
+    }
+    buildAndSendMessage = async (messageType, messageBody, deplaySeconds = 0) => {
+        const message = this.buildMessage(messageType, messageBody);
+        return await this.sendMessage(message, deplaySeconds);
+    };
+    buildAndSendMessages = async (messageType, messageBodies, delaySeconds = 0, maxBatchSize = 10) => {
+        const messages = messageBodies.map((messageBody) => this.buildMessage(messageType, messageBody));
+        return await this.sendMessages(messages, delaySeconds, maxBatchSize);
+    };
+    buildMessage = (messageType, messageBody, messageId = uuidv4(), messageTime = getCurrentTimestamp()) => {
+        return {
+            messageId,
+            messageType,
+            messageTime,
+            messageBody,
+        };
+    };
+    sendMessage = async (messageBody, delaySeconds = 0) => {
+        const params = {
+            QueueUrl: this.queueUrl,
+            DelaySeconds: delaySeconds,
+            MessageBody: JSON.stringify(messageBody),
+        };
+        const response = await this.sqs.sendMessage(params);
+        return response;
+    };
+    sendMessages = async (messageBodies, delaySeconds = 0, maxBatchSize = 10) => {
+        const messages = messageBodies ?? [];
+        if (messages.length === 0) {
+            return { sentCount: 0, failedCount: 0, responses: [] };
+        }
+        const serializedMessages = messages.map((messageBody, index) => ({
+            id: String(index),
+            body: JSON.stringify(messageBody),
+            delaySeconds,
+        }));
+        const { batches, skipped } = chunkMessagesBySize(serializedMessages, this.limits);
+        if (skipped.length > 0) {
+            Logger.error('SQS sendMessages: messages exceeded size limit and were skipped', {
+                queueUrl: this.queueUrl,
+                skippedCount: skipped.length,
+                skippedMessages: skipped,
+                maxMessageSizeBytes: this.limits.maxMessageSizeBytes,
+            });
+        }
+        const responses = [];
+        let sentCount = 0;
+        let failedCount = skipped.length;
+        for (const batch of batches) {
+            const entries = batch.map((msg) => ({
+                Id: msg.id,
+                MessageBody: msg.body,
+                DelaySeconds: msg.delaySeconds,
+            }));
+            const params = {
+                QueueUrl: this.queueUrl,
+                Entries: entries,
+            };
+            const response = await this.sqs.sendMessageBatch(params);
+            responses.push(response);
+            sentCount += response.Successful?.length ?? 0;
+            failedCount += response.Failed?.length ?? 0;
+        }
+        return {
+            sentCount,
+            failedCount,
+            responses,
+        };
+    };
+    buildAndSendBatchWithEntryDelays = async (entries) => {
+        if (!entries || entries.length === 0) {
+            return { sentCount: 0, failedCount: 0, responses: [] };
+        }
+        const serializedEntries = entries.map((entry, index) => ({
+            id: String(index),
+            body: JSON.stringify(this.buildMessage(entry.messageType, entry.messageBody)),
+            delaySeconds: entry.delaySeconds ?? 0,
+        }));
+        const { batches, skipped } = chunkMessagesBySize(serializedEntries, this.limits);
+        if (skipped.length > 0) {
+            Logger.error('SQS buildAndSendBatchWithEntryDelays: messages exceeded size limit and were skipped', {
+                queueUrl: this.queueUrl,
+                skippedCount: skipped.length,
+                skippedMessages: skipped,
+                maxMessageSizeBytes: this.limits.maxMessageSizeBytes,
+            });
+        }
+        const batchResults = await Promise.allSettled(batches.map((batch) => {
+            const sqsEntries = batch.map((item) => ({
+                Id: item.id,
+                MessageBody: item.body,
+                DelaySeconds: item.delaySeconds,
+            }));
+            const params = {
+                QueueUrl: this.queueUrl,
+                Entries: sqsEntries,
+            };
+            return this.sqs.sendMessageBatch(params);
+        }));
+        let sentCount = 0;
+        let failedCount = skipped.length;
+        const responses = [];
+        for (const result of batchResults) {
+            if (result.status === 'fulfilled') {
+                responses.push(result.value);
+                sentCount += result.value.Successful?.length ?? 0;
+                failedCount += result.value.Failed?.length ?? 0;
+            }
+            else {
+                Logger.error('SQS buildAndSendBatchWithEntryDelays: batch send failed', {
+                    queueUrl: this.queueUrl,
+                    error: result.reason,
+                });
+                failedCount += SQS_MAX_BATCH_SIZE;
+            }
+        }
+        return { sentCount, failedCount, responses };
+    };
+    sendMessagesV2 = async (messageBodies, delaySeconds = 0, maxBatchSize = 10) => {
+        const messages = messageBodies ?? [];
+        if (messages.length === 0) {
+            return { sentCount: 0, failedCount: 0, batchCount: 0, failedIds: [] };
+        }
+        const boundedBatchSize = Math.min(Math.max(maxBatchSize, 1), SQS_MAX_BATCH_SIZE);
+        let sentCount = 0;
+        let failedCount = 0;
+        let batchCount = 0;
+        const failedIds = [];
+        for (let i = 0; i < messages.length; i += boundedBatchSize) {
+            const batch = messages.slice(i, i + boundedBatchSize);
+            const entries = batch.map((messageBody, index) => ({
+                Id: String(i + index),
+                MessageBody: JSON.stringify(messageBody),
+                DelaySeconds: delaySeconds,
+            }));
+            const params = {
+                QueueUrl: this.queueUrl,
+                Entries: entries,
+            };
+            try {
+                const response = await this.sqs.sendMessageBatch(params);
+                batchCount++;
+                sentCount += response.Successful?.length ?? 0;
+                failedCount += response.Failed?.length ?? 0;
+                if (response.Failed?.length) {
+                    for (const failure of response.Failed) {
+                        if (failure.Id) {
+                            failedIds.push(failure.Id);
+                            const messageIndex = parseInt(failure.Id, 10);
+                            const failedMessage = messages[messageIndex];
+                            const messageSizeBytes = failedMessage ? JSON.stringify(failedMessage).length : 0;
+                            Logger.error('SQSClient [sendMessagesV2]: message failed', {
+                                queueUrl: this.queueUrl,
+                                entryId: failure.Id,
+                                sqsErrorCode: failure.Code,
+                                sqsErrorMessage: failure.Message,
+                                senderFault: failure.SenderFault,
+                                messageSizeBytes,
+                                batchIndex: Math.floor(i / boundedBatchSize),
+                                stage: 'sendMessageBatch',
+                            });
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                const batchSizeBytes = batch.reduce((sum, msg) => sum + JSON.stringify(msg).length, 0);
+                Logger.error('SQSClient [sendMessagesV2]: batch send failed', {
+                    error,
+                    errorMessage: error instanceof Error ? error.message : String(error),
+                    errorStack: error instanceof Error ? error.stack : undefined,
+                    queueUrl: this.queueUrl,
+                    batchStartIndex: i,
+                    batchSize: batch.length,
+                    batchSizeBytes,
+                });
+                failedCount += batch.length;
+                for (let j = 0; j < batch.length; j++) {
+                    failedIds.push(String(i + j));
+                }
+            }
+        }
+        return { sentCount, failedCount, batchCount, failedIds };
+    };
+    buildAndSendMessagesV2 = async (messageType, messageBodies, delaySeconds = 0, maxBatchSize = SQS_MAX_BATCH_SIZE) => {
+        const builtMessages = messageBodies.map((messageBody) => this.buildMessage(messageType, messageBody));
+        const batches = this.createSizeLimitedBatches(builtMessages, maxBatchSize);
+        let successCount = 0;
+        let failedCount = 0;
+        let totalBatchCount = 0;
+        const failedMessages = [];
+        let messageOffset = 0;
+        for (const batch of batches) {
+            const result = await this.sendMessagesV2(batch, delaySeconds, batch.length);
+            successCount += result.sentCount;
+            failedCount += result.failedCount;
+            totalBatchCount += result.batchCount;
+            for (const failedId of result.failedIds) {
+                const batchIndex = parseInt(failedId, 10);
+                const absoluteIndex = messageOffset + batchIndex;
+                if (!isNaN(batchIndex) && absoluteIndex < messageBodies.length) {
+                    failedMessages.push(messageBodies[absoluteIndex]);
+                }
+            }
+            messageOffset += batch.length;
+        }
+        return { successCount, failedCount, batchCount: totalBatchCount, failedMessages };
+    };
+    createSizeLimitedBatches(messages, maxBatchSize) {
+        const batches = [];
+        let currentBatch = [];
+        let currentBatchSize = 0;
+        for (const message of messages) {
+            const messageSize = sizeInBytes(message);
+            const wouldExceedCount = currentBatch.length >= maxBatchSize;
+            const wouldExceedSize = currentBatchSize + messageSize > this.limits.safeMaxBatchPayloadBytes;
+            if ((wouldExceedCount || wouldExceedSize) && currentBatch.length > 0) {
+                batches.push(currentBatch);
+                currentBatch = [];
+                currentBatchSize = 0;
+            }
+            if (messageSize > this.limits.safeMaxMessageSizeBytes) {
+                Logger.warn('SQSClient [createSizeLimitedBatches]: single message exceeds safe size limit', {
+                    messageSize,
+                    limit: this.limits.safeMaxMessageSizeBytes,
+                });
+            }
+            currentBatch.push(message);
+            currentBatchSize += messageSize;
+        }
+        if (currentBatch.length > 0) {
+            batches.push(currentBatch);
+        }
+        return batches;
+    }
+}
 //# sourceMappingURL=sqs-client.js.map

package/dist/esm/clients/generic/sqs-unbundle.d.ts

@@ -1,32 +1,32 @@
-import { BundledMessageEnvelope } from './sqs-bundled-client.types.js';
-export interface UnbundleOptions {
-    maxDecompressedSizeBytes?: number;
-    timeoutMs?: number;
-}
-export declare function isBundledEnvelope(payload: unknown): payload is BundledMessageEnvelope;
-export declare function unbundleMessage<T>(envelope: BundledMessageEnvelope<T>, options?: UnbundleOptions): Promise<T[]>;
-export interface UnbundleRecordResult<T> {
-    messageId: string;
-    success: boolean;
-    items: T[];
-    isBundled: boolean;
-    error?: Error;
-}
-export interface UnbundleStats {
-    totalRecords: number;
-    bundledSqsRecords: number;
-    legacySqsRecords: number;
-    failedRecords: number;
-    totalItems: number;
-}
-export interface UnbundleResult<T> {
-    items: T[];
-    recordMap: Map<T, string>;
-    failedMessageIds: string[];
-    stats: UnbundleStats;
-}
-export declare function unbundleRecords<T>(records: Array<{
-    body: string;
-    messageId: string;
-}>, options?: UnbundleOptions): Promise<UnbundleResult<T>>;
-export declare function getRecordIdForItem<T>(item: T, recordMap: Map<T, string>): string | undefined;
+import { BundledMessageEnvelope } from './sqs-bundled-client.types.js';
+export interface UnbundleOptions {
+    maxDecompressedSizeBytes?: number;
+    timeoutMs?: number;
+}
+export declare function isBundledEnvelope(payload: unknown): payload is BundledMessageEnvelope;
+export declare function unbundleMessage<T>(envelope: BundledMessageEnvelope<T>, options?: UnbundleOptions): Promise<T[]>;
+export interface UnbundleRecordResult<T> {
+    messageId: string;
+    success: boolean;
+    items: T[];
+    isBundled: boolean;
+    error?: Error;
+}
+export interface UnbundleStats {
+    totalRecords: number;
+    bundledSqsRecords: number;
+    legacySqsRecords: number;
+    failedRecords: number;
+    totalItems: number;
+}
+export interface UnbundleResult<T> {
+    items: T[];
+    recordMap: Map<T, string>;
+    failedMessageIds: string[];
+    stats: UnbundleStats;
+}
+export declare function unbundleRecords<T>(records: Array<{
+    body: string;
+    messageId: string;
+}>, options?: UnbundleOptions): Promise<UnbundleResult<T>>;
+export declare function getRecordIdForItem<T>(item: T, recordMap: Map<T, string>): string | undefined;