@devrev/airsync-sdk 2.0.0-beta.3 → 2.0.0-beta.5

package/dist/attachments-streaming/attachments-streaming-pool.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=attachments-streaming-pool.test.d.ts.map

package/dist/attachments-streaming/attachments-streaming-pool.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"attachments-streaming-pool.test.d.ts","sourceRoot":"","sources":["../../src/attachments-streaming/attachments-streaming-pool.test.ts"],"names":[],"mappings":""}

package/dist/attachments-streaming/attachments-streaming-pool.test.js

@@ -1,540 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const attachments_streaming_pool_1 = require("./attachments-streaming-pool");
-/* eslint-disable @typescript-eslint/no-explicit-any */
-describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
-    let mockAdapter;
-    let mockStream;
-    let mockAttachments;
-    let attachmentsMetadata;
-    beforeEach(() => {
-        // SDK-owned attachments bookkeeping, passed into the pool directly.
-        attachmentsMetadata = {
-            artifactIds: [],
-            lastProcessed: 0,
-            lastProcessedAttachmentsIdsList: [],
-        };
-        // Create mock adapter
-        mockAdapter = {
-            state: {
-                attachments: { completed: false },
-            },
-            processAttachment: jest
-                .fn()
-                .mockResolvedValue({}),
-        };
-        // Create mock stream function
-        mockStream = jest.fn().mockResolvedValue({ success: true });
-        // Create mock attachments
-        mockAttachments = [
-            {
-                id: 'attachment-1',
-                url: 'https://example.com/file1.pdf',
-                file_name: 'file1.pdf',
-                parent_id: 'parent-1',
-            },
-            {
-                id: 'attachment-2',
-                url: 'https://example.com/file2.jpg',
-                file_name: 'file2.jpg',
-                parent_id: 'parent-2',
-            },
-            {
-                id: 'attachment-3',
-                url: 'https://example.com/file3.doc',
-                file_name: 'file3.doc',
-                parent_id: 'parent-3',
-            },
-        ];
-    });
-    afterEach(() => {
-        jest.clearAllMocks();
-        jest.restoreAllMocks();
-    });
-    describe(attachments_streaming_pool_1.AttachmentsStreamingPool.prototype.constructor.name, () => {
-        it('should initialize with default values', () => {
-            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
-                adapter: mockAdapter,
-                attachmentsMetadata,
-                attachments: mockAttachments,
-                stream: mockStream,
-            });
-            expect(pool['adapter']).toBe(mockAdapter);
-            expect(pool['attachments']).toEqual(mockAttachments);
-            expect(pool['batchSize']).toBe(10);
-            expect(pool['stream']).toBe(mockStream);
-        });
-        it('should initialize with custom batch size', () => {
-            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
-                adapter: mockAdapter,
-                attachmentsMetadata,
-                attachments: mockAttachments,
-                batchSize: 5,
-                stream: mockStream,
-            });
-            expect(pool['batchSize']).toBe(5);
-        });
-        it('should create a copy of attachments array', () => {
-            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
-                adapter: mockAdapter,
-                attachmentsMetadata,
-                attachments: mockAttachments,
-                stream: mockStream,
-            });
-            expect(pool['attachments']).toEqual(mockAttachments);
-            expect(pool['attachments']).not.toBe(mockAttachments); // Different reference
-        });
-    });
-    describe(attachments_streaming_pool_1.AttachmentsStreamingPool.prototype.streamAll.name, () => {
-        it('should initialize lastProcessedAttachmentsIdsList if it does not exist', async () => {
-            attachmentsMetadata.lastProcessedAttachmentsIdsList = undefined;
-            mockAdapter.processAttachment.mockResolvedValue({});
-            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
-                adapter: mockAdapter,
-                attachmentsMetadata,
-                attachments: mockAttachments,
-                stream: mockStream,
-            });
-            // Mock startPoolStreaming to avoid actual processing
-            jest
-                .spyOn(pool, 'startPoolStreaming')
-                .mockResolvedValue(undefined);
-            await pool.streamAll();
-            expect(attachmentsMetadata.lastProcessedAttachmentsIdsList).toEqual([]);
-        });
-        it('should process all attachments successfully', async () => {
-            mockAdapter.processAttachment.mockResolvedValue({});
-            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
-                adapter: mockAdapter,
-                attachmentsMetadata,
-                attachments: mockAttachments,
-                stream: mockStream,
-            });
-            const result = await pool.streamAll();
-            expect(result).toEqual({});
-            expect(mockAdapter.processAttachment).toHaveBeenCalledTimes(3);
-        });
-        it('should handle empty attachments array', async () => {
-            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
-                adapter: mockAdapter,
-                attachmentsMetadata,
-                attachments: [],
-                stream: mockStream,
-            });
-            const result = await pool.streamAll();
-            expect(result).toEqual({});
-            expect(mockAdapter.processAttachment).not.toHaveBeenCalled();
-        });
-        it('should return delay when rate limit is hit', async () => {
-            const delayResponse = { delay: 5000 };
-            mockAdapter.processAttachment.mockResolvedValue(delayResponse);
-            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
-                adapter: mockAdapter,
-                attachmentsMetadata,
-                attachments: mockAttachments,
-                stream: mockStream,
-            });
-            const result = await pool.streamAll();
-            expect(result).toEqual({ delay: 5000 });
-        });
-        it('should resume attachment extraction if it encounters old ids', async () => {
-            // Test migration from old string[] format to new ProcessedAttachment[] format
-            // Using 'as any' because we're intentionally testing legacy data format
-            attachmentsMetadata.lastProcessedAttachmentsIdsList = [
-                'attachment-1',
-                'attachment-2',
-            ];
-            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
-                adapter: mockAdapter,
-                attachmentsMetadata,
-                attachments: mockAttachments,
-                stream: mockStream,
-            });
-            const result = await pool.streamAll();
-            expect(attachmentsMetadata.lastProcessedAttachmentsIdsList).toEqual([
-                { id: 'attachment-1', parent_id: '' },
-                { id: 'attachment-2', parent_id: '' },
-                { id: 'attachment-1', parent_id: 'parent-1' },
-                { id: 'attachment-2', parent_id: 'parent-2' },
-                { id: 'attachment-3', parent_id: 'parent-3' },
-            ]);
-            expect(result).toEqual({});
-        });
-        it('should handle all attachments failing with different file types and sizes', async () => {
-            const largeAttachments = [
-                {
-                    id: 'attachment-image',
-                    url: 'https://example.com/photo.jpg',
-                    file_name: 'photo.jpg',
-                    parent_id: 'parent-1',
-                },
-                {
-                    id: 'attachment-pdf',
-                    url: 'https://example.com/document.pdf',
-                    file_name: 'document.pdf',
-                    parent_id: 'parent-2',
-                },
-                {
-                    id: 'attachment-video',
-                    url: 'https://example.com/video.mp4',
-                    file_name: 'video.mp4',
-                    parent_id: 'parent-3',
-                },
-            ];
-            const imageError = new Error('Image upload failed: File too large');
-            const pdfError = new Error('PDF upload failed: Unsupported format');
-            const videoError = new Error('Video upload failed: Network error');
-            mockAdapter.processAttachment
-                .mockRejectedValueOnce(imageError)
-                .mockRejectedValueOnce(pdfError)
-                .mockRejectedValueOnce(videoError);
-            const warnSpy = jest.spyOn(console, 'warn');
-            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
-                adapter: mockAdapter,
-                attachmentsMetadata,
-                attachments: largeAttachments,
-                stream: mockStream,
-            });
-            await pool.streamAll();
-            expect(mockAdapter.processAttachment).toHaveBeenCalledTimes(3);
-            // Since there are 3 parallel workers (one per attachment), each logs its own failed attachment
-            expect(warnSpy).toHaveBeenCalledTimes(3);
-            expect(attachmentsMetadata.lastProcessedAttachmentsIdsList).toEqual([]);
-        });
-    });
-    describe(attachments_streaming_pool_1.AttachmentsStreamingPool.prototype.startPoolStreaming.name, () => {
-        it('should skip already processed attachments', async () => {
-            attachmentsMetadata.lastProcessedAttachmentsIdsList = [
-                { id: 'attachment-1', parent_id: 'parent-1' },
-            ];
-            mockAdapter.processAttachment.mockResolvedValue({});
-            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
-                adapter: mockAdapter,
-                attachmentsMetadata,
-                attachments: mockAttachments,
-                stream: mockStream,
-            });
-            await pool.streamAll();
-            expect(mockAdapter.processAttachment).toHaveBeenCalledTimes(2); // Only 2 out of 3
-        });
-        it('should add successfully processed attachment IDs to the list', async () => {
-            mockAdapter.processAttachment.mockResolvedValue({});
-            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
-                adapter: mockAdapter,
-                attachmentsMetadata,
-                attachments: mockAttachments,
-                stream: mockStream,
-            });
-            await pool.streamAll();
-            expect(attachmentsMetadata.lastProcessedAttachmentsIdsList).toEqual([
-                { id: 'attachment-1', parent_id: 'parent-1' },
-                { id: 'attachment-2', parent_id: 'parent-2' },
-                { id: 'attachment-3', parent_id: 'parent-3' },
-            ]);
-        });
-        it('should handle processing errors gracefully', async () => {
-            const warnSpy = jest.spyOn(console, 'warn').mockImplementation();
-            const error = new Error('Processing failed');
-            mockAdapter.processAttachment
-                .mockResolvedValueOnce({}) // First attachment succeeds
-                .mockRejectedValueOnce(error) // Second attachment fails
-                .mockResolvedValueOnce({}); // Third attachment succeeds
-            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
-                adapter: mockAdapter,
-                attachmentsMetadata,
-                attachments: mockAttachments,
-                stream: mockStream,
-            });
-            await pool.streamAll();
-            expect(warnSpy).toHaveBeenCalledWith('Skipping attachment with ID attachment-2 with extension jpg due to error in processAttachment function', error);
-            expect(attachmentsMetadata.lastProcessedAttachmentsIdsList).toEqual([
-                {
-                    id: 'attachment-1',
-                    parent_id: 'parent-1',
-                },
-                {
-                    id: 'attachment-3',
-                    parent_id: 'parent-3',
-                },
-            ]);
-        });
-        it('should stop processing when rate limit delay is encountered', async () => {
-            mockAdapter.processAttachment
-                .mockResolvedValueOnce({}) // First attachment succeeds
-                .mockResolvedValueOnce({ delay: 5000 }) // Second attachment triggers rate limit
-                .mockResolvedValueOnce({}); // Third attachment succeeds
-            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
-                adapter: mockAdapter,
-                attachmentsMetadata,
-                attachments: mockAttachments,
-                stream: mockStream,
-            });
-            await pool.streamAll();
-            expect(mockAdapter.processAttachment).toHaveBeenCalledTimes(3);
-            expect(attachmentsMetadata.lastProcessedAttachmentsIdsList).toEqual([
-                { id: 'attachment-1', parent_id: 'parent-1' },
-                { id: 'attachment-3', parent_id: 'parent-3' },
-            ]);
-        });
-        it('should pass correct parameters to processAttachment', async () => {
-            mockAdapter.processAttachment.mockResolvedValue({});
-            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
-                adapter: mockAdapter,
-                attachmentsMetadata,
-                attachments: [mockAttachments[0]],
-                stream: mockStream,
-            });
-            await pool.streamAll();
-            expect(mockAdapter.processAttachment).toHaveBeenCalledWith(mockAttachments[0], mockStream);
-        });
-    });
-    it('[edge] should handle single attachment', async () => {
-        mockAdapter.processAttachment.mockResolvedValue({});
-        const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
-            adapter: mockAdapter,
-            attachmentsMetadata,
-            attachments: [mockAttachments[0]],
-            stream: mockStream,
-        });
-        const result = await pool.streamAll();
-        expect(result).toEqual({});
-        expect(mockAdapter.processAttachment).toHaveBeenCalledTimes(1);
-    });
-    it('[edge] should handle batch size larger than attachments array', async () => {
-        mockAdapter.processAttachment.mockResolvedValue({});
-        const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
-            adapter: mockAdapter,
-            attachmentsMetadata,
-            attachments: mockAttachments,
-            batchSize: 100,
-            stream: mockStream,
-        });
-        await pool.streamAll();
-        expect(mockAdapter.processAttachment).toHaveBeenCalledTimes(3);
-    });
-    it('[edge] should upload attachments with same id, but different parent_id', async () => {
-        mockAdapter.processAttachment.mockResolvedValue({});
-        mockAttachments.push({
-            id: 'attachment-1',
-            url: 'http://example.com/file5.jpg',
-            file_name: 'file5.jpg',
-            parent_id: 'parent-4',
-        });
-        const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
-            adapter: mockAdapter,
-            attachmentsMetadata,
-            attachments: mockAttachments,
-            batchSize: 1,
-            stream: mockStream,
-        });
-        await pool.streamAll();
-        expect(mockAdapter.processAttachment).toHaveBeenCalledTimes(4);
-    });
-    it('[edge] should handle batch size of 1', async () => {
-        mockAdapter.processAttachment.mockResolvedValue({});
-        const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
-            adapter: mockAdapter,
-            attachmentsMetadata,
-            attachments: mockAttachments,
-            batchSize: 1,
-            stream: mockStream,
-        });
-        await pool.streamAll();
-        expect(mockAdapter.processAttachment).toHaveBeenCalledTimes(3);
-    });
-    describe('content_type handling', () => {
-        it('should pass attachment with content_type to processAttachment', async () => {
-            mockAdapter.processAttachment.mockResolvedValue({});
-            const attachmentWithContentType = {
-                id: 'attachment-ct',
-                url: 'https://example.com/report.pdf',
-                file_name: 'report.pdf',
-                parent_id: 'parent-ct',
-                content_type: 'application/pdf',
-            };
-            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
-                adapter: mockAdapter,
-                attachmentsMetadata,
-                attachments: [attachmentWithContentType],
-                stream: mockStream,
-            });
-            await pool.streamAll();
-            expect(mockAdapter.processAttachment).toHaveBeenCalledWith(attachmentWithContentType, mockStream);
-            expect(mockAdapter.processAttachment.mock.calls[0][0].content_type).toBe('application/pdf');
-        });
-        it('should handle mixed attachments with and without content_type', async () => {
-            mockAdapter.processAttachment.mockResolvedValue({});
-            const mixedAttachments = [
-                {
-                    id: 'att-with-ct',
-                    url: 'https://example.com/image.png',
-                    file_name: 'image.png',
-                    parent_id: 'parent-1',
-                    content_type: 'image/png',
-                },
-                {
-                    id: 'att-without-ct',
-                    url: 'https://example.com/file.bin',
-                    file_name: 'file.bin',
-                    parent_id: 'parent-2',
-                },
-                {
-                    id: 'att-with-ct-2',
-                    url: 'https://example.com/doc.pdf',
-                    file_name: 'doc.pdf',
-                    parent_id: 'parent-3',
-                    content_type: 'application/pdf',
-                },
-            ];
-            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
-                adapter: mockAdapter,
-                attachmentsMetadata,
-                attachments: mixedAttachments,
-                batchSize: 1,
-                stream: mockStream,
-            });
-            await pool.streamAll();
-            expect(mockAdapter.processAttachment).toHaveBeenCalledTimes(3);
-            expect(mockAdapter.processAttachment.mock.calls[0][0].content_type).toBe('image/png');
-            expect(mockAdapter.processAttachment.mock.calls[1][0].content_type).toBeUndefined();
-            expect(mockAdapter.processAttachment.mock.calls[2][0].content_type).toBe('application/pdf');
-        });
-        it('should include content_type in error log when processAttachment returns error', async () => {
-            mockAdapter.processAttachment.mockResolvedValue({
-                error: { message: 'Upload failed' },
-            });
-            const warnSpy = jest.spyOn(console, 'warn');
-            const attachmentWithContentType = {
-                id: 'att-error-ct',
-                url: 'https://example.com/file.pdf',
-                file_name: 'file.pdf',
-                parent_id: 'parent-err',
-                content_type: 'application/pdf',
-            };
-            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
-                adapter: mockAdapter,
-                attachmentsMetadata,
-                attachments: [attachmentWithContentType],
-                batchSize: 1,
-                stream: mockStream,
-            });
-            await pool.streamAll();
-            expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('content_type application/pdf'), expect.any(String));
-        });
-        it('should include content_type in error log when processAttachment throws', async () => {
-            const error = new Error('Processing crashed');
-            mockAdapter.processAttachment.mockRejectedValue(error);
-            const warnSpy = jest.spyOn(console, 'warn');
-            const attachmentWithContentType = {
-                id: 'att-throw-ct',
-                url: 'https://example.com/file.png',
-                file_name: 'file.png',
-                parent_id: 'parent-throw',
-                content_type: 'image/png',
-            };
-            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
-                adapter: mockAdapter,
-                attachmentsMetadata,
-                attachments: [attachmentWithContentType],
-                batchSize: 1,
-                stream: mockStream,
-            });
-            await pool.streamAll();
-            expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('content_type image/png'), error);
-        });
-        it('should not include content_type in error log when content_type is not set', async () => {
-            mockAdapter.processAttachment.mockResolvedValue({
-                error: { message: 'Upload failed' },
-            });
-            const warnSpy = jest.spyOn(console, 'warn');
-            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
-                adapter: mockAdapter,
-                attachmentsMetadata,
-                attachments: [mockAttachments[0]],
-                batchSize: 1,
-                stream: mockStream,
-            });
-            await pool.streamAll();
-            expect(warnSpy).toHaveBeenCalledWith(expect.not.stringContaining('content_type'), expect.any(String));
-        });
-    });
-    describe('concurrency behavior', () => {
-        it('should process attachments concurrently within batch size', async () => {
-            let processCallCount = 0;
-            const processPromises = [];
-            mockAdapter.processAttachment.mockImplementation(async () => {
-                const promise = new Promise((resolve) => {
-                    setTimeout(() => {
-                        processCallCount++;
-                        resolve({});
-                    }, 100);
-                });
-                processPromises.push(promise);
-                return promise;
-            });
-            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
-                adapter: mockAdapter,
-                attachmentsMetadata,
-                attachments: mockAttachments,
-                batchSize: 2,
-                stream: mockStream,
-            });
-            const startTime = Date.now();
-            await pool.streamAll();
-            const endTime = Date.now();
-            expect(mockAdapter.processAttachment).toHaveBeenCalledTimes(3);
-            expect(processCallCount).toBe(3);
-            // Should complete in roughly 200ms (2 batches of 100ms each) rather than 300ms (sequential)
-            expect(endTime - startTime).toBeLessThan(250);
-        });
-    });
-    describe('log context attribution', () => {
-        it('should emit SDK-generated logs from pool (Starting download message)', async () => {
-            const logSpy = jest.spyOn(console, 'log');
-            mockAdapter.processAttachment.mockResolvedValue({});
-            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
-                adapter: mockAdapter,
-                attachmentsMetadata,
-                attachments: mockAttachments.slice(0, 1),
-                stream: mockStream,
-            });
-            // Call streamAll - it should log "Starting download of N attachments..."
-            await pool.streamAll();
-            // Verify the SDK-generated "Starting download" message was logged
-            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Starting download of 1 attachments'));
-        });
-        it('should process user stream callback correctly while maintaining context isolation', async () => {
-            let userCallbackExecuted = false;
-            // Mock stream to capture context info
-            const mockStreamFn = jest
-                .fn()
-                .mockImplementation(async () => {
-                await Promise.resolve();
-                userCallbackExecuted = true;
-                // Record that the callback executed
-                return Promise.resolve({
-                    httpStream: undefined,
-                    error: undefined,
-                });
-            });
-            mockAdapter.processAttachment.mockImplementation(async (attachment, stream) => {
-                // processAttachment should be called with the user's stream function
-                const result = await stream({
-                    item: attachment,
-                    event: {},
-                });
-                return result;
-            });
-            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
-                adapter: mockAdapter,
-                attachmentsMetadata,
-                attachments: mockAttachments.slice(0, 1),
-                stream: mockStreamFn,
-            });
-            await pool.streamAll();
-            // Verify the user callback was executed
-            expect(userCallbackExecuted).toBe(true);
-            expect(mockStreamFn).toHaveBeenCalled();
-        });
-    });
-});

