@itwin/ecschema-metadata 4.0.0-dev.28 → 4.0.0-dev.32

package/lib/cjs/Metadata/Class.js

@@ -1,559 +1,559 @@
-"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 Metadata
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MutableClass = exports.MutableStructClass = exports.StructClass = exports.ECClass = void 0;
-const core_bentley_1 = require("@itwin/core-bentley");
-const DelayedPromise_1 = require("../DelayedPromise");
-const XmlSerializationUtils_1 = require("../Deserialization/XmlSerializationUtils");
-const ECObjects_1 = require("../ECObjects");
-const Exception_1 = require("../Exception");
-const SchemaKey_1 = require("../SchemaKey");
-const CustomAttribute_1 = require("./CustomAttribute");
-const Property_1 = require("./Property");
-const SchemaItem_1 = require("./SchemaItem");
-/**
- * A common abstract class for all of the ECClass types.
- * @beta
- */
-class ECClass extends SchemaItem_1.SchemaItem {
-    constructor(schema, name, modifier) {
-        super(schema, name);
-        if (modifier)
-            this._modifier = modifier;
-        else
-            this._modifier = ECObjects_1.ECClassModifier.None;
-    }
-    get modifier() { return this._modifier; }
-    get baseClass() { return this._baseClass; }
-    set baseClass(baseClass) { this._baseClass = baseClass; }
-    get properties() { return this._properties?.values(); }
-    get customAttributes() { return this._customAttributes; }
-    /**
-     * Convenience method for adding an already loaded ECProperty used by create*Property methods.
-     * @param prop The property to add.
-     * @return The property that was added.
-     */
-    addProperty(prop) {
-        if (!this._properties)
-            this._properties = new Map();
-        this._properties.set(prop.name.toUpperCase(), prop);
-        return prop;
-    }
-    /**
-     * Deletes a property from within this class.
-     * @param name The property name to delete, lookup is case-insensitive
-     * @alpha
-     */
-    async deleteProperty(name) {
-        if (this._properties) {
-            const property = await this.getProperty(name);
-            if (property)
-                this._properties.delete(name.toUpperCase());
-        }
-    }
-    /**
-     * Deletes a property from within this class.
-     * @param name The property name to delete, lookup is case-insensitive
-     * @alpha
-     */
-    deletePropertySync(name) {
-        if (this._properties) {
-            const property = this.getPropertySync(name);
-            if (property)
-                this._properties.delete(name.toUpperCase());
-        }
-    }
-    getBaseClassSync() {
-        if (!this.baseClass) {
-            return undefined;
-        }
-        return this.schema.lookupItemSync(this.baseClass);
-    }
-    /**
-     * Searches, case-insensitive, for a local ECProperty with the name provided.
-     * @param name
-     */
-    async getProperty(name, includeInherited = false) {
-        if (this._properties) {
-            const upperKey = name.toUpperCase();
-            const property = this._properties.get(upperKey);
-            if (property)
-                return property;
-        }
-        if (!includeInherited) {
-            return undefined;
-        }
-        return this.getInheritedProperty(name);
-    }
-    /**
-     * Searches, case-insensitive, for a local ECProperty with the name provided.
-     * @param name
-     */
-    getPropertySync(name, includeInherited = false) {
-        if (this._properties) {
-            const upperKey = name.toUpperCase();
-            const property = this._properties.get(upperKey);
-            if (property)
-                return property;
-        }
-        if (!includeInherited) {
-            return undefined;
-        }
-        return this.getInheritedPropertySync(name);
-    }
-    /**
-     * Searches the base class, if one exists, for the property with the name provided.
-     * @param name The name of the inherited property to find.
-     */
-    async getInheritedProperty(name) {
-        if (this.baseClass) {
-            const baseClassObj = await this.baseClass;
-            return baseClassObj.getProperty(name, true);
-        }
-        return undefined;
-    }
-    /**
-     * Searches the base class, if one exists, for the property with the name provided.
-     * @param name The name of the inherited property to find.
-     */
-    getInheritedPropertySync(name) {
-        const baseClassObj = this.getBaseClassSync();
-        if (baseClassObj)
-            return baseClassObj.getPropertySync(name, true);
-        return undefined;
-    }
-    async createPrimitiveProperty(name, primitiveType) {
-        if (await this.getProperty(name))
-            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.DuplicateProperty, `An ECProperty with the name ${name} already exists in the class ${this.name}.`);
-        const propType = await this.loadPrimitiveType(primitiveType, this.schema);
-        if (typeof (propType) === "number")
-            return this.addProperty(new Property_1.PrimitiveProperty(this, name, propType));
-        return this.addProperty(new Property_1.EnumerationProperty(this, name, new DelayedPromise_1.DelayedPromiseWithProps(propType.key, async () => propType)));
-    }
-    createPrimitivePropertySync(name, primitiveType) {
-        if (this.getPropertySync(name))
-            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.DuplicateProperty, `An ECProperty with the name ${name} already exists in the class ${this.name}.`);
-        const propType = this.loadPrimitiveTypeSync(primitiveType, this.schema);
-        if (typeof (propType) === "number")
-            return this.addProperty(new Property_1.PrimitiveProperty(this, name, propType));
-        return this.addProperty(new Property_1.EnumerationProperty(this, name, new DelayedPromise_1.DelayedPromiseWithProps(propType.key, async () => propType)));
-    }
-    async createPrimitiveArrayProperty(name, primitiveType) {
-        if (await this.getProperty(name))
-            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.DuplicateProperty, `An ECProperty with the name ${name} already exists in the class ${this.name}.`);
-        const propType = await this.loadPrimitiveType(primitiveType, this.schema);
-        if (typeof (propType) === "number")
-            return this.addProperty(new Property_1.PrimitiveArrayProperty(this, name, propType));
-        return this.addProperty(new Property_1.EnumerationArrayProperty(this, name, new DelayedPromise_1.DelayedPromiseWithProps(propType.key, async () => propType)));
-    }
-    createPrimitiveArrayPropertySync(name, primitiveType) {
-        if (this.getPropertySync(name))
-            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.DuplicateProperty, `An ECProperty with the name ${name} already exists in the class ${this.name}.`);
-        const propType = this.loadPrimitiveTypeSync(primitiveType, this.schema);
-        if (typeof (propType) === "number")
-            return this.addProperty(new Property_1.PrimitiveArrayProperty(this, name, propType));
-        return this.addProperty(new Property_1.EnumerationArrayProperty(this, name, new DelayedPromise_1.DelayedPromiseWithProps(propType.key, async () => propType)));
-    }
-    /**
-     *
-     * @param name The name of property to create.
-     * @param structType The struct type of property to create.
-     */
-    async createStructProperty(name, structType) {
-        if (await this.getProperty(name))
-            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.DuplicateProperty, `An ECProperty with the name ${name} already exists in the class ${this.name}.`);
-        return this.addProperty(new Property_1.StructProperty(this, name, await this.loadStructType(structType, this.schema)));
-    }
-    /**
-     *
-     * @param name The name of property to create.
-     * @param structType The struct type of property to create.
-     */
-    createStructPropertySync(name, structType) {
-        if (this.getPropertySync(name))
-            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.DuplicateProperty, `An ECProperty with the name ${name} already exists in the class ${this.name}.`);
-        return this.addProperty(new Property_1.StructProperty(this, name, this.loadStructTypeSync(structType, this.schema)));
-    }
-    /**
-     *
-     * @param name
-     * @param type
-     */
-    async createStructArrayProperty(name, structType) {
-        if (await this.getProperty(name))
-            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.DuplicateProperty, `An ECProperty with the name ${name} already exists in the class ${this.name}.`);
-        return this.addProperty(new Property_1.StructArrayProperty(this, name, await this.loadStructType(structType, this.schema)));
-    }
-    /**
-     *
-     * @param name
-     * @param type
-     */
-    createStructArrayPropertySync(name, structType) {
-        if (this.getPropertySync(name))
-            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.DuplicateProperty, `An ECProperty with the name ${name} already exists in the class ${this.name}.`);
-        return this.addProperty(new Property_1.StructArrayProperty(this, name, this.loadStructTypeSync(structType, this.schema)));
-    }
-    async loadStructType(structType, schema) {
-        let correctType;
-        if (typeof (structType) === "string") {
-            correctType = await schema.lookupItem(structType);
-        }
-        else
-            correctType = structType;
-        if (!correctType)
-            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.InvalidType, `The provided Struct type, ${structType}, is not a valid StructClass.`);
-        return correctType;
-    }
-    loadStructTypeSync(structType, schema) {
-        let correctType;
-        if (typeof (structType) === "string") {
-            correctType = schema.lookupItemSync(structType);
-        }
-        else
-            correctType = structType;
-        if (!correctType)
-            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.InvalidType, `The provided Struct type, ${structType}, is not a valid StructClass.`);
-        return correctType;
-    }
-    async loadPrimitiveType(primitiveType, schema) {
-        if (primitiveType === undefined)
-            return ECObjects_1.PrimitiveType.Integer;
-        if (typeof (primitiveType) === "string") {
-            let resolvedType = (0, ECObjects_1.parsePrimitiveType)(primitiveType);
-            if (!resolvedType) {
-                resolvedType = await schema.lookupItem(primitiveType);
-            }
-            if (resolvedType === undefined)
-                throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.InvalidType, `The provided primitive type, ${primitiveType}, is not a valid PrimitiveType or Enumeration.`);
-            // If resolvedType is a SchemaItem, make sure it is an Enumeration- if not, throw an error
-            if (typeof (resolvedType) !== "number" && resolvedType.schemaItemType !== ECObjects_1.SchemaItemType.Enumeration)
-                throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.InvalidType, `The provided primitive type, ${primitiveType}, is not a valid PrimitiveType or Enumeration.`);
-            return resolvedType;
-        }
-        return primitiveType;
-    }
-    loadPrimitiveTypeSync(primitiveType, schema) {
-        if (primitiveType === undefined)
-            return ECObjects_1.PrimitiveType.Integer;
-        if (typeof (primitiveType) === "string") {
-            let resolvedType = (0, ECObjects_1.parsePrimitiveType)(primitiveType);
-            if (!resolvedType) {
-                resolvedType = schema.lookupItemSync(primitiveType);
-            }
-            if (resolvedType === undefined)
-                throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.InvalidType, `The provided primitive type, ${primitiveType}, is not a valid PrimitiveType or Enumeration.`);
-            return resolvedType;
-        }
-        return primitiveType;
-    }
-    /**
-     * Save this Classes properties to an object for serializing to JSON.
-     * @param standalone Serialization includes only this object (as opposed to the full schema).
-     * @param includeSchemaVersion Include the Schema's version information in the serialized object.
-     */
-    toJSON(standalone = false, includeSchemaVersion = false) {
-        const schemaJson = super.toJSON(standalone, includeSchemaVersion);
-        const isMixin = ECObjects_1.SchemaItemType.Mixin === this.schemaItemType;
-        const isRelationship = ECObjects_1.SchemaItemType.RelationshipClass === this.schemaItemType;
-        if (!isMixin && (ECObjects_1.ECClassModifier.None !== this.modifier || isRelationship))
-            schemaJson.modifier = (0, ECObjects_1.classModifierToString)(this.modifier);
-        if (this.baseClass !== undefined)
-            schemaJson.baseClass = this.baseClass.fullName;
-        if (this._properties !== undefined && this._properties.size > 0)
-            schemaJson.properties = [...this.properties].map((prop) => prop.toJSON());
-        const customAttributes = (0, CustomAttribute_1.serializeCustomAttributes)(this.customAttributes);
-        if (customAttributes !== undefined)
-            schemaJson.customAttributes = customAttributes;
-        return schemaJson;
-    }
-    /** @internal */
-    async toXml(schemaXml) {
-        const itemElement = await super.toXml(schemaXml);
-        if (undefined !== this.modifier)
-            itemElement.setAttribute("modifier", (0, ECObjects_1.classModifierToString)(this.modifier));
-        if (undefined !== this.baseClass) {
-            const baseClass = await this.baseClass;
-            const baseClassElement = schemaXml.createElement("BaseClass");
-            const baseClassName = XmlSerializationUtils_1.XmlSerializationUtils.createXmlTypedName(this.schema, baseClass.schema, baseClass.name);
-            baseClassElement.textContent = baseClassName;
-            itemElement.appendChild(baseClassElement);
-        }
-        if (undefined !== this.properties) {
-            for (const prop of this.properties) {
-                const propXml = await prop.toXml(schemaXml);
-                itemElement.appendChild(propXml);
-            }
-        }
-        if (this._customAttributes) {
-            const caContainerElement = schemaXml.createElement("ECCustomAttributes");
-            for (const [name, attribute] of this._customAttributes) {
-                const caElement = await XmlSerializationUtils_1.XmlSerializationUtils.writeCustomAttribute(name, attribute, schemaXml, this.schema);
-                caContainerElement.appendChild(caElement);
-            }
-            itemElement.appendChild(caContainerElement);
-        }
-        return itemElement;
-    }
-    fromJSONSync(classProps) {
-        super.fromJSONSync(classProps);
-        if (undefined !== classProps.modifier) {
-            const modifier = (0, ECObjects_1.parseClassModifier)(classProps.modifier);
-            if (undefined === modifier)
-                throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.InvalidModifier, `The string '${classProps.modifier}' is not a valid ECClassModifier.`);
-            this._modifier = modifier;
-        }
-        if (undefined !== classProps.baseClass) {
-            const ecClassSchemaItemKey = this.schema.getSchemaItemKey(classProps.baseClass);
-            if (!ecClassSchemaItemKey)
-                throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.InvalidECJson, `Unable to locate the baseClass ${classProps.baseClass}.`);
-            this._baseClass = new DelayedPromise_1.DelayedPromiseWithProps(ecClassSchemaItemKey, async () => {
-                const baseClass = await this.schema.lookupItem(ecClassSchemaItemKey);
-                if (undefined === baseClass)
-                    throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.InvalidECJson, `Unable to locate the baseClass ${classProps.baseClass}.`);
-                return baseClass;
-            });
-        }
-    }
-    async fromJSON(classProps) {
-        this.fromJSONSync(classProps);
-    }
-    addCustomAttribute(customAttribute) {
-        if (!this._customAttributes)
-            this._customAttributes = new Map();
-        this._customAttributes.set(customAttribute.className, customAttribute);
-    }
-    /**
-     * Iterates (recursively) over all base classes and mixins, in "property override" order.
-     * This is essentially a depth-first traversal through the inheritance tree.
-     */
-    async *getAllBaseClasses() {
-        const baseClasses = [this];
-        const addBaseClasses = async (ecClass) => {
-            if (ECObjects_1.SchemaItemType.EntityClass === ecClass.schemaItemType) {
-                for (let i = (ecClass).mixins.length - 1; i >= 0; i--) {
-                    baseClasses.push(await (ecClass).mixins[i]);
-                }
-            }
-            if (ecClass.baseClass)
-                baseClasses.push(await ecClass.baseClass);
-        };
-        while (baseClasses.length > 0) {
-            const baseClass = baseClasses.pop();
-            await addBaseClasses(baseClass);
-            if (baseClass !== this)
-                yield baseClass;
-        }
-    }
-    *getAllBaseClassesSync() {
-        const baseClasses = [this];
-        const addBaseClasses = (ecClass) => {
-            if (ECObjects_1.SchemaItemType.EntityClass === ecClass.schemaItemType) {
-                for (const m of Array.from(ecClass.getMixinsSync()).reverse()) {
-                    baseClasses.push(m);
-                }
-            }
-            const baseClass = ecClass.getBaseClassSync();
-            if (baseClass)
-                baseClasses.push(baseClass);
-        };
-        while (baseClasses.length > 0) {
-            const baseClass = baseClasses.pop();
-            addBaseClasses(baseClass);
-            if (baseClass !== this)
-                yield baseClass;
-        }
-    }
-    static mergeProperties(target, existingValues, propertiesToMerge, overwriteExisting) {
-        for (const property of propertiesToMerge) {
-            const upperCaseName = property.name.toUpperCase();
-            const existing = existingValues.get(upperCaseName);
-            if (existing !== undefined) {
-                if (overwriteExisting) {
-                    target[existing] = property;
-                }
-            }
-            else {
-                existingValues.set(upperCaseName, target.length);
-                target.push(property);
-            }
-        }
-    }
-    async buildPropertyCache(result, existingValues, resetBaseCaches = false) {
-        if (!existingValues) {
-            existingValues = new Map();
-        }
-        if (this.baseClass) {
-            ECClass.mergeProperties(result, existingValues, await (await this.baseClass).getProperties(resetBaseCaches), false);
-        }
-        if (!this.properties)
-            return;
-        ECClass.mergeProperties(result, existingValues, [...this.properties], true);
-    }
-    buildPropertyCacheSync(result, existingValues, resetBaseCaches = false) {
-        if (!existingValues) {
-            existingValues = new Map();
-        }
-        const baseClass = this.getBaseClassSync();
-        if (baseClass) {
-            ECClass.mergeProperties(result, existingValues, baseClass.getPropertiesSync(resetBaseCaches), false);
-        }
-        if (!this.properties)
-            return;
-        ECClass.mergeProperties(result, existingValues, [...this.properties], true);
-    }
-    /**
-     * Iterates all properties, including the ones merged from base classes and mixins. To obtain only local properties, use the 'properties' field.
-     * Since this is an expensive operation, results will be cached after first call.
-     * @param resetCache if true, any previously cached results will be dropped and cache will be rebuilt
-     */
-    getPropertiesSync(resetCache = false) {
-        if (!this._mergedPropertyCache || resetCache) {
-            this._mergedPropertyCache = [];
-            this.buildPropertyCacheSync(this._mergedPropertyCache, undefined, resetCache);
-        }
-        return this._mergedPropertyCache;
-    }
-    /**
-     * Iterates all properties, including the ones merged from base classes and mixins. To obtain only local properties, use the 'properties' field.
-     * Since this is an expensive operation, results will be cached after first call.
-     * @param resetCache if true, any previously cached results will be dropped and cache will be rebuilt
-     */
-    async getProperties(resetCache = false) {
-        if (!this._mergedPropertyCache || resetCache) {
-            this._mergedPropertyCache = [];
-            await this.buildPropertyCache(this._mergedPropertyCache, undefined, resetCache);
-        }
-        return this._mergedPropertyCache;
-    }
-    /**
-     * Retrieve all custom attributes in the current class and its bases
-     * This is the async version of getCustomAttributesSync()
-     */
-    async getCustomAttributes() {
-        return this.getCustomAttributesSync();
-    }
-    /**
-     * Retrieve all custom attributes in the current class and its bases.
-     */
-    getCustomAttributesSync() {
-        let customAttributes = this._customAttributes;
-        if (undefined === customAttributes) {
-            customAttributes = new Map();
-        }
-        this.traverseBaseClassesSync((ecClass) => {
-            if (undefined === ecClass.customAttributes)
-                return false;
-            for (const [className, customAttribute] of ecClass.customAttributes) {
-                if (customAttributes.has(className))
-                    continue;
-                customAttributes.set(className, customAttribute);
-            }
-            return false;
-        });
-        return customAttributes;
-    }
-    /**
-     * Asynchronously traverses through the inheritance tree, using depth-first traversal, calling the given callback
-     * function for each base class encountered.
-     * @param callback The function to call for each base class in the hierarchy.
-     * @param arg An argument that will be passed as the second parameter to the callback function.
-     */
-    async traverseBaseClasses(callback, arg) {
-        for await (const baseClass of this.getAllBaseClasses()) {
-            if (callback(baseClass, arg))
-                return true;
-        }
-        return false;
-    }
-    /**
-     * Synchronously traverses through the inheritance tree, using depth-first traversal, calling the given callback
-     * function for each base class encountered.
-     * @param callback The function to call for each base class in the hierarchy.
-     * @param arg An argument that will be passed as the second parameter to the callback function.
-     */
-    traverseBaseClassesSync(callback, arg) {
-        const baseClasses = this.getAllBaseClassesSync();
-        if (!baseClasses)
-            return false;
-        for (const baseClass of baseClasses) {
-            if (callback(baseClass, arg))
-                return true;
-        }
-        return false;
-    }
-    async is(targetClass, schemaName) {
-        if (schemaName !== undefined) {
-            (0, core_bentley_1.assert)(typeof (targetClass) === "string", "Expected targetClass of type string because schemaName was specified");
-            const key = new SchemaKey_1.SchemaItemKey(targetClass, new SchemaKey_1.SchemaKey(schemaName));
-            if (SchemaItem_1.SchemaItem.equalByKey(this, key))
-                return true;
-            return this.traverseBaseClasses(SchemaItem_1.SchemaItem.equalByKey, key);
-        }
-        else {
-            (0, core_bentley_1.assert)(ECClass.isECClass(targetClass), "Expected targetClass to be of type ECClass");
-            if (SchemaItem_1.SchemaItem.equalByKey(this, targetClass))
-                return true;
-            return this.traverseBaseClasses(SchemaItem_1.SchemaItem.equalByKey, targetClass);
-        }
-    }
-    /**
-     * A synchronous version of the [[ECClass.is]], indicating if the targetClass is of this type.
-     * @param targetClass The class to check.
-     */
-    isSync(targetClass) {
-        if (SchemaItem_1.SchemaItem.equalByKey(this, targetClass))
-            return true;
-        return this.traverseBaseClassesSync(SchemaItem_1.SchemaItem.equalByKey, targetClass);
-    }
-    /**
-     * @internal
-     */
-    static isECClass(object) {
-        if (!SchemaItem_1.SchemaItem.isSchemaItem(object))
-            return false;
-        return object.schemaItemType === ECObjects_1.SchemaItemType.EntityClass || object.schemaItemType === ECObjects_1.SchemaItemType.Mixin || object.schemaItemType === ECObjects_1.SchemaItemType.RelationshipClass ||
-            object.schemaItemType === ECObjects_1.SchemaItemType.StructClass || object.schemaItemType === ECObjects_1.SchemaItemType.CustomAttributeClass;
-    }
-    /**
-     * @alpha
-     * A setter method used specifically for schema editing.
-     * @param modifier
-     */
-    setModifier(modifier) {
-        this._modifier = modifier;
-    }
-}
-exports.ECClass = ECClass;
-/**
- * A Typescript class representation of an ECStructClass.
- * @beta
- */
-class StructClass extends ECClass {
-    constructor(schema, name, modifier) {
-        super(schema, name, modifier);
-        this.schemaItemType = ECObjects_1.SchemaItemType.StructClass;
-    }
-}
-exports.StructClass = StructClass;
-/**
- * @internal
- * An abstract class used for schema editing.
- */
-class MutableStructClass extends StructClass {
-}
-exports.MutableStructClass = MutableStructClass;
-/**
- * Hackish approach that works like a "friend class" so we can access protected members without making them public.
- * @internal
- */
-class MutableClass extends ECClass {
-}
-exports.MutableClass = MutableClass;
+"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 Metadata
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MutableClass = exports.MutableStructClass = exports.StructClass = exports.ECClass = void 0;
+const core_bentley_1 = require("@itwin/core-bentley");
+const DelayedPromise_1 = require("../DelayedPromise");
+const XmlSerializationUtils_1 = require("../Deserialization/XmlSerializationUtils");
+const ECObjects_1 = require("../ECObjects");
+const Exception_1 = require("../Exception");
+const SchemaKey_1 = require("../SchemaKey");
+const CustomAttribute_1 = require("./CustomAttribute");
+const Property_1 = require("./Property");
+const SchemaItem_1 = require("./SchemaItem");
+/**
+ * A common abstract class for all of the ECClass types.
+ * @beta
+ */
+class ECClass extends SchemaItem_1.SchemaItem {
+    constructor(schema, name, modifier) {
+        super(schema, name);
+        if (modifier)
+            this._modifier = modifier;
+        else
+            this._modifier = ECObjects_1.ECClassModifier.None;
+    }
+    get modifier() { return this._modifier; }
+    get baseClass() { return this._baseClass; }
+    set baseClass(baseClass) { this._baseClass = baseClass; }
+    get properties() { return this._properties?.values(); }
+    get customAttributes() { return this._customAttributes; }
+    /**
+     * Convenience method for adding an already loaded ECProperty used by create*Property methods.
+     * @param prop The property to add.
+     * @return The property that was added.
+     */
+    addProperty(prop) {
+        if (!this._properties)
+            this._properties = new Map();
+        this._properties.set(prop.name.toUpperCase(), prop);
+        return prop;
+    }
+    /**
+     * Deletes a property from within this class.
+     * @param name The property name to delete, lookup is case-insensitive
+     * @alpha
+     */
+    async deleteProperty(name) {
+        if (this._properties) {
+            const property = await this.getProperty(name);
+            if (property)
+                this._properties.delete(name.toUpperCase());
+        }
+    }
+    /**
+     * Deletes a property from within this class.
+     * @param name The property name to delete, lookup is case-insensitive
+     * @alpha
+     */
+    deletePropertySync(name) {
+        if (this._properties) {
+            const property = this.getPropertySync(name);
+            if (property)
+                this._properties.delete(name.toUpperCase());
+        }
+    }
+    getBaseClassSync() {
+        if (!this.baseClass) {
+            return undefined;
+        }
+        return this.schema.lookupItemSync(this.baseClass);
+    }
+    /**
+     * Searches, case-insensitive, for a local ECProperty with the name provided.
+     * @param name
+     */
+    async getProperty(name, includeInherited = false) {
+        if (this._properties) {
+            const upperKey = name.toUpperCase();
+            const property = this._properties.get(upperKey);
+            if (property)
+                return property;
+        }
+        if (!includeInherited) {
+            return undefined;
+        }
+        return this.getInheritedProperty(name);
+    }
+    /**
+     * Searches, case-insensitive, for a local ECProperty with the name provided.
+     * @param name
+     */
+    getPropertySync(name, includeInherited = false) {
+        if (this._properties) {
+            const upperKey = name.toUpperCase();
+            const property = this._properties.get(upperKey);
+            if (property)
+                return property;
+        }
+        if (!includeInherited) {
+            return undefined;
+        }
+        return this.getInheritedPropertySync(name);
+    }
+    /**
+     * Searches the base class, if one exists, for the property with the name provided.
+     * @param name The name of the inherited property to find.
+     */
+    async getInheritedProperty(name) {
+        if (this.baseClass) {
+            const baseClassObj = await this.baseClass;
+            return baseClassObj.getProperty(name, true);
+        }
+        return undefined;
+    }
+    /**
+     * Searches the base class, if one exists, for the property with the name provided.
+     * @param name The name of the inherited property to find.
+     */
+    getInheritedPropertySync(name) {
+        const baseClassObj = this.getBaseClassSync();
+        if (baseClassObj)
+            return baseClassObj.getPropertySync(name, true);
+        return undefined;
+    }
+    async createPrimitiveProperty(name, primitiveType) {
+        if (await this.getProperty(name))
+            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.DuplicateProperty, `An ECProperty with the name ${name} already exists in the class ${this.name}.`);
+        const propType = await this.loadPrimitiveType(primitiveType, this.schema);
+        if (typeof (propType) === "number")
+            return this.addProperty(new Property_1.PrimitiveProperty(this, name, propType));
+        return this.addProperty(new Property_1.EnumerationProperty(this, name, new DelayedPromise_1.DelayedPromiseWithProps(propType.key, async () => propType)));
+    }
+    createPrimitivePropertySync(name, primitiveType) {
+        if (this.getPropertySync(name))
+            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.DuplicateProperty, `An ECProperty with the name ${name} already exists in the class ${this.name}.`);
+        const propType = this.loadPrimitiveTypeSync(primitiveType, this.schema);
+        if (typeof (propType) === "number")
+            return this.addProperty(new Property_1.PrimitiveProperty(this, name, propType));
+        return this.addProperty(new Property_1.EnumerationProperty(this, name, new DelayedPromise_1.DelayedPromiseWithProps(propType.key, async () => propType)));
+    }
+    async createPrimitiveArrayProperty(name, primitiveType) {
+        if (await this.getProperty(name))
+            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.DuplicateProperty, `An ECProperty with the name ${name} already exists in the class ${this.name}.`);
+        const propType = await this.loadPrimitiveType(primitiveType, this.schema);
+        if (typeof (propType) === "number")
+            return this.addProperty(new Property_1.PrimitiveArrayProperty(this, name, propType));
+        return this.addProperty(new Property_1.EnumerationArrayProperty(this, name, new DelayedPromise_1.DelayedPromiseWithProps(propType.key, async () => propType)));
+    }
+    createPrimitiveArrayPropertySync(name, primitiveType) {
+        if (this.getPropertySync(name))
+            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.DuplicateProperty, `An ECProperty with the name ${name} already exists in the class ${this.name}.`);
+        const propType = this.loadPrimitiveTypeSync(primitiveType, this.schema);
+        if (typeof (propType) === "number")
+            return this.addProperty(new Property_1.PrimitiveArrayProperty(this, name, propType));
+        return this.addProperty(new Property_1.EnumerationArrayProperty(this, name, new DelayedPromise_1.DelayedPromiseWithProps(propType.key, async () => propType)));
+    }
+    /**
+     *
+     * @param name The name of property to create.
+     * @param structType The struct type of property to create.
+     */
+    async createStructProperty(name, structType) {
+        if (await this.getProperty(name))
+            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.DuplicateProperty, `An ECProperty with the name ${name} already exists in the class ${this.name}.`);
+        return this.addProperty(new Property_1.StructProperty(this, name, await this.loadStructType(structType, this.schema)));
+    }
+    /**
+     *
+     * @param name The name of property to create.
+     * @param structType The struct type of property to create.
+     */
+    createStructPropertySync(name, structType) {
+        if (this.getPropertySync(name))
+            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.DuplicateProperty, `An ECProperty with the name ${name} already exists in the class ${this.name}.`);
+        return this.addProperty(new Property_1.StructProperty(this, name, this.loadStructTypeSync(structType, this.schema)));
+    }
+    /**
+     *
+     * @param name
+     * @param type
+     */
+    async createStructArrayProperty(name, structType) {
+        if (await this.getProperty(name))
+            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.DuplicateProperty, `An ECProperty with the name ${name} already exists in the class ${this.name}.`);
+        return this.addProperty(new Property_1.StructArrayProperty(this, name, await this.loadStructType(structType, this.schema)));
+    }
+    /**
+     *
+     * @param name
+     * @param type
+     */
+    createStructArrayPropertySync(name, structType) {
+        if (this.getPropertySync(name))
+            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.DuplicateProperty, `An ECProperty with the name ${name} already exists in the class ${this.name}.`);
+        return this.addProperty(new Property_1.StructArrayProperty(this, name, this.loadStructTypeSync(structType, this.schema)));
+    }
+    async loadStructType(structType, schema) {
+        let correctType;
+        if (typeof (structType) === "string") {
+            correctType = await schema.lookupItem(structType);
+        }
+        else
+            correctType = structType;
+        if (!correctType)
+            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.InvalidType, `The provided Struct type, ${structType}, is not a valid StructClass.`);
+        return correctType;
+    }
+    loadStructTypeSync(structType, schema) {
+        let correctType;
+        if (typeof (structType) === "string") {
+            correctType = schema.lookupItemSync(structType);
+        }
+        else
+            correctType = structType;
+        if (!correctType)
+            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.InvalidType, `The provided Struct type, ${structType}, is not a valid StructClass.`);
+        return correctType;
+    }
+    async loadPrimitiveType(primitiveType, schema) {
+        if (primitiveType === undefined)
+            return ECObjects_1.PrimitiveType.Integer;
+        if (typeof (primitiveType) === "string") {
+            let resolvedType = (0, ECObjects_1.parsePrimitiveType)(primitiveType);
+            if (!resolvedType) {
+                resolvedType = await schema.lookupItem(primitiveType);
+            }
+            if (resolvedType === undefined)
+                throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.InvalidType, `The provided primitive type, ${primitiveType}, is not a valid PrimitiveType or Enumeration.`);
+            // If resolvedType is a SchemaItem, make sure it is an Enumeration- if not, throw an error
+            if (typeof (resolvedType) !== "number" && resolvedType.schemaItemType !== ECObjects_1.SchemaItemType.Enumeration)
+                throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.InvalidType, `The provided primitive type, ${primitiveType}, is not a valid PrimitiveType or Enumeration.`);
+            return resolvedType;
+        }
+        return primitiveType;
+    }
+    loadPrimitiveTypeSync(primitiveType, schema) {
+        if (primitiveType === undefined)
+            return ECObjects_1.PrimitiveType.Integer;
+        if (typeof (primitiveType) === "string") {
+            let resolvedType = (0, ECObjects_1.parsePrimitiveType)(primitiveType);
+            if (!resolvedType) {
+                resolvedType = schema.lookupItemSync(primitiveType);
+            }
+            if (resolvedType === undefined)
+                throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.InvalidType, `The provided primitive type, ${primitiveType}, is not a valid PrimitiveType or Enumeration.`);
+            return resolvedType;
+        }
+        return primitiveType;
+    }
+    /**
+     * Save this Classes properties to an object for serializing to JSON.
+     * @param standalone Serialization includes only this object (as opposed to the full schema).
+     * @param includeSchemaVersion Include the Schema's version information in the serialized object.
+     */
+    toJSON(standalone = false, includeSchemaVersion = false) {
+        const schemaJson = super.toJSON(standalone, includeSchemaVersion);
+        const isMixin = ECObjects_1.SchemaItemType.Mixin === this.schemaItemType;
+        const isRelationship = ECObjects_1.SchemaItemType.RelationshipClass === this.schemaItemType;
+        if (!isMixin && (ECObjects_1.ECClassModifier.None !== this.modifier || isRelationship))
+            schemaJson.modifier = (0, ECObjects_1.classModifierToString)(this.modifier);
+        if (this.baseClass !== undefined)
+            schemaJson.baseClass = this.baseClass.fullName;
+        if (this._properties !== undefined && this._properties.size > 0)
+            schemaJson.properties = [...this.properties].map((prop) => prop.toJSON());
+        const customAttributes = (0, CustomAttribute_1.serializeCustomAttributes)(this.customAttributes);
+        if (customAttributes !== undefined)
+            schemaJson.customAttributes = customAttributes;
+        return schemaJson;
+    }
+    /** @internal */
+    async toXml(schemaXml) {
+        const itemElement = await super.toXml(schemaXml);
+        if (undefined !== this.modifier)
+            itemElement.setAttribute("modifier", (0, ECObjects_1.classModifierToString)(this.modifier));
+        if (undefined !== this.baseClass) {
+            const baseClass = await this.baseClass;
+            const baseClassElement = schemaXml.createElement("BaseClass");
+            const baseClassName = XmlSerializationUtils_1.XmlSerializationUtils.createXmlTypedName(this.schema, baseClass.schema, baseClass.name);
+            baseClassElement.textContent = baseClassName;
+            itemElement.appendChild(baseClassElement);
+        }
+        if (undefined !== this.properties) {
+            for (const prop of this.properties) {
+                const propXml = await prop.toXml(schemaXml);
+                itemElement.appendChild(propXml);
+            }
+        }
+        if (this._customAttributes) {
+            const caContainerElement = schemaXml.createElement("ECCustomAttributes");
+            for (const [name, attribute] of this._customAttributes) {
+                const caElement = await XmlSerializationUtils_1.XmlSerializationUtils.writeCustomAttribute(name, attribute, schemaXml, this.schema);
+                caContainerElement.appendChild(caElement);
+            }
+            itemElement.appendChild(caContainerElement);
+        }
+        return itemElement;
+    }
+    fromJSONSync(classProps) {
+        super.fromJSONSync(classProps);
+        if (undefined !== classProps.modifier) {
+            const modifier = (0, ECObjects_1.parseClassModifier)(classProps.modifier);
+            if (undefined === modifier)
+                throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.InvalidModifier, `The string '${classProps.modifier}' is not a valid ECClassModifier.`);
+            this._modifier = modifier;
+        }
+        if (undefined !== classProps.baseClass) {
+            const ecClassSchemaItemKey = this.schema.getSchemaItemKey(classProps.baseClass);
+            if (!ecClassSchemaItemKey)
+                throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.InvalidECJson, `Unable to locate the baseClass ${classProps.baseClass}.`);
+            this._baseClass = new DelayedPromise_1.DelayedPromiseWithProps(ecClassSchemaItemKey, async () => {
+                const baseClass = await this.schema.lookupItem(ecClassSchemaItemKey);
+                if (undefined === baseClass)
+                    throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.InvalidECJson, `Unable to locate the baseClass ${classProps.baseClass}.`);
+                return baseClass;
+            });
+        }
+    }
+    async fromJSON(classProps) {
+        this.fromJSONSync(classProps);
+    }
+    addCustomAttribute(customAttribute) {
+        if (!this._customAttributes)
+            this._customAttributes = new Map();
+        this._customAttributes.set(customAttribute.className, customAttribute);
+    }
+    /**
+     * Iterates (recursively) over all base classes and mixins, in "property override" order.
+     * This is essentially a depth-first traversal through the inheritance tree.
+     */
+    async *getAllBaseClasses() {
+        const baseClasses = [this];
+        const addBaseClasses = async (ecClass) => {
+            if (ECObjects_1.SchemaItemType.EntityClass === ecClass.schemaItemType) {
+                for (let i = (ecClass).mixins.length - 1; i >= 0; i--) {
+                    baseClasses.push(await (ecClass).mixins[i]);
+                }
+            }
+            if (ecClass.baseClass)
+                baseClasses.push(await ecClass.baseClass);
+        };
+        while (baseClasses.length > 0) {
+            const baseClass = baseClasses.pop();
+            await addBaseClasses(baseClass);
+            if (baseClass !== this)
+                yield baseClass;
+        }
+    }
+    *getAllBaseClassesSync() {
+        const baseClasses = [this];
+        const addBaseClasses = (ecClass) => {
+            if (ECObjects_1.SchemaItemType.EntityClass === ecClass.schemaItemType) {
+                for (const m of Array.from(ecClass.getMixinsSync()).reverse()) {
+                    baseClasses.push(m);
+                }
+            }
+            const baseClass = ecClass.getBaseClassSync();
+            if (baseClass)
+                baseClasses.push(baseClass);
+        };
+        while (baseClasses.length > 0) {
+            const baseClass = baseClasses.pop();
+            addBaseClasses(baseClass);
+            if (baseClass !== this)
+                yield baseClass;
+        }
+    }
+    static mergeProperties(target, existingValues, propertiesToMerge, overwriteExisting) {
+        for (const property of propertiesToMerge) {
+            const upperCaseName = property.name.toUpperCase();
+            const existing = existingValues.get(upperCaseName);
+            if (existing !== undefined) {
+                if (overwriteExisting) {
+                    target[existing] = property;
+                }
+            }
+            else {
+                existingValues.set(upperCaseName, target.length);
+                target.push(property);
+            }
+        }
+    }
+    async buildPropertyCache(result, existingValues, resetBaseCaches = false) {
+        if (!existingValues) {
+            existingValues = new Map();
+        }
+        if (this.baseClass) {
+            ECClass.mergeProperties(result, existingValues, await (await this.baseClass).getProperties(resetBaseCaches), false);
+        }
+        if (!this.properties)
+            return;
+        ECClass.mergeProperties(result, existingValues, [...this.properties], true);
+    }
+    buildPropertyCacheSync(result, existingValues, resetBaseCaches = false) {
+        if (!existingValues) {
+            existingValues = new Map();
+        }
+        const baseClass = this.getBaseClassSync();
+        if (baseClass) {
+            ECClass.mergeProperties(result, existingValues, baseClass.getPropertiesSync(resetBaseCaches), false);
+        }
+        if (!this.properties)
+            return;
+        ECClass.mergeProperties(result, existingValues, [...this.properties], true);
+    }
+    /**
+     * Iterates all properties, including the ones merged from base classes and mixins. To obtain only local properties, use the 'properties' field.
+     * Since this is an expensive operation, results will be cached after first call.
+     * @param resetCache if true, any previously cached results will be dropped and cache will be rebuilt
+     */
+    getPropertiesSync(resetCache = false) {
+        if (!this._mergedPropertyCache || resetCache) {
+            this._mergedPropertyCache = [];
+            this.buildPropertyCacheSync(this._mergedPropertyCache, undefined, resetCache);
+        }
+        return this._mergedPropertyCache;
+    }
+    /**
+     * Iterates all properties, including the ones merged from base classes and mixins. To obtain only local properties, use the 'properties' field.
+     * Since this is an expensive operation, results will be cached after first call.
+     * @param resetCache if true, any previously cached results will be dropped and cache will be rebuilt
+     */
+    async getProperties(resetCache = false) {
+        if (!this._mergedPropertyCache || resetCache) {
+            this._mergedPropertyCache = [];
+            await this.buildPropertyCache(this._mergedPropertyCache, undefined, resetCache);
+        }
+        return this._mergedPropertyCache;
+    }
+    /**
+     * Retrieve all custom attributes in the current class and its bases
+     * This is the async version of getCustomAttributesSync()
+     */
+    async getCustomAttributes() {
+        return this.getCustomAttributesSync();
+    }
+    /**
+     * Retrieve all custom attributes in the current class and its bases.
+     */
+    getCustomAttributesSync() {
+        let customAttributes = this._customAttributes;
+        if (undefined === customAttributes) {
+            customAttributes = new Map();
+        }
+        this.traverseBaseClassesSync((ecClass) => {
+            if (undefined === ecClass.customAttributes)
+                return false;
+            for (const [className, customAttribute] of ecClass.customAttributes) {
+                if (customAttributes.has(className))
+                    continue;
+                customAttributes.set(className, customAttribute);
+            }
+            return false;
+        });
+        return customAttributes;
+    }
+    /**
+     * Asynchronously traverses through the inheritance tree, using depth-first traversal, calling the given callback
+     * function for each base class encountered.
+     * @param callback The function to call for each base class in the hierarchy.
+     * @param arg An argument that will be passed as the second parameter to the callback function.
+     */
+    async traverseBaseClasses(callback, arg) {
+        for await (const baseClass of this.getAllBaseClasses()) {
+            if (callback(baseClass, arg))
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Synchronously traverses through the inheritance tree, using depth-first traversal, calling the given callback
+     * function for each base class encountered.
+     * @param callback The function to call for each base class in the hierarchy.
+     * @param arg An argument that will be passed as the second parameter to the callback function.
+     */
+    traverseBaseClassesSync(callback, arg) {
+        const baseClasses = this.getAllBaseClassesSync();
+        if (!baseClasses)
+            return false;
+        for (const baseClass of baseClasses) {
+            if (callback(baseClass, arg))
+                return true;
+        }
+        return false;
+    }
+    async is(targetClass, schemaName) {
+        if (schemaName !== undefined) {
+            (0, core_bentley_1.assert)(typeof (targetClass) === "string", "Expected targetClass of type string because schemaName was specified");
+            const key = new SchemaKey_1.SchemaItemKey(targetClass, new SchemaKey_1.SchemaKey(schemaName));
+            if (SchemaItem_1.SchemaItem.equalByKey(this, key))
+                return true;
+            return this.traverseBaseClasses(SchemaItem_1.SchemaItem.equalByKey, key);
+        }
+        else {
+            (0, core_bentley_1.assert)(ECClass.isECClass(targetClass), "Expected targetClass to be of type ECClass");
+            if (SchemaItem_1.SchemaItem.equalByKey(this, targetClass))
+                return true;
+            return this.traverseBaseClasses(SchemaItem_1.SchemaItem.equalByKey, targetClass);
+        }
+    }
+    /**
+     * A synchronous version of the [[ECClass.is]], indicating if the targetClass is of this type.
+     * @param targetClass The class to check.
+     */
+    isSync(targetClass) {
+        if (SchemaItem_1.SchemaItem.equalByKey(this, targetClass))
+            return true;
+        return this.traverseBaseClassesSync(SchemaItem_1.SchemaItem.equalByKey, targetClass);
+    }
+    /**
+     * @internal
+     */
+    static isECClass(object) {
+        if (!SchemaItem_1.SchemaItem.isSchemaItem(object))
+            return false;
+        return object.schemaItemType === ECObjects_1.SchemaItemType.EntityClass || object.schemaItemType === ECObjects_1.SchemaItemType.Mixin || object.schemaItemType === ECObjects_1.SchemaItemType.RelationshipClass ||
+            object.schemaItemType === ECObjects_1.SchemaItemType.StructClass || object.schemaItemType === ECObjects_1.SchemaItemType.CustomAttributeClass;
+    }
+    /**
+     * @alpha
+     * A setter method used specifically for schema editing.
+     * @param modifier
+     */
+    setModifier(modifier) {
+        this._modifier = modifier;
+    }
+}
+exports.ECClass = ECClass;
+/**
+ * A Typescript class representation of an ECStructClass.
+ * @beta
+ */
+class StructClass extends ECClass {
+    constructor(schema, name, modifier) {
+        super(schema, name, modifier);
+        this.schemaItemType = ECObjects_1.SchemaItemType.StructClass;
+    }
+}
+exports.StructClass = StructClass;
+/**
+ * @internal
+ * An abstract class used for schema editing.
+ */
+class MutableStructClass extends StructClass {
+}
+exports.MutableStructClass = MutableStructClass;
+/**
+ * Hackish approach that works like a "friend class" so we can access protected members without making them public.
+ * @internal
+ */
+class MutableClass extends ECClass {
+}
+exports.MutableClass = MutableClass;
 //# sourceMappingURL=Class.js.map