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

package/lib/cjs/Editing/InvertedUnits.js

@@ -1,83 +1,83 @@
-"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.InvertedUnits = void 0;
-const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
-/**
- * @alpha
- * A class allowing you to create schema items of type Inverted Unit.
- */
-class InvertedUnits {
-    constructor(_schemaEditor) {
-        this._schemaEditor = _schemaEditor;
-    }
-    async create(schemaKey, name, invertsUnitKey, unitSystemKey, displayLabel) {
-        const schema = await this._schemaEditor.getSchema(schemaKey);
-        if (schema === undefined)
-            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
-        const newUnit = (await schema.createInvertedUnit(name));
-        if (newUnit === undefined)
-            return { errorMessage: `Failed to create class ${name} in schema ${schemaKey.toString(true)}.` };
-        const invertsUnit = await schema.lookupItem(invertsUnitKey);
-        if (invertsUnit === undefined)
-            return { errorMessage: `Unable to locate unit ${invertsUnitKey.fullName} in schema ${schema.fullName}.` };
-        if (invertsUnit.schemaItemType !== ecschema_metadata_1.SchemaItemType.Unit)
-            return { errorMessage: `${invertsUnit.fullName} is not of type Unit.` };
-        newUnit.setInvertsUnit(new ecschema_metadata_1.DelayedPromiseWithProps(invertsUnitKey, async () => invertsUnit));
-        const unitSystem = await schema.lookupItem(unitSystemKey);
-        if (unitSystem === undefined)
-            return { errorMessage: `Unable to locate unit system ${unitSystemKey.fullName} in schema ${schema.fullName}.` };
-        if (unitSystem.schemaItemType !== ecschema_metadata_1.SchemaItemType.UnitSystem)
-            return { errorMessage: `${unitSystemKey.fullName} is not of type Unit System.` };
-        newUnit.setUnitSystem(new ecschema_metadata_1.DelayedPromiseWithProps(unitSystemKey, async () => unitSystem));
-        if (displayLabel)
-            newUnit.setDisplayLabel(displayLabel);
-        return { itemKey: newUnit.key };
-    }
-    async createFromProps(schemaKey, invertedUnitProps) {
-        const schema = await this._schemaEditor.getSchema(schemaKey);
-        if (schema === undefined)
-            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
-        if (invertedUnitProps.name === undefined)
-            return { errorMessage: `No name was supplied within props.` };
-        const newUnit = (await schema.createInvertedUnit(invertedUnitProps.name));
-        if (newUnit === undefined)
-            return { errorMessage: `Failed to create class ${invertedUnitProps.name} in schema ${schemaKey.toString(true)}.` };
-        await newUnit.fromJSON(invertedUnitProps);
-        return { itemKey: newUnit.key };
-    }
-    async setInvertsUnit(invertedUnitKey, invertsUnitKey) {
-        const invertedUnit = await this._schemaEditor.schemaContext.getSchemaItem(invertedUnitKey);
-        if (invertedUnit === undefined)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.ClassNotFound, `Inverted Unit ${invertedUnitKey.fullName} not found in schema context.`);
-        if (invertedUnit.schemaItemType !== ecschema_metadata_1.SchemaItemType.InvertedUnit)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidSchemaItemType, `Expected ${invertedUnitKey.fullName} to be of type Inverted Unit.`);
-        const invertsUnit = await this._schemaEditor.schemaContext.getSchemaItem(invertsUnitKey);
-        if (invertsUnit === undefined)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.ClassNotFound, `Unit ${invertsUnitKey.fullName} not found in schema context.`);
-        if (invertsUnit.schemaItemType !== ecschema_metadata_1.SchemaItemType.Unit)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidSchemaItemType, `Expected ${invertsUnitKey.fullName} to be of type Unit.`);
-        invertedUnit.setInvertsUnit(new ecschema_metadata_1.DelayedPromiseWithProps(invertsUnitKey, async () => invertsUnit));
-    }
-    async setUnitSystem(invertedUnitKey, unitSystemKey) {
-        const invertedUnit = await this._schemaEditor.schemaContext.getSchemaItem(invertedUnitKey);
-        if (invertedUnit === undefined)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.ClassNotFound, `Inverted Unit ${invertedUnitKey.fullName} not found in schema context.`);
-        if (invertedUnit.schemaItemType !== ecschema_metadata_1.SchemaItemType.InvertedUnit)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidSchemaItemType, `Expected ${invertedUnitKey.fullName} to be of type Inverted Unit.`);
-        const unitSystem = await this._schemaEditor.schemaContext.getSchemaItem(unitSystemKey);
-        if (unitSystem === undefined)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.ClassNotFound, `Unit ${unitSystemKey.fullName} not found in schema context.`);
-        if (unitSystem.schemaItemType !== ecschema_metadata_1.SchemaItemType.UnitSystem)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidSchemaItemType, `Expected ${unitSystemKey.fullName} to be of type Unit System.`);
-        invertedUnit.setUnitSystem(new ecschema_metadata_1.DelayedPromiseWithProps(unitSystemKey, async () => unitSystem));
-    }
-}
-exports.InvertedUnits = InvertedUnits;
+"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.InvertedUnits = void 0;
+const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
+/**
+ * @alpha
+ * A class allowing you to create schema items of type Inverted Unit.
+ */
+class InvertedUnits {
+    constructor(_schemaEditor) {
+        this._schemaEditor = _schemaEditor;
+    }
+    async create(schemaKey, name, invertsUnitKey, unitSystemKey, displayLabel) {
+        const schema = await this._schemaEditor.getSchema(schemaKey);
+        if (schema === undefined)
+            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
+        const newUnit = (await schema.createInvertedUnit(name));
+        if (newUnit === undefined)
+            return { errorMessage: `Failed to create class ${name} in schema ${schemaKey.toString(true)}.` };
+        const invertsUnit = await schema.lookupItem(invertsUnitKey);
+        if (invertsUnit === undefined)
+            return { errorMessage: `Unable to locate unit ${invertsUnitKey.fullName} in schema ${schema.fullName}.` };
+        if (invertsUnit.schemaItemType !== ecschema_metadata_1.SchemaItemType.Unit)
+            return { errorMessage: `${invertsUnit.fullName} is not of type Unit.` };
+        newUnit.setInvertsUnit(new ecschema_metadata_1.DelayedPromiseWithProps(invertsUnitKey, async () => invertsUnit));
+        const unitSystem = await schema.lookupItem(unitSystemKey);
+        if (unitSystem === undefined)
+            return { errorMessage: `Unable to locate unit system ${unitSystemKey.fullName} in schema ${schema.fullName}.` };
+        if (unitSystem.schemaItemType !== ecschema_metadata_1.SchemaItemType.UnitSystem)
+            return { errorMessage: `${unitSystemKey.fullName} is not of type Unit System.` };
+        newUnit.setUnitSystem(new ecschema_metadata_1.DelayedPromiseWithProps(unitSystemKey, async () => unitSystem));
+        if (displayLabel)
+            newUnit.setDisplayLabel(displayLabel);
+        return { itemKey: newUnit.key };
+    }
+    async createFromProps(schemaKey, invertedUnitProps) {
+        const schema = await this._schemaEditor.getSchema(schemaKey);
+        if (schema === undefined)
+            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
+        if (invertedUnitProps.name === undefined)
+            return { errorMessage: `No name was supplied within props.` };
+        const newUnit = (await schema.createInvertedUnit(invertedUnitProps.name));
+        if (newUnit === undefined)
+            return { errorMessage: `Failed to create class ${invertedUnitProps.name} in schema ${schemaKey.toString(true)}.` };
+        await newUnit.fromJSON(invertedUnitProps);
+        return { itemKey: newUnit.key };
+    }
+    async setInvertsUnit(invertedUnitKey, invertsUnitKey) {
+        const invertedUnit = await this._schemaEditor.schemaContext.getSchemaItem(invertedUnitKey);
+        if (invertedUnit === undefined)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.ClassNotFound, `Inverted Unit ${invertedUnitKey.fullName} not found in schema context.`);
+        if (invertedUnit.schemaItemType !== ecschema_metadata_1.SchemaItemType.InvertedUnit)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidSchemaItemType, `Expected ${invertedUnitKey.fullName} to be of type Inverted Unit.`);
+        const invertsUnit = await this._schemaEditor.schemaContext.getSchemaItem(invertsUnitKey);
+        if (invertsUnit === undefined)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.ClassNotFound, `Unit ${invertsUnitKey.fullName} not found in schema context.`);
+        if (invertsUnit.schemaItemType !== ecschema_metadata_1.SchemaItemType.Unit)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidSchemaItemType, `Expected ${invertsUnitKey.fullName} to be of type Unit.`);
+        invertedUnit.setInvertsUnit(new ecschema_metadata_1.DelayedPromiseWithProps(invertsUnitKey, async () => invertsUnit));
+    }
+    async setUnitSystem(invertedUnitKey, unitSystemKey) {
+        const invertedUnit = await this._schemaEditor.schemaContext.getSchemaItem(invertedUnitKey);
+        if (invertedUnit === undefined)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.ClassNotFound, `Inverted Unit ${invertedUnitKey.fullName} not found in schema context.`);
+        if (invertedUnit.schemaItemType !== ecschema_metadata_1.SchemaItemType.InvertedUnit)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidSchemaItemType, `Expected ${invertedUnitKey.fullName} to be of type Inverted Unit.`);
+        const unitSystem = await this._schemaEditor.schemaContext.getSchemaItem(unitSystemKey);
+        if (unitSystem === undefined)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.ClassNotFound, `Unit ${unitSystemKey.fullName} not found in schema context.`);
+        if (unitSystem.schemaItemType !== ecschema_metadata_1.SchemaItemType.UnitSystem)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidSchemaItemType, `Expected ${unitSystemKey.fullName} to be of type Unit System.`);
+        invertedUnit.setUnitSystem(new ecschema_metadata_1.DelayedPromiseWithProps(unitSystemKey, async () => unitSystem));
+    }
+}
+exports.InvertedUnits = InvertedUnits;
 //# sourceMappingURL=InvertedUnits.js.map

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

