@itwin/ecschema-editing 4.0.0-dev.10 → 4.0.0-dev.100

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

package/lib/cjs/Editing/Mutable/MutableCAClass.js

@@ -1,16 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MutableCAClass = void 0;
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
-/**
- * @internal
- * An abstract class used for Schema editing.
- */
-class MutableCAClass extends ecschema_metadata_1.CustomAttributeClass {
-}
-exports.MutableCAClass = MutableCAClass;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MutableCAClass = void 0;
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
+/**
+ * @internal
+ * An abstract class used for Schema editing.
+ */
+class MutableCAClass extends ecschema_metadata_1.CustomAttributeClass {
+}
+exports.MutableCAClass = MutableCAClass;
 //# sourceMappingURL=MutableCAClass.js.map

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

@@ -1,35 +1,35 @@
-import { CustomAttribute, ECClass, ECClassModifier, Enumeration, EnumerationArrayProperty, EnumerationProperty, PrimitiveArrayProperty, PrimitiveProperty, PrimitiveType, Property, StructArrayProperty, StructClass, StructProperty } from "@itwin/ecschema-metadata";
-/**
- * @internal
- * An abstract class used for schema editing.
- */
-export declare abstract class MutableStructClass extends StructClass {
-    abstract setDisplayLabel(displayLabel: string): void;
-}
-/**
- * Hackish approach that works like a "friend class" so we can access protected members without making them public.
- * @internal
- */
-export declare abstract class MutableClass extends ECClass {
-    abstract addCustomAttribute(customAttribute: CustomAttribute): void;
-    abstract setModifier(modifier: ECClassModifier): void;
-    abstract createPrimitiveProperty(name: string, primitiveType: PrimitiveType): Promise<PrimitiveProperty>;
-    abstract createPrimitiveProperty(name: string, primitiveType: Enumeration): Promise<EnumerationProperty>;
-    abstract createPrimitiveProperty(name: string, primitiveType?: string | PrimitiveType | Enumeration): Promise<Property>;
-    abstract createPrimitivePropertySync(name: string, primitiveType: PrimitiveType): PrimitiveProperty;
-    abstract createPrimitivePropertySync(name: string, primitiveType: Enumeration): EnumerationProperty;
-    abstract createPrimitivePropertySync(name: string, primitiveType?: string | PrimitiveType | Enumeration): Property;
-    abstract createPrimitiveArrayProperty(name: string, primitiveType: PrimitiveType): Promise<PrimitiveArrayProperty>;
-    abstract createPrimitiveArrayProperty(name: string, primitiveType: Enumeration): Promise<EnumerationArrayProperty>;
-    abstract createPrimitiveArrayProperty(name: string, primitiveType?: string | PrimitiveType | Enumeration): Promise<Property>;
-    abstract createPrimitiveArrayPropertySync(name: string, primitiveType: PrimitiveType): PrimitiveArrayProperty;
-    abstract createPrimitiveArrayPropertySync(name: string, primitiveType: Enumeration): EnumerationArrayProperty;
-    abstract createPrimitiveArrayPropertySync(name: string, primitiveType?: string | PrimitiveType | Enumeration): Property;
-    abstract createStructProperty(name: string, structType: string | StructClass): Promise<StructProperty>;
-    abstract createStructPropertySync(name: string, structType: string | StructClass): StructProperty;
-    abstract createStructArrayProperty(name: string, structType: string | StructClass): Promise<StructArrayProperty>;
-    abstract createStructArrayPropertySync(name: string, structType: string | StructClass): StructArrayProperty;
-    abstract deleteProperty(name: string): Promise<void>;
-    abstract deletePropertySync(name: string): void;
-}
+import { CustomAttribute, ECClass, ECClassModifier, Enumeration, EnumerationArrayProperty, EnumerationProperty, PrimitiveArrayProperty, PrimitiveProperty, PrimitiveType, Property, StructArrayProperty, StructClass, StructProperty } from "@itwin/ecschema-metadata";
+/**
+ * @internal
+ * An abstract class used for schema editing.
+ */
+export declare abstract class MutableStructClass extends StructClass {
+    abstract setDisplayLabel(displayLabel: string): void;
+}
+/**
+ * Hackish approach that works like a "friend class" so we can access protected members without making them public.
+ * @internal
+ */
+export declare abstract class MutableClass extends ECClass {
+    abstract addCustomAttribute(customAttribute: CustomAttribute): void;
+    abstract setModifier(modifier: ECClassModifier): void;
+    abstract createPrimitiveProperty(name: string, primitiveType: PrimitiveType): Promise<PrimitiveProperty>;
+    abstract createPrimitiveProperty(name: string, primitiveType: Enumeration): Promise<EnumerationProperty>;
+    abstract createPrimitiveProperty(name: string, primitiveType?: string | PrimitiveType | Enumeration): Promise<Property>;
+    abstract createPrimitivePropertySync(name: string, primitiveType: PrimitiveType): PrimitiveProperty;
+    abstract createPrimitivePropertySync(name: string, primitiveType: Enumeration): EnumerationProperty;
+    abstract createPrimitivePropertySync(name: string, primitiveType?: string | PrimitiveType | Enumeration): Property;
+    abstract createPrimitiveArrayProperty(name: string, primitiveType: PrimitiveType): Promise<PrimitiveArrayProperty>;
+    abstract createPrimitiveArrayProperty(name: string, primitiveType: Enumeration): Promise<EnumerationArrayProperty>;
+    abstract createPrimitiveArrayProperty(name: string, primitiveType?: string | PrimitiveType | Enumeration): Promise<Property>;
+    abstract createPrimitiveArrayPropertySync(name: string, primitiveType: PrimitiveType): PrimitiveArrayProperty;
+    abstract createPrimitiveArrayPropertySync(name: string, primitiveType: Enumeration): EnumerationArrayProperty;
+    abstract createPrimitiveArrayPropertySync(name: string, primitiveType?: string | PrimitiveType | Enumeration): Property;
+    abstract createStructProperty(name: string, structType: string | StructClass): Promise<StructProperty>;
+    abstract createStructPropertySync(name: string, structType: string | StructClass): StructProperty;
+    abstract createStructArrayProperty(name: string, structType: string | StructClass): Promise<StructArrayProperty>;
+    abstract createStructArrayPropertySync(name: string, structType: string | StructClass): StructArrayProperty;
+    abstract deleteProperty(name: string): Promise<void>;
+    abstract deletePropertySync(name: string): void;
+}
 //# sourceMappingURL=MutableClass.d.ts.map

