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

package/dist/state/state.test.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const constants_1 = require("../common/constants");
-const test_helpers_1 = require("../tests/test-helpers");
+const jest_setup_1 = require("../tests/jest.setup");
+const test_utils_1 = require("../common/test-utils");
 const extraction_1 = require("../types/extraction");
-const state_1 = require("./state");
+const extraction_state_1 = require("./extraction-state");
 const state_interfaces_1 = require("./state.interfaces");
 /* eslint-disable @typescript-eslint/no-require-imports */
-describe(state_1.State.name, () => {
+describe(extraction_state_1.ExtractionState.name, () => {
     let initSpy;
     let postStateSpy;
     let fetchStateSpy;
@@ -15,9 +16,9 @@ describe(state_1.State.name, () => {
     beforeEach(() => {
         jest.clearAllMocks();
         jest.restoreAllMocks();
-        initSpy = jest.spyOn(state_1.State.prototype, 'init');
-        postStateSpy = jest.spyOn(state_1.State.prototype, 'postState');
-        fetchStateSpy = jest.spyOn(state_1.State.prototype, 'fetchState');
+        initSpy = jest.spyOn(extraction_state_1.ExtractionState.prototype, 'init');
+        postStateSpy = jest.spyOn(extraction_state_1.ExtractionState.prototype, 'postState');
+        fetchStateSpy = jest.spyOn(extraction_state_1.ExtractionState.prototype, 'fetchState');
         installInitialDomainMappingSpy = jest.spyOn(require('../common/install-initial-domain-mapping'), 'installInitialDomainMapping');
         processExitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {
             throw new Error('process.exit called');
@@ -25,11 +26,11 @@ describe(state_1.State.name, () => {
     });
     it.each(constants_1.STATELESS_EVENT_TYPES)('should not init, fetch, post or install IDM for stateless event type %s', async (eventType) => {
         // Arrange
-        const event = (0, test_helpers_1.createEvent)({
-            eventType: eventType,
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            payload: { event_type: eventType },
         });
         // Act
-        await (0, state_1.createAdapterState)({
+        await (0, extraction_state_1.createExtractionState)({
             event,
             initialState: {},
             initialDomainMapping: {},
@@ -40,48 +41,45 @@ describe(state_1.State.name, () => {
         expect(postStateSpy).not.toHaveBeenCalled();
         expect(installInitialDomainMappingSpy).not.toHaveBeenCalled();
     });
-    it.each(constants_1.STATEFUL_EVENT_TYPES)('should exit the process if fetching the state fails', async (eventType) => {
+    it.each(constants_1.STATEFUL_EVENT_TYPES)('should exit the process if fetching the state fails for event type %s', async (eventType) => {
         // Arrange
-        const event = (0, test_helpers_1.createEvent)({
-            eventType: eventType,
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            payload: { event_type: eventType },
         });
         fetchStateSpy.mockRejectedValue({
             isAxiosError: true,
             response: { status: 500 },
         });
-        jest.spyOn(console, 'error').mockImplementation(() => { });
         // Act & Assert
-        await expect((0, state_1.createAdapterState)({
+        await expect((0, extraction_state_1.createExtractionState)({
             event,
             initialState: {},
             initialDomainMapping: {},
         })).rejects.toThrow('process.exit called');
         expect(processExitSpy).toHaveBeenCalledWith(1);
     });
-    it.each(constants_1.STATEFUL_EVENT_TYPES)('should exit the process if parsing the state fails', async (eventType) => {
+    it.each(constants_1.STATEFUL_EVENT_TYPES)('should exit the process if parsing the state fails for event type %s', async (eventType) => {
         // Arrange
-        const event = (0, test_helpers_1.createEvent)({
-            eventType: eventType,
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            payload: { event_type: eventType },
         });
-        fetchStateSpy.mockResolvedValue('invalid-json');
-        jest.spyOn(console, 'error').mockImplementation(() => { });
+        fetchStateSpy.mockResolvedValue({ state: 'invalid-json' });
         // Act & Assert
-        await expect((0, state_1.createAdapterState)({
+        await expect((0, extraction_state_1.createExtractionState)({
             event,
             initialState: {},
             initialDomainMapping: {},
         })).rejects.toThrow('process.exit called');
         expect(processExitSpy).toHaveBeenCalledWith(1);
     });
-    it.each(constants_1.STATEFUL_EVENT_TYPES)('should exit the process if fetching is successful but there is no state in the response', async (eventType) => {
+    it.each(constants_1.STATEFUL_EVENT_TYPES)('should exit the process if fetching is successful but there is no state in the response for event type %s', async (eventType) => {
         // Arrange
-        const event = (0, test_helpers_1.createEvent)({
-            eventType: eventType,
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            payload: { event_type: eventType },
         });
-        fetchStateSpy.mockResolvedValue(null);
-        jest.spyOn(console, 'error').mockImplementation(() => { });
+        fetchStateSpy.mockResolvedValue({ state: null });
         // Act & Assert
-        await expect((0, state_1.createAdapterState)({
+        await expect((0, extraction_state_1.createExtractionState)({
             event,
             initialState: {},
             initialDomainMapping: {},
@@ -93,11 +91,11 @@ describe(state_1.State.name, () => {
         const initialState = {
             test: 'test',
         };
-        const event = (0, test_helpers_1.createEvent)({
-            eventType: eventType,
-            contextOverrides: {
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            context: {
                 snap_in_version_id: '',
             },
+            payload: { event_type: eventType },
         });
         fetchStateSpy.mockRejectedValue({
             isAxiosError: true,
@@ -109,63 +107,30 @@ describe(state_1.State.name, () => {
         postStateSpy.mockResolvedValue({
             success: true,
         });
-        jest.spyOn(console, 'log').mockImplementation(() => { });
         // Act
-        await (0, state_1.createAdapterState)({
+        const adapterState = await (0, extraction_state_1.createExtractionState)({
             event,
             initialState,
             initialDomainMapping: {},
         });
-        const expectedState = Object.assign(Object.assign({}, initialState), state_interfaces_1.extractionSdkState);
-        expect(postStateSpy).toHaveBeenCalledWith(expectedState);
-    });
-    it(extraction_1.EventType.StartExtractingData, async () => {
-        // Arrange
-        const initialState = {
-            test: 'test',
-        };
-        const event = (0, test_helpers_1.createEvent)({
-            eventType: extraction_1.EventType.StartExtractingData,
-            contextOverrides: {
-                snap_in_version_id: '',
-            },
-        });
-        fetchStateSpy.mockRejectedValue({
-            isAxiosError: true,
-            response: { status: 404 },
-        });
-        installInitialDomainMappingSpy.mockResolvedValue({
-            success: true,
-        });
-        postStateSpy.mockResolvedValue({
-            success: true,
-        });
-        jest.spyOn(console, 'log').mockImplementation(() => { });
-        // Act
-        await (0, state_1.createAdapterState)({
-            event,
-            initialState,
-            initialDomainMapping: {},
-        });
-        // Assert
-        // Verify that post state is called with object that contains
-        // lastSyncStarted which is not empty string
-        expect(postStateSpy).toHaveBeenCalledWith(expect.objectContaining({
-            lastSyncStarted: expect.not.stringMatching(/^$/),
-        }));
+        // On 404, init() persists the v2 envelope: connector state untouched,
+        // SDK bookkeeping seeded from defaults.
+        expect(postStateSpy).toHaveBeenCalled();
+        expect(adapterState.state).toEqual(initialState);
+        expect(adapterState.sdkState).toEqual(state_interfaces_1.initialExtractionSdkState);
     });
     it.each(constants_1.STATEFUL_EVENT_TYPES)('should exit the process if initialDomainMapping is not provided for event type %s', async (eventType) => {
         // Arrange
-        const event = (0, test_helpers_1.createEvent)({
-            eventType: eventType,
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            payload: { event_type: eventType },
+        });
+        fetchStateSpy.mockResolvedValue({
+            state: JSON.stringify({
+                test: 'test',
+            }),
         });
-        fetchStateSpy.mockResolvedValue(JSON.stringify({
-            test: 'test',
-        }));
-        jest.spyOn(console, 'log').mockImplementation(() => { });
-        jest.spyOn(console, 'error').mockImplementation(() => { });
         // Act & Assert
-        await expect((0, state_1.createAdapterState)({
+        await expect((0, extraction_state_1.createExtractionState)({
             event,
             initialState: {},
             initialDomainMapping: undefined,
@@ -174,20 +139,19 @@ describe(state_1.State.name, () => {
     });
     it.each(constants_1.STATEFUL_EVENT_TYPES)('should not install IDM if version matches for event type %s', async (eventType) => {
         // Arrange
-        const event = (0, test_helpers_1.createEvent)({
-            eventType: eventType,
-            contextOverrides: {
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            context: {
                 snap_in_version_id: '1.0.0',
             },
+            payload: { event_type: eventType },
         });
         const stringifiedState = JSON.stringify({
             test: 'test',
             snapInVersionId: '1.0.0',
         });
-        fetchStateSpy.mockResolvedValue(stringifiedState);
-        jest.spyOn(console, 'log').mockImplementation(() => { });
+        fetchStateSpy.mockResolvedValue({ state: stringifiedState });
         // Act & Assert
-        await (0, state_1.createAdapterState)({
+        await (0, extraction_state_1.createExtractionState)({
             event,
             initialState: {},
             initialDomainMapping: {},
@@ -197,23 +161,22 @@ describe(state_1.State.name, () => {
     });
     it.each(constants_1.STATEFUL_EVENT_TYPES)('should install IDM if version does not match for event type %s', async (eventType) => {
         // Arrange
-        const event = (0, test_helpers_1.createEvent)({
-            eventType: eventType,
-            contextOverrides: {
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            context: {
                 snap_in_version_id: '2.0.0',
             },
+            payload: { event_type: eventType },
         });
         const stringifiedState = JSON.stringify({
             test: 'test',
             snapInVersionId: '1.0.0',
         });
-        fetchStateSpy.mockResolvedValue(stringifiedState);
+        fetchStateSpy.mockResolvedValue({ state: stringifiedState });
         installInitialDomainMappingSpy.mockResolvedValue({
             success: true,
         });
-        jest.spyOn(console, 'log').mockImplementation(() => { });
         // Act
-        await (0, state_1.createAdapterState)({
+        await (0, extraction_state_1.createExtractionState)({
             event,
             initialState: {},
             initialDomainMapping: {},
@@ -221,4 +184,88 @@ describe(state_1.State.name, () => {
         // Assert
         expect(installInitialDomainMappingSpy).toHaveBeenCalled();
     });
+    it('should populate extractionScope from API response', async () => {
+        // Arrange
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            context: {
+                snap_in_version_id: '1.0.0',
+            },
+            payload: { event_type: extraction_1.EventType.StartExtractingData },
+        });
+        fetchStateSpy.mockResolvedValue({
+            state: JSON.stringify({ snapInVersionId: '1.0.0' }),
+            objects: JSON.stringify({
+                tasks: { extract: true },
+                users: { extract: true },
+            }),
+        });
+        // Act
+        const result = await (0, extraction_state_1.createExtractionState)({
+            event,
+            initialState: {},
+            initialDomainMapping: {},
+        });
+        // Assert
+        expect(result.extractionScope).toEqual({
+            tasks: { extract: true },
+            users: { extract: true },
+        });
+    });
+    it('should have empty extractionScope on 404', async () => {
+        // Arrange
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            context: {
+                snap_in_version_id: '',
+            },
+            payload: { event_type: extraction_1.EventType.StartExtractingMetadata },
+        });
+        fetchStateSpy.mockRejectedValue({
+            isAxiosError: true,
+            response: { status: 404 },
+        });
+        installInitialDomainMappingSpy.mockResolvedValue({ success: true });
+        postStateSpy.mockResolvedValue({ success: true });
+        // Act
+        const result = await (0, extraction_state_1.createExtractionState)({
+            event,
+            initialState: {},
+            initialDomainMapping: {},
+        });
+        // Assert
+        expect(result.extractionScope).toEqual({});
+    });
+    it('should have empty extractionScope for stateless events', async () => {
+        // Arrange
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            payload: { event_type: extraction_1.EventType.StartExtractingExternalSyncUnits },
+        });
+        // Act
+        const result = await (0, extraction_state_1.createExtractionState)({
+            event,
+            initialState: {},
+            initialDomainMapping: {},
+        });
+        // Assert
+        expect(result.extractionScope).toEqual({});
+    });
+    it('should continue with empty extractionScope when objects field contains invalid JSON', async () => {
+        // Arrange
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            context: { snap_in_version_id: '1.0.0' },
+            payload: { event_type: extraction_1.EventType.StartExtractingData },
+        });
+        fetchStateSpy.mockResolvedValue({
+            state: JSON.stringify({ snapInVersionId: '1.0.0' }),
+            objects: 'NOT_VALID_JSON',
+        });
+        // Act
+        const result = await (0, extraction_state_1.createExtractionState)({
+            event,
+            initialState: {},
+            initialDomainMapping: {},
+        });
+        // Assert: should not crash, extractionScope is empty (default)
+        expect(result.extractionScope).toEqual({});
+        expect(processExitSpy).not.toHaveBeenCalled();
+    });
 });

package/dist/state/state.time-value-resolution.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=state.time-value-resolution.test.d.ts.map

package/dist/state/state.time-value-resolution.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.time-value-resolution.test.d.ts","sourceRoot":"","sources":["../../src/state/state.time-value-resolution.test.ts"],"names":[],"mappings":""}

package/dist/state/state.time-value-resolution.test.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jest_setup_1 = require("../tests/jest.setup");
+const test_utils_1 = require("../common/test-utils");
+const extraction_1 = require("../types/extraction");
+const extraction_state_1 = require("./extraction-state");
+describe('State — TimeValue resolution', () => {
+    let fetchStateSpy;
+    let processExitSpy;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.restoreAllMocks();
+        fetchStateSpy = jest.spyOn(extraction_state_1.ExtractionState.prototype, 'fetchState');
+        processExitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {
+            throw new Error('process.exit called');
+        });
+    });
+    describe('Enhanced Control Protocol - TimeValue resolution failures', () => {
+        it('should exit the process if extraction_start_time resolution fails', async () => {
+            // Arrange: WORKERS_NEWEST type but state has no workersNewest
+            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+                payload: {
+                    event_type: extraction_1.EventType.StartExtractingMetadata,
+                    event_context: {
+                        extraction_start_time: {
+                            type: extraction_1.TimeValueType.WORKERS_NEWEST,
+                        },
+                    },
+                },
+            });
+            const stringifiedState = JSON.stringify({
+                snapInVersionId: 'test_snap_in_version_id',
+                workers_oldest: '',
+                workers_newest: '',
+            });
+            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
+            // Act & Assert
+            await expect((0, extraction_state_1.createExtractionState)({
+                event,
+                initialState: {},
+                initialDomainMapping: {},
+            })).rejects.toThrow('process.exit called');
+            expect(processExitSpy).toHaveBeenCalledWith(1);
+        });
+        it('should exit the process if extraction_end_time resolution fails', async () => {
+            // Arrange: WORKERS_NEWEST type but state has no workersNewest
+            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+                payload: {
+                    event_type: extraction_1.EventType.StartExtractingMetadata,
+                    event_context: {
+                        extraction_start_time: {
+                            type: extraction_1.TimeValueType.UNBOUNDED,
+                        },
+                        extraction_end_time: {
+                            type: extraction_1.TimeValueType.WORKERS_NEWEST,
+                        },
+                    },
+                },
+            });
+            const stringifiedState = JSON.stringify({
+                snapInVersionId: 'test_snap_in_version_id',
+                workers_oldest: '',
+                workers_newest: '',
+            });
+            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
+            // Act & Assert
+            await expect((0, extraction_state_1.createExtractionState)({
+                event,
+                initialState: {},
+                initialDomainMapping: {},
+            })).rejects.toThrow('process.exit called');
+            expect(processExitSpy).toHaveBeenCalledWith(1);
+        });
+    });
+    describe('Backwards compatibility - missing TimeValue type', () => {
+        it('should skip resolution when extraction_start_time has no type', async () => {
+            // Arrange: platform sends extraction_start_time without a type field (old platform version)
+            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+                context: {
+                    snap_in_version_id: 'test_snap_in_version_id',
+                },
+                payload: {
+                    event_type: extraction_1.EventType.StartExtractingMetadata,
+                    event_context: {
+                        extraction_start_time: {},
+                        extraction_end_time: {
+                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
+                            value: '2025-06-01T00:00:00Z',
+                        },
+                    },
+                },
+            });
+            const stringifiedState = JSON.stringify({
+                snapInVersionId: 'test_snap_in_version_id',
+            });
+            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
+            // Act
+            const state = await (0, extraction_state_1.createExtractionState)({
+                event,
+                initialState: {},
+                initialDomainMapping: {},
+            });
+            // Assert: should not crash, extract_from is not set, extract_to is resolved
+            expect(processExitSpy).not.toHaveBeenCalled();
+            expect(event.payload.event_context.extract_from).toBeUndefined();
+            expect(event.payload.event_context.extract_to).toBe('2025-06-01T00:00:00.000Z');
+            expect(state.sdkState.pendingWorkersNewest).toBe('2025-06-01T00:00:00.000Z');
+        });
+        it('should skip resolution when extraction_end_time has no type', async () => {
+            // Arrange: platform sends extraction_end_time without a type field
+            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+                context: {
+                    snap_in_version_id: 'test_snap_in_version_id',
+                },
+                payload: {
+                    event_type: extraction_1.EventType.StartExtractingMetadata,
+                    event_context: {
+                        extraction_start_time: {
+                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
+                            value: '2024-01-01T00:00:00Z',
+                        },
+                        extraction_end_time: {},
+                    },
+                },
+            });
+            const stringifiedState = JSON.stringify({
+                snapInVersionId: 'test_snap_in_version_id',
+            });
+            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
+            // Act
+            await (0, extraction_state_1.createExtractionState)({
+                event,
+                initialState: {},
+                initialDomainMapping: {},
+            });
+            // Assert: should not crash, extract_to is not set, extract_from is resolved
+            expect(processExitSpy).not.toHaveBeenCalled();
+            expect(event.payload.event_context.extract_from).toBe('2024-01-01T00:00:00.000Z');
+            expect(event.payload.event_context.extract_to).toBeUndefined();
+        });
+        it('should skip resolution when both extraction times have no type', async () => {
+            // Arrange: platform sends both time values without type fields
+            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+                context: {
+                    snap_in_version_id: 'test_snap_in_version_id',
+                },
+                payload: {
+                    event_type: extraction_1.EventType.StartExtractingMetadata,
+                    event_context: {
+                        extraction_start_time: {
+                            value: 'some-value',
+                        },
+                        extraction_end_time: {
+                            value: 'some-value',
+                        },
+                    },
+                },
+            });
+            const stringifiedState = JSON.stringify({
+                snapInVersionId: 'test_snap_in_version_id',
+            });
+            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
+            // Act
+            await (0, extraction_state_1.createExtractionState)({
+                event,
+                initialState: {},
+                initialDomainMapping: {},
+            });
+            // Assert: should not crash, neither extraction time is resolved
+            expect(processExitSpy).not.toHaveBeenCalled();
+            expect(event.payload.event_context.extract_from).toBeUndefined();
+            expect(event.payload.event_context.extract_to).toBeUndefined();
+        });
+    });
+});

package/dist/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.58.7"
+    }
+  ]
+}

package/dist/types/common.d.ts

@@ -1,34 +1,9 @@
-import { Artifact } from '../uploader/uploader.interfaces';
-/**
- * ErrorLevel is an enum that represents the level of an error.
- * @deprecated
- */
-export declare enum ErrorLevel {
-    Warning = "WARNING",
-    Error = "ERROR",
-    Info = "INFO"
-}
 /**
  * ErrorRecord is an interface that defines the structure of an error record.
  */
 export interface ErrorRecord {
     message: string;
 }
-/**
- * LogRecord is an interface that defines the structure of a log record.
- * @deprecated
- */
-export interface LogRecord {
-    level: ErrorLevel;
-    message: string;
-}
-/**
- * AdapterUpdateParams is an interface that defines the structure of the parameters that can be passed to the update adapter.
- * @deprecated
- */
-export interface AdapterUpdateParams {
-    artifact?: Artifact;
-}
 /**
  * InitialDomainMapping is an interface that defines the structure of the initial domain mapping.
  */

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

@@ -1 +1 @@
-{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/types/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAE3D;;;GAGG;AACH,oBAAY,UAAU;IACpB,OAAO,YAAY;IACnB,KAAK,UAAU;IACf,IAAI,SAAS;CACd;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,UAAU,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;GAKG;AACH,oBAAY,QAAQ;IAClB,OAAO,YAAY;IACnB,WAAW,gBAAgB;IAC3B,OAAO,YAAY;CACpB"}
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/types/common.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;GAKG;AACH,oBAAY,QAAQ;IAClB,OAAO,YAAY;IACnB,WAAW,gBAAgB;IAC3B,OAAO,YAAY;CACpB"}

package/dist/types/common.js

@@ -1,16 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SyncMode = exports.ErrorLevel = void 0;
-/**
- * ErrorLevel is an enum that represents the level of an error.
- * @deprecated
- */
-var ErrorLevel;
-(function (ErrorLevel) {
-    ErrorLevel["Warning"] = "WARNING";
-    ErrorLevel["Error"] = "ERROR";
-    ErrorLevel["Info"] = "INFO";
-})(ErrorLevel || (exports.ErrorLevel = ErrorLevel = {}));
+exports.SyncMode = void 0;
 /**
  * SyncMode is an enum that defines the different modes of sync that can be used by the external extractor.
  * It can be either INITIAL, INCREMENTAL or LOADING. INITIAL mode is used for

package/dist/types/external-domain-metadata.d.ts

@@ -19,7 +19,7 @@ export type StageKey = string;
 /**
  * Field type discriminator.
  */
-export type FieldType = 'bool' | 'int' | 'float' | 'text' | 'rich_text' | 'reference' | 'typed_reference' | 'enum' | 'date' | 'timestamp' | 'struct' | 'permission' | 'record_type_privilege' | 'field_privilege' | 'conditional_privilege';
+export type FieldType = 'bool' | 'int' | 'float' | 'text' | 'rich_text' | 'reference' | 'typed_reference' | 'enum' | 'date' | 'timestamp' | 'struct' | 'permission' | 'record_type_privilege' | 'field_privilege' | 'conditional_privilege' | 'participation';
 /**
  * Reference type indicating parent-child relationship.
  */
@@ -113,6 +113,13 @@ export interface TypedReferenceData {
 export interface StructData {
     key?: StructTypeKey;
 }
+/**
+ * Participation field data specifying target record types.
+ */
+export interface ParticipationData {
+    /** The record types that this participation reference can refer to */
+    refers_to: Record<RecordTypeKey, ReferenceDetail>;
+}
 /**
  * Permission data associating a reference with a role.
  */
@@ -190,6 +197,7 @@ export interface Field {
     record_type_privilege?: RecordTypePrivilegeData;
     field_privilege?: FieldPrivilegeData;
     conditional_privilege?: ConditionalPrivilegeData;
+    participation?: ParticipationData;
 }
 /**
  * Field condition definition.
@@ -269,6 +277,15 @@ export interface RecordTypeCategory {
     /** Indicates whether a record can move between the record types of this category while preserving its identity */
     are_record_type_conversions_possible?: boolean;
 }
+/**
+ * Attachments configuration for a record type.
+ */
+export interface Attachments {
+    /** Whether attachments can be extracted */
+    is_extractable?: boolean;
+    /** Whether attachments can be loaded: that is, whether the connector supports creating it in the system */
+    is_loadable?: boolean;
+}
 /**
  * Record type definition.
  */
@@ -293,6 +310,8 @@ export interface RecordType {
     stage_diagram?: StageDiagram;
     /** Link naming data for custom links */
     link_naming_data?: CustomLinkData;
+    /** Attachments configuration */
+    attachments?: Attachments;
 }
 /**
  * Struct type definition for reusable field structures.