@kontent-ai/migration-toolkit 2.9.1 → 3.0.0-1

package/lib/core/models/core.models.ts

@@ -1,169 +1,180 @@
 import type {
-    AssetModels,
-    ContentItemModels,
-    ContentTypeElements,
-    LanguageVariantModels,
-    WorkflowModels
-} from '@kontent-ai/management-sdk';
-import type { MigrationElementType } from './migration.models.js';
+	AssetModels,
+	ContentItemModels,
+	ContentTypeElements,
+	LanguageVariantModels,
+	WorkflowModels,
+} from "@kontent-ai/management-sdk";
+import type { MigrationElementType } from "./migration.models.js";
 
 export type LiteralUnion<T extends string> = T | (string & {});
-export type TargetItemState = 'exists' | 'doesNotExists';
-export type CliAction = 'export' | 'import' | 'migrate';
-export type EnvContext = 'browser' | 'node';
+export type TargetItemState = "exists" | "doesNotExists";
+export type CliAction = "export" | "import" | "migrate";
+export type EnvContext = "browser" | "node";
 
 export type MapiAction =
-    | 'list'
-    | 'view'
-    | 'archive'
-    | 'unpublish'
-    | 'changeWorkflowStep'
-    | 'publish'
-    | 'upload'
-    | 'create'
-    | 'upsert'
-    | 'schedulePublish'
-    | 'scheduleUnpublish'
-    | 'cancelScheduledPublish'
-    | 'cancelScheduledUnpublish'
-    | 'createNewVersion';
-
-export type MigrationItemType = 'exportItem';
+	| "list"
+	| "view"
+	| "archive"
+	| "unpublish"
+	| "changeWorkflowStep"
+	| "publish"
+	| "upload"
+	| "create"
+	| "upsert"
+	| "schedulePublish"
+	| "scheduleUnpublish"
+	| "cancelScheduledPublish"
+	| "cancelScheduledUnpublish"
+	| "createNewVersion";
+
+export type MigrationItemType = "exportItem";
 
 export type MapiType =
-    | 'contentType'
-    | 'assetFolder'
-    | 'asset'
-    | 'contentTypeSnippet'
-    | 'contentItem'
-    | 'languageVariant'
-    | 'language'
-    | 'collection'
-    | 'taxonomy'
-    | 'binaryFile'
-    | 'workflow';
-
-export type LanguageVariantWorkflowStateValues = 'published' | 'archived' | 'draft' | 'scheduled';
-export type LanguageVariantSchedulesStateValues = 'scheduledPublish' | 'scheduledUnpublish' | 'n/a';
+	| "contentType"
+	| "assetFolder"
+	| "asset"
+	| "contentTypeSnippet"
+	| "contentItem"
+	| "languageVariant"
+	| "language"
+	| "collection"
+	| "taxonomy"
+	| "binaryFile"
+	| "workflow";
+
+export type LanguageVariantWorkflowStateValues = "published" | "archived" | "draft" | "scheduled";
+export type LanguageVariantSchedulesStateValues = "scheduledPublish" | "scheduledUnpublish" | "n/a";
 export type LanguageVariantWorkflowState =
-    | {
-          readonly workflowState: LanguageVariantWorkflowStateValues;
-          readonly scheduledState: LanguageVariantSchedulesStateValues;
-      }
-    | undefined;
+	| {
+			readonly workflowState: LanguageVariantWorkflowStateValues;
+			readonly scheduledState: LanguageVariantSchedulesStateValues;
+	  }
+	| undefined;
 
 export interface ItemInfo {
-    readonly title: string;
-    readonly itemType: MapiType | MigrationItemType;
+	readonly title: string;
+	readonly itemType: MapiType | MigrationItemType;
 }
 
 export interface ErrorData {
-    readonly message: string;
-    readonly requestData?: string;
-    readonly requestUrl?: string;
-    readonly isUnknownError: boolean;
-    readonly error: unknown;
+	readonly message: string;
+	readonly requestData?: string;
+	readonly requestUrl?: string;
+	readonly isUnknownError: boolean;
+	readonly error: unknown;
 }
 
 export interface ReferencedDataInMigrationItems {
-    readonly itemCodenames: ReadonlySet<string>;
-    readonly assetCodenames: ReadonlySet<string>;
+	readonly itemCodenames: ReadonlySet<string>;
+	readonly assetCodenames: ReadonlySet<string>;
 }
 
 export interface ReferencedDataInLanguageVariants {
-    readonly itemIds: ReadonlySet<string>;
-    readonly assetIds: ReadonlySet<string>;
+	readonly itemIds: ReadonlySet<string>;
+	readonly assetIds: ReadonlySet<string>;
 }
 
