@contrail/cli 3.4.5 → 3.4.6-alpha.cffb28e

package/node_modules/@contrail/loader/lib/pipeline/transform.spec.js

@@ -0,0 +1,442 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const transform_1 = require("./transform");
+const dataTransformerFunctions = __importStar(require("../common/data-transformer-functions"));
+const typeHelper = __importStar(require("../common/type-helper"));
+let getReducedTypesSpy;
+let getPropertiesBySlugAndLabelSpy;
+let getOptionSetsUsingTypePropertiesBySlugSpy;
+jest.mock('../common/type-helper', () => ({
+    buildTypesByPathForPipeline: jest.fn().mockResolvedValue({}),
+}));
+describe('transform', () => {
+    let mockClient;
+    const baseConfig = {
+        loadType: [types_1.LoadType.ITEM],
+        federatedMappings: { federatedId: 'sku' },
+    };
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockClient = {};
+        typeHelper.buildTypesByPathForPipeline.mockResolvedValue({});
+        getReducedTypesSpy = jest.spyOn(dataTransformerFunctions, 'getReducedTypes')
+            .mockResolvedValue([]);
+        getPropertiesBySlugAndLabelSpy = jest.spyOn(dataTransformerFunctions, 'getPropertiesBySlugAndLabel')
+            .mockReturnValue({ typePropertiesBySlug: {}, typePropertiesByLabel: {} });
+        getOptionSetsUsingTypePropertiesBySlugSpy = jest.spyOn(dataTransformerFunctions, 'getOptionSetsUsingTypePropertiesBySlug')
+            .mockReturnValue({});
+    });
+    it('should return empty result for empty rows', async () => {
+        const result = await (0, transform_1.transform)(mockClient, [], baseConfig);
+        expect(result.rows).toEqual([]);
+        expect(result.stepResults).toEqual([]);
+        expect(result.errors).toEqual([]);
+    });
+    it('should run all 8 transform steps (including type fetch and column analysis)', async () => {
+        const rows = [{ sku: 'ABC-123', name: 'Test', active: 'true' }];
+        const result = await (0, transform_1.transform)(mockClient, rows, baseConfig);
+        expect(result.stepResults).toHaveLength(8);
+        expect(result.stepResults.map((s) => s.stepName)).toEqual([
+            'Evaluate Conditional Columns',
+            'Remove Unwanted Properties',
+            'Trim Whitespace',
+            'Apply Federated Mapping',
+            'Fetch Type Definitions',
+            'Transform Data Based on Types',
+            'Coerce Values by Type',
+            'Analyze Columns',
+        ]);
+    });
+    it('should include type definitions and column analysis in the result', async () => {
+        const rows = [{ sku: 'ABC-123', name: 'Test' }];
+        const result = await (0, transform_1.transform)(mockClient, rows, baseConfig);
+        expect(result.typePropertyMaps).toBeDefined();
+        expect(result.typesByPath).toBeDefined();
+        expect(result.columns).toBeDefined();
+        expect(Array.isArray(result.columns)).toBe(true);
+    });
+    it('should coerce boolean values for type-mapped columns', async () => {
+        getPropertiesBySlugAndLabelSpy.mockReturnValue({
+            typePropertiesBySlug: {
+                active: { slug: 'active', propertyType: 'boolean' },
+                archived: { slug: 'archived', propertyType: 'boolean' },
+            },
+            typePropertiesByLabel: {},
+        });
+        const rows = [{ active: 'true', archived: 'false' }];
+        const result = await (0, transform_1.transform)(mockClient, rows, baseConfig);
+        expect(result.rows[0].active).toBe(true);
+        expect(result.rows[0].archived).toBe(false);
+    });
+    it('should apply federated mappings across multiple columns', async () => {
+        const config = {
+            loadType: [types_1.LoadType.COLOR],
+            federatedMappings: {
+                federatedId: 'sku',
+                name: 'display_name',
+                property_1: 'input_col_1',
+            },
+        };
+        const rows = [{ sku: 'ABC-123', display_name: 'Test Item', input_col_1: 'val1', unmapped: 'stays' }];
+        const result = await (0, transform_1.transform)(mockClient, rows, config);
+        expect(result.rows[0].federatedId).toBe('ABC-123');
+        expect(result.rows[0].name).toBe('Test Item');
+        expect(result.rows[0].property_1).toBe('val1');
+        expect(result.rows[0].unmapped).toBe('stays');
+        expect(result.rows[0].sku).toBe('ABC-123');
+        expect(result.rows[0].display_name).toBe('Test Item');
+        expect(result.rows[0].input_col_1).toBe('val1');
+    });
+    it('should apply conditional columns before federated mappings', async () => {
+        const config = {
+            loadType: [types_1.LoadType.COLOR],
+            conditionalColumns: [{
+                    toProperty: 'computedField',
+                    columnName: 'category',
+                    conditions: [
+                        { value: 'shoes', conditional: "{category} === 'footwear'" },
+                    ],
+                    default: 'other',
+                }],
+            federatedMappings: {
+                property_1: 'category',
+            },
+        };
+        const rows = [{ federatedId: '1', category: 'footwear' }];
+        const result = await (0, transform_1.transform)(mockClient, rows, config);
+        expect(result.rows[0].computedField).toBe('shoes');
+        expect(result.rows[0].property_1).toBe('footwear');
+    });
+    it('should handle empty federated mappings', async () => {
+        const config = {
+            loadType: [types_1.LoadType.COLOR],
+            federatedMappings: {},
+        };
+        const rows = [{ federatedId: '1', name: 'Test', color: 'red' }];
+        const result = await (0, transform_1.transform)(mockClient, rows, config);
+        expect(result.rows[0].federatedId).toBe('1');
+        expect(result.rows[0].name).toBe('Test');
+        expect(result.rows[0].color).toBe('red');
+    });
+    it('should handle undefined federated mappings', async () => {
+        const config = {
+            loadType: [types_1.LoadType.COLOR],
+        };
+        const rows = [{ federatedId: '1', name: 'Test' }];
+        const result = await (0, transform_1.transform)(mockClient, rows, config);
+        expect(result.rows[0].federatedId).toBe('1');
+        expect(result.rows[0].name).toBe('Test');
+    });
+    it('should remove unwanted properties', async () => {
+        const config = {
+            ...baseConfig,
+            propertiesToRemove: ['internalNote'],
+        };
+        const rows = [{ federatedId: '123', internalNote: 'secret', name: 'Test' }];
+        const result = await (0, transform_1.transform)(mockClient, rows, config);
+        expect(result.rows[0].internalNote).toBeUndefined();
+        expect(result.rows[0].name).toBe('Test');
+    });
+    it('should not coerce unmapped columns', async () => {
+        getPropertiesBySlugAndLabelSpy.mockReturnValue({
+            typePropertiesBySlug: {
+                active: { slug: 'active', propertyType: 'boolean' },
+            },
+            typePropertiesByLabel: {},
+        });
+        const rows = [{ active: 'true', unmappedField: 'true' }];
+        const result = await (0, transform_1.transform)(mockClient, rows, baseConfig);
+        expect(result.rows[0].active).toBe(true);
+        expect(result.rows[0].unmappedField).toBe('true');
+    });
+    it('should not mutate original rows', async () => {
+        const rows = [{ sku: 'ABC', active: 'true' }];
+        const original = JSON.parse(JSON.stringify(rows));
+        await (0, transform_1.transform)(mockClient, rows, baseConfig);
+        expect(rows[0].sku).toBe(original[0].sku);
+        expect(rows[0].active).toBe(original[0].active);
+    });
+    it('should collect step summaries with counts', async () => {
+        const rows = [{ a: '1' }, { b: '2' }];
+        const result = await (0, transform_1.transform)(mockClient, rows, baseConfig);
+        for (const step of result.stepResults) {
+            expect(step.rowCountAfter).toBeGreaterThan(0);
+            expect(typeof step.errorCount).toBe('number');
+            expect(typeof step.warningCount).toBe('number');
+        }
+    });
+    it('should handle preprocessing step errors gracefully', async () => {
+        jest.spyOn(dataTransformerFunctions, 'applyFederatedMappings').mockImplementation(() => {
+            throw new Error('Step exploded');
+        });
+        const rows = [{ federatedId: '123' }];
+        const result = await (0, transform_1.transform)(mockClient, rows, baseConfig);
+        expect(result.generalErrors).toHaveLength(1);
+        expect(result.generalErrors[0].message).toContain('Step exploded');
+        expect(result.generalErrors[0].issueType).toBe(types_1.IssueType.SYSTEM_ERROR);
+    });
+    it('should fetch types using typePath values set by conditional columns', async () => {
+        const config = {
+            loadType: [types_1.LoadType.ITEM],
+            conditionalColumns: [{
+                    toProperty: 'typePath',
+                    default: 'item:footwear',
+                }],
+        };
+        const rows = [{ federatedId: '1', name: 'Test' }];
+        await (0, transform_1.transform)(mockClient, rows, config);
+        expect(typeHelper.buildTypesByPathForPipeline).toHaveBeenCalledWith(mockClient, expect.arrayContaining(['item:footwear']));
+    });
+    it('should report errors when ITEM load rows are missing typePath', async () => {
+        const rows = [
+            { federatedId: '1', name: 'A', typePath: 'item:footwear' },
+            { federatedId: '2', name: 'B' },
+            { federatedId: '3', name: 'C', typePath: '' },
+        ];
+        const result = await (0, transform_1.transform)(mockClient, rows, baseConfig);
+        const missingTypePathErrors = result.generalErrors.filter((e) => e.message.includes('missing a typePath'));
+        expect(missingTypePathErrors).toHaveLength(1);
+        expect(missingTypePathErrors[0].message).toContain('2 row(s)');
+        expect(missingTypePathErrors[0].issueType).toBe(types_1.IssueType.MISSING_DATA);
+    });
+    it('should report errors when ITEM load rows have wrong typePath prefix', async () => {
+        const rows = [
+            { federatedId: '1', name: 'A', typePath: 'color' },
+        ];
+        const result = await (0, transform_1.transform)(mockClient, rows, baseConfig);
+        const prefixErrors = result.generalErrors.filter((e) => e.message.includes('unexpected prefix'));
+        expect(prefixErrors).toHaveLength(1);
+        expect(prefixErrors[0].issueType).toBe(types_1.IssueType.INVALID_DATA);
+    });
+    it('should only pass valid typePaths to buildTypesByPathForPipeline for ITEM loads', async () => {
+        const rows = [
+            { federatedId: '1', name: 'A', typePath: 'item:footwear' },
+            { federatedId: '2', name: 'B' },
+        ];
+        await (0, transform_1.transform)(mockClient, rows, baseConfig);
+        expect(typeHelper.buildTypesByPathForPipeline).toHaveBeenCalledTimes(1);
+        const callArgs = typeHelper.buildTypesByPathForPipeline.mock.calls[0];
+        expect(callArgs[0]).toBe(mockClient);
+        expect(callArgs[1]).toEqual(['item:footwear']);
+    });
+    it('should not require typePath on rows for non-subtype loads (COLOR)', async () => {
+        const config = {
+            loadType: [types_1.LoadType.COLOR],
+        };
+        const rows = [{ federatedId: '1', name: 'Red' }];
+        const result = await (0, transform_1.transform)(mockClient, rows, config);
+        const missingTypePathErrors = result.generalErrors.filter((e) => e.message.includes('missing a typePath'));
+        expect(missingTypePathErrors).toHaveLength(0);
+        expect(typeHelper.buildTypesByPathForPipeline).toHaveBeenCalledWith(mockClient, expect.arrayContaining(['color']));
+    });
+    it('should not require typePath on rows for ASSORTMENT loads', async () => {
+        const config = {
+            loadType: [types_1.LoadType.ASSORTMENT],
+        };
+        const rows = [{ itemFamilyFederatedId: 'fam-1' }];
+        const result = await (0, transform_1.transform)(mockClient, rows, config);
+        const missingTypePathErrors = result.generalErrors.filter((e) => e.message.includes('missing a typePath'));
+        expect(missingTypePathErrors).toHaveLength(0);
+        expect(typeHelper.buildTypesByPathForPipeline).toHaveBeenCalledWith(mockClient, expect.arrayContaining(['assortment-item']));
+    });
+    it('should require typePath for mixed loads that include ITEM', async () => {
+        const config = {
+            loadType: [types_1.LoadType.ITEM, types_1.LoadType.PROJECT_ITEM, types_1.LoadType.ASSORTMENT],
+        };
+        const rows = [{ federatedId: '1', name: 'A' }];
+        const result = await (0, transform_1.transform)(mockClient, rows, config);
+        const missingTypePathErrors = result.generalErrors.filter((e) => e.message.includes('missing a typePath'));
+        expect(missingTypePathErrors).toHaveLength(1);
+    });
+    const columnAnalysisTypeMaps = {
+        typePropertiesBySlug: {
+            color: { slug: 'color', label: 'Color', propertyType: 'string', isArchived: false },
+            size: { slug: 'size', label: 'Size', propertyType: 'choice', isArchived: false },
+            oldProp: { slug: 'oldProp', label: 'Old Property', propertyType: 'string', isArchived: true },
+        },
+        typePropertiesByLabel: {
+            Color: { slug: 'color', label: 'Color', propertyType: 'string', isArchived: false },
+            Size: { slug: 'size', label: 'Size', propertyType: 'choice', isArchived: false },
+            'Old Property': { slug: 'oldProp', label: 'Old Property', propertyType: 'string', isArchived: true },
+        },
+        optionSetUsingTypePropertiesBySlug: {
+            size: { slug: 'size', label: 'Size', propertyType: 'choice', isArchived: false },
+        },
+    };
+    function setupColumnAnalysisMocks() {
+        getPropertiesBySlugAndLabelSpy.mockReturnValue({
+            typePropertiesBySlug: columnAnalysisTypeMaps.typePropertiesBySlug,
+            typePropertiesByLabel: columnAnalysisTypeMaps.typePropertiesByLabel,
+        });
+        getOptionSetsUsingTypePropertiesBySlugSpy.mockReturnValue(columnAnalysisTypeMaps.optionSetUsingTypePropertiesBySlug);
+    }
+    it('should classify columns matched by slug', async () => {
+        setupColumnAnalysisMocks();
+        const config = { loadType: [types_1.LoadType.COLOR] };
+        const rows = [{ federatedId: '123', color: 'red', size: 'S' }];
+        const result = await (0, transform_1.transform)(mockClient, rows, config);
+        const colorCol = result.columns.find((c) => c.csvHeader === 'color');
+        expect(colorCol).toBeDefined();
+        expect(colorCol.isMapped).toBe(true);
+        expect(colorCol.matchedSlug).toBe('color');
+        expect(colorCol.isArchived).toBe(false);
+    });
+    it('should detect option set columns', async () => {
+        setupColumnAnalysisMocks();
+        const config = { loadType: [types_1.LoadType.COLOR] };
+        const rows = [{ size: 'S' }];
+        const result = await (0, transform_1.transform)(mockClient, rows, config);
+        const sizeCol = result.columns.find((c) => c.csvHeader === 'size');
+        expect(sizeCol).toBeDefined();
+        expect(sizeCol.hasOptionSet).toBe(true);
+        expect(sizeCol.propertyType).toBe('choice');
+    });
+    it('should detect archived properties', async () => {
+        setupColumnAnalysisMocks();
+        const config = { loadType: [types_1.LoadType.COLOR] };
+        const rows = [{ oldProp: 'value' }];
+        const result = await (0, transform_1.transform)(mockClient, rows, config);
+        const archivedCol = result.columns.find((c) => c.csvHeader === 'oldProp');
+        expect(archivedCol).toBeDefined();
+        expect(archivedCol.isArchived).toBe(true);
+        expect(archivedCol.isMapped).toBe(true);
+    });
+    it('should mark system properties as required for non-item loads', async () => {
+        setupColumnAnalysisMocks();
+        const config = { loadType: [types_1.LoadType.COLOR] };
+        const rows = [{ federatedId: '123', name: 'Test' }];
+        const result = await (0, transform_1.transform)(mockClient, rows, config);
+        const fedIdCol = result.columns.find((c) => c.csvHeader === 'federatedId');
+        expect(fedIdCol.isRequired).toBe(true);
+        expect(fedIdCol.isMapped).toBe(true);
+    });
+    it('should mark item-specific required and paired properties for item loads', async () => {
+        setupColumnAnalysisMocks();
+        const config = {
+            loadType: [types_1.LoadType.ITEM],
+            conditionalColumns: [{ toProperty: 'typePath', default: 'item' }],
+        };
+        const rows = [{ itemFamilyFederatedId: 'fam-1', name: 'Test', itemOptionFederatedId: 'opt-1', optionName: 'Opt' }];
+        const result = await (0, transform_1.transform)(mockClient, rows, config);
+        const famFedIdCol = result.columns.find((c) => c.csvHeader === 'itemFamilyFederatedId');
+        expect(famFedIdCol.isRequired).toBe(true);
+        const nameCol = result.columns.find((c) => c.csvHeader === 'name');
+        expect(nameCol.isRequired).toBe(true);
+        const optFedIdCol = result.columns.find((c) => c.csvHeader === 'itemOptionFederatedId');
+        expect(optFedIdCol.isRequired).toBe(true);
+        expect(optFedIdCol.requiredNote).toBe('paired with optionName');
+        const optNameCol = result.columns.find((c) => c.csvHeader === 'optionName');
+        expect(optNameCol.isRequired).toBe(true);
+        expect(optNameCol.requiredNote).toBe('paired with itemOptionFederatedId');
+    });
+    it('should mark unmapped columns', async () => {
+        setupColumnAnalysisMocks();
+        const config = { loadType: [types_1.LoadType.COLOR] };
+        const rows = [{ unknownColumn: 'value' }];
+        const result = await (0, transform_1.transform)(mockClient, rows, config);
+        const unknownCol = result.columns.find((c) => c.csvHeader === 'unknownColumn');
+        expect(unknownCol.isMapped).toBe(false);
+        expect(unknownCol.isArchived).toBe(false);
+    });
+    it('should handle Family/Option suffixed columns', async () => {
+        setupColumnAnalysisMocks();
+        const config = {
+            loadType: [types_1.LoadType.ITEM],
+            conditionalColumns: [{ toProperty: 'typePath', default: 'item' }],
+        };
+        const rows = [{ colorFamily: 'red', colorOption: 'blue' }];
+        const result = await (0, transform_1.transform)(mockClient, rows, config);
+        const familyCol = result.columns.find((c) => c.csvHeader === 'colorFamily');
+        expect(familyCol.isMapped).toBe(true);
+        expect(familyCol.matchedSlug).toBe('color');
+    });
+    it('should extract unique headers from all rows', async () => {
+        setupColumnAnalysisMocks();
+        const config = { loadType: [types_1.LoadType.COLOR] };
+        const rows = [
+            { federatedId: '1', color: 'red' },
+            { federatedId: '2', size: 'M' },
+        ];
+        const result = await (0, transform_1.transform)(mockClient, rows, config);
+        const headers = result.columns.map((c) => c.csvHeader);
+        expect(headers).toContain('federatedId');
+        expect(headers).toContain('color');
+        expect(headers).toContain('size');
+    });
+    it('should inject config.assortmentId onto all rows as default', async () => {
+        const config = {
+            loadType: [types_1.LoadType.ASSORTMENT],
+            assortmentId: 'assort-123',
+        };
+        const rows = [{ itemFamilyFederatedId: 'fam-1' }, { itemFamilyFederatedId: 'fam-2' }];
+        const result = await (0, transform_1.transform)(mockClient, rows, config);
+        for (const row of result.rows) {
+            expect(row.assortmentId).toBe('assort-123');
+        }
+    });
+    it('should inject config.assortmentIdentifier onto all rows as default', async () => {
+        const config = {
+            loadType: [types_1.LoadType.ASSORTMENT],
+            assortmentIdentifier: 'summer-2025',
+        };
+        const rows = [{ itemFamilyFederatedId: 'fam-1' }];
+        const result = await (0, transform_1.transform)(mockClient, rows, config);
+        expect(result.rows[0].assortmentIdentifier).toBe('summer-2025');
+    });
+    it('should inject config.projectId onto all rows as default', async () => {
+        const config = {
+            loadType: [types_1.LoadType.PROJECT_ITEM],
+            projectId: 'proj-123',
+        };
+        const rows = [{ itemFamilyFederatedId: 'fam-1' }];
+        const result = await (0, transform_1.transform)(mockClient, rows, config);
+        expect(result.rows[0].projectId).toBe('proj-123');
+    });
+    it('should inject config.workspaceIdentifier onto all rows as default', async () => {
+        const config = {
+            loadType: [types_1.LoadType.PROJECT_ITEM],
+            workspaceIdentifier: 'ws-1',
+        };
+        const rows = [{ itemFamilyFederatedId: 'fam-1' }];
+        const result = await (0, transform_1.transform)(mockClient, rows, config);
+        expect(result.rows[0].workspaceIdentifier).toBe('ws-1');
+    });
+    it('should allow multiple identifier injections to coexist', async () => {
+        const config = {
+            loadType: [types_1.LoadType.ASSORTMENT],
+            assortmentId: 'assort-1',
+            workspaceIdentifier: 'ws-1',
+        };
+        const rows = [{ itemFamilyFederatedId: 'fam-1' }];
+        const result = await (0, transform_1.transform)(mockClient, rows, config);
+        expect(result.rows[0].assortmentId).toBe('assort-1');
+        expect(result.rows[0].workspaceIdentifier).toBe('ws-1');
+    });
+});

