@twin.org/entity-storage-models 0.0.3-next.21 → 0.0.3-next.23

package/dist/types/helpers/migrationHelper.d.ts

@@ -1,10 +1,12 @@
-import { type IContextIds } from "@twin.org/context";
 import { type IEntitySchemaDiff } from "@twin.org/entity";
 import type { IEntityStorageConnector } from "../models/IEntityStorageConnector.js";
 import type { IEntityStorageMigrationConnector } from "../models/IEntityStorageMigrationConnector.js";
 import type { IMigrationOptions } from "../models/IMigrationOptions.js";
+import type { IResolvedMigrationStep } from "../models/IResolvedMigrationStep.js";
 /**
- * Helper class for performing schema migrations between two connectors.
+ * Helper class for performing entity schema migrations between two connectors.
+ * The chain-based API (migrateWithChain / applyEntityChain) is the single migration
+ * path: a chain of one step covers the same case as a traditional single-step migration.
  */
 export declare class MigrationHelper {
     /**
@@ -12,50 +14,41 @@ export declare class MigrationHelper {
      */
     static readonly CLASS_NAME: string;
     /**
-     * Performs a migration between two connectors, using the provided options and schema diff to control the migration behaviour.
-     * @param sourceConnector The connector to migrate from to allow the migration helper to create the new connector and finalize the migration.
-     * @param targetEntitySchemaName The name of the new entity schema.
-     * @param renames An optional list of property renames to apply during migration.
-     * @param options Options controlling migration behaviour.
-     * @param loggingComponentType An optional logging component type to use for bootstrapping and starting connectors if necessary.
-     * @returns The connector for the new schema and the number of entities successfully migrated, the sourceConnector will no longer be usable, finalConnector will be undefined if no migration was necessary.
-     */
-    static migrate<T, U>(sourceConnector: IEntityStorageMigrationConnector<T>, targetEntitySchemaName: string, renames?: {
-        from: string;
-        to: string;
-    }[], options?: IMigrationOptions<T, U>, loggingComponentType?: string): Promise<{
-        finalConnector?: IEntityStorageConnector<U>;
-        migrated: number;
-    }>;
-    /**
-     * Generic per-partition migration loop.
-     * @param source Connector to read from (current schema, already bootstrapped).
-     * @param target Connector to write to (new schema, already bootstrapped).
-     * @param partitionContextIds The context ids to use for the migration, used for partitioning and can be used in the transform function when `options.transformEntityProperty` is provided.
-     * @param schemaDiff The schema diff.
-     * @param options Optional migration controls (batchSize, transformEntity, onProgress).
-     * @returns The number of entities successfully migrated.
-     */
-    static migrateEntities<T = unknown, U = T>(source: IEntityStorageMigrationConnector<T>, target: IEntityStorageConnector<U>, partitionContextIds: IContextIds[], schemaDiff: IEntitySchemaDiff<T, U>, options?: IMigrationOptions<T, U>): Promise<number>;
-    /**
-     * Generic per-partition migration loop.
-     * @param source Connector to read from (current schema, already bootstrapped).
-     * @param target Connector to write to (new schema, already bootstrapped).
-     * @param partitionTotal The total number of partitions to migrate, used for progress reporting.
-     * @param partitionIndex The index of the current partition being migrated, used for progress reporting.
-     * @param schemaDiff Schema diff used to add nullable defaults and drop removed fields when `options.transformEntity` is not provided.
-     * @param options Optional migration controls (batchSize, transformEntity, onProgress).
-     * @returns The number of entities successfully migrated.
-     */
-    static migratePartition<T = unknown, U = unknown>(source: IEntityStorageConnector<T>, target: IEntityStorageConnector<U>, partitionTotal: number, partitionIndex: number, schemaDiff: IEntitySchemaDiff<T, U>, options?: IMigrationOptions<T, U>): Promise<number>;
-    /**
-     * Applies the entity transformation for migration, using the provided options and schema diff.
+     * Applies the entity transformation for a single diff, handling added, removed, and
+     * modified properties according to the provided schema diff and optional transform hook.
      * @param entity The entity to transform.
      * @param schemaDiff The schema diff between the old and new schemas.
-     * @param options The migration options.
+     * @param transformEntityProperty Optional per-property transform hook for object/array properties.
      * @returns The transformed entity ready to be written to the new schema.
-     * @throws GeneralError if a transformation is required for an object or array property but no `options.transformEntityProperty` function is provided.
+     * @throws GeneralError if a transformation is required for an object or array property but no transformEntityProperty function is provided.
      * @throws GeneralError if coercion of a modified property results in undefined for a non-optional target property.
      */
-    static applyEntityTransform<T = unknown, U = unknown>(entity: Partial<T>, schemaDiff: IEntitySchemaDiff<T, U>, options?: IMigrationOptions<T, U>): U;
+    static applyEntityTransform<T = unknown, U = unknown>(entity: Partial<T>, schemaDiff: IEntitySchemaDiff<T, U>, transformEntityProperty?: IMigrationOptions<T, U>["transformEntityProperty"]): U;
+    /**
+     * Transforms a single entity through an ordered chain of fully-resolved migration steps.
+     * For each step the method diffs fromProperties against toProperties, then applies
+     * applyEntityTransform. Each step's output feeds the next step's input so that
+     * per-step transformEntityProperty hooks are honoured throughout the chain.
+     * @param entity The entity to transform (at the shape described by steps[0].fromProperties).
+     * @param steps Ordered, fully-resolved migration steps from stored version to current version.
+     * Each step's fromProperties and toProperties are resolved by the caller before invocation.
+     * @returns The entity transformed to the shape described by steps[last].toProperties.
+     */
+    static applyEntityChain(entity: unknown, steps: IResolvedMigrationStep[]): unknown;
+    /**
+     * Performs a chain migration in a single connector swap, regardless of how many version
+     * steps the chain spans. Creates one target connector, reads all source entities, applies
+     * applyEntityChain to each, writes them to the target, then finalizes the migration.
+     * A chain of one step is equivalent to a traditional single-step migration.
+     * @param sourceConnector The connector holding data at the stored schema version.
+     * @param targetSchemaName The schema name for the current version (used to create the target connector).
+     * @param steps Ordered, fully-resolved migration steps from stored to current version.
+     * @param loggingComponentType An optional logging component type for connector startup.
+     * @param batchSize Number of entities to read and write per batch. Defaults to 100.
+     * @returns The finalized connector and the count of migrated entities.
+     */
+    static migrateWithChain(sourceConnector: IEntityStorageMigrationConnector, targetSchemaName: string, steps: IResolvedMigrationStep[], loggingComponentType?: string, batchSize?: number): Promise<{
+        finalConnector: IEntityStorageConnector;
+        migrated: number;
+    }>;
 }

