@itwin/ecschema-editing 3.0.0-dev.72

package/lib/Validation/SchemaValidationVisitor.js

@@ -0,0 +1,729 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @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); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaValidationVisitor = void 0;
+const Diagnostic_1 = require("./Diagnostic");
+/**
+ * A SchemaWalkerVisitor interface implementation that is used to validate ECObjects schemas using
+ * [[IRuleSet]] objects registered with the instance. Also allows for reporting of [[IDiagnostic]]
+ * objects returned from failing rules using [[IDiagnosticReporter]] implementations registered
+ * with an instance of this class.
+ * @beta
+ */
+class SchemaValidationVisitor {
+    constructor() {
+        this._reporters = [];
+        this._ruleSets = {};
+    }
+    /** Gets the IRule<AnyClass> objects registered with the visitor. */
+    get ruleSets() {
+        return this._ruleSets;
+    }
+    get suppressionSet() {
+        return this._ruleSuppressionSet;
+    }
+    /** Gets the IDiagnosticReporter objects registered with the visitor. */
+    get diagnosticReporters() {
+        return this._reporters;
+    }
+    /**
+     * Registers a [[IDiagnosticReporter]] allowing the reporter to be
+     * notified when a [[IDiagnostic]] is created due to a rule violation.
+     * @param reporter The [[DiagnosticReporter]] to register.
+     */
+    registerReporter(...reporters) {
+        for (const reporter of reporters)
+            this._reporters.push(reporter);
+    }
+    /**
+     * Registers a [[IRuleSet]] that will applied during schema traversal.
+     * @param ruleSet The [[IRuleSet]] to register.
+     */
+    registerRuleSet(ruleSet) {
+        if (undefined !== this.ruleSets[ruleSet.name])
+            throw new Error(`A RuleSet with the name '${ruleSet.name}' has already been registered.`);
+        this.ruleSets[ruleSet.name] = ruleSet;
+    }
+    /**
+     * Registers a [[IRuleSuppressionSet]] that will be applied during schema traversal.
+     * @param ruleSet The [[IRuleSuppressionSet]] to register.
+     * Only supports one Rule Suppression Set, if you call it twice it will overwrite the
+     * previous suppression set
+     */
+    registerRuleSuppressionSet(suppressionSet) {
+        this._ruleSuppressionSet = suppressionSet;
+    }
+    /**
+     * Called before schema traversal.
+     * @param schema a Schema object.
+     */
+    async visitFullSchema(schema) {
+        for (const index of Object.keys(this._ruleSets))
+            await this.applySchemaRules(schema, this._ruleSets[index]);
+    }
+    /**
+     * Called for each [[SchemaItem]] instance found during schema traversal.
+     * @param schemaItem a SchemaItem object.
+     */
+    async visitSchemaItem(schemaItem) {
+        for (const index of Object.keys(this._ruleSets))
+            await this.applySchemaItemRules(schemaItem, this._ruleSets[index]);
+    }
+    /**
+     * Called for each [AnyClass]($ecschema-metadata) instance found during schema traversal.
+     * @param ecClass an ECClass object.
+     */
+    async visitClass(ecClass) {
+        for (const index of Object.keys(this._ruleSets))
+            await this.applyClassRules(ecClass, this._ruleSets[index]);
+    }
+    /**
+     * Called for each [AnyProperty]($ecschema-metadata) instance of an ECClass.
+     * @param property an AnyProperty object.
+     */
+    async visitProperty(property) {
+        for (const index of Object.keys(this._ruleSets))
+            await this.applyPropertyRules(property, this._ruleSets[index]);
+    }
+    /**
+     * Called for each [EntityClass]($ecschema-metadata) instance found during schema traversal.
+     * @param entityClass an EntityClass object.
+     */
+    async visitEntityClass(entity) {
+        for (const index of Object.keys(this._ruleSets))
+            await this.applyEntityRules(entity, this._ruleSets[index]);
+    }
+    /**
+     * Called for each [StructClass]($ecschema-metadata) instance found during schema traversal.
+     * @param structClass a StructClass object.
+     */
+    async visitStructClass(struct) {
+        for (const index of Object.keys(this._ruleSets))
+            await this.applyStructRules(struct, this._ruleSets[index]);
+    }
+    /**
+     * Called for each [Mixin]($ecschema-metadata) instance found during schema traversal.
+     * @param mixin a Mixin object.
+     */
+    async visitMixin(mixin) {
+        for (const index of Object.keys(this._ruleSets))
+            await this.applyMixinRules(mixin, this._ruleSets[index]);
+    }
+    /**
+     * Called for each [RelationshipClass]($ecschema-metadata) instance found during schema traversal.
+     * @param relationshipClass a RelationshipClass object.
+     */
+    async visitRelationshipClass(relationship) {
+        for (const index of Object.keys(this._ruleSets))
+            await this.applyRelationshipRules(relationship, this._ruleSets[index]);
+    }
+    /**
+     * Called for each [RelationshipConstraint]($ecschema-metadata) of each RelationshipClass found during schema traversal.
+     * @param relationshipConstraint a RelationshipConstraint object.
+     */
+    async visitRelationshipConstraint(constraint) {
+        for (const index of Object.keys(this._ruleSets))
+            await this.applyRelationshipConstraintRules(constraint, this._ruleSets[index]);
+    }
+    /**
+     * Called for each [CustomAttributeClass]($ecschema-metadata) instance found during schema traversal.
+     * @param customAttributeClass a CustomAttributeClass object.
+     */
+    async visitCustomAttributeClass(customAttribute) {
+        for (const index of Object.keys(this._ruleSets))
+            await this.applyCustomAttributeRules(customAttribute, this._ruleSets[index]);
+    }
+    /**
+     * Called for each [CustomAttribute]($ecschema-metadata) container in the schema.
+     * @param customAttributeContainer a [[CustomAttributeContainerProps]] object.
+     */
+    async visitCustomAttributeContainer(container) {
+        for (const index of Object.keys(this._ruleSets))
+            await this.applyCustomAttributeContainerRules(container, this._ruleSets[index]);
+        if (undefined === container.customAttributes)
+            return;
+        for (const [, customAttribute] of container.customAttributes) {
+            for (const index of Object.keys(this._ruleSets)) {
+                await this.applyCustomAttributeInstanceRules(container, customAttribute, this._ruleSets[index]);
+            }
+        }
+    }
+    /**
+     * Called for each [Enumeration]($ecschema-metadata) instance found during schema traversal.
+     * @param enumeration an Enumeration object.
+     */
+    async visitEnumeration(enumeration) {
+        for (const index of Object.keys(this._ruleSets))
+            await this.applyEnumerationRules(enumeration, this._ruleSets[index]);
+    }
+    /**
+     * Called for each [KindOfQuantity]($ecschema-metadata) instance found during schema traversal.
+     * @param koq a KindOfQuantity object.
+     */
+    async visitKindOfQuantity(koq) {
+        for (const index of Object.keys(this._ruleSets))
+            await this.applyKindOfQuantityRules(koq, this._ruleSets[index]);
+    }
+    /**
+     * Called for each [PropertyCategory]($ecschema-metadata) instance found during schema traversal.
+     * @param category a PropertyCategory object.
+     */
+    async visitPropertyCategory(category) {
+        for (const index of Object.keys(this._ruleSets))
+            await this.applyPropertyCategoryRules(category, this._ruleSets[index]);
+    }
+    /**
+     * Called for each [Format]($ecschema-metadata) instance found during schema traversal.
+     * @param format a Format object.
+     */
+    async visitFormat(format) {
+        for (const index of Object.keys(this._ruleSets))
+            await this.applyFormatRules(format, this._ruleSets[index]);
+    }
+    /**
+     * Called for each [Unit]($ecschema-metadata) instance found during schema traversal.
+     * @param unit a Unit object.
+     */
+    async visitUnit(unit) {
+        for (const index of Object.keys(this._ruleSets))
+            await this.applyUnitRules(unit, this._ruleSets[index]);
+    }
+    /**
+     * Called for each [InvertedUnit]($ecschema-metadata) instance found during schema traversal.
+     * @param invertedUnit an InvertedUnit object.
+     */
+    async visitInvertedUnit(invertedUnit) {
+        for (const index of Object.keys(this._ruleSets))
+            await this.applyInvertedUnitRules(invertedUnit, this._ruleSets[index]);
+    }
+    /**
+     * Called for each [UnitSystem]($ecschema-metadata) instance found during schema traversal.
+     * @param unitSystem a UnitSystem object.
+     */
+    async visitUnitSystem(unitSystem) {
+        for (const index of Object.keys(this._ruleSets))
+            await this.applyUnitSystemRules(unitSystem, this._ruleSets[index]);
+    }
+    /**
+     * Called for each [Phenomenon]($ecschema-metadata) instance found during schema traversal.
+     * @param phenomena a Phenomenon object.
+     */
+    async visitPhenomenon(phenomenon) {
+        for (const index of Object.keys(this._ruleSets))
+            await this.applyPhenomenonRules(phenomenon, this._ruleSets[index]);
+    }
+    /**
+     * Called for each [Constant]($ecschema-metadata) instance found during schema traversal.
+     * @param constant a Constant object.
+     */
+    async visitConstant(constant) {
+        for (const index of Object.keys(this._ruleSets))
+            await this.applyConstantRules(constant, this._ruleSets[index]);
+    }
+    async applySchemaRules(schema, ruleSet) {
+        var e_1, _a;
+        if (!ruleSet.schemaRules || this.excludeSchemaFromRuleSet(schema, ruleSet))
+            return;
+        for (const rule of ruleSet.schemaRules) {
+            const result = rule(schema);
+            try {
+                for (var result_1 = (e_1 = void 0, __asyncValues(result)), result_1_1; result_1_1 = await result_1.next(), !result_1_1.done;) {
+                    const diagnostic = result_1_1.value;
+                    const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.schemaRuleSuppressions : undefined;
+                    await this.reportDiagnostics(diagnostic, schema, suppressions);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (result_1_1 && !result_1_1.done && (_a = result_1.return)) await _a.call(result_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
+    }
+    async applySchemaItemRules(schemaItem, ruleSet) {
+        var e_2, _a;
+        if (!ruleSet.schemaItemRules || this.excludeSchemaFromRuleSet(schemaItem.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.schemaItemRules) {
+            const result = rule(schemaItem);
+            try {
+                for (var result_2 = (e_2 = void 0, __asyncValues(result)), result_2_1; result_2_1 = await result_2.next(), !result_2_1.done;) {
+                    const diagnostic = result_2_1.value;
+                    const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.schemaItemRuleSuppressions : undefined;
+                    await this.reportDiagnostics(diagnostic, schemaItem, suppressions);
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (result_2_1 && !result_2_1.done && (_a = result_2.return)) await _a.call(result_2);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        }
+    }
+    async applyClassRules(ecClass, ruleSet) {
+        var e_3, _a;
+        if (!ruleSet.classRules || this.excludeSchemaFromRuleSet(ecClass.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.classRules) {
+            const result = rule(ecClass);
+            try {
+                for (var result_3 = (e_3 = void 0, __asyncValues(result)), result_3_1; result_3_1 = await result_3.next(), !result_3_1.done;) {
+                    const diagnostic = result_3_1.value;
+                    const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.classRuleSuppressions : undefined;
+                    await this.reportDiagnostics(diagnostic, ecClass, suppressions);
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (result_3_1 && !result_3_1.done && (_a = result_3.return)) await _a.call(result_3);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+        }
+    }
+    async applyPropertyRules(property, ruleSet) {
+        var e_4, _a;
+        if (!ruleSet.propertyRules || this.excludeSchemaFromRuleSet(property.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.propertyRules) {
+            const result = rule(property);
+            try {
+                for (var result_4 = (e_4 = void 0, __asyncValues(result)), result_4_1; result_4_1 = await result_4.next(), !result_4_1.done;) {
+                    const diagnostic = result_4_1.value;
+                    const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.propertyRuleSuppressions : undefined;
+                    await this.reportDiagnostics(diagnostic, property, suppressions);
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (result_4_1 && !result_4_1.done && (_a = result_4.return)) await _a.call(result_4);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+        }
+    }
+    async applyEntityRules(entityClass, ruleSet) {
+        var e_5, _a;
+        if (!ruleSet.entityClassRules || this.excludeSchemaFromRuleSet(entityClass.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.entityClassRules) {
+            const result = rule(entityClass);
+            try {
+                for (var result_5 = (e_5 = void 0, __asyncValues(result)), result_5_1; result_5_1 = await result_5.next(), !result_5_1.done;) {
+                    const diagnostic = result_5_1.value;
+                    const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.entityRuleSuppressions : undefined;
+                    await this.reportDiagnostics(diagnostic, entityClass, suppressions);
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (result_5_1 && !result_5_1.done && (_a = result_5.return)) await _a.call(result_5);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+        }
+    }
+    async applyStructRules(structClass, ruleSet) {
+        var e_6, _a;
+        if (!ruleSet.structClassRules || this.excludeSchemaFromRuleSet(structClass.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.structClassRules) {
+            const result = rule(structClass);
+            try {
+                for (var result_6 = (e_6 = void 0, __asyncValues(result)), result_6_1; result_6_1 = await result_6.next(), !result_6_1.done;) {
+                    const diagnostic = result_6_1.value;
+                    const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.structRuleSuppressions : undefined;
+                    await this.reportDiagnostics(diagnostic, structClass, suppressions);
+                }
+            }
+            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            finally {
+                try {
+                    if (result_6_1 && !result_6_1.done && (_a = result_6.return)) await _a.call(result_6);
+                }
+                finally { if (e_6) throw e_6.error; }
+            }
+        }
+    }
+    async applyMixinRules(mixin, ruleSet) {
+        var e_7, _a;
+        if (!ruleSet.mixinRules || this.excludeSchemaFromRuleSet(mixin.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.mixinRules) {
+            const result = rule(mixin);
+            try {
+                for (var result_7 = (e_7 = void 0, __asyncValues(result)), result_7_1; result_7_1 = await result_7.next(), !result_7_1.done;) {
+                    const diagnostic = result_7_1.value;
+                    const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.mixinRuleSuppressions : undefined;
+                    await this.reportDiagnostics(diagnostic, mixin, suppressions);
+                }
+            }
+            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+            finally {
+                try {
+                    if (result_7_1 && !result_7_1.done && (_a = result_7.return)) await _a.call(result_7);
+                }
+                finally { if (e_7) throw e_7.error; }
+            }
+        }
+    }
+    async applyRelationshipRules(relationship, ruleSet) {
+        var e_8, _a;
+        if (!ruleSet.relationshipRules || this.excludeSchemaFromRuleSet(relationship.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.relationshipRules) {
+            const result = rule(relationship);
+            try {
+                for (var result_8 = (e_8 = void 0, __asyncValues(result)), result_8_1; result_8_1 = await result_8.next(), !result_8_1.done;) {
+                    const diagnostic = result_8_1.value;
+                    const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.relationshipRuleSuppressions : undefined;
+                    await this.reportDiagnostics(diagnostic, relationship, suppressions);
+                }
+            }
+            catch (e_8_1) { e_8 = { error: e_8_1 }; }
+            finally {
+                try {
+                    if (result_8_1 && !result_8_1.done && (_a = result_8.return)) await _a.call(result_8);
+                }
+                finally { if (e_8) throw e_8.error; }
+            }
+        }
+    }
+    async applyRelationshipConstraintRules(constraint, ruleSet) {
+        var e_9, _a;
+        if (!ruleSet.relationshipConstraintRules || this.excludeSchemaFromRuleSet(constraint.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.relationshipConstraintRules) {
+            const result = rule(constraint);
+            try {
+                for (var result_9 = (e_9 = void 0, __asyncValues(result)), result_9_1; result_9_1 = await result_9.next(), !result_9_1.done;) {
+                    const diagnostic = result_9_1.value;
+                    const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.relationshipConstraintRuleSuppressions : undefined;
+                    await this.reportDiagnostics(diagnostic, constraint, suppressions);
+                }
+            }
+            catch (e_9_1) { e_9 = { error: e_9_1 }; }
+            finally {
+                try {
+                    if (result_9_1 && !result_9_1.done && (_a = result_9.return)) await _a.call(result_9);
+                }
+                finally { if (e_9) throw e_9.error; }
+            }
+        }
+    }
+    async applyCustomAttributeRules(customAttribute, ruleSet) {
+        var e_10, _a;
+        if (!ruleSet.customAttributeClassRules || this.excludeSchemaFromRuleSet(customAttribute.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.customAttributeClassRules) {
+            const result = rule(customAttribute);
+            try {
+                for (var result_10 = (e_10 = void 0, __asyncValues(result)), result_10_1; result_10_1 = await result_10.next(), !result_10_1.done;) {
+                    const diagnostic = result_10_1.value;
+                    const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.customAttributeRuleSuppressions : undefined;
+                    await this.reportDiagnostics(diagnostic, customAttribute, suppressions);
+                }
+            }
+            catch (e_10_1) { e_10 = { error: e_10_1 }; }
+            finally {
+                try {
+                    if (result_10_1 && !result_10_1.done && (_a = result_10.return)) await _a.call(result_10);
+                }
+                finally { if (e_10) throw e_10.error; }
+            }
+        }
+    }
+    async applyCustomAttributeContainerRules(container, ruleSet) {
+        var e_11, _a;
+        if (!ruleSet.customAttributeContainerRules || this.excludeSchemaFromRuleSet(container.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.customAttributeContainerRules) {
+            const result = rule(container);
+            try {
+                for (var result_11 = (e_11 = void 0, __asyncValues(result)), result_11_1; result_11_1 = await result_11.next(), !result_11_1.done;) {
+                    const diagnostic = result_11_1.value;
+                    const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.customAttributeContainerSuppressions : undefined;
+                    await this.reportDiagnostics(diagnostic, container, suppressions);
+                }
+            }
+            catch (e_11_1) { e_11 = { error: e_11_1 }; }
+            finally {
+                try {
+                    if (result_11_1 && !result_11_1.done && (_a = result_11.return)) await _a.call(result_11);
+                }
+                finally { if (e_11) throw e_11.error; }
+            }
+        }
+    }
+    async applyCustomAttributeInstanceRules(container, customAttribute, ruleSet) {
+        var e_12, _a;
+        if (!ruleSet.customAttributeInstanceRules || this.excludeSchemaFromRuleSet(container.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.customAttributeInstanceRules) {
+            const result = rule(container, customAttribute);
+            try {
+                for (var result_12 = (e_12 = void 0, __asyncValues(result)), result_12_1; result_12_1 = await result_12.next(), !result_12_1.done;) {
+                    const diagnostic = result_12_1.value;
+                    const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.customAttributeInstanceSuppressions : undefined;
+                    await this.reportDiagnostics(diagnostic, container, suppressions);
+                }
+            }
+            catch (e_12_1) { e_12 = { error: e_12_1 }; }
+            finally {
+                try {
+                    if (result_12_1 && !result_12_1.done && (_a = result_12.return)) await _a.call(result_12);
+                }
+                finally { if (e_12) throw e_12.error; }
+            }
+        }
+    }
+    async applyEnumerationRules(enumeration, ruleSet) {
+        var e_13, _a;
+        if (!ruleSet.enumerationRules || this.excludeSchemaFromRuleSet(enumeration.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.enumerationRules) {
+            const result = rule(enumeration);
+            try {
+                for (var result_13 = (e_13 = void 0, __asyncValues(result)), result_13_1; result_13_1 = await result_13.next(), !result_13_1.done;) {
+                    const diagnostic = result_13_1.value;
+                    const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.enumerationRuleSuppressions : undefined;
+                    await this.reportDiagnostics(diagnostic, enumeration, suppressions);
+                }
+            }
+            catch (e_13_1) { e_13 = { error: e_13_1 }; }
+            finally {
+                try {
+                    if (result_13_1 && !result_13_1.done && (_a = result_13.return)) await _a.call(result_13);
+                }
+                finally { if (e_13) throw e_13.error; }
+            }
+        }
+    }
+    async applyKindOfQuantityRules(kindOfQuantity, ruleSet) {
+        var e_14, _a;
+        if (!ruleSet.kindOfQuantityRules || this.excludeSchemaFromRuleSet(kindOfQuantity.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.kindOfQuantityRules) {
+            const result = rule(kindOfQuantity);
+            try {
+                for (var result_14 = (e_14 = void 0, __asyncValues(result)), result_14_1; result_14_1 = await result_14.next(), !result_14_1.done;) {
+                    const diagnostic = result_14_1.value;
+                    const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.koqRuleSuppressions : undefined;
+                    await this.reportDiagnostics(diagnostic, kindOfQuantity, suppressions);
+                }
+            }
+            catch (e_14_1) { e_14 = { error: e_14_1 }; }
+            finally {
+                try {
+                    if (result_14_1 && !result_14_1.done && (_a = result_14.return)) await _a.call(result_14);
+                }
+                finally { if (e_14) throw e_14.error; }
+            }
+        }
+    }
+    async applyPropertyCategoryRules(propertyCategory, ruleSet) {
+        var e_15, _a;
+        if (!ruleSet.propertyCategoryRules || this.excludeSchemaFromRuleSet(propertyCategory.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.propertyCategoryRules) {
+            const result = rule(propertyCategory);
+            try {
+                for (var result_15 = (e_15 = void 0, __asyncValues(result)), result_15_1; result_15_1 = await result_15.next(), !result_15_1.done;) {
+                    const diagnostic = result_15_1.value;
+                    const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.propertyCategoryRuleSuppressions : undefined;
+                    await this.reportDiagnostics(diagnostic, propertyCategory, suppressions);
+                }
+            }
+            catch (e_15_1) { e_15 = { error: e_15_1 }; }
+            finally {
+                try {
+                    if (result_15_1 && !result_15_1.done && (_a = result_15.return)) await _a.call(result_15);
+                }
+                finally { if (e_15) throw e_15.error; }
+            }
+        }
+    }
+    async applyFormatRules(format, ruleSet) {
+        var e_16, _a;
+        if (!ruleSet.formatRules || this.excludeSchemaFromRuleSet(format.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.formatRules) {
+            const result = rule(format);
+            try {
+                for (var result_16 = (e_16 = void 0, __asyncValues(result)), result_16_1; result_16_1 = await result_16.next(), !result_16_1.done;) {
+                    const diagnostic = result_16_1.value;
+                    const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.formatRuleSuppressions : undefined;
+                    await this.reportDiagnostics(diagnostic, format, suppressions);
+                }
+            }
+            catch (e_16_1) { e_16 = { error: e_16_1 }; }
+            finally {
+                try {
+                    if (result_16_1 && !result_16_1.done && (_a = result_16.return)) await _a.call(result_16);
+                }
+                finally { if (e_16) throw e_16.error; }
+            }
+        }
+    }
+    async applyUnitRules(unit, ruleSet) {
+        var e_17, _a;
+        if (!ruleSet.unitRules || this.excludeSchemaFromRuleSet(unit.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.unitRules) {
+            const result = rule(unit);
+            try {
+                for (var result_17 = (e_17 = void 0, __asyncValues(result)), result_17_1; result_17_1 = await result_17.next(), !result_17_1.done;) {
+                    const diagnostic = result_17_1.value;
+                    const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.unitRuleSuppressions : undefined;
+                    await this.reportDiagnostics(diagnostic, unit, suppressions);
+                }
+            }
+            catch (e_17_1) { e_17 = { error: e_17_1 }; }
+            finally {
+                try {
+                    if (result_17_1 && !result_17_1.done && (_a = result_17.return)) await _a.call(result_17);
+                }
+                finally { if (e_17) throw e_17.error; }
+            }
+        }
+    }
+    async applyInvertedUnitRules(invertedUnit, ruleSet) {
+        var e_18, _a;
+        if (!ruleSet.invertedUnitRules || this.excludeSchemaFromRuleSet(invertedUnit.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.invertedUnitRules) {
+            const result = rule(invertedUnit);
+            try {
+                for (var result_18 = (e_18 = void 0, __asyncValues(result)), result_18_1; result_18_1 = await result_18.next(), !result_18_1.done;) {
+                    const diagnostic = result_18_1.value;
+                    const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.invertedUnitRuleSuppressions : undefined;
+                    await this.reportDiagnostics(diagnostic, invertedUnit, suppressions);
+                }
+            }
+            catch (e_18_1) { e_18 = { error: e_18_1 }; }
+            finally {
+                try {
+                    if (result_18_1 && !result_18_1.done && (_a = result_18.return)) await _a.call(result_18);
+                }
+                finally { if (e_18) throw e_18.error; }
+            }
+        }
+    }
+    async applyUnitSystemRules(unitSystem, ruleSet) {
+        var e_19, _a;
+        if (!ruleSet.unitSystemRules || this.excludeSchemaFromRuleSet(unitSystem.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.unitSystemRules) {
+            const result = rule(unitSystem);
+            try {
+                for (var result_19 = (e_19 = void 0, __asyncValues(result)), result_19_1; result_19_1 = await result_19.next(), !result_19_1.done;) {
+                    const diagnostic = result_19_1.value;
+                    const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.unitSystemRuleSuppressions : undefined;
+                    await this.reportDiagnostics(diagnostic, unitSystem, suppressions);
+                }
+            }
+            catch (e_19_1) { e_19 = { error: e_19_1 }; }
+            finally {
+                try {
+                    if (result_19_1 && !result_19_1.done && (_a = result_19.return)) await _a.call(result_19);
+                }
+                finally { if (e_19) throw e_19.error; }
+            }
+        }
+    }
+    async applyPhenomenonRules(phenomenon, ruleSet) {
+        var e_20, _a;
+        if (!ruleSet.phenomenonRules || this.excludeSchemaFromRuleSet(phenomenon.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.phenomenonRules) {
+            const result = rule(phenomenon);
+            try {
+                for (var result_20 = (e_20 = void 0, __asyncValues(result)), result_20_1; result_20_1 = await result_20.next(), !result_20_1.done;) {
+                    const diagnostic = result_20_1.value;
+                    const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.phenomenonRuleSuppressions : undefined;
+                    await this.reportDiagnostics(diagnostic, phenomenon, suppressions);
+                }
+            }
+            catch (e_20_1) { e_20 = { error: e_20_1 }; }
+            finally {
+                try {
+                    if (result_20_1 && !result_20_1.done && (_a = result_20.return)) await _a.call(result_20);
+                }
+                finally { if (e_20) throw e_20.error; }
+            }
+        }
+    }
+    async applyConstantRules(constant, ruleSet) {
+        var e_21, _a;
+        if (!ruleSet.constantRules || this.excludeSchemaFromRuleSet(constant.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.constantRules) {
+            const result = rule(constant);
+            try {
+                for (var result_21 = (e_21 = void 0, __asyncValues(result)), result_21_1; result_21_1 = await result_21.next(), !result_21_1.done;) {
+                    const diagnostic = result_21_1.value;
+                    const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.constantRuleSuppressions : undefined;
+                    await this.reportDiagnostics(diagnostic, constant, suppressions);
+                }
+            }
+            catch (e_21_1) { e_21 = { error: e_21_1 }; }
+            finally {
+                try {
+                    if (result_21_1 && !result_21_1.done && (_a = result_21.return)) await _a.call(result_21);
+                }
+                finally { if (e_21) throw e_21.error; }
+            }
+        }
+    }
+    findSuppressionRule(suppressionSet, code) {
+        if (!suppressionSet)
+            return;
+        for (const suppression of suppressionSet) {
+            if (suppression.ruleCode === code) {
+                return suppression.rule;
+            }
+        }
+        return;
+    }
+    excludeSchemaFromRuleSet(schema, ruleSet) {
+        if (!ruleSet.schemaExclusionSet)
+            return false;
+        return ruleSet.schemaExclusionSet.includes(schema.name);
+    }
+    async reportDiagnostics(diagnostic, ecType, suppressionMap) {
+        if (!diagnostic)
+            return;
+        if (suppressionMap) {
+            const suppressRule = this.findSuppressionRule(suppressionMap, diagnostic.code);
+            if (suppressRule) {
+                const ecSuppression = await suppressRule(diagnostic, ecType);
+                if (ecSuppression) {
+                    diagnostic.category = Diagnostic_1.DiagnosticCategory.Warning;
+                }
+            }
+        }
+        this._reporters.forEach((reporter) => { reporter.report(diagnostic); });
+    }
+}
+exports.SchemaValidationVisitor = SchemaValidationVisitor;
+//# sourceMappingURL=SchemaValidationVisitor.js.map