@itwin/ecschema-editing 4.0.0-dev.52 → 4.0.0-dev.55

package/lib/cjs/Editing/Entities.js

@@ -1,117 +1,117 @@
-"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 Editing
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Entities = void 0;
-const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
-const ECClasses_1 = require("./ECClasses");
-/**
- * @alpha
- * A class extending ECClasses allowing you to create schema items of type EntityClass.
- */
-class Entities extends ECClasses_1.ECClasses {
-    constructor(_schemaEditor) {
-        super(_schemaEditor);
-    }
-    async createElement(schemaKey, name, modifier, baseClassKey, displayLabel, mixins) {
-        const baseClass = await this._schemaEditor.schemaContext.getSchemaItem(baseClassKey);
-        if (!baseClass)
-            throw new Error(`The class ${name} could not be created because the specified base class ${baseClassKey.fullName} could be found.`);
-        if (baseClass?.schemaItemType !== ecschema_metadata_1.SchemaItemType.EntityClass)
-            throw new Error(`The class ${name} could not be created because the specified base class ${baseClassKey.fullName} is not an EntityClass.`);
-        if (!(await baseClass.is("Element", "BisCore"))) {
-            throw new Error(`The class ${name} could not be created because the specified base class ${baseClassKey.fullName} is not an Element.`);
-        }
-        return this.create(schemaKey, name, modifier, displayLabel, baseClassKey, mixins);
-    }
-    async createElementUniqueAspect(schemaKey, name, modifier, baseClassKey, displayLabel, mixins) {
-        const baseClass = await this._schemaEditor.schemaContext.getSchemaItem(baseClassKey);
-        if (!baseClass)
-            throw new Error(`The class ${name} could not be created because the specified base class ${baseClassKey.fullName} could be found.`);
-        if (baseClass?.schemaItemType !== ecschema_metadata_1.SchemaItemType.EntityClass)
-            throw new Error(`The class ${name} could not be created because the specified base class ${baseClassKey.fullName} is not an EntityClass.`);
-        if (!(await baseClass.is("ElementUniqueAspect", "BisCore"))) {
-            throw new Error(`The class ${name} could not be created because the specified base class ${baseClassKey.fullName} is not an ElementUniqueAspect.`);
-        }
-        return this.create(schemaKey, name, modifier, displayLabel, baseClassKey, mixins);
-    }
-    async createElementMultiAspect(schemaKey, name, modifier, baseClassKey, displayLabel, mixins) {
-        const baseClass = await this._schemaEditor.schemaContext.getSchemaItem(baseClassKey);
-        if (!baseClass)
-            throw new Error(`The class ${name} could not be created because the specified base class ${baseClassKey.fullName} could be found.`);
-        if (baseClass?.schemaItemType !== ecschema_metadata_1.SchemaItemType.EntityClass)
-            throw new Error(`The class ${name} could not be created because the specified base class ${baseClassKey.fullName} is not an EntityClass.`);
-        if (!(await baseClass.is("ElementMultiAspect", "BisCore"))) {
-            throw new Error(`The class ${name} could not be created because the specified base class ${baseClassKey.fullName} is not an ElementMultiAspect.`);
-        }
-        return this.create(schemaKey, name, modifier, displayLabel, baseClassKey, mixins);
-    }
-    async create(schemaKey, name, modifier, displayLabel, baseClassKey, mixins) {
-        const schema = await this._schemaEditor.getSchema(schemaKey);
-        if (schema === undefined)
-            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
-        const newClass = (await schema.createEntityClass(name, modifier));
-        if (newClass === undefined)
-            return { errorMessage: `Failed to create class ${name} in schema ${schemaKey.toString(true)}.` };
-        // Add a deserializing method.
-        if (baseClassKey !== undefined) {
-            let baseClassSchema = schema;
-            if (!baseClassKey.schemaKey.matches(schema.schemaKey))
-                baseClassSchema = await this._schemaEditor.getSchema(baseClassKey.schemaKey);
-            const baseClassItem = await baseClassSchema.lookupItem(baseClassKey);
-            if (baseClassItem === undefined)
-                return { errorMessage: `Unable to locate base class ${baseClassKey.fullName} in schema ${baseClassSchema.fullName}.` };
-            if (baseClassItem.schemaItemType !== ecschema_metadata_1.SchemaItemType.EntityClass)
-                return { errorMessage: `${baseClassItem.fullName} is not of type Entity Class.` };
-            newClass.baseClass = new ecschema_metadata_1.DelayedPromiseWithProps(baseClassKey, async () => baseClassItem);
-        }
-        if (mixins !== undefined)
-            mixins.forEach((m) => newClass.addMixin(m));
-        if (displayLabel)
-            newClass.setDisplayLabel(displayLabel);
-        return { itemKey: newClass.key };
-    }
-    /**
-     * Creates an EntityClass through an EntityClassProps.
-     * @param schemaKey a SchemaKey of the Schema that will house the new object.
-     * @param entityProps a json object that will be used to populate the new EntityClass. Needs a name value passed in.
-     */
-    async createFromProps(schemaKey, entityProps) {
-        const schema = await this._schemaEditor.getSchema(schemaKey);
-        if (schema === undefined)
-            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
-        if (entityProps.name === undefined)
-            return { errorMessage: `No name was supplied within props.` };
-        const newClass = (await schema.createEntityClass(entityProps.name));
-        if (newClass === undefined)
-            return { errorMessage: `Failed to create class ${entityProps.name} in schema ${schemaKey.toString(true)}.` };
-        await newClass.fromJSON(entityProps);
-        return { itemKey: newClass.key };
-    }
-    async addMixin(entityKey, mixinKey) {
-        const entity = (await this._schemaEditor.schemaContext.getSchemaItem(entityKey));
-        const mixin = (await this._schemaEditor.schemaContext.getSchemaItem(mixinKey));
-        // TODO: have a helpful returns
-        if (!entity || entity.schemaItemType !== ecschema_metadata_1.SchemaItemType.EntityClass)
-            return;
-        if (!mixin || mixin.schemaItemType !== ecschema_metadata_1.SchemaItemType.Mixin)
-            return;
-        entity.addMixin(mixin);
-    }
-    async createNavigationProperty(entityKey, name, relationship, direction) {
-        const entity = (await this._schemaEditor.schemaContext.getSchemaItem(entityKey));
-        if (entity === undefined)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.ClassNotFound, `Entity Class ${entityKey.fullName} not found in schema context.`);
-        if (entity.schemaItemType !== ecschema_metadata_1.SchemaItemType.EntityClass)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidSchemaItemType, `Expected ${entityKey.fullName} to be of type Entity Class.`);
-        await entity.createNavigationProperty(name, relationship, direction);
-        return { itemKey: entityKey, propertyName: name };
-    }
-}
-exports.Entities = Entities;
+"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 Editing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entities = void 0;
+const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
+const ECClasses_1 = require("./ECClasses");
+/**
+ * @alpha
+ * A class extending ECClasses allowing you to create schema items of type EntityClass.
+ */
+class Entities extends ECClasses_1.ECClasses {
+    constructor(_schemaEditor) {
+        super(_schemaEditor);
+    }
+    async createElement(schemaKey, name, modifier, baseClassKey, displayLabel, mixins) {
+        const baseClass = await this._schemaEditor.schemaContext.getSchemaItem(baseClassKey);
+        if (!baseClass)
+            throw new Error(`The class ${name} could not be created because the specified base class ${baseClassKey.fullName} could be found.`);
+        if (baseClass?.schemaItemType !== ecschema_metadata_1.SchemaItemType.EntityClass)
+            throw new Error(`The class ${name} could not be created because the specified base class ${baseClassKey.fullName} is not an EntityClass.`);
+        if (!(await baseClass.is("Element", "BisCore"))) {
+            throw new Error(`The class ${name} could not be created because the specified base class ${baseClassKey.fullName} is not an Element.`);
+        }
+        return this.create(schemaKey, name, modifier, displayLabel, baseClassKey, mixins);
+    }
+    async createElementUniqueAspect(schemaKey, name, modifier, baseClassKey, displayLabel, mixins) {
+        const baseClass = await this._schemaEditor.schemaContext.getSchemaItem(baseClassKey);
+        if (!baseClass)
+            throw new Error(`The class ${name} could not be created because the specified base class ${baseClassKey.fullName} could be found.`);
+        if (baseClass?.schemaItemType !== ecschema_metadata_1.SchemaItemType.EntityClass)
+            throw new Error(`The class ${name} could not be created because the specified base class ${baseClassKey.fullName} is not an EntityClass.`);
+        if (!(await baseClass.is("ElementUniqueAspect", "BisCore"))) {
+            throw new Error(`The class ${name} could not be created because the specified base class ${baseClassKey.fullName} is not an ElementUniqueAspect.`);
+        }
+        return this.create(schemaKey, name, modifier, displayLabel, baseClassKey, mixins);
+    }
+    async createElementMultiAspect(schemaKey, name, modifier, baseClassKey, displayLabel, mixins) {
+        const baseClass = await this._schemaEditor.schemaContext.getSchemaItem(baseClassKey);
+        if (!baseClass)
+            throw new Error(`The class ${name} could not be created because the specified base class ${baseClassKey.fullName} could be found.`);
+        if (baseClass?.schemaItemType !== ecschema_metadata_1.SchemaItemType.EntityClass)
+            throw new Error(`The class ${name} could not be created because the specified base class ${baseClassKey.fullName} is not an EntityClass.`);
+        if (!(await baseClass.is("ElementMultiAspect", "BisCore"))) {
+            throw new Error(`The class ${name} could not be created because the specified base class ${baseClassKey.fullName} is not an ElementMultiAspect.`);
+        }
+        return this.create(schemaKey, name, modifier, displayLabel, baseClassKey, mixins);
+    }
+    async create(schemaKey, name, modifier, displayLabel, baseClassKey, mixins) {
+        const schema = await this._schemaEditor.getSchema(schemaKey);
+        if (schema === undefined)
+            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
+        const newClass = (await schema.createEntityClass(name, modifier));
+        if (newClass === undefined)
+            return { errorMessage: `Failed to create class ${name} in schema ${schemaKey.toString(true)}.` };
+        // Add a deserializing method.
+        if (baseClassKey !== undefined) {
+            let baseClassSchema = schema;
+            if (!baseClassKey.schemaKey.matches(schema.schemaKey))
+                baseClassSchema = await this._schemaEditor.getSchema(baseClassKey.schemaKey);
+            const baseClassItem = await baseClassSchema.lookupItem(baseClassKey);
+            if (baseClassItem === undefined)
+                return { errorMessage: `Unable to locate base class ${baseClassKey.fullName} in schema ${baseClassSchema.fullName}.` };
+            if (baseClassItem.schemaItemType !== ecschema_metadata_1.SchemaItemType.EntityClass)
+                return { errorMessage: `${baseClassItem.fullName} is not of type Entity Class.` };
+            newClass.baseClass = new ecschema_metadata_1.DelayedPromiseWithProps(baseClassKey, async () => baseClassItem);
+        }
+        if (mixins !== undefined)
+            mixins.forEach((m) => newClass.addMixin(m));
+        if (displayLabel)
+            newClass.setDisplayLabel(displayLabel);
+        return { itemKey: newClass.key };
+    }
+    /**
+     * Creates an EntityClass through an EntityClassProps.
+     * @param schemaKey a SchemaKey of the Schema that will house the new object.
+     * @param entityProps a json object that will be used to populate the new EntityClass. Needs a name value passed in.
+     */
+    async createFromProps(schemaKey, entityProps) {
+        const schema = await this._schemaEditor.getSchema(schemaKey);
+        if (schema === undefined)
+            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
+        if (entityProps.name === undefined)
+            return { errorMessage: `No name was supplied within props.` };
+        const newClass = (await schema.createEntityClass(entityProps.name));
+        if (newClass === undefined)
+            return { errorMessage: `Failed to create class ${entityProps.name} in schema ${schemaKey.toString(true)}.` };
+        await newClass.fromJSON(entityProps);
+        return { itemKey: newClass.key };
+    }
+    async addMixin(entityKey, mixinKey) {
+        const entity = (await this._schemaEditor.schemaContext.getSchemaItem(entityKey));
+        const mixin = (await this._schemaEditor.schemaContext.getSchemaItem(mixinKey));
+        // TODO: have a helpful returns
+        if (!entity || entity.schemaItemType !== ecschema_metadata_1.SchemaItemType.EntityClass)
+            return;
+        if (!mixin || mixin.schemaItemType !== ecschema_metadata_1.SchemaItemType.Mixin)
+            return;
+        entity.addMixin(mixin);
+    }
+    async createNavigationProperty(entityKey, name, relationship, direction) {
+        const entity = (await this._schemaEditor.schemaContext.getSchemaItem(entityKey));
+        if (entity === undefined)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.ClassNotFound, `Entity Class ${entityKey.fullName} not found in schema context.`);
+        if (entity.schemaItemType !== ecschema_metadata_1.SchemaItemType.EntityClass)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidSchemaItemType, `Expected ${entityKey.fullName} to be of type Entity Class.`);
+        await entity.createNavigationProperty(name, relationship, direction);
+        return { itemKey: entityKey, propertyName: name };
+    }
+}
+exports.Entities = Entities;
 //# sourceMappingURL=Entities.js.map