@@ -1,29 +1,29 @@
-/** @packageDocumentation
- * @module Editing
- */
-import { InvertedUnit, KindOfQuantityProps, OverrideFormat, SchemaItemKey, SchemaKey, Unit } from "@itwin/ecschema-metadata";
-import { SchemaContextEditor, SchemaItemEditResults } from "./Editor";
-/**
- * @alpha
- * A class allowing you to create schema items of type KindOfQuantity.
- */
-export declare class KindOfQuantities {
-    protected _schemaEditor: SchemaContextEditor;
-    constructor(_schemaEditor: SchemaContextEditor);
-    createFromProps(schemaKey: SchemaKey, koqProps: KindOfQuantityProps): Promise<SchemaItemEditResults>;
-    /**
-     *
-     * @param koqKey A schemaItemKey of the editing KindOfQuantity.
-     * @param format A schemaItemKey of a Format.
-     * @param isDefault .is set to false when not explicitly passed.
-     */
-    addPresentationFormat(koqKey: SchemaItemKey, format: SchemaItemKey, isDefault?: boolean): Promise<void>;
-    addPresentationOverrideFormat(koqKey: SchemaItemKey, overrideFormat: OverrideFormat, isDefault?: boolean): Promise<void>;
-    /**
-     * @param koqKey A schemaItemKey of the editing KindOfQuantity.
-     * @param parent A SchemaItemKey of the parent Format.
-     * @param unitLabelOverrides The list of Unit (or InvertedUnit) and label overrides. The length of list should be equal to the number of units in the parent Format.
-     */
-    createFormatOverride(koqKey: SchemaItemKey, parent: SchemaItemKey, precision?: number, unitLabelOverrides?: Array<[Unit | InvertedUnit, string | undefined]>): Promise<OverrideFormat>;
-}
+/** @packageDocumentation
+ * @module Editing
+ */
+import { InvertedUnit, KindOfQuantityProps, OverrideFormat, SchemaItemKey, SchemaKey, Unit } from "@itwin/ecschema-metadata";
+import { SchemaContextEditor, SchemaItemEditResults } from "./Editor";
+/**
+ * @alpha
+ * A class allowing you to create schema items of type KindOfQuantity.
+ */
+export declare class KindOfQuantities {
+    protected _schemaEditor: SchemaContextEditor;
+    constructor(_schemaEditor: SchemaContextEditor);
+    createFromProps(schemaKey: SchemaKey, koqProps: KindOfQuantityProps): Promise<SchemaItemEditResults>;
+    /**
+     *
+     * @param koqKey A schemaItemKey of the editing KindOfQuantity.
+     * @param format A schemaItemKey of a Format.
+     * @param isDefault .is set to false when not explicitly passed.
+     */
+    addPresentationFormat(koqKey: SchemaItemKey, format: SchemaItemKey, isDefault?: boolean): Promise<void>;
+    addPresentationOverrideFormat(koqKey: SchemaItemKey, overrideFormat: OverrideFormat, isDefault?: boolean): Promise<void>;
+    /**
+     * @param koqKey A schemaItemKey of the editing KindOfQuantity.
+     * @param parent A SchemaItemKey of the parent Format.
+     * @param unitLabelOverrides The list of Unit (or InvertedUnit) and label overrides. The length of list should be equal to the number of units in the parent Format.
+     */
+    createFormatOverride(koqKey: SchemaItemKey, parent: SchemaItemKey, precision?: number, unitLabelOverrides?: Array<[Unit | InvertedUnit, string | undefined]>): Promise<OverrideFormat>;
+}
 //# sourceMappingURL=KindOfQuantities.d.ts.map

