@contrail/cli 3.4.5 → 3.4.6-alpha.cffb28e

package/node_modules/@contrail/loader/lib/pipeline/validate.js

@@ -0,0 +1,1217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validate = void 0;
+const types_1 = require("@contrail/types");
+const entity_processor_v2_1 = require("../entities-v2/entity-processor-v2");
+const processor_registry_1 = require("../processor-registry");
+const entities_helper_1 = require("../entities-v2/entities-helper");
+const types_2 = require("./types");
+const CONFIG_CATEGORY = types_2.PreValidationCategory.CONFIG;
+const MISSING_REQUIRED_FIELD_CATEGORY = types_2.PreValidationCategory.MISSING_REQUIRED_FIELD;
+const REFERENCE_NOT_FOUND_CATEGORY = types_2.PreValidationCategory.REFERENCE_DATA_NOT_FOUND;
+const FAMILY_INCONSISTENT_CATEGORY = types_2.PreValidationCategory.FAMILY_PROPERTY_VALUES_INCONSISTENT;
+const SELF_REFERENCE_CATEGORY = types_2.PreValidationCategory.SELF_REFERENCE;
+function isEmpty(value) {
+    return value === null || value === undefined || value === '';
+}
+function forEachRow(rows, callback) {
+    rows.forEach((row, index) => callback(row, index + 2));
+}
+const PROPERTY_TYPE_DISPLAY = {
+    choice: 'SINGLE_SELECT',
+    multi_select: 'MULTI_SELECT',
+};
+async function validate(rows, config, columnAnalysis, client) {
+    const issues = [];
+    if (!rows?.length) {
+        return buildResult(issues);
+    }
+    const processorIssues = runProcessorValidation(rows, config);
+    issues.push(...processorIssues);
+    const itemNameIssues = validateItemNames(rows, config);
+    issues.push(...itemNameIssues);
+    const identifierConflictIssues = validateStaticIdentifierConflicts(config);
+    issues.push(...identifierConflictIssues);
+    const projectItemColumnIssues = validateProjectItemColumns(rows, config);
+    issues.push(...projectItemColumnIssues);
+    if (client && projectItemColumnIssues.length === 0) {
+        const resolutionIssues = await validateAndResolveProjectIdentifiers(rows, config, client);
+        issues.push(...resolutionIssues);
+    }
+    const assortmentColumnIssues = validateAssortmentColumns(rows, config);
+    issues.push(...assortmentColumnIssues);
+    if (client && assortmentColumnIssues.length === 0) {
+        const assortmentIssues = await validateAndResolveAssortmentIdentifiers(rows, config, client);
+        issues.push(...assortmentIssues);
+    }
+    const partialUpdateIssues = validatePartialAssortmentConfig(rows, config);
+    issues.push(...partialUpdateIssues);
+    const typePathExistenceIssues = validateTypePathExistence(columnAnalysis.typesByPath);
+    issues.push(...typePathExistenceIssues);
+    const familyConsistencyIssues = validateFamilyPropertyConsistency(rows, config, columnAnalysis.typesByPath);
+    issues.push(...familyConsistencyIssues);
+    const suffixIssues = validateAllOverrideSuffixes(rows, config, columnAnalysis);
+    issues.push(...suffixIssues);
+    const selfRefIssues = validateSelfReferences(rows, config, columnAnalysis.typesByPath);
+    issues.push(...selfRefIssues);
+    const optionSetIssues = validateOptionSets(rows, columnAnalysis.typePropertyMaps);
+    issues.push(...optionSetIssues);
+    const booleanIssues = validateBooleanFormats(rows, columnAnalysis.typePropertyMaps);
+    issues.push(...booleanIssues);
+    const multiSelectIssues = validateMultiSelectFormats(rows, columnAnalysis.typePropertyMaps);
+    issues.push(...multiSelectIssues);
+    const unmappedIssues = generateUnmappedWarnings(columnAnalysis);
+    issues.push(...unmappedIssues);
+    const precisionIssues = validateNumberPrecision(rows, columnAnalysis.typePropertyMaps);
+    issues.push(...precisionIssues);
+    return buildResult(issues);
+}
+exports.validate = validate;
+function getFederatedIdKeyForLoadType(loadTypes) {
+    const itemBasedLoadTypes = [types_2.LoadType.ITEM, types_2.LoadType.PROJECT_ITEM, types_2.LoadType.ASSORTMENT];
+    const isItemBased = loadTypes.some((lt) => itemBasedLoadTypes.includes(lt));
+    return isItemBased ? 'itemFamilyFederatedId' : 'federatedId';
+}
+function runStructuralValidation(rows, config) {
+    const loaderProcess = (0, types_2.toLoaderProcessCompat)(config);
+    const federatedIdKey = getFederatedIdKeyForLoadType(config.loadType);
+    const result = entity_processor_v2_1.EntityProcessorV2.validateLoadFile(rows, loaderProcess, federatedIdKey);
+    const issues = [];
+    for (const error of result.generalErrors ?? []) {
+        issues.push({
+            severity: types_2.PreValidationSeverity.ERROR,
+            category: CONFIG_CATEGORY,
+            columnName: '',
+            propertySlug: '',
+            propertyType: '',
+            message: error.message,
+            affectedRows: [],
+        });
+    }
+    for (const warning of result.generalWarnings ?? []) {
+        issues.push({
+            severity: types_2.PreValidationSeverity.WARNING,
+            category: CONFIG_CATEGORY,
+            columnName: '',
+            propertySlug: '',
+            propertyType: '',
+            message: warning.message,
+            affectedRows: [],
+        });
+    }
+    return issues;
+}
+function runProcessorValidation(rows, config) {
+    const entityTypes = (0, types_2.loadTypeToEntityTypes)(config.loadType);
+    const invalidLoadTypes = config.loadType.filter((lt, i) => {
+        const singleResult = (0, types_2.loadTypeToEntityTypes)([lt]);
+        return singleResult.length === 0;
+    });
+    if (invalidLoadTypes.length > 0) {
+        throw new Error(`Unsupported LoadTypes detected: ${invalidLoadTypes.join(', ')}`);
+    }
+    const processor = (0, processor_registry_1.getProcessorForEntityTypes)(entityTypes);
+    if (!processor?.validateLoadFile) {
+        throw new Error(`Processor for entity types [${entityTypes.join(', ')}] does not implement validateLoadFile`);
+    }
+    const loaderProcess = (0, types_2.toLoaderProcessCompat)(config);
+    const validationResult = processor.validateLoadFile(rows, loaderProcess);
+    const issues = [];
+    for (const error of validationResult?.generalErrors ?? []) {
+        issues.push({
+            severity: types_2.PreValidationSeverity.ERROR,
+            category: CONFIG_CATEGORY,
+            columnName: '',
+            propertySlug: '',
+            propertyType: '',
+            message: error.message,
+            affectedRows: [],
+        });
+    }
+    for (const warning of validationResult?.generalWarnings ?? []) {
+        issues.push({
+            severity: types_2.PreValidationSeverity.WARNING,
+            category: CONFIG_CATEGORY,
+            columnName: '',
+            propertySlug: '',
+            propertyType: '',
+            message: warning.message,
+            affectedRows: [],
+        });
+    }
+    for (const error of validationResult?.errors ?? []) {
+        for (const colIssue of error.columnIssues ?? []) {
+            issues.push({
+                severity: types_2.PreValidationSeverity.ERROR,
+                category: CONFIG_CATEGORY,
+                columnName: colIssue.columnName,
+                propertySlug: colIssue.columnName,
+                propertyType: '',
+                message: colIssue.message,
+                affectedRows: [{ row: error.rowNumber, value: colIssue.data }],
+            });
+        }
+    }
+    for (const warning of validationResult?.warnings ?? []) {
+        for (const colIssue of warning.columnIssues ?? []) {
+            issues.push({
+                severity: types_2.PreValidationSeverity.WARNING,
+                category: CONFIG_CATEGORY,
+                columnName: colIssue.columnName,
+                propertySlug: colIssue.columnName,
+                propertyType: '',
+                message: colIssue.message,
+                affectedRows: [{ row: warning.rowNumber, value: colIssue.data }],
+            });
+        }
+    }
+    return issues;
+}
+function validateOptionSets(rows, typePropertyMaps) {
+    const { optionSetUsingTypePropertiesBySlug } = typePropertyMaps;
+    const issues = [];
+    const skipColumns = new Set();
+    const affectedRowsByColumn = {};
+    forEachRow(rows, (row, rowNumber) => {
+        for (const [key, value] of Object.entries(row)) {
+            if (isEmpty(value))
+                continue;
+            if (!optionSetUsingTypePropertiesBySlug[key])
+                continue;
+            if (!affectedRowsByColumn[key])
+                affectedRowsByColumn[key] = [];
+            affectedRowsByColumn[key].push({ row: rowNumber, value: String(value) });
+        }
+    });
+    for (const [slug, property] of Object.entries(optionSetUsingTypePropertiesBySlug)) {
+        if (!affectedRowsByColumn[slug])
+            continue;
+        if (!property.typePropertyOptionSetId) {
+            issues.push({
+                severity: types_2.PreValidationSeverity.ERROR,
+                category: types_2.PreValidationCategory.OPTION_SET,
+                columnName: slug,
+                propertySlug: property.slug,
+                propertyType: property.propertyType,
+                message: `Property "${slug}" is type ${PROPERTY_TYPE_DISPLAY[property.propertyType] ?? property.propertyType} but has no option set attached. Attach an option set to this property or change the property type.`,
+                affectedRows: affectedRowsByColumn[slug],
+            });
+            skipColumns.add(slug);
+        }
+        else if (!property.options || property.options.length === 0) {
+            issues.push({
+                severity: types_2.PreValidationSeverity.ERROR,
+                category: types_2.PreValidationCategory.OPTION_SET,
+                columnName: slug,
+                propertySlug: property.slug,
+                propertyType: property.propertyType,
+                message: `Option set for property "${slug}" is empty. Values in this column cannot be validated. Populate the option set or remove data from this column.`,
+                affectedRows: affectedRowsByColumn[slug],
+            });
+            skipColumns.add(slug);
+        }
+    }
+    const issuesByColumn = {};
+    forEachRow(rows, (row, rowNumber) => {
+        for (const [key, value] of Object.entries(row)) {
+            if (isEmpty(value))
+                continue;
+            const property = optionSetUsingTypePropertiesBySlug[key];
+            if (!property)
+                continue;
+            if (skipColumns.has(key))
+                continue;
+            if (property.propertyType === 'choice') {
+                const isValidByValue = property.optionLookupByValue?.[value];
+                const isValidByDisplay = property.optionLookupByDisplay?.[value];
+                if (!isValidByValue && !isValidByDisplay) {
+                    trackMissingValue(issuesByColumn, key, property, String(value), rowNumber);
+                }
+            }
+            else if (property.propertyType === 'multi_select') {
+                const values = String(value)
+                    .split(',')
+                    .map((v) => v.trim());
+                for (const val of values) {
+                    if (!val)
+                        continue;
+                    const isValidByValue = property.optionLookupByValue?.[val];
+                    const isValidByDisplay = property.optionLookupByDisplay?.[val];
+                    if (!isValidByValue && !isValidByDisplay) {
+                        trackMissingValue(issuesByColumn, key, property, val, rowNumber);
+                    }
+                }
+            }
+        }
+    });
+    for (const [columnName, data] of Object.entries(issuesByColumn)) {
+        for (const [missingValue, affectedRows] of data.missingValues) {
+            issues.push({
+                severity: types_2.PreValidationSeverity.ERROR,
+                category: types_2.PreValidationCategory.OPTION_SET,
+                columnName,
+                propertySlug: data.property.slug,
+                propertyType: data.property.propertyType,
+                message: `Value "${missingValue}" is not in the option set for property "${columnName}".`,
+                affectedRows,
+                suggestedFix: {
+                    type: types_2.SuggestedFixType.ADD_OPTION_SET_VALUES,
+                    details: {
+                        propertySlug: data.property.slug,
+                        missingValue,
+                    },
+                },
+            });
+        }
+    }
+    return issues;
+}
+function trackMissingValue(tracker, columnName, property, value, rowNumber) {
+    if (!tracker[columnName]) {
+        tracker[columnName] = { property, missingValues: new Map() };
+    }
+    const existing = tracker[columnName].missingValues.get(value) || [];
+    existing.push({ row: rowNumber, value });
+    tracker[columnName].missingValues.set(value, existing);
+}
+function validateBooleanFormats(rows, typePropertyMaps) {
+    const { typePropertiesBySlug } = typePropertyMaps;
+    const issuesByColumn = {};
+    const validBooleanValues = new Set(['true', 'false', 'yes', 'no', '1', '0']);
+    forEachRow(rows, (row, rowNumber) => {
+        for (const [key, value] of Object.entries(row)) {
+            const property = typePropertiesBySlug[key];
+            if (!property || property.propertyType !== 'boolean')
+                continue;
+            if (isEmpty(value) || typeof value === 'boolean')
+                continue;
+            const strVal = String(value).toLowerCase().trim();
+            if (!validBooleanValues.has(strVal)) {
+                if (!issuesByColumn[key])
+                    issuesByColumn[key] = [];
+                issuesByColumn[key].push({ row: rowNumber, value: String(value) });
+            }
+        }
+    });
+    return Object.entries(issuesByColumn).map(([columnName, affectedRows]) => ({
+        severity: types_2.PreValidationSeverity.WARNING,
+        category: types_2.PreValidationCategory.FORMAT_BOOLEAN,
+        columnName,
+        propertySlug: typePropertiesBySlug[columnName]?.slug ?? columnName,
+        propertyType: 'boolean',
+        message: `Column "${columnName}" contains non-standard boolean values.`,
+        affectedRows,
+    }));
+}
+function validateMultiSelectFormats(rows, typePropertyMaps) {
+    const { optionSetUsingTypePropertiesBySlug } = typePropertyMaps;
+    const issues = [];
+    const semicolonColumns = {};
+    forEachRow(rows, (row, rowNumber) => {
+        for (const [key, value] of Object.entries(row)) {
+            const property = optionSetUsingTypePropertiesBySlug[key];
+            if (!property || property.propertyType !== 'multi_select')
+                continue;
+            if (isEmpty(value))
+                continue;
+            const strVal = String(value);
+            if (strVal.includes(';') && !strVal.includes(',')) {
+                if (!semicolonColumns[key])
+                    semicolonColumns[key] = [];
+                semicolonColumns[key].push({ row: rowNumber, value: strVal });
+            }
+        }
+    });
+    for (const [columnName, affectedRows] of Object.entries(semicolonColumns)) {
+        const property = optionSetUsingTypePropertiesBySlug[columnName];
+        issues.push({
+            severity: types_2.PreValidationSeverity.WARNING,
+            category: types_2.PreValidationCategory.FORMAT_MULTI_SELECT,
+            columnName,
+            propertySlug: property?.slug ?? columnName,
+            propertyType: 'multi_select',
+            message: `Column "${columnName}" appears to use semicolons instead of commas as a multi-select separator.`,
+            affectedRows,
+            suggestedFix: {
+                type: types_2.SuggestedFixType.CHANGE_SEPARATOR,
+                details: { from: ';', to: ',' },
+            },
+        });
+    }
+    return issues;
+}
+function validateItemNames(rows, config) {
+    const itemBasedLoadTypes = [types_2.LoadType.ITEM, types_2.LoadType.PROJECT_ITEM, types_2.LoadType.ASSORTMENT];
+    const isItemBased = config.loadType.some((lt) => itemBasedLoadTypes.includes(lt));
+    if (!isItemBased)
+        return [];
+    const issues = [];
+    const nameKey = 'name';
+    const familyFedIdKey = 'itemFamilyFederatedId';
+    const optionNameKey = 'optionName';
+    const optionFedIdKey = 'itemOptionFederatedId';
+    const emptyNameRows = [];
+    const emptyFamilyFedIdRows = [];
+    const optionFedIdWithoutNameRows = [];
+    const optionNameWithoutFedIdRows = [];
+    forEachRow(rows, (row, rowNumber) => {
+        const nameVal = row[nameKey];
+        if (isEmpty(nameVal)) {
+            emptyNameRows.push({ row: rowNumber, value: String(nameVal ?? '') });
+        }
+        const familyFedIdVal = row[familyFedIdKey];
+        if (isEmpty(familyFedIdVal)) {
+            emptyFamilyFedIdRows.push({ row: rowNumber, value: String(familyFedIdVal ?? '') });
+        }
+        const hasOptionFedId = !isEmpty(row[optionFedIdKey]);
+        const hasOptionName = !isEmpty(row[optionNameKey]);
+        if (hasOptionFedId && !hasOptionName) {
+            optionFedIdWithoutNameRows.push({ row: rowNumber, value: String(row[optionFedIdKey]) });
+        }
+        else if (hasOptionName && !hasOptionFedId) {
+            optionNameWithoutFedIdRows.push({ row: rowNumber, value: String(row[optionNameKey]) });
+        }
+    });
+    if (emptyNameRows.length > 0) {
+        issues.push({
+            severity: types_2.PreValidationSeverity.ERROR,
+            category: MISSING_REQUIRED_FIELD_CATEGORY,
+            columnName: nameKey,
+            propertySlug: 'name',
+            propertyType: 'string',
+            message: `"name" cannot be empty for item families. ${emptyNameRows.length} row(s) have an empty name.`,
+            affectedRows: emptyNameRows,
+        });
+    }
+    if (emptyFamilyFedIdRows.length > 0) {
+        issues.push({
+            severity: types_2.PreValidationSeverity.ERROR,
+            category: MISSING_REQUIRED_FIELD_CATEGORY,
+            columnName: familyFedIdKey,
+            propertySlug: 'itemFamilyFederatedId',
+            propertyType: 'string',
+            message: `"itemFamilyFederatedId" cannot be empty. ${emptyFamilyFedIdRows.length} row(s) have an empty itemFamilyFederatedId.`,
+            affectedRows: emptyFamilyFedIdRows,
+        });
+    }
+    if (optionFedIdWithoutNameRows.length > 0) {
+        issues.push({
+            severity: types_2.PreValidationSeverity.ERROR,
+            category: MISSING_REQUIRED_FIELD_CATEGORY,
+            columnName: optionNameKey,
+            propertySlug: 'optionName',
+            propertyType: 'string',
+            message: `"optionName" is required when "itemOptionFederatedId" is provided. ${optionFedIdWithoutNameRows.length} row(s) have an itemOptionFederatedId but no optionName.`,
+            affectedRows: optionFedIdWithoutNameRows,
+        });
+    }
+    if (optionNameWithoutFedIdRows.length > 0) {
+        issues.push({
+            severity: types_2.PreValidationSeverity.ERROR,
+            category: MISSING_REQUIRED_FIELD_CATEGORY,
+            columnName: optionFedIdKey,
+            propertySlug: 'itemOptionFederatedId',
+            propertyType: 'string',
+            message: `"itemOptionFederatedId" is required when "optionName" is provided. ${optionNameWithoutFedIdRows.length} row(s) have an optionName but no itemOptionFederatedId.`,
+            affectedRows: optionNameWithoutFedIdRows,
+        });
+    }
+    return issues;
+}
+function validateTypePathExistence(typesByPath) {
+    const issues = [];
+    for (const [typePath, entry] of Object.entries(typesByPath)) {
+        if (entry.error) {
+            issues.push({
+                severity: types_2.PreValidationSeverity.ERROR,
+                category: CONFIG_CATEGORY,
+                columnName: 'typePath',
+                propertySlug: '',
+                propertyType: '',
+                message: `Type "${typePath}" does not exist. Check that the typePath is correct.`,
+                affectedRows: [],
+            });
+        }
+    }
+    return issues;
+}
+function validateFamilyPropertyConsistency(rows, config, typesByPath) {
+    const itemBasedLoadTypes = [types_2.LoadType.ITEM, types_2.LoadType.PROJECT_ITEM, types_2.LoadType.ASSORTMENT];
+    const isItemBased = config.loadType.some((lt) => itemBasedLoadTypes.includes(lt));
+    if (!isItemBased)
+        return [];
+    const familyPropertyLevels = {};
+    const typesWithFamilyLevels = new Set(['item', 'project-item']);
+    for (const typePath of Object.keys(typesByPath)) {
+        if (!typesWithFamilyLevels.has(typePath))
+            continue;
+        const typeObj = typesByPath[typePath];
+        if (!typeObj?.type?.typeProperties)
+            continue;
+        for (const prop of typeObj.type.typeProperties) {
+            if (isFamilyLevelProperty(prop.propertyLevel)) {
+                const level = prop.propertyLevel || 'family-default';
+                familyPropertyLevels[prop.slug] = level;
+                if (prop.propertyLevel === types_1.PropertyLevel.OVERRIDABLE) {
+                    familyPropertyLevels[prop.slug + 'Family'] = types_1.PropertyLevel.FAMILY;
+                }
+            }
+        }
+    }
+    const familyPropertySlugs = new Set(Object.keys(familyPropertyLevels));
+    if (familyPropertySlugs.size === 0)
+        return [];
+    const familyGroups = {};
+    forEachRow(rows, (row, rowNumber) => {
+        const famId = row.itemFamilyFederatedId;
+        if (!famId)
+            return;
+        if (!familyGroups[famId]) {
+            familyGroups[famId] = { rows: [], rowNumbers: [] };
+        }
+        familyGroups[famId].rows.push(row);
+        familyGroups[famId].rowNumbers.push(rowNumber);
+    });
+    const issues = [];
+    const inconsistenciesBySlug = {};
+    for (const [famId, group] of Object.entries(familyGroups)) {
+        if (group.rows.length <= 1)
+            continue;
+        for (const slug of familyPropertySlugs) {
+            const valuesWithRows = new Map();
+            for (let i = 0; i < group.rows.length; i++) {
+                const row = group.rows[i];
+                if (!(slug in row))
+                    continue;
+                const val = String(row[slug] ?? '');
+                const existing = valuesWithRows.get(val) || [];
+                existing.push(group.rowNumbers[i]);
+                valuesWithRows.set(val, existing);
+            }
+            if (valuesWithRows.size <= 1)
+                continue;
+            if (!inconsistenciesBySlug[slug]) {
+                inconsistenciesBySlug[slug] = { families: [] };
+            }
+            inconsistenciesBySlug[slug].families.push({
+                familyId: famId,
+                values: new Set(valuesWithRows.keys()),
+                rowNumbers: group.rowNumbers,
+            });
+        }
+    }
+    for (const [slug, data] of Object.entries(inconsistenciesBySlug)) {
+        const affectedRows = [];
+        const familyDetails = [];
+        for (const family of data.families) {
+            const valuesStr = Array.from(family.values).map((v) => `"${v}"`).join(', ');
+            familyDetails.push(`family "${family.familyId}" has values: ${valuesStr}`);
+            for (const rowNum of family.rowNumbers) {
+                affectedRows.push({ row: rowNum, value: slug });
+            }
+        }
+        const level = familyPropertyLevels[slug];
+        let message;
+        if (level === types_1.PropertyLevel.FAMILY || level === 'family-default') {
+            message = `Family-level property "${slug}" has inconsistent values across rows for the same family. All rows sharing an itemFamilyFederatedId must have the same value for family properties. ${familyDetails.join('; ')}.`;
+        }
+        else if (level === types_1.PropertyLevel.ALL) {
+            message = `All-level property "${slug}" has inconsistent values across rows for the same family. Without a "Family"/"Option" suffix, this column applies the same value to both family and option — so all rows for the same itemFamilyFederatedId must agree. If you need different values per option, split this into "${slug}Family" and "${slug}Option" columns. ${familyDetails.join('; ')}.`;
+        }
+        else if (level === types_1.PropertyLevel.OVERRIDABLE) {
+            message = `Override-level property "${slug}" has inconsistent values across rows for the same family. Without a "Family"/"Option" suffix, this column applies the same value to both family and option — so all rows for the same itemFamilyFederatedId must agree. If you need different values per option, split this into "${slug}Family" and "${slug}Option" columns. ${familyDetails.join('; ')}.`;
+        }
+        else {
+            message = `Property "${slug}" has inconsistent values across rows for the same family. All rows sharing an itemFamilyFederatedId must have the same value. ${familyDetails.join('; ')}.`;
+        }
+        issues.push({
+            severity: types_2.PreValidationSeverity.ERROR,
+            category: FAMILY_INCONSISTENT_CATEGORY,
+            columnName: slug,
+            propertySlug: slug,
+            propertyType: '',
+            message,
+            affectedRows,
+        });
+    }
+    return issues;
+}
+function isFamilyLevelProperty(propertyLevel) {
+    if (!propertyLevel)
+        return true;
+    return [
+        types_1.PropertyLevel.FAMILY,
+        types_1.PropertyLevel.ALL,
+        types_1.PropertyLevel.OVERRIDABLE,
+    ].includes(propertyLevel);
+}
+function validateAllOverrideSuffixes(rows, config, columnAnalysis) {
+    const loadTypeHasRoles = [types_2.LoadType.ITEM, types_2.LoadType.PROJECT_ITEM];
+    const hasRoles = config.loadType.some((lt) => loadTypeHasRoles.includes(lt));
+    if (!hasRoles)
+        return [];
+    const allOverrideSlugs = new Set();
+    const allOverrideLabels = new Map();
+    for (const typePath of Object.keys(columnAnalysis.typesByPath)) {
+        const typeObj = columnAnalysis.typesByPath[typePath];
+        if (!typeObj?.type?.typeProperties)
+            continue;
+        for (const prop of typeObj.type.typeProperties) {
+            if (prop.propertyLevel === types_1.PropertyLevel.ALL ||
+                prop.propertyLevel === types_1.PropertyLevel.OVERRIDABLE) {
+                allOverrideSlugs.add(prop.slug);
+                if (prop.label) {
+                    allOverrideLabels.set(prop.label, prop.slug);
+                }
+            }
+        }
+    }
+    if (allOverrideSlugs.size === 0)
+        return [];
+    const issues = [];
+    const csvHeaders = rows.length > 0 ? Object.keys(rows[0]) : [];
+    for (const header of csvHeaders) {
+        const matchedSlug = allOverrideSlugs.has(header)
+            ? header
+            : allOverrideLabels.get(header);
+        if (!matchedSlug)
+            continue;
+        const affectedRows = [];
+        forEachRow(rows, (row, rowNumber) => {
+            const val = row[header];
+            if (!isEmpty(val)) {
+                affectedRows.push({ row: rowNumber, value: String(val) });
+            }
+        });
+        if (affectedRows.length === 0) {
+            affectedRows.push({ row: 2, value: '' });
+        }
+        issues.push({
+            severity: types_2.PreValidationSeverity.ERROR,
+            category: CONFIG_CATEGORY,
+            columnName: header,
+            propertySlug: matchedSlug,
+            propertyType: '',
+            message: `Column "${header}" targets an all-level or override-level property without a "Family" or "Option" suffix. The loader cannot determine whether this value should apply to the family, the option, or both. Use "${matchedSlug}Family" and/or "${matchedSlug}Option" columns instead.`,
+            affectedRows,
+        });
+    }
+    return issues;
+}
+async function validateAndResolveProjectIdentifiers(rows, config, client) {
+    const isProjectItemLoad = config.loadType.some((lt) => lt === types_2.LoadType.PROJECT_ITEM);
+    if (!isProjectItemLoad)
+        return [];
+    const hasWorkspaceIdentifier = rows.some((row) => row.workspaceIdentifier);
+    if (hasWorkspaceIdentifier) {
+        return validateWorkspaceIdentifiers(rows, client);
+    }
+    return validateProjectIds(rows, client);
+}
+async function validateWorkspaceIdentifiers(rows, client) {
+    const issues = [];
+    const cache = {};
+    const uniqueIdentifiers = new Set();
+    for (const row of rows) {
+        if (row.workspaceIdentifier)
+            uniqueIdentifiers.add(row.workspaceIdentifier);
+    }
+    for (const wsIdentifier of uniqueIdentifiers) {
+        try {
+            const project = await resolveProjectIdFromWorkspace(client, wsIdentifier);
+            cache[wsIdentifier] = project;
+            if (!project) {
+                const affectedRows = [];
+                rows.forEach((row, index) => {
+                    if (row.workspaceIdentifier === wsIdentifier) {
+                        affectedRows.push({ row: index + 2, value: wsIdentifier });
+                    }
+                });
+                issues.push({
+                    severity: types_2.PreValidationSeverity.ERROR,
+                    category: REFERENCE_NOT_FOUND_CATEGORY,
+                    columnName: 'workspaceIdentifier',
+                    propertySlug: 'workspaceIdentifier',
+                    propertyType: 'string',
+                    message: `Could not resolve workspace identifier "${wsIdentifier}" to a project. Verify the workspace exists and is a PROJECT type workspace.`,
+                    affectedRows,
+                });
+            }
+        }
+        catch (e) {
+            issues.push({
+                severity: types_2.PreValidationSeverity.ERROR,
+                category: REFERENCE_NOT_FOUND_CATEGORY,
+                columnName: 'workspaceIdentifier',
+                propertySlug: 'workspaceIdentifier',
+                propertyType: 'string',
+                message: `Failed to resolve workspace identifier "${wsIdentifier}": ${e.message}`,
+                affectedRows: [],
+            });
+        }
+    }
+    if (issues.length === 0) {
+        for (const row of rows) {
+            if (row.workspaceIdentifier) {
+                const project = cache[row.workspaceIdentifier];
+                row.projectId = project.id;
+                row.projectName = project.name;
+                delete row.workspaceIdentifier;
+            }
+        }
+    }
+    return issues;
+}
+async function validateProjectIds(rows, client) {
+    const issues = [];
+    const nameCache = {};
+    const uniqueProjectIds = new Set();
+    for (const row of rows) {
+        if (row.projectId)
+            uniqueProjectIds.add(row.projectId);
+    }
+    if (uniqueProjectIds.size === 0)
+        return [];
+    for (const projectId of uniqueProjectIds) {
+        try {
+            const project = await (0, entities_helper_1.retryOnTimeout)(client, entities_helper_1.EntitiesLambdaCallType.GET, {
+                entityName: 'project',
+                id: projectId,
+                skipHydrateRelationships: true,
+            });
+            if (!project) {
+                const affectedRows = [];
+                rows.forEach((row, index) => {
+                    if (row.projectId === projectId) {
+                        affectedRows.push({ row: index + 2, value: projectId });
+                    }
+                });
+                issues.push({
+                    severity: types_2.PreValidationSeverity.ERROR,
+                    category: REFERENCE_NOT_FOUND_CATEGORY,
+                    columnName: 'projectId',
+                    propertySlug: 'projectId',
+                    propertyType: 'string',
+                    message: `Project "${projectId}" not found. Verify the project ID is correct and the project exists.`,
+                    affectedRows,
+                });
+            }
+            else {
+                nameCache[projectId] = project.name || project.identifier || projectId;
+            }
+        }
+        catch (e) {
+            const affectedRows = [];
+            rows.forEach((row, index) => {
+                if (row.projectId === projectId) {
+                    affectedRows.push({ row: index + 2, value: projectId });
+                }
+            });
+            issues.push({
+                severity: types_2.PreValidationSeverity.ERROR,
+                category: REFERENCE_NOT_FOUND_CATEGORY,
+                columnName: 'projectId',
+                propertySlug: 'projectId',
+                propertyType: 'string',
+                message: `Failed to validate project "${projectId}": ${e.message}`,
+                affectedRows,
+            });
+        }
+    }
+    if (issues.length === 0) {
+        for (const row of rows) {
+            if (row.projectId && nameCache[row.projectId]) {
+                row.projectName = nameCache[row.projectId];
+            }
+        }
+    }
+    return issues;
+}
+async function resolveProjectIdFromWorkspace(client, workspaceIdentifier) {
+    const workspaces = await (0, entities_helper_1.retryOnTimeout)(client, entities_helper_1.EntitiesLambdaCallType.GET, {
+        entityName: 'workspace',
+        criteria: {
+            identifier: workspaceIdentifier,
+            workspaceType: 'PROJECT',
+        },
+        skipHydrateRelationships: true,
+    });
+    if (!workspaces?.length)
+        return null;
+    const workspaceId = workspaces[0]?.id;
+    if (!workspaceId)
+        return null;
+    const workspace = await (0, entities_helper_1.retryOnTimeout)(client, entities_helper_1.EntitiesLambdaCallType.GET, {
+        entityName: 'workspace',
+        id: workspaceId,
+        relations: ['project'],
+        skipHydrateRelationships: true,
+    });
+    const project = workspace?.project;
+    if (!project?.id)
+        return null;
+    return { id: project.id, name: project.name || project.id };
+}
+function validateProjectItemColumns(rows, config) {
+    const isProjectItemLoad = config.loadType.some((lt) => lt === types_2.LoadType.PROJECT_ITEM);
+    if (!isProjectItemLoad)
+        return [];
+    const issues = [];
+    const hasWorkspaceIdentifier = rows.some((row) => row.workspaceIdentifier !== undefined);
+    const hasProjectId = rows.some((row) => row.projectId !== undefined);
+    if (hasWorkspaceIdentifier && hasProjectId) {
+        issues.push({
+            severity: types_2.PreValidationSeverity.ERROR,
+            category: CONFIG_CATEGORY,
+            columnName: 'workspaceIdentifier / projectId',
+            propertySlug: '',
+            propertyType: '',
+            message: 'Rows contain both "workspaceIdentifier" and "projectId" columns. Use one or the other to identify the target project.',
+            affectedRows: [],
+        });
+        return issues;
+    }
+    if (!hasWorkspaceIdentifier && !hasProjectId) {
+        issues.push({
+            severity: types_2.PreValidationSeverity.ERROR,
+            category: CONFIG_CATEGORY,
+            columnName: 'workspaceIdentifier / projectId',
+            propertySlug: '',
+            propertyType: '',
+            message: 'PROJECT_ITEM loads require a "workspaceIdentifier" or "projectId" column (or a config-level workspaceIdentifier) to identify the target project.',
+            affectedRows: [],
+        });
+        return issues;
+    }
+    const columnName = hasWorkspaceIdentifier ? 'workspaceIdentifier' : 'projectId';
+    const emptyRows = [];
+    forEachRow(rows, (row, rowNumber) => {
+        if (isEmpty(row[columnName])) {
+            emptyRows.push({ row: rowNumber, value: '' });
+        }
+    });
+    if (emptyRows.length > 0) {
+        issues.push({
+            severity: types_2.PreValidationSeverity.ERROR,
+            category: MISSING_REQUIRED_FIELD_CATEGORY,
+            columnName,
+            propertySlug: columnName,
+            propertyType: 'string',
+            message: `"${columnName}" cannot be empty for project-item rows. ${emptyRows.length} row(s) have an empty value.`,
+            affectedRows: emptyRows,
+        });
+    }
+    return issues;
+}
+function validateStaticIdentifierConflicts(config) {
+    const issues = [];
+    const conditionalTargets = new Set((config.conditionalColumns || []).map((col) => col.toProperty));
+    const staticFields = [
+        { field: 'workspaceIdentifier', value: config.workspaceIdentifier },
+        { field: 'projectId', value: config.projectId },
+        { field: 'assortmentId', value: config.assortmentId },
+        { field: 'assortmentIdentifier', value: config.assortmentIdentifier },
+    ];
+    for (const { field, value } of staticFields) {
+        if (value && conditionalTargets.has(field)) {
+            issues.push({
+                severity: types_2.PreValidationSeverity.ERROR,
+                category: CONFIG_CATEGORY,
+                columnName: field,
+                propertySlug: field,
+                propertyType: 'string',
+                message: `"${field}" is set as a static config value and also as a conditionalColumns target. Use one or the other.`,
+                affectedRows: [],
+            });
+        }
+    }
+    return issues;
+}
+function validateAssortmentColumns(rows, config) {
+    const isAssortmentLoad = config.loadType.some((lt) => lt === types_2.LoadType.ASSORTMENT);
+    if (!isAssortmentLoad)
+        return [];
+    const issues = [];
+    const hasAssortmentId = rows.some((row) => row.assortmentId !== undefined);
+    const hasAssortmentIdentifier = rows.some((row) => row.assortmentIdentifier !== undefined);
+    const assortmentIdFromConditions = (config.conditionalColumns || []).some((col) => (col.toProperty === 'assortmentId' || col.toProperty === 'assortmentIdentifier') && col.conditions?.length);
+    if (!hasAssortmentId && !hasAssortmentIdentifier) {
+        issues.push({
+            severity: types_2.PreValidationSeverity.ERROR,
+            category: CONFIG_CATEGORY,
+            columnName: 'assortmentId / assortmentIdentifier',
+            propertySlug: '',
+            propertyType: '',
+            message: 'ASSORTMENT loads require an "assortmentId" or "assortmentIdentifier" column (or a config-level assortmentId/assortmentIdentifier) to identify the target assortment.',
+            affectedRows: [],
+        });
+        return issues;
+    }
+    const bothRows = [];
+    forEachRow(rows, (row, rowNumber) => {
+        const hasId = !isEmpty(row.assortmentId);
+        const hasIdent = !isEmpty(row.assortmentIdentifier);
+        if (hasId && hasIdent) {
+            bothRows.push({ row: rowNumber, value: `${row.assortmentId} / ${row.assortmentIdentifier}` });
+        }
+    });
+    if (bothRows.length > 0) {
+        issues.push({
+            severity: types_2.PreValidationSeverity.ERROR,
+            category: CONFIG_CATEGORY,
+            columnName: 'assortmentId / assortmentIdentifier',
+            propertySlug: '',
+            propertyType: '',
+            message: `${bothRows.length} row(s) have both "assortmentId" and "assortmentIdentifier". Each row must use one or the other.`,
+            affectedRows: bothRows,
+        });
+        return issues;
+    }
+    const emptyIdRows = [];
+    const emptyIdentRows = [];
+    forEachRow(rows, (row, rowNumber) => {
+        if (hasAssortmentId && row.assortmentId !== undefined) {
+            if (isEmpty(row.assortmentId)) {
+                emptyIdRows.push({ row: rowNumber, value: '' });
+            }
+        }
+        else if (hasAssortmentId && row.assortmentId === undefined && !assortmentIdFromConditions) {
+            emptyIdRows.push({ row: rowNumber, value: '' });
+        }
+        if (hasAssortmentIdentifier && row.assortmentIdentifier !== undefined) {
+            if (isEmpty(row.assortmentIdentifier)) {
+                emptyIdentRows.push({ row: rowNumber, value: '' });
+            }
+        }
+    });
+    if (emptyIdRows.length > 0) {
+        issues.push({
+            severity: types_2.PreValidationSeverity.ERROR,
+            category: MISSING_REQUIRED_FIELD_CATEGORY,
+            columnName: 'assortmentId',
+            propertySlug: 'assortmentId',
+            propertyType: 'string',
+            message: `"assortmentId" cannot be empty for assortment rows. ${emptyIdRows.length} row(s) have an empty value.`,
+            affectedRows: emptyIdRows,
+        });
+    }
+    if (emptyIdentRows.length > 0) {
+        issues.push({
+            severity: types_2.PreValidationSeverity.ERROR,
+            category: MISSING_REQUIRED_FIELD_CATEGORY,
+            columnName: 'assortmentIdentifier',
+            propertySlug: 'assortmentIdentifier',
+            propertyType: 'string',
+            message: `"assortmentIdentifier" cannot be empty for assortment rows. ${emptyIdentRows.length} row(s) have an empty value.`,
+            affectedRows: emptyIdentRows,
+        });
+    }
+    return issues;
+}
+async function validateAndResolveAssortmentIdentifiers(rows, config, client) {
+    const isAssortmentLoad = config.loadType.some((lt) => lt === types_2.LoadType.ASSORTMENT);
+    if (!isAssortmentLoad)
+        return [];
+    const hasAssortmentIdentifier = rows.some((row) => row.assortmentIdentifier);
+    if (hasAssortmentIdentifier) {
+        return resolveAssortmentIdentifiers(rows, client);
+    }
+    return validateAssortmentIds(rows, client);
+}
+async function resolveAssortmentIdentifiers(rows, client) {
+    const issues = [];
+    const cache = {};
+    const uniqueIdentifiers = new Set();
+    for (const row of rows) {
+        if (row.assortmentIdentifier)
+            uniqueIdentifiers.add(row.assortmentIdentifier);
+    }
+    for (const identifier of uniqueIdentifiers) {
+        try {
+            const assortments = await (0, entities_helper_1.retryOnTimeout)(client, entities_helper_1.EntitiesLambdaCallType.GET, {
+                entityName: 'assortment',
+                criteria: { identifier },
+                skipHydrateRelationships: true,
+            });
+            if (!assortments?.length) {
+                cache[identifier] = null;
+                const affectedRows = [];
+                rows.forEach((row, index) => {
+                    if (row.assortmentIdentifier === identifier) {
+                        affectedRows.push({ row: index + 2, value: identifier });
+                    }
+                });
+                issues.push({
+                    severity: types_2.PreValidationSeverity.ERROR,
+                    category: REFERENCE_NOT_FOUND_CATEGORY,
+                    columnName: 'assortmentIdentifier',
+                    propertySlug: 'assortmentIdentifier',
+                    propertyType: 'string',
+                    message: `Assortment with identifier "${identifier}" not found. Verify the identifier is correct and the assortment exists.`,
+                    affectedRows,
+                });
+            }
+            else {
+                const assortment = assortments[0];
+                cache[identifier] = { id: assortment.id, name: assortment.name || assortment.id };
+            }
+        }
+        catch (e) {
+            issues.push({
+                severity: types_2.PreValidationSeverity.ERROR,
+                category: REFERENCE_NOT_FOUND_CATEGORY,
+                columnName: 'assortmentIdentifier',
+                propertySlug: 'assortmentIdentifier',
+                propertyType: 'string',
+                message: `Failed to resolve assortment identifier "${identifier}": ${e.message}`,
+                affectedRows: [],
+            });
+        }
+    }
+    if (issues.length === 0) {
+        for (const row of rows) {
+            if (row.assortmentIdentifier) {
+                const assortment = cache[row.assortmentIdentifier];
+                row.assortmentId = assortment.id;
+                row.assortmentName = assortment.name;
+                delete row.assortmentIdentifier;
+            }
+        }
+    }
+    return issues;
+}
+async function validateAssortmentIds(rows, client) {
+    const issues = [];
+    const nameCache = {};
+    const uniqueIds = new Set();
+    for (const row of rows) {
+        if (row.assortmentId)
+            uniqueIds.add(row.assortmentId);
+    }
+    if (uniqueIds.size === 0)
+        return [];
+    for (const assortmentId of uniqueIds) {
+        try {
+            const assortment = await (0, entities_helper_1.retryOnTimeout)(client, entities_helper_1.EntitiesLambdaCallType.GET, {
+                entityName: 'assortment',
+                id: assortmentId,
+                skipHydrateRelationships: true,
+            });
+            if (assortment) {
+                nameCache[assortmentId] = assortment.name || assortmentId;
+            }
+        }
+        catch (e) {
+            const affectedRows = [];
+            rows.forEach((row, index) => {
+                if (row.assortmentId === assortmentId) {
+                    affectedRows.push({ row: index + 2, value: assortmentId });
+                }
+            });
+            const parsedDetails = typeof e?.details === 'string' ? JSON.parse(e.details).statusCode : e?.details?.statusCode;
+            const message = parsedDetails === 404
+                ? `Assortment "${assortmentId}" not found. Verify the assortment ID is correct and the assortment exists.`
+                : `Failed to validate assortment "${assortmentId}": ${e.message}`;
+            issues.push({
+                severity: types_2.PreValidationSeverity.ERROR,
+                category: REFERENCE_NOT_FOUND_CATEGORY,
+                columnName: 'assortmentId',
+                propertySlug: 'assortmentId',
+                propertyType: 'string',
+                message,
+                affectedRows,
+            });
+        }
+    }
+    if (issues.length === 0) {
+        for (const row of rows) {
+            if (row.assortmentId && nameCache[row.assortmentId]) {
+                row.assortmentName = nameCache[row.assortmentId];
+            }
+        }
+    }
+    return issues;
+}
+function validatePartialAssortmentConfig(rows, config) {
+    const isAssortmentLoad = config.loadType.some((lt) => lt === types_2.LoadType.ASSORTMENT);
+    if (!isAssortmentLoad || !config.partialAssortmentUpdate)
+        return [];
+    const issues = [];
+    if (!config.assortmentItemDropField) {
+        issues.push({
+            severity: types_2.PreValidationSeverity.ERROR,
+            category: CONFIG_CATEGORY,
+            columnName: 'assortmentItemDropField',
+            propertySlug: 'assortmentItemDropField',
+            propertyType: 'string',
+            message: 'partialAssortmentUpdate is enabled but assortmentItemDropField is not set. Specify which column identifies items to drop.',
+            affectedRows: [],
+        });
+        return issues;
+    }
+    const hasDropField = rows.some((row) => row[config.assortmentItemDropField] !== undefined);
+    if (!hasDropField) {
+        issues.push({
+            severity: types_2.PreValidationSeverity.ERROR,
+            category: CONFIG_CATEGORY,
+            columnName: config.assortmentItemDropField,
+            propertySlug: config.assortmentItemDropField,
+            propertyType: 'string',
+            message: `partialAssortmentUpdate requires the drop field column "${config.assortmentItemDropField}" to be present in the data.`,
+            affectedRows: [],
+        });
+    }
+    return issues;
+}
+function validateSelfReferences(rows, config, typesByPath) {
+    const itemBasedLoadTypes = [types_2.LoadType.ITEM, types_2.LoadType.PROJECT_ITEM, types_2.LoadType.ASSORTMENT];
+    const isItemBased = config.loadType.some((lt) => itemBasedLoadTypes.includes(lt));
+    const columnChecks = buildObjectRefColumnChecks(typesByPath, isItemBased);
+    if (columnChecks.length === 0)
+        return [];
+    const selfRefsByColumn = {};
+    forEachRow(rows, (row, rowNumber) => {
+        for (const check of columnChecks) {
+            const refValue = row[check.columnName];
+            if (isEmpty(refValue))
+                continue;
+            const refStr = String(refValue);
+            for (const fedIdKey of check.federatedIdKeys) {
+                const ownId = row[fedIdKey];
+                if (!ownId)
+                    continue;
+                if (refStr === String(ownId)) {
+                    if (!selfRefsByColumn[check.columnName])
+                        selfRefsByColumn[check.columnName] = [];
+                    selfRefsByColumn[check.columnName].push({ row: rowNumber, value: refStr });
+                    break;
+                }
+            }
+        }
+    });
+    const issues = [];
+    for (const [columnName, affectedRows] of Object.entries(selfRefsByColumn)) {
+        issues.push({
+            severity: types_2.PreValidationSeverity.ERROR,
+            category: SELF_REFERENCE_CATEGORY,
+            columnName,
+            propertySlug: columnName,
+            propertyType: 'object_reference',
+            message: `Object reference property "${columnName}" contains self-referencing values. ${affectedRows.length} row(s) reference their own federatedId, which creates circular references and causes issues with publishing and data integrity.`,
+            affectedRows,
+        });
+    }
+    return issues;
+}
+function buildObjectRefColumnChecks(typesByPath, isItemBased) {
+    const checks = [];
+    for (const typePath of Object.keys(typesByPath)) {
+        const typeObj = typesByPath[typePath];
+        for (const prop of typeObj?.objectReferenceProperties ?? []) {
+            if (!isItemBased) {
+                checks.push({ columnName: prop.slug, federatedIdKeys: ['federatedId'] });
+                continue;
+            }
+            const level = prop.propertyLevel;
+            if (level === types_1.PropertyLevel.FAMILY) {
+                checks.push({ columnName: prop.slug, federatedIdKeys: ['itemFamilyFederatedId'] });
+            }
+            else if (level === types_1.PropertyLevel.OPTION) {
+                checks.push({ columnName: prop.slug, federatedIdKeys: ['itemOptionFederatedId'] });
+            }
+            else if (level === types_1.PropertyLevel.OVERRIDABLE || level === types_1.PropertyLevel.ALL) {
+                checks.push({ columnName: prop.slug + 'Family', federatedIdKeys: ['itemFamilyFederatedId'] });
+                checks.push({ columnName: prop.slug + 'Option', federatedIdKeys: ['itemOptionFederatedId'] });
+            }
+            else {
+                checks.push({ columnName: prop.slug, federatedIdKeys: ['itemFamilyFederatedId'] });
+            }
+        }
+    }
+    return checks;
+}
+const NUMERIC_PROPERTY_TYPES = new Set(['number', 'currency', 'percent', 'sequence']);
+function validateNumberPrecision(rows, typePropertyMaps) {
+    const { typePropertiesBySlug } = typePropertyMaps;
+    const issuesByColumn = {};
+    rows.forEach((row, index) => {
+        const rowNumber = index + 2;
+        for (const [key, value] of Object.entries(row)) {
+            const property = typePropertiesBySlug[key];
+            if (!property || !NUMERIC_PROPERTY_TYPES.has(property.propertyType))
+                continue;
+            const precision = property.numberFormat?.precision;
+            if (precision === null || precision === undefined)
+                continue;
+            if (typeof value !== 'number')
+                continue;
+            if (Number(value.toFixed(precision)) !== value) {
+                if (!issuesByColumn[key])
+                    issuesByColumn[key] = { affectedRows: [], precision };
+                issuesByColumn[key].affectedRows.push({ row: rowNumber, value: String(value) });
+            }
+        }
+    });
+    return Object.entries(issuesByColumn).map(([columnName, { affectedRows, precision }]) => ({
+        severity: types_2.PreValidationSeverity.WARNING,
+        category: types_2.PreValidationCategory.FORMAT_NUMBER_PRECISION,
+        columnName,
+        propertySlug: typePropertiesBySlug[columnName]?.slug ?? columnName,
+        propertyType: typePropertiesBySlug[columnName]?.propertyType ?? 'number',
+        message: `Column "${columnName}" contains values that exceed the configured precision of ${precision} decimal place${precision === 1 ? '' : 's'}. These values will be truncated when saved.`,
+        affectedRows,
+    }));
+}
+function generateUnmappedWarnings(columnAnalysis) {
+    const issues = [];
+    for (const col of columnAnalysis.columns) {
+        if (!col.isMapped) {
+            issues.push({
+                severity: types_2.PreValidationSeverity.WARNING,
+                category: types_2.PreValidationCategory.UNMAPPED_COLUMN,
+                columnName: col.csvHeader,
+                propertySlug: '',
+                propertyType: '',
+                message: `CSV column '${col.csvHeader}' does not match any property on the type definition`,
+                affectedRows: [],
+            });
+        }
+    }
+    for (const prop of columnAnalysis.unmappedTypeProperties) {
+        issues.push({
+            severity: types_2.PreValidationSeverity.WARNING,
+            category: types_2.PreValidationCategory.UNMAPPED_TYPE_PROPERTY,
+            columnName: '',
+            propertySlug: prop.slug,
+            propertyType: prop.propertyType ?? '',
+            message: `Type property key '${prop.slug}' with label '${prop.label}' has no corresponding column in the CSV`,
+            affectedRows: [],
+        });
+    }
+    return issues;
+}
+function buildResult(issues) {
+    let errorCount = 0;
+    let warningCount = 0;
+    let infoCount = 0;
+    const countsByCategory = {};
+    for (const issue of issues) {
+        if (issue.severity === types_2.PreValidationSeverity.ERROR)
+            errorCount++;
+        else if (issue.severity === types_2.PreValidationSeverity.WARNING)
+            warningCount++;
+        else
+            infoCount++;
+        countsByCategory[issue.category] = (countsByCategory[issue.category] || 0) + 1;
+    }
+    return {
+        valid: errorCount === 0,
+        issues,
+        summary: {
+            errorCount,
+            warningCount,
+            infoCount,
+            countsByCategory,
+        },
+    };
+}