package/lib/cjs/Editing/Enumerations.d.ts

@@ -1,22 +1,22 @@
-/** @packageDocumentation
- * @module Editing
- */
-import { AnyEnumerator, EnumerationProps, PrimitiveType, SchemaItemKey, SchemaKey } from "@itwin/ecschema-metadata";
-import { SchemaContextEditor, SchemaItemEditResults } from "./Editor";
-/**
- * @alpha
- * A class allowing you to create schema items of type Enumeration.
- */
-export declare class Enumerations {
-    protected _schemaEditor: SchemaContextEditor;
-    constructor(_schemaEditor: SchemaContextEditor);
-    create(schemaKey: SchemaKey, name: string, type: PrimitiveType.Integer | PrimitiveType.String, displayLabel?: string, isStrict?: boolean, enumerators?: AnyEnumerator[]): Promise<SchemaItemEditResults>;
-    /**
-     * Creates an Enumeration through an EnumeratorProps.
-     * @param schemaKey a SchemaKey of the Schema that will house the new object.
-     * @param relationshipProps a json object that will be used to populate the new RelationshipClass. Needs a name value passed in.
-     */
-    createFromProps(schemaKey: SchemaKey, enumProps: EnumerationProps): Promise<SchemaItemEditResults>;
-    addEnumerator(enumerationKey: SchemaItemKey, enumerator: AnyEnumerator): Promise<void>;
-}
+/** @packageDocumentation
+ * @module Editing
+ */
+import { AnyEnumerator, EnumerationProps, PrimitiveType, SchemaItemKey, SchemaKey } from "@itwin/ecschema-metadata";
+import { SchemaContextEditor, SchemaItemEditResults } from "./Editor";
+/**
+ * @alpha
+ * A class allowing you to create schema items of type Enumeration.
+ */
+export declare class Enumerations {
+    protected _schemaEditor: SchemaContextEditor;
+    constructor(_schemaEditor: SchemaContextEditor);
+    create(schemaKey: SchemaKey, name: string, type: PrimitiveType.Integer | PrimitiveType.String, displayLabel?: string, isStrict?: boolean, enumerators?: AnyEnumerator[]): Promise<SchemaItemEditResults>;
+    /**
+     * Creates an Enumeration through an EnumeratorProps.
+     * @param schemaKey a SchemaKey of the Schema that will house the new object.
+     * @param relationshipProps a json object that will be used to populate the new RelationshipClass. Needs a name value passed in.
+     */
+    createFromProps(schemaKey: SchemaKey, enumProps: EnumerationProps): Promise<SchemaItemEditResults>;
+    addEnumerator(enumerationKey: SchemaItemKey, enumerator: AnyEnumerator): Promise<void>;
+}
 //# sourceMappingURL=Enumerations.d.ts.map

