@squiz/dxp-cli-next 5.33.0-develop.2 → 5.33.0-develop.4

package/lib/migration/mark-deployed/mark-deployed.spec.js

@@ -0,0 +1,217 @@
+"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;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const nock_1 = __importDefault(require("nock"));
+const mark_deployed_1 = __importDefault(require("./mark-deployed"));
+const utils = __importStar(require("../utils/common"));
+const ApplicationStore = __importStar(require("../../ApplicationStore"));
+const markComponentsDeployedModule = __importStar(require("../utils/markComponentsDeployed"));
+const loadAssetIdsModule = __importStar(require("../utils/loadAssetIdsFromFile"));
+jest.mock('../utils/common');
+jest.mock('../utils/markComponentsDeployed');
+jest.mock('../utils/loadAssetIdsFromFile');
+jest.mock('../../ApplicationStore');
+const mockUtils = utils;
+const mockMarkComponentsDeployed = markComponentsDeployedModule;
+const mockLoadAssetIds = loadAssetIdsModule;
+const mockApplicationStore = ApplicationStore;
+describe('markDeployedCommand', () => {
+    let logSpy;
+    let mockMarkDeployedResponse;
+    beforeEach(() => {
+        nock_1.default.cleanAll();
+        jest.clearAllMocks();
+        jest.resetAllMocks();
+        logSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
+        mockApplicationStore.getApplicationFile.mockResolvedValue('session-cookie');
+        mockUtils.throwErrorIfNotLoggedIn.mockResolvedValue(undefined);
+        mockLoadAssetIds.loadAssetIdsFromFile.mockReturnValue([
+            'cct-1',
+            'cct-2',
+            'cct-3',
+        ]);
+        mockMarkDeployedResponse = {
+            success: ['cct-1', 'cct-2', 'cct-3'],
+            failed: [],
+        };
+        mockMarkComponentsDeployed.markComponentsDeployed.mockResolvedValue(mockMarkDeployedResponse);
+    });
+    afterEach(() => {
+        logSpy.mockRestore();
+    });
+    describe('successful mark deployed execution', () => {
+        it('should mark components as deployed successfully with required options', () => __awaiter(void 0, void 0, void 0, function* () {
+            const program = (0, mark_deployed_1.default)();
+            yield program.parseAsync(['node', 'dxp-cli', '--cct-ids', './ccts.json']);
+            expect(mockUtils.throwErrorIfNotLoggedIn).toHaveBeenCalledWith(program);
+            expect(mockLoadAssetIds.loadAssetIdsFromFile).toHaveBeenCalledWith('./ccts.json');
+            expect(mockMarkComponentsDeployed.markComponentsDeployed).toHaveBeenCalledWith({
+                cctIds: ['cct-1', 'cct-2', 'cct-3'],
+            });
+            expect(mockMarkComponentsDeployed.markComponentsDeployed).toHaveBeenCalledTimes(1);
+            expect(mockUtils.handleCommandError).not.toHaveBeenCalled();
+        }));
+        it('should mark components as deployed with tenant option', () => __awaiter(void 0, void 0, void 0, function* () {
+            const program = (0, mark_deployed_1.default)();
+            yield program.parseAsync([
+                'node',
+                'dxp-cli',
+                '--cct-ids',
+                './ccts.json',
+                '--tenant',
+                'test-tenant',
+            ]);
+            expect(mockMarkComponentsDeployed.markComponentsDeployed).toHaveBeenCalledWith({
+                cctIds: ['cct-1', 'cct-2', 'cct-3'],
+                tenant: 'test-tenant',
+            });
+        }));
+        it('should mark components as deployed with override URL when environment variable is set', () => __awaiter(void 0, void 0, void 0, function* () {
+            const originalEnv = process.env.ENABLE_OVERRIDE_MIGRATION_URL;
+            process.env.ENABLE_OVERRIDE_MIGRATION_URL = 'true';
+            const program = (0, mark_deployed_1.default)();
+            yield program.parseAsync([
+                'node',
+                'dxp-cli',
+                '--cct-ids',
+                './ccts.json',
+                '--overrideUrl',
+                'https://custom.migration.url',
+            ]);
+            expect(mockMarkComponentsDeployed.markComponentsDeployed).toHaveBeenCalledWith({
+                cctIds: ['cct-1', 'cct-2', 'cct-3'],
+                overrideUrl: 'https://custom.migration.url',
+            });
+            process.env.ENABLE_OVERRIDE_MIGRATION_URL = originalEnv;
+        }));
+        it('should handle mixed success and failure response', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockMarkDeployedResponse = {
+                success: ['cct-1'],
+                failed: [
+                    { cctId: 'cct-2', error: 'Component not found' },
+                    { cctId: 'cct-3', error: 'Already deployed' },
+                ],
+            };
+            mockMarkComponentsDeployed.markComponentsDeployed.mockResolvedValue(mockMarkDeployedResponse);
+            const program = (0, mark_deployed_1.default)();
+            yield program.parseAsync(['node', 'dxp-cli', '--cct-ids', './ccts.json']);
+            expect(mockMarkComponentsDeployed.markComponentsDeployed).toHaveBeenCalledTimes(1);
+            expect(mockUtils.handleCommandError).not.toHaveBeenCalled();
+        }));
+    });
+    describe('error scenarios', () => {
+        it('should handle markComponentsDeployed API error', () => __awaiter(void 0, void 0, void 0, function* () {
+            const apiError = new Error('Failed to mark components as deployed');
+            mockMarkComponentsDeployed.markComponentsDeployed.mockRejectedValue(apiError);
+            mockUtils.handleCommandError.mockImplementation((() => { }));
+            const program = (0, mark_deployed_1.default)();
+            yield program.parseAsync(['node', 'dxp-cli', '--cct-ids', './ccts.json']);
+            expect(mockUtils.handleCommandError).toHaveBeenCalledWith(program, apiError);
+        }));
+        it('should handle network error', () => __awaiter(void 0, void 0, void 0, function* () {
+            const networkError = new Error('Network connection failed');
+            mockMarkComponentsDeployed.markComponentsDeployed.mockRejectedValue(networkError);
+            mockUtils.handleCommandError.mockImplementation((() => { }));
+            const program = (0, mark_deployed_1.default)();
+            yield program.parseAsync(['node', 'dxp-cli', '--cct-ids', './ccts.json']);
+            expect(mockUtils.handleCommandError).toHaveBeenCalledWith(program, networkError);
+        }));
+        it('should handle empty CCT IDs', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockLoadAssetIds.loadAssetIdsFromFile.mockReturnValue([]);
+            mockUtils.handleCommandError.mockImplementation((() => { }));
+            const program = (0, mark_deployed_1.default)();
+            yield program.parseAsync([
+                'node',
+                'dxp-cli',
+                '--cct-ids',
+                './empty-ccts.json',
+            ]);
+            expect(mockUtils.handleCommandError).toHaveBeenCalledWith(program, expect.objectContaining({
+                message: 'No CCT IDs provided',
+            }));
+        }));
+        it('should handle undefined CCT IDs', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockLoadAssetIds.loadAssetIdsFromFile.mockReturnValue(undefined);
+            mockUtils.handleCommandError.mockImplementation((() => { }));
+            const program = (0, mark_deployed_1.default)();
+            yield program.parseAsync([
+                'node',
+                'dxp-cli',
+                '--cct-ids',
+                './invalid-ccts.json',
+            ]);
+            expect(mockUtils.handleCommandError).toHaveBeenCalledWith(program, expect.objectContaining({
+                message: 'No CCT IDs provided',
+            }));
+        }));
+    });
+    describe('required options validation', () => {
+        it('should require cct-ids option', () => {
+            const program = (0, mark_deployed_1.default)().exitOverride();
+            expect(() => {
+                program.parse(['node', 'dxp-cli']);
+            }).toThrow();
+        });
+        it('should not require tenant option', () => {
+            const program = (0, mark_deployed_1.default)().exitOverride();
+            expect(() => {
+                program.parse(['node', 'dxp-cli', '--cct-ids', './ccts.json']);
+            }).not.toThrow();
+        });
+    });
+    describe('command configuration', () => {
+        it('should have correct command name and description', () => {
+            const program = (0, mark_deployed_1.default)();
+            expect(program.name()).toBe('mark-deployed');
+            expect(program.description()).toBe('Mark components as deployed in the AI Page Migration service');
+        });
+        it('should parse options correctly', () => {
+            const program = (0, mark_deployed_1.default)();
+            program.parse([
+                'node',
+                'dxp-cli',
+                '--cct-ids',
+                './ccts.json',
+                '--tenant',
+                'test-tenant',
+            ]);
+            const opts = program.opts();
+            expect(opts.cctIds).toBe('./ccts.json');
+            expect(opts.tenant).toBe('test-tenant');
+        });
+    });
+});

