@contrail/cli 3.5.0 → 3.5.1-alpha.64bf880

package/dist/commands/types/uploadTypePropertyPolicies.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findAllOccurrences = exports.uploadTypePropertyPolicies = void 0;
+exports.uploadTypePropertyPolicies = void 0;
 const tslib_1 = require("tslib");
 const sdk_1 = require("@contrail/sdk");
 const fs_1 = tslib_1.__importDefault(require("fs"));
@@ -8,12 +8,10 @@ const path = tslib_1.__importStar(require("path"));
 const login_1 = require("../../auth/login");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const core_1 = require("@oclif/core");
-const type_extractor_1 = require("../../helpers/types/type-extractor");
 const users_1 = require("../../api/users");
 const basecommand_1 = require("../../basecommand");
 const logger_1 = tslib_1.__importDefault(require("../../logger"));
 const js_yaml_1 = tslib_1.__importDefault(require("js-yaml"));
-const _ = tslib_1.__importStar(require("lodash"));
 class UploadTypePropertyPolicies extends basecommand_1.BaseCommand {
     static description = 'Upload type property policies';
     static examples = [
@@ -38,14 +36,12 @@ async function uploadTypePropertyPolicies(dir) {
     try {
         await (0, login_1.authUser)();
         logger_1.default.info(`${chalk_1.default.yellow.bold('TYPE PROPERTY POLICY')} Uploading`);
-        const [reducedTypePropertyPolicies, reducedTypePropertyPolicyLinks] = await loadTPPolicies(dir);
+        const reducedTypePropertyPolicies = await loadTPPolicies(dir);
         await uploadTPPolicyObjects(reducedTypePropertyPolicies);
-        await uploadTypePropertyPolicyLinks(reducedTypePropertyPolicyLinks);
         logger_1.default.info(`${chalk_1.default.yellow.bold('TYPE PROPERTY POLICY')} Uploaded`);
     }
     catch (e) {
         logger_1.default.info(`${chalk_1.default.red.bold('FAIL')} Type Property Policy Upload Failed . ${e}`);
-        //TODO make this only print if a debug flag is set
         console.trace(e);
         return;
     }
@@ -54,15 +50,13 @@ async function uploadTypePropertyPolicies(dir) {
 exports.uploadTypePropertyPolicies = uploadTypePropertyPolicies;
 function loadTPPolicies(fromDir) {
     const tpps = [];
-    let tppLinks = [];
     const dir = path.join(fromDir, 'type-property-policies');
     try {
         const files = fs_1.default.readdirSync(dir);
         for (const file of files) {
             tpps.push(js_yaml_1.default.load(fs_1.default.readFileSync(path.join(dir, file), 'utf8')));
         }
-        tppLinks = js_yaml_1.default.load(fs_1.default.readFileSync(path.join(fromDir, 'type-property-policy-links.yml'), 'utf8'));
-        return [tpps, tppLinks];
+        return tpps;
     }
     catch (e) {
         throw new Error(`ERROR PARSING YAML: ${e}`);
@@ -155,133 +149,3 @@ async function uploadTPPolicyObjects(reducedTypePropertyPolicies) {
         }
     }
 }
-async function uploadTypePropertyPolicyLinks(reducedTypePropertyPolicyLinks) {
-    const typesWithProperties = await (0, type_extractor_1.getTypes)();
-    const typeProperties = [];
-    typesWithProperties.forEach((type) => {
-        if (type.typeProperties) {
-            for (const tp of type.typeProperties) {
-                tp.typeId = type.id;
-                tp.typeSlug = type.slug;
-                typeProperties.push(tp);
-            }
-        }
-    });
-    const currentTPPs = await new sdk_1.Entities().get({
-        entityName: 'type-property-policy',
-    });
-    const currentTPPLinks = await new sdk_1.Entities().get({
-        entityName: 'type-property-policy-link',
-    });
-    logger_1.default.info(`found ${currentTPPLinks.length} current type property policy links`);
-    logger_1.default.info(`found ${reducedTypePropertyPolicyLinks.length} type property policy links to load`);
-    const currentLinksHashes = {};
-    for (const currentLink of currentTPPLinks) {
-        const foundTPs = findAllOccurrences(typeProperties, (tp) => tp.id === currentLink.typePropertyId);
-        for (const foundTP of foundTPs) {
-            const foundTPP = currentTPPs.find((tpp) => tpp.id === currentLink.typePropertyPolicyId);
-            if (!foundTP || !foundTPP) {
-                logger_1.default.info(`skipping unhashable, invalid policy link: ${JSON.stringify(currentLink, null, 2)}`);
-                continue;
-            }
-            const hash = `${foundTP.typeSlug}|${foundTP.slug}|${foundTPP.identifier}`;
-            currentLinksHashes[hash] = currentLink;
-        }
-    }
-    logger_1.default.debug(`current links hashes: ${JSON.stringify(currentLinksHashes, null, 2)}`);
-    const reducedLinksByHashes = {};
-    for (const loadedLink of reducedTypePropertyPolicyLinks) {
-        const hash = `${loadedLink.typeSlug}|${loadedLink.typePropertySlug}|${loadedLink.typePropertyPolicyIdentifier}`;
-        reducedLinksByHashes[hash] = loadedLink;
-    }
-    const toCreate = Object.keys(reducedLinksByHashes)
-        .filter((x) => !currentLinksHashes[x])
-        .map((x) => {
-        return {
-            [x]: reducedLinksByHashes[x],
-        };
-    })
-        .reduce((a, b) => Object.assign(a, b), {});
-    const toDelete = _.uniqBy(Object.keys(currentLinksHashes)
-        .filter((x) => !reducedLinksByHashes[x])
-        .map((x) => {
-        return {
-            [x]: currentLinksHashes[x],
-        };
-    }), 'id').reduce((a, b) => Object.assign(a, b), {});
-    logger_1.default.debug(`reduced links hashes: ${JSON.stringify(reducedLinksByHashes, null, 2)}`);
-    logger_1.default.info(`found ${Object.keys(toCreate).length} type property policy links to create`);
-    logger_1.default.info(`found ${Object.keys(toDelete).length} type property policy links to delete`);
-    logger_1.default.debug(`to create: ${JSON.stringify(toCreate, null, 2)}`);
-    logger_1.default.debug(`to delete: ${JSON.stringify(toDelete, null, 2)}`);
-    logger_1.default.debug(`current links hashes to delete: ${JSON.stringify(Object.keys(currentLinksHashes).filter((x) => !reducedLinksByHashes[x]), null, 2)}`);
-    // fs.writeFileSync('toCreate.json', JSON.stringify(toCreate, null, 2));
-    // fs.writeFileSync('toDelete.json', JSON.stringify(toDelete, null, 2));
-    // fs.writeFileSync('currentLinksHashes.json', JSON.stringify(currentLinksHashes, null, 2));
-    // fs.writeFileSync('reducedLinksByHashes.json', JSON.stringify(reducedLinksByHashes, null, 2));
-    // fs.writeFileSync(
-    //   'current_link_hashes_to_delete.json',
-    //   JSON.stringify(
-    //     Object.keys(currentLinksHashes).filter((x) => !reducedLinksByHashes[x]),
-    //     null,
-    //     2,
-    //   ),
-    // );
-    // return;
-    for (const [hash, link] of Object.entries(toCreate)) {
-        try {
-            if (!transformReducedLink(link, typeProperties, currentTPPs)) {
-                continue;
-            }
-            logger_1.default.info(`Creating: ${hash}: ${JSON.stringify(link, null, 2)}`);
-            await new sdk_1.Entities().create({
-                entityName: 'type-property-policy-link',
-                object: {
-                    typePropertyPolicyId: link.typePropertyPolicyId,
-                    typePropertyId: link.typePropertyId,
-                },
-            });
-        }
-        catch (err) {
-            logger_1.default.error(`Error Uploading type property policy links: ${err}`);
-        }
-    }
-    for (const [hash, link] of Object.entries(toDelete)) {
-        try {
-            logger_1.default.info(`Deleting: ${hash}`);
-            await new sdk_1.Entities().delete({
-                entityName: 'type-property-policy-link',
-                id: link['id'],
-            });
-        }
-        catch (err) {
-            logger_1.default.error(`Error Deleting type property policy link: ${err}`);
-        }
-    }
-    function transformReducedLink(TPPLink, typeProperties, typePropertyPolicies) {
-        const foundTP = typeProperties.find((tp) => tp.slug === TPPLink.typePropertySlug && tp.typeSlug === TPPLink.typeSlug);
-        if (!foundTP) {
-            logger_1.default.error(`Could not find type property with slug ${TPPLink.typePropertySlug} `);
-            return false;
-        }
-        TPPLink.typePropertyId = foundTP.id;
-        const foundTPP = typePropertyPolicies.find((tpp) => tpp.identifier === TPPLink.typePropertyPolicyIdentifier);
-        if (!foundTPP) {
-            logger_1.default.error(`Could not find type property policy with identifier ${TPPLink.typePropertyPolicyIdentifier} `);
-            return false;
-        }
-        TPPLink.typePropertyPolicyId = foundTPP.id;
-        return true;
-    }
-}
-function findAllOccurrences(array, evaluator) {
-    const found = [];
-    for (let i = 0; i < array.length; i++) {
-        const element = array[i];
-        if (evaluator(element)) {
-            found.push(element);
-        }
-    }
-    return found;
-}
-exports.findAllOccurrences = findAllOccurrences;

package/dist/helpers/types/type-uploader.js

@@ -303,7 +303,7 @@ async function uploadReducedTypeProperties(type, currentPropertyTypes, newProper
             }
         }
         catch (err) {
-            throw new Error(`Error Deleting Properties: ${err}`);
+            logger_1.default.error(`Error Deleting Type-Property ${currentPropertyType.slug}: ${err}`);
         }
     }
 }

package/dist/interfaces.d.ts

@@ -370,31 +370,6 @@ export interface ReducedOptionSet {
     isArchived: boolean;
     optionSet: any[];
 }
-export interface ReducedUsageInfo {
-    typeId: string;
-    typePropertyId: string;
-    typePath: string;
-    typePropertySlug: string;
-    editable: boolean;
-    used: boolean;
-    formulaFunction?: string;
-    validationFunction?: string;
-    numberFormat?: any;
-    defaultValue?: string;
-    label?: string;
-    required?: boolean;
-    searchable?: boolean;
-    isUniqueProperty?: boolean;
-    isUniquePropertyInFamily?: boolean;
-    copyBehavior?: string;
-    copyDefault?: string;
-    propertyLevel?: string;
-    isArchived: boolean;
-    isFederationProperty?: boolean;
-    carryOverBehavior?: string;
-    carryOverDefault?: string;
-}
-export type PersistReducedUsageInfo = Omit<ReducedUsageInfo, 'typePath' | 'typePropertySlug'>;
 export declare enum PropertyType {
     Text = "text",
     String = "string",

package/node_modules/@contrail/loader/lib/color-processor.js

@@ -5,14 +5,7 @@ const entity_types_1 = require("@contrail/entity-types");
 const base_processor_1 = require("./base-processor");
 const entity_processor_1 = require("./entity-processor");
 const constants_1 = require("./constants");
-function removeHexHash(data) {
-    for (const row of data ?? []) {
-        if (row.hex?.startsWith('#')) {
-            row.hex = row.hex.slice(1);
-        }
-    }
-    return data;
-}
+const color_validation_1 = require("./common/color-validation");
 class ColorProcessor extends base_processor_1.BaseProcessor {
     static typesToTransformBy = ['color'];
     static requiredProperties = ['typePath', 'typeId', 'federatedId', 'name', 'hex', 'red', 'green', 'blue'];
@@ -20,7 +13,7 @@ class ColorProcessor extends base_processor_1.BaseProcessor {
         if (!data) {
             return [];
         }
-        return removeHexHash(data);
+        return (0, color_validation_1.applyHexPriorityToRows)(data);
     }
     static validateTypePath(data, config, csvHeaders, generalErrors) {
         const typePathSource = {
@@ -56,20 +49,13 @@ class ColorProcessor extends base_processor_1.BaseProcessor {
     static validateLoadFile(data, config) {
         const { errors, warnings, generalErrors, generalWarnings, csvHeaders } = entity_processor_1.EntityProcessor.validateLoadFile(data, config, entity_types_1.LoadType.COLOR);
         this.validateTypePath(data, config, csvHeaders, generalErrors);
-        const redColumn = config?.federatedMappings?.red || 'red';
-        const blueColumn = config?.federatedMappings?.blue || 'blue';
-        const greenColumn = config?.federatedMappings?.green || 'green';
-        const hexColumn = config?.federatedMappings?.hex || 'hex';
-        const hasRedColumn = csvHeaders.includes(redColumn);
-        const hasBlueColumn = csvHeaders.includes(blueColumn);
-        const hasGreenColumn = csvHeaders.includes(greenColumn);
-        const hasHexColumn = csvHeaders.includes(hexColumn);
-        if (hasHexColumn && hasRedColumn && hasGreenColumn && hasBlueColumn) {
-            generalWarnings.push({
-                message: constants_1.COLOR_PROCESSOR_WARNINGS.HEX_IGNORED_WARNING,
-                issueType: entity_types_1.IssueType.CONFIG,
-            });
-        }
+        data.forEach((row, index) => {
+            const { rowErrors, rowWarnings } = (0, color_validation_1.buildColorRowIssues)(row, index + 2, config?.federatedMappings);
+            if (rowErrors)
+                errors.push(rowErrors);
+            if (rowWarnings)
+                warnings.push(rowWarnings);
+        });
         return { errors, warnings, generalErrors, generalWarnings };
     }
 }

package/node_modules/@contrail/loader/lib/color-processor.spec.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const color_processor_1 = require("./color-processor");
 const entity_types_1 = require("@contrail/entity-types");
 const constants_1 = require("./constants");
+const color_validation_1 = require("./common/color-validation");
 describe('ColorProcessor', () => {
     const loaderProcess = {
         id: 'mock-loader-process-id',
@@ -219,72 +220,38 @@ describe('ColorProcessor', () => {
             });
         });
         describe('color column validation', () => {
-            it('should warn when both hex and RGB columns are present', () => {
+            it('warns per-row when both hex and RGB are populated (hex prioritized)', () => {
                 const data = [
-                    {
-                        name: 'test-color',
-                        red: '255',
-                        green: '0',
-                        blue: '0',
-                        hex: '#ff0000',
-                    },
+                    { name: 'test-color', red: '255', green: '0', blue: '0', hex: '#ff0000' },
                 ];
-                const config = {
-                    ...loaderProcess,
-                    federatedMappings: {
-                        ...loaderProcess.federatedMappings,
-                        red: 'red',
-                        green: 'green',
-                        blue: 'blue',
-                        hex: 'hex',
-                    },
-                };
-                const result = color_processor_1.ColorProcessor.validateLoadFile(data, config);
-                expect(result.generalWarnings).toContainEqual({
-                    message: constants_1.COLOR_PROCESSOR_WARNINGS.HEX_IGNORED_WARNING,
-                    issueType: entity_types_1.IssueType.CONFIG,
-                });
-            });
-            it('should not warn when only RGB columns are present', () => {
-                const data = [
+                const result = color_processor_1.ColorProcessor.validateLoadFile(data, loaderProcess);
+                expect(result.warnings).toEqual([
                     {
-                        name: 'test-color',
-                        red: '255',
-                        green: '0',
-                        blue: '0',
-                    },
-                ];
-                const config = {
-                    ...loaderProcess,
-                    federatedMappings: {
-                        ...loaderProcess.federatedMappings,
-                        red: 'red',
-                        green: 'green',
-                        blue: 'blue',
+                        rowNumber: 2,
+                        columnIssues: [
+                            {
+                                columnName: 'hex',
+                                message: color_validation_1.COLOR_VALIDATION_MESSAGES.HEX_PRIORITIZED_OVER_RGB,
+                                issueType: entity_types_1.IssueType.INVALID_DATA,
+                                data: JSON.stringify(data[0]),
+                            },
+                        ],
                     },
-                };
-                const result = color_processor_1.ColorProcessor.validateLoadFile(data, config);
-                expect(result.generalWarnings).not.toContainEqual({
-                    message: constants_1.COLOR_PROCESSOR_WARNINGS.HEX_IGNORED_WARNING,
-                    issueType: entity_types_1.IssueType.CONFIG,
-                });
+                ]);
             });
-            it('should not warn when only hex column is present', () => {
+            it('does not warn when only RGB is populated and all components are valid', () => {
+                const data = [{ name: 'test-color', red: '255', green: '0', blue: '0' }];
+                const result = color_processor_1.ColorProcessor.validateLoadFile(data, loaderProcess);
+                expect(result.warnings).toEqual([]);
+                expect(result.errors).toEqual([]);
+            });
+            it('does not warn when only a valid hex is populated', () => {
                 const data = [{ name: 'test-color', hex: '#ff0000' }];
-                const config = {
-                    ...loaderProcess,
-                    federatedMappings: {
-                        ...loaderProcess.federatedMappings,
-                        hex: 'hex',
-                    },
-                };
-                const result = color_processor_1.ColorProcessor.validateLoadFile(data, config);
-                expect(result.generalWarnings).not.toContainEqual({
-                    message: constants_1.COLOR_PROCESSOR_WARNINGS.HEX_IGNORED_WARNING,
-                    issueType: entity_types_1.IssueType.CONFIG,
-                });
+                const result = color_processor_1.ColorProcessor.validateLoadFile(data, loaderProcess);
+                expect(result.warnings).toEqual([]);
+                expect(result.errors).toEqual([]);
             });
-            it('should handle custom column names from federatedMappings', () => {
+            it('warns per-row when both hex and RGB are populated under federatedMappings', () => {
                 const data = [{ name: 'test-color', r: '255', g: '0', b: '0', hexcode: '#ff0000' }];
                 const config = {
                     ...loaderProcess,
@@ -297,11 +264,94 @@ describe('ColorProcessor', () => {
                     },
                 };
                 const result = color_processor_1.ColorProcessor.validateLoadFile(data, config);
-                expect(result.generalWarnings).toContainEqual({
-                    message: constants_1.COLOR_PROCESSOR_WARNINGS.HEX_IGNORED_WARNING,
-                    issueType: entity_types_1.IssueType.CONFIG,
+                expect(result.warnings).toEqual([
+                    {
+                        rowNumber: 2,
+                        columnIssues: [
+                            {
+                                columnName: 'hex',
+                                message: color_validation_1.COLOR_VALIDATION_MESSAGES.HEX_PRIORITIZED_OVER_RGB,
+                                issueType: entity_types_1.IssueType.INVALID_DATA,
+                                data: JSON.stringify(data[0]),
+                            },
+                        ],
+                    },
+                ]);
+            });
+            it('errors when hex is invalid', () => {
+                const data = [{ name: 'bad', hex: 'notahex' }];
+                const result = color_processor_1.ColorProcessor.validateLoadFile(data, loaderProcess);
+                expect(result.errors).toHaveLength(1);
+                expect(result.errors[0]).toMatchObject({
+                    rowNumber: 2,
+                    columnIssues: [
+                        {
+                            columnName: 'hex',
+                            message: color_validation_1.COLOR_VALIDATION_MESSAGES.HEX_INVALID('notahex'),
+                            issueType: entity_types_1.IssueType.INVALID_DATA,
+                        },
+                    ],
+                });
+            });
+            it('errors when RGB is partially populated and hex is missing', () => {
+                const data = [{ name: 'partial', red: '255', green: '128' }];
+                const result = color_processor_1.ColorProcessor.validateLoadFile(data, loaderProcess);
+                expect(result.errors).toHaveLength(1);
+                expect(result.errors[0].rowNumber).toBe(2);
+                expect(result.errors[0].columnIssues).toEqual([
+                    {
+                        columnName: 'blue',
+                        message: color_validation_1.COLOR_VALIDATION_MESSAGES.RGB_INCOMPLETE(['blue']),
+                        issueType: entity_types_1.IssueType.INVALID_DATA,
+                        data: JSON.stringify(data[0]),
+                    },
+                ]);
+            });
+            it('errors when an RGB component is out of range or non-numeric', () => {
+                const data = [
+                    { name: 'bad-red', red: '300', green: '0', blue: '0' },
+                    { name: 'nan-green', red: '10', green: 'foo', blue: '0' },
+                ];
+                const result = color_processor_1.ColorProcessor.validateLoadFile(data, loaderProcess);
+                expect(result.errors).toHaveLength(2);
+                expect(result.errors[0]).toMatchObject({
+                    rowNumber: 2,
+                    columnIssues: [
+                        { columnName: 'red', message: color_validation_1.COLOR_VALIDATION_MESSAGES.RGB_OUT_OF_RANGE('red', '300') },
+                    ],
+                });
+                expect(result.errors[1]).toMatchObject({
+                    rowNumber: 3,
+                    columnIssues: [
+                        { columnName: 'green', message: color_validation_1.COLOR_VALIDATION_MESSAGES.RGB_OUT_OF_RANGE('green', 'foo') },
+                    ],
                 });
             });
+            it('does not error when neither hex nor RGB are populated (defaults to black)', () => {
+                const data = [{ name: 'no-color' }];
+                const result = color_processor_1.ColorProcessor.validateLoadFile(data, loaderProcess);
+                expect(result.errors).toEqual([]);
+                expect(result.warnings).toEqual([]);
+            });
+        });
+    });
+    describe('transformData (hex priority)', () => {
+        it('strips red/green/blue when hex is valid', () => {
+            const data = [
+                { hex: '#ff0000', red: '255', green: '0', blue: '0', name: 'red' },
+            ];
+            const result = color_processor_1.ColorProcessor.transformData(data);
+            expect(result).toEqual([{ hex: 'ff0000', name: 'red' }]);
+        });
+        it('keeps red/green/blue and removes empty hex when hex is missing', () => {
+            const data = [{ red: '255', green: '0', blue: '0', name: 'red' }];
+            const result = color_processor_1.ColorProcessor.transformData(data);
+            expect(result).toEqual([{ red: '255', green: '0', blue: '0', name: 'red' }]);
+        });
+        it('defaults to #000000 (without hash) when neither hex nor full RGB is provided', () => {
+            const data = [{ name: 'fallback' }];
+            const result = color_processor_1.ColorProcessor.transformData(data);
+            expect(result).toEqual([{ name: 'fallback', hex: color_validation_1.DEFAULT_HEX }]);
         });
     });
 });

package/node_modules/@contrail/loader/lib/common/chunk-by-url-length.d.ts

@@ -2,5 +2,5 @@ interface ChunkByUrlLengthOptions {
     maxBytes?: number;
     maxCount?: number;
 }
-export declare function chunkByUrlLength(ids: string[], options?: ChunkByUrlLengthOptions): string[][];
+export declare function chunkByUrlLength(ids: readonly string[] | null | undefined, options?: ChunkByUrlLengthOptions): string[][];
 export {};

package/node_modules/@contrail/loader/lib/common/chunk-by-url-length.js

@@ -6,6 +6,8 @@ function wireEncodedLength(id) {
     return encodeURIComponent(id.replace(/,/g, '_COMMA_')).length;
 }
 function chunkByUrlLength(ids, options = {}) {
+    if (!ids?.length)
+        return [];
     const maxBytes = options.maxBytes ?? constants_1.FEDERATED_ID_FETCH_MAX_URL_BYTES;
     const maxCount = options.maxCount ?? constants_1.FEDERATED_ID_FETCH_MAX_COUNT;
     const result = [];

package/node_modules/@contrail/loader/lib/common/chunk-by-url-length.spec.js

@@ -5,6 +5,10 @@ describe('chunkByUrlLength', () => {
     it('returns an empty array for empty input', () => {
         expect((0, chunk_by_url_length_1.chunkByUrlLength)([])).toEqual([]);
     });
+    it('returns an empty array for null/undefined input (matches lodash.chunk behavior)', () => {
+        expect((0, chunk_by_url_length_1.chunkByUrlLength)(undefined)).toEqual([]);
+        expect((0, chunk_by_url_length_1.chunkByUrlLength)(null)).toEqual([]);
+    });
     it('packs short ids into a single chunk up to maxCount', () => {
         const ids = Array.from({ length: 50 }, (_, i) => `id-${i}`);
         const chunks = (0, chunk_by_url_length_1.chunkByUrlLength)(ids, { maxCount: 200, maxBytes: 10000 });

package/node_modules/@contrail/loader/lib/common/color-validation.d.ts

@@ -0,0 +1,26 @@
+import { ProcessingIssues } from '@contrail/entity-types';
+export declare const COLOR_VALIDATION_MESSAGES: {
+    readonly HEX_INVALID: (hex: string) => string;
+    readonly RGB_INCOMPLETE: (missingColumns: string[]) => string;
+    readonly RGB_OUT_OF_RANGE: (column: string, value: string) => string;
+    readonly HEX_PRIORITIZED_OVER_RGB: "Both \"hex\" and red/green/blue values are provided — \"hex\" will be used and red/green/blue will be ignored for this row.";
+};
+export declare const DEFAULT_HEX = "000000";
+export declare function isValidHex(hex: string): boolean;
+export declare function parseRgbComponent(value: any): number | null;
+export interface ColorRowValidationResult {
+    errors: {
+        columnName: string;
+        message: string;
+    }[];
+    warnings: {
+        columnName: string;
+        message: string;
+    }[];
+}
+export declare function validateColorRow(row: Record<string, any>, federatedMappings?: Record<string, string>): ColorRowValidationResult;
+export declare function buildColorRowIssues(row: Record<string, any>, rowNumber: number, federatedMappings?: Record<string, string>): {
+    rowErrors: ProcessingIssues | null;
+    rowWarnings: ProcessingIssues | null;
+};
+export declare function applyHexPriorityToRows<T extends Record<string, any>>(rows: T[]): T[];