@contrail/cli 3.4.5 → 3.4.6-alpha.cffb28e

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

@@ -0,0 +1,10 @@
+import { EntitiesClient } from '@contrail/entity-types';
+import { LoaderConfig, TransformResult, PreviewResult, ExecutionResult, ExecuteOptions, PreValidationResult } from './types';
+export declare class LoaderPipeline {
+    private client;
+    constructor(client: EntitiesClient);
+    transform(data: Record<string, any>[], config: LoaderConfig): Promise<TransformResult>;
+    validate(transformed: TransformResult, config: LoaderConfig): Promise<PreValidationResult>;
+    preview(transformed: TransformResult, config: LoaderConfig): Promise<PreviewResult>;
+    execute(transformed: TransformResult, config: LoaderConfig, options?: ExecuteOptions, previewData?: PreviewResult): Promise<ExecutionResult>;
+}

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoaderPipeline = void 0;
+const transform_1 = require("./transform");
+const validate_1 = require("./validate");
+const preview_1 = require("./preview");
+const execute_1 = require("./execute");
+class LoaderPipeline {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async transform(data, config) {
+        return (0, transform_1.transform)(this.client, data, config);
+    }
+    async validate(transformed, config) {
+        return (0, validate_1.validate)(transformed.rows, config, transformed, this.client);
+    }
+    async preview(transformed, config) {
+        return (0, preview_1.preview)(this.client, transformed.rows, config, transformed);
+    }
+    async execute(transformed, config, options, previewData) {
+        return (0, execute_1.execute)(this.client, transformed.rows, config, transformed, options, previewData);
+    }
+}
+exports.LoaderPipeline = LoaderPipeline;

package/node_modules/@contrail/loader/lib/pipeline/loader-pipeline.spec.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,125 @@
+"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 loader_pipeline_1 = require("./loader-pipeline");
+const transformModule = __importStar(require("./transform"));
+const validateModule = __importStar(require("./validate"));
+const previewModule = __importStar(require("./preview"));
+const executeModule = __importStar(require("./execute"));
+jest.mock('./transform');
+jest.mock('./validate');
+jest.mock('./preview');
+jest.mock('./execute');
+describe('LoaderPipeline', () => {
+    let mockClient;
+    let pipeline;
+    const baseConfig = {
+        loadType: [types_1.LoadType.ITEM],
+    };
+    const mockTransformed = {
+        rows: [{ federatedId: '1', name: 'Test' }],
+        typePropertyMaps: {
+            typePropertiesBySlug: {},
+            typePropertiesByLabel: {},
+            optionSetUsingTypePropertiesBySlug: {},
+        },
+        typesByPath: {},
+        columns: [],
+        unmappedTypeProperties: [],
+        errors: [],
+        warnings: [],
+        generalErrors: [],
+        generalWarnings: [],
+        stepResults: [],
+    };
+    const mockValidation = {
+        valid: true,
+        issues: [],
+        summary: { errorCount: 0, warningCount: 0, infoCount: 0, countsByCategory: {} },
+    };
+    const mockPreview = {
+        entities: [{ entityType: 'item', total: 1, creates: 1, updates: 0, drops: 0, unchanged: 0, skippedStale: 0 }],
+        badRows: [],
+        staleRows: [],
+        warnings: [],
+        constructedEntities: {},
+    };
+    const mockExecutionResult = {
+        status: 'complete',
+        entities: [],
+        skippedRows: [],
+        warnings: [],
+        duration: 100,
+    };
+    beforeEach(() => {
+        mockClient = {
+            create: jest.fn(),
+            update: jest.fn(),
+            get: jest.fn(),
+            delete: jest.fn(),
+            batchCreate: jest.fn(),
+            batchUpdate: jest.fn(),
+            batchDelete: jest.fn(),
+            getAllReferences: jest.fn(),
+        };
+        pipeline = new loader_pipeline_1.LoaderPipeline(mockClient);
+        transformModule.transform.mockResolvedValue(mockTransformed);
+        validateModule.validate.mockResolvedValue(mockValidation);
+        previewModule.preview.mockResolvedValue(mockPreview);
+        executeModule.execute.mockResolvedValue(mockExecutionResult);
+    });
+    afterEach(() => {
+        jest.resetAllMocks();
+    });
+    it('should delegate transform to standalone function with client', async () => {
+        const rows = [{ federatedId: '1' }];
+        await pipeline.transform(rows, baseConfig);
+        expect(transformModule.transform).toHaveBeenCalledWith(mockClient, rows, baseConfig);
+    });
+    it('should delegate validate, passing transformed result as column analysis', async () => {
+        await pipeline.validate(mockTransformed, baseConfig);
+        expect(validateModule.validate).toHaveBeenCalledWith(mockTransformed.rows, baseConfig, mockTransformed, mockClient);
+    });
+    it('should delegate preview to standalone function with client', async () => {
+        await pipeline.preview(mockTransformed, baseConfig);
+        expect(previewModule.preview).toHaveBeenCalledWith(mockClient, mockTransformed.rows, baseConfig, mockTransformed);
+    });
+    it('should delegate execute to standalone function with client', async () => {
+        const options = { batchSize: 50 };
+        await pipeline.execute(mockTransformed, baseConfig, options, mockPreview);
+        expect(executeModule.execute).toHaveBeenCalledWith(mockClient, mockTransformed.rows, baseConfig, mockTransformed, options, mockPreview);
+    });
+    it('should support full pipeline flow: transform → validate → preview → execute', async () => {
+        const rows = [{ federatedId: '1', name: 'Test' }];
+        const transformed = await pipeline.transform(rows, baseConfig);
+        const validation = await pipeline.validate(transformed, baseConfig);
+        expect(validation.valid).toBe(true);
+        const previewResult = await pipeline.preview(transformed, baseConfig);
+        expect(previewResult.entities).toHaveLength(1);
+        const result = await pipeline.execute(transformed, baseConfig, undefined, previewResult);
+        expect(result.status).toBe('complete');
+    });
+});

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