package/dist/types/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./factories/entityStorageConnectorFactory.js";
+export * from "./factories/schemaMigrationFactory.js";
 export * from "./helpers/entityStorageHelper.js";
 export * from "./helpers/migrationHelper.js";
 export * from "./models/api/IEntityStorageCountRequest.js";
@@ -16,3 +17,5 @@ export * from "./models/IEntityStorageComponent.js";
 export * from "./models/IEntityStorageConnector.js";
 export * from "./models/IEntityStorageMigrationConnector.js";
 export * from "./models/IMigrationOptions.js";
+export * from "./models/IResolvedMigrationStep.js";
+export * from "./models/ISchemaMigration.js";

package/dist/types/models/IResolvedMigrationStep.d.ts

@@ -0,0 +1,36 @@
+import type { IEntitySchemaProperty } from "@twin.org/entity";
+import type { IMigrationOptions } from "./IMigrationOptions.js";
+/**
+ * A fully-resolved single migration step used by MigrationHelper.
+ * The SchemaVersionService builds these by looking up versioned schema classes
+ * from EntitySchemaFactory (e.g. MyEntityV0, MyEntityV1) before invoking the helper,
+ * keeping factory knowledge out of the helper itself.
+ * @template T The entity type. Defaults to `unknown`. Use a concrete entity type
+ * when the step's source and target schemas are known at the call site.
+ */
+export interface IResolvedMigrationStep<T = unknown, U = unknown> {
+    /**
+     * The property list of the entity at the start of this step (the "old" shape).
+     * Sourced from the versioned schema class registered in EntitySchemaFactory,
+     * e.g. EntitySchemaFactory.get("MyEntityV0").properties.
+     */
+    fromProperties: IEntitySchemaProperty<T>[];
+    /**
+     * The property list of the entity at the end of this step (the "new" shape).
+     * For the final step this is the live current schema's properties.
+     */
+    toProperties: IEntitySchemaProperty<U>[];
+    /**
+     * Optional property renames for this step, forwarded to EntitySchemaDiffHelper.diff.
+     */
+    renames?: {
+        from: string;
+        to: string;
+    }[];
+    /**
+     * Optional per-property transformer for object/array properties that the structural
+     * diff cannot handle automatically. Sourced from an ISchemaMigration override when
+     * one is registered in SchemaMigrationFactory for this step.
+     */
+    transformEntityProperty?: IMigrationOptions<T, U>["transformEntityProperty"];
+}

