@itwin/ecschema-editing 3.0.0-dev.77 → 3.0.0-dev.81

package/lib/{Validation → cjs/Validation}/ECRules.js

@@ -6,30 +6,6 @@
 /** @packageDocumentation
  * @module Validation
  */
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
-var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
-    var i, p;
-    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
-    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
-};
-var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
-    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-    function fulfill(value) { resume("next", value); }
-    function reject(value) { resume("throw", value); }
-    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateCustomAttributeInstance = exports.mixinAppliedToClassMustDeriveFromConstraint = exports.enumerationTypeUnsupported = exports.abstractConstraintMustExistWithMultipleConstraints = exports.atLeastOneConstraintClassDefined = exports.constraintClassesDeriveFromAbstractContraint = exports.derivedConstraintsMustNarrowBaseConstraints = exports.abstractConstraintMustNarrowBaseConstraints = exports.validateNavigationProperty = exports.incompatibleUnitPropertyOverride = exports.incompatibleTypePropertyOverride = exports.incompatibleValueTypePropertyOverride = exports.abstractClassWithNonAbstractBase = exports.baseClassIsOfDifferentType = exports.baseClassIsSealed = exports.validateSchemaReferencesSync = exports.validateSchemaReferences = exports.ECRuleSet = exports.Diagnostics = exports.DiagnosticCodes = void 0;
 const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