package/lib/cjs/Editing/KindOfQuantities.js

@@ -1,79 +1,79 @@
-"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.KindOfQuantities = void 0;
-const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
-/**
- * @alpha
- * A class allowing you to create schema items of type KindOfQuantity.
- */
-class KindOfQuantities {
-    constructor(_schemaEditor) {
-        this._schemaEditor = _schemaEditor;
-    }
-    async createFromProps(schemaKey, koqProps) {
-        const schema = await this._schemaEditor.getSchema(schemaKey);
-        if (schema === undefined)
-            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
-        if (koqProps.name === undefined)
-            return { errorMessage: `No name was supplied within props.` };
-        const newKoQ = (await schema.createKindOfQuantity(koqProps.name));
-        if (newKoQ === undefined)
-            return { errorMessage: `Failed to create class ${koqProps.name} in schema ${schemaKey.toString(true)}.` };
-        await newKoQ.fromJSON(koqProps);
-        return { itemKey: newKoQ.key };
-    }
-    /**
-     *
-     * @param koqKey A schemaItemKey of the editing KindOfQuantity.
-     * @param format A schemaItemKey of a Format.
-     * @param isDefault .is set to false when not explicitly passed.
-     */
-    async addPresentationFormat(koqKey, format, isDefault = false) {
-        const kindOfQuantity = (await this._schemaEditor.schemaContext.getSchemaItem(koqKey));
-        if (kindOfQuantity === undefined)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.ClassNotFound, `Entity Class ${koqKey.fullName} not found in schema context.`);
-        if (kindOfQuantity.schemaItemType !== ecschema_metadata_1.SchemaItemType.KindOfQuantity)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidSchemaItemType, `Expected ${koqKey.fullName} to be of type Kind Of Quantity.`);
-        const presentationFormat = await (this._schemaEditor.schemaContext.getSchemaItem(format));
-        if (undefined === presentationFormat)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidECJson, `Unable to locate format '${format.fullName}' for the presentation unit on KindOfQuantity ${koqKey.fullName}.`);
-        if (presentationFormat.schemaItemType !== ecschema_metadata_1.SchemaItemType.Format)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidSchemaItemType, `Expected ${presentationFormat.fullName} to be of type Format.`);
-        kindOfQuantity.addPresentationFormat(presentationFormat, isDefault);
-    }
-    async addPresentationOverrideFormat(koqKey, overrideFormat, isDefault = false) {
-        const kindOfQuantity = (await this._schemaEditor.schemaContext.getSchemaItem(koqKey));
-        if (kindOfQuantity === undefined)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.ClassNotFound, `Entity Class ${koqKey.fullName} not found in schema context.`);
-        if (kindOfQuantity.schemaItemType !== ecschema_metadata_1.SchemaItemType.KindOfQuantity)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidSchemaItemType, `Expected ${koqKey.fullName} to be of type Kind Of Quantity.`);
-        kindOfQuantity.addPresentationFormat(overrideFormat, isDefault);
-    }
-    /**
-     * @param koqKey A schemaItemKey of the editing KindOfQuantity.
-     * @param parent A SchemaItemKey of the parent Format.
-     * @param unitLabelOverrides The list of Unit (or InvertedUnit) and label overrides. The length of list should be equal to the number of units in the parent Format.
-     */
-    async createFormatOverride(koqKey, parent, precision, unitLabelOverrides) {
-        const kindOfQuantity = (await this._schemaEditor.schemaContext.getSchemaItem(koqKey));
-        if (kindOfQuantity === undefined)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.ClassNotFound, `Entity Class ${koqKey.fullName} not found in schema context.`);
-        if (kindOfQuantity.schemaItemType !== ecschema_metadata_1.SchemaItemType.KindOfQuantity)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidSchemaItemType, `Expected ${koqKey.fullName} to be of type Kind Of Quantity.`);
-        const parentFormat = await (this._schemaEditor.schemaContext.getSchemaItem(parent));
-        if (undefined === parentFormat)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidECJson, `Unable to locate format '${parent.fullName}' for the presentation unit on KindOfQuantity ${koqKey.fullName}.`);
-        if (parentFormat.schemaItemType !== ecschema_metadata_1.SchemaItemType.Format)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidSchemaItemType, `Expected ${parentFormat.fullName} to be of type Format.`);
-        return new ecschema_metadata_1.OverrideFormat(parentFormat, precision, unitLabelOverrides);
-    }
-}
-exports.KindOfQuantities = KindOfQuantities;
+"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.KindOfQuantities = void 0;
+const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
+/**
+ * @alpha
+ * A class allowing you to create schema items of type KindOfQuantity.
+ */
+class KindOfQuantities {
+    constructor(_schemaEditor) {
+        this._schemaEditor = _schemaEditor;
+    }
+    async createFromProps(schemaKey, koqProps) {
+        const schema = await this._schemaEditor.getSchema(schemaKey);
+        if (schema === undefined)
+            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
+        if (koqProps.name === undefined)
+            return { errorMessage: `No name was supplied within props.` };
+        const newKoQ = (await schema.createKindOfQuantity(koqProps.name));
+        if (newKoQ === undefined)
+            return { errorMessage: `Failed to create class ${koqProps.name} in schema ${schemaKey.toString(true)}.` };
+        await newKoQ.fromJSON(koqProps);
+        return { itemKey: newKoQ.key };
+    }
+    /**
+     *
+     * @param koqKey A schemaItemKey of the editing KindOfQuantity.
+     * @param format A schemaItemKey of a Format.
+     * @param isDefault .is set to false when not explicitly passed.
+     */
+    async addPresentationFormat(koqKey, format, isDefault = false) {
+        const kindOfQuantity = (await this._schemaEditor.schemaContext.getSchemaItem(koqKey));
+        if (kindOfQuantity === undefined)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.ClassNotFound, `Entity Class ${koqKey.fullName} not found in schema context.`);
+        if (kindOfQuantity.schemaItemType !== ecschema_metadata_1.SchemaItemType.KindOfQuantity)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidSchemaItemType, `Expected ${koqKey.fullName} to be of type Kind Of Quantity.`);
+        const presentationFormat = await (this._schemaEditor.schemaContext.getSchemaItem(format));
+        if (undefined === presentationFormat)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidECJson, `Unable to locate format '${format.fullName}' for the presentation unit on KindOfQuantity ${koqKey.fullName}.`);
+        if (presentationFormat.schemaItemType !== ecschema_metadata_1.SchemaItemType.Format)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidSchemaItemType, `Expected ${presentationFormat.fullName} to be of type Format.`);
+        kindOfQuantity.addPresentationFormat(presentationFormat, isDefault);
+    }
+    async addPresentationOverrideFormat(koqKey, overrideFormat, isDefault = false) {
+        const kindOfQuantity = (await this._schemaEditor.schemaContext.getSchemaItem(koqKey));
+        if (kindOfQuantity === undefined)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.ClassNotFound, `Entity Class ${koqKey.fullName} not found in schema context.`);
+        if (kindOfQuantity.schemaItemType !== ecschema_metadata_1.SchemaItemType.KindOfQuantity)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidSchemaItemType, `Expected ${koqKey.fullName} to be of type Kind Of Quantity.`);
+        kindOfQuantity.addPresentationFormat(overrideFormat, isDefault);
+    }
+    /**
+     * @param koqKey A schemaItemKey of the editing KindOfQuantity.
+     * @param parent A SchemaItemKey of the parent Format.
+     * @param unitLabelOverrides The list of Unit (or InvertedUnit) and label overrides. The length of list should be equal to the number of units in the parent Format.
+     */
+    async createFormatOverride(koqKey, parent, precision, unitLabelOverrides) {
+        const kindOfQuantity = (await this._schemaEditor.schemaContext.getSchemaItem(koqKey));
+        if (kindOfQuantity === undefined)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.ClassNotFound, `Entity Class ${koqKey.fullName} not found in schema context.`);
+        if (kindOfQuantity.schemaItemType !== ecschema_metadata_1.SchemaItemType.KindOfQuantity)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidSchemaItemType, `Expected ${koqKey.fullName} to be of type Kind Of Quantity.`);
+        const parentFormat = await (this._schemaEditor.schemaContext.getSchemaItem(parent));
+        if (undefined === parentFormat)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidECJson, `Unable to locate format '${parent.fullName}' for the presentation unit on KindOfQuantity ${koqKey.fullName}.`);
+        if (parentFormat.schemaItemType !== ecschema_metadata_1.SchemaItemType.Format)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidSchemaItemType, `Expected ${parentFormat.fullName} to be of type Format.`);
+        return new ecschema_metadata_1.OverrideFormat(parentFormat, precision, unitLabelOverrides);
+    }
+}
+exports.KindOfQuantities = KindOfQuantities;
 //# sourceMappingURL=KindOfQuantities.js.map

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

