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

package/lib/cjs/Editing/Phenomena.js

@@ -1,45 +1,45 @@
-"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.Phenomena = void 0;
-/**
- * @alpha
- * A class allowing you to create schema items of type Phenomenon.
- */
-class Phenomena {
-    constructor(_schemaEditor) {
-        this._schemaEditor = _schemaEditor;
-    }
-    async create(schemaKey, name, definition, displayLabel) {
-        const schema = await this._schemaEditor.getSchema(schemaKey);
-        if (schema === undefined)
-            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
-        const newPhenomenon = (await schema.createPhenomenon(name));
-        if (newPhenomenon === undefined)
-            return { errorMessage: `Failed to create class ${name} in schema ${schemaKey.toString(true)}.` };
-        if (displayLabel)
-            newPhenomenon.setDisplayLabel(displayLabel);
-        await newPhenomenon.setDefinition(definition);
-        return { itemKey: newPhenomenon.key };
-    }
-    async createFromProps(schemaKey, phenomenonProps) {
-        const schema = await this._schemaEditor.getSchema(schemaKey);
-        if (schema === undefined)
-            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
-        if (phenomenonProps.name === undefined)
-            return { errorMessage: `No name was supplied within props.` };
-        const newPhenomenon = (await schema.createPhenomenon(phenomenonProps.name));
-        if (newPhenomenon === undefined)
-            return { errorMessage: `Failed to create class ${phenomenonProps.name} in schema ${schemaKey.toString(true)}.` };
-        await newPhenomenon.fromJSON(phenomenonProps);
-        return { itemKey: newPhenomenon.key };
-    }
-}
-exports.Phenomena = Phenomena;
+"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.Phenomena = void 0;
+/**
+ * @alpha
+ * A class allowing you to create schema items of type Phenomenon.
+ */
+class Phenomena {
+    constructor(_schemaEditor) {
+        this._schemaEditor = _schemaEditor;
+    }
+    async create(schemaKey, name, definition, displayLabel) {
+        const schema = await this._schemaEditor.getSchema(schemaKey);
+        if (schema === undefined)
+            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
+        const newPhenomenon = (await schema.createPhenomenon(name));
+        if (newPhenomenon === undefined)
+            return { errorMessage: `Failed to create class ${name} in schema ${schemaKey.toString(true)}.` };
+        if (displayLabel)
+            newPhenomenon.setDisplayLabel(displayLabel);
+        await newPhenomenon.setDefinition(definition);
+        return { itemKey: newPhenomenon.key };
+    }
+    async createFromProps(schemaKey, phenomenonProps) {
+        const schema = await this._schemaEditor.getSchema(schemaKey);
+        if (schema === undefined)
+            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
+        if (phenomenonProps.name === undefined)
+            return { errorMessage: `No name was supplied within props.` };
+        const newPhenomenon = (await schema.createPhenomenon(phenomenonProps.name));
+        if (newPhenomenon === undefined)
+            return { errorMessage: `Failed to create class ${phenomenonProps.name} in schema ${schemaKey.toString(true)}.` };
+        await newPhenomenon.fromJSON(phenomenonProps);
+        return { itemKey: newPhenomenon.key };
+    }
+}
+exports.Phenomena = Phenomena;
 //# sourceMappingURL=Phenomena.js.map

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