-export interface ItemStateInSourceEnvironmentById {
-    readonly state: TargetItemState;
-    readonly id: string;
-    readonly item: Readonly<ContentItemModels.ContentItem> | undefined;
-}
-
-export interface AssetStateInSourceEnvironmentById {
-    readonly state: TargetItemState;
-    readonly id: string;
-    readonly asset: Readonly<AssetModels.Asset> | undefined;
-}
+type DataStateInSourceEnvironmentById<T extends Readonly<ContentItemModels.ContentItem> | Readonly<AssetModels.Asset>> = {
+	readonly id: string;
+} & (
+	| {
+			readonly state: "exists";
+			readonly data: T;
+	  }
+	| {
+			readonly state: "doesNotExists";
+			readonly data?: never;
+	  }
+	| {
+			readonly state: "skip";
+			readonly data?: never;
+	  }
+);
+
+export type ItemStateInSourceEnvironmentById = DataStateInSourceEnvironmentById<Readonly<ContentItemModels.ContentItem>>;
+
+export type AssetStateInSourceEnvironmentById = DataStateInSourceEnvironmentById<Readonly<AssetModels.Asset>>;
 
 export interface ItemStateInTargetEnvironmentByCodename {
-    readonly state: TargetItemState;
-    readonly itemCodename: string;
-    readonly item: Readonly<ContentItemModels.ContentItem> | undefined;
-    readonly externalIdToUse: string;
+	readonly state: TargetItemState;
+	readonly itemCodename: string;
+	readonly item: Readonly<ContentItemModels.ContentItem> | undefined;
+	readonly externalIdToUse: string;
 }
 
 export interface LanguageVariantStateData {
-    readonly languageVariant: Readonly<LanguageVariantModels.ContentItemLanguageVariant> | undefined;
-    readonly workflow: Readonly<WorkflowModels.Workflow> | undefined;
-    readonly workflowState: LanguageVariantWorkflowState;
+	readonly languageVariant: Readonly<LanguageVariantModels.ContentItemLanguageVariant> | undefined;
+	readonly workflow: Readonly<WorkflowModels.Workflow> | undefined;
+	readonly workflowState: LanguageVariantWorkflowState;
 }
 
 export interface LanguageVariantStateInTargetEnvironmentByCodename {
-    readonly state: TargetItemState;
-    readonly itemCodename: string;
-    readonly languageCodename: string;
-    readonly publishedLanguageVariant: LanguageVariantStateData | undefined;
-    readonly draftLanguageVariant: LanguageVariantStateData | undefined;
+	readonly state: TargetItemState;
+	readonly itemCodename: string;
+	readonly languageCodename: string;
+	readonly publishedLanguageVariant: LanguageVariantStateData | undefined;
+	readonly draftLanguageVariant: LanguageVariantStateData | undefined;
 }
 
 export interface AssetStateInTargetEnvironmentByCodename {
-    readonly state: TargetItemState;
-    readonly assetCodename: string;
-    readonly asset: Readonly<AssetModels.Asset> | undefined;
-    readonly externalIdToUse: string;
+	readonly state: TargetItemState;
+	readonly assetCodename: string;
+	readonly asset: Readonly<AssetModels.Asset> | undefined;
+	readonly externalIdToUse: string;
 }
 
 export interface PackageMetadata {
-    readonly created: Date;
-    readonly environmentId: string;
-    readonly dataOverview: PackageDataOverview;
+	readonly created: Date;
+	readonly environmentId: string;
+	readonly dataOverview: PackageDataOverview;
 }
 
 export interface PackageDataOverview {
-    readonly contentItemsCount: number;
-    readonly assetsCount: number;
+	readonly contentItemsCount: number;
+	readonly assetsCount: number;
 }
 
 export interface FlattenedContentTypeElement {
-    readonly codename: string;
-    readonly id: string;
-    readonly type: MigrationElementType;
-    readonly element: Readonly<ContentTypeElements.ContentTypeElementModel>;
+	readonly codename: string;
+	readonly name: string | undefined;
+	readonly id: string;
+	readonly type: MigrationElementType;
+	readonly element: Readonly<ContentTypeElements.ContentTypeElementModel>;
 }
 
 export interface FlattenedContentType {
-    readonly contentTypeCodename: string;
-    readonly contentTypeId: string;
-    readonly elements: readonly FlattenedContentTypeElement[];
+	readonly contentTypeCodename: string;
+	readonly name: string;
+	readonly contentTypeId: string;
+	readonly elements: readonly FlattenedContentTypeElement[];
 }
 
 export interface OriginalManagementError {
-    readonly response?: {
-        readonly status?: number;
-        readonly config?: {
-            readonly url?: string;
-            readonly data?: string;
-        };
-        readonly data?: {
-            readonly error_code?: number;
-        };
-    };
+	readonly response?: {
+		readonly status?: number;
+		readonly config?: {
+			readonly url?: string;
+			readonly data?: string;
+		};
+		readonly data?: {
+			readonly error_code?: number;
+		};
+	};
 }
 
 export type ItemProcessingResult<InputItem, OutputItem> =
