@itwin/ecschema-editing 3.5.0-dev.65 → 3.5.0-dev.66

package/lib/cjs/Validation/SchemaValidationVisitor.js

@@ -1,493 +1,493 @@
-"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
- */
-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) {
-        if (!ruleSet.schemaRules || this.excludeSchemaFromRuleSet(schema, ruleSet))
-            return;
-        for (const rule of ruleSet.schemaRules) {
-            const result = rule(schema);
-            for await (const diagnostic of result) {
-                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.schemaRuleSuppressions : undefined;
-                await this.reportDiagnostics(diagnostic, schema, suppressions);
-            }
-        }
-    }
-    async applySchemaItemRules(schemaItem, ruleSet) {
-        if (!ruleSet.schemaItemRules || this.excludeSchemaFromRuleSet(schemaItem.schema, ruleSet))
-            return;
-        for (const rule of ruleSet.schemaItemRules) {
-            const result = rule(schemaItem);
-            for await (const diagnostic of result) {
-                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.schemaItemRuleSuppressions : undefined;
-                await this.reportDiagnostics(diagnostic, schemaItem, suppressions);
-            }
-        }
-    }
-    async applyClassRules(ecClass, ruleSet) {
-        if (!ruleSet.classRules || this.excludeSchemaFromRuleSet(ecClass.schema, ruleSet))
-            return;
-        for (const rule of ruleSet.classRules) {
-            const result = rule(ecClass);
-            for await (const diagnostic of result) {
-                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.classRuleSuppressions : undefined;
-                await this.reportDiagnostics(diagnostic, ecClass, suppressions);
-            }
-        }
-    }
-    async applyPropertyRules(property, ruleSet) {
-        if (!ruleSet.propertyRules || this.excludeSchemaFromRuleSet(property.schema, ruleSet))
-            return;
-        for (const rule of ruleSet.propertyRules) {
-            const result = rule(property);
-            for await (const diagnostic of result) {
-                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.propertyRuleSuppressions : undefined;
-                await this.reportDiagnostics(diagnostic, property, suppressions);
-            }
-        }
-    }
-    async applyEntityRules(entityClass, ruleSet) {
-        if (!ruleSet.entityClassRules || this.excludeSchemaFromRuleSet(entityClass.schema, ruleSet))
-            return;
-        for (const rule of ruleSet.entityClassRules) {
-            const result = rule(entityClass);
-            for await (const diagnostic of result) {
-                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.entityRuleSuppressions : undefined;
-                await this.reportDiagnostics(diagnostic, entityClass, suppressions);
-            }
-        }
-    }
-    async applyStructRules(structClass, ruleSet) {
-        if (!ruleSet.structClassRules || this.excludeSchemaFromRuleSet(structClass.schema, ruleSet))
-            return;
-        for (const rule of ruleSet.structClassRules) {
-            const result = rule(structClass);
-            for await (const diagnostic of result) {
-                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.structRuleSuppressions : undefined;
-                await this.reportDiagnostics(diagnostic, structClass, suppressions);
-            }
-        }
-    }
-    async applyMixinRules(mixin, ruleSet) {
-        if (!ruleSet.mixinRules || this.excludeSchemaFromRuleSet(mixin.schema, ruleSet))
-            return;
-        for (const rule of ruleSet.mixinRules) {
-            const result = rule(mixin);
-            for await (const diagnostic of result) {
-                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.mixinRuleSuppressions : undefined;
-                await this.reportDiagnostics(diagnostic, mixin, suppressions);
-            }
-        }
-    }
-    async applyRelationshipRules(relationship, ruleSet) {
-        if (!ruleSet.relationshipRules || this.excludeSchemaFromRuleSet(relationship.schema, ruleSet))
-            return;
-        for (const rule of ruleSet.relationshipRules) {
-            const result = rule(relationship);
-            for await (const diagnostic of result) {
-                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.relationshipRuleSuppressions : undefined;
-                await this.reportDiagnostics(diagnostic, relationship, suppressions);
-            }
-        }
-    }
-    async applyRelationshipConstraintRules(constraint, ruleSet) {
-        if (!ruleSet.relationshipConstraintRules || this.excludeSchemaFromRuleSet(constraint.schema, ruleSet))
-            return;
-        for (const rule of ruleSet.relationshipConstraintRules) {
-            const result = rule(constraint);
-            for await (const diagnostic of result) {
-                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.relationshipConstraintRuleSuppressions : undefined;
-                await this.reportDiagnostics(diagnostic, constraint, suppressions);
-            }
-        }
-    }
-    async applyCustomAttributeRules(customAttribute, ruleSet) {
-        if (!ruleSet.customAttributeClassRules || this.excludeSchemaFromRuleSet(customAttribute.schema, ruleSet))
-            return;
-        for (const rule of ruleSet.customAttributeClassRules) {
-            const result = rule(customAttribute);
-            for await (const diagnostic of result) {
-                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.customAttributeRuleSuppressions : undefined;
-                await this.reportDiagnostics(diagnostic, customAttribute, suppressions);
-            }
-        }
-    }
-    async applyCustomAttributeContainerRules(container, ruleSet) {
-        if (!ruleSet.customAttributeContainerRules || this.excludeSchemaFromRuleSet(container.schema, ruleSet))
-            return;
-        for (const rule of ruleSet.customAttributeContainerRules) {
-            const result = rule(container);
-            for await (const diagnostic of result) {
-                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.customAttributeContainerSuppressions : undefined;
-                await this.reportDiagnostics(diagnostic, container, suppressions);
-            }
-        }
-    }
-    async applyCustomAttributeInstanceRules(container, customAttribute, ruleSet) {
-        if (!ruleSet.customAttributeInstanceRules || this.excludeSchemaFromRuleSet(container.schema, ruleSet))
-            return;
-        for (const rule of ruleSet.customAttributeInstanceRules) {
-            const result = rule(container, customAttribute);
-            for await (const diagnostic of result) {
-                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.customAttributeInstanceSuppressions : undefined;
-                await this.reportDiagnostics(diagnostic, container, suppressions);
-            }
-        }
-    }
-    async applyEnumerationRules(enumeration, ruleSet) {
-        if (!ruleSet.enumerationRules || this.excludeSchemaFromRuleSet(enumeration.schema, ruleSet))
-            return;
-        for (const rule of ruleSet.enumerationRules) {
-            const result = rule(enumeration);
-            for await (const diagnostic of result) {
-                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.enumerationRuleSuppressions : undefined;
-                await this.reportDiagnostics(diagnostic, enumeration, suppressions);
-            }
-        }
-    }
-    async applyKindOfQuantityRules(kindOfQuantity, ruleSet) {
-        if (!ruleSet.kindOfQuantityRules || this.excludeSchemaFromRuleSet(kindOfQuantity.schema, ruleSet))
-            return;
-        for (const rule of ruleSet.kindOfQuantityRules) {
-            const result = rule(kindOfQuantity);
-            for await (const diagnostic of result) {
-                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.koqRuleSuppressions : undefined;
-                await this.reportDiagnostics(diagnostic, kindOfQuantity, suppressions);
-            }
-        }
-    }
-    async applyPropertyCategoryRules(propertyCategory, ruleSet) {
-        if (!ruleSet.propertyCategoryRules || this.excludeSchemaFromRuleSet(propertyCategory.schema, ruleSet))
-            return;
-        for (const rule of ruleSet.propertyCategoryRules) {
-            const result = rule(propertyCategory);
-            for await (const diagnostic of result) {
-                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.propertyCategoryRuleSuppressions : undefined;
-                await this.reportDiagnostics(diagnostic, propertyCategory, suppressions);
-            }
-        }
-    }
-    async applyFormatRules(format, ruleSet) {
-        if (!ruleSet.formatRules || this.excludeSchemaFromRuleSet(format.schema, ruleSet))
-            return;
-        for (const rule of ruleSet.formatRules) {
-            const result = rule(format);
-            for await (const diagnostic of result) {
-                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.formatRuleSuppressions : undefined;
-                await this.reportDiagnostics(diagnostic, format, suppressions);
-            }
-        }
-    }
-    async applyUnitRules(unit, ruleSet) {
-        if (!ruleSet.unitRules || this.excludeSchemaFromRuleSet(unit.schema, ruleSet))
-            return;
-        for (const rule of ruleSet.unitRules) {
-            const result = rule(unit);
-            for await (const diagnostic of result) {
-                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.unitRuleSuppressions : undefined;
-                await this.reportDiagnostics(diagnostic, unit, suppressions);
-            }
-        }
-    }
-    async applyInvertedUnitRules(invertedUnit, ruleSet) {
-        if (!ruleSet.invertedUnitRules || this.excludeSchemaFromRuleSet(invertedUnit.schema, ruleSet))
-            return;
-        for (const rule of ruleSet.invertedUnitRules) {
-            const result = rule(invertedUnit);
-            for await (const diagnostic of result) {
-                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.invertedUnitRuleSuppressions : undefined;
-                await this.reportDiagnostics(diagnostic, invertedUnit, suppressions);
-            }
-        }
-    }
-    async applyUnitSystemRules(unitSystem, ruleSet) {
-        if (!ruleSet.unitSystemRules || this.excludeSchemaFromRuleSet(unitSystem.schema, ruleSet))
-            return;
-        for (const rule of ruleSet.unitSystemRules) {
-            const result = rule(unitSystem);
-            for await (const diagnostic of result) {
-                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.unitSystemRuleSuppressions : undefined;
-                await this.reportDiagnostics(diagnostic, unitSystem, suppressions);
-            }
-        }
-    }
-    async applyPhenomenonRules(phenomenon, ruleSet) {
-        if (!ruleSet.phenomenonRules || this.excludeSchemaFromRuleSet(phenomenon.schema, ruleSet))
-            return;
-        for (const rule of ruleSet.phenomenonRules) {
-            const result = rule(phenomenon);
-            for await (const diagnostic of result) {
-                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.phenomenonRuleSuppressions : undefined;
-                await this.reportDiagnostics(diagnostic, phenomenon, suppressions);
-            }
-        }
-    }
-    async applyConstantRules(constant, ruleSet) {
-        if (!ruleSet.constantRules || this.excludeSchemaFromRuleSet(constant.schema, ruleSet))
-            return;
-        for (const rule of ruleSet.constantRules) {
-            const result = rule(constant);
-            for await (const diagnostic of result) {
-                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.constantRuleSuppressions : undefined;
-                await this.reportDiagnostics(diagnostic, constant, suppressions);
-            }
-        }
-    }
-    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;
+"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
+ */
+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) {
+        if (!ruleSet.schemaRules || this.excludeSchemaFromRuleSet(schema, ruleSet))
+            return;
+        for (const rule of ruleSet.schemaRules) {
+            const result = rule(schema);
+            for await (const diagnostic of result) {
+                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.schemaRuleSuppressions : undefined;
+                await this.reportDiagnostics(diagnostic, schema, suppressions);
+            }
+        }
+    }
+    async applySchemaItemRules(schemaItem, ruleSet) {
+        if (!ruleSet.schemaItemRules || this.excludeSchemaFromRuleSet(schemaItem.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.schemaItemRules) {
+            const result = rule(schemaItem);
+            for await (const diagnostic of result) {
+                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.schemaItemRuleSuppressions : undefined;
+                await this.reportDiagnostics(diagnostic, schemaItem, suppressions);
+            }
+        }
+    }
+    async applyClassRules(ecClass, ruleSet) {
+        if (!ruleSet.classRules || this.excludeSchemaFromRuleSet(ecClass.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.classRules) {
+            const result = rule(ecClass);
+            for await (const diagnostic of result) {
+                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.classRuleSuppressions : undefined;
+                await this.reportDiagnostics(diagnostic, ecClass, suppressions);
+            }
+        }
+    }
+    async applyPropertyRules(property, ruleSet) {
+        if (!ruleSet.propertyRules || this.excludeSchemaFromRuleSet(property.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.propertyRules) {
+            const result = rule(property);
+            for await (const diagnostic of result) {
+                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.propertyRuleSuppressions : undefined;
+                await this.reportDiagnostics(diagnostic, property, suppressions);
+            }
+        }
+    }
+    async applyEntityRules(entityClass, ruleSet) {
+        if (!ruleSet.entityClassRules || this.excludeSchemaFromRuleSet(entityClass.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.entityClassRules) {
+            const result = rule(entityClass);
+            for await (const diagnostic of result) {
+                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.entityRuleSuppressions : undefined;
+                await this.reportDiagnostics(diagnostic, entityClass, suppressions);
+            }
+        }
+    }
+    async applyStructRules(structClass, ruleSet) {
+        if (!ruleSet.structClassRules || this.excludeSchemaFromRuleSet(structClass.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.structClassRules) {
+            const result = rule(structClass);
+            for await (const diagnostic of result) {
+                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.structRuleSuppressions : undefined;
+                await this.reportDiagnostics(diagnostic, structClass, suppressions);
+            }
+        }
+    }
+    async applyMixinRules(mixin, ruleSet) {
+        if (!ruleSet.mixinRules || this.excludeSchemaFromRuleSet(mixin.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.mixinRules) {
+            const result = rule(mixin);
+            for await (const diagnostic of result) {
+                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.mixinRuleSuppressions : undefined;
+                await this.reportDiagnostics(diagnostic, mixin, suppressions);
+            }
+        }
+    }
+    async applyRelationshipRules(relationship, ruleSet) {
+        if (!ruleSet.relationshipRules || this.excludeSchemaFromRuleSet(relationship.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.relationshipRules) {
+            const result = rule(relationship);
+            for await (const diagnostic of result) {
+                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.relationshipRuleSuppressions : undefined;
+                await this.reportDiagnostics(diagnostic, relationship, suppressions);
+            }
+        }
+    }
+    async applyRelationshipConstraintRules(constraint, ruleSet) {
+        if (!ruleSet.relationshipConstraintRules || this.excludeSchemaFromRuleSet(constraint.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.relationshipConstraintRules) {
+            const result = rule(constraint);
+            for await (const diagnostic of result) {
+                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.relationshipConstraintRuleSuppressions : undefined;
+                await this.reportDiagnostics(diagnostic, constraint, suppressions);
+            }
+        }
+    }
+    async applyCustomAttributeRules(customAttribute, ruleSet) {
+        if (!ruleSet.customAttributeClassRules || this.excludeSchemaFromRuleSet(customAttribute.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.customAttributeClassRules) {
+            const result = rule(customAttribute);
+            for await (const diagnostic of result) {
+                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.customAttributeRuleSuppressions : undefined;
+                await this.reportDiagnostics(diagnostic, customAttribute, suppressions);
+            }
+        }
+    }
+    async applyCustomAttributeContainerRules(container, ruleSet) {
+        if (!ruleSet.customAttributeContainerRules || this.excludeSchemaFromRuleSet(container.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.customAttributeContainerRules) {
+            const result = rule(container);
+            for await (const diagnostic of result) {
+                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.customAttributeContainerSuppressions : undefined;
+                await this.reportDiagnostics(diagnostic, container, suppressions);
+            }
+        }
+    }
+    async applyCustomAttributeInstanceRules(container, customAttribute, ruleSet) {
+        if (!ruleSet.customAttributeInstanceRules || this.excludeSchemaFromRuleSet(container.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.customAttributeInstanceRules) {
+            const result = rule(container, customAttribute);
+            for await (const diagnostic of result) {
+                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.customAttributeInstanceSuppressions : undefined;
+                await this.reportDiagnostics(diagnostic, container, suppressions);
+            }
+        }
+    }
+    async applyEnumerationRules(enumeration, ruleSet) {
+        if (!ruleSet.enumerationRules || this.excludeSchemaFromRuleSet(enumeration.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.enumerationRules) {
+            const result = rule(enumeration);
+            for await (const diagnostic of result) {
+                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.enumerationRuleSuppressions : undefined;
+                await this.reportDiagnostics(diagnostic, enumeration, suppressions);
+            }
+        }
+    }
+    async applyKindOfQuantityRules(kindOfQuantity, ruleSet) {
+        if (!ruleSet.kindOfQuantityRules || this.excludeSchemaFromRuleSet(kindOfQuantity.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.kindOfQuantityRules) {
+            const result = rule(kindOfQuantity);
+            for await (const diagnostic of result) {
+                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.koqRuleSuppressions : undefined;
+                await this.reportDiagnostics(diagnostic, kindOfQuantity, suppressions);
+            }
+        }
+    }
+    async applyPropertyCategoryRules(propertyCategory, ruleSet) {
+        if (!ruleSet.propertyCategoryRules || this.excludeSchemaFromRuleSet(propertyCategory.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.propertyCategoryRules) {
+            const result = rule(propertyCategory);
+            for await (const diagnostic of result) {
+                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.propertyCategoryRuleSuppressions : undefined;
+                await this.reportDiagnostics(diagnostic, propertyCategory, suppressions);
+            }
+        }
+    }
+    async applyFormatRules(format, ruleSet) {
+        if (!ruleSet.formatRules || this.excludeSchemaFromRuleSet(format.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.formatRules) {
+            const result = rule(format);
+            for await (const diagnostic of result) {
+                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.formatRuleSuppressions : undefined;
+                await this.reportDiagnostics(diagnostic, format, suppressions);
+            }
+        }
+    }
+    async applyUnitRules(unit, ruleSet) {
+        if (!ruleSet.unitRules || this.excludeSchemaFromRuleSet(unit.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.unitRules) {
+            const result = rule(unit);
+            for await (const diagnostic of result) {
+                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.unitRuleSuppressions : undefined;
+                await this.reportDiagnostics(diagnostic, unit, suppressions);
+            }
+        }
+    }
+    async applyInvertedUnitRules(invertedUnit, ruleSet) {
+        if (!ruleSet.invertedUnitRules || this.excludeSchemaFromRuleSet(invertedUnit.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.invertedUnitRules) {
+            const result = rule(invertedUnit);
+            for await (const diagnostic of result) {
+                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.invertedUnitRuleSuppressions : undefined;
+                await this.reportDiagnostics(diagnostic, invertedUnit, suppressions);
+            }
+        }
+    }
+    async applyUnitSystemRules(unitSystem, ruleSet) {
+        if (!ruleSet.unitSystemRules || this.excludeSchemaFromRuleSet(unitSystem.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.unitSystemRules) {
+            const result = rule(unitSystem);
+            for await (const diagnostic of result) {
+                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.unitSystemRuleSuppressions : undefined;
+                await this.reportDiagnostics(diagnostic, unitSystem, suppressions);
+            }
+        }
+    }
+    async applyPhenomenonRules(phenomenon, ruleSet) {
+        if (!ruleSet.phenomenonRules || this.excludeSchemaFromRuleSet(phenomenon.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.phenomenonRules) {
+            const result = rule(phenomenon);
+            for await (const diagnostic of result) {
+                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.phenomenonRuleSuppressions : undefined;
+                await this.reportDiagnostics(diagnostic, phenomenon, suppressions);
+            }
+        }
+    }
+    async applyConstantRules(constant, ruleSet) {
+        if (!ruleSet.constantRules || this.excludeSchemaFromRuleSet(constant.schema, ruleSet))
+            return;
+        for (const rule of ruleSet.constantRules) {
+            const result = rule(constant);
+            for await (const diagnostic of result) {
+                const suppressions = this._ruleSuppressionSet ? this._ruleSuppressionSet.constantRuleSuppressions : undefined;
+                await this.reportDiagnostics(diagnostic, constant, suppressions);
+            }
+        }
+    }
+    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