package/lib/cjs/Editing/Enumerations.js

@@ -1,67 +1,67 @@
-"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 Editing
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Enumerations = void 0;
-const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
-/**
- * @alpha
- * A class allowing you to create schema items of type Enumeration.
- */
-class Enumerations {
-    constructor(_schemaEditor) {
-        this._schemaEditor = _schemaEditor;
-    }
-    async create(schemaKey, name, type, displayLabel, isStrict, enumerators) {
-        const schema = await this._schemaEditor.getSchema(schemaKey);
-        if (schema === undefined)
-            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
-        const newEnum = (await schema.createEnumeration(name, type));
-        if (newEnum === undefined)
-            return { errorMessage: `Failed to create class ${name} in schema ${schemaKey.toString(true)}.` };
-        if (undefined !== isStrict)
-            newEnum.setIsStrict(isStrict);
-        if (undefined !== enumerators)
-            for (const enumerator of enumerators)
-                await this.addEnumerator(newEnum.key, enumerator);
-        if (displayLabel)
-            newEnum.setDisplayLabel(displayLabel);
-        return { itemKey: newEnum.key };
-    }
-    /**
-     * Creates an Enumeration through an EnumeratorProps.
-     * @param schemaKey a SchemaKey of the Schema that will house the new object.
-     * @param relationshipProps a json object that will be used to populate the new RelationshipClass. Needs a name value passed in.
-     */
-    async createFromProps(schemaKey, enumProps) {
-        const schema = await this._schemaEditor.getSchema(schemaKey);
-        if (schema === undefined)
-            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
-        if (enumProps.name === undefined)
-            return { errorMessage: `No name was supplied within props.` };
-        const newEnum = (await schema.createEnumeration(enumProps.name));
-        if (newEnum === undefined)
-            return { errorMessage: `Failed to create class ${enumProps.name} in schema ${schemaKey.toString(true)}.` };
-        await newEnum.fromJSON(enumProps);
-        return { itemKey: newEnum.key };
-    }
-    async addEnumerator(enumerationKey, enumerator) {
-        const enumeration = (await this._schemaEditor.schemaContext.getSchemaItem(enumerationKey));
-        if (enumeration === undefined)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.ClassNotFound, `Unable to locate Enumeration class ${enumerationKey.fullName}.`);
-        if (enumeration.schemaItemType !== ecschema_metadata_1.SchemaItemType.Enumeration)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidType, `${enumeration.fullName} is not of type Enumerator class.`);
-        if (enumeration.isInt && typeof (enumerator.value) !== "number")
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidPrimitiveType, `The Enumeration ${enumeration.name} has type integer, while ${enumerator.name} has type ${typeof (enumerator.value)}.`);
-        if (enumeration.isString && typeof (enumerator.value) !== "string")
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidPrimitiveType, `The Enumeration ${enumeration.name} has type string, while ${enumerator.name} has type ${typeof (enumerator.value)}.`);
-        enumeration.addEnumerator(enumerator);
-    }
-}
-exports.Enumerations = Enumerations;
+"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 Editing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Enumerations = void 0;
+const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
+/**
+ * @alpha
+ * A class allowing you to create schema items of type Enumeration.
+ */
+class Enumerations {
+    constructor(_schemaEditor) {
+        this._schemaEditor = _schemaEditor;
+    }
+    async create(schemaKey, name, type, displayLabel, isStrict, enumerators) {
+        const schema = await this._schemaEditor.getSchema(schemaKey);
+        if (schema === undefined)
+            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
+        const newEnum = (await schema.createEnumeration(name, type));
+        if (newEnum === undefined)
+            return { errorMessage: `Failed to create class ${name} in schema ${schemaKey.toString(true)}.` };
+        if (undefined !== isStrict)
+            newEnum.setIsStrict(isStrict);
+        if (undefined !== enumerators)
+            for (const enumerator of enumerators)
+                await this.addEnumerator(newEnum.key, enumerator);
+        if (displayLabel)
+            newEnum.setDisplayLabel(displayLabel);
+        return { itemKey: newEnum.key };
+    }
+    /**
+     * Creates an Enumeration through an EnumeratorProps.
+     * @param schemaKey a SchemaKey of the Schema that will house the new object.
+     * @param relationshipProps a json object that will be used to populate the new RelationshipClass. Needs a name value passed in.
+     */
+    async createFromProps(schemaKey, enumProps) {
+        const schema = await this._schemaEditor.getSchema(schemaKey);
+        if (schema === undefined)
+            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
+        if (enumProps.name === undefined)
+            return { errorMessage: `No name was supplied within props.` };
+        const newEnum = (await schema.createEnumeration(enumProps.name));
+        if (newEnum === undefined)
+            return { errorMessage: `Failed to create class ${enumProps.name} in schema ${schemaKey.toString(true)}.` };
+        await newEnum.fromJSON(enumProps);
+        return { itemKey: newEnum.key };
+    }
+    async addEnumerator(enumerationKey, enumerator) {
+        const enumeration = (await this._schemaEditor.schemaContext.getSchemaItem(enumerationKey));
+        if (enumeration === undefined)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.ClassNotFound, `Unable to locate Enumeration class ${enumerationKey.fullName}.`);
+        if (enumeration.schemaItemType !== ecschema_metadata_1.SchemaItemType.Enumeration)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidType, `${enumeration.fullName} is not of type Enumerator class.`);
+        if (enumeration.isInt && typeof (enumerator.value) !== "number")
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidPrimitiveType, `The Enumeration ${enumeration.name} has type integer, while ${enumerator.name} has type ${typeof (enumerator.value)}.`);
+        if (enumeration.isString && typeof (enumerator.value) !== "string")
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidPrimitiveType, `The Enumeration ${enumeration.name} has type string, while ${enumerator.name} has type ${typeof (enumerator.value)}.`);
+        enumeration.addEnumerator(enumerator);
+    }
+}
+exports.Enumerations = Enumerations;
 //# sourceMappingURL=Enumerations.js.map