package/lib/cjs/Editing/Mutable/MutableClass.js

@@ -1,23 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MutableClass = exports.MutableStructClass = void 0;
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
-/**
- * @internal
- * An abstract class used for schema editing.
- */
-class MutableStructClass extends ecschema_metadata_1.StructClass {
-}
-exports.MutableStructClass = MutableStructClass;
-/**
- * Hackish approach that works like a "friend class" so we can access protected members without making them public.
- * @internal
- */
-class MutableClass extends ecschema_metadata_1.ECClass {
-}
-exports.MutableClass = MutableClass;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MutableClass = exports.MutableStructClass = void 0;
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
+/**
+ * @internal
+ * An abstract class used for schema editing.
+ */
+class MutableStructClass extends ecschema_metadata_1.StructClass {
+}
+exports.MutableStructClass = MutableStructClass;
+/**
+ * Hackish approach that works like a "friend class" so we can access protected members without making them public.
+ * @internal
+ */
+class MutableClass extends ecschema_metadata_1.ECClass {
+}
+exports.MutableClass = MutableClass;
 //# sourceMappingURL=MutableClass.js.map

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

@@ -1,13 +1,13 @@
-import { Constant, LazyLoadedPhenomenon } from "@itwin/ecschema-metadata";
-/**
- * @internal
- * An abstract class used for schema editing.
- */
-export declare abstract class MutableConstant extends Constant {
-    abstract setPhenomenon(phenomenon: LazyLoadedPhenomenon): void;
-    abstract setDefinition(definition: string): void;
-    abstract setNumerator(numerator: number): void;
-    abstract setDenominator(denominator: number): void;
-    abstract setDisplayLabel(displayLabel: string): void;
-}
+import { Constant, LazyLoadedPhenomenon } from "@itwin/ecschema-metadata";
+/**
+ * @internal
+ * An abstract class used for schema editing.
+ */
+export declare abstract class MutableConstant extends Constant {
+    abstract setPhenomenon(phenomenon: LazyLoadedPhenomenon): void;
+    abstract setDefinition(definition: string): void;
+    abstract setNumerator(numerator: number): void;
+    abstract setDenominator(denominator: number): void;
+    abstract setDisplayLabel(displayLabel: string): void;
+}
 //# sourceMappingURL=MutableConstant.d.ts.map