@@ -1,23 +1,23 @@
-/** @packageDocumentation
- * @module Editing
- */
-import { MixinProps, RelationshipClass, SchemaItemKey, SchemaKey, StrengthDirection } from "@itwin/ecschema-metadata";
-import { PropertyEditResults, SchemaContextEditor, SchemaItemEditResults } from "./Editor";
-import { ECClasses } from "./ECClasses";
-/**
- * @alpha
- * A class extending ECClasses allowing you to create schema items of type Mixin.
- */
-export declare class Mixins extends ECClasses {
-    constructor(_schemaEditor: SchemaContextEditor);
-    create(schemaKey: SchemaKey, name: string, appliesTo: SchemaItemKey, displayLabel?: string, baseClass?: SchemaItemKey): Promise<SchemaItemEditResults>;
-    /**
-     * Creates a MixinClass through a MixinProps.
-     * @param schemaKey a SchemaKey of the Schema that will house the new object.
-     * @param mixinProps a json object that will be used to populate the new MixinClass. Needs a name value passed in.
-     */
-    createFromProps(schemaKey: SchemaKey, mixinProps: MixinProps): Promise<SchemaItemEditResults>;
-    addMixin(entityKey: SchemaItemKey, mixinKey: SchemaItemKey): Promise<void>;
-    createNavigationProperty(mixinKey: SchemaItemKey, name: string, relationship: string | RelationshipClass, direction: string | StrengthDirection): Promise<PropertyEditResults>;
-}
+/** @packageDocumentation
+ * @module Editing
+ */
+import { MixinProps, RelationshipClass, SchemaItemKey, SchemaKey, StrengthDirection } from "@itwin/ecschema-metadata";
+import { PropertyEditResults, SchemaContextEditor, SchemaItemEditResults } from "./Editor";
+import { ECClasses } from "./ECClasses";
+/**
+ * @alpha
+ * A class extending ECClasses allowing you to create schema items of type Mixin.
+ */
+export declare class Mixins extends ECClasses {
+    constructor(_schemaEditor: SchemaContextEditor);
+    create(schemaKey: SchemaKey, name: string, appliesTo: SchemaItemKey, displayLabel?: string, baseClass?: SchemaItemKey): Promise<SchemaItemEditResults>;
+    /**
+     * Creates a MixinClass through a MixinProps.
+     * @param schemaKey a SchemaKey of the Schema that will house the new object.
+     * @param mixinProps a json object that will be used to populate the new MixinClass. Needs a name value passed in.
+     */
+    createFromProps(schemaKey: SchemaKey, mixinProps: MixinProps): Promise<SchemaItemEditResults>;
+    addMixin(entityKey: SchemaItemKey, mixinKey: SchemaItemKey): Promise<void>;
+    createNavigationProperty(mixinKey: SchemaItemKey, name: string, relationship: string | RelationshipClass, direction: string | StrengthDirection): Promise<PropertyEditResults>;
+}
 //# sourceMappingURL=Mixins.d.ts.map