@@ -0,0 +1,3 @@
+import { EntitiesClient } from '@contrail/entity-types';
+import { LoaderConfig, ColumnAnalysisResult, PreviewResult } from './types';
+export declare function preview(client: EntitiesClient, rows: Record<string, any>[], config: LoaderConfig, columnAnalysis: ColumnAnalysisResult): Promise<PreviewResult>;

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

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preview = void 0;
+const types_1 = require("./types");
+const entity_processor_v2_1 = require("../entities-v2/entity-processor-v2");
+const entities_helper_1 = require("../entities-v2/entities-helper");
+const types_2 = require("./types");
+const item_execute_helpers_1 = require("./item-execute-helpers");
+const project_item_execute_helpers_1 = require("./project-item-execute-helpers");
+async function preview(client, rows, config, columnAnalysis) {
+    const entityTypes = (0, types_2.enforceItemFirstOrder)((0, types_2.loadTypeToEntityTypes)(config.loadType));
+    const loaderProcess = (0, types_2.toLoaderProcessCompat)(config);
+    const allWarnings = [];
+    const allBadRows = [];
+    const allStaleRows = [];
+    const entities = [];
+    const constructedEntities = {};
+    let sharedItemsByFederatedId = {};
+    for (const entityType of entityTypes) {
+        const doConstructEntities = entityType !== types_1.EntityType.ASSORTMENT;
+        const itemsByFederatedId = entityType !== types_1.EntityType.ITEM ? { ...sharedItemsByFederatedId } : {};
+        const clonedRows = rows.map(row => ({ ...row }));
+        const result = await entity_processor_v2_1.EntityProcessorV2.setupEntities(client, entityType, clonedRows, undefined, loaderProcess, itemsByFederatedId, doConstructEntities, columnAnalysis.typesByPath ? buildTypesByTypePathCache(columnAnalysis) : undefined);
+        if (result.generalWarnings?.length) {
+            for (const warning of result.generalWarnings) {
+                allWarnings.push(warning.message);
+            }
+        }
+        if (result.badEntities?.length) {
+            for (let i = 0; i < result.badEntities.length; i++) {
+                const badEntity = result.badEntities[i];
+                allBadRows.push({
+                    rowNumber: findRowNumber(badEntity, rows),
+                    federatedId: badEntity?.federatedId,
+                    reason: 'Failed entity construction (invalid row, missing typePath, or missing required properties)',
+                });
+            }
+        }
+        const incoming = result.incomingEntities || [];
+        const currentByFedId = result.allCurrentEntitiesByFederatedId || {};
+        if (entityType === types_1.EntityType.PROJECT_ITEM) {
+            const projectNameById = {};
+            for (const row of rows) {
+                if (row.projectId && row.projectName && !projectNameById[row.projectId]) {
+                    projectNameById[row.projectId] = row.projectName;
+                }
+            }
+            const entitySetForPreview = {
+                incomingEntities: incoming,
+                badEntities: result.badEntities || [],
+                allCurrentEntitiesByFederatedId: currentByFedId,
+                typesByPath: result.typesByPath || {},
+                projectId: result.projectId,
+                generalWarnings: result.generalWarnings,
+            };
+            const projectItemPreview = await (0, project_item_execute_helpers_1.previewProjectItemEntities)(client, entitySetForPreview, config, projectNameById);
+            entities.push(...projectItemPreview.summaries);
+            allBadRows.push(...projectItemPreview.badRows);
+            allStaleRows.push(...projectItemPreview.staleRows);
+            allWarnings.push(...projectItemPreview.warnings);
+            constructedEntities[entityType] = entitySetForPreview;
+        }
+        else if (entityType === types_1.EntityType.ITEM) {
+            const itemPreview = (0, item_execute_helpers_1.previewItemEntities)(incoming, currentByFedId, result.typesByPath || {}, config);
+            entities.push(...itemPreview.summaries);
+            allBadRows.push(...itemPreview.badRows);
+            allStaleRows.push(...itemPreview.staleRows);
+            allWarnings.push(...itemPreview.warnings);
+            constructedEntities[entityType] = {
+                incomingEntities: incoming,
+                badEntities: result.badEntities || [],
+                allCurrentEntitiesByFederatedId: currentByFedId,
+                typesByPath: result.typesByPath || {},
+                projectId: result.projectId,
+                generalWarnings: result.generalWarnings,
+            };
+            Object.assign(sharedItemsByFederatedId, currentByFedId);
+            for (const entity of incoming) {
+                const famFedId = entity.federatedId || entity.itemFamilyFederatedId;
+                const optFedId = entity.itemOptionFederatedId;
+                if (famFedId && !sharedItemsByFederatedId[famFedId]) {
+                    sharedItemsByFederatedId[famFedId] = { id: `pending:${famFedId}`, federatedId: famFedId };
+                }
+                if (optFedId && !sharedItemsByFederatedId[optFedId]) {
+                    sharedItemsByFederatedId[optFedId] = { id: `pending:${optFedId}`, federatedId: optFedId };
+                }
+            }
+        }
+        else if (entityType === types_1.EntityType.ASSORTMENT && result.assortmentDetails?.length) {
+            for (const detail of result.assortmentDetails) {
+                const assortment = detail.assortment;
+                const summary = detail.fullSummary;
+                const targetId = assortment?.id || undefined;
+                const targetName = assortment?.name || assortment?.identifier || targetId;
+                const unmapped = detail.unmappedAssortmentItems || [];
+                entities.push({
+                    entityType: 'assortment-item',
+                    total: (detail.incomingAssortmentItems || []).length,
+                    creates: summary?.adds?.length || 0,
+                    updates: summary?.updates?.length || 0,
+                    drops: summary?.deletes?.length || 0,
+                    unchanged: summary?.unchanged?.length || 0,
+                    skippedStale: 0,
+                    targetName,
+                    targetId,
+                });
+                for (const item of unmapped) {
+                    const fedId = item.itemOptionFederatedId || item.itemFamilyFederatedId;
+                    allWarnings.push(`Item "${fedId}" does not exist in the database and will be skipped from the assortment load if the execution step is run. Add 'ITEM' to loadType if you want this item to be created so it can be added to the assortment.`);
+                }
+            }
+            constructedEntities[entityType] = {
+                incomingEntities: incoming,
+                badEntities: result.badEntities || [],
+                allCurrentEntitiesByFederatedId: currentByFedId,
+                typesByPath: result.typesByPath || {},
+                projectId: result.projectId,
+                generalWarnings: result.generalWarnings,
+                assortmentDetails: result.assortmentDetails,
+            };
+        }
+        else {
+            const classification = classifyEntities(incoming, currentByFedId, config.skipStaleUpdatesUsing);
+            for (const staleInfo of classification.stale) {
+                allStaleRows.push({
+                    rowNumber: findRowNumber(staleInfo.entity, rows),
+                    federatedId: staleInfo.entity?.federatedId,
+                    reason: 'Skipped: incoming timestamp is older than existing',
+                    details: {
+                        incomingTimestamp: staleInfo.incomingTimestamp,
+                        existingTimestamp: staleInfo.existingTimestamp,
+                    },
+                });
+            }
+            entities.push({
+                entityType,
+                total: incoming.length,
+                creates: classification.toCreate.length,
+                updates: classification.toUpdate.length,
+                drops: 0,
+                unchanged: classification.unchanged.length,
+                skippedStale: classification.stale.length,
+            });
+            constructedEntities[entityType] = {
+                incomingEntities: incoming,
+                badEntities: result.badEntities || [],
+                allCurrentEntitiesByFederatedId: currentByFedId,
+                typesByPath: result.typesByPath || {},
+                projectId: result.projectId,
+                generalWarnings: result.generalWarnings,
+            };
+        }
+    }
+    return {
+        entities,
+        badRows: allBadRows,
+        staleRows: allStaleRows,
+        warnings: allWarnings,
+        constructedEntities,
+    };
+}
+exports.preview = preview;
+function classifyEntities(incomingEntities, currentByFedId, skipStaleUpdatesUsing) {
+    const toCreate = [];
+    const toUpdate = [];
+    const unchanged = [];
+    const stale = [];
+    for (const incoming of incomingEntities) {
+        const fedId = incoming.federatedId;
+        const existing = fedId ? currentByFedId[fedId] : undefined;
+        if (!existing) {
+            toCreate.push(incoming);
+            continue;
+        }
+        if (skipStaleUpdatesUsing) {
+            const incomingTs = incoming[skipStaleUpdatesUsing];
+            const existingTs = existing[skipStaleUpdatesUsing];
+            if (incomingTs && existingTs && new Date(incomingTs) < new Date(existingTs)) {
+                stale.push({
+                    entity: incoming,
+                    incomingTimestamp: String(incomingTs),
+                    existingTimestamp: String(existingTs),
+                });
+                continue;
+            }
+        }
+        if ((0, entities_helper_1.UpdateNeeded)(incoming, existing)) {
+            toUpdate.push(incoming);
+        }
+        else {
+            unchanged.push(incoming);
+        }
+    }
+    return { toCreate, toUpdate, unchanged, stale };
+}
+function buildTypesByTypePathCache(columnAnalysis) {
+    const cache = {};
+    let hasEntries = false;
+    for (const [path, typeInfo] of Object.entries(columnAnalysis.typesByPath || {})) {
+        if (typeInfo?.type) {
+            cache[path] = typeInfo.type;
+            hasEntries = true;
+        }
+    }
+    return hasEntries ? cache : undefined;
+}
+function findRowNumber(entity, originalRows) {
+    if (!entity)
+        return -1;
+    const fedId = entity.federatedId;
+    if (fedId) {
+        for (let i = 0; i < originalRows.length; i++) {
+            if (originalRows[i].federatedId === fedId) {
+                return i + 2;
+            }
+        }
+    }
+    return -1;
+}

package/node_modules/@contrail/loader/lib/pipeline/preview.spec.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const preview_1 = require("./preview");
+const entity_processor_v2_1 = require("../entities-v2/entity-processor-v2");
+jest.mock('../entities-v2/entity-processor-v2');
+describe('preview (non-item entity types)', () => {
+    let mockClient;
+    const baseConfig = {
+        loadType: [types_1.LoadType.COLOR],
+    };
+    const baseAnalysis = {
+        columns: [],
+        unmappedTypeProperties: [],
+        typePropertyMaps: {
+            typePropertiesBySlug: {},
+            typePropertiesByLabel: {},
+            optionSetUsingTypePropertiesBySlug: {},
+        },
+        typesByPath: {},
+    };
+    beforeEach(() => {
+        mockClient = {
+            create: jest.fn(),
+            update: jest.fn(),
+            get: jest.fn(),
+            delete: jest.fn(),
+            batchCreate: jest.fn(),
+            batchUpdate: jest.fn(),
+            batchDelete: jest.fn(),
+            getAllReferences: jest.fn(),
+        };
+    });
+    afterEach(() => {
+        jest.resetAllMocks();
+    });
+    it('should classify creates when no existing entities match', async () => {
+        entity_processor_v2_1.EntityProcessorV2.setupEntities.mockResolvedValue({
+            incomingEntities: [
+                { federatedId: 'item-1', name: 'New Item 1' },
+                { federatedId: 'item-2', name: 'New Item 2' },
+            ],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: {},
+            projectId: null,
+            generalWarnings: [],
+        });
+        const rows = [
+            { federatedId: 'item-1', name: 'New Item 1' },
+            { federatedId: 'item-2', name: 'New Item 2' },
+        ];
+        const result = await (0, preview_1.preview)(mockClient, rows, baseConfig, baseAnalysis);
+        expect(result.entities).toHaveLength(1);
+        expect(result.entities[0].entityType).toBe(types_1.EntityType.COLOR);
+        expect(result.entities[0].creates).toBe(2);
+        expect(result.entities[0].updates).toBe(0);
+        expect(result.entities[0].unchanged).toBe(0);
+    });
+    it('should classify updates when existing entities match and differ', async () => {
+        entity_processor_v2_1.EntityProcessorV2.setupEntities.mockResolvedValue({
+            incomingEntities: [
+                { federatedId: 'item-1', name: 'Updated Name', color: 'blue' },
+            ],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {
+                'item-1': { id: 'id-1', federatedId: 'item-1', name: 'Old Name', color: 'red' },
+            },
+            typesByPath: {},
+            projectId: null,
+            generalWarnings: [],
+        });
+        const rows = [{ federatedId: 'item-1', name: 'Updated Name', color: 'blue' }];
+        const result = await (0, preview_1.preview)(mockClient, rows, baseConfig, baseAnalysis);
+        expect(result.entities[0].updates).toBe(1);
+        expect(result.entities[0].creates).toBe(0);
+    });
+    it('should collect bad rows from entity construction', async () => {
+        entity_processor_v2_1.EntityProcessorV2.setupEntities.mockResolvedValue({
+            incomingEntities: [{ federatedId: 'item-1', name: 'Good' }],
+            badEntities: [{ federatedId: 'bad-1', name: '' }],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: {},
+            projectId: null,
+            generalWarnings: [],
+        });
+        const rows = [
+            { federatedId: 'item-1', name: 'Good' },
+            { federatedId: 'bad-1', name: '' },
+        ];
+        const result = await (0, preview_1.preview)(mockClient, rows, baseConfig, baseAnalysis);
+        expect(result.badRows).toHaveLength(1);
+        expect(result.badRows[0].federatedId).toBe('bad-1');
+    });
+    it('should detect stale rows when skipStaleUpdatesUsing is configured', async () => {
+        entity_processor_v2_1.EntityProcessorV2.setupEntities.mockResolvedValue({
+            incomingEntities: [
+                { federatedId: 'item-1', name: 'Test', updatedOn: '2024-01-01T00:00:00Z' },
+            ],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {
+                'item-1': {
+                    id: 'id-1',
+                    federatedId: 'item-1',
+                    name: 'Test',
+                    updatedOn: '2024-06-01T00:00:00Z',
+                },
+            },
+            typesByPath: {},
+            projectId: null,
+            generalWarnings: [],
+        });
+        const config = {
+            ...baseConfig,
+            skipStaleUpdatesUsing: 'updatedOn',
+        };
+        const rows = [{ federatedId: 'item-1', name: 'Test', updatedOn: '2024-01-01T00:00:00Z' }];
+        const result = await (0, preview_1.preview)(mockClient, rows, config, baseAnalysis);
+        expect(result.entities[0].skippedStale).toBe(1);
+        expect(result.staleRows).toHaveLength(1);
+        expect(result.staleRows[0].federatedId).toBe('item-1');
+        expect(result.staleRows[0].details?.incomingTimestamp).toBe('2024-01-01T00:00:00Z');
+        expect(result.staleRows[0].details?.existingTimestamp).toBe('2024-06-01T00:00:00Z');
+    });
+    it('should collect warnings from object reference resolution', async () => {
+        entity_processor_v2_1.EntityProcessorV2.setupEntities.mockResolvedValue({
+            incomingEntities: [],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: {},
+            projectId: null,
+            generalWarnings: [
+                { message: 'ObjectReference not found for vendor with value acme', issueType: 'INVALID_DATA' },
+            ],
+        });
+        const rows = [{ federatedId: '1' }];
+        const result = await (0, preview_1.preview)(mockClient, rows, baseConfig, baseAnalysis);
+        expect(result.warnings).toContain('ObjectReference not found for vendor with value acme');
+    });
+    it('should store constructed entities for execute stage', async () => {
+        entity_processor_v2_1.EntityProcessorV2.setupEntities.mockResolvedValue({
+            incomingEntities: [{ federatedId: 'item-1', name: 'Test' }],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: { 'item-1': { id: 'id-1', federatedId: 'item-1' } },
+            typesByPath: {},
+            projectId: 'proj-1',
+            generalWarnings: [],
+        });
+        const rows = [{ federatedId: 'item-1', name: 'Test' }];
+        const result = await (0, preview_1.preview)(mockClient, rows, baseConfig, baseAnalysis);
+        expect(result.constructedEntities).toBeDefined();
+        expect(result.constructedEntities[types_1.EntityType.COLOR]).toBeDefined();
+        expect(result.constructedEntities[types_1.EntityType.COLOR].incomingEntities).toHaveLength(1);
+    });
+});

package/node_modules/@contrail/loader/lib/pipeline/project-item-execute-helpers.d.ts

@@ -0,0 +1,5 @@
+import { EntitiesClient } from '@contrail/entity-types';
+import { LoaderConfig, ExecuteOptions, ConstructedEntitySet } from './types';
+import { ItemExecutionResult, ItemPreviewResult } from './item-execute-helpers';
+export declare function previewProjectItemEntities(client: EntitiesClient, entitySet: ConstructedEntitySet, config: LoaderConfig, projectNameById?: Record<string, string>): Promise<ItemPreviewResult>;
+export declare function executeProjectItemEntities(client: EntitiesClient, entitySet: ConstructedEntitySet, config: LoaderConfig, options?: ExecuteOptions): Promise<ItemExecutionResult>;