package/lib/cjs/Editing/Formats.d.ts

@@ -1,22 +1,22 @@
-/** @packageDocumentation
- * @module Editing
- */
-import { FormatProps, SchemaItemKey, SchemaKey } from "@itwin/ecschema-metadata";
-import { FormatType } from "@itwin/core-quantity";
-import { SchemaContextEditor, SchemaItemEditResults } from "./Editor";
-/**
- * @alpha
- * A class allowing you to create schema items of type Format.
- */
-export declare class Formats {
-    protected _schemaEditor: SchemaContextEditor;
-    constructor(_schemaEditor: SchemaContextEditor);
-    create(schemaKey: SchemaKey, name: string, formatType: FormatType, displayLabel?: string, units?: SchemaItemKey[]): Promise<SchemaItemEditResults>;
-    /**
-     * Creates a format through a FormatProps.
-     * @param schemaKey a SchemaKey of the Schema that will house the new object.
-     * @param relationshipProps a json object that will be used to populate the new RelationshipClass. Needs a name value passed in.
-     */
-    createFromProps(schemaKey: SchemaKey, formatProps: FormatProps): Promise<SchemaItemEditResults>;
-}
+/** @packageDocumentation
+ * @module Editing
+ */
+import { FormatProps, SchemaItemKey, SchemaKey } from "@itwin/ecschema-metadata";
+import { FormatType } from "@itwin/core-quantity";
+import { SchemaContextEditor, SchemaItemEditResults } from "./Editor";
+/**
+ * @alpha
+ * A class allowing you to create schema items of type Format.
+ */
+export declare class Formats {
+    protected _schemaEditor: SchemaContextEditor;
+    constructor(_schemaEditor: SchemaContextEditor);
+    create(schemaKey: SchemaKey, name: string, formatType: FormatType, displayLabel?: string, units?: SchemaItemKey[]): Promise<SchemaItemEditResults>;
+    /**
+     * Creates a format through a FormatProps.
+     * @param schemaKey a SchemaKey of the Schema that will house the new object.
+     * @param relationshipProps a json object that will be used to populate the new RelationshipClass. Needs a name value passed in.
+     */
+    createFromProps(schemaKey: SchemaKey, formatProps: FormatProps): Promise<SchemaItemEditResults>;
+}
 //# sourceMappingURL=Formats.d.ts.map