package/lib/cjs/Editing/Mutable/MutableConstant.js

@@ -1,16 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MutableConstant = void 0;
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
-/**
- * @internal
- * An abstract class used for schema editing.
- */
-class MutableConstant extends ecschema_metadata_1.Constant {
-}
-exports.MutableConstant = MutableConstant;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MutableConstant = void 0;
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
+/**
+ * @internal
+ * An abstract class used for schema editing.
+ */
+class MutableConstant extends ecschema_metadata_1.Constant {
+}
+exports.MutableConstant = MutableConstant;
 //# sourceMappingURL=MutableConstant.js.map

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

@@ -1,16 +1,16 @@
-import { ECClass, EntityClass, Mixin, NavigationProperty, RelationshipClass, StrengthDirection } from "@itwin/ecschema-metadata";
-/**
- * Hackish approach that works like a "friend class" so we can access protected members without making them public.
- * @internal
- */
-export declare abstract class MutableEntityClass extends EntityClass {
-    abstract addMixin(mixin: Mixin): any;
-    abstract createNavigationProperty(name: string, relationship: string | RelationshipClass, direction: string | StrengthDirection): Promise<NavigationProperty>;
-    abstract createNavigationPropertySync(name: string, relationship: string | RelationshipClass, direction: string | StrengthDirection): NavigationProperty;
-    abstract setDisplayLabel(displayLabel: string): void;
-}
-/** @internal */
-export declare function createNavigationProperty(ecClass: ECClass, name: string, relationship: string | RelationshipClass, direction: string | StrengthDirection): Promise<NavigationProperty>;
-/** @internal */
-export declare function createNavigationPropertySync(ecClass: ECClass, name: string, relationship: string | RelationshipClass, direction: string | StrengthDirection): NavigationProperty;
+import { ECClass, EntityClass, Mixin, NavigationProperty, RelationshipClass, StrengthDirection } from "@itwin/ecschema-metadata";
+/**
+ * Hackish approach that works like a "friend class" so we can access protected members without making them public.
+ * @internal
+ */
+export declare abstract class MutableEntityClass extends EntityClass {
+    abstract addMixin(mixin: Mixin): any;
+    abstract createNavigationProperty(name: string, relationship: string | RelationshipClass, direction: string | StrengthDirection): Promise<NavigationProperty>;
+    abstract createNavigationPropertySync(name: string, relationship: string | RelationshipClass, direction: string | StrengthDirection): NavigationProperty;
+    abstract setDisplayLabel(displayLabel: string): void;
+}
+/** @internal */
+export declare function createNavigationProperty(ecClass: ECClass, name: string, relationship: string | RelationshipClass, direction: string | StrengthDirection): Promise<NavigationProperty>;
+/** @internal */
+export declare function createNavigationPropertySync(ecClass: ECClass, name: string, relationship: string | RelationshipClass, direction: string | StrengthDirection): NavigationProperty;
 //# sourceMappingURL=MutableEntityClass.d.ts.map

