@itwin/ecschema-editing 4.0.0-dev.6 → 4.0.0-dev.61

package/CHANGELOG.md

@@ -1,6 +1,16 @@
 # Change Log - @itwin/ecschema-editing
 
-This log was last generated on Thu, 26 Jan 2023 22:53:27 GMT and should not be manually modified.
+This log was last generated on Wed, 08 Feb 2023 14:58:40 GMT and should not be manually modified.
+
+## 3.6.0
+Wed, 08 Feb 2023 14:58:40 GMT
+
+_Version update only_
+
+## 3.5.6
+Fri, 24 Feb 2023 16:02:47 GMT
+
+_Version update only_
 
 ## 3.5.5
 Thu, 26 Jan 2023 22:53:27 GMT

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

@@ -1,21 +1,21 @@
-/** @packageDocumentation
- * @module Editing
- */
-import { ConstantProps, SchemaItemKey, SchemaKey } from "@itwin/ecschema-metadata";
-import { SchemaContextEditor, SchemaItemEditResults } from "./Editor";
-/**
- * @alpha
- * A class allowing you to create schema items of type Constant.
- */
-export declare class Constants {
-    protected _schemaEditor: SchemaContextEditor;
-    constructor(_schemaEditor: SchemaContextEditor);
-    create(schemaKey: SchemaKey, name: string, phenomenon: SchemaItemKey, definition: string, displayLabel?: string, numerator?: number, denominator?: number): Promise<SchemaItemEditResults>;
-    /**
-     * Creates a Constant through a ConstantProps.
-     * @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, constantProps: ConstantProps): Promise<SchemaItemEditResults>;
-}
+/** @packageDocumentation
+ * @module Editing
+ */
+import { ConstantProps, SchemaItemKey, SchemaKey } from "@itwin/ecschema-metadata";
+import { SchemaContextEditor, SchemaItemEditResults } from "./Editor";
+/**
+ * @alpha
+ * A class allowing you to create schema items of type Constant.
+ */
+export declare class Constants {
+    protected _schemaEditor: SchemaContextEditor;
+    constructor(_schemaEditor: SchemaContextEditor);
+    create(schemaKey: SchemaKey, name: string, phenomenon: SchemaItemKey, definition: string, displayLabel?: string, numerator?: number, denominator?: number): Promise<SchemaItemEditResults>;
+    /**
+     * Creates a Constant through a ConstantProps.
+     * @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, constantProps: ConstantProps): Promise<SchemaItemEditResults>;
+}
 //# sourceMappingURL=Constants.d.ts.map

package/lib/cjs/Editing/Constants.js

@@ -1,61 +1,61 @@
-"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.Constants = void 0;
-const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
-/**
- * @alpha
- * A class allowing you to create schema items of type Constant.
- */
-class Constants {
-    constructor(_schemaEditor) {
-        this._schemaEditor = _schemaEditor;
-    }
-    async create(schemaKey, name, phenomenon, definition, displayLabel, numerator, denominator) {
-        const schema = await this._schemaEditor.getSchema(schemaKey);
-        if (schema === undefined)
-            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
-        const newConstant = (await schema.createConstant(name));
-        if (newConstant === undefined) {
-            return { errorMessage: `Failed to create class ${name} in schema ${schemaKey.toString(true)}.` };
-        }
-        const newPhenomenon = (await this._schemaEditor.schemaContext.getSchemaItem(phenomenon));
-        if (newPhenomenon === undefined || newPhenomenon.schemaItemType !== ecschema_metadata_1.SchemaItemType.Phenomenon) {
-            return { errorMessage: `Unable to locate phenomenon ${phenomenon.name}` };
-        }
-        newConstant.setPhenomenon(new ecschema_metadata_1.DelayedPromiseWithProps(newPhenomenon.key, async () => newPhenomenon));
-        newConstant.setDefinition(definition);
-        if (numerator)
-            newConstant.setNumerator(numerator);
-        if (denominator)
-            newConstant.setDenominator(denominator);
-        if (displayLabel)
-            newConstant.setDisplayLabel(displayLabel);
-        return { itemKey: newConstant.key };
-    }
-    /**
-     * Creates a Constant through a ConstantProps.
-     * @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, constantProps) {
-        const schema = await this._schemaEditor.getSchema(schemaKey);
-        if (schema === undefined)
-            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
-        if (constantProps.name === undefined)
-            return { errorMessage: `No name was supplied within props.` };
-        const newConstant = (await schema.createConstant(constantProps.name));
-        if (newConstant === undefined)
-            return { errorMessage: `Failed to create class ${constantProps.name} in schema ${schemaKey.toString(true)}.` };
-        await newConstant.fromJSON(constantProps);
-        return { itemKey: newConstant.key };
-    }
-}
-exports.Constants = Constants;
+"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.Constants = void 0;
+const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
+/**
+ * @alpha
+ * A class allowing you to create schema items of type Constant.
+ */
+class Constants {
+    constructor(_schemaEditor) {
+        this._schemaEditor = _schemaEditor;
+    }
+    async create(schemaKey, name, phenomenon, definition, displayLabel, numerator, denominator) {
+        const schema = await this._schemaEditor.getSchema(schemaKey);
+        if (schema === undefined)
+            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
+        const newConstant = (await schema.createConstant(name));
+        if (newConstant === undefined) {
+            return { errorMessage: `Failed to create class ${name} in schema ${schemaKey.toString(true)}.` };
+        }
+        const newPhenomenon = (await this._schemaEditor.schemaContext.getSchemaItem(phenomenon));
+        if (newPhenomenon === undefined || newPhenomenon.schemaItemType !== ecschema_metadata_1.SchemaItemType.Phenomenon) {
+            return { errorMessage: `Unable to locate phenomenon ${phenomenon.name}` };
+        }
+        newConstant.setPhenomenon(new ecschema_metadata_1.DelayedPromiseWithProps(newPhenomenon.key, async () => newPhenomenon));
+        newConstant.setDefinition(definition);
+        if (numerator)
+            newConstant.setNumerator(numerator);
+        if (denominator)
+            newConstant.setDenominator(denominator);
+        if (displayLabel)
+            newConstant.setDisplayLabel(displayLabel);
+        return { itemKey: newConstant.key };
+    }
+    /**
+     * Creates a Constant through a ConstantProps.
+     * @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, constantProps) {
+        const schema = await this._schemaEditor.getSchema(schemaKey);
+        if (schema === undefined)
+            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
+        if (constantProps.name === undefined)
+            return { errorMessage: `No name was supplied within props.` };
+        const newConstant = (await schema.createConstant(constantProps.name));
+        if (newConstant === undefined)
+            return { errorMessage: `Failed to create class ${constantProps.name} in schema ${schemaKey.toString(true)}.` };
+        await newConstant.fromJSON(constantProps);
+        return { itemKey: newConstant.key };
+    }
+}
+exports.Constants = Constants;
 //# sourceMappingURL=Constants.js.map

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

@@ -1,21 +1,21 @@
-/** @packageDocumentation
- * @module Editing
- */
-import { CustomAttributeClassProps, CustomAttributeContainerType, SchemaItemKey, SchemaKey } 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 CustomAttributeClass.
- */
-export declare class CustomAttributes extends ECClasses {
-    constructor(_schemaEditor: SchemaContextEditor);
-    create(schemaKey: SchemaKey, name: string, containerType: CustomAttributeContainerType, displayLabel?: string, baseClass?: SchemaItemKey): Promise<SchemaItemEditResults>;
-    /**
-     * Creates a CustomAttributeClass through a CustomAttributeClassProps.
-     * @param schemaKey a SchemaKey of the Schema that will house the new object.
-     * @param caProps a json object that will be used to populate the new CustomAttributeClass. Needs a name value passed in.
-     */
-    createFromProps(schemaKey: SchemaKey, caProps: CustomAttributeClassProps): Promise<SchemaItemEditResults>;
-}
+/** @packageDocumentation
+ * @module Editing
+ */
+import { CustomAttributeClassProps, CustomAttributeContainerType, SchemaItemKey, SchemaKey } 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 CustomAttributeClass.
+ */
+export declare class CustomAttributes extends ECClasses {
+    constructor(_schemaEditor: SchemaContextEditor);
+    create(schemaKey: SchemaKey, name: string, containerType: CustomAttributeContainerType, displayLabel?: string, baseClass?: SchemaItemKey): Promise<SchemaItemEditResults>;
+    /**
+     * Creates a CustomAttributeClass through a CustomAttributeClassProps.
+     * @param schemaKey a SchemaKey of the Schema that will house the new object.
+     * @param caProps a json object that will be used to populate the new CustomAttributeClass. Needs a name value passed in.
+     */
+    createFromProps(schemaKey: SchemaKey, caProps: CustomAttributeClassProps): Promise<SchemaItemEditResults>;
+}
 //# sourceMappingURL=CustomAttributes.d.ts.map

package/lib/cjs/Editing/CustomAttributes.js

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

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

@@ -1,55 +1,55 @@
-/** @packageDocumentation
- * @module Editing
- */
-import { CustomAttribute, Enumeration, EnumerationPropertyProps, PrimitiveArrayPropertyProps, PrimitivePropertyProps, PrimitiveType, SchemaItemKey, StructArrayPropertyProps, StructClass, StructPropertyProps } from "@itwin/ecschema-metadata";
-import { PropertyEditResults, SchemaContextEditor, SchemaItemEditResults } from "./Editor";
-/**
- * @alpha
- * Acts as a base class for schema class creation. Enables property creation.
- */
-export declare class ECClasses {
-    protected _schemaEditor: SchemaContextEditor;
-    protected constructor(_schemaEditor: SchemaContextEditor);
-    /**
-     * Creates a property on class identified by the given SchemaItemKey. This method restricts the
-     * property type to primitives of type Double, String, DateTime and Integer.
-     * @param classKey The SchemaItemKey of the class.
-     * @param name The name of the new property.
-     * @param type The PrimitiveType assigned to the new property.
-     */
-    createProperty(classKey: SchemaItemKey, name: string, type: PrimitiveType, prefix: string): Promise<PropertyEditResults>;
-    /**
-     * Create a primitive property on class identified by the given SchemaItemKey.
-     * @param classKey The SchemaItemKey of the class.
-     * @param name The name of the new property.
-     * @param type The PrimitiveType assigned to the new property.
-     */
-    createPrimitiveProperty(classKey: SchemaItemKey, name: string, type: PrimitiveType): Promise<PropertyEditResults>;
-    createPrimitivePropertyFromProps(classKey: SchemaItemKey, name: string, type: PrimitiveType, primitiveProps: PrimitivePropertyProps): Promise<PropertyEditResults>;
-    createEnumerationProperty(classKey: SchemaItemKey, name: string, type: Enumeration): Promise<PropertyEditResults>;
-    createEnumerationPropertyFromProps(classKey: SchemaItemKey, name: string, type: Enumeration, enumProps: EnumerationPropertyProps): Promise<PropertyEditResults>;
-    createPrimitiveArrayProperty(classKey: SchemaItemKey, name: string, type: PrimitiveType): Promise<PropertyEditResults>;
-    createPrimitiveArrayPropertyFromProps(classKey: SchemaItemKey, name: string, type: PrimitiveType, primitiveProps: PrimitiveArrayPropertyProps): Promise<PropertyEditResults>;
-    createStructProperty(classKey: SchemaItemKey, name: string, type: StructClass): Promise<PropertyEditResults>;
-    createStructPropertyFromProps(classKey: SchemaItemKey, name: string, type: StructClass, structProps: StructPropertyProps): Promise<PropertyEditResults>;
-    createStructArrayProperty(classKey: SchemaItemKey, name: string, type: StructClass): Promise<PropertyEditResults>;
-    createStructArrayPropertyFromProps(classKey: SchemaItemKey, name: string, type: StructClass, structProps: StructArrayPropertyProps): Promise<PropertyEditResults>;
-    deleteProperty(classKey: SchemaItemKey, name: string): Promise<PropertyEditResults>;
-    delete(classKey: SchemaItemKey): Promise<SchemaItemEditResults>;
-    /**
-     * Adds a CustomAttribute instance to the Class identified by the given SchemaItemKey
-     * @param classKey The SchemaItemKey identifying the schema.
-     * @param customAttribute The CustomAttribute instance to add.
-     */
-    addCustomAttribute(classKey: SchemaItemKey, customAttribute: CustomAttribute): Promise<SchemaItemEditResults>;
-    /**
-     * Adds a CustomAttribute instance to the Property identified by the given SchemaItemKey and property name.
-     * @param classKey The SchemaItemKey identifying the class.
-     * @param propertyName The name of the property.
-     * @param customAttribute The CustomAttribute instance to add.
-     */
-    addCustomAttributeToProperty(classKey: SchemaItemKey, propertyName: string, customAttribute: CustomAttribute): Promise<PropertyEditResults>;
-    private getClass;
-    private removeCustomAttribute;
-}
+/** @packageDocumentation
+ * @module Editing
+ */
+import { CustomAttribute, Enumeration, EnumerationPropertyProps, PrimitiveArrayPropertyProps, PrimitivePropertyProps, PrimitiveType, SchemaItemKey, StructArrayPropertyProps, StructClass, StructPropertyProps } from "@itwin/ecschema-metadata";
+import { PropertyEditResults, SchemaContextEditor, SchemaItemEditResults } from "./Editor";
+/**
+ * @alpha
+ * Acts as a base class for schema class creation. Enables property creation.
+ */
+export declare class ECClasses {
+    protected _schemaEditor: SchemaContextEditor;
+    protected constructor(_schemaEditor: SchemaContextEditor);
+    /**
+     * Creates a property on class identified by the given SchemaItemKey. This method restricts the
+     * property type to primitives of type Double, String, DateTime and Integer.
+     * @param classKey The SchemaItemKey of the class.
+     * @param name The name of the new property.
+     * @param type The PrimitiveType assigned to the new property.
+     */
+    createProperty(classKey: SchemaItemKey, name: string, type: PrimitiveType, prefix: string): Promise<PropertyEditResults>;
+    /**
+     * Create a primitive property on class identified by the given SchemaItemKey.
+     * @param classKey The SchemaItemKey of the class.
+     * @param name The name of the new property.
+     * @param type The PrimitiveType assigned to the new property.
+     */
+    createPrimitiveProperty(classKey: SchemaItemKey, name: string, type: PrimitiveType): Promise<PropertyEditResults>;
+    createPrimitivePropertyFromProps(classKey: SchemaItemKey, name: string, type: PrimitiveType, primitiveProps: PrimitivePropertyProps): Promise<PropertyEditResults>;
+    createEnumerationProperty(classKey: SchemaItemKey, name: string, type: Enumeration): Promise<PropertyEditResults>;
+    createEnumerationPropertyFromProps(classKey: SchemaItemKey, name: string, type: Enumeration, enumProps: EnumerationPropertyProps): Promise<PropertyEditResults>;
+    createPrimitiveArrayProperty(classKey: SchemaItemKey, name: string, type: PrimitiveType): Promise<PropertyEditResults>;
+    createPrimitiveArrayPropertyFromProps(classKey: SchemaItemKey, name: string, type: PrimitiveType, primitiveProps: PrimitiveArrayPropertyProps): Promise<PropertyEditResults>;
+    createStructProperty(classKey: SchemaItemKey, name: string, type: StructClass): Promise<PropertyEditResults>;
+    createStructPropertyFromProps(classKey: SchemaItemKey, name: string, type: StructClass, structProps: StructPropertyProps): Promise<PropertyEditResults>;
+    createStructArrayProperty(classKey: SchemaItemKey, name: string, type: StructClass): Promise<PropertyEditResults>;
+    createStructArrayPropertyFromProps(classKey: SchemaItemKey, name: string, type: StructClass, structProps: StructArrayPropertyProps): Promise<PropertyEditResults>;
+    deleteProperty(classKey: SchemaItemKey, name: string): Promise<PropertyEditResults>;
+    delete(classKey: SchemaItemKey): Promise<SchemaItemEditResults>;
+    /**
+     * Adds a CustomAttribute instance to the Class identified by the given SchemaItemKey
+     * @param classKey The SchemaItemKey identifying the schema.
+     * @param customAttribute The CustomAttribute instance to add.
+     */
+    addCustomAttribute(classKey: SchemaItemKey, customAttribute: CustomAttribute): Promise<SchemaItemEditResults>;
+    /**
+     * Adds a CustomAttribute instance to the Property identified by the given SchemaItemKey and property name.
+     * @param classKey The SchemaItemKey identifying the class.
+     * @param propertyName The name of the property.
+     * @param customAttribute The CustomAttribute instance to add.
+     */
+    addCustomAttributeToProperty(classKey: SchemaItemKey, propertyName: string, customAttribute: CustomAttribute): Promise<PropertyEditResults>;
+    private getClass;
+    private removeCustomAttribute;
+}
 //# sourceMappingURL=ECClasses.d.ts.map