package/lib/cjs/Editing/Formats.js

@@ -1,62 +1,62 @@
-"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 Editing
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Formats = void 0;
-const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
-/**
- * @alpha
- * A class allowing you to create schema items of type Format.
- */
-class Formats {
-    constructor(_schemaEditor) {
-        this._schemaEditor = _schemaEditor;
-    }
-    async create(schemaKey, name, formatType, displayLabel, units) {
-        const schema = await this._schemaEditor.getSchema(schemaKey);
-        const newFormat = (await schema.createFormat(name));
-        if (newFormat === undefined) {
-            return { errorMessage: `Failed to create class ${name} in schema ${schemaKey.toString(true)}.` };
-        }
-        if (units !== undefined) {
-            for (const unit of units) {
-                const unitItem = await this._schemaEditor.schemaContext.getSchemaItem(unit);
-                if (unitItem === undefined) {
-                    return { errorMessage: `Failed to locate unit ${unit.name} in Schema Context.` };
-                }
-                if (unitItem.schemaItemType !== ecschema_metadata_1.SchemaItemType.Unit && unitItem.schemaItemType !== ecschema_metadata_1.SchemaItemType.InvertedUnit)
-                    return { errorMessage: `${unitItem.fullName} is not of type Unit or InvertedUnit.` };
-                newFormat.addUnit(unitItem);
-            }
-        }
-        if (displayLabel)
-            newFormat.setDisplayLabel(displayLabel);
-        // TODO: Handle the setting of format traits, separators, etc....
-        newFormat.setFormatType(formatType);
-        return { itemKey: newFormat.key };
-    }
-    /**
-     * Creates a format through a FormatProps.
-     * @param schemaKey a SchemaKey of the Schema that will house the new object.
-     * @param relationshipProps a json object that will be used to populate the new RelationshipClass. Needs a name value passed in.
-     */
-    async createFromProps(schemaKey, formatProps) {
-        const schema = await this._schemaEditor.getSchema(schemaKey);
-        if (schema === undefined)
-            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
-        if (formatProps.name === undefined)
-            return { errorMessage: `No name was supplied within props.` };
-        const newFormat = (await schema.createFormat(formatProps.name));
-        if (newFormat === undefined)
-            return { errorMessage: `Failed to create class ${formatProps.name} in schema ${schemaKey.toString(true)}.` };
-        await newFormat.fromJSON(formatProps);
-        return { itemKey: newFormat.key };
-    }
-}
-exports.Formats = Formats;
+"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 Editing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Formats = void 0;
+const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
+/**
+ * @alpha
+ * A class allowing you to create schema items of type Format.
+ */
+class Formats {
+    constructor(_schemaEditor) {
+        this._schemaEditor = _schemaEditor;
+    }
+    async create(schemaKey, name, formatType, displayLabel, units) {
+        const schema = await this._schemaEditor.getSchema(schemaKey);
+        const newFormat = (await schema.createFormat(name));
+        if (newFormat === undefined) {
+            return { errorMessage: `Failed to create class ${name} in schema ${schemaKey.toString(true)}.` };
+        }
+        if (units !== undefined) {
+            for (const unit of units) {
+                const unitItem = await this._schemaEditor.schemaContext.getSchemaItem(unit);
+                if (unitItem === undefined) {
+                    return { errorMessage: `Failed to locate unit ${unit.name} in Schema Context.` };
+                }
+                if (unitItem.schemaItemType !== ecschema_metadata_1.SchemaItemType.Unit && unitItem.schemaItemType !== ecschema_metadata_1.SchemaItemType.InvertedUnit)
+                    return { errorMessage: `${unitItem.fullName} is not of type Unit or InvertedUnit.` };
+                newFormat.addUnit(unitItem);
+            }
+        }
+        if (displayLabel)
+            newFormat.setDisplayLabel(displayLabel);
+        // TODO: Handle the setting of format traits, separators, etc....
+        newFormat.setFormatType(formatType);
+        return { itemKey: newFormat.key };
+    }
+    /**
+     * Creates a format through a FormatProps.
+     * @param schemaKey a SchemaKey of the Schema that will house the new object.
+     * @param relationshipProps a json object that will be used to populate the new RelationshipClass. Needs a name value passed in.
+     */
+    async createFromProps(schemaKey, formatProps) {
+        const schema = await this._schemaEditor.getSchema(schemaKey);
+        if (schema === undefined)
+            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
+        if (formatProps.name === undefined)
+            return { errorMessage: `No name was supplied within props.` };
+        const newFormat = (await schema.createFormat(formatProps.name));
+        if (newFormat === undefined)
+            return { errorMessage: `Failed to create class ${formatProps.name} in schema ${schemaKey.toString(true)}.` };
+        await newFormat.fromJSON(formatProps);
+        return { itemKey: newFormat.key };
+    }
+}
+exports.Formats = Formats;
 //# sourceMappingURL=Formats.js.map