-    | {
-          readonly state: 'valid';
-          readonly inputItem: InputItem;
-          readonly outputItem: OutputItem;
-      }
-    | {
-          readonly state: 'error';
-          readonly inputItem: InputItem;
-          readonly error: unknown;
-      }
-    | {
-          readonly state: '404';
-          readonly inputItem: InputItem;
-      };
+	| {
+			readonly state: "valid";
+			readonly inputItem: InputItem;
+			readonly outputItem: OutputItem;
+	  }
+	| {
+			readonly state: "error";
+			readonly inputItem: InputItem;
+			readonly error: unknown;
+	  }
+	| {
+			readonly state: "404";
+			readonly inputItem: InputItem;
+	  };

package/lib/core/models/error.models.ts

@@ -0,0 +1,148 @@
+import chalk from "chalk";
+import { match, P } from "ts-pattern";
+import type { ExportItem, ExportItemVersion } from "../../export/export.models.js";
+import type { ErrorData, FlattenedContentType, FlattenedContentTypeElement } from "./core.models.js";
+
+const missingReferencesMessage = `You can skip missing references using the '${chalk.green("skipMissingReferences")}' option.`;
+
+export type MigrationToolkitErrorType =
+	| "confirmationRefused"
+	| "invalidZip"
+	| "invalidFolder"
+	| "unsupportedCommand"
+	| "importFailedForItem"
+	| "invalidElement"
+	| "exportFailedForItem"
+	| "missingContentType"
+	| "invalidEnvironment"
+	| "exitProgram"
+	| "missingItem"
+	| "findRequiredError"
+	| "missingWorkflowStep"
+	| "missingAsset"
+	| "missingTaxonomyTerm"
+	| "invalidValue"
+	| "invalidMultipleChoiceOption";
+
+export class MigrationToolkitError extends Error {
+	constructor(
+		public readonly type: MigrationToolkitErrorType,
+		readonly message: string,
+	) {
+		super(message);
+	}
+}
+
+export class MissingItemError extends MigrationToolkitError {
+	constructor(public readonly id: string) {
+		super("missingItem", `Missing item with id '${chalk.red(id)}'`);
+	}
+}
+
+export class MissingAssetError extends MigrationToolkitError {
+	constructor(public readonly id: string) {
+		super("missingAsset", `Missing asset with id '${chalk.red(id)}'`);
+	}
+}
+
+export class InvalidValueError extends MigrationToolkitError {
+	constructor({
+		element,
+		value,
+		contentType,
+		errorData,
+		exportItem,
+		exportItemVersion,
+	}: {
+		readonly exportItem: ExportItem;
+		readonly exportItemVersion: ExportItemVersion;
+		readonly element: FlattenedContentTypeElement;
+		readonly contentType: FlattenedContentType;
+		readonly value: unknown;
+		readonly errorData: ErrorData;
+	}) {
+		const { missingReferenceId, isMissingReference } = match(errorData.error)
+			.returnType<{ readonly missingReferenceId: string | undefined; readonly isMissingReference: boolean }>()
+			.when(
+				(m) => m instanceof MissingAssetError || m instanceof MissingItemError,
+				(m) => {
+					return {
+						missingReferenceId: m.id,
+						isMissingReference: true,
+					};
+				},
+			)
+			.otherwise(() => {
+				return {
+					missingReferenceId: undefined,
+					isMissingReference: false,
+				};
+			});
+
+		const getValueToDisplay = () => {
+			let jsonValue: string | undefined;
+
+			try {
+				jsonValue = JSON.stringify(value, null, 2);
+			} catch {
+				jsonValue = undefined;
+			}
+
+			const baseValue = match(jsonValue)
+				.returnType<string>()
+				.with(P.string, (jsonValue) =>
+					jsonValue
+						.split("\n")
+						.map((line) => `  ${line}`)
+						.join("\n"),
+				)
+				.otherwise(() => value?.toString() ?? "");
+
+			// Highlight missing reference ID in red if present
+			return missingReferenceId ? baseValue.replaceAll(missingReferenceId, chalk.red(missingReferenceId)) : baseValue;
+		};
+
+		const lines: readonly string[] = [
+			"",
+			chalk.red("❌ Invalid value error"),
+			"",
+			`${chalk.cyan("📝 Content type:")}`,
+			`  ${chalk.gray("├─")} Name:     ${chalk.yellow.bold(contentType.name)}`,
+			`  ${chalk.gray("├─")} Codename: ${chalk.yellow.bold(contentType.contentTypeCodename)}`,
+			`  ${chalk.gray("└─")} ID:       ${chalk.dim(contentType.contentTypeId)}`,
+			"",
+			`${chalk.cyan("🔧 Element:")}`,
+			`  ${chalk.gray("├─")} Name:     ${chalk.yellow.bold(element.name)}`,
+			`  ${chalk.gray("├─")} Codename: ${chalk.yellow.bold(element.codename)}`,
+			`  ${chalk.gray("├─")} Type:     ${chalk.green.bold(element.type)}`,
+			`  ${chalk.gray("└─")} ID:       ${chalk.dim(element.id)}`,
+			"",
+			`${chalk.cyan("📦 Item:")}`,
+			`  ${chalk.gray("├─")} Item codename: ${chalk.yellow.bold(exportItem.requestItem.itemCodename)}`,
+			`  ${chalk.gray("├─")} Language codename: ${chalk.yellow.bold(exportItem.requestItem.languageCodename)}`,
+			`  ${chalk.gray("└─")} Version codename: ${chalk.yellow.bold(exportItemVersion.workflowStepCodename)}`,
+			"",
+			`${chalk.cyan("📦 Item version:")}`,
+			`  ${chalk.gray("├─")} Workflow step codename: ${chalk.yellow.bold(exportItemVersion.workflowStepCodename)}`,
+			`  ${chalk.gray("└─")} Language variant: ${chalk.yellow.bold(exportItemVersion.languageVariant.language.codename)}`,
+			"",
+			chalk.cyan("Invalid Value:"),
+			chalk.dim(getValueToDisplay()),
+			"",
+			...match(errorData.message)
+				.returnType<readonly string[]>()
+				.with(P.string, (message) => [chalk.cyan("Error Details:"), chalk.gray(`  ${message}`), ""])
+				.otherwise(() => []),
+			...match(errorData.requestUrl)
+				.returnType<readonly string[]>()
+				.with(P.string, (requestUrl) => [chalk.cyan("Request URL:"), chalk.gray(`  ${requestUrl}`), ""])
+				.otherwise(() => []),
+			...match(isMissingReference)
+				.returnType<readonly string[]>()
+				.with(true, () => [chalk.cyan("💡 Tip:"), chalk.gray(`  ${missingReferencesMessage}`), ""])
+				.otherwise(() => []),
+		];
+
+		super("invalidValue", lines.join("\n"));
+	}
+}