package/dist/types/models/ISchemaMigration.d.ts

@@ -0,0 +1,27 @@
+import type { IMigrationOptions } from "./IMigrationOptions.js";
+/**
+ * Optional per-step override for a single version-to-version migration.
+ * Only register an entry in SchemaMigrationFactory when a step requires property
+ * renames or a custom object/array transform. For purely structural changes
+ * (add/remove/type-change fields) no entry is needed — the runner diffs the two
+ * versioned schema classes (e.g. MyEntityV0 vs MyEntityV1) from EntitySchemaFactory
+ * automatically.
+ *
+ * Register under the key "<BaseSchemaName>_<fromVersion>_<toVersion>"
+ * e.g. "MyEntity_0_1" for the step that migrates from version 0 to version 1.
+ * The key itself encodes the version pair; no version field is needed on the object.
+ */
+export interface ISchemaMigration<T = unknown, U = unknown> {
+    /**
+     * Optional property renames to apply during this step.
+     */
+    renames?: {
+        from: string;
+        to: string;
+    }[];
+    /**
+     * Optional per-property transformer for object/array properties that cannot be
+     * automatically coerced. T is the source entity type, U is the target entity type.
+     */
+    transformEntityProperty?: IMigrationOptions<T, U>["transformEntityProperty"];
+}