package/dist/common/control-protocol.d.ts

@@ -1,10 +0,0 @@
-import { AxiosResponse } from 'axios';
-import { AirSyncEvent, EventData, ExtractorEventType } from '../types/extraction';
-import { LoaderEventType } from '../types/loading';
-export interface EmitInterface {
-    event: AirSyncEvent;
-    eventType: ExtractorEventType | LoaderEventType;
-    data?: EventData;
-}
-export declare const emit: ({ event, eventType, data, }: EmitInterface) => Promise<AxiosResponse>;
-//# sourceMappingURL=control-protocol.d.ts.map

package/dist/common/control-protocol.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"control-protocol.d.ts","sourceRoot":"","sources":["../../src/common/control-protocol.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAEtC,OAAO,EACL,YAAY,EACZ,SAAS,EAET,kBAAkB,EAEnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAGnD,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,YAAY,CAAC;IACpB,SAAS,EAAE,kBAAkB,GAAG,eAAe,CAAC;IAChD,IAAI,CAAC,EAAE,SAAS,CAAC;CAClB;AAED,eAAO,MAAM,IAAI,GAAU,6BAIxB,aAAa,KAAG,OAAO,CAAC,aAAa,CA4BvC,CAAC"}

package/dist/common/errors.d.ts

@@ -1,6 +0,0 @@
-export declare const enum ExtractionCommonError {
-    EXTERNAL_SYNC_UNIT_DELETED = "ERROR_CODE=EXTERNAL_SYNC_UNIT_DELETED",
-    EXTERNAL_SYNC_UNIT_DEACTIVATED = "ERROR_CODE=EXTERNAL_SYNC_UNIT_DEACTIVATED",
-    USER_DELETED = "ERROR_CODE=USER_DELETED"
-}
-//# sourceMappingURL=errors.d.ts.map

package/dist/common/errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/common/errors.ts"],"names":[],"mappings":"AAGA,0BAAkB,qBAAqB;IACrC,0BAA0B,0CAAgE;IAC1F,8BAA8B,8CAAoE;IAClG,YAAY,4BAAkD;CAC/D"}

package/dist/common/install-initial-domain-mapping.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"install-initial-domain-mapping.d.ts","sourceRoot":"","sources":["../../src/common/install-initial-domain-mapping.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAEvD,wBAAsB,2BAA2B,CAC/C,KAAK,EAAE,YAAY,EACnB,wBAAwB,EAAE,oBAAoB,GAC7C,OAAO,CAAC,IAAI,CAAC,CA0Ff"}

package/dist/common/install-initial-domain-mapping.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=install-initial-domain-mapping.test.d.ts.map

package/dist/common/install-initial-domain-mapping.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"install-initial-domain-mapping.test.d.ts","sourceRoot":"","sources":["../../src/common/install-initial-domain-mapping.test.ts"],"names":[],"mappings":""}