package/lib/core/models/log.models.ts

@@ -1,34 +1,34 @@
-import type { MapiAction, MapiType, MigrationItemType } from '../index.js';
+import type { MapiAction, MapiType, MigrationItemType } from "./core.models.js";
 
 export type DebugType =
-    | 'error'
-    | 'completed'
-    | 'warning'
-    | 'info'
-    | 'errorData'
-    | 'cancel'
-    | 'process'
-    | 'readFs'
-    | 'skip'
-    | 'writeFs'
-    | 'download'
-    | MigrationItemType
-    | MapiType
-    | MapiAction;
+	| "error"
+	| "completed"
+	| "warning"
+	| "info"
+	| "errorData"
+	| "cancel"
+	| "process"
+	| "readFs"
+	| "skip"
+	| "writeFs"
+	| "download"
+	| MigrationItemType
+	| MapiType
+	| MapiAction;
 
 export interface LogMessage {
-    readonly type?: DebugType;
-    readonly message: string;
+	readonly type?: DebugType;
+	readonly message: string;
 }
 
 export interface LogSpinnerMessage extends LogMessage {
-    readonly prefix?: string;
+	readonly prefix?: string;
 }
 
 export type LogData = (data: LogMessage) => void;
 export type LogSpinnerData = (data: LogSpinnerMessage) => void;
 
 export interface Logger {
-    readonly logWithSpinnerAsync: <T>(func: (logData: LogSpinnerData) => Promise<T>) => Promise<T>;
-    readonly log: LogData;
+	readonly logWithSpinnerAsync: <T>(func: (logData: LogSpinnerData) => Promise<T>) => Promise<T>;
+	readonly log: LogData;
 }

