@itwin/ecschema-editing 5.0.0-dev.90 → 5.0.0-dev.92

package/lib/esm/Validation/SchemaChanges.js

@@ -0,0 +1,1141 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Comparison
+ */
+import { ECClass, ECObjectsError, ECObjectsStatus, OverrideFormat, Property, RelationshipConstraint, Schema, SchemaItem, SchemaItemType, } from "@itwin/ecschema-metadata";
+import { SchemaCompareCodes } from "./SchemaCompareDiagnostics";
+/**
+ * Possible change types used to categorize ISchemaChange objects.
+ * @alpha
+ */
+export var ChangeType;
+(function (ChangeType) {
+    ChangeType[ChangeType["Delta"] = 0] = "Delta";
+    ChangeType[ChangeType["Missing"] = 1] = "Missing";
+})(ChangeType || (ChangeType = {}));
+/**
+ * An ISchemaChange implementation meant to be used as the base class
+ * for all other ISchemaChange implementations.
+ * @alpha
+ */
+export class BaseSchemaChange {
+    _diagnostic;
+    _changeType;
+    /**
+     * Initializes a new BaseSchemaChange instance.
+     * @param diagnostic The diagnostic holding the change data.
+     */
+    constructor(diagnostic) {
+        this._diagnostic = diagnostic;
+    }
+    /** Gets the diagnostic holding the information about the schema change. */
+    get diagnostic() { return this._diagnostic; }
+    /**
+     * Gets the change type (Delta or Missing) for the change. If not previously
+     * set, the defaultChangeType value will be returned.
+     */
+    get changeType() {
+        if (!this._changeType)
+            this._changeType = this.defaultChangeType;
+        return this._changeType;
+    }
+    set changeType(changeType) { this._changeType = changeType; }
+    /**
+     * Gets the name or fullName from an EC type that is in the args array at
+     * the specified index. Performs validation based on the given parameters.
+     * @param index The index in the args array to find the EC type.
+     * @param args  The collection of arguments received in the diagnostics.
+     * @param allowUndefined Specifies that undefined values are allowed.
+     * @param fullName  Flag indicating that the fullName should be returned rather than the name.
+     */
+    getNameFromArgument(index, allowUndefined = false, fullName = false) {
+        if (!this.diagnostic.messageArgs || this.diagnostic.messageArgs.length <= index)
+            throw new ECObjectsError(ECObjectsStatus.InvalidSchemaComparisonArgument, `Schema comparison diagnostic '${this.diagnostic.code}' for SchemaItem '${this.topLevelSchemaItem.fullName}' has invalid arguments`);
+        const schemaItem = this.getValueFromArgument(index);
+        if (Schema.isSchema(schemaItem) || SchemaItem.isSchemaItem(schemaItem) || OverrideFormat.isOverrideFormat(schemaItem))
+            return fullName ? schemaItem.fullName : schemaItem.name;
+        if (!allowUndefined)
+            throw new ECObjectsError(ECObjectsStatus.InvalidSchemaComparisonArgument, `Schema comparison diagnostic '${this.diagnostic.code}' for SchemaItem '${this.topLevelSchemaItem.fullName}' has invalid arguments`);
+        return "undefined";
+    }
+    /**
+     * Gets a string from the diagnostics arguments at the given index. If the value is undefined,
+     * the string 'undefined' will be returned.
+     * @param index The index in the args array to find the property value.
+     */
+    getStringFromArgument(index) {
+        const value = this.getValueFromArgument(index);
+        if (value === undefined)
+            return "undefined";
+        if (typeof value === "number")
+            return value.toString();
+        if (typeof value === "boolean")
+            return value ? "true" : "false";
+        if (typeof value !== "string")
+            throw new Error();
+        return value;
+    }
+    /**
+     * Helper method to retrieve a value from the diagnostic arguments, performing validation.
+     * @param index THe index in the diagnostic arguments array.
+     */
+    getValueFromArgument(index) {
+        if (!this.diagnostic.messageArgs || this.diagnostic.messageArgs.length <= index)
+            throw new Error();
+        return this.diagnostic.messageArgs[index];
+    }
+}
+/**
+ * Base class for all ISchemaChanges implementations.
+ * @alpha
+ */
+export class BaseSchemaChanges {
+    _ecTypeName;
+    _schema;
+    _propertyValueChanges = [];
+    /**
+     * Initializes a new BaseSchemaChanges instance.
+     * @param schema The schema containing the changes.
+     * @param anyECTypeName The name of the EC type.
+     */
+    constructor(schema, anyECTypeName) {
+        this._schema = schema;
+        this._ecTypeName = anyECTypeName;
+    }
+    /** Gets the array of PropertyValueChange instances. */
+    get propertyValueChanges() {
+        return this._propertyValueChanges;
+    }
+    /** Gets the name of the EC type associated with these schema changes. */
+    get ecTypeName() {
+        return this._ecTypeName;
+    }
+    /** Gets the schema to which these changes are associated. */
+    get schema() {
+        return this._schema;
+    }
+    /**
+     * Helper method that adds a new ISchemaChange to a Map whose values are ISchemaChanges. The changesType will
+     * be used to create a new ISchemaChanges instance if the changes collection does not exist in the Map.
+     * @param changes The ISchemaChanges Map to which to add the ISchemaChange.
+     * @param changesType The constructor of the ISchemaChanges. Called if the ISchemaChanges instance does not exist in the Map.
+     * @param change The ISchemaChange to add.
+     * @param changeKey The key used to identify the ISchemaChanges in the Map (typically the name of the EC type, ie. SchemaItem.name).
+     */
+    addChangeToMap(changes, changesType, change, changeKey) {
+        if (changes.has(changeKey)) {
+            const existingChanges = changes.get(changeKey);
+            existingChanges.addChange(change);
+        }
+        else {
+            const newChanges = new changesType(this._schema, changeKey);
+            newChanges.addChange(change);
+            changes.set(changeKey, newChanges);
+        }
+    }
+    /**
+     * Helper method to determine if the diagnostic is a property value change delta for this ISchemaChanges instance.
+     * @param diagnostic The change diagnostic.
+     * @param ecTypeName The name of the EC type as determined by the implementation.
+     */
+    isPropertyValueChangeForThis(diagnostic, ecTypeName) {
+        if (this.ecTypeName !== ecTypeName)
+            return false;
+        switch (diagnostic.code) {
+            case SchemaCompareCodes.SchemaDelta:
+            case SchemaCompareCodes.SchemaItemDelta:
+            case SchemaCompareCodes.ClassDelta:
+            case SchemaCompareCodes.MixinDelta:
+            case SchemaCompareCodes.RelationshipDelta:
+            case SchemaCompareCodes.CustomAttributeClassDelta:
+            case SchemaCompareCodes.EnumerationDelta:
+            case SchemaCompareCodes.KoqDelta:
+            case SchemaCompareCodes.PropertyCategoryDelta:
+            case SchemaCompareCodes.FormatDelta:
+            case SchemaCompareCodes.UnitDelta:
+            case SchemaCompareCodes.InvertedUnitDelta:
+            case SchemaCompareCodes.PhenomenonDelta:
+            case SchemaCompareCodes.ConstantDelta:
+            case SchemaCompareCodes.PropertyDelta:
+            case SchemaCompareCodes.RelationshipConstraintDelta:
+                return true;
+            default:
+                return false;
+        }
+    }
+    /**
+     * Helper method to determine if the diagnostic is a CustomAttributeInstance class change for this ISchemaChanges instance.
+     * @param diagnostic The change diagnostic.
+     * @param ecTypeName The name of the EC type as determined by the implementation.
+     */
+    isCAContainerChangeForThis(diagnostic, ecTypeName) {
+        if (this.ecTypeName !== ecTypeName)
+            return false;
+        return diagnostic.code === SchemaCompareCodes.CustomAttributeInstanceClassMissing;
+    }
+}
+/**
+ * An ISchemaChanges implementation for managing schema comparison diagnostics at the Schema level.
+ * @alpha
+ */
+export class SchemaChanges extends BaseSchemaChanges {
+    _diagnostics = [];
+    _missingSchemaReferences = [];
+    _schemaReferenceDeltas = [];
+    _customAttributeChanges = new Map();
+    _classChanges = new Map();
+    _entityClassChanges = new Map();
+    _relationshipClassChanges = new Map();
+    _schemaItemChanges = new Map();
+    _enumerationChanges = new Map();
+    _kindOfQuantityChanges = new Map();
+    _formatChanges = new Map();
+    /**
+     * Initializes a new SchemaChanges instance.
+     * @param schema The schema containing the changes.
+     */
+    constructor(schema) {
+        super(schema, schema.name);
+    }
+    /** Gets the MissingSchemaReferences collection. */
+    get missingSchemaReferences() { return this._missingSchemaReferences; }
+    /** Gets the SchemaReferenceChange collection. */
+    get schemaReferenceDeltas() { return this._schemaReferenceDeltas; }
+    /** Gets the CustomAttributeContainerChanges Map. */
+    get customAttributeChanges() { return this._customAttributeChanges; }
+    /** Gets the ClassChanges Map. */
+    get classChanges() { return this._classChanges; }
+    /** Gets the EntityClassChanges Map. */
+    get entityClassChanges() { return this._entityClassChanges; }
+    /** Gets the RelationshipClassChanges Map. */
+    get relationshipClassChanges() { return this._relationshipClassChanges; }
+    /** Gets the SchemaItemChanges Map. */
+    get schemaItemChanges() { return this._schemaItemChanges; }
+    /** Gets the EnumerationChanges Map. */
+    get enumerationChanges() { return this._enumerationChanges; }
+    /** Gets the KindOfQuantityChanges Map. */
+    get kindOfQuantityChanges() { return this._kindOfQuantityChanges; }
+    /** Gets the FormatChanges Map. */
+    get formatChanges() { return this._formatChanges; }
+    /** Gets all the change diagnostics that have been added to instance. */
+    get allDiagnostics() {
+        return this._diagnostics;
+    }
+    /**
+     * Adds a new change diagnostic for the schema.
+     * @param diagnostic
+     */
+    addDiagnostic(diagnostic) {
+        this._diagnostics.push(diagnostic);
+        const change = this.createChangeFromDiagnostic(diagnostic);
+        this.addChange(change);
+    }
+    /**
+     * Adds the change to the appropriate change collection at this level or adds the change
+     * to a Map of child changes will which propagate the change to lower levels. Typically
+     * any 'addChangeToMap' type method will then call addChange to add the ISchemaChange to
+     * the ISchemaChanges instance at that level.
+     * @param change The ISchemaChange to add.
+     */
+    addChange(change) {
+        const schemaName = this.getSchemaNameFromChange(change);
+        // If change is at the schema level, record change and return
+        if (schemaName) {
+            if (change.diagnostic.code === SchemaCompareCodes.SchemaReferenceMissing) {
+                this.missingSchemaReferences.push(change);
+                return;
+            }
+            if (change.diagnostic.code === SchemaCompareCodes.SchemaReferenceDelta) {
+                this.schemaReferenceDeltas.push(change);
+                return;
+            }
+            if (this.isCAContainerChangeForThis(change.diagnostic, schemaName)) {
+                this.addChangeToMap(this.customAttributeChanges, CustomAttributeContainerChanges, change, change.changeKey);
+                return;
+            }
+            if (this.isPropertyValueChangeForThis(change.diagnostic, schemaName)) {
+                this.propertyValueChanges.push(change);
+                return;
+            }
+        }
+        // Start by adding the change for the top-level SchemaItem which will
+        // start a recursion to add the change at each appropriate level.
+        const schemaItem = change.topLevelSchemaItem;
+        const schemaItemType = schemaItem.schemaItemType;
+        switch (schemaItemType) {
+            case SchemaItemType.Mixin:
+            case SchemaItemType.StructClass:
+            case SchemaItemType.CustomAttributeClass:
+                this.addChangeToClassMap(change, schemaItem);
+                return;
+            case SchemaItemType.EntityClass:
+                this.addChangeToEntityClassMap(change, schemaItem);
+                return;
+            case SchemaItemType.RelationshipClass:
+                this.addChangeToRelationshipClassMap(change, schemaItem);
+                return;
+            case SchemaItemType.PropertyCategory:
+            case SchemaItemType.Unit:
+            case SchemaItemType.InvertedUnit:
+            case SchemaItemType.UnitSystem:
+            case SchemaItemType.Phenomenon:
+            case SchemaItemType.Constant:
+                this.addChangeToSchemaItemMap(change, schemaItem);
+                return;
+            case SchemaItemType.Enumeration:
+                this.addChangeToEnumerationMap(change, schemaItem);
+                return;
+            case SchemaItemType.KindOfQuantity:
+                this.addChangeToKOQMap(change, schemaItem);
+                return;
+            case SchemaItemType.Format:
+                this.addChangeToFormatMap(change, schemaItem);
+                return;
+        }
+    }
+    getSchemaNameFromChange(change) {
+        const type = change.diagnostic.ecDefinition;
+        return (Schema.isSchema(type)) ? type.name : undefined;
+    }
+    /** This creates ISchemaChange instances based on the change diagnostic specified. */
+    createChangeFromDiagnostic(diagnostic) {
+        switch (diagnostic.code) {
+            case SchemaCompareCodes.SchemaReferenceMissing:
+                return new SchemaReferenceMissing(diagnostic);
+            case SchemaCompareCodes.SchemaReferenceDelta:
+                return new SchemaReferenceDelta(diagnostic);
+            case SchemaCompareCodes.SchemaDelta:
+            case SchemaCompareCodes.SchemaItemDelta:
+            case SchemaCompareCodes.ClassDelta:
+            case SchemaCompareCodes.MixinDelta:
+            case SchemaCompareCodes.RelationshipDelta:
+            case SchemaCompareCodes.CustomAttributeClassDelta:
+            case SchemaCompareCodes.EnumerationDelta:
+            case SchemaCompareCodes.KoqDelta:
+            case SchemaCompareCodes.PropertyCategoryDelta:
+            case SchemaCompareCodes.FormatDelta:
+            case SchemaCompareCodes.UnitDelta:
+            case SchemaCompareCodes.InvertedUnitDelta:
+            case SchemaCompareCodes.PhenomenonDelta:
+            case SchemaCompareCodes.ConstantDelta:
+            case SchemaCompareCodes.PropertyDelta:
+            case SchemaCompareCodes.RelationshipConstraintDelta:
+                return new PropertyValueChange(diagnostic);
+            case SchemaCompareCodes.SchemaItemMissing:
+                return new SchemaItemMissing(diagnostic);
+            case SchemaCompareCodes.BaseClassDelta:
+                return new BaseClassDelta(diagnostic);
+            case SchemaCompareCodes.PropertyMissing:
+                return new PropertyMissing(diagnostic);
+            case SchemaCompareCodes.EntityMixinMissing:
+                return new EntityMixinChange(diagnostic);
+            case SchemaCompareCodes.RelationshipConstraintClassMissing:
+                return new RelationshipConstraintClassChange(diagnostic);
+            case SchemaCompareCodes.CustomAttributeInstanceClassMissing:
+                return new CustomAttributeContainerChange(diagnostic);
+            case SchemaCompareCodes.EnumeratorMissing:
+                return new EnumeratorMissing(diagnostic);
+            case SchemaCompareCodes.EnumeratorDelta:
+                return new EnumeratorDelta(diagnostic);
+            case SchemaCompareCodes.PresentationUnitMissing:
+                return new PresentationUnitChange(diagnostic);
+            case SchemaCompareCodes.FormatUnitMissing:
+                return new FormatUnitChange(diagnostic);
+            case SchemaCompareCodes.UnitLabelOverrideDelta:
+                return new UnitLabelOverrideDelta(diagnostic);
+            default:
+                throw new Error();
+        }
+    }
+    addChangeToSchemaItemMap(change, schemaItem) {
+        if (this.schemaItemChanges.has(schemaItem.name)) {
+            const existingChanges = this.schemaItemChanges.get(schemaItem.name);
+            existingChanges.addChange(change);
+        }
+        else {
+            const newChanges = new SchemaItemChanges(this.schema, schemaItem.name, schemaItem.schemaItemType);
+            newChanges.addChange(change);
+            this.schemaItemChanges.set(schemaItem.name, newChanges);
+        }
+    }
+    addChangeToClassMap(change, ecClass) {
+        if (this.classChanges.has(ecClass.name)) {
+            const existingChanges = this.classChanges.get(ecClass.name);
+            existingChanges.addChange(change);
+        }
+        else {
+            const newChanges = new ClassChanges(this.schema, ecClass.name, ecClass.schemaItemType);
+            newChanges.addChange(change);
+            this.classChanges.set(ecClass.name, newChanges);
+        }
+    }
+    addChangeToEntityClassMap(change, ecClass) {
+        if (this.entityClassChanges.has(ecClass.name)) {
+            const existingChanges = this.entityClassChanges.get(ecClass.name);
+            existingChanges.addChange(change);
+        }
+        else {
+            const newChanges = new EntityClassChanges(this.schema, ecClass.name, ecClass.schemaItemType);
+            newChanges.addChange(change);
+            this.entityClassChanges.set(ecClass.name, newChanges);
+        }
+    }
+    addChangeToRelationshipClassMap(change, ecClass) {
+        if (this.relationshipClassChanges.has(ecClass.name)) {
+            const existingChanges = this.relationshipClassChanges.get(ecClass.name);
+            existingChanges.addChange(change);
+        }
+        else {
+            const newChanges = new RelationshipClassChanges(this.schema, ecClass.name, ecClass.schemaItemType);
+            newChanges.addChange(change);
+            this.relationshipClassChanges.set(ecClass.name, newChanges);
+        }
+    }
+    addChangeToEnumerationMap(change, enumeration) {
+        if (this.enumerationChanges.has(enumeration.name)) {
+            const existingChanges = this.enumerationChanges.get(enumeration.name);
+            existingChanges.addChange(change);
+        }
+        else {
+            const newChanges = new EnumerationChanges(this.schema, enumeration.name, enumeration.schemaItemType);
+            newChanges.addChange(change);
+            this.enumerationChanges.set(enumeration.name, newChanges);
+        }
+    }
+    addChangeToKOQMap(change, koq) {
+        if (this.kindOfQuantityChanges.has(koq.name)) {
+            const existingChanges = this.kindOfQuantityChanges.get(koq.name);
+            existingChanges.addChange(change);
+        }
+        else {
+            const newChanges = new KindOfQuantityChanges(this.schema, koq.name, koq.schemaItemType);
+            newChanges.addChange(change);
+            this.kindOfQuantityChanges.set(koq.name, newChanges);
+        }
+    }
+    addChangeToFormatMap(change, format) {
+        if (this.formatChanges.has(format.name)) {
+            const existingChanges = this.formatChanges.get(format.name);
+            existingChanges.addChange(change);
+        }
+        else {
+            const newChanges = new FormatChanges(this.schema, format.name, format.schemaItemType);
+            newChanges.addChange(change);
+            this.formatChanges.set(format.name, newChanges);
+        }
+    }
+}
+/**
+ * An ISchemaChanges implementation for managing schema comparison diagnostics at the SchemaItem level.
+ * @alpha
+ */
+export class SchemaItemChanges extends BaseSchemaChanges {
+    _schemaItemType;
+    _schemaItemMissing;
+    /**
+     * Initializes a new SchemaItemChanges instance.
+     * @param schema The Schema containing the change.
+     * @param schemaItemName The name of the EC type associated with the change.
+     * @param schemaItemType The SchemaItemType of the EC type.
+     */
+    constructor(schema, schemaItemName, schemaItemType) {
+        super(schema, schemaItemName);
+        this._schemaItemType = schemaItemType;
+    }
+    /** Gets the SchemaItemType of the SchemaItem associated with the changes. */
+    get schemaItemType() {
+        return this._schemaItemType;
+    }
+    /** Gets the SchemaItemMissing change. Maybe undefined. */
+    get schemaItemMissing() {
+        return this._schemaItemMissing;
+    }
+    /**
+     * Adds the change to the appropriate change collection at this level or adds the change
+     * to a Map of child changes will which propagate the change to lower levels.
+     * @param change The ISchemaChange to add.
+     */
+    addChange(change) {
+        if (change.diagnostic.code === SchemaCompareCodes.SchemaItemMissing) {
+            this._schemaItemMissing = change;
+            return;
+        }
+        const name = this.getSchemaItemNameFromChange(change);
+        if (!name)
+            return;
+        if (this.isPropertyValueChangeForThis(change.diagnostic, name)) {
+            this.propertyValueChanges.push(change);
+            return;
+        }
+    }
+    getSchemaItemNameFromChange(change) {
+        const type = change.diagnostic.ecDefinition;
+        return (SchemaItem.isSchemaItem(type)) ? type.name : undefined;
+    }
+}
+/**
+ * An ISchemaChanges implementation for managing schema comparison diagnostics at the Class level.
+ * @alpha
+ */
+export class ClassChanges extends SchemaItemChanges {
+    _baseClassDelta;
+    _propertyChanges = new Map();
+    _customAttributeChanges = new Map();
+    /** Gets the BaseClassDelta change. Maybe undefined. */
+    get baseClassDelta() {
+        return this._baseClassDelta;
+    }
+    /** Gets the PropertyChanges Map. */
+    get propertyChanges() {
+        return this._propertyChanges;
+    }
+    /** Gets the Map of CustomAttributeContainerChanges. */
+    get customAttributeChanges() {
+        return this._customAttributeChanges;
+    }
+    /**
+     * Adds the change to the appropriate change collection at this level or adds the change
+     * to a Map of child changes will which propagate the change to lower levels.
+     * @param change The ISchemaChange to add.
+     */
+    addChange(change) {
+        super.addChange(change);
+        if (change.diagnostic.code === SchemaCompareCodes.BaseClassDelta) {
+            this._baseClassDelta = change;
+            return;
+        }
+        if (Property.isProperty(change.diagnostic.ecDefinition)) {
+            this.addChangeToMap(this.propertyChanges, PropertyChanges, change, change.diagnostic.ecDefinition.name);
+            return;
+        }
+        if (this.isCAContainerChangeForThis(change.diagnostic, this.getSchemaItemNameFromChange(change))) {
+            this.addChangeToMap(this.customAttributeChanges, CustomAttributeContainerChanges, change, change.changeKey);
+            return;
+        }
+    }
+}
+/**
+ * An ISchemaChanges implementation for managing schema comparison diagnostics at the Class level.
+ * @alpha
+ */
+export class EntityClassChanges extends ClassChanges {
+    _entityMixinChanges = new Map();
+    /** Gets the EntityMixinChanges Map. */
+    get entityMixinChanges() {
+        return this._entityMixinChanges;
+    }
+    /**
+     * Adds the change to the appropriate change collection at this level or adds the change
+     * to a Map of child changes will which propagate the change to lower levels.
+     * @param change The ISchemaChange to add.
+     */
+    addChange(change) {
+        super.addChange(change);
+        if (change.diagnostic.code === SchemaCompareCodes.EntityMixinMissing) {
+            this.addChangeToMap(this.entityMixinChanges, EntityMixinChanges, change, change.changeKey);
+            return;
+        }
+    }
+}
+/**
+ * An ISchemaChanges implementation for managing schema comparison diagnostics for RelationshipClasses.
+ * @alpha
+ */
+export class RelationshipClassChanges extends ClassChanges {
+    _sourceConstraintChanges = new Map();
+    _targetConstraintChanges = new Map();
+    /** Gets the source RelationshipConstraintChanges Map. */
+    get sourceConstraintChanges() {
+        return this._sourceConstraintChanges;
+    }
+    /** Gets the target RelationshipConstraintChanges Map. */
+    get targetConstraintChanges() {
+        return this._targetConstraintChanges;
+    }
+    /**
+     * Adds the change to the appropriate change collection at this level or adds the change
+     * to a Map of child changes will which propagate the change to lower levels.
+     * @param change The ISchemaChange to add.
+     */
+    addChange(change) {
+        super.addChange(change);
+        if (RelationshipConstraint.isRelationshipConstraint(change.diagnostic.ecDefinition)) {
+            if (change.diagnostic.ecDefinition.isSource)
+                this.addChangeToMap(this.sourceConstraintChanges, RelationshipConstraintChanges, change, change.diagnostic.ecDefinition.fullName);
+            else
+                this.addChangeToMap(this.targetConstraintChanges, RelationshipConstraintChanges, change, change.diagnostic.ecDefinition.fullName);
+        }
+    }
+}
+/**
+ * An ISchemaChanges implementation for managing schema comparison diagnostics at the Property level.
+ * @alpha
+ */
+export class PropertyChanges extends BaseSchemaChanges {
+    _propertyMissing;
+    _customAttributeChanges = new Map();
+    /** Gets the PropertyMissing change. Maybe undefined. */
+    get propertyMissing() {
+        return this._propertyMissing;
+    }
+    /** Gets the CustomAttributeContainerChanges Map. */
+    get customAttributeChanges() {
+        return this._customAttributeChanges;
+    }
+    /**
+     * Adds the change to the appropriate change collection at this level or adds the change
+     * to a Map of child changes will which propagate the change to lower levels.
+     * @param change The ISchemaChange to add.
+     */
+    addChange(change) {
+        const propertyName = this.getPropertyNameFromChange(change);
+        if (!propertyName)
+            return;
+        if (change.diagnostic.code === SchemaCompareCodes.PropertyMissing) {
+            this._propertyMissing = change;
+            return;
+        }
+        if (this.isPropertyValueChangeForThis(change.diagnostic, propertyName)) {
+            this.propertyValueChanges.push(change);
+            return;
+        }
+        if (this.isCAContainerChangeForThis(change.diagnostic, propertyName))
+            this.addChangeToMap(this.customAttributeChanges, CustomAttributeContainerChanges, change, change.changeKey);
+    }
+    getPropertyNameFromChange(change) {
+        const type = change.diagnostic.ecDefinition;
+        return (Property.isProperty(type)) ? type.name : undefined;
+    }
+}
+/**
+ * An ISchemaChanges implementation for managing schema comparison diagnostics for Enumerations.
+ * @alpha
+ */
+export class EnumerationChanges extends SchemaItemChanges {
+    _enumeratorChanges = new Map();
+    /** Gets the EnumeratorChanges map. */
+    get enumeratorChanges() {
+        return this._enumeratorChanges;
+    }
+    /**
+     * Adds the change to the appropriate change collection at this level or adds the change
+     * to a Map of child changes will which propagate the change to lower levels.
+     * @param change The ISchemaChange to add.
+     */
+    addChange(change) {
+        super.addChange(change);
+        if (change.diagnostic.code === SchemaCompareCodes.EnumeratorDelta) {
+            this.addChangeToMap(this.enumeratorChanges, EnumeratorChanges, change, change.changeKey);
+            return;
+        }
+        if (change.diagnostic.code === SchemaCompareCodes.EnumeratorMissing) {
+            this.addChangeToMap(this.enumeratorChanges, EnumeratorChanges, change, change.changeKey);
+        }
+    }
+}
+/**
+ * An ISchemaChanges implementation for managing schema comparison diagnostics for CustomAttributeContainers.
+ * @alpha
+ */
+export class CustomAttributeContainerChanges extends BaseSchemaChanges {
+    _customAttributeChanges = [];
+    /** Gets the CustomAttributeContainerChange collection. */
+    get customAttributeChanges() {
+        return this._customAttributeChanges;
+    }
+    /**
+     * Adds the change to the appropriate change collection at this level.
+     * @param change The ISchemaChange to add.
+     */
+    addChange(change) {
+        if (change.diagnostic.code === SchemaCompareCodes.CustomAttributeInstanceClassMissing)
+            this.customAttributeChanges.push(change);
+    }
+}
+/**
+ * An ISchemaChanges implementation for managing schema comparison diagnostics for RelationshipConstraints.
+ * @alpha
+ */
+export class RelationshipConstraintChanges extends BaseSchemaChanges {
+    _constraintClassChanges = [];
+    _customAttributeChanges = new Map();
+    /** Gets the RelationshipConstraintClassChange collection. */
+    get constraintClassChanges() {
+        return this._constraintClassChanges;
+    }
+    /** Gets the CustomAttributeContainerChanges Map. */
+    get customAttributeChanges() {
+        return this._customAttributeChanges;
+    }
+    /**
+     * Adds the change to the appropriate change collection at this level or adds the change
+     * to a Map of child changes will which propagate the change to lower levels.
+     * @param change The ISchemaChange to add.
+     */
+    addChange(change) {
+        const constraintName = this.getConstraintNameFromChange(change);
+        if (!constraintName)
+            return;
+        if (this.isPropertyValueChangeForThis(change.diagnostic, constraintName)) {
+            this.propertyValueChanges.push(change);
+            return;
+        }
+        if (change.diagnostic.code === SchemaCompareCodes.RelationshipConstraintClassMissing) {
+            this.constraintClassChanges.push(change);
+            return;
+        }
+        if (this.isCAContainerChangeForThis(change.diagnostic, constraintName))
+            this.addChangeToMap(this.customAttributeChanges, CustomAttributeContainerChanges, change, change.changeKey);
+    }
+    getConstraintNameFromChange(change) {
+        const type = change.diagnostic.ecDefinition;
+        if (RelationshipConstraint.isRelationshipConstraint(type))
+            return type.fullName;
+        return undefined;
+    }
+}
+/**
+ * An ISchemaChanges implementation for managing schema comparison diagnostics for Enumerators.
+ * @alpha
+ */
+export class EnumeratorChanges extends BaseSchemaChanges {
+    _enumeratorDeltas = [];
+    _enumeratorMissing;
+    /** Gets the EnumeratorDelta collection. */
+    get enumeratorDeltas() {
+        return this._enumeratorDeltas;
+    }
+    /** Gets the EnumeratorMissing change. Maybe undefined. */
+    get enumeratorMissing() {
+        return this._enumeratorMissing;
+    }
+    /**
+     * Adds the change to the appropriate change collection.
+     * @param change The ISchemaChange to add.
+     */
+    addChange(change) {
+        if (change.diagnostic.code === SchemaCompareCodes.EnumeratorDelta) {
+            this.enumeratorDeltas.push(change);
+            return;
+        }
+        if (change.diagnostic.code === SchemaCompareCodes.EnumeratorMissing)
+            this._enumeratorMissing = change;
+    }
+}
+/**
+ * An ISchemaChanges implementation for managing schema comparison diagnostics for EntityClass mixin changes.
+ * @alpha
+ */
+export class EntityMixinChanges extends BaseSchemaChanges {
+    _entityMixinChange = [];
+    /** Gets the EntityMixinChange collection. */
+    get entityMixinChange() {
+        return this._entityMixinChange;
+    }
+    /**
+     * Adds the change to the appropriate change collection.
+     * @param change The ISchemaChange to add.
+     */
+    addChange(change) {
+        if (change.diagnostic.code === SchemaCompareCodes.EntityMixinMissing)
+            this.entityMixinChange.push(change);
+    }
+}
+/**
+ * An ISchemaChanges implementation for managing schema comparison diagnostics for KindOfQuantities.
+ * @alpha
+ */
+export class KindOfQuantityChanges extends SchemaItemChanges {
+    _presentationUnitChanges = new Map();
+    /** Gets the EntityMixinChange Map. */
+    get presentationUnitChanges() {
+        return this._presentationUnitChanges;
+    }
+    /**
+     * Adds the change to the appropriate change collection.
+     * @param change The ISchemaChange to add.
+     */
+    addChange(change) {
+        super.addChange(change);
+        if (change.diagnostic.code === SchemaCompareCodes.PresentationUnitMissing)
+            this.addChangeToMap(this.presentationUnitChanges, PresentationUnitChanges, change, change.changeKey);
+    }
+}
+/**
+ * An ISchemaChanges implementation for managing schema comparison diagnostics for KindOfQuantity presentation units.
+ * @alpha
+ */
+export class PresentationUnitChanges extends BaseSchemaChanges {
+    _presentationUnitChange = [];
+    /** Gets the PresentationUnitChange collection. */
+    get presentationUnitChange() {
+        return this._presentationUnitChange;
+    }
+    /**
+     * Adds the change to the appropriate change collection.
+     * @param change The ISchemaChange to add.
+     */
+    addChange(change) {
+        if (change.diagnostic.code === SchemaCompareCodes.PresentationUnitMissing)
+            this.presentationUnitChange.push(change);
+    }
+}
+/**
+ * An ISchemaChanges implementation for managing schema comparison diagnostics for Formats.
+ * @alpha
+ */
+export class FormatChanges extends SchemaItemChanges {
+    _formatUnitChanges = new Map();
+    /** Gets the FormatUnitChanges collection. */
+    get formatUnitChanges() {
+        return this._formatUnitChanges;
+    }
+    /**
+     * Adds the change to the appropriate change collection.
+     * @param change The ISchemaChange to add.
+     */
+    addChange(change) {
+        super.addChange(change);
+        if (change.diagnostic.code === SchemaCompareCodes.UnitLabelOverrideDelta) {
+            this.addChangeToMap(this.formatUnitChanges, FormatUnitChanges, change, change.changeKey);
+            return;
+        }
+        if (change.diagnostic.code === SchemaCompareCodes.FormatUnitMissing)
+            this.addChangeToMap(this.formatUnitChanges, FormatUnitChanges, change, change.changeKey);
+    }
+}
+/**
+ * An ISchemaChanges implementation for managing schema comparison diagnostics for Format units.
+ * @alpha
+ */
+export class FormatUnitChanges extends BaseSchemaChanges {
+    _unitLabelOverrideDeltas = [];
+    _formatUnitChanges = [];
+    /** Gets the UnitLabelOverrideDelta collection. */
+    get unitLabelOverrideDeltas() {
+        return this._unitLabelOverrideDeltas;
+    }
+    /** Gets the FormatUnitChange collection. */
+    get formatUnitChanges() {
+        return this._formatUnitChanges;
+    }
+    /**
+     * Adds the change to the appropriate change collection.
+     * @param change The ISchemaChange to add.
+     */
+    addChange(change) {
+        if (change.diagnostic.code === SchemaCompareCodes.UnitLabelOverrideDelta) {
+            this.unitLabelOverrideDeltas.push(change);
+            return;
+        }
+        if (change.diagnostic.code === SchemaCompareCodes.FormatUnitMissing)
+            this.formatUnitChanges.push(change);
+    }
+}
+/** ISchemaChange Implementations */
+/**
+ * An ISchemaChange implementation to act as the base class for all changes
+ * associated with SchemaItem instances.
+ * @alpha
+ */
+export class SchemaItemChange extends BaseSchemaChange {
+    get topLevelSchemaItem() { return this.diagnostic.ecDefinition; }
+}
+/**
+ * An ISchemaChange implementation for Schema reference changes.
+ * @alpha
+ */
+export class SchemaReferenceMissing extends BaseSchemaChange {
+    /** Gets the default ChangeType (Delta or Missing) for this change */
+    get defaultChangeType() { return ChangeType.Missing; }
+    /** Gets the SchemaItem or Schema (if a schema change) that this change ultimately belongs to. */
+    get topLevelSchemaItem() { return this.diagnostic.ecDefinition; }
+    /** Gets a string representation of the change. */
+    toString() {
+        const refSchema = this.getNameFromArgument(0, false, true);
+        return `Schema(${refSchema})`;
+    }
+}
+/**
+ * An ISchemaChange implementation differences of baseClasses between two ECClasses.
+ * @alpha
+ */
+export class SchemaReferenceDelta extends BaseSchemaChange {
+    /** Gets the default ChangeType (Delta or Missing) for this change */
+    get defaultChangeType() { return ChangeType.Delta; }
+    /** Gets the SchemaItem or Schema (if a schema change) that this change ultimately belongs to. */
+    get topLevelSchemaItem() { return this.diagnostic.ecDefinition; }
+    /** Gets a string representation of the change. */
+    toString() {
+        const refSchema = this.getNameFromArgument(0, false, true);
+        const versionA = this.getStringFromArgument(1);
+        const versionB = this.getStringFromArgument(2);
+        return `Schema(${refSchema}): ${versionA} -> ${versionB}`;
+    }
+}
+/**
+ * An ISchemaChange implementation for missing SchemaItems.
+ * @alpha
+ */
+export class SchemaItemMissing extends SchemaItemChange {
+    /** Gets the default ChangeType (Delta or Missing) for this change */
+    get defaultChangeType() { return ChangeType.Missing; }
+    /** Gets a string representation of the change. */
+    toString() {
+        const item = this.diagnostic.ecDefinition;
+        const typeName = ECClass.isECClass(item) ? "Class" : item.schemaItemType;
+        return `${typeName}(${item.name})`;
+    }
+}
+/**
+ * An ISchemaChange implementation for changes in property values of any EC type.
+ * @alpha
+ */
+export class PropertyValueChange extends BaseSchemaChange {
+    /** Gets the SchemaItem that this change ultimately belongs to. */
+    get topLevelSchemaItem() {
+        if (SchemaItem.isSchemaItem(this.diagnostic.ecDefinition))
+            return this.diagnostic.ecDefinition;
+        if (Schema.isSchema(this.diagnostic.ecDefinition))
+            return this.diagnostic.ecDefinition;
+        if (Property.isProperty(this.diagnostic.ecDefinition))
+            return this.diagnostic.ecDefinition.class;
+        if (RelationshipConstraint.isRelationshipConstraint(this.diagnostic.ecDefinition))
+            return this.diagnostic.ecDefinition.relationshipClass;
+        throw new Error();
+    }
+    /** Gets the default ChangeType (Delta or Missing) for this change */
+    get defaultChangeType() { return ChangeType.Delta; }
+    /** Gets a string representation of the change. */
+    toString() {
+        let property = this.getStringFromArgument(0);
+        // Capitalize property name
+        property = property.charAt(0).toUpperCase() + property.slice(1);
+        const valueA = this.getStringFromArgument(1);
+        const valueB = this.getStringFromArgument(2);
+        return `${property}: ${valueA} -> ${valueB}`;
+    }
+}
+/**
+ * An ISchemaChange implementation for missing CustomAttribute instances
+ * for a given container.
+ * @alpha
+ */
+export class CustomAttributeContainerChange extends BaseSchemaChange {
+    /** Gets the default ChangeType (Delta or Missing) for this change */
+    get defaultChangeType() { return ChangeType.Missing; }
+    /** Gets the SchemaItem that this change ultimately belongs to. */
+    get topLevelSchemaItem() {
+        if (SchemaItem.isSchemaItem(this.diagnostic.ecDefinition))
+            return this.diagnostic.ecDefinition;
+        if (Property.isProperty(this.diagnostic.ecDefinition))
+            return this.diagnostic.ecDefinition.class;
+        if (Schema.isSchema(this.diagnostic.ecDefinition))
+            return this.diagnostic.ecDefinition;
+        if (RelationshipConstraint.isRelationshipConstraint(this.diagnostic.ecDefinition))
+            return this.diagnostic.ecDefinition.relationshipClass;
+        throw new Error();
+    }
+    /** Gets the key to use in a Map of this type of ISchemaChange. */
+    get changeKey() {
+        return this.getValueFromArgument(0).className;
+    }
+    /** Gets a string representation of the change. */
+    toString() {
+        return `CustomAttribute: ${this.changeKey}`;
+    }
+}
+/**
+ * An ISchemaChange implementation differences of baseClasses between two ECClasses.
+ * @alpha
+ */
+export class BaseClassDelta extends SchemaItemChange {
+    /** Gets the default ChangeType (Delta or Missing) for this change */
+    get defaultChangeType() { return ChangeType.Delta; }
+    /** Gets a string representation of the change. */
+    toString() {
+        const classA = this.getNameFromArgument(0, true, true);
+        const classB = this.getNameFromArgument(1, true, true);
+        return `BaseClass: ${classA} -> ${classB}`;
+    }
+}
+/**
+ * An ISchemaChange implementation for missing properties.
+ * @alpha
+ */
+export class PropertyMissing extends BaseSchemaChange {
+    /** Gets the SchemaItem that this change ultimately belongs to. */
+    get topLevelSchemaItem() {
+        return this.diagnostic.ecDefinition.class;
+    }
+    /** Gets the default ChangeType (Delta or Missing) for this change */
+    get defaultChangeType() { return ChangeType.Missing; }
+    /** Gets a string representation of the change. */
+    toString() {
+        return `Property(${this.diagnostic.ecDefinition.name})`;
+    }
+}
+/**
+ * An ISchemaChange implementation for missing RelationshipConstraint classes.
+ * @alpha
+ */
+export class RelationshipConstraintClassChange extends BaseSchemaChange {
+    /** Gets the default ChangeType (Delta or Missing) for this change */
+    get defaultChangeType() { return ChangeType.Missing; }
+    /** Gets the SchemaItem that this change ultimately belongs to. */
+    get topLevelSchemaItem() {
+        return this.diagnostic.ecDefinition.relationshipClass;
+    }
+    /** Gets a string representation of the change. */
+    toString() {
+        const constraintClass = this.getNameFromArgument(0, false, true);
+        return `ConstraintClass: ${constraintClass}`;
+    }
+}
+/**
+ * An ISchemaChange implementation for differences of Enumerator properties.
+ * @alpha
+ */
+export class EnumeratorDelta extends BaseSchemaChange {
+    /** Gets the default ChangeType (Delta or Missing) for this change */
+    get defaultChangeType() { return ChangeType.Delta; }
+    /** Gets the SchemaItem that this change ultimately belongs to. */
+    get topLevelSchemaItem() {
+        return this.diagnostic.ecDefinition;
+    }
+    /** Gets the key to use in a Map of this type of ISchemaChange. */
+    get changeKey() {
+        const enumerator = this.getValueFromArgument(0);
+        return enumerator.name;
+    }
+    /** Gets a string representation of the change. */
+    toString() {
+        let propertyName = this.getStringFromArgument(1);
+        // Capitalize property name
+        propertyName = propertyName.charAt(0).toUpperCase() + propertyName.slice(1);
+        const valueA = this.getStringFromArgument(2);
+        const valueB = this.getStringFromArgument(3);
+        return `${propertyName}: ${valueA} -> ${valueB}`;
+    }
+}
+/**
+ * An ISchemaChange implementation for missing Enumerators within an Enumeration.
+ * @alpha
+ */
+export class EnumeratorMissing extends BaseSchemaChange {
+    /** Gets the default ChangeType (Delta or Missing) for this change */
+    get defaultChangeType() { return ChangeType.Missing; }
+    /** Gets the SchemaItem that this change ultimately belongs to. */
+    get topLevelSchemaItem() {
+        return this.diagnostic.ecDefinition;
+    }
+    /** Gets the key to use in a Map of this type of ISchemaChange. */
+    get changeKey() {
+        return this.getValueFromArgument(0).name;
+    }
+    /** Gets a string representation of the change. */
+    toString() {
+        return `Enumerator(${this.changeKey})`;
+    }
+}
+/**
+ * An ISchemaChange implementation for missing mixins within an EntityClass.
+ * @alpha
+ */
+export class EntityMixinChange extends BaseSchemaChange {
+    /** Gets the default ChangeType (Delta or Missing) for this change */
+    get defaultChangeType() { return ChangeType.Missing; }
+    /** Gets the SchemaItem that this change ultimately belongs to. */
+    get topLevelSchemaItem() {
+        return this.diagnostic.ecDefinition;
+    }
+    /** Gets the key to use in a Map of this type of ISchemaChange. */
+    get changeKey() {
+        return this.getNameFromArgument(0, false, true);
+    }
+    /** Gets a string representation of the change. */
+    toString() {
+        return `Mixin: ${this.changeKey}`;
+    }
+}
+/**
+ * An ISchemaChange implementation for missing presentation Units within a KindOfQuantity.
+ * @alpha
+ */
+export class PresentationUnitChange extends BaseSchemaChange {
+    /** Gets the default ChangeType (Delta or Missing) for this change */
+    get defaultChangeType() { return ChangeType.Missing; }
+    /** Gets the SchemaItem that this change ultimately belongs to. */
+    get topLevelSchemaItem() {
+        return this.diagnostic.ecDefinition;
+    }
+    /** Gets the key to use in a Map of this type of ISchemaChange. */
+    get changeKey() {
+        return this.getNameFromArgument(0, false, true);
+    }
+    /** Gets a string representation of the change. */
+    toString() {
+        return `Unit: ${this.changeKey}`;
+    }
+    get _isOverrideFormat() {
+        if (!this.diagnostic.messageArgs)
+            return false;
+        return OverrideFormat.isOverrideFormat(this.diagnostic.messageArgs[0]);
+    }
+}
+/**
+ * An ISchemaChange implementation for missing Units within a Format.
+ * @alpha
+ */
+export class FormatUnitChange extends BaseSchemaChange {
+    /** Gets the default ChangeType (Delta or Missing) for this change */
+    get defaultChangeType() { return ChangeType.Missing; }
+    /** Gets the SchemaItem that this change ultimately belongs to. */
+    get topLevelSchemaItem() {
+        return this.diagnostic.ecDefinition;
+    }
+    /** Gets the key to use in a Map of this type of ISchemaChange. */
+    get changeKey() {
+        return this.getNameFromArgument(0, false, true);
+    }
+    /** Gets a string representation of the change. */
+    toString() {
+        return `Unit: ${this.changeKey}, label: ${this.getStringFromArgument(1)}`;
+    }
+    get _isInvertedUnit() {
+        if (!this.diagnostic.messageArgs)
+            return false;
+        return this.diagnostic.messageArgs[0].schemaItemType === SchemaItemType.InvertedUnit;
+    }
+}
+/**
+ * An ISchemaChange implementation for differences of Unit label overrides within a given Format.
+ * @alpha
+ */
+export class UnitLabelOverrideDelta extends BaseSchemaChange {
+    /** Gets the default ChangeType (Delta or Missing) for this change */
+    get defaultChangeType() { return ChangeType.Delta; }
+    /** Gets the SchemaItem that this change ultimately belongs to. */
+    get topLevelSchemaItem() {
+        return this.diagnostic.ecDefinition;
+    }
+    /** Gets the key to use in a Map of this type of ISchemaChange. */
+    get changeKey() {
+        return this.getNameFromArgument(0, false, true);
+    }
+    /** Gets a string representation of the change. */
+    toString() {
+        const valueA = this.getStringFromArgument(1);
+        const valueB = this.getStringFromArgument(2);
+        return `Label: ${valueA} -> ${valueB}`;
+    }
+    get _isInvertedUnit() {
+        if (!this.diagnostic.messageArgs)
+            return false;
+        return this.diagnostic.messageArgs[0].schemaItemType === SchemaItemType.InvertedUnit;
+    }
+}
+//# sourceMappingURL=SchemaChanges.js.map