package/lib/cjs/Editing/Mixins.js

@@ -1,85 +1,85 @@
-"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.Mixins = 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 Mixin.
- */
-class Mixins extends ECClasses_1.ECClasses {
-    constructor(_schemaEditor) {
-        super(_schemaEditor);
-    }
-    async create(schemaKey, name, appliesTo, displayLabel, baseClass) {
-        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.createMixinClass(name));
-        if (newClass === undefined)
-            return { errorMessage: `Failed to create class ${name} in schema ${schemaKey.toString(true)}.` };
-        if (baseClass !== undefined) {
-            const baseClassItem = await schema.lookupItem(baseClass);
-            if (baseClassItem === undefined)
-                return { errorMessage: `Unable to locate base class ${baseClass.fullName} in schema ${schema.fullName}.` };
-            if (baseClassItem.schemaItemType !== ecschema_metadata_1.SchemaItemType.Mixin)
-                return { errorMessage: `${baseClassItem.fullName} is not of type Mixin.` };
-            newClass.baseClass = new ecschema_metadata_1.DelayedPromiseWithProps(baseClass, async () => baseClassItem);
-        }
-        const newAppliesTo = (await this._schemaEditor.schemaContext.getSchemaItem(appliesTo));
-        if (newAppliesTo === undefined || newAppliesTo.schemaItemType !== ecschema_metadata_1.SchemaItemType.EntityClass)
-            return { errorMessage: `Failed to locate the appliedTo entity class ${appliesTo.name}.` };
-        newClass.setAppliesTo(new ecschema_metadata_1.DelayedPromiseWithProps(newAppliesTo.key, async () => newAppliesTo));
-        if (displayLabel)
-            newClass.setDisplayLabel(displayLabel);
-        return { itemKey: newClass.key };
-    }
-    /**
-     * Creates a MixinClass through a MixinProps.
-     * @param schemaKey a SchemaKey of the Schema that will house the new object.
-     * @param mixinProps a json object that will be used to populate the new MixinClass. Needs a name value passed in.
-     */
-    async createFromProps(schemaKey, mixinProps) {
-        const schema = await this._schemaEditor.getSchema(schemaKey);
-        if (schema === undefined)
-            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
-        if (mixinProps.name === undefined)
-            return { errorMessage: `No name was supplied within props.` };
-        const newClass = (await schema.createMixinClass(mixinProps.name));
-        if (newClass === undefined)
-            return { errorMessage: `Failed to create class ${mixinProps.name} in schema ${schemaKey.toString(true)}.` };
-        await newClass.fromJSON(mixinProps);
-        return { itemKey: newClass.key };
-    }
-    async addMixin(entityKey, mixinKey) {
-        const entity = (await this._schemaEditor.schemaContext.getSchemaItem(entityKey));
-        const mixin = (await this._schemaEditor.schemaContext.getSchemaItem(mixinKey));
-        if (entity === undefined)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.ClassNotFound, `Entity Class ${entityKey.fullName} not found in schema context.`);
-        if (mixin === undefined)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.ClassNotFound, `Mixin Class ${mixinKey.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.`);
-        if (mixin.schemaItemType !== ecschema_metadata_1.SchemaItemType.Mixin)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidSchemaItemType, `Expected ${mixinKey.fullName} to be of type Mixin.`);
-        entity.addMixin(mixin);
-    }
-    async createNavigationProperty(mixinKey, name, relationship, direction) {
-        const mixin = (await this._schemaEditor.schemaContext.getSchemaItem(mixinKey));
-        if (mixin === undefined)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.ClassNotFound, `Mixin Class ${mixinKey.fullName} not found in schema context.`);
-        if (mixin.schemaItemType !== ecschema_metadata_1.SchemaItemType.Mixin)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidSchemaItemType, `Expected ${mixinKey.fullName} to be of type Mixin.`);
-        await mixin.createNavigationProperty(name, relationship, direction);
-        return { itemKey: mixinKey, propertyName: name };
-    }
-}
-exports.Mixins = Mixins;
+"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.Mixins = 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 Mixin.
+ */
+class Mixins extends ECClasses_1.ECClasses {
+    constructor(_schemaEditor) {
+        super(_schemaEditor);
+    }
+    async create(schemaKey, name, appliesTo, displayLabel, baseClass) {
+        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.createMixinClass(name));
+        if (newClass === undefined)
+            return { errorMessage: `Failed to create class ${name} in schema ${schemaKey.toString(true)}.` };
+        if (baseClass !== undefined) {
+            const baseClassItem = await schema.lookupItem(baseClass);
+            if (baseClassItem === undefined)
+                return { errorMessage: `Unable to locate base class ${baseClass.fullName} in schema ${schema.fullName}.` };
+            if (baseClassItem.schemaItemType !== ecschema_metadata_1.SchemaItemType.Mixin)
+                return { errorMessage: `${baseClassItem.fullName} is not of type Mixin.` };
+            newClass.baseClass = new ecschema_metadata_1.DelayedPromiseWithProps(baseClass, async () => baseClassItem);
+        }
+        const newAppliesTo = (await this._schemaEditor.schemaContext.getSchemaItem(appliesTo));
+        if (newAppliesTo === undefined || newAppliesTo.schemaItemType !== ecschema_metadata_1.SchemaItemType.EntityClass)
+            return { errorMessage: `Failed to locate the appliedTo entity class ${appliesTo.name}.` };
+        newClass.setAppliesTo(new ecschema_metadata_1.DelayedPromiseWithProps(newAppliesTo.key, async () => newAppliesTo));
+        if (displayLabel)
+            newClass.setDisplayLabel(displayLabel);
+        return { itemKey: newClass.key };
+    }
+    /**
+     * Creates a MixinClass through a MixinProps.
+     * @param schemaKey a SchemaKey of the Schema that will house the new object.
+     * @param mixinProps a json object that will be used to populate the new MixinClass. Needs a name value passed in.
+     */
+    async createFromProps(schemaKey, mixinProps) {
+        const schema = await this._schemaEditor.getSchema(schemaKey);
+        if (schema === undefined)
+            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
+        if (mixinProps.name === undefined)
+            return { errorMessage: `No name was supplied within props.` };
+        const newClass = (await schema.createMixinClass(mixinProps.name));
+        if (newClass === undefined)
+            return { errorMessage: `Failed to create class ${mixinProps.name} in schema ${schemaKey.toString(true)}.` };
+        await newClass.fromJSON(mixinProps);
+        return { itemKey: newClass.key };
+    }
+    async addMixin(entityKey, mixinKey) {
+        const entity = (await this._schemaEditor.schemaContext.getSchemaItem(entityKey));
+        const mixin = (await this._schemaEditor.schemaContext.getSchemaItem(mixinKey));
+        if (entity === undefined)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.ClassNotFound, `Entity Class ${entityKey.fullName} not found in schema context.`);
+        if (mixin === undefined)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.ClassNotFound, `Mixin Class ${mixinKey.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.`);
+        if (mixin.schemaItemType !== ecschema_metadata_1.SchemaItemType.Mixin)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidSchemaItemType, `Expected ${mixinKey.fullName} to be of type Mixin.`);
+        entity.addMixin(mixin);
+    }
+    async createNavigationProperty(mixinKey, name, relationship, direction) {
+        const mixin = (await this._schemaEditor.schemaContext.getSchemaItem(mixinKey));
+        if (mixin === undefined)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.ClassNotFound, `Mixin Class ${mixinKey.fullName} not found in schema context.`);
+        if (mixin.schemaItemType !== ecschema_metadata_1.SchemaItemType.Mixin)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidSchemaItemType, `Expected ${mixinKey.fullName} to be of type Mixin.`);
+        await mixin.createNavigationProperty(name, relationship, direction);
+        return { itemKey: mixinKey, propertyName: name };
+    }
+}
+exports.Mixins = Mixins;
 //# sourceMappingURL=Mixins.js.map

package/lib/cjs/Editing/Mutable/MutableCAClass.d.ts

@@ -1,10 +1,10 @@
-import { CustomAttributeClass, CustomAttributeContainerType } from "@itwin/ecschema-metadata";
-/**
- * @internal
- * An abstract class used for Schema editing.
- */
-export declare abstract class MutableCAClass extends CustomAttributeClass {
-    abstract setContainerType(containerType: CustomAttributeContainerType): void;
-    abstract setDisplayLabel(displayLabel: string): void;
-}
+import { CustomAttributeClass, CustomAttributeContainerType } from "@itwin/ecschema-metadata";
+/**
+ * @internal
+ * An abstract class used for Schema editing.
+ */
+export declare abstract class MutableCAClass extends CustomAttributeClass {
+    abstract setContainerType(containerType: CustomAttributeContainerType): void;
+    abstract setDisplayLabel(displayLabel: string): void;
+}
 //# sourceMappingURL=MutableCAClass.d.ts.map