package/docs/changelog.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.0.3-next.23](https://github.com/iotaledger/twin-entity-storage/compare/entity-storage-models-v0.0.3-next.22...entity-storage-models-v0.0.3-next.23) (2026-06-08)
+
+
+### Features
+
+* entity storage conditions ([#115](https://github.com/iotaledger/twin-entity-storage/issues/115)) ([7a53884](https://github.com/iotaledger/twin-entity-storage/commit/7a53884f6acb856d77733e4e0f23ec1c00b74cb4))
+
+## [0.0.3-next.22](https://github.com/iotaledger/twin-entity-storage/compare/entity-storage-models-v0.0.3-next.21...entity-storage-models-v0.0.3-next.22) (2026-06-08)
+
+
+### Features
+
+* add ISchemaMigration chain, SchemaVersionMigrator runner and version store ([#110](https://github.com/iotaledger/twin-entity-storage/issues/110)) ([2dac924](https://github.com/iotaledger/twin-entity-storage/commit/2dac9244a752cb58304d1649ff03c3a2469783dd))
+
 ## [0.0.3-next.21](https://github.com/iotaledger/twin-entity-storage/compare/entity-storage-models-v0.0.3-next.20...entity-storage-models-v0.0.3-next.21) (2026-06-01)
 
 

package/docs/reference/classes/EntityStorageHelper.md

@@ -107,6 +107,80 @@ The entity with undefined and null values handled.
 
 ***
 
+### validateSortProperties() {#validatesortproperties}
+
+> `static` **validateSortProperties**\<`T`\>(`schema`, `sortProperties?`): `void`
+
+Validate that every sort property in the list is indexed in the schema (isPrimary, isSecondary,
+or has a default sortDirection), throwing sortNotIndexed for the first violation found.
+
+#### Type Parameters
+
+##### T
+
+`T`
+
+#### Parameters
+
+##### schema
+
+`IEntitySchema`\<`T`\>
+
+The entity schema to validate against.
+
+##### sortProperties?
+
+`object`[]
+
+The sort properties to check.
+
+#### Returns
+
+`void`
+
+#### Throws
+
+GeneralError If a sort property is not indexed in the schema.
+
+***
+
+### validateProperties() {#validateproperties}
+
+> `static` **validateProperties**\<`T`\>(`schema`, `properties?`): `void`
+
+Validate that every property in the list exists in the schema, throwing propertyNotInSchema
+for the first property that is not found.
+
+#### Type Parameters
+
+##### T
+
+`T`
+
+#### Parameters
+
+##### schema
+
+`IEntitySchema`\<`T`\>
+
+The entity schema to validate against.
+
+##### properties?
+
+keyof `T`[]
+
+The properties to check.
+
+#### Returns
+
+`void`
+
+#### Throws
+
+GeneralError If a property does not exist in the schema.
+
+***
+
 ### normalizeConditionValues() {#normalizeconditionvalues}
 
 > `static` **normalizeConditionValues**\<`T`\>(`condition`): `EntityCondition`\<`T`\>

package/docs/reference/classes/MigrationHelper.md

@@ -1,6 +1,8 @@
 # Class: MigrationHelper
 
-Helper class for performing schema migrations between two connectors.
+Helper class for performing entity schema migrations between two connectors.
+The chain-based API (migrateWithChain / applyEntityChain) is the single migration
+path: a chain of one step covers the same case as a traditional single-step migration.
 
 ## Constructors
 
@@ -22,67 +24,12 @@ Runtime name for the class.
 
 ## Methods
 
-### migrate() {#migrate}
-
-> `static` **migrate**\<`T`, `U`\>(`sourceConnector`, `targetEntitySchemaName`, `renames?`, `options?`, `loggingComponentType?`): `Promise`\<\{ `finalConnector?`: [`IEntityStorageConnector`](../interfaces/IEntityStorageConnector.md)\<`U`\>; `migrated`: `number`; \}\>
-
-Performs a migration between two connectors, using the provided options and schema diff to control the migration behaviour.
-
-#### Type Parameters
-
-##### T
-
-`T`
-
-##### U
-
-`U`
-
-#### Parameters
-
-##### sourceConnector
-
-[`IEntityStorageMigrationConnector`](../interfaces/IEntityStorageMigrationConnector.md)\<`T`\>
-
-The connector to migrate from to allow the migration helper to create the new connector and finalize the migration.
-
-##### targetEntitySchemaName
-
-`string`
-
-The name of the new entity schema.
-
-##### renames?
-
-`object`[]
-
-An optional list of property renames to apply during migration.
-
-##### options?
-
-[`IMigrationOptions`](../interfaces/IMigrationOptions.md)\<`T`, `U`\>
-
-Options controlling migration behaviour.
-
-##### loggingComponentType?
-
-`string`
-
-An optional logging component type to use for bootstrapping and starting connectors if necessary.
-
-#### Returns
-
-`Promise`\<\{ `finalConnector?`: [`IEntityStorageConnector`](../interfaces/IEntityStorageConnector.md)\<`U`\>; `migrated`: `number`; \}\>
-
-The connector for the new schema and the number of entities successfully migrated, the sourceConnector will no longer be usable, finalConnector will be undefined if no migration was necessary.
-
-***
-
-### migrateEntities() {#migrateentities}
+### applyEntityTransform() {#applyentitytransform}
 
-> `static` **migrateEntities**\<`T`, `U`\>(`source`, `target`, `partitionContextIds`, `schemaDiff`, `options?`): `Promise`\<`number`\>
+> `static` **applyEntityTransform**\<`T`, `U`\>(`entity`, `schemaDiff`, `transformEntityProperty?`): `U`
 
-Generic per-partition migration loop.
+Applies the entity transformation for a single diff, handling added, removed, and
+modified properties according to the provided schema diff and optional transform hook.
 
 #### Type Parameters
 
@@ -92,156 +39,119 @@ Generic per-partition migration loop.
 
 ##### U
 
-`U` = `T`
+`U` = `unknown`
 
 #### Parameters
 
-##### source
-
-[`IEntityStorageMigrationConnector`](../interfaces/IEntityStorageMigrationConnector.md)\<`T`\>
-
-Connector to read from (current schema, already bootstrapped).
-
-##### target
-
-[`IEntityStorageConnector`](../interfaces/IEntityStorageConnector.md)\<`U`\>
-
-Connector to write to (new schema, already bootstrapped).
-
-##### partitionContextIds
+##### entity
 
-`IContextIds`[]
+`Partial`\<`T`\>
 
-The context ids to use for the migration, used for partitioning and can be used in the transform function when `options.transformEntityProperty` is provided.
+The entity to transform.
 
 ##### schemaDiff
 
 `IEntitySchemaDiff`\<`T`, `U`\>
 
-The schema diff.
+The schema diff between the old and new schemas.
 
-##### options?
+##### transformEntityProperty?
 
-[`IMigrationOptions`](../interfaces/IMigrationOptions.md)\<`T`, `U`\>
+(`schema1Property`, `schemaProperty2`, `value`) => `unknown`
 
-Optional migration controls (batchSize, transformEntity, onProgress).
+Optional per-property transform hook for object/array properties.
 
 #### Returns
 
-`Promise`\<`number`\>
-
-The number of entities successfully migrated.
+`U`
 
-***
+The transformed entity ready to be written to the new schema.
 
-### migratePartition() {#migratepartition}
+#### Throws
 
-> `static` **migratePartition**\<`T`, `U`\>(`source`, `target`, `partitionTotal`, `partitionIndex`, `schemaDiff`, `options?`): `Promise`\<`number`\>
+GeneralError if a transformation is required for an object or array property but no transformEntityProperty function is provided.
 
-Generic per-partition migration loop.
+#### Throws
 
-#### Type Parameters
+GeneralError if coercion of a modified property results in undefined for a non-optional target property.
 
-##### T
+***
 
-`T` = `unknown`
+### applyEntityChain() {#applyentitychain}
 
-##### U
+> `static` **applyEntityChain**(`entity`, `steps`): `unknown`
 
-`U` = `unknown`
+Transforms a single entity through an ordered chain of fully-resolved migration steps.
+For each step the method diffs fromProperties against toProperties, then applies
+applyEntityTransform. Each step's output feeds the next step's input so that
+per-step transformEntityProperty hooks are honoured throughout the chain.
 
 #### Parameters
 
-##### source
-
-[`IEntityStorageConnector`](../interfaces/IEntityStorageConnector.md)\<`T`\>
-
-Connector to read from (current schema, already bootstrapped).
-
-##### target
-
-[`IEntityStorageConnector`](../interfaces/IEntityStorageConnector.md)\<`U`\>
-
-Connector to write to (new schema, already bootstrapped).
-
-##### partitionTotal
-
-`number`
-
-The total number of partitions to migrate, used for progress reporting.
-
-##### partitionIndex
-
-`number`
-
-The index of the current partition being migrated, used for progress reporting.
-
-##### schemaDiff
+##### entity
 
-`IEntitySchemaDiff`\<`T`, `U`\>
+`unknown`
 
-Schema diff used to add nullable defaults and drop removed fields when `options.transformEntity` is not provided.
+The entity to transform (at the shape described by steps[0].fromProperties).
 
-##### options?
+##### steps
 
-[`IMigrationOptions`](../interfaces/IMigrationOptions.md)\<`T`, `U`\>
+[`IResolvedMigrationStep`](../interfaces/IResolvedMigrationStep.md)\<`unknown`, `unknown`\>[]
 
-Optional migration controls (batchSize, transformEntity, onProgress).
+Ordered, fully-resolved migration steps from stored version to current version.
+Each step's fromProperties and toProperties are resolved by the caller before invocation.
 
 #### Returns
 
-`Promise`\<`number`\>
+`unknown`
 
-The number of entities successfully migrated.
+The entity transformed to the shape described by steps[last].toProperties.
 
 ***
 
-### applyEntityTransform() {#applyentitytransform}
+### migrateWithChain() {#migratewithchain}
 
-> `static` **applyEntityTransform**\<`T`, `U`\>(`entity`, `schemaDiff`, `options?`): `U`
+> `static` **migrateWithChain**(`sourceConnector`, `targetSchemaName`, `steps`, `loggingComponentType?`, `batchSize?`): `Promise`\<\{ `finalConnector`: [`IEntityStorageConnector`](../interfaces/IEntityStorageConnector.md); `migrated`: `number`; \}\>
 
-Applies the entity transformation for migration, using the provided options and schema diff.
+Performs a chain migration in a single connector swap, regardless of how many version
+steps the chain spans. Creates one target connector, reads all source entities, applies
+applyEntityChain to each, writes them to the target, then finalizes the migration.
+A chain of one step is equivalent to a traditional single-step migration.
 
-#### Type Parameters
-
-##### T
-
-`T` = `unknown`
-
-##### U
+#### Parameters
 
-`U` = `unknown`
+##### sourceConnector
 
-#### Parameters
+[`IEntityStorageMigrationConnector`](../interfaces/IEntityStorageMigrationConnector.md)
 
-##### entity
+The connector holding data at the stored schema version.
 
-`Partial`\<`T`\>
+##### targetSchemaName
 
-The entity to transform.
+`string`
 
-##### schemaDiff
+The schema name for the current version (used to create the target connector).
 
-`IEntitySchemaDiff`\<`T`, `U`\>
+##### steps
 
-The schema diff between the old and new schemas.
+[`IResolvedMigrationStep`](../interfaces/IResolvedMigrationStep.md)\<`unknown`, `unknown`\>[]
 
-##### options?
+Ordered, fully-resolved migration steps from stored to current version.
 
-[`IMigrationOptions`](../interfaces/IMigrationOptions.md)\<`T`, `U`\>
+##### loggingComponentType?
 
-The migration options.
+`string`
 
-#### Returns
+An optional logging component type for connector startup.
 
-`U`
+##### batchSize?
 
-The transformed entity ready to be written to the new schema.
+`number` = `100`
 
-#### Throws
+Number of entities to read and write per batch. Defaults to 100.
 
-GeneralError if a transformation is required for an object or array property but no `options.transformEntityProperty` function is provided.
+#### Returns
 
-#### Throws
+`Promise`\<\{ `finalConnector`: [`IEntityStorageConnector`](../interfaces/IEntityStorageConnector.md); `migrated`: `number`; \}\>
 
-GeneralError if coercion of a modified property results in undefined for a non-optional target property.
+The finalized connector and the count of migrated entities.

package/docs/reference/index.md

@@ -11,6 +11,8 @@
 - [IEntityStorageConnector](interfaces/IEntityStorageConnector.md)
 - [IEntityStorageMigrationConnector](interfaces/IEntityStorageMigrationConnector.md)
 - [IMigrationOptions](interfaces/IMigrationOptions.md)
+- [IResolvedMigrationStep](interfaces/IResolvedMigrationStep.md)
+- [ISchemaMigration](interfaces/ISchemaMigration.md)
 - [IEntityStorageCountRequest](interfaces/IEntityStorageCountRequest.md)
 - [IEntityStorageCountResponse](interfaces/IEntityStorageCountResponse.md)
 - [IEntityStorageEmptyRequest](interfaces/IEntityStorageEmptyRequest.md)
@@ -26,3 +28,4 @@
 ## Variables
 
 - [EntityStorageConnectorFactory](variables/EntityStorageConnectorFactory.md)
+- [SchemaMigrationFactory](variables/SchemaMigrationFactory.md)

package/docs/reference/interfaces/IResolvedMigrationStep.md

@@ -0,0 +1,82 @@
+# Interface: IResolvedMigrationStep\<T, U\>
+
+A fully-resolved single migration step used by MigrationHelper.
+The SchemaVersionService builds these by looking up versioned schema classes
+from EntitySchemaFactory (e.g. MyEntityV0, MyEntityV1) before invoking the helper,
+keeping factory knowledge out of the helper itself.
+
+## Type Parameters
+
+### T
+
+`T` = `unknown`
+
+The entity type. Defaults to `unknown`. Use a concrete entity type
+when the step's source and target schemas are known at the call site.
+
+### U
+
+`U` = `unknown`
+
+## Properties
+
+### fromProperties {#fromproperties}
+
+> **fromProperties**: `IEntitySchemaProperty`\<`T`\>[]
+
+The property list of the entity at the start of this step (the "old" shape).
+Sourced from the versioned schema class registered in EntitySchemaFactory,
+e.g. EntitySchemaFactory.get("MyEntityV0").properties.
+
+***
+
+### toProperties {#toproperties}
+
+> **toProperties**: `IEntitySchemaProperty`\<`U`\>[]
+
+The property list of the entity at the end of this step (the "new" shape).
+For the final step this is the live current schema's properties.
+
+***
+
+### renames? {#renames}
+
+> `optional` **renames?**: `object`[]
+
+Optional property renames for this step, forwarded to EntitySchemaDiffHelper.diff.
+
+#### from
+
+> **from**: `string`
+
+#### to
+
+> **to**: `string`
+
+***
+
+### transformEntityProperty? {#transformentityproperty}
+
+> `optional` **transformEntityProperty?**: (`schema1Property`, `schemaProperty2`, `value`) => `unknown`
+
+Optional per-property transformer for object/array properties that the structural
+diff cannot handle automatically. Sourced from an ISchemaMigration override when
+one is registered in SchemaMigrationFactory for this step.
+
+#### Parameters
+
+##### schema1Property
+
+`IEntitySchemaProperty`\<`T`\>
+
+##### schemaProperty2
+
+`IEntitySchemaProperty`\<`U`\>
+
+##### value
+
+`unknown`
+
+#### Returns
+
+`unknown`