package/lib/cjs/Editing/InvertedUnits.d.ts

@@ -1,18 +1,18 @@
-/** @packageDocumentation
- * @module Editing
- */
-import { InvertedUnitProps, SchemaItemKey, SchemaKey } from "@itwin/ecschema-metadata";
-import { SchemaContextEditor, SchemaItemEditResults } from "./Editor";
-/**
- * @alpha
- * A class allowing you to create schema items of type Inverted Unit.
- */
-export declare class InvertedUnits {
-    protected _schemaEditor: SchemaContextEditor;
-    constructor(_schemaEditor: SchemaContextEditor);
-    create(schemaKey: SchemaKey, name: string, invertsUnitKey: SchemaItemKey, unitSystemKey: SchemaItemKey, displayLabel?: string): Promise<SchemaItemEditResults>;
-    createFromProps(schemaKey: SchemaKey, invertedUnitProps: InvertedUnitProps): Promise<SchemaItemEditResults>;
-    setInvertsUnit(invertedUnitKey: SchemaItemKey, invertsUnitKey: SchemaItemKey): Promise<void>;
-    setUnitSystem(invertedUnitKey: SchemaItemKey, unitSystemKey: SchemaItemKey): Promise<void>;
-}
+/** @packageDocumentation
+ * @module Editing
+ */
+import { InvertedUnitProps, SchemaItemKey, SchemaKey } from "@itwin/ecschema-metadata";
+import { SchemaContextEditor, SchemaItemEditResults } from "./Editor";
+/**
+ * @alpha
+ * A class allowing you to create schema items of type Inverted Unit.
+ */
+export declare class InvertedUnits {
+    protected _schemaEditor: SchemaContextEditor;
+    constructor(_schemaEditor: SchemaContextEditor);
+    create(schemaKey: SchemaKey, name: string, invertsUnitKey: SchemaItemKey, unitSystemKey: SchemaItemKey, displayLabel?: string): Promise<SchemaItemEditResults>;
+    createFromProps(schemaKey: SchemaKey, invertedUnitProps: InvertedUnitProps): Promise<SchemaItemEditResults>;
+    setInvertsUnit(invertedUnitKey: SchemaItemKey, invertsUnitKey: SchemaItemKey): Promise<void>;
+    setUnitSystem(invertedUnitKey: SchemaItemKey, unitSystemKey: SchemaItemKey): Promise<void>;
+}
 //# sourceMappingURL=InvertedUnits.d.ts.map