package/lib/core/models/migration.models.ts

@@ -1,83 +1,80 @@
-import type { z } from 'zod';
+import type { z } from "zod";
 import type {
-    MigrationAssetDescriptionSchema,
-    MigrationAssetSchema,
-    MigrationComponentSchema,
-    MigrationDataSchema,
-    MigrationElementSchema,
-    MigrationElementsSchema,
-    MigrationElementTypeSchema,
-    MigrationElementValueSchema,
-    MigrationItemSchema,
-    MigrationItemSystemSchema,
-    MigrationItemVersionSchema,
-    MigrationReferenceSchema,
-    MigrationUrlSlugModeSchema
-} from './migration.schema.js';
+	MigrationAssetDescriptionSchema,
+	MigrationAssetSchema,
+	MigrationComponentSchema,
+	MigrationDataSchema,
+	MigrationElementSchema,
+	MigrationElementsSchema,
+	MigrationElementTypeSchema,
+	MigrationElementValueSchema,
+	MigrationItemSystemSchema,
+	MigrationItemVersionSchema,
+	MigrationReferenceSchema,
+	MigrationUrlSlugModeSchema,
+} from "./migration.schema.js";
 
 export namespace MigrationElementModels {
-    type MigrationElementDef<
-        TElementType extends MigrationElementType = MigrationElementType,
-        TValue extends MigrationElementValue = MigrationElementValue
-    > = {
-        readonly value: TValue | undefined;
-        readonly type: TElementType;
-    };
+	type MigrationElementDef<
+		TElementType extends MigrationElementType = MigrationElementType,
+		TValue extends MigrationElementValue = MigrationElementValue,
+	> = {
+		readonly value: TValue | undefined;
+		readonly type: TElementType;
+	};
 
-    export type TextElement = MigrationElementDef<'text', string>;
-    export type NumberElement = MigrationElementDef<'number', number>;
-    export type RichTextElement = MigrationElementDef<'rich_text', string> & Pick<MigrationElement, 'components'>;
-    export type MultipleChoiceElement = MigrationElementDef<'multiple_choice', MigrationReference[]>;
-    export type DateTimeElement = MigrationElementDef<'date_time', string> & Pick<MigrationElement, 'display_timezone'>;
-    export type AssetElement = MigrationElementDef<'asset', MigrationReference[]>;
-    export type LinkedItemsElement = MigrationElementDef<'modular_content', MigrationReference[]>;
-    export type TaxonomyElement = MigrationElementDef<'taxonomy', MigrationReference[]>;
-    export type UrlSlugElement = MigrationElementDef<'url_slug', string> & Pick<MigrationElement, 'mode'>;
-    export type CustomElement = MigrationElementDef<'custom', string>;
-    export type SubpagesElement = MigrationElementDef<'subpages', MigrationReference[]>;
+	export type TextElement = MigrationElementDef<"text", string>;
+	export type NumberElement = MigrationElementDef<"number", number>;
+	export type RichTextElement = MigrationElementDef<"rich_text", string> & Pick<MigrationElement, "components">;
+	export type MultipleChoiceElement = MigrationElementDef<"multiple_choice", MigrationReference[]>;
+	export type DateTimeElement = MigrationElementDef<"date_time", string> & Pick<MigrationElement, "display_timezone">;
+	export type AssetElement = MigrationElementDef<"asset", MigrationReference[]>;
+	export type LinkedItemsElement = MigrationElementDef<"modular_content", MigrationReference[]>;
+	export type TaxonomyElement = MigrationElementDef<"taxonomy", MigrationReference[]>;
+	export type UrlSlugElement = MigrationElementDef<"url_slug", string> & Pick<MigrationElement, "mode">;
+	export type CustomElement = MigrationElementDef<"custom", string>;
+	export type SubpagesElement = MigrationElementDef<"subpages", MigrationReference[]>;
 }
 