package/lib/cjs/Editing/Mutable/MutableEntityClass.js

@@ -1,60 +1,60 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNavigationPropertySync = exports.createNavigationProperty = exports.MutableEntityClass = void 0;
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
-/**
- * Hackish approach that works like a "friend class" so we can access protected members without making them public.
- * @internal
- */
-class MutableEntityClass extends ecschema_metadata_1.EntityClass {
-}
-exports.MutableEntityClass = MutableEntityClass;
-/** @internal */
-async function createNavigationProperty(ecClass, name, relationship, direction) {
-    if (await ecClass.getProperty(name))
-        throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.DuplicateProperty, `An ECProperty with the name ${name} already exists in the class ${ecClass.name}.`);
-    let resolvedRelationship;
-    if (typeof (relationship) === "string") {
-        resolvedRelationship = await ecClass.schema.lookupItem(relationship);
-    }
-    else
-        resolvedRelationship = relationship;
-    if (!resolvedRelationship)
-        throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidType, `The provided RelationshipClass, ${relationship}, is not a valid RelationshipClassInterface.`);
-    if (typeof (direction) === "string") {
-        const tmpDirection = (0, ecschema_metadata_1.parseStrengthDirection)(direction);
-        if (undefined === tmpDirection)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidStrengthDirection, `The provided StrengthDirection, ${direction}, is not a valid StrengthDirection.`);
-        direction = tmpDirection;
-    }
-    const lazyRelationship = new ecschema_metadata_1.DelayedPromiseWithProps(resolvedRelationship.key, async () => resolvedRelationship);
-    return new ecschema_metadata_1.NavigationProperty(ecClass, name, lazyRelationship, direction);
-}
-exports.createNavigationProperty = createNavigationProperty;
-/** @internal */
-function createNavigationPropertySync(ecClass, name, relationship, direction) {
-    if (ecClass.getPropertySync(name))
-        throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.DuplicateProperty, `An ECProperty with the name ${name} already exists in the class ${ecClass.name}.`);
-    let resolvedRelationship;
-    if (typeof (relationship) === "string") {
-        resolvedRelationship = ecClass.schema.lookupItemSync(relationship);
-    }
-    else
-        resolvedRelationship = relationship;
-    if (!resolvedRelationship)
-        throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidType, `The provided RelationshipClass, ${relationship}, is not a valid RelationshipClassInterface.`);
-    if (typeof (direction) === "string") {
-        const tmpDirection = (0, ecschema_metadata_1.parseStrengthDirection)(direction);
-        if (undefined === tmpDirection)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidStrengthDirection, `The provided StrengthDirection, ${direction}, is not a valid StrengthDirection.`);
-        direction = tmpDirection;
-    }
-    const lazyRelationship = new ecschema_metadata_1.DelayedPromiseWithProps(resolvedRelationship.key, async () => resolvedRelationship);
-    return new ecschema_metadata_1.NavigationProperty(ecClass, name, lazyRelationship, direction);
-}
-exports.createNavigationPropertySync = createNavigationPropertySync;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNavigationPropertySync = exports.createNavigationProperty = exports.MutableEntityClass = void 0;
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
+/**
+ * Hackish approach that works like a "friend class" so we can access protected members without making them public.
+ * @internal
+ */
+class MutableEntityClass extends ecschema_metadata_1.EntityClass {
+}
+exports.MutableEntityClass = MutableEntityClass;
+/** @internal */
+async function createNavigationProperty(ecClass, name, relationship, direction) {
+    if (await ecClass.getProperty(name))
+        throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.DuplicateProperty, `An ECProperty with the name ${name} already exists in the class ${ecClass.name}.`);
+    let resolvedRelationship;
+    if (typeof (relationship) === "string") {
+        resolvedRelationship = await ecClass.schema.lookupItem(relationship);
+    }
+    else
+        resolvedRelationship = relationship;
+    if (!resolvedRelationship)
+        throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidType, `The provided RelationshipClass, ${relationship}, is not a valid RelationshipClassInterface.`);
+    if (typeof (direction) === "string") {
+        const tmpDirection = (0, ecschema_metadata_1.parseStrengthDirection)(direction);
+        if (undefined === tmpDirection)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidStrengthDirection, `The provided StrengthDirection, ${direction}, is not a valid StrengthDirection.`);
+        direction = tmpDirection;
+    }
+    const lazyRelationship = new ecschema_metadata_1.DelayedPromiseWithProps(resolvedRelationship.key, async () => resolvedRelationship);
+    return new ecschema_metadata_1.NavigationProperty(ecClass, name, lazyRelationship, direction);
+}
+exports.createNavigationProperty = createNavigationProperty;
+/** @internal */
+function createNavigationPropertySync(ecClass, name, relationship, direction) {
+    if (ecClass.getPropertySync(name))
+        throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.DuplicateProperty, `An ECProperty with the name ${name} already exists in the class ${ecClass.name}.`);
+    let resolvedRelationship;
+    if (typeof (relationship) === "string") {
+        resolvedRelationship = ecClass.schema.lookupItemSync(relationship);
+    }
+    else
+        resolvedRelationship = relationship;
+    if (!resolvedRelationship)
+        throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidType, `The provided RelationshipClass, ${relationship}, is not a valid RelationshipClassInterface.`);
+    if (typeof (direction) === "string") {
+        const tmpDirection = (0, ecschema_metadata_1.parseStrengthDirection)(direction);
+        if (undefined === tmpDirection)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidStrengthDirection, `The provided StrengthDirection, ${direction}, is not a valid StrengthDirection.`);
+        direction = tmpDirection;
+    }
+    const lazyRelationship = new ecschema_metadata_1.DelayedPromiseWithProps(resolvedRelationship.key, async () => resolvedRelationship);
+    return new ecschema_metadata_1.NavigationProperty(ecClass, name, lazyRelationship, direction);
+}
+exports.createNavigationPropertySync = createNavigationPropertySync;
 //# sourceMappingURL=MutableEntityClass.js.map

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