@@ -1,17 +1,17 @@
-/** @packageDocumentation
- * @module Editing
- */
-import { PropertyCategoryProps, SchemaItemKey, SchemaKey } from "@itwin/ecschema-metadata";
-import { SchemaContextEditor, SchemaItemEditResults } from "./Editor";
-/**
- * @alpha
- * A class allowing you to create schema items of type Property Category.
- */
-export declare class PropertyCategories {
-    protected _schemaEditor: SchemaContextEditor;
-    constructor(_schemaEditor: SchemaContextEditor);
-    create(schemaKey: SchemaKey, name: string, priority: number, displayLabel?: string): Promise<SchemaItemEditResults>;
-    createFromProps(schemaKey: SchemaKey, propertyCategoryProps: PropertyCategoryProps): Promise<SchemaItemEditResults>;
-    setPriority(propCategoryKey: SchemaItemKey, priority: number): Promise<void>;
-}
+/** @packageDocumentation
+ * @module Editing
+ */
+import { PropertyCategoryProps, SchemaItemKey, SchemaKey } from "@itwin/ecschema-metadata";
+import { SchemaContextEditor, SchemaItemEditResults } from "./Editor";
+/**
+ * @alpha
+ * A class allowing you to create schema items of type Property Category.
+ */
+export declare class PropertyCategories {
+    protected _schemaEditor: SchemaContextEditor;
+    constructor(_schemaEditor: SchemaContextEditor);
+    create(schemaKey: SchemaKey, name: string, priority: number, displayLabel?: string): Promise<SchemaItemEditResults>;
+    createFromProps(schemaKey: SchemaKey, propertyCategoryProps: PropertyCategoryProps): Promise<SchemaItemEditResults>;
+    setPriority(propCategoryKey: SchemaItemKey, priority: number): Promise<void>;
+}
 //# sourceMappingURL=PropertyCategories.d.ts.map

package/lib/cjs/Editing/PropertyCategories.js

@@ -1,52 +1,52 @@
-"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.PropertyCategories = void 0;
-const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
-/**
- * @alpha
- * A class allowing you to create schema items of type Property Category.
- */
-class PropertyCategories {
-    constructor(_schemaEditor) {
-        this._schemaEditor = _schemaEditor;
-    }
-    async create(schemaKey, name, priority, displayLabel) {
-        const schema = await this._schemaEditor.getSchema(schemaKey);
-        if (schema === undefined)
-            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
-        const newPropCategory = (await schema.createPropertyCategory(name));
-        newPropCategory.setPriority(priority);
-        if (displayLabel)
-            newPropCategory.setDisplayLabel(displayLabel);
-        return { itemKey: newPropCategory.key };
-    }
-    async createFromProps(schemaKey, propertyCategoryProps) {
-        const schema = await this._schemaEditor.getSchema(schemaKey);
-        if (schema === undefined)
-            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
-        if (propertyCategoryProps.name === undefined)
-            return { errorMessage: `No name was supplied within props.` };
-        const newPropCategory = (await schema.createPropertyCategory(propertyCategoryProps.name));
-        if (newPropCategory === undefined)
-            return { errorMessage: `Failed to create class ${propertyCategoryProps.name} in schema ${schemaKey.toString(true)}.` };
-        await newPropCategory.fromJSON(propertyCategoryProps);
-        return { itemKey: newPropCategory.key };
-    }
-    async setPriority(propCategoryKey, priority) {
-        const propertyCategory = (await this._schemaEditor.schemaContext.getSchemaItem(propCategoryKey));
-        if (propertyCategory === undefined)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.ClassNotFound, `Property Category ${propCategoryKey.fullName} not found in schema context.`);
-        if (propertyCategory.schemaItemType !== ecschema_metadata_1.SchemaItemType.PropertyCategory)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidSchemaItemType, `Expected ${propCategoryKey.fullName} to be of type Property Category.`);
-        propertyCategory.setPriority(priority);
-    }
-}
-exports.PropertyCategories = PropertyCategories;
+"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.PropertyCategories = void 0;
+const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
+/**
+ * @alpha
+ * A class allowing you to create schema items of type Property Category.
+ */
+class PropertyCategories {
+    constructor(_schemaEditor) {
+        this._schemaEditor = _schemaEditor;
+    }
+    async create(schemaKey, name, priority, displayLabel) {
+        const schema = await this._schemaEditor.getSchema(schemaKey);
+        if (schema === undefined)
+            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
+        const newPropCategory = (await schema.createPropertyCategory(name));
+        newPropCategory.setPriority(priority);
+        if (displayLabel)
+            newPropCategory.setDisplayLabel(displayLabel);
+        return { itemKey: newPropCategory.key };
+    }
+    async createFromProps(schemaKey, propertyCategoryProps) {
+        const schema = await this._schemaEditor.getSchema(schemaKey);
+        if (schema === undefined)
+            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
+        if (propertyCategoryProps.name === undefined)
+            return { errorMessage: `No name was supplied within props.` };
+        const newPropCategory = (await schema.createPropertyCategory(propertyCategoryProps.name));
+        if (newPropCategory === undefined)
+            return { errorMessage: `Failed to create class ${propertyCategoryProps.name} in schema ${schemaKey.toString(true)}.` };
+        await newPropCategory.fromJSON(propertyCategoryProps);
+        return { itemKey: newPropCategory.key };
+    }
+    async setPriority(propCategoryKey, priority) {
+        const propertyCategory = (await this._schemaEditor.schemaContext.getSchemaItem(propCategoryKey));
+        if (propertyCategory === undefined)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.ClassNotFound, `Property Category ${propCategoryKey.fullName} not found in schema context.`);
+        if (propertyCategory.schemaItemType !== ecschema_metadata_1.SchemaItemType.PropertyCategory)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidSchemaItemType, `Expected ${propCategoryKey.fullName} to be of type Property Category.`);
+        propertyCategory.setPriority(priority);
+    }
+}
+exports.PropertyCategories = PropertyCategories;
 //# sourceMappingURL=PropertyCategories.js.map

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

