@itwin/ecschema-metadata 5.0.0-dev.11 → 5.0.0-dev.110

package/lib/esm/Metadata/Schema.js

@@ -9,7 +9,8 @@ import { SchemaReadHelper } from "../Deserialization/Helper";
 import { JsonParser } from "../Deserialization/JsonParser";
 import { XmlParser } from "../Deserialization/XmlParser";
 import { XmlSerializationUtils } from "../Deserialization/XmlSerializationUtils";
-import { ECObjectsError, ECObjectsStatus } from "../Exception";
+import { isSupportedSchemaItemType } from "../ECObjects";
+import { ECSchemaError, ECSchemaStatus } from "../Exception";
 import { ECVersion, SchemaItemKey, SchemaKey } from "../SchemaKey";
 import { ECName } from "../ECName";
 import { ECClass, StructClass } from "./Class";
@@ -28,12 +29,22 @@ import { RelationshipClass } from "./RelationshipClass";
 import { SchemaItem } from "./SchemaItem";
 import { Unit } from "./Unit";
 import { UnitSystem } from "./UnitSystem";
-const SCHEMAURL3_2_JSON = "https://dev.bentley.com/json_schemas/ec/32/ecschema";
-const SCHEMAURL3_2_XML = "http://www.bentley.com/schemas/Bentley.ECXML.3.2";
+import { ECSchemaNamespaceUris } from "../Constants";
 /**
- * @beta
+ * @public @preview
  */
 export class Schema {
+    static _currentECSpecVersion = "3.2";
+    _context;
+    _schemaKey;
+    _alias;
+    _label;
+    _description;
+    references;
+    _items;
+    _customAttributes;
+    _originalECSpecMajorVersion;
+    _originalECSpecMinorVersion;
     /** @internal */
     constructor(context, nameOrKey, alias, readVer, writeVer, minorVer) {
         this._schemaKey = (typeof (nameOrKey) === "string") ? new SchemaKey(nameOrKey, new ECVersion(readVer, writeVer, minorVer)) : nameOrKey;
@@ -44,43 +55,47 @@ export class Schema {
             this._alias = alias;
         }
         else if (nameOrKey !== undefined) {
-            throw new ECObjectsError(ECObjectsStatus.InvalidECJson, `The Schema ${this.name} does not have the required 'alias' attribute.`);
+            throw new ECSchemaError(ECSchemaStatus.InvalidECJson, `The Schema ${this.name} does not have the required 'alias' attribute.`);
         }
         this._originalECSpecMajorVersion = Schema.currentECSpecMajorVersion;
         this._originalECSpecMinorVersion = Schema.currentECSpecMinorVersion;
     }
     get schemaKey() {
         if (undefined === this._schemaKey)
-            throw new ECObjectsError(ECObjectsStatus.InvalidECJson, `The schema has an invalid or missing SchemaKey.`);
+            throw new ECSchemaError(ECSchemaStatus.InvalidECJson, `The schema has an invalid or missing SchemaKey.`);
         return this._schemaKey;
     }
     get name() {
         if (this._schemaKey === undefined)
-            throw new ECObjectsError(ECObjectsStatus.InvalidECJson, `The schema has an invalid or missing SchemaKey.`);
+            throw new ECSchemaError(ECSchemaStatus.InvalidECJson, `The schema has an invalid or missing SchemaKey.`);
         return this.schemaKey.name;
     }
     get readVersion() {
         if (this._schemaKey === undefined)
-            throw new ECObjectsError(ECObjectsStatus.InvalidECJson, `The schema has an invalid or missing SchemaKey.`);
+            throw new ECSchemaError(ECSchemaStatus.InvalidECJson, `The schema has an invalid or missing SchemaKey.`);
         return this.schemaKey.readVersion;
     }
     get writeVersion() {
         if (this._schemaKey === undefined)
-            throw new ECObjectsError(ECObjectsStatus.InvalidECJson, `The schema has an invalid or missing SchemaKey.`);
+            throw new ECSchemaError(ECSchemaStatus.InvalidECJson, `The schema has an invalid or missing SchemaKey.`);
         return this.schemaKey.writeVersion;
     }
     get minorVersion() {
         if (this._schemaKey === undefined)
-            throw new ECObjectsError(ECObjectsStatus.InvalidECJson, `The schema has an invalid or missing SchemaKey.`);
+            throw new ECSchemaError(ECSchemaStatus.InvalidECJson, `The schema has an invalid or missing SchemaKey.`);
         return this.schemaKey.minorVersion;
     }
     get originalECSpecMajorVersion() { return this._originalECSpecMajorVersion; }
     get originalECSpecMinorVersion() { return this._originalECSpecMinorVersion; }
     static get currentECSpecMajorVersion() { return parseInt(Schema._currentECSpecVersion.split(".")[0], 10); }
     static get currentECSpecMinorVersion() { return parseInt(Schema._currentECSpecVersion.split(".")[1], 10); }
+    get _isECSpecVersionUnsupported() {
+        return (this.originalECSpecMajorVersion !== 3 || this.originalECSpecMinorVersion === undefined
+            || (this.originalECSpecMinorVersion < 2 || this.originalECSpecMinorVersion > Schema.currentECSpecMinorVersion));
+    }
     get alias() {
         if (this._alias === undefined || this._alias === null) {
-            throw new ECObjectsError(ECObjectsStatus.InvalidECJson, `The Schema ${this.name} does not have the required 'alias' attribute.`);
+            throw new ECSchemaError(ECSchemaStatus.InvalidECJson, `The Schema ${this.name} does not have the required 'alias' attribute.`);
         }
         else {
             return this._alias;
@@ -105,18 +120,19 @@ export class Schema {
         if (this.name !== schemaName) {
             const newSchemaRef = this.getReferenceSync(schemaName);
             if (undefined === newSchemaRef)
-                throw new ECObjectsError(ECObjectsStatus.InvalidECJson, `Unable to find the referenced SchemaItem ${itemName}.`);
+                throw new ECSchemaError(ECSchemaStatus.InvalidECJson, `Unable to find the referenced SchemaItem ${itemName}.`);
             schemaKey = newSchemaRef.schemaKey;
         }
         return new SchemaItemKey(itemName, schemaKey);
     }
+    /** @internal */
     addItem(item) {
         if (undefined !== this.getItemSync(item.name))
-            throw new ECObjectsError(ECObjectsStatus.DuplicateItem, `The SchemaItem ${item.name} cannot be added to the schema ${this.name} because it already exists`);
+            throw new ECSchemaError(ECSchemaStatus.DuplicateItem, `The SchemaItem ${item.name} cannot be added to the schema ${this.name} because it already exists`);
         this._items.set(item.name.toUpperCase(), item);
     }
     /**
-     * @alpha
+     * @internal
      */
     createClass(type, name, modifier) {
         const item = new type(this, name, modifier);
@@ -126,7 +142,7 @@ export class Schema {
     /**
      * Deletes a class from within this schema.
      * @param name the local (unqualified) class name, lookup is case-insensitive
-     * @alpha
+     * @internal
      */
     async deleteClass(name) {
         const schemaItem = await this.getItem(name);
@@ -137,7 +153,7 @@ export class Schema {
     /**
      * Deletes a class from within this schema.
      * @param name the local (unqualified) class name, lookup is case-insensitive
-     * @alpha
+     * @internal
      */
     deleteClassSync(name) {
         const schemaItem = this.getItemSync(name);
@@ -147,7 +163,7 @@ export class Schema {
     /**
      * Deletes a SchemaItem from within this schema.
      * @param name the local (unqualified) class name, lookup is case-insensitive
-     * @alpha
+     * @internal
      */
     async deleteSchemaItem(name) {
         const schemaItem = await this.getItem(name);
@@ -158,21 +174,20 @@ export class Schema {
     /**
      * Deletes a SchemaItem from within this schema.
      * @param name the local (unqualified) class name, lookup is case-insensitive
-     * @alpha
+     * @internal
      */
     deleteSchemaItemSync(name) {
         const schemaItem = this.getItemSync(name);
         if (SchemaItem.isSchemaItem(schemaItem))
             this._items.delete(name.toUpperCase());
     }
-    /**
-     * @alpha
-     */
+    /** @internal */
     createItem(type, name) {
         const item = new type(this, name);
         this.addItem(item);
         return item;
     }
+    /** @internal */
     addCustomAttribute(customAttribute) {
         if (!this._customAttributes)
             this._customAttributes = new Map();
@@ -182,27 +197,33 @@ export class Schema {
      * Creates a EntityClass with the provided name in this schema.
      * @param name
      * @param modifier
+     * @internal
      */
     async createEntityClass(name, modifier) {
         return this.createClass(EntityClass, name, modifier);
     }
+    /** @internal */
     createEntityClassSync(name, modifier) {
         return this.createClass(EntityClass, name, modifier);
     }
     /**
      * Creates a Mixin with the provided name in this schema.
      * @param name
+     * @internal
      */
     async createMixinClass(name) { return this.createClass(Mixin, name); }
+    /** @internal */
     createMixinClassSync(name) { return this.createClass(Mixin, name); }
     /**
      * Creates a StructClass with the provided name in this schema.
      * @param name
      * @param modifier
+     * @internal
      */
     async createStructClass(name, modifier) {
         return this.createClass(StructClass, name, modifier);
     }
+    /** @internal */
     createStructClassSync(name, modifier) {
         return this.createClass(StructClass, name, modifier);
     }
@@ -210,10 +231,12 @@ export class Schema {
      * Creates a CustomAttributeClass with the provided name in this schema.
      * @param name
      * @param modifier
+     * @internal
      */
     async createCustomAttributeClass(name, modifier) {
         return this.createClass(CustomAttributeClass, name, modifier);
     }
+    /** @internal */
     createCustomAttributeClassSync(name, modifier) {
         return this.createClass(CustomAttributeClass, name, modifier);
     }
@@ -221,20 +244,26 @@ export class Schema {
      * Creates a RelationshipClass with the provided name in this schema.
      * @param name
      * @param modifier
+     * @internal
      */
     async createRelationshipClass(name, modifier) {
         return this.createRelationshipClassSync(name, modifier);
     }
+    /** @internal */
     createRelationshipClassSync(name, modifier) {
         return this.createClass(RelationshipClass, name, modifier);
     }
     /**
      * Creates an Enumeration with the provided name in this schema.
      * @param name
+     * @param primitiveType
+     *
+     * @internal
      */
     async createEnumeration(name, primitiveType) {
         return this.createEnumerationSync(name, primitiveType);
     }
+    /** @internal */
     createEnumerationSync(name, primitiveType) {
         const item = new Enumeration(this, name, primitiveType);
         this.addItem(item);
@@ -243,97 +272,113 @@ export class Schema {
     /**
      * Creates an KindOfQuantity with the provided name in this schema.
      * @param name
+     * @internal
      */
     async createKindOfQuantity(name) {
         return this.createKindOfQuantitySync(name);
     }
+    /** @internal */
     createKindOfQuantitySync(name) {
         return this.createItem(KindOfQuantity, name);
     }
     /**
      * Creates a Constant with the provided name in this schema.
      * @param name
+     * @internal
      */
     async createConstant(name) {
         return this.createItem(Constant, name);
     }
+    /** @internal */
     createConstantSync(name) {
         return this.createItem(Constant, name);
     }
     /**
      * Creates a Inverted Unit with the provided name in this schema.
      * @param name
+     * @internal
      */
     async createInvertedUnit(name) {
         return this.createItem(InvertedUnit, name);
     }
+    /** @internal */
     createInvertedUnitSync(name) {
         return this.createItem(InvertedUnit, name);
     }
     /**
      * Creates an Format with the provided name in this schema.
      * @param name
+     * @internal
      */
     async createFormat(name) {
         return this.createItem(Format, name);
     }
+    /** @internal */
     createFormatSync(name) {
         return this.createItem(Format, name);
     }
     /**
      * Creates a UnitSystem with the provided name in this schema.
      * @param name
+     * @internal
      */
     async createUnitSystem(name) {
         return this.createItem(UnitSystem, name);
     }
+    /** @internal */
     createUnitSystemSync(name) {
         return this.createItem(UnitSystem, name);
     }
     /**
      * Creates a Phenomenon with the provided name in this schema.
      * @param name
+     * @internal
      */
     async createPhenomenon(name) {
         return this.createItem(Phenomenon, name);
     }
+    /** @internal */
     createPhenomenonSync(name) {
         return this.createItem(Phenomenon, name);
     }
     /**
      * Creates a Unit with the provided name in this schema.
      * @param name
+     * @internal
      */
     async createUnit(name) {
         return this.createItem(Unit, name);
     }
+    /** @internal */
     createUnitSync(name) {
         return this.createItem(Unit, name);
     }
     /**
      * Creates an PropertyCategory with the provided name in this schema.
      * @param name
+     * @internal
      */
     async createPropertyCategory(name) {
         return this.createItem(PropertyCategory, name);
     }
+    /** @internal */
     createPropertyCategorySync(name) {
         return this.createItem(PropertyCategory, name);
     }
     /**
      *
      * @param refSchema
+     * @internal
      */
     async addReference(refSchema) {
         // TODO validation of reference schema. For now just adding
         this.addReferenceSync(refSchema);
     }
+    /** @internal */
     addReferenceSync(refSchema) {
         this.references.push(refSchema);
     }
-    /**
-     * @alpha Used for schema editing.
-     */
+    /** @internal */
     setContext(context) {
         this._context = context;
     }
@@ -342,34 +387,113 @@ export class Schema {
      * @param readVersion The read version of the schema. If undefined, the value from the existing SchemaKey will be used.
      * @param writeVersion The write version of the schema. If undefined, the value from the existing SchemaKey will be used.
      * @param minorVersion The minor version of the schema. If undefined, the value from the existing SchemaKey will be used.
+     * @internal
      */
     setVersion(readVersion, writeVersion, minorVersion) {
         if (!this._schemaKey)
-            throw new ECObjectsError(ECObjectsStatus.InvalidSchemaKey, `The schema '${this.name}' has an invalid SchemaKey.`);
+            throw new ECSchemaError(ECSchemaStatus.InvalidSchemaKey, `The schema '${this.name}' has an invalid SchemaKey.`);
         const newVersion = new ECVersion(readVersion ?? this._schemaKey.readVersion, writeVersion ?? this._schemaKey.writeVersion, minorVersion ?? this._schemaKey.minorVersion);
         this._schemaKey = new SchemaKey(this._schemaKey.name, newVersion);
     }
     /**
-     * Gets an item from within this schema. To get by full name use lookupItem instead.
-     * @param key the local (unqualified) name, lookup is case-insensitive
+     * Shortcut for calling getItem with EntityClass.
+     * @param name The local (unqualified) name of the item to return.
+     * @returns The requested EntityClass or undefined if not found.
      */
-    async getItem(name) {
-        // this method exists so we can rewire it later when we load partial schemas, for now it is identical to the sync version
-        return this.getItemSync(name);
-    }
+    async getEntityClass(name) { return this.getItem(name, EntityClass); }
     /**
-     * Gets an item from within this schema. To get by full name use lookupItem instead.
-     * @param key the local (unqualified) name, lookup is case-insensitive
+     * Shortcut for calling getItem with Mixin.
+     * @param name The local (unqualified) name of the item to return.
+     * @returns The requested Mixin or undefined if not found.
      */
-    getItemSync(name) {
-        // Case-insensitive search
-        return this._items.get(name.toUpperCase());
-    }
+    async getMixin(name) { return this.getItem(name, Mixin); }
+    /**
+     * Shortcut for calling getItem with StructClass.
+     * @param name The local (unqualified) name of the item to return.
+     * @returns The requested StructClass or undefined if not found.
+     */
+    async getStructClass(name) { return this.getItem(name, StructClass); }
+    /**
+     * Shortcut for calling getItem with CustomAttributeClass.
+     * @param name The local (unqualified) name of the item to return.
+     * @returns The requested CustomAttributeClass or undefined if not found.
+     */
+    async getCustomAttributeClass(name) { return this.getItem(name, CustomAttributeClass); }
+    /**
+     * Shortcut for calling getItem with RelationshipClass.
+     * @param name The local (unqualified) name of the item to return.
+     * @returns The requested RelationshipClass or undefined if not found.
+     */
+    async getRelationshipClass(name) { return this.getItem(name, RelationshipClass); }
+    /**
+     * Shortcut for calling getItem with Enumeration.
+     * @param name The local (unqualified) name of the item to return.
+     * @returns The requested Enumeration or undefined if not found.
+     */
+    async getEnumeration(name) { return this.getItem(name, Enumeration); }
+    /**
+     * Shortcut for calling getItem with KindOfQuantity.
+     * @param name The local (unqualified) name of the item to return.
+     * @returns The requested KindOfQuantity or undefined if not found.
+     */
+    async getKindOfQuantity(name) { return this.getItem(name, KindOfQuantity); }
+    /**
+     * Shortcut for calling getItem with PropertyCategory.
+     * @param name The local (unqualified) name of the item to return.
+     * @returns The requested PropertyCategory or undefined if not found.
+     */
+    async getPropertyCategory(name) { return this.getItem(name, PropertyCategory); }
+    /**
+     * Shortcut for calling getItem with Unit.
+     * @param name The local (unqualified) name of the item to return.
+     * @returns The requested Unit or undefined if not found.
+     */
+    async getUnit(name) { return this.getItem(name, Unit); }
+    /**
+     * Shortcut for calling getItem with InvertedUnit.
+     * @param name The local (unqualified) name of the item to return.
+     * @returns The requested InvertedUnit or undefined if not found.
+     */
+    async getInvertedUnit(name) { return this.getItem(name, InvertedUnit); }
+    /**
+     * Shortcut for calling getItem with Constant.
+     * @param name The local (unqualified) name of the item to return.
+     * @returns The requested Constant or undefined if not found.
+     */
+    async getConstant(name) { return this.getItem(name, Constant); }
+    /**
+     * Shortcut for calling getItem with Phenomenon.
+     * @param name The local (unqualified) name of the item to return.
+     * @returns The requested Phenomenon or undefined if not found.
+     */
+    async getPhenomenon(name) { return this.getItem(name, Phenomenon); }
     /**
-     * Attempts to find a schema item within this schema or a (directly) referenced schema
-     * @param key The full name or a SchemaItemKey identifying the desired item.
+     * Shortcut for calling getItem with UnitSystem.
+     * @param name The local (unqualified) name of the item to return.
+     * @returns The requested UnitSystem or undefined if not found.
      */
-    async lookupItem(key) {
+    async getUnitSystem(name) { return this.getItem(name, UnitSystem); }
+    /**
+     * Shortcut for calling getItem with Format.
+     * @param name The local (unqualified) name of the item to return.
+     * @returns The requested Format or undefined if not found.
+     */
+    async getFormat(name) { return this.getItem(name, Format); }
+    async getItem(name, itemConstructor) {
+        // this method exists so we can rewire it later when we load partial schemas, for now it is identical to the sync version
+        if (itemConstructor === undefined)
+            return this.getItemSync(name);
+        return this.getItemSync(name, itemConstructor);
+    }
+    getItemSync(name, itemConstructor) {
+        const value = this._items.get(name.toUpperCase());
+        if (value === undefined || itemConstructor === undefined)
+            return value;
+        if (isSupportedSchemaItemType(value.schemaItemType, itemConstructor.schemaItemType))
+            return value;
+        return undefined;
+    }
+    async lookupItem(key, itemConstructor) {
         let schemaName, itemName;
         if (typeof (key) === "string") {
             [schemaName, itemName] = SchemaItem.parseFullName(key);
@@ -379,18 +503,18 @@ export class Schema {
             schemaName = key.schemaName;
         }
         if (!schemaName || schemaName.toUpperCase() === this.name.toUpperCase()) {
-            return this.getItem(itemName);
+            return itemConstructor
+                ? this.getItem(itemName, itemConstructor)
+                : this.getItem(itemName);
         }
         const refSchema = await this.getReference(schemaName);
         if (!refSchema)
             return undefined;
-        return refSchema.getItem(itemName);
+        return itemConstructor
+            ? refSchema.getItem(itemName, itemConstructor)
+            : refSchema.getItem(itemName);
     }
-    /**
-     * Attempts to find a schema item within this schema or a (directly) referenced schema
-     * @param key The full name or a SchemaItemKey identifying the desired item.
-     */
-    lookupItemSync(key) {
+    lookupItemSync(key, itemConstructor) {
         let schemaName, itemName;
         if (typeof (key) === "string") {
             [schemaName, itemName] = SchemaItem.parseFullName(key);
@@ -400,35 +524,48 @@ export class Schema {
             schemaName = key.schemaName;
         }
         if (!schemaName || schemaName.toUpperCase() === this.name.toUpperCase()) {
-            return this.getItemSync(itemName);
+            return itemConstructor
+                ? this.getItemSync(itemName, itemConstructor)
+                : this.getItemSync(itemName);
         }
         const refSchema = this.getReferenceSync(schemaName);
         if (!refSchema)
             return undefined;
-        return refSchema.getItemSync(itemName);
+        return itemConstructor
+            ? refSchema.getItemSync(itemName, itemConstructor)
+            : refSchema.getItemSync(itemName);
     }
-    getItems() {
+    *getItems(itemConstructor) {
         if (!this._items)
-            return new Map().values();
-        return this._items.values();
-    }
-    *getClasses() {
-        for (const [, value] of this._items) {
-            if (ECClass.isECClass(value))
-                yield value;
+            return;
+        for (const item of this._items.values()) {
+            if (itemConstructor === undefined || isSupportedSchemaItemType(item.schemaItemType, itemConstructor.schemaItemType))
+                yield item;
         }
     }
+    /**
+     * Gets a referenced schema by name
+     * @param refSchemaName schema name to find
+     */
     async getReference(refSchemaName) {
         if (this.references.length === 0)
             return undefined;
         return this.references.find((ref) => ref.name.toLowerCase() === refSchemaName.toLowerCase());
     }
+    /**
+     * Gets a referenced schema by alias
+     * @param alias alias to find
+     */
     getReferenceNameByAlias(alias) {
         if (this.references.length === 0)
             return undefined;
         const schema = this.references.find((ref) => ref.alias ? ref.alias.toLowerCase() === alias.toLowerCase() : false);
         return schema ? schema.name : undefined;
     }
+    /**
+     * Gets a referenced schema by name
+     * @param refSchemaName schema name to find
+     */
     getReferenceSync(refSchemaName) {
         if (this.references.length === 0)
             return undefined;
@@ -438,10 +575,10 @@ export class Schema {
      * Save this Schema's properties to an object for serializing to JSON.
      */
     toJSON() {
-        if (!this.isECSpecVersionSupported())
-            throw new ECObjectsError(ECObjectsStatus.NewerECSpecVersion, `The Schema '${this.name}' has an unsupported ECSpecVersion and cannot be serialized.`);
+        if (this._isECSpecVersionUnsupported)
+            throw new ECSchemaError(ECSchemaStatus.NewerECSpecVersion, `The Schema '${this.name}' has an unsupported ECSpecVersion and cannot be serialized.`);
         const schemaJson = {};
-        schemaJson.$schema = SCHEMAURL3_2_JSON; // $schema is required
+        schemaJson.$schema = ECSchemaNamespaceUris.SCHEMAURL3_2_JSON; // $schema is required
         schemaJson.name = this.name; // name is required
         schemaJson.version = this.schemaKey.version.toString(true);
         schemaJson.alias = this.alias; // alias is required
@@ -467,10 +604,10 @@ export class Schema {
      * @param schemaXml An empty DOM document to which the schema will be written
      */
     async toXml(schemaXml) {
-        if (!this.isECSpecVersionSupported())
-            throw new ECObjectsError(ECObjectsStatus.NewerECSpecVersion, `The Schema '${this.name}' has an unsupported ECSpecVersion and cannot be serialized.`);
+        if (this._isECSpecVersionUnsupported)
+            throw new ECSchemaError(ECSchemaStatus.NewerECSpecVersion, `The Schema '${this.name}' has an unsupported ECSpecVersion and cannot be serialized.`);
         const schemaMetadata = schemaXml.createElement("ECSchema");
-        schemaMetadata.setAttribute("xmlns", SCHEMAURL3_2_XML);
+        schemaMetadata.setAttribute("xmlns", ECSchemaNamespaceUris.SCHEMAURL3_2_XML);
         schemaMetadata.setAttribute("version", this.schemaKey.version.toString());
         schemaMetadata.setAttribute("schemaName", this.name);
         schemaMetadata.setAttribute("alias", this.alias ? this.alias : "");
@@ -503,33 +640,6 @@ export class Schema {
         schemaXml.appendChild(schemaMetadata);
         return schemaXml;
     }
-    // Check if the ECSpecVersion read-version is greater than the current ECSpecVersion supported.
-    // If a specific ECSpecVersion is given, check against that version.
-    // If no argument is given, check against the original ECSpecVersion of the schema.
-    isECSpecMajorVersionSupported(ecSpecMajorVersionToCheck) {
-        // If argument is supplied, check the argument against the current ECSpecVersion supported
-        if (ecSpecMajorVersionToCheck !== undefined)
-            return (Schema.currentECSpecMajorVersion >= ecSpecMajorVersionToCheck);
-        // If argument is not supplied, check against the original ECSpecVersion of the schema
-        if (this.originalECSpecMajorVersion === undefined)
-            return false;
-        return (Schema.currentECSpecMajorVersion >= this.originalECSpecMajorVersion);
-    }
-    // Check if the full ECSpecVersion is greater than the current ECSpecVersion supported.
-    // If a specific ECSpecVersion is given, check against that version.
-    // If no argument is given, check against the original ECSpecVersion of the schema.
-    isECSpecVersionSupported(ecSpecMajorVersionToCheck, ecSpecMinorVersionToCheck) {
-        // If arguments are supplied, check the arguments against the current ECSpecVersion supported
-        if (ecSpecMajorVersionToCheck !== undefined && ecSpecMinorVersionToCheck !== undefined) {
-            if (!this.isECSpecMajorVersionSupported(ecSpecMajorVersionToCheck))
-                return false;
-            return (Schema.currentECSpecMinorVersion >= ecSpecMinorVersionToCheck);
-        }
-        // If arguments are not supplied, check against the original ECSpecVersion of the schema
-        if (!this.isECSpecMajorVersionSupported() || this.originalECSpecMinorVersion === undefined)
-            return false;
-        return (Schema.currentECSpecMinorVersion >= this.originalECSpecMinorVersion);
-    }
     /**
      * Loads the schema header (name, version alias, label and description) from the input SchemaProps
      */
@@ -541,12 +651,12 @@ export class Schema {
         }
         else {
             if (schemaProps.name.toLowerCase() !== this.name.toLowerCase())
-                throw new ECObjectsError(ECObjectsStatus.InvalidECJson, `The Schema ${this.name} does not match the provided name, '${schemaProps.name}'.`);
+                throw new ECSchemaError(ECSchemaStatus.InvalidECJson, `The Schema ${this.name} does not match the provided name, '${schemaProps.name}'.`);
             if (this.schemaKey.version.compare(ECVersion.fromString(schemaProps.version)))
-                throw new ECObjectsError(ECObjectsStatus.InvalidECJson, `The Schema ${this.name} has the version '${this.schemaKey.version}' that does not match the provided version '${schemaProps.version}'.`);
+                throw new ECSchemaError(ECSchemaStatus.InvalidECJson, `The Schema ${this.name} has the version '${this.schemaKey.version}' that does not match the provided version '${schemaProps.version}'.`);
         }
         if (schemaProps.$schema.match(`https://dev\\.bentley\\.com/json_schemas/ec/([0-9]+)/ecschema`) == null && schemaProps.$schema.match(`http://www\\.bentley\\.com/schemas/Bentley\\.ECXML\\.([0-9]+)`) == null)
-            throw new ECObjectsError(ECObjectsStatus.MissingSchemaUrl, `The Schema '${this.name}' has an unsupported namespace '${schemaProps.$schema}'.`);
+            throw new ECSchemaError(ECSchemaStatus.MissingSchemaUrl, `The Schema '${this.name}' has an unsupported namespace '${schemaProps.$schema}'.`);
         // The schema props have not been parsed. Parse the ECXml version from the $schema attribute
         let ecVersion;
         if (schemaProps.ecSpecMajorVersion === undefined || schemaProps.ecSpecMinorVersion === undefined) {
@@ -555,15 +665,15 @@ export class Schema {
         else {
             ecVersion = { readVersion: schemaProps.ecSpecMajorVersion, writeVersion: schemaProps.ecSpecMinorVersion };
         }
-        this._originalECSpecMajorVersion = ecVersion?.readVersion;
-        this._originalECSpecMinorVersion = ecVersion?.writeVersion;
-        if (!this.isECSpecMajorVersionSupported(ecVersion?.readVersion))
-            throw new ECObjectsError(ECObjectsStatus.NewerECSpecVersion, `The Schema '${this.name}' has an unsupported ECVersion and cannot be loaded.`);
+        this._originalECSpecMajorVersion = ecVersion.readVersion;
+        this._originalECSpecMinorVersion = ecVersion.writeVersion;
+        if (ecVersion.readVersion !== 3 || (ecVersion.readVersion === 3 && ecVersion.writeVersion < 2))
+            throw new ECSchemaError(ECSchemaStatus.InvalidECVersion, `The Schema '${this.name}' has an unsupported ECVersion ${ecVersion.readVersion}.${ecVersion.writeVersion} and cannot be loaded.`);
         if (ECName.validate(schemaProps.alias)) {
             this._alias = schemaProps.alias;
         }
         else {
-            throw new ECObjectsError(ECObjectsStatus.InvalidECJson, `The Schema ${schemaProps.name} does not have the required 'alias' attribute.`);
+            throw new ECSchemaError(ECSchemaStatus.InvalidECJson, `The Schema ${schemaProps.name} does not have the required 'alias' attribute.`);
         }
         if (undefined !== schemaProps.label)
             this._label = schemaProps.label;
@@ -610,32 +720,22 @@ export class Schema {
         const schema = object;
         return schema !== undefined && schema.schemaKey !== undefined && schema.context !== undefined;
     }
-    /**
-     * @alpha
-     * Used for schema editing.
-     */
+    /** @internal */
     setDisplayLabel(displayLabel) {
         this._label = displayLabel;
     }
-    /**
-     * @alpha
-     * Used for schema editing.
-     */
+    /** @internal */
     setDescription(description) {
         this._description = description;
     }
-    /**
-     * @alpha
-     * Used for schema editing.
-     */
+    /** @internal */
     setAlias(alias) {
         if (!ECName.validate(alias)) {
-            throw new ECObjectsError(ECObjectsStatus.InvalidECName, "The specified schema alias is invalid.");
+            throw new ECSchemaError(ECSchemaStatus.InvalidECName, "The specified schema alias is invalid.");
         }
         this._alias = alias;
     }
 }
-Schema._currentECSpecVersion = "3.2";
 /**
  * Hackish approach that works like a "friend class" so we can access protected members without making them public.
  * We cannot put this into Helper.ts and make it non-export, because we are importing Helper.ts from this file, and the circular import