@@ -1,10 +1,10 @@
-import { AnyEnumerator, Enumeration } from "@itwin/ecschema-metadata";
-/** @internal
- * An abstract class used for schema editing.
- */
-export declare abstract class MutableEnumeration extends Enumeration {
-    abstract addEnumerator(enumerator: AnyEnumerator): void;
-    abstract setIsStrict(isStrict: boolean): void;
-    abstract setDisplayLabel(displayLabel: string): void;
-}
+import { AnyEnumerator, Enumeration } from "@itwin/ecschema-metadata";
+/** @internal
+ * An abstract class used for schema editing.
+ */
+export declare abstract class MutableEnumeration extends Enumeration {
+    abstract addEnumerator(enumerator: AnyEnumerator): void;
+    abstract setIsStrict(isStrict: boolean): void;
+    abstract setDisplayLabel(displayLabel: string): void;
+}
 //# sourceMappingURL=MutableEnumeration.d.ts.map

package/lib/cjs/Editing/Mutable/MutableEnumeration.js

@@ -1,15 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MutableEnumeration = void 0;
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
-/** @internal
- * An abstract class used for schema editing.
- */
-class MutableEnumeration extends ecschema_metadata_1.Enumeration {
-}
-exports.MutableEnumeration = MutableEnumeration;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MutableEnumeration = void 0;
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
+/** @internal
+ * An abstract class used for schema editing.
+ */
+class MutableEnumeration extends ecschema_metadata_1.Enumeration {
+}
+exports.MutableEnumeration = MutableEnumeration;
 //# sourceMappingURL=MutableEnumeration.js.map