@@ -189,10 +165,8 @@ exports.ECRuleSet = {
  * Validates schema references against multiple EC rules.
  * @param schema The schema to validate.
  */
-function validateSchemaReferences(schema) {
-    return __asyncGenerator(this, arguments, function* validateSchemaReferences_1() {
-        yield __await(yield* __asyncDelegator(__asyncValues(validateSchemaReferencesSync(schema))));
-    });
+async function* validateSchemaReferences(schema) {
+    yield* validateSchemaReferencesSync(schema);
 }
 exports.validateSchemaReferences = validateSchemaReferences;
 function* validateSchemaReferencesSync(schema) {
@@ -222,321 +196,264 @@ exports.validateSchemaReferencesSync = validateSchemaReferencesSync;
  * EC Rule: Sealed classes cannot be a base class.
  * @internal
  */
-function baseClassIsSealed(ecClass) {
-    return __asyncGenerator(this, arguments, function* baseClassIsSealed_1() {
-        if (!ecClass.baseClass)
-            return yield __await(void 0);
-        const baseClass = yield __await(ecClass.baseClass);
-        // return if rule passed
-        if (baseClass.modifier !== ecschema_metadata_1.ECClassModifier.Sealed)
-            return yield __await(void 0);
-        yield yield __await(new exports.Diagnostics.BaseClassIsSealed(ecClass, [ecClass.fullName, baseClass.fullName]));
-    });
+async function* baseClassIsSealed(ecClass) {
+    if (!ecClass.baseClass)
+        return;
+    const baseClass = await ecClass.baseClass;
+    // return if rule passed
+    if (baseClass.modifier !== ecschema_metadata_1.ECClassModifier.Sealed)
+        return;
+    yield new exports.Diagnostics.BaseClassIsSealed(ecClass, [ecClass.fullName, baseClass.fullName]);
 }
 exports.baseClassIsSealed = baseClassIsSealed;
 /**
  * EC Rule: Base and child class must be of the same type (i.e. Entity, Mixin, Relationship, etc.)
  * @internal
  */
-function baseClassIsOfDifferentType(ecClass) {
-    return __asyncGenerator(this, arguments, function* baseClassIsOfDifferentType_1() {
-        if (!ecClass.baseClass)
-            return yield __await(void 0);
-        const baseClass = yield __await(ecClass.baseClass);
-        // return if rule passed
-        if (baseClass.schemaItemType === ecClass.schemaItemType)
-            return yield __await(void 0);
-        const itemType = (0, ecschema_metadata_1.schemaItemTypeToString)(baseClass.schemaItemType);
-        yield yield __await(new exports.Diagnostics.BaseClassIsOfDifferentType(ecClass, [ecClass.fullName, baseClass.fullName, itemType]));
-    });
+async function* baseClassIsOfDifferentType(ecClass) {
+    if (!ecClass.baseClass)
+        return;
+    const baseClass = await ecClass.baseClass;
+    // return if rule passed
+    if (baseClass.schemaItemType === ecClass.schemaItemType)
+        return;
+    const itemType = (0, ecschema_metadata_1.schemaItemTypeToString)(baseClass.schemaItemType);
+    yield new exports.Diagnostics.BaseClassIsOfDifferentType(ecClass, [ecClass.fullName, baseClass.fullName, itemType]);
 }
 exports.baseClassIsOfDifferentType = baseClassIsOfDifferentType;
 /**
  * EC Rule: Abstract class cannot derive from a non-abstract base class.
  * @internal
  */
-function abstractClassWithNonAbstractBase(ecClass) {
-    return __asyncGenerator(this, arguments, function* abstractClassWithNonAbstractBase_1() {
-        if (ecClass.modifier !== ecschema_metadata_1.ECClassModifier.Abstract || !ecClass.baseClass)
-            return yield __await(void 0);
-        const baseClass = yield __await(ecClass.baseClass);
-        // return if rule passed
-        if (baseClass.modifier === ecschema_metadata_1.ECClassModifier.Abstract)
-            return yield __await(void 0);
-        yield yield __await(new exports.Diagnostics.AbstractClassWithNonAbstractBase(ecClass, [ecClass.fullName, baseClass.fullName]));
-    });
+async function* abstractClassWithNonAbstractBase(ecClass) {
+    if (ecClass.modifier !== ecschema_metadata_1.ECClassModifier.Abstract || !ecClass.baseClass)
+        return;
+    const baseClass = await ecClass.baseClass;
+    // return if rule passed
+    if (baseClass.modifier === ecschema_metadata_1.ECClassModifier.Abstract)
+        return;
+    yield new exports.Diagnostics.AbstractClassWithNonAbstractBase(ecClass, [ecClass.fullName, baseClass.fullName]);
 }
 exports.abstractClassWithNonAbstractBase = abstractClassWithNonAbstractBase;
 /**
  * EC Rule: When overriding a class primitive property, the child and base property must be of the same type (string, number, etc...).
  * @internal
 */
-function incompatibleValueTypePropertyOverride(property) {
-    return __asyncGenerator(this, arguments, function* incompatibleValueTypePropertyOverride_1() {
-        var e_1, _a;
-        if (!property.class.baseClass)
-            return yield __await(void 0);
-        const primitiveType = getPrimitiveType(property);
-        if (!primitiveType)
-            return yield __await(void 0);
-        async function callback(baseClass) {
-            const baseProperty = await baseClass.getProperty(property.name);
-            if (!baseProperty)
-                return;
-            // Other rules will catch this if false, but we need to make sure
-            // types match for this rule to be valid.
-            if (!propertyTypesMatch(property, baseProperty))
-                return;
-            const baseType = getPrimitiveType(baseProperty);
-            // Return if rule passed
-            if (!baseType || primitiveType === baseType)
-                return;
-            return new exports.Diagnostics.IncompatibleValueTypePropertyOverride(property, [property.class.fullName, property.name, baseClass.fullName, (0, ecschema_metadata_1.primitiveTypeToString)(baseType), (0, ecschema_metadata_1.primitiveTypeToString)(primitiveType)]);
-        }
-        try {
-            for (var _b = __asyncValues(property.class.getAllBaseClasses()), _c; _c = yield __await(_b.next()), !_c.done;) {
-                const baseClass = _c.value;
-                const result = yield __await(callback(baseClass));
-                if (result)
-                    yield yield __await(result);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) yield __await(_a.call(_b));
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-    });
+async function* incompatibleValueTypePropertyOverride(property) {
+    if (!property.class.baseClass)
+        return;
+    const primitiveType = getPrimitiveType(property);
+    if (!primitiveType)
+        return;
+    async function callback(baseClass) {
+        const baseProperty = await baseClass.getProperty(property.name);
+        if (!baseProperty)
+            return;
+        // Other rules will catch this if false, but we need to make sure
+        // types match for this rule to be valid.
+        if (!propertyTypesMatch(property, baseProperty))
+            return;
+        const baseType = getPrimitiveType(baseProperty);
+        // Return if rule passed
+        if (!baseType || primitiveType === baseType)
+            return;
+        return new exports.Diagnostics.IncompatibleValueTypePropertyOverride(property, [property.class.fullName, property.name, baseClass.fullName, (0, ecschema_metadata_1.primitiveTypeToString)(baseType), (0, ecschema_metadata_1.primitiveTypeToString)(primitiveType)]);
+    }
+    for await (const baseClass of property.class.getAllBaseClasses()) {
+        const result = await callback(baseClass);
+        if (result)
+            yield result;
+    }
 }
 exports.incompatibleValueTypePropertyOverride = incompatibleValueTypePropertyOverride;
 /**
  * EC Rule: When overriding a class property, the child and base property must be of the same property type (primitive, struct, enumeration, etc...).
  * @internal
  */
-function incompatibleTypePropertyOverride(property) {
-    return __asyncGenerator(this, arguments, function* incompatibleTypePropertyOverride_1() {
-        var e_2, _a;
-        if (!property.class.baseClass)
-            return yield __await(void 0);
-        async function callback(baseClass) {
-            const baseProperty = await baseClass.getProperty(property.name);
-            if (!baseProperty)
-                return;
-            // Return if rule passed
-            if (propertyTypesMatch(property, baseProperty))
-                return;
-            return new exports.Diagnostics.IncompatibleTypePropertyOverride(property, [property.class.fullName, property.name, baseClass.fullName, baseProperty.constructor.name, property.constructor.name]);
-        }
-        try {
-            for (var _b = __asyncValues(property.class.getAllBaseClasses()), _c; _c = yield __await(_b.next()), !_c.done;) {
-                const baseClass = _c.value;
-                const result = yield __await(callback(baseClass));
-                if (result)
-                    yield yield __await(result);
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) yield __await(_a.call(_b));
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
-    });
+async function* incompatibleTypePropertyOverride(property) {
+    if (!property.class.baseClass)
+        return;
+    async function callback(baseClass) {
+        const baseProperty = await baseClass.getProperty(property.name);
+        if (!baseProperty)
+            return;
+        // Return if rule passed
+        if (propertyTypesMatch(property, baseProperty))
+            return;
+        return new exports.Diagnostics.IncompatibleTypePropertyOverride(property, [property.class.fullName, property.name, baseClass.fullName, baseProperty.constructor.name, property.constructor.name]);
+    }
+    for await (const baseClass of property.class.getAllBaseClasses()) {
+        const result = await callback(baseClass);
+        if (result)
+            yield result;
+    }
 }
 exports.incompatibleTypePropertyOverride = incompatibleTypePropertyOverride;
 /**
  * EC Rule: When overriding a kindOfQuantity property, the child and base property units must be the same.
  * @internal
  */
-function incompatibleUnitPropertyOverride(property) {
-    return __asyncGenerator(this, arguments, function* incompatibleUnitPropertyOverride_1() {
-        var e_3, _a;
-        if (!property.kindOfQuantity || !property.class.baseClass)
-            return yield __await(void 0);
-        async function callback(baseClass) {
-            const baseProperty = await baseClass.getProperty(property.name);
-            if (!baseProperty || !baseProperty.kindOfQuantity)
-                return;
-            // Other rules will catch this if false, but we need to make sure
-            // types match for this rule to be valid.
-            if (!propertyTypesMatch(property, baseProperty))
-                return;
-            const koq = await property.kindOfQuantity;
-            const baseKoq = await baseProperty.kindOfQuantity;
-            if (!koq || !baseKoq)
-                return;
-            const unit = await koq.persistenceUnit;
-            const baseUnit = await baseKoq.persistenceUnit;
-            if (!unit || !baseUnit)
-                return;
-            // return if rule passed
-            if (unit.key.matches(baseUnit.key))
-                return;
-            return new exports.Diagnostics.IncompatibleUnitPropertyOverride(property, [
-                property.class.fullName,
-                property.name,
-                baseClass.fullName,
-                baseKoq.fullName,
-                baseUnit.fullName,
-                unit.fullName,
-                koq.fullName,
-            ]);
-        }
-        try {
-            for (var _b = __asyncValues(property.class.getAllBaseClasses()), _c; _c = yield __await(_b.next()), !_c.done;) {
-                const baseClass = _c.value;
-                const result = yield __await(callback(baseClass));
-                if (result)
-                    yield yield __await(result);
-            }
-        }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) yield __await(_a.call(_b));
-            }
-            finally { if (e_3) throw e_3.error; }
-        }
-    });
+async function* incompatibleUnitPropertyOverride(property) {
+    if (!property.kindOfQuantity || !property.class.baseClass)
+        return;
+    async function callback(baseClass) {
+        const baseProperty = await baseClass.getProperty(property.name);
+        if (!baseProperty || !baseProperty.kindOfQuantity)
+            return;
+        // Other rules will catch this if false, but we need to make sure
+        // types match for this rule to be valid.
+        if (!propertyTypesMatch(property, baseProperty))
+            return;
+        const koq = await property.kindOfQuantity;
+        const baseKoq = await baseProperty.kindOfQuantity;
+        if (!koq || !baseKoq)
+            return;
+        const unit = await koq.persistenceUnit;
+        const baseUnit = await baseKoq.persistenceUnit;
+        if (!unit || !baseUnit)
+            return;
+        // return if rule passed
+        if (unit.key.matches(baseUnit.key))
+            return;
+        return new exports.Diagnostics.IncompatibleUnitPropertyOverride(property, [
+            property.class.fullName,
+            property.name,
+            baseClass.fullName,
+            baseKoq.fullName,
+            baseUnit.fullName,
+            unit.fullName,
+            koq.fullName,
+        ]);
+    }
+    for await (const baseClass of property.class.getAllBaseClasses()) {
+        const result = await callback(baseClass);
+        if (result)
+            yield result;
+    }
 }
 exports.incompatibleUnitPropertyOverride = incompatibleUnitPropertyOverride;
 /** Validates Navigation Properties. EC Rules: 1303, 1304 */
-function validateNavigationProperty(property) {
-    return __asyncGenerator(this, arguments, function* validateNavigationProperty_1() {
-        if (!property.isNavigation())
-            return yield __await(void 0);
-        const navProp = property;
-        const relationship = yield __await(navProp.relationshipClass);
-        if (relationship.baseClass)
-            yield yield __await(new exports.Diagnostics.NavigationRelationshipMustBeRoot(property, [property.fullName, relationship.fullName]));
-        let thisConstraint;
-        let thatConstraint;
-        let navigationClassSide;
-        if (navProp.direction === ecschema_metadata_1.StrengthDirection.Forward) {
-            thisConstraint = relationship.source;
-            thatConstraint = relationship.target;
-            navigationClassSide = "source";
-        }
-        else {
-            thisConstraint = relationship.target;
-            thatConstraint = relationship.source;
-            navigationClassSide = "target";
-        }
-        const thatAbstractConstraint = yield __await(thatConstraint.abstractConstraint);
-        if (thatAbstractConstraint && thatAbstractConstraint.schemaItemType === ecschema_metadata_1.SchemaItemType.RelationshipClass) {
-            yield yield __await(new exports.Diagnostics.NavigationRelationshipAbstractConstraintEntityOrMixin(property, [property.fullName, relationship.fullName]));
-        }
-        const isClassSupported = async (ecClass, propertyName, constraintName) => {
-            if (constraintName === ecClass.fullName && undefined !== await ecClass.getProperty(propertyName))
-                return true;
-            const inheritedProp = await ecClass.getInheritedProperty(propertyName);
-            if (inheritedProp && constraintName === inheritedProp.class.fullName)
-                return true;
-            const baseClass = await ecClass.baseClass;
-            if (!baseClass)
-                return false;
-            return isClassSupported(baseClass, propertyName, constraintName);
-        };
-        let classSupported = false;
-        if (thisConstraint.constraintClasses) {
-            for (const constraintClass of thisConstraint.constraintClasses) {
-                classSupported = yield __await(isClassSupported(property.class, property.name, constraintClass.fullName));
-                if (classSupported)
-                    break;
-            }
-        }
-        if (!classSupported)
-            yield yield __await(new exports.Diagnostics.NavigationClassMustBeAConstraintClassOfRelationship(property, [property.class.name, property.name, relationship.fullName, navigationClassSide]));
-        if (thatConstraint.multiplicity === ecschema_metadata_1.RelationshipMultiplicity.oneMany || thatConstraint.multiplicity === ecschema_metadata_1.RelationshipMultiplicity.zeroMany) {
-            const direction = (0, ecschema_metadata_1.strengthDirectionToString)(navProp.direction);
-            yield yield __await(new exports.Diagnostics.NavigationTargetMustHaveSingularMultiplicity(property, [property.fullName, relationship.fullName, direction]));
+async function* validateNavigationProperty(property) {
+    if (!property.isNavigation())
+        return;
+    const navProp = property;
+    const relationship = await navProp.relationshipClass;
+    if (relationship.baseClass)
+        yield new exports.Diagnostics.NavigationRelationshipMustBeRoot(property, [property.fullName, relationship.fullName]);
+    let thisConstraint;
+    let thatConstraint;
+    let navigationClassSide;
+    if (navProp.direction === ecschema_metadata_1.StrengthDirection.Forward) {
+        thisConstraint = relationship.source;
+        thatConstraint = relationship.target;
+        navigationClassSide = "source";
+    }
+    else {
+        thisConstraint = relationship.target;
+        thatConstraint = relationship.source;
+        navigationClassSide = "target";
+    }
+    const thatAbstractConstraint = await thatConstraint.abstractConstraint;
+    if (thatAbstractConstraint && thatAbstractConstraint.schemaItemType === ecschema_metadata_1.SchemaItemType.RelationshipClass) {
+        yield new exports.Diagnostics.NavigationRelationshipAbstractConstraintEntityOrMixin(property, [property.fullName, relationship.fullName]);
+    }
+    const isClassSupported = async (ecClass, propertyName, constraintName) => {
+        if (constraintName === ecClass.fullName && undefined !== await ecClass.getProperty(propertyName))
+            return true;
+        const inheritedProp = await ecClass.getInheritedProperty(propertyName);
+        if (inheritedProp && constraintName === inheritedProp.class.fullName)
+            return true;
+        const baseClass = await ecClass.baseClass;
+        if (!baseClass)
+            return false;
+        return isClassSupported(baseClass, propertyName, constraintName);
+    };
+    let classSupported = false;
+    if (thisConstraint.constraintClasses) {
+        for (const constraintClass of thisConstraint.constraintClasses) {
+            classSupported = await isClassSupported(property.class, property.name, constraintClass.fullName);
+            if (classSupported)
+                break;
         }
-        return yield __await(void 0);
-    });
+    }
+    if (!classSupported)
+        yield new exports.Diagnostics.NavigationClassMustBeAConstraintClassOfRelationship(property, [property.class.name, property.name, relationship.fullName, navigationClassSide]);
+    if (thatConstraint.multiplicity === ecschema_metadata_1.RelationshipMultiplicity.oneMany || thatConstraint.multiplicity === ecschema_metadata_1.RelationshipMultiplicity.zeroMany) {
+        const direction = (0, ecschema_metadata_1.strengthDirectionToString)(navProp.direction);
+        yield new exports.Diagnostics.NavigationTargetMustHaveSingularMultiplicity(property, [property.fullName, relationship.fullName, direction]);
+    }
+    return;
 }
 exports.validateNavigationProperty = validateNavigationProperty;
 /**
  * EC Rule: When overriding a RelationshipClass, the derived abstract constraint must narrow the base constraint classes.
  * @internal
  */
-function abstractConstraintMustNarrowBaseConstraints(ecClass) {
-    return __asyncGenerator(this, arguments, function* abstractConstraintMustNarrowBaseConstraints_1() {
-        if (!ecClass.baseClass)
-            return yield __await(void 0);
-        const baseRelationship = yield __await(ecClass.baseClass);
-        const sourceResult = yield __await(applyAbstractConstraintMustNarrowBaseConstraints(ecClass, ecClass.source, baseRelationship));
-        if (sourceResult)
-            yield yield __await(sourceResult);
-        const targetResult = yield __await(applyAbstractConstraintMustNarrowBaseConstraints(ecClass, ecClass.target, baseRelationship));
-        if (targetResult)
-            yield yield __await(targetResult);
-    });
+async function* abstractConstraintMustNarrowBaseConstraints(ecClass) {
+    if (!ecClass.baseClass)
+        return;
+    const baseRelationship = await ecClass.baseClass;
+    const sourceResult = await applyAbstractConstraintMustNarrowBaseConstraints(ecClass, ecClass.source, baseRelationship);
+    if (sourceResult)
+        yield sourceResult;
+    const targetResult = await applyAbstractConstraintMustNarrowBaseConstraints(ecClass, ecClass.target, baseRelationship);
+    if (targetResult)
+        yield targetResult;
 }
 exports.abstractConstraintMustNarrowBaseConstraints = abstractConstraintMustNarrowBaseConstraints;
 /**
  * EC Rule: When overriding a RelationshipClass, derived constraint classes must narrow base constraint classes.
  * @internal
  */
-function derivedConstraintsMustNarrowBaseConstraints(ecClass) {
-    return __asyncGenerator(this, arguments, function* derivedConstraintsMustNarrowBaseConstraints_1() {
-        if (!ecClass.baseClass)
-            return yield __await(void 0);
-        const baseRelationship = yield __await(ecClass.baseClass);
-        const sourceResult = yield __await(applyDerivedConstraintsMustNarrowBaseConstraints(ecClass, ecClass.source, baseRelationship));
-        if (sourceResult)
-            yield yield __await(sourceResult);
-        const targetResult = yield __await(applyDerivedConstraintsMustNarrowBaseConstraints(ecClass, ecClass.target, baseRelationship));
-        if (targetResult)
-            yield yield __await(targetResult);
-    });
+async function* derivedConstraintsMustNarrowBaseConstraints(ecClass) {
+    if (!ecClass.baseClass)
+        return;
+    const baseRelationship = await ecClass.baseClass;
+    const sourceResult = await applyDerivedConstraintsMustNarrowBaseConstraints(ecClass, ecClass.source, baseRelationship);
+    if (sourceResult)
+        yield sourceResult;
+    const targetResult = await applyDerivedConstraintsMustNarrowBaseConstraints(ecClass, ecClass.target, baseRelationship);
+    if (targetResult)
+        yield targetResult;
 }
 exports.derivedConstraintsMustNarrowBaseConstraints = derivedConstraintsMustNarrowBaseConstraints;
 /**
  * EC Rule: All constraint classes must have a common base class specified in the abstract constraint.
  * @internal
  */
-function constraintClassesDeriveFromAbstractContraint(ecClass) {
-    return __asyncGenerator(this, arguments, function* constraintClassesDeriveFromAbstractContraint_1() {
-        const sourceResult = yield __await(applyConstraintClassesDeriveFromAbstractContraint(ecClass, ecClass.source));
-        if (sourceResult)
-            yield yield __await(sourceResult);
-        const targetResult = yield __await(applyConstraintClassesDeriveFromAbstractContraint(ecClass, ecClass.target));
-        if (targetResult)
-            yield yield __await(targetResult);
-    });
+async function* constraintClassesDeriveFromAbstractContraint(ecClass) {
+    const sourceResult = await applyConstraintClassesDeriveFromAbstractContraint(ecClass, ecClass.source);
+    if (sourceResult)
+        yield sourceResult;
+    const targetResult = await applyConstraintClassesDeriveFromAbstractContraint(ecClass, ecClass.target);
+    if (targetResult)
+        yield targetResult;
 }
 exports.constraintClassesDeriveFromAbstractContraint = constraintClassesDeriveFromAbstractContraint;
 /**
  * EC Rule: At least on concrete constraint class must be defined in the list of constraint classes.
  * @internal
  */
-function atLeastOneConstraintClassDefined(constraint) {
-    return __asyncGenerator(this, arguments, function* atLeastOneConstraintClassDefined_1() {
-        if (!constraint.constraintClasses || constraint.constraintClasses.length === 0) {
-            const constraintType = constraint.isSource ? ecschema_metadata_1.ECStringConstants.RELATIONSHIP_END_SOURCE : ecschema_metadata_1.ECStringConstants.RELATIONSHIP_END_TARGET;
-            yield yield __await(new exports.Diagnostics.AtLeastOneConstraintClassDefined(constraint, [constraintType, constraint.relationshipClass.fullName]));
-        }
-    });
+async function* atLeastOneConstraintClassDefined(constraint) {
+    if (!constraint.constraintClasses || constraint.constraintClasses.length === 0) {
+        const constraintType = constraint.isSource ? ecschema_metadata_1.ECStringConstants.RELATIONSHIP_END_SOURCE : ecschema_metadata_1.ECStringConstants.RELATIONSHIP_END_TARGET;
+        yield new exports.Diagnostics.AtLeastOneConstraintClassDefined(constraint, [constraintType, constraint.relationshipClass.fullName]);
+    }
 }
 exports.atLeastOneConstraintClassDefined = atLeastOneConstraintClassDefined;
 /**
  * EC Rule: If multiple constraints exist, an abstract constraint must be defined.
  * @internal
  */
-function abstractConstraintMustExistWithMultipleConstraints(constraint) {
-    return __asyncGenerator(this, arguments, function* abstractConstraintMustExistWithMultipleConstraints_1() {
-        if (!constraint.constraintClasses || constraint.constraintClasses.length <= 1) {
-            return yield __await(void 0);
-        }
-        const abstractConstraint = yield __await(getAbstractConstraint(constraint));
-        if (abstractConstraint)
-            return yield __await(void 0);
-        const constraintType = constraint.isSource ? ecschema_metadata_1.ECStringConstants.RELATIONSHIP_END_SOURCE : ecschema_metadata_1.ECStringConstants.RELATIONSHIP_END_TARGET;
-        yield yield __await(new exports.Diagnostics.AbstractConstraintMustExistWithMultipleConstraints(constraint, [constraintType, constraint.relationshipClass.fullName]));
-    });
+async function* abstractConstraintMustExistWithMultipleConstraints(constraint) {
+    if (!constraint.constraintClasses || constraint.constraintClasses.length <= 1) {
+        return;
+    }
+    const abstractConstraint = await getAbstractConstraint(constraint);
+    if (abstractConstraint)
+        return;
+    const constraintType = constraint.isSource ? ecschema_metadata_1.ECStringConstants.RELATIONSHIP_END_SOURCE : ecschema_metadata_1.ECStringConstants.RELATIONSHIP_END_TARGET;
+    yield new exports.Diagnostics.AbstractConstraintMustExistWithMultipleConstraints(constraint, [constraintType, constraint.relationshipClass.fullName]);
 }
 exports.abstractConstraintMustExistWithMultipleConstraints = abstractConstraintMustExistWithMultipleConstraints;
 function propertyTypesMatch(propertyA, propertyB) {
@@ -551,75 +468,63 @@ function getPrimitiveType(property) {
  * EC Rule: Enumeration type must be a string or integer
  * @internal
  */
-function enumerationTypeUnsupported(enumeration) {
-    return __asyncGenerator(this, arguments, function* enumerationTypeUnsupported_1() {
-        const type = enumeration.type;
-        if (type === ecschema_metadata_1.PrimitiveType.Integer || type === ecschema_metadata_1.PrimitiveType.String)
-            return yield __await(void 0);
-        yield yield __await(new exports.Diagnostics.EnumerationTypeUnsupported(enumeration, [enumeration.fullName]));
-    });
+async function* enumerationTypeUnsupported(enumeration) {
+    const type = enumeration.type;
+    if (type === ecschema_metadata_1.PrimitiveType.Integer || type === ecschema_metadata_1.PrimitiveType.String)
+        return;
+    yield new exports.Diagnostics.EnumerationTypeUnsupported(enumeration, [enumeration.fullName]);
 }
 exports.enumerationTypeUnsupported = enumerationTypeUnsupported;
 /**
  * EC Rule: Mixin applied to class must derived from the Mixin appliesTo constraint.
  * @internal
  */
-function mixinAppliedToClassMustDeriveFromConstraint(entityClass) {
-    return __asyncGenerator(this, arguments, function* mixinAppliedToClassMustDeriveFromConstraint_1() {
-        for (const lazyMixin of entityClass.mixins) {
-            const mixin = yield __await(lazyMixin);
-            if (!mixin.appliesTo)
-                continue;
-            if (!(yield __await(entityClass.is(yield __await(mixin.appliesTo)))))
-                yield yield __await(new exports.Diagnostics.MixinAppliedToClassMustDeriveFromConstraint(entityClass, [mixin.fullName, entityClass.fullName, mixin.appliesTo.fullName]));
-        }
-        return yield __await(void 0);
-    });
+async function* mixinAppliedToClassMustDeriveFromConstraint(entityClass) {
+    for (const lazyMixin of entityClass.mixins) {
+        const mixin = await lazyMixin;
+        if (!mixin.appliesTo)
+            continue;
+        if (!await entityClass.is(await mixin.appliesTo))
+            yield new exports.Diagnostics.MixinAppliedToClassMustDeriveFromConstraint(entityClass, [mixin.fullName, entityClass.fullName, mixin.appliesTo.fullName]);
+    }
+    return;
 }
 exports.mixinAppliedToClassMustDeriveFromConstraint = mixinAppliedToClassMustDeriveFromConstraint;
 /**
  * Validates a custom attribute instance and yields EC-500, EC-501, and EC-502 rule violations.
  */
-function validateCustomAttributeInstance(container, customAttribute) {
-    return __asyncGenerator(this, arguments, function* validateCustomAttributeInstance_1() {
-        yield __await(yield* __asyncDelegator(__asyncValues(customAttributeNotOfConcreteClass(container, customAttribute))));
-        yield __await(yield* __asyncDelegator(__asyncValues(customAttributeSchemaMustBeReferenced(container, customAttribute))));
-        yield __await(yield* __asyncDelegator(__asyncValues(customAttributeClassMustExist(container, customAttribute))));
-    });
+async function* validateCustomAttributeInstance(container, customAttribute) {
+    yield* customAttributeNotOfConcreteClass(container, customAttribute);
+    yield* customAttributeSchemaMustBeReferenced(container, customAttribute);
+    yield* customAttributeClassMustExist(container, customAttribute);
 }
 exports.validateCustomAttributeInstance = validateCustomAttributeInstance;
 /** EC Rule: CustomAttribute instance must be of a concrete CustomAttributeClass. */
-function customAttributeNotOfConcreteClass(container, customAttribute) {
-    return __asyncGenerator(this, arguments, function* customAttributeNotOfConcreteClass_1() {
-        const schema = container.schema;
-        const caClass = yield __await(schema.lookupItem(customAttribute.className));
-        if (!caClass)
-            return yield __await(void 0);
-        if (caClass.modifier !== ecschema_metadata_1.ECClassModifier.Abstract)
-            return yield __await(void 0);
-        yield yield __await(new exports.Diagnostics.CustomAttributeNotOfConcreteClass(container, [container.fullName, caClass.fullName]));
-    });
+async function* customAttributeNotOfConcreteClass(container, customAttribute) {
+    const schema = container.schema;
+    const caClass = await schema.lookupItem(customAttribute.className);
+    if (!caClass)
+        return;
+    if (caClass.modifier !== ecschema_metadata_1.ECClassModifier.Abstract)
+        return;
+    yield new exports.Diagnostics.CustomAttributeNotOfConcreteClass(container, [container.fullName, caClass.fullName]);
 }
 /** EC Rule: CustomAttribute Schema must be referenced by the container's Schema. */
-function customAttributeSchemaMustBeReferenced(container, customAttribute) {
-    return __asyncGenerator(this, arguments, function* customAttributeSchemaMustBeReferenced_1() {
-        const schema = container.schema;
-        const nameParts = customAttribute.className.split(".");
-        if (nameParts.length === 1 || nameParts[0] === schema.name)
-            return yield __await(void 0);
-        if (schema.references.some((s) => s.name === nameParts[0]))
-            return yield __await(void 0);
-        yield yield __await(new exports.Diagnostics.CustomAttributeSchemaMustBeReferenced(container, [container.fullName, customAttribute.className]));
-    });
+async function* customAttributeSchemaMustBeReferenced(container, customAttribute) {
+    const schema = container.schema;
+    const nameParts = customAttribute.className.split(".");
+    if (nameParts.length === 1 || nameParts[0] === schema.name)
+        return;
+    if (schema.references.some((s) => s.name === nameParts[0]))
+        return;
+    yield new exports.Diagnostics.CustomAttributeSchemaMustBeReferenced(container, [container.fullName, customAttribute.className]);
 }
 /** EC Rule: CustomAttribute instance class must exist. */
-function customAttributeClassMustExist(container, customAttribute) {
-    return __asyncGenerator(this, arguments, function* customAttributeClassMustExist_1() {
-        const schema = container.schema;
-        const caClass = yield __await(schema.lookupItem(customAttribute.className));
-        if (!caClass)
-            yield yield __await(new exports.Diagnostics.CustomAttributeClassNotFound(container, [container.fullName, customAttribute.className]));
-    });
+async function* customAttributeClassMustExist(container, customAttribute) {
+    const schema = container.schema;
+    const caClass = await schema.lookupItem(customAttribute.className);
+    if (!caClass)
+        yield new exports.Diagnostics.CustomAttributeClassNotFound(container, [container.fullName, customAttribute.className]);
 }
 async function applyAbstractConstraintMustNarrowBaseConstraints(ecClass, constraint, baseRelationship) {
     const baseConstraint = constraint.isSource ? baseRelationship.source : baseRelationship.target;