@@ -1,22 +1,22 @@
-/** @packageDocumentation
- * @module Editing
- */
-import { RelationshipClass, RelationshipClassProps, 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 RelationshipClass.
- * Can only create RelationshipClass objects using RelationshipClassProps for now.
- */
-export declare class RelationshipClasses extends ECClasses {
-    constructor(_schemaEditor: SchemaContextEditor);
-    /**
-     * Creates a RelationshipClass through a RelationshipClassProps.
-     * @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, relationshipProps: RelationshipClassProps): Promise<SchemaItemEditResults>;
-    createNavigationProperty(relationshipKey: SchemaItemKey, name: string, relationship: string | RelationshipClass, direction: string | StrengthDirection): Promise<PropertyEditResults>;
-}
+/** @packageDocumentation
+ * @module Editing
+ */
+import { RelationshipClass, RelationshipClassProps, 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 RelationshipClass.
+ * Can only create RelationshipClass objects using RelationshipClassProps for now.
+ */
+export declare class RelationshipClasses extends ECClasses {
+    constructor(_schemaEditor: SchemaContextEditor);
+    /**
+     * Creates a RelationshipClass through a RelationshipClassProps.
+     * @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, relationshipProps: RelationshipClassProps): Promise<SchemaItemEditResults>;
+    createNavigationProperty(relationshipKey: SchemaItemKey, name: string, relationship: string | RelationshipClass, direction: string | StrengthDirection): Promise<PropertyEditResults>;
+}
 //# sourceMappingURL=RelationshipClasses.d.ts.map

package/lib/cjs/Editing/RelationshipClasses.js

@@ -1,69 +1,69 @@
-"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.RelationshipClasses = 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 RelationshipClass.
- * Can only create RelationshipClass objects using RelationshipClassProps for now.
- */
-class RelationshipClasses extends ECClasses_1.ECClasses {
-    constructor(_schemaEditor) {
-        super(_schemaEditor);
-    }
-    // // TODO: Add relationshipConstraint, multiplicity arguments.
-    // // Note: This method is not done yet, there's a lot of arguments.
-    // public async create(schemaKey: SchemaKey, name: string, modifier: ECClassModifier, strength: StrengthType, direction: StrengthDirection, sourceMultiplicity: RelationshipMultiplicity, targetMultiplicity: RelationshipMultiplicity, baseClass?: SchemaItemKey) {
-    //   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.createRelationshipClass(name, modifier)) as MutableRelationshipClass;
-    //   if (newClass === undefined) {
-    //     return { errorMessage: `Failed to create class ${name} in schema ${schemaKey.toString(true)}.` };
-    //   }
-    //   if (baseClass !== undefined) {
-    //     const baseClassItem = await schema.lookupItem(baseClass) as RelationshipClass;
-    //     newClass.baseClass = new DelayedPromiseWithProps<SchemaItemKey, ECClass>(baseClass, async () => baseClassItem);
-    //   }
-    //   newClass.setStrength(strength);
-    //   newClass.setStrengthDirection(direction);
-    //   return { itemKey: newClass.key };
-    // }
-    /**
-     * Creates a RelationshipClass through a RelationshipClassProps.
-     * @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, relationshipProps) {
-        const schema = await this._schemaEditor.getSchema(schemaKey);
-        if (schema === undefined)
-            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
-        if (relationshipProps.name === undefined)
-            return { errorMessage: `No name was supplied within props.` };
-        const newClass = (await schema.createRelationshipClass(relationshipProps.name));
-        if (newClass === undefined)
-            return { errorMessage: `Failed to create class ${relationshipProps.name} in schema ${schemaKey.toString(true)}.` };
-        await newClass.fromJSON(relationshipProps);
-        await newClass.source.fromJSON(relationshipProps.source);
-        await newClass.target.fromJSON(relationshipProps.target);
-        return { itemKey: newClass.key };
-    }
-    async createNavigationProperty(relationshipKey, name, relationship, direction) {
-        const relationshipClass = (await this._schemaEditor.schemaContext.getSchemaItem(relationshipKey));
-        if (relationshipClass === undefined)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.ClassNotFound, `Relationship Class ${relationshipKey.fullName} not found in schema context.`);
-        if (relationshipClass.schemaItemType !== ecschema_metadata_1.SchemaItemType.RelationshipClass)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidSchemaItemType, `Expected ${relationshipKey.fullName} to be of type Relationship Class.`);
-        await relationshipClass.createNavigationProperty(name, relationship, direction);
-        return { itemKey: relationshipKey, propertyName: name };
-    }
-}
-exports.RelationshipClasses = RelationshipClasses;
+"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.RelationshipClasses = 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 RelationshipClass.
+ * Can only create RelationshipClass objects using RelationshipClassProps for now.
+ */
+class RelationshipClasses extends ECClasses_1.ECClasses {
+    constructor(_schemaEditor) {
+        super(_schemaEditor);
+    }
+    // // TODO: Add relationshipConstraint, multiplicity arguments.
+    // // Note: This method is not done yet, there's a lot of arguments.
+    // public async create(schemaKey: SchemaKey, name: string, modifier: ECClassModifier, strength: StrengthType, direction: StrengthDirection, sourceMultiplicity: RelationshipMultiplicity, targetMultiplicity: RelationshipMultiplicity, baseClass?: SchemaItemKey) {
+    //   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.createRelationshipClass(name, modifier)) as MutableRelationshipClass;
+    //   if (newClass === undefined) {
+    //     return { errorMessage: `Failed to create class ${name} in schema ${schemaKey.toString(true)}.` };
+    //   }
+    //   if (baseClass !== undefined) {
+    //     const baseClassItem = await schema.lookupItem(baseClass) as RelationshipClass;
+    //     newClass.baseClass = new DelayedPromiseWithProps<SchemaItemKey, ECClass>(baseClass, async () => baseClassItem);
+    //   }
+    //   newClass.setStrength(strength);
+    //   newClass.setStrengthDirection(direction);
+    //   return { itemKey: newClass.key };
+    // }
+    /**
+     * Creates a RelationshipClass through a RelationshipClassProps.
+     * @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, relationshipProps) {
+        const schema = await this._schemaEditor.getSchema(schemaKey);
+        if (schema === undefined)
+            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
+        if (relationshipProps.name === undefined)
+            return { errorMessage: `No name was supplied within props.` };
+        const newClass = (await schema.createRelationshipClass(relationshipProps.name));
+        if (newClass === undefined)
+            return { errorMessage: `Failed to create class ${relationshipProps.name} in schema ${schemaKey.toString(true)}.` };
+        await newClass.fromJSON(relationshipProps);
+        await newClass.source.fromJSON(relationshipProps.source);
+        await newClass.target.fromJSON(relationshipProps.target);
+        return { itemKey: newClass.key };
+    }
+    async createNavigationProperty(relationshipKey, name, relationship, direction) {
+        const relationshipClass = (await this._schemaEditor.schemaContext.getSchemaItem(relationshipKey));
+        if (relationshipClass === undefined)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.ClassNotFound, `Relationship Class ${relationshipKey.fullName} not found in schema context.`);
+        if (relationshipClass.schemaItemType !== ecschema_metadata_1.SchemaItemType.RelationshipClass)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidSchemaItemType, `Expected ${relationshipKey.fullName} to be of type Relationship Class.`);
+        await relationshipClass.createNavigationProperty(name, relationship, direction);
+        return { itemKey: relationshipKey, propertyName: name };
+    }
+}
+exports.RelationshipClasses = RelationshipClasses;
 //# sourceMappingURL=RelationshipClasses.js.map

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

@@ -1,20 +1,20 @@
-/** @packageDocumentation
- * @module Editing
- */
-import { SchemaItemKey, SchemaKey, StructClassProps } from "@itwin/ecschema-metadata";
-import { SchemaContextEditor, SchemaItemEditResults } from "./Editor";
-import { ECClasses } from "./ECClasses";
-/**
- * @alpha A class extending ECClasses allowing you to create schema items of type StructClass.
- */
-export declare class Structs extends ECClasses {
-    constructor(_schemaEditor: SchemaContextEditor);
-    create(schemaKey: SchemaKey, name: string, displayLabel?: string, baseClass?: SchemaItemKey): Promise<SchemaItemEditResults>;
-    /**
-     *  Creates a StructClass through a StructClassProps.
-     * @param schemaKey a SchemaKey of the Schema that will house the new object.
-     * @param structProps a json object that will be used to populate the new StructClass. Needs a name value passed in.
-     */
-    createFromProps(schemaKey: SchemaKey, structProps: StructClassProps): Promise<SchemaItemEditResults>;
-}
+/** @packageDocumentation
+ * @module Editing
+ */
+import { SchemaItemKey, SchemaKey, StructClassProps } from "@itwin/ecschema-metadata";
+import { SchemaContextEditor, SchemaItemEditResults } from "./Editor";
+import { ECClasses } from "./ECClasses";
+/**
+ * @alpha A class extending ECClasses allowing you to create schema items of type StructClass.
+ */
+export declare class Structs extends ECClasses {
+    constructor(_schemaEditor: SchemaContextEditor);
+    create(schemaKey: SchemaKey, name: string, displayLabel?: string, baseClass?: SchemaItemKey): Promise<SchemaItemEditResults>;
+    /**
+     *  Creates a StructClass through a StructClassProps.
+     * @param schemaKey a SchemaKey of the Schema that will house the new object.
+     * @param structProps a json object that will be used to populate the new StructClass. Needs a name value passed in.
+     */
+    createFromProps(schemaKey: SchemaKey, structProps: StructClassProps): Promise<SchemaItemEditResults>;
+}
 //# sourceMappingURL=Structs.d.ts.map

package/lib/cjs/Editing/Structs.js

@@ -1,58 +1,58 @@
-"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.Structs = 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 StructClass.
- */
-class Structs extends ECClasses_1.ECClasses {
-    constructor(_schemaEditor) {
-        super(_schemaEditor);
-    }
-    async create(schemaKey, name, 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.createStructClass(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.StructClass)
-                return { errorMessage: `${baseClassItem.fullName} is not of type Struct Class.` };
-            newClass.baseClass = new ecschema_metadata_1.DelayedPromiseWithProps(baseClass, async () => baseClassItem);
-        }
-        if (displayLabel)
-            newClass.setDisplayLabel(displayLabel);
-        return { itemKey: newClass.key };
-    }
-    /**
-     *  Creates a StructClass through a StructClassProps.
-     * @param schemaKey a SchemaKey of the Schema that will house the new object.
-     * @param structProps a json object that will be used to populate the new StructClass. Needs a name value passed in.
-     */
-    async createFromProps(schemaKey, structProps) {
-        const schema = await this._schemaEditor.getSchema(schemaKey);
-        if (schema === undefined)
-            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
-        if (structProps.name === undefined)
-            return { errorMessage: `No name was supplied within props.` };
-        const newClass = (await schema.createStructClass(structProps.name));
-        if (newClass === undefined)
-            return { errorMessage: `Failed to create class ${structProps.name} in schema ${schemaKey.toString(true)}.` };
-        await newClass.fromJSON(structProps);
-        return { itemKey: newClass.key };
-    }
-}
-exports.Structs = Structs;
+"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.Structs = 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 StructClass.
+ */
+class Structs extends ECClasses_1.ECClasses {
+    constructor(_schemaEditor) {
+        super(_schemaEditor);
+    }
+    async create(schemaKey, name, 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.createStructClass(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.StructClass)
+                return { errorMessage: `${baseClassItem.fullName} is not of type Struct Class.` };
+            newClass.baseClass = new ecschema_metadata_1.DelayedPromiseWithProps(baseClass, async () => baseClassItem);
+        }
+        if (displayLabel)
+            newClass.setDisplayLabel(displayLabel);
+        return { itemKey: newClass.key };
+    }
+    /**
+     *  Creates a StructClass through a StructClassProps.
+     * @param schemaKey a SchemaKey of the Schema that will house the new object.
+     * @param structProps a json object that will be used to populate the new StructClass. Needs a name value passed in.
+     */
+    async createFromProps(schemaKey, structProps) {
+        const schema = await this._schemaEditor.getSchema(schemaKey);
+        if (schema === undefined)
+            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
+        if (structProps.name === undefined)
+            return { errorMessage: `No name was supplied within props.` };
+        const newClass = (await schema.createStructClass(structProps.name));
+        if (newClass === undefined)
+            return { errorMessage: `Failed to create class ${structProps.name} in schema ${schemaKey.toString(true)}.` };
+        await newClass.fromJSON(structProps);
+        return { itemKey: newClass.key };
+    }
+}
+exports.Structs = Structs;
 //# sourceMappingURL=Structs.js.map

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

@@ -1,16 +1,16 @@
-/** @packageDocumentation
- * @module Editing
- */
-import { SchemaKey, UnitSystemProps } from "@itwin/ecschema-metadata";
-import { SchemaContextEditor, SchemaItemEditResults } from "./Editor";
-/**
- * @alpha
- * A class allowing you to create schema items of type UnitSystems.
- */
-export declare class UnitSystems {
-    protected _schemaEditor: SchemaContextEditor;
-    constructor(_schemaEditor: SchemaContextEditor);
-    create(schemaKey: SchemaKey, name: string, displayLabel?: string): Promise<SchemaItemEditResults>;
-    createFromProps(schemaKey: SchemaKey, unitSystemProps: UnitSystemProps): Promise<SchemaItemEditResults>;
-}
+/** @packageDocumentation
+ * @module Editing
+ */
+import { SchemaKey, UnitSystemProps } from "@itwin/ecschema-metadata";
+import { SchemaContextEditor, SchemaItemEditResults } from "./Editor";
+/**
+ * @alpha
+ * A class allowing you to create schema items of type UnitSystems.
+ */
+export declare class UnitSystems {
+    protected _schemaEditor: SchemaContextEditor;
+    constructor(_schemaEditor: SchemaContextEditor);
+    create(schemaKey: SchemaKey, name: string, displayLabel?: string): Promise<SchemaItemEditResults>;
+    createFromProps(schemaKey: SchemaKey, unitSystemProps: UnitSystemProps): Promise<SchemaItemEditResults>;
+}
 //# sourceMappingURL=UnitSystems.d.ts.map