package/node_modules/@contrail/loader/lib/pipeline/types.d.ts

@@ -0,0 +1,251 @@
+import { EntitiesClient } from '@contrail/entity-types';
+import { ColumnDefinition, ConditionalValues } from '../common/conditional-columns';
+import { TypePropertyMaps } from '../common/data-transformer-functions';
+import { TypesByPath } from '../entities-v2/entities-helper';
+export { EntitiesClient, TypePropertyMaps, TypesByPath, };
+export declare enum LoadType {
+    ITEM = "ITEM",
+    PROJECT_ITEM = "PROJECT_ITEM",
+    ASSORTMENT = "ASSORTMENT",
+    COLOR = "COLOR",
+    CUSTOM_ENTITY = "CUSTOM_ENTITY",
+    SIZE_RANGE_TEMPLATE = "SIZE_RANGE_TEMPLATE",
+    PROJECT = "PROJECT"
+}
+export declare enum EntityType {
+    COLOR = "color",
+    CUSTOM_ENTITY = "custom-entity",
+    ITEM = "item",
+    PROJECT_ITEM = "project-item",
+    ASSORTMENT = "assortment-item"
+}
+export declare enum IssueType {
+    CONFIG = "CONFIG",
+    INVALID_DATA = "INVALID_DATA",
+    MISSING_DATA = "MISSING_DATA",
+    DUPLICATE_FEDERATED_ID = "DUPLICATE_FEDERATED_ID",
+    SYSTEM_ERROR = "SYSTEM_ERROR",
+    HEADER_MISMATCH = "HEADER_MISMATCH",
+    VALIDATION_ERROR = "VALIDATION_ERROR",
+    PERMISSION_DENIED = "PERMISSION_DENIED",
+    UNKNOWN_ERROR = "UNKNOWN_ERROR"
+}
+export declare enum PreValidationCategory {
+    OPTION_SET = "OPTION_SET",
+    FORMAT_BOOLEAN = "FORMAT_BOOLEAN",
+    FORMAT_MULTI_SELECT = "FORMAT_MULTI_SELECT",
+    CONFIG = "CONFIG",
+    MISSING_REQUIRED_FIELD = "MISSING_REQUIRED_FIELD",
+    REFERENCE_DATA_NOT_FOUND = "REFERENCE_DATA_NOT_FOUND",
+    FAMILY_PROPERTY_VALUES_INCONSISTENT = "FAMILY_PROPERTY_VALUES_INCONSISTENT",
+    SELF_REFERENCE = "SELF_REFERENCE",
+    UNMAPPED_COLUMN = "UNMAPPED_COLUMN",
+    UNMAPPED_TYPE_PROPERTY = "UNMAPPED_TYPE_PROPERTY",
+    FORMAT_NUMBER_PRECISION = "FORMAT_NUMBER_PRECISION"
+}
+export declare enum PreValidationSeverity {
+    ERROR = "error",
+    WARNING = "warning",
+    INFO = "info"
+}
+export declare enum SuggestedFixType {
+    ADD_OPTION_SET_VALUES = "add-option-set-values",
+    REPLACE_VALUES = "replace-values",
+    CHANGE_SEPARATOR = "change-separator"
+}
+export interface GeneralIssueDetails {
+    message: string;
+    issueType: IssueType;
+}
+export interface ColumnIssueDetails {
+    columnName: string;
+    message: string;
+    issueType: IssueType;
+}
+export interface ProcessingIssues {
+    rowNumber: number;
+    columnIssues: ColumnIssueDetails[];
+}
+export { ColumnDefinition, ConditionalValues };
+export interface SuggestedFix {
+    type: SuggestedFixType;
+    details: Record<string, any>;
+}
+export interface AffectedRow {
+    row: number;
+    value: string;
+}
+export interface PreValidationIssue {
+    severity: PreValidationSeverity;
+    category: PreValidationCategory;
+    columnName: string;
+    propertySlug: string;
+    propertyType: string;
+    message: string;
+    affectedRows: AffectedRow[];
+    suggestedFix?: SuggestedFix;
+}
+export interface PreValidationSummary {
+    errorCount: number;
+    warningCount: number;
+    infoCount: number;
+    countsByCategory: Partial<Record<PreValidationCategory, number>>;
+}
+export interface PreValidationResult {
+    valid: boolean;
+    issues: PreValidationIssue[];
+    summary: PreValidationSummary;
+}
+export interface LoaderConfig {
+    loadType: LoadType[];
+    federatedMappings?: Record<string, string>;
+    conditionalColumns?: ColumnDefinition[];
+    propertiesToRemove?: string[];
+    skipStaleUpdatesUsing?: string;
+    workspaceIdentifier?: string;
+    projectId?: string;
+    assortmentId?: string;
+    assortmentIdentifier?: string;
+    partialAssortmentUpdate?: boolean;
+    assortmentItemDropField?: string;
+    skipAssortmentPublish?: boolean;
+    options?: LoaderOptions;
+}
+export interface LoaderOptions {
+    batchSize?: number;
+    concurrency?: number;
+    maxRetries?: number;
+    ignoreFamilyNameOnUpdate?: boolean;
+    ignoreOptionNameOnUpdate?: boolean;
+}
+export interface TypeDefinitionsResult {
+    typePropertyMaps: TypePropertyMaps;
+    typesByPath: TypesByPath;
+}
+export interface TransformResult {
+    rows: Record<string, any>[];
+    typePropertyMaps: TypePropertyMaps;
+    typesByPath: TypesByPath;
+    columns: ColumnMetaData[];
+    unmappedTypeProperties: UnmappedTypeProperty[];
+    errors: ProcessingIssues[];
+    warnings: ProcessingIssues[];
+    generalErrors: GeneralIssueDetails[];
+    generalWarnings: GeneralIssueDetails[];
+    stepResults: PreprocessingStepSummary[];
+}
+export declare type ColumnAnalysisResult = Pick<TransformResult, 'columns' | 'unmappedTypeProperties' | 'typePropertyMaps' | 'typesByPath'>;
+export interface ColumnMetaData {
+    csvHeader: string;
+    matchedSlug?: string;
+    matchedLabel?: string;
+    propertyType?: string;
+    isRequired: boolean;
+    requiredNote?: string;
+    isMapped: boolean;
+    isArchived: boolean;
+    hasOptionSet: boolean;
+}
+export interface UnmappedTypeProperty {
+    slug: string;
+    label?: string;
+    propertyType?: string;
+    isRequired: boolean;
+    hasOptionSet: boolean;
+}
+export interface PreprocessingStepSummary {
+    stepName: string;
+    rowCountAfter: number;
+    errorCount: number;
+    warningCount: number;
+}
+export interface PreviewResult {
+    entities: EntityPreviewSummary[];
+    badRows: SkippedRow[];
+    staleRows: SkippedRow[];
+    warnings: string[];
+    constructedEntities?: Record<string, ConstructedEntitySet>;
+}
+export interface EntityPreviewSummary {
+    entityType: string;
+    total: number;
+    creates: number;
+    updates: number;
+    drops: number;
+    unchanged: number;
+    skippedStale: number;
+    targetName?: string;
+    targetId?: string;
+}
+export interface SkippedRow {
+    rowNumber: number;
+    federatedId?: string;
+    reason: string;
+    details?: Record<string, any>;
+}
+export interface AssortmentDetail {
+    assortment: Record<string, any>;
+    fullSummary: {
+        adds: any[];
+        updates: Array<{
+            id: string;
+            diffs: Array<{
+                propertyName: string;
+                newValue: any;
+            }>;
+        }>;
+        deletes: any[];
+        unchanged: any[];
+    };
+    incomingAssortmentItems: any[];
+    badAssortmentItems: any[];
+    unmappedAssortmentItems: any[];
+}
+export interface ConstructedEntitySet {
+    incomingEntities: any[];
+    badEntities: any[];
+    allCurrentEntitiesByFederatedId: Record<string, any>;
+    typesByPath: TypesByPath;
+    projectId?: string;
+    generalWarnings?: GeneralIssueDetails[];
+    assortmentDetails?: AssortmentDetail[];
+}
+export interface ExecutionResult {
+    status: 'complete' | 'partial-failure' | 'failed';
+    entities: EntityExecutionSummary[];
+    skippedRows: SkippedRow[];
+    warnings: string[];
+    duration: number;
+}
+export interface EntityExecutionSummary {
+    entityType: string;
+    created: number;
+    updated: number;
+    dropped: number;
+    skippedStale: number;
+    failed: number;
+    failures: EntityFailure[];
+    targetName?: string;
+    targetId?: string;
+}
+export interface EntityFailure {
+    federatedId: string;
+    operation: 'create' | 'update' | 'drop';
+    error: string;
+}
+export interface ExecuteOptions {
+    batchSize?: number;
+    concurrency?: number;
+    onProgress?: (progress: ProgressEvent) => void;
+    skipAssortmentPublish?: boolean;
+    maxRetries?: number;
+}
+export interface ProgressEvent {
+    stage: string;
+    current: number;
+    total: number;
+}
+export declare function toLoaderProcessCompat(config: LoaderConfig): any;
+export declare function loadTypeToEntityTypes(loadTypes: LoadType[]): EntityType[];
+export declare function entityTypesToTypeRoots(entityTypes: EntityType[]): string[];
+export declare function enforceItemFirstOrder(entityTypes: EntityType[]): EntityType[];