-export type MigrationReference<T extends string = string> = z.infer<typeof MigrationReferenceSchema> & {
-    readonly codename: T;
+export type MigrationReference<T extends string = string> = Omit<z.infer<typeof MigrationReferenceSchema>, "codename"> & {
+	readonly codename: T;
 };
 
 export type MigrationItemSystem<
-    TTypeCodenames extends string = string,
-    TLanguageCodenames extends string = string,
-    TCollectionCodenames extends string = string,
-    TWorkflowCodenames extends string = string
-> = z.infer<typeof MigrationItemSystemSchema> & {
-    readonly codename: string;
-    readonly name: string;
-    readonly language: MigrationReference<TLanguageCodenames>;
-    readonly type: MigrationReference<TTypeCodenames>;
-    readonly collection: MigrationReference<TCollectionCodenames>;
-    readonly workflow: MigrationReference<TWorkflowCodenames>;
+	TTypeCodenames extends string = string,
+	TLanguageCodenames extends string = string,
+	TCollectionCodenames extends string = string,
+	TWorkflowCodenames extends string = string,
+> = Pick<z.infer<typeof MigrationItemSystemSchema>, "codename" | "name"> & {
+	readonly language: MigrationReference<TLanguageCodenames>;
+	readonly type: MigrationReference<TTypeCodenames>;
+	readonly collection: MigrationReference<TCollectionCodenames>;
+	readonly workflow: MigrationReference<TWorkflowCodenames>;
 };
 export type MigrationUrlSlugMode = z.infer<typeof MigrationUrlSlugModeSchema>;
 export type MigrationElementType = z.infer<typeof MigrationElementTypeSchema>;
 export type MigrationComponent = z.infer<typeof MigrationComponentSchema>;
 export type MigrationElementValue = z.infer<typeof MigrationElementValueSchema>;
 export type MigrationElement = z.infer<typeof MigrationElementSchema>;
-export type MigrationElementTransformData = Omit<MigrationElement, 'type'>;
+export type MigrationElementTransformData = Omit<MigrationElement, "type">;
 export type MigrationElements = z.infer<typeof MigrationElementsSchema>;
 export type MigrationAssetDescription = z.infer<typeof MigrationAssetDescriptionSchema>;
 export type MigrationAsset = z.infer<typeof MigrationAssetSchema>;
 export type MigrationData = z.infer<typeof MigrationDataSchema>;
 
 export type MigrationItemVersion<
-    TElements extends MigrationElements = MigrationElements,
-    TWorkflowStepCodenames extends string = string
+	TElements extends MigrationElements = MigrationElements,
+	TWorkflowStepCodenames extends string = string,
 > = z.infer<typeof MigrationItemVersionSchema> & {
-    readonly elements: Readonly<TElements>;
-    readonly workflow_step: MigrationReference<TWorkflowStepCodenames>;
+	readonly elements: Readonly<TElements>;
+	readonly workflow_step: MigrationReference<TWorkflowStepCodenames>;
 };
 
 export type MigrationItem<
-    TElements extends MigrationElements = MigrationElements,
-    TSystem extends MigrationItemSystem = MigrationItemSystem,
-    TWorkflowStepCodenames extends string = string
-> = z.infer<typeof MigrationItemSchema> & {
-    readonly versions: Readonly<MigrationItemVersion<TElements, TWorkflowStepCodenames>[]>;
-    readonly system: TSystem;
+	TElements extends MigrationElements = MigrationElements,
+	TSystem extends MigrationItemSystem = MigrationItemSystem,
+	TWorkflowStepCodenames extends string = string,
+> = {
+	readonly versions: Readonly<MigrationItemVersion<TElements, TWorkflowStepCodenames>[]>;
+	readonly system: TSystem;
 };