@itwin/ecschema-editing 3.5.2 → 3.5.4

package/lib/cjs/Validation/SchemaComparer.d.ts

@@ -1,172 +1,172 @@
-/** @packageDocumentation
- * @module Comparison
- */
-import { AnyClass, AnyProperty, Constant, CustomAttributeClass, CustomAttributeContainerProps, EntityClass, Enumeration, Format, InvertedUnit, KindOfQuantity, Mixin, Phenomenon, PropertyCategory, RelationshipClass, RelationshipConstraint, Schema, SchemaItem, Unit } from "@itwin/ecschema-metadata";
-import { ISchemaCompareReporter } from "./SchemaCompareReporter";
-/**
- * Enum that identifies if Schema A is being iterated (Forward) or
- * Schema B is being iterated (Backward);
- * @alpha
- */
-export declare enum SchemaCompareDirection {
-    Forward = 0,
-    Backward = 1
-}
-/**
- * Interface for comparing EC Schemas.
- * @alpha
- */
-export interface ISchemaComparer {
-    compareSchemas(schemaA: Schema, schemaB: Schema): void;
-    compareSchemaProps(schemaA: Schema, schemaB: Schema): void;
-    compareSchemaItems(schemaItemA: SchemaItem, schemaItemB: SchemaItem | undefined): void;
-    compareClasses(classA: AnyClass, classB: AnyClass | undefined): void;
-    compareProperties(propertyA: AnyProperty, propertyB: AnyProperty | undefined): void;
-    compareEntityClasses(entityA: EntityClass, entityB: EntityClass | undefined): void;
-    compareMixins(mixinA: Mixin, mixinB: Mixin | undefined): void;
-    compareRelationshipClasses(relationshipClassA: RelationshipClass, relationshipClassB: RelationshipClass | undefined): void;
-    compareRelationshipConstraints(relationshipConstraintA: RelationshipConstraint, relationshipConstraintB: RelationshipConstraint | undefined): void;
-    compareCustomAttributeClasses(customAttributeClassA: CustomAttributeClass, customAttributeClassB: CustomAttributeClass | undefined): void;
-    compareCustomAttributeContainers(containerA: CustomAttributeContainerProps, containerB: CustomAttributeContainerProps | undefined): void;
-    compareEnumerations(enumA: Enumeration, enumB: Enumeration | undefined): void;
-    compareKindOfQuantities(koqA: KindOfQuantity, koqB: KindOfQuantity | undefined): void;
-    comparePropertyCategories(categoryA: PropertyCategory, categoryB: PropertyCategory | undefined): void;
-    compareFormats(formatA: Format, formatB: Format | undefined): void;
-    compareUnits(unitA: Unit, unitB: Unit | undefined): void;
-    compareInvertedUnits(invertedUnitA: InvertedUnit, invertedUnitB: InvertedUnit | undefined): void;
-    comparePhenomenons(phenomenonA: Phenomenon, phenomenonB: Phenomenon | undefined): void;
-    compareConstants(constantA: Constant, constantB: Constant | undefined): void;
-}
-/**
- * Compares EC Schemas and reports differences using the [[IDiagnosticReporter]] objects
- * specified.
- * @alpha
- */
-export declare class SchemaComparer {
-    private _compareDirection;
-    private _reporter;
-    private _reporters;
-    /**
-     * Initializes a new SchemaComparer instance.
-     * @param reporters The [[IDiagnosticReporter]] object(s) to use to report the results.
-     */
-    constructor(...reporters: ISchemaCompareReporter[]);
-    /**
-     * Compares two schemas to identify differences.
-     * @param schemaA The first Schema.
-     * @param schemaB The second Schema.
-     */
-    compareSchemas(schemaA: Schema, schemaB: Schema): Promise<void>;
-    /**
-     * Compares two schemas to identify differences between property values.
-     * @param schemaA The first Schema.
-     * @param schemaB The second Schema.
-     */
-    compareSchemaProps(schemaA: Schema, schemaB: Schema): Promise<void>;
-    /**
-     * Compares two SchemaItems to identify differences between property values.
-     * @param schemaItemA The first SchemaItem.
-     * @param schemaItemB The second SchemaItem.
-     */
-    compareSchemaItems(schemaItemA: SchemaItem, schemaItemB: SchemaItem | undefined): Promise<void>;
-    /**
-     * Compares two ECClasses to identify differences between property values.
-     * @param classA The first ECClass.
-     * @param classB The second ECClass.
-     */
-    compareClasses(classA: AnyClass, classB: AnyClass | undefined): Promise<void>;
-    /**
-     * Compares two ECProperties to identify differences between property values.
-     * @param propertyA The first ECProperty.
-     * @param propertyB The second ECProperty.
-     */
-    compareProperties(propertyA: AnyProperty, propertyB: AnyProperty | undefined): Promise<void>;
-    /**
-     * Compares two EntityClass objects to identify differences between property values.
-     * @param entityA
-     * @param entityB
-     */
-    compareEntityClasses(entityA: EntityClass, entityB: EntityClass | undefined): Promise<void>;
-    /**
-     * Compares two Mixin objects to identify differences between property values.
-     * @param mixinA
-     * @param mixinB
-     */
-    compareMixins(mixinA: Mixin, mixinB: Mixin | undefined): Promise<void>;
-    /**
-     * Compares two RelationshipClass objects to identify differences between property values.
-     * @param relationshipA
-     * @param relationshipB
-     */
-    compareRelationshipClasses(relationshipA: RelationshipClass, relationshipB: RelationshipClass | undefined): Promise<void>;
-    /**
-     * Compares two RelationshipConstraint objects to identify differences between property values.
-     * @param relationshipConstraintA
-     * @param relationshipConstraintB
-     */
-    compareRelationshipConstraints(constraintA: RelationshipConstraint, constraintB: RelationshipConstraint | undefined): Promise<void>;
-    /**
-     * Compares two CustomAttributeClass objects to identify differences between property values.
-     * @param customAttributeClassA
-     * @param customAttributeClassB
-     */
-    compareCustomAttributeClasses(customAttributeClassA: CustomAttributeClass, customAttributeClassB: CustomAttributeClass | undefined): Promise<void>;
-    /**
-     * Compares two CustomAttributeContainerProps objects to identify differences between property values.
-     * @param containerA
-     * @param containerB
-     */
-    compareCustomAttributeContainers(containerA: CustomAttributeContainerProps, containerB: CustomAttributeContainerProps | undefined): Promise<void>;
-    /**
-     * Compares two Enumeration objects to identify differences between property values.
-     * @param enumA
-     * @param enumB
-     */
-    compareEnumerations(enumA: Enumeration, enumB: Enumeration | undefined): Promise<void>;
-    /**
-     * Compares two KindOfQuantity objects to identify differences between property values.
-     * @param koqA
-     * @param koqB
-     */
-    compareKindOfQuantities(koqA: KindOfQuantity, koqB: KindOfQuantity | undefined): Promise<void>;
-    /**
-     * Compares two PropertyCategory objects to identify differences between property values.
-     * @param categoryA
-     * @param categoryB
-     */
-    comparePropertyCategories(categoryA: PropertyCategory, categoryB: PropertyCategory | undefined): Promise<void>;
-    /**
-     * Compares two Format objects to identify differences between property values.
-     * @param formatA
-     * @param formatB
-     */
-    compareFormats(formatA: Format, formatB: Format | undefined): Promise<void>;
-    /**
-     * Compares two Unit objects to identify differences between property values.
-     * @param unitA
-     * @param unitB
-     */
-    compareUnits(unitA: Unit, unitB: Unit | undefined): Promise<void>;
-    /**
-     * Compares two InvertedUnit objects to identify differences between property values.
-     * @param invertedUnitA
-     * @param invertedUnitB
-     */
-    compareInvertedUnits(invertedUnitA: InvertedUnit, invertedUnitB: InvertedUnit | undefined): Promise<void>;
-    /**
-     * Compares two Phenomenon objects to identify differences between property values.
-     * @param phenomenonA
-     * @param phenomenonB
-     */
-    comparePhenomenons(phenomenonA: Phenomenon, phenomenonB: Phenomenon | undefined): Promise<void>;
-    /**
-     * Compares two Constant objects to identify differences between property values.
-     * @param constantA
-     * @param constantB
-     */
-    compareConstants(constantA: Constant, constantB: Constant | undefined): Promise<void>;
-    private comparePropertyType;
-    private compareEnumerators;
-    private compareFormatUnits;
-}
+/** @packageDocumentation
+ * @module Comparison
+ */
+import { AnyClass, AnyProperty, Constant, CustomAttributeClass, CustomAttributeContainerProps, EntityClass, Enumeration, Format, InvertedUnit, KindOfQuantity, Mixin, Phenomenon, PropertyCategory, RelationshipClass, RelationshipConstraint, Schema, SchemaItem, Unit } from "@itwin/ecschema-metadata";
+import { ISchemaCompareReporter } from "./SchemaCompareReporter";
+/**
+ * Enum that identifies if Schema A is being iterated (Forward) or
+ * Schema B is being iterated (Backward);
+ * @alpha
+ */
+export declare enum SchemaCompareDirection {
+    Forward = 0,
+    Backward = 1
+}
+/**
+ * Interface for comparing EC Schemas.
+ * @alpha
+ */
+export interface ISchemaComparer {
+    compareSchemas(schemaA: Schema, schemaB: Schema): void;
+    compareSchemaProps(schemaA: Schema, schemaB: Schema): void;
+    compareSchemaItems(schemaItemA: SchemaItem, schemaItemB: SchemaItem | undefined): void;
+    compareClasses(classA: AnyClass, classB: AnyClass | undefined): void;
+    compareProperties(propertyA: AnyProperty, propertyB: AnyProperty | undefined): void;
+    compareEntityClasses(entityA: EntityClass, entityB: EntityClass | undefined): void;
+    compareMixins(mixinA: Mixin, mixinB: Mixin | undefined): void;
+    compareRelationshipClasses(relationshipClassA: RelationshipClass, relationshipClassB: RelationshipClass | undefined): void;
+    compareRelationshipConstraints(relationshipConstraintA: RelationshipConstraint, relationshipConstraintB: RelationshipConstraint | undefined): void;
+    compareCustomAttributeClasses(customAttributeClassA: CustomAttributeClass, customAttributeClassB: CustomAttributeClass | undefined): void;
+    compareCustomAttributeContainers(containerA: CustomAttributeContainerProps, containerB: CustomAttributeContainerProps | undefined): void;
+    compareEnumerations(enumA: Enumeration, enumB: Enumeration | undefined): void;
+    compareKindOfQuantities(koqA: KindOfQuantity, koqB: KindOfQuantity | undefined): void;
+    comparePropertyCategories(categoryA: PropertyCategory, categoryB: PropertyCategory | undefined): void;
+    compareFormats(formatA: Format, formatB: Format | undefined): void;
+    compareUnits(unitA: Unit, unitB: Unit | undefined): void;
+    compareInvertedUnits(invertedUnitA: InvertedUnit, invertedUnitB: InvertedUnit | undefined): void;
+    comparePhenomenons(phenomenonA: Phenomenon, phenomenonB: Phenomenon | undefined): void;
+    compareConstants(constantA: Constant, constantB: Constant | undefined): void;
+}
+/**
+ * Compares EC Schemas and reports differences using the [[IDiagnosticReporter]] objects
+ * specified.
+ * @alpha
+ */
+export declare class SchemaComparer {
+    private _compareDirection;
+    private _reporter;
+    private _reporters;
+    /**
+     * Initializes a new SchemaComparer instance.
+     * @param reporters The [[IDiagnosticReporter]] object(s) to use to report the results.
+     */
+    constructor(...reporters: ISchemaCompareReporter[]);
+    /**
+     * Compares two schemas to identify differences.
+     * @param schemaA The first Schema.
+     * @param schemaB The second Schema.
+     */
+    compareSchemas(schemaA: Schema, schemaB: Schema): Promise<void>;
+    /**
+     * Compares two schemas to identify differences between property values.
+     * @param schemaA The first Schema.
+     * @param schemaB The second Schema.
+     */
+    compareSchemaProps(schemaA: Schema, schemaB: Schema): Promise<void>;
+    /**
+     * Compares two SchemaItems to identify differences between property values.
+     * @param schemaItemA The first SchemaItem.
+     * @param schemaItemB The second SchemaItem.
+     */
+    compareSchemaItems(schemaItemA: SchemaItem, schemaItemB: SchemaItem | undefined): Promise<void>;
+    /**
+     * Compares two ECClasses to identify differences between property values.
+     * @param classA The first ECClass.
+     * @param classB The second ECClass.
+     */
+    compareClasses(classA: AnyClass, classB: AnyClass | undefined): Promise<void>;
+    /**
+     * Compares two ECProperties to identify differences between property values.
+     * @param propertyA The first ECProperty.
+     * @param propertyB The second ECProperty.
+     */
+    compareProperties(propertyA: AnyProperty, propertyB: AnyProperty | undefined): Promise<void>;
+    /**
+     * Compares two EntityClass objects to identify differences between property values.
+     * @param entityA
+     * @param entityB
+     */
+    compareEntityClasses(entityA: EntityClass, entityB: EntityClass | undefined): Promise<void>;
+    /**
+     * Compares two Mixin objects to identify differences between property values.
+     * @param mixinA
+     * @param mixinB
+     */
+    compareMixins(mixinA: Mixin, mixinB: Mixin | undefined): Promise<void>;
+    /**
+     * Compares two RelationshipClass objects to identify differences between property values.
+     * @param relationshipA
+     * @param relationshipB
+     */
+    compareRelationshipClasses(relationshipA: RelationshipClass, relationshipB: RelationshipClass | undefined): Promise<void>;
+    /**
+     * Compares two RelationshipConstraint objects to identify differences between property values.
+     * @param relationshipConstraintA
+     * @param relationshipConstraintB
+     */
+    compareRelationshipConstraints(constraintA: RelationshipConstraint, constraintB: RelationshipConstraint | undefined): Promise<void>;
+    /**
+     * Compares two CustomAttributeClass objects to identify differences between property values.
+     * @param customAttributeClassA
+     * @param customAttributeClassB
+     */
+    compareCustomAttributeClasses(customAttributeClassA: CustomAttributeClass, customAttributeClassB: CustomAttributeClass | undefined): Promise<void>;
+    /**
+     * Compares two CustomAttributeContainerProps objects to identify differences between property values.
+     * @param containerA
+     * @param containerB
+     */
+    compareCustomAttributeContainers(containerA: CustomAttributeContainerProps, containerB: CustomAttributeContainerProps | undefined): Promise<void>;
+    /**
+     * Compares two Enumeration objects to identify differences between property values.
+     * @param enumA
+     * @param enumB
+     */
+    compareEnumerations(enumA: Enumeration, enumB: Enumeration | undefined): Promise<void>;
+    /**
+     * Compares two KindOfQuantity objects to identify differences between property values.
+     * @param koqA
+     * @param koqB
+     */
+    compareKindOfQuantities(koqA: KindOfQuantity, koqB: KindOfQuantity | undefined): Promise<void>;
+    /**
+     * Compares two PropertyCategory objects to identify differences between property values.
+     * @param categoryA
+     * @param categoryB
+     */
+    comparePropertyCategories(categoryA: PropertyCategory, categoryB: PropertyCategory | undefined): Promise<void>;
+    /**
+     * Compares two Format objects to identify differences between property values.
+     * @param formatA
+     * @param formatB
+     */
+    compareFormats(formatA: Format, formatB: Format | undefined): Promise<void>;
+    /**
+     * Compares two Unit objects to identify differences between property values.
+     * @param unitA
+     * @param unitB
+     */
+    compareUnits(unitA: Unit, unitB: Unit | undefined): Promise<void>;
+    /**
+     * Compares two InvertedUnit objects to identify differences between property values.
+     * @param invertedUnitA
+     * @param invertedUnitB
+     */
+    compareInvertedUnits(invertedUnitA: InvertedUnit, invertedUnitB: InvertedUnit | undefined): Promise<void>;
+    /**
+     * Compares two Phenomenon objects to identify differences between property values.
+     * @param phenomenonA
+     * @param phenomenonB
+     */
+    comparePhenomenons(phenomenonA: Phenomenon, phenomenonB: Phenomenon | undefined): Promise<void>;
+    /**
+     * Compares two Constant objects to identify differences between property values.
+     * @param constantA
+     * @param constantB
+     */
+    compareConstants(constantA: Constant, constantB: Constant | undefined): Promise<void>;
+    private comparePropertyType;
+    private compareEnumerators;
+    private compareFormatUnits;
+}
 //# sourceMappingURL=SchemaComparer.d.ts.map