package/lib/migration/next/next.spec.js

@@ -41,6 +41,7 @@ const utils = __importStar(require("../utils/common"));
 const ApplicationStore = __importStar(require("../../ApplicationStore"));
 const nextStageModule = __importStar(require("../utils/nextStage"));
 const getMigrationModule = __importStar(require("../utils/getMigration"));
+const types_1 = require("../types");
 jest.mock('../utils/common');
 jest.mock('../utils/nextStage');
 jest.mock('../utils/getMigration');
@@ -66,8 +67,8 @@ describe('nextStageCommand', () => {
         mockGetMigration.getMigration.mockResolvedValue({
             migrationId: 'migration-123',
             assetId: 'asset-456',
-            stage: 'validation',
-            status: 'completed',
+            stage: types_1.MigrationStage.create,
+            status: types_1.MigrationStatus.running,
             xmlFilePath: 'test.xml',
             matrixUrl: 'http://test.com',
             previewAssetId: 'preview-123',
@@ -159,7 +160,7 @@ describe('nextStageCommand', () => {
         it('should handle getMigration error', () => __awaiter(void 0, void 0, void 0, function* () {
             const migrationError = new Error('Failed to get migration: TypeError: Invalid URL');
             mockGetMigration.getMigration.mockRejectedValue(migrationError);
-            mockUtils.handleCommandError.mockImplementation(() => { });
+            mockUtils.handleCommandError.mockImplementation((() => { }));
             const program = (0, next_1.default)();
             yield program.parseAsync([
                 'node',
@@ -175,7 +176,7 @@ describe('nextStageCommand', () => {
         it('should handle nextStage API error', () => __awaiter(void 0, void 0, void 0, function* () {
             const apiError = new Error('Failed to start next stage');
             mockNextStage.nextStage.mockRejectedValue(apiError);
-            mockUtils.handleCommandError.mockImplementation(() => { });
+            mockUtils.handleCommandError.mockImplementation((() => { }));
             const program = (0, next_1.default)();
             yield program.parseAsync([
                 'node',
@@ -191,7 +192,7 @@ describe('nextStageCommand', () => {
         it('should handle network error', () => __awaiter(void 0, void 0, void 0, function* () {
             const networkError = new Error('Network connection failed');
             mockNextStage.nextStage.mockRejectedValue(networkError);
-            mockUtils.handleCommandError.mockImplementation(() => { });
+            mockUtils.handleCommandError.mockImplementation((() => { }));
             const program = (0, next_1.default)();
             yield program.parseAsync([
                 'node',

package/lib/migration/pre/pre.js

@@ -16,7 +16,7 @@ const commander_1 = require("commander");
 const chalk_1 = __importDefault(require("chalk"));
 const ora_1 = __importDefault(require("ora"));
 const utils_1 = require("../utils");
-const loadCctIdsFromFile_1 = require("../utils/loadCctIdsFromFile");
+const loadAssetIdsFromFile_1 = require("../utils/loadAssetIdsFromFile");
 const preMigrationCommand = () => {
     const preCommand = new commander_1.Command('pre')
         .name('pre')
@@ -33,13 +33,13 @@ const preMigrationCommand = () => {
         yield (0, utils_1.throwErrorIfNotLoggedIn)(preCommand);
         const spinner = (0, ora_1.default)('Creating pre-migration').start();
         try {
-            const cctIds = (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(options.cctIds);
+            const cctIds = (0, loadAssetIdsFromFile_1.loadAssetIdsFromFile)(options.cctIds);
             // Create pre-migration
             const response = yield (0, utils_1.createMigration)(Object.assign(Object.assign({}, options), { cctIds }));
             if (!response) {
                 throw new Error('Pre-migration creation failed');
             }
-            spinner.succeed((0, utils_1.buildMigrationSuccessMessage)('pre-migration', response.assetMigration));
+            spinner.succeed((0, utils_1.buildMigrationSuccessMessage)('pre-migration', response));
         }
         catch (error) {
             spinner.fail();

package/lib/migration/pre/pre.spec.js

@@ -39,10 +39,10 @@ const nock_1 = __importDefault(require("nock"));
 const pre_1 = __importDefault(require("./pre"));
 const utils = __importStar(require("../utils/common"));
 const createMigration = __importStar(require("../utils/createMigration"));
-const loadCctIdsFromFile = __importStar(require("../utils/loadCctIdsFromFile"));
+const loadCctIdsFromFile = __importStar(require("../utils/loadAssetIdsFromFile"));
 jest.mock('../utils/common');
 jest.mock('../utils/createMigration');
-jest.mock('../utils/loadCctIdsFromFile');
+jest.mock('../utils/loadAssetIdsFromFile');
 const mockUtils = utils;
 const mockCreateMigration = createMigration;
 const mockLoadCctIdsFromFile = loadCctIdsFromFile;
@@ -56,7 +56,7 @@ describe('preMigrationCommand', () => {
         logSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
         mockUtils.throwErrorIfNotLoggedIn.mockResolvedValue(undefined);
         mockUtils.buildMigrationSuccessMessage.mockReturnValue('Pre-migration created successfully');
-        mockLoadCctIdsFromFile.loadCctIdsFromFile.mockReturnValue([
+        mockLoadCctIdsFromFile.loadAssetIdsFromFile.mockReturnValue([
             'cct-id-1',
             'cct-id-2',
         ]);
@@ -91,7 +91,7 @@ describe('preMigrationCommand', () => {
                 '/path/to/cct-ids.json',
             ]);
             expect(mockUtils.throwErrorIfNotLoggedIn).toHaveBeenCalledWith(program);
-            expect(mockLoadCctIdsFromFile.loadCctIdsFromFile).toHaveBeenCalledWith('/path/to/cct-ids.json');
+            expect(mockLoadCctIdsFromFile.loadAssetIdsFromFile).toHaveBeenCalledWith('/path/to/cct-ids.json');
             expect(mockCreateMigration.createMigration).toHaveBeenCalledWith({
                 matrixUrl: 'https://matrix.example.com',
                 cctIds: ['cct-id-1', 'cct-id-2'],
@@ -142,7 +142,7 @@ describe('preMigrationCommand', () => {
     describe('error scenarios', () => {
         it('should handle pre-migration creation failure', () => __awaiter(void 0, void 0, void 0, function* () {
             mockCreateMigration.createMigration.mockResolvedValue(null);
-            mockUtils.handleCommandError.mockImplementation(() => { });
+            mockUtils.handleCommandError.mockImplementation((() => { }));
             const program = (0, pre_1.default)();
             yield program.parseAsync([
                 'node',
@@ -157,7 +157,7 @@ describe('preMigrationCommand', () => {
         it('should handle migration API error', () => __awaiter(void 0, void 0, void 0, function* () {
             const apiError = new Error('Migration API failed');
             mockCreateMigration.createMigration.mockRejectedValue(apiError);
-            mockUtils.handleCommandError.mockImplementation(() => { });
+            mockUtils.handleCommandError.mockImplementation((() => { }));
             const program = (0, pre_1.default)();
             yield program.parseAsync([
                 'node',
@@ -187,10 +187,10 @@ describe('preMigrationCommand', () => {
         }));
         it('should handle loadCctIdsFromFile error', () => __awaiter(void 0, void 0, void 0, function* () {
             const loadError = new Error('Failed to load CCT IDs from file');
-            mockLoadCctIdsFromFile.loadCctIdsFromFile.mockImplementation(() => {
+            mockLoadCctIdsFromFile.loadAssetIdsFromFile.mockImplementation(() => {
                 throw loadError;
             });
-            mockUtils.handleCommandError.mockImplementation(() => { });
+            mockUtils.handleCommandError.mockImplementation((() => { }));
             const program = (0, pre_1.default)();
             yield program.parseAsync([
                 'node',

package/lib/migration/revert/revert.js

@@ -20,7 +20,7 @@ const options_1 = require("../utils/options");
 const revertMigrationCommand = () => {
     const revertCommand = new commander_1.Command('revert')
         .name('revert')
-        .description('Revert the current stage of a migration using the AI Page migration service')
+        .description('Revert asset with stage "morph" and status "awaiting-confirmation" using the AI Page migration service')
         .addOption((0, options_1.getParamOption)(options_1.OptionName.MIGRATION_ID))
         .addOption((0, options_1.getParamOption)(options_1.OptionName.ASSET_ID, false))
         .addOption((0, options_1.getParamOption)(options_1.OptionName.TENANT, false))

package/lib/migration/revert/revert.spec.js

@@ -52,7 +52,7 @@ describe('revertMigrationCommand', () => {
         it('should have correct command name and description', () => {
             const program = (0, revert_1.default)();
             expect(program.name()).toBe('revert');
-            expect(program.description()).toBe('Revert the current stage of a migration using the AI Page migration service');
+            expect(program.description()).toBe('Revert asset with stage "morph" and status "awaiting-confirmation" using the AI Page migration service');
         });
         it('should have required migration-id option', () => {
             const program = (0, revert_1.default)();

package/lib/migration/settings/settings.spec.js

@@ -186,7 +186,7 @@ describe('setMigrationSettingsCommand', () => {
         it('should handle setMigrationSetting API error', () => __awaiter(void 0, void 0, void 0, function* () {
             const apiError = new Error('Settings update failed');
             mockSetMigrationSettings.setMigrationSettings.mockRejectedValue(apiError);
-            mockUtils.handleCommandError.mockImplementation(() => { });
+            mockUtils.handleCommandError.mockImplementation((() => { }));
             const program = (0, settings_1.default)();
             yield program.parseAsync([
                 'node',
@@ -207,7 +207,7 @@ describe('setMigrationSettingsCommand', () => {
         it('should handle network error', () => __awaiter(void 0, void 0, void 0, function* () {
             const networkError = new Error('Network connection failed');
             mockSetMigrationSettings.setMigrationSettings.mockRejectedValue(networkError);
-            mockUtils.handleCommandError.mockImplementation(() => { });
+            mockUtils.handleCommandError.mockImplementation((() => { }));
             const program = (0, settings_1.default)();
             yield program.parseAsync([
                 'node',

package/lib/migration/types/common.types.d.ts

@@ -2,6 +2,20 @@ export interface CommonCommandOptions {
     tenant?: string;
     overrideUrl?: string;
 }
+export declare enum MigrationStage {
+    create = "create",
+    exportToJson = "export-to-json",
+    cctExport = "cct-export",
+    mapFromCctToCmp = "map-from-cct-to-cmp",
+    preview = "preview",
+    morph = "morph"
+}
+export declare enum MigrationStatus {
+    running = "running",
+    awaitingConfirmation = "awaiting-confirmation",
+    complete = "complete",
+    failed = "failed"
+}
 export interface AssetMigration {
     /**
      * Will be programmatically set while creating a migration or pre-migration,
@@ -13,17 +27,34 @@ export interface AssetMigration {
      * In migrations, this will be the CCT IDs to be skipped (because they were already converted and deployed).
      */
     cctIds?: string[];
+    /**
+     * Whether to trigger the next stage of the migration automatically.
+     * This will automatically be set to true for pre and bulk migrations.
+     * For single asset migrations, it will be set to false by default but can be overridden by the user.
+     */
+    triggerNextStage?: boolean;
     migrationId: string;
     assetId: string;
     xmlFilePath: string;
     matrixUrl: string;
     previewAssetId: string;
     previewPageAssetId?: string;
-    stage: string;
-    status: string;
+    stage: MigrationStage;
+    status: MigrationStatus;
     stageDetails?: string;
+    stageOptions?: Record<string, unknown>;
     created: number;
     updated: number;
     migrationIdAssetId: string;
     componentsTarDownloadUrl?: string;
 }
+declare type MigrationStageRecord = Partial<Record<MigrationStatus, {
+    assetIds: string[];
+}>>;
+export declare type AssetMigrationSummary = {
+    created: number;
+    expiry: number;
+    migrationId: string;
+    cctIds?: string[];
+} & Partial<Record<MigrationStage, MigrationStageRecord>>;
+export {};

package/lib/migration/types/common.types.js

@@ -1,2 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrationStatus = exports.MigrationStage = void 0;
+var MigrationStage;
+(function (MigrationStage) {
+    MigrationStage["create"] = "create";
+    MigrationStage["exportToJson"] = "export-to-json";
+    MigrationStage["cctExport"] = "cct-export";
+    MigrationStage["mapFromCctToCmp"] = "map-from-cct-to-cmp";
+    MigrationStage["preview"] = "preview";
+    MigrationStage["morph"] = "morph";
+})(MigrationStage = exports.MigrationStage || (exports.MigrationStage = {}));
+var MigrationStatus;
+(function (MigrationStatus) {
+    MigrationStatus["running"] = "running";
+    MigrationStatus["awaitingConfirmation"] = "awaiting-confirmation";
+    MigrationStatus["complete"] = "complete";
+    MigrationStatus["failed"] = "failed";
+})(MigrationStatus = exports.MigrationStatus || (exports.MigrationStatus = {}));

package/lib/migration/types/createMigration.types.d.ts

@@ -1,10 +1,48 @@
-import { AssetMigration, CommonCommandOptions } from '.';
-export interface CreateMigrationOptions extends CommonCommandOptions, Pick<AssetMigration, 'assetId' | 'previewAssetId' | 'matrixUrl'> {
+import { AssetMigration, BatchNextStageResults, CommonCommandOptions, StageOptions, AssetMigrationSummary } from '.';
+export interface CreateMigrationOptions extends CommonCommandOptions, Pick<AssetMigration, 'previewAssetId' | 'matrixUrl'> {
+    /**
+     * Optional for bulk migrations, required for single asset migrations.
+     */
+    assetId?: string;
+    /**
+     * The path to a JSON file containing the IDs of the assets to be migrated. Required for bulk migrations, optional for single asset migrations.
+     */
+    assetIds?: string;
     /**
      * The path to a JSON file containing the CCT IDs to be skipped in a migration (because they were already converted and deployed)
      */
     cctIds?: string;
+    /**
+     * The path to a JSON file containing stage options for the next stage of the migration.
+     */
+    stageOptions?: string;
+    /**
+     * Whether to trigger the next stage of the migration automatically.
+     * This will automatically be set to true for pre and bulk migrations.
+     * For single asset migrations, it will be set to false by default but can be overridden by the user.
+     */
+    triggerNextStage?: boolean;
+}
+export interface CreateMigrationInput extends Omit<CreateMigrationOptions, 'stageOptions' | 'cctIds' | 'assetId' | 'assetIds' | 'previewAssetId'> {
+    /**
+     * The IDs of the assets to be migrated.
+     */
+    assetIds?: string[];
+    /**
+     * The CCT IDs to be skipped in a migration (because they were already converted and deployed).
+     */
+    cctIds?: string[];
+    /**
+     * Stage options for the next stage of the migration.
+     */
+    stageOptions?: StageOptions;
+    /**
+     * The ID of the folder that will be used as the parent of the migrated asset generated during the Preview stage.
+     */
+    previewAssetId?: string;
 }
 export interface CreateMigrationApiResponse {
-    assetMigration: AssetMigration;
+    assetMigration?: AssetMigration;
+    summary?: AssetMigrationSummary;
+    nextStageResults?: BatchNextStageResults;
 }

package/lib/migration/types/getMigration.types.d.ts

@@ -1,5 +1,9 @@
-import { AssetMigration, CommonCommandOptions } from '.';
+import { AssetMigration, CommonCommandOptions, AssetMigrationSummary } from '.';
 export interface GetMigrationOptions extends CommonCommandOptions, Pick<AssetMigration, 'migrationId' | 'assetId'> {
 }
 export interface GetMigrationApiResponse extends AssetMigration {
 }
+export interface BatchGetMigrationOptions extends CommonCommandOptions, Pick<AssetMigration, 'migrationId'> {
+}
+export interface BatchGetMigrationApiResponse extends AssetMigrationSummary {
+}

package/lib/migration/types/index.d.ts

@@ -5,3 +5,4 @@ export * from './nextStage.types';
 export * from './preMigration.types';
 export * from './settings.types';
 export * from './revert.types';
+export * from './markDeployed.types';

package/lib/migration/types/index.js

@@ -21,3 +21,4 @@ __exportStar(require("./nextStage.types"), exports);
 __exportStar(require("./preMigration.types"), exports);
 __exportStar(require("./settings.types"), exports);
 __exportStar(require("./revert.types"), exports);
+__exportStar(require("./markDeployed.types"), exports);

package/lib/migration/types/markDeployed.types.d.ts

@@ -0,0 +1,20 @@
+import { CommonCommandOptions } from '.';
+export interface MarkDeployedOptions extends CommonCommandOptions {
+    /**
+     * Path to a JSON file containing the CCT IDs to mark as deployed
+     */
+    cctIds: string;
+}
+export interface MarkDeployedInput extends CommonCommandOptions {
+    /**
+     * The CCT IDs to mark as deployed
+     */
+    cctIds: string[];
+}
+export interface MarkDeployedApiResponse {
+    success: string[];
+    failed: {
+        cctId: string;
+        error: string;
+    }[];
+}

package/lib/migration/types/markDeployed.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/migration/types/nextStage.types.d.ts

@@ -1,10 +1,31 @@
 import { AssetMigration, CommonCommandOptions } from '.';
+export interface StageOptions {
+    [key: string]: unknown;
+}
 export interface NextStageOptions extends CommonCommandOptions, Pick<AssetMigration, 'migrationId' | 'assetId'> {
     stageOptions?: string;
 }
 export interface NextStageParsedOptions extends Omit<NextStageOptions, 'stageOptions'> {
-    stageOptions?: Record<string, any>;
+    stageOptions?: StageOptions;
 }
 export interface NextStageApiResponse {
     message: string;
 }
+export interface BatchNextStageResults {
+    success: {
+        assetIds: string[];
+        message: string;
+    }[];
+    failed: {
+        assetIds: string[];
+        error: string;
+    }[];
+}
+export interface BatchNextStageApiResponse extends BatchNextStageResults {
+}
+export interface BatchNextStageOptions extends CommonCommandOptions, Pick<AssetMigration, 'migrationId' | 'stage'> {
+    stageOptions?: string;
+}
+export interface BatchNextStageParsedOptions extends Omit<BatchNextStageOptions, 'stageOptions'> {
+    stageOptions?: StageOptions;
+}

package/lib/migration/types/revert.types.d.ts

@@ -4,3 +4,15 @@ export interface RevertMigrationOptions extends CommonCommandOptions, Pick<Asset
 export interface RevertMigrationApiResponse {
     message: string;
 }
+export interface BatchRevertMigrationOptions extends CommonCommandOptions, Pick<AssetMigration, 'migrationId'> {
+}
+export interface BatchRevertMigrationApiResponse {
+    success: {
+        assetIds: string[];
+        message: string;
+    }[];
+    failed: {
+        assetIds: string[];
+        error: string;
+    }[];
+}