@itwin/ecschema-metadata 4.8.0-dev.9 → 4.9.0-dev.1

package/lib/esm/Metadata/PropertyCategory.d.ts

@@ -0,0 +1,40 @@
+/** @packageDocumentation
+ * @module Metadata
+ */
+import { PropertyCategoryProps } from "../Deserialization/JsonProps";
+import { SchemaItemType } from "../ECObjects";
+import { Schema } from "./Schema";
+import { SchemaItem } from "./SchemaItem";
+/**
+ * @beta
+ */
+export declare class PropertyCategory extends SchemaItem {
+    readonly schemaItemType: SchemaItemType.PropertyCategory;
+    protected _priority: number;
+    get priority(): number;
+    constructor(schema: Schema, name: string);
+    /**
+     * Save this PropertyCategory's properties to an object for serializing to JSON.
+     * @param standalone Serialization includes only this object (as opposed to the full schema).
+     * @param includeSchemaVersion Include the Schema's version information in the serialized object.
+     */
+    toJSON(standalone?: boolean, includeSchemaVersion?: boolean): PropertyCategoryProps;
+    /** @internal */
+    toXml(schemaXml: Document): Promise<Element>;
+    fromJSONSync(propertyCategoryProps: PropertyCategoryProps): void;
+    fromJSON(propertyCategoryProps: PropertyCategoryProps): Promise<void>;
+    /**
+     * @alpha
+     * Used for schema editing.
+     */
+    protected setPriority(priority: number): void;
+}
+/**
+ * @internal
+ * An abstract class used for schema editing.
+ */
+export declare abstract class MutablePropertyCategory extends PropertyCategory {
+    abstract setPriority(priority: number): void;
+    abstract setDisplayLabel(displayLabel: string): void;
+}
+//# sourceMappingURL=PropertyCategory.d.ts.map

package/lib/esm/Metadata/PropertyCategory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PropertyCategory.d.ts","sourceRoot":"","sources":["../../../src/Metadata/PropertyCategory.ts"],"names":[],"mappings":"AAIA;;GAEG;AAEH,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C;;GAEG;AACH,qBAAa,gBAAiB,SAAQ,UAAU;IAC9C,SAAyB,cAAc,EAAG,cAAc,CAAC,gBAAgB,CAAC;IAC1E,SAAS,CAAC,SAAS,EAAE,MAAM,CAAC;IAE5B,IAAW,QAAQ,WAA6B;gBAEpC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IAMxC;;;;OAIG;IACa,MAAM,CAAC,UAAU,GAAE,OAAe,EAAE,oBAAoB,GAAE,OAAe,GAAG,qBAAqB;IAMjH,gBAAgB;IACM,KAAK,CAAC,SAAS,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC;IAMlD,YAAY,CAAC,qBAAqB,EAAE,qBAAqB;IAKnD,QAAQ,CAAC,qBAAqB,EAAE,qBAAqB;IAG3E;;;OAGG;IACH,SAAS,CAAC,WAAW,CAAC,QAAQ,EAAE,MAAM;CAGvC;AAED;;;GAGG;AACH,8BAAsB,uBAAwB,SAAQ,gBAAgB;aAC3C,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;aACnC,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;CACrE"}

package/lib/esm/Metadata/PropertyCategory.js

@@ -0,0 +1,57 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Metadata
+ */
+import { SchemaItemType } from "../ECObjects";
+import { SchemaItem } from "./SchemaItem";
+/**
+ * @beta
+ */
+export class PropertyCategory extends SchemaItem {
+    get priority() { return this._priority; }
+    constructor(schema, name) {
+        super(schema, name);
+        this.schemaItemType = SchemaItemType.PropertyCategory;
+        this._priority = 0;
+    }
+    /**
+     * Save this PropertyCategory's properties to an object for serializing to JSON.
+     * @param standalone Serialization includes only this object (as opposed to the full schema).
+     * @param includeSchemaVersion Include the Schema's version information in the serialized object.
+     */
+    toJSON(standalone = false, includeSchemaVersion = false) {
+        const schemaJson = super.toJSON(standalone, includeSchemaVersion);
+        schemaJson.priority = this.priority;
+        return schemaJson;
+    }
+    /** @internal */
+    async toXml(schemaXml) {
+        const itemElement = await super.toXml(schemaXml);
+        itemElement.setAttribute("priority", this.priority.toString());
+        return itemElement;
+    }
+    fromJSONSync(propertyCategoryProps) {
+        super.fromJSONSync(propertyCategoryProps);
+        this._priority = propertyCategoryProps.priority;
+    }
+    async fromJSON(propertyCategoryProps) {
+        this.fromJSONSync(propertyCategoryProps);
+    }
+    /**
+     * @alpha
+     * Used for schema editing.
+     */
+    setPriority(priority) {
+        this._priority = priority;
+    }
+}
+/**
+ * @internal
+ * An abstract class used for schema editing.
+ */
+export class MutablePropertyCategory extends PropertyCategory {
+}
+//# sourceMappingURL=PropertyCategory.js.map

package/lib/esm/Metadata/PropertyCategory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PropertyCategory.js","sourceRoot":"","sources":["../../../src/Metadata/PropertyCategory.ts"],"names":[],"mappings":"AAAA;;;+FAG+F;AAC/F;;GAEG;AAGH,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAE9C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C;;GAEG;AACH,MAAM,OAAO,gBAAiB,SAAQ,UAAU;IAI9C,IAAW,QAAQ,KAAK,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;IAEhD,YAAY,MAAc,EAAE,IAAY;QACtC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QACpB,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC,gBAAgB,CAAC;QACtD,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC;IACrB,CAAC;IAED;;;;OAIG;IACa,MAAM,CAAC,aAAsB,KAAK,EAAE,uBAAgC,KAAK;QACvF,MAAM,UAAU,GAAG,KAAK,CAAC,MAAM,CAAC,UAAU,EAAE,oBAAoB,CAAQ,CAAC;QACzE,UAAU,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;QACpC,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,gBAAgB;IACA,KAAK,CAAC,KAAK,CAAC,SAAmB;QAC7C,MAAM,WAAW,GAAG,MAAM,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QACjD,WAAW,CAAC,YAAY,CAAC,UAAU,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC;QAC/D,OAAO,WAAW,CAAC;IACrB,CAAC;IAEe,YAAY,CAAC,qBAA4C;QACvE,KAAK,CAAC,YAAY,CAAC,qBAAqB,CAAC,CAAC;QAC1C,IAAI,CAAC,SAAS,GAAG,qBAAqB,CAAC,QAAQ,CAAC;IAClD,CAAC;IAEe,KAAK,CAAC,QAAQ,CAAC,qBAA4C;QACzE,IAAI,CAAC,YAAY,CAAC,qBAAqB,CAAC,CAAC;IAC3C,CAAC;IACD;;;OAGG;IACO,WAAW,CAAC,QAAgB;QACpC,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;IAC5B,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,OAAgB,uBAAwB,SAAQ,gBAAgB;CAGrE","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module Metadata\r\n */\r\n\r\nimport { PropertyCategoryProps } from \"../Deserialization/JsonProps\";\r\nimport { SchemaItemType } from \"../ECObjects\";\r\nimport { Schema } from \"./Schema\";\r\nimport { SchemaItem } from \"./SchemaItem\";\r\n\r\n/**\r\n * @beta\r\n */\r\nexport class PropertyCategory extends SchemaItem {\r\n  public override readonly schemaItemType!: SchemaItemType.PropertyCategory; // eslint-disable-line\r\n  protected _priority: number;\r\n\r\n  public get priority() { return this._priority; }\r\n\r\n  constructor(schema: Schema, name: string) {\r\n    super(schema, name);\r\n    this.schemaItemType = SchemaItemType.PropertyCategory;\r\n    this._priority = 0;\r\n  }\r\n\r\n  /**\r\n   * Save this PropertyCategory's properties to an object for serializing to JSON.\r\n   * @param standalone Serialization includes only this object (as opposed to the full schema).\r\n   * @param includeSchemaVersion Include the Schema's version information in the serialized object.\r\n   */\r\n  public override toJSON(standalone: boolean = false, includeSchemaVersion: boolean = false): PropertyCategoryProps {\r\n    const schemaJson = super.toJSON(standalone, includeSchemaVersion) as any;\r\n    schemaJson.priority = this.priority;\r\n    return schemaJson;\r\n  }\r\n\r\n  /** @internal */\r\n  public override async toXml(schemaXml: Document): Promise<Element> {\r\n    const itemElement = await super.toXml(schemaXml);\r\n    itemElement.setAttribute(\"priority\", this.priority.toString());\r\n    return itemElement;\r\n  }\r\n\r\n  public override fromJSONSync(propertyCategoryProps: PropertyCategoryProps) {\r\n    super.fromJSONSync(propertyCategoryProps);\r\n    this._priority = propertyCategoryProps.priority;\r\n  }\r\n\r\n  public override async fromJSON(propertyCategoryProps: PropertyCategoryProps) {\r\n    this.fromJSONSync(propertyCategoryProps);\r\n  }\r\n  /**\r\n   * @alpha\r\n   * Used for schema editing.\r\n   */\r\n  protected setPriority(priority: number) {\r\n    this._priority = priority;\r\n  }\r\n}\r\n\r\n/**\r\n * @internal\r\n * An abstract class used for schema editing.\r\n */\r\nexport abstract class MutablePropertyCategory extends PropertyCategory {\r\n  public abstract override setPriority(priority: number): void;\r\n  public abstract override setDisplayLabel(displayLabel: string): void;\r\n}\r\n"]}

package/lib/esm/Metadata/RelationshipClass.d.ts

@@ -0,0 +1,170 @@
+/** @packageDocumentation
+ * @module Metadata
+ */
+import { RelationshipClassProps, RelationshipConstraintProps } from "../Deserialization/JsonProps";
+import { ECClassModifier, RelationshipEnd, SchemaItemType, StrengthDirection, StrengthType } from "../ECObjects";
+import { LazyLoadedRelationshipConstraintClass } from "../Interfaces";
+import { ECClass } from "./Class";
+import { CustomAttribute, CustomAttributeContainerProps, CustomAttributeSet } from "./CustomAttribute";
+import { EntityClass } from "./EntityClass";
+import { Mixin } from "./Mixin";
+import { NavigationProperty } from "./Property";
+import { Schema } from "./Schema";
+/**
+ * A Typescript class representation of a ECRelationshipClass.
+ * @beta
+ */
+export declare class RelationshipClass extends ECClass {
+    readonly schema: Schema;
+    readonly schemaItemType: SchemaItemType.RelationshipClass;
+    protected _strength: StrengthType;
+    protected _strengthDirection: StrengthDirection;
+    protected _source: RelationshipConstraint;
+    protected _target: RelationshipConstraint;
+    constructor(schema: Schema, name: string, modifier?: ECClassModifier);
+    get strength(): StrengthType;
+    get strengthDirection(): StrengthDirection;
+    get source(): RelationshipConstraint;
+    get target(): RelationshipConstraint;
+    /**
+     *
+     * @param name
+     * @param relationship
+     * @param direction
+     */
+    protected createNavigationProperty(name: string, relationship: string | RelationshipClass, direction: string | StrengthDirection): Promise<NavigationProperty>;
+    protected createNavigationPropertySync(name: string, relationship: string | RelationshipClass, direction: string | StrengthDirection): NavigationProperty;
+    /**
+     * @alpha Used for schema editing.
+     */
+    protected setStrength(strength: StrengthType): void;
+    /**
+     * @alpha Used for schema editing.
+     */
+    protected setStrengthDirection(direction: StrengthDirection): void;
+    /**
+     * @alpha Used for schema editing.
+     */
+    protected setSourceConstraint(source: RelationshipConstraint): void;
+    /**
+     * @alpha Used for schema editing.
+     */
+    protected setTargetConstraint(target: RelationshipConstraint): void;
+    /**
+     * Save this RelationshipClass's properties to an object for serializing to JSON.
+     * @param standalone Serialization includes only this object (as opposed to the full schema).
+     * @param includeSchemaVersion Include the Schema's version information in the serialized object.
+     */
+    toJSON(standalone?: boolean, includeSchemaVersion?: boolean): RelationshipClassProps;
+    /** @internal */
+    toXml(schemaXml: Document): Promise<Element>;
+    fromJSONSync(relationshipClassProps: RelationshipClassProps): void;
+    fromJSON(relationshipClassProps: RelationshipClassProps): Promise<void>;
+}
+/**
+ * A Typescript class representation of a ECRelationshipConstraint.
+ * @beta
+ */
+export declare class RelationshipConstraint implements CustomAttributeContainerProps {
+    protected _abstractConstraint?: LazyLoadedRelationshipConstraintClass;
+    protected _relationshipClass: RelationshipClass;
+    protected _relationshipEnd: RelationshipEnd;
+    protected _multiplicity?: RelationshipMultiplicity;
+    protected _polymorphic?: boolean;
+    protected _roleLabel?: string;
+    protected _constraintClasses?: LazyLoadedRelationshipConstraintClass[];
+    private _customAttributes?;
+    constructor(relClass: RelationshipClass, relEnd: RelationshipEnd, roleLabel?: string, polymorphic?: boolean);
+    get multiplicity(): RelationshipMultiplicity;
+    protected set multiplicity(multiplicity: RelationshipMultiplicity);
+    get polymorphic(): boolean;
+    protected set polymorphic(polymorphic: boolean);
+    get roleLabel(): string | undefined;
+    protected set roleLabel(roleLabel: string | undefined);
+    get constraintClasses(): LazyLoadedRelationshipConstraintClass[] | undefined;
+    get relationshipClass(): RelationshipClass;
+    get relationshipEnd(): RelationshipEnd;
+    protected set relationshipEnd(relationshipEnd: RelationshipEnd);
+    get customAttributes(): CustomAttributeSet | undefined;
+    /** Returns the constraint name, ie. 'RelationshipName.Source/Target' */
+    get fullName(): string;
+    /** Returns the schema of the RelationshipClass. */
+    get schema(): Schema;
+    get abstractConstraint(): LazyLoadedRelationshipConstraintClass | undefined;
+    set abstractConstraint(abstractConstraint: LazyLoadedRelationshipConstraintClass | undefined);
+    /**
+     * True if this RelationshipConstraint is the Source relationship end.
+     */
+    get isSource(): boolean;
+    /**
+     * Adds the provided class as a constraint class to this constraint.
+     * @param constraint The class to add as a constraint class.
+     */
+    addClass(constraint: EntityClass | Mixin | RelationshipClass): void;
+    /**
+     * Removes the provided class as a constraint class from this constraint.
+     * @param constraint The class to add as a constraint class.
+     */
+    protected removeClass(constraint: EntityClass | Mixin | RelationshipClass): void;
+    /**
+     * Save this RelationshipConstraint's properties to an object for serializing to JSON.
+     */
+    toJSON(): RelationshipConstraintProps;
+    /** @internal */
+    toXml(schemaXml: Document): Promise<Element>;
+    fromJSONSync(relationshipConstraintProps: RelationshipConstraintProps): void;
+    fromJSON(relationshipConstraintProps: RelationshipConstraintProps): Promise<void>;
+    /**
+     * Indicates if the provided [[ECClass]] is supported by this [[RelationshipConstraint]].
+     * @param ecClass The class to check.
+     */
+    supportsClass(ecClass: ECClass): Promise<boolean>;
+    /**
+     * Indicates if an ECClass is of the type or applies to the type (if a mixin) of the ECClass specified by the constraintClass parameter.
+     * @param constraintClass The ECClass that is a constraint class of a relationship.
+     * @param testClass The ECClass to check against the constraint class.
+     * @param isPolymorphic Indicates if the testClass should be checked polymorphically.
+     */
+    static classCompatibleWithConstraint(constraintClass: ECClass, testClass: ECClass, isPolymorphic: boolean): Promise<boolean>;
+    /**
+     * @internal
+     */
+    static isRelationshipConstraint(object: any): object is RelationshipConstraint;
+    protected addCustomAttribute(customAttribute: CustomAttribute): void;
+}
+/**
+ * Hackish approach that works like a "friend class" so we can access protected members without making them public.
+ * @internal
+ */
+export declare abstract class MutableRelationshipConstraint extends RelationshipConstraint {
+    abstract addCustomAttribute(customAttribute: CustomAttribute): void;
+}
+/**
+ * @beta
+ */
+export declare class RelationshipMultiplicity {
+    static readonly zeroOne: RelationshipMultiplicity;
+    static readonly zeroMany: RelationshipMultiplicity;
+    static readonly oneOne: RelationshipMultiplicity;
+    static readonly oneMany: RelationshipMultiplicity;
+    readonly lowerLimit: number;
+    readonly upperLimit: number;
+    constructor(lowerLimit: number, upperLimit: number);
+    static fromString(str: string): RelationshipMultiplicity | undefined;
+    equals(rhs: RelationshipMultiplicity): boolean;
+    toString(): string;
+}
+/**
+ * @internal
+ * An abstract class used for schema editing.
+ */
+export declare abstract class MutableRelationshipClass extends RelationshipClass {
+    get source(): MutableRelationshipConstraint;
+    get target(): MutableRelationshipConstraint;
+    abstract setStrength(strength: StrengthType): void;
+    abstract setStrengthDirection(direction: StrengthDirection): void;
+    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;
+}
+//# sourceMappingURL=RelationshipClass.d.ts.map

package/lib/esm/Metadata/RelationshipClass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RelationshipClass.d.ts","sourceRoot":"","sources":["../../../src/Metadata/RelationshipClass.ts"],"names":[],"mappings":"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"}

package/lib/esm/Metadata/RelationshipClass.js

@@ -0,0 +1,380 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Metadata
+ */
+import { DelayedPromiseWithProps } from "../DelayedPromise";
+import { XmlSerializationUtils } from "../Deserialization/XmlSerializationUtils";
+import { parseStrength, parseStrengthDirection, RelationshipEnd, SchemaItemType, StrengthDirection, strengthDirectionToString, strengthToString, StrengthType, } from "../ECObjects";
+import { ECObjectsError, ECObjectsStatus } from "../Exception";
+import { ECClass } from "./Class";
+import { serializeCustomAttributes } from "./CustomAttribute";
+import { createNavigationProperty, createNavigationPropertySync } from "./EntityClass";
+import { SchemaItem } from "./SchemaItem";
+/**
+ * A Typescript class representation of a ECRelationshipClass.
+ * @beta
+ */
+export class RelationshipClass extends ECClass {
+    constructor(schema, name, modifier) {
+        super(schema, name, modifier);
+        this.schemaItemType = SchemaItemType.RelationshipClass;
+        this._strengthDirection = StrengthDirection.Forward;
+        this._strength = StrengthType.Referencing;
+        this._source = new RelationshipConstraint(this, RelationshipEnd.Source);
+        this._target = new RelationshipConstraint(this, RelationshipEnd.Target);
+    }
+    get strength() { return this._strength; }
+    get strengthDirection() { return this._strengthDirection; }
+    get source() { return this._source; }
+    get target() { return this._target; }
+    /**
+     *
+     * @param name
+     * @param relationship
+     * @param direction
+     */
+    async createNavigationProperty(name, relationship, direction) {
+        return this.addProperty(await createNavigationProperty(this, name, relationship, direction));
+    }
+    createNavigationPropertySync(name, relationship, direction) {
+        return this.addProperty(createNavigationPropertySync(this, name, relationship, direction));
+    }
+    /**
+     * @alpha Used for schema editing.
+     */
+    setStrength(strength) {
+        this._strength = strength;
+    }
+    /**
+     * @alpha Used for schema editing.
+     */
+    setStrengthDirection(direction) {
+        this._strengthDirection = direction;
+    }
+    /**
+     * @alpha Used for schema editing.
+     */
+    setSourceConstraint(source) {
+        this._source = source;
+    }
+    /**
+     * @alpha Used for schema editing.
+     */
+    setTargetConstraint(target) {
+        this._target = target;
+    }
+    /**
+     * Save this RelationshipClass's properties to an object for serializing to JSON.
+     * @param standalone Serialization includes only this object (as opposed to the full schema).
+     * @param includeSchemaVersion Include the Schema's version information in the serialized object.
+     */
+    toJSON(standalone = false, includeSchemaVersion = false) {
+        const schemaJson = super.toJSON(standalone, includeSchemaVersion);
+        schemaJson.strength = strengthToString(this.strength);
+        schemaJson.strengthDirection = strengthDirectionToString(this.strengthDirection);
+        schemaJson.source = this.source.toJSON();
+        schemaJson.target = this.target.toJSON();
+        return schemaJson;
+    }
+    /** @internal */
+    async toXml(schemaXml) {
+        const itemElement = await super.toXml(schemaXml);
+        itemElement.setAttribute("strength", strengthToString(this.strength));
+        itemElement.setAttribute("strengthDirection", strengthDirectionToString(this.strengthDirection));
+        itemElement.appendChild(await this.source.toXml(schemaXml));
+        itemElement.appendChild(await this.target.toXml(schemaXml));
+        return itemElement;
+    }
+    fromJSONSync(relationshipClassProps) {
+        super.fromJSONSync(relationshipClassProps);
+        const strength = parseStrength(relationshipClassProps.strength);
+        if (undefined === strength)
+            throw new ECObjectsError(ECObjectsStatus.InvalidStrength, `The RelationshipClass ${this.fullName} has an invalid 'strength' attribute. '${relationshipClassProps.strength}' is not a valid StrengthType.`);
+        const strengthDirection = parseStrengthDirection(relationshipClassProps.strengthDirection);
+        if (undefined === strengthDirection)
+            throw new ECObjectsError(ECObjectsStatus.InvalidStrength, `The RelationshipClass ${this.fullName} has an invalid 'strengthDirection' attribute. '${relationshipClassProps.strengthDirection}' is not a valid StrengthDirection.`);
+        this._strength = strength;
+        this._strengthDirection = strengthDirection;
+    }
+    async fromJSON(relationshipClassProps) {
+        this.fromJSONSync(relationshipClassProps);
+    }
+}
+/**
+ * A Typescript class representation of a ECRelationshipConstraint.
+ * @beta
+ */
+export class RelationshipConstraint {
+    constructor(relClass, relEnd, roleLabel, polymorphic) {
+        this._relationshipEnd = relEnd;
+        if (polymorphic)
+            this._polymorphic = polymorphic;
+        else
+            this._polymorphic = false;
+        this._multiplicity = RelationshipMultiplicity.zeroOne;
+        this._relationshipClass = relClass;
+        this._roleLabel = roleLabel;
+    }
+    get multiplicity() { return this._multiplicity ?? RelationshipMultiplicity.zeroOne; }
+    set multiplicity(multiplicity) {
+        this._multiplicity = multiplicity;
+    }
+    get polymorphic() { return this._polymorphic ?? false; }
+    set polymorphic(polymorphic) {
+        this._polymorphic = polymorphic;
+    }
+    get roleLabel() { return this._roleLabel; }
+    set roleLabel(roleLabel) {
+        this._roleLabel = roleLabel;
+    }
+    get constraintClasses() { return this._constraintClasses; }
+    get relationshipClass() { return this._relationshipClass; }
+    get relationshipEnd() { return this._relationshipEnd; }
+    set relationshipEnd(relationshipEnd) {
+        this._relationshipEnd = relationshipEnd;
+    }
+    get customAttributes() { return this._customAttributes; }
+    /** Returns the constraint name, ie. 'RelationshipName.Source/Target' */
+    get fullName() { return `${this._relationshipClass.name}:${this.isSource ? "Source" : "Target"}`; }
+    /** Returns the schema of the RelationshipClass. */
+    get schema() { return this._relationshipClass.schema; }
+    get abstractConstraint() {
+        if (this._abstractConstraint)
+            return this._abstractConstraint;
+        if (this.constraintClasses && this.constraintClasses.length === 1)
+            return this.constraintClasses[0];
+        return this._abstractConstraint;
+    }
+    set abstractConstraint(abstractConstraint) {
+        this._abstractConstraint = abstractConstraint;
+    }
+    /**
+     * True if this RelationshipConstraint is the Source relationship end.
+     */
+    get isSource() { return this.relationshipEnd === RelationshipEnd.Source; }
+    /**
+     * Adds the provided class as a constraint class to this constraint.
+     * @param constraint The class to add as a constraint class.
+     */
+    addClass(constraint) {
+        // TODO: Ensure we don't start mixing constraint class types
+        // TODO: Check that this class is or subclasses abstract constraint?
+        if (!this._constraintClasses)
+            this._constraintClasses = [];
+        // TODO: Handle relationship constraints
+        this._constraintClasses.push(new DelayedPromiseWithProps(constraint.key, async () => constraint));
+    }
+    /**
+     * Removes the provided class as a constraint class from this constraint.
+     * @param constraint The class to add as a constraint class.
+     */
+    removeClass(constraint) {
+        if (undefined === this._constraintClasses)
+            return;
+        this._constraintClasses.forEach((item, index) => {
+            const constraintName = item.fullName;
+            if (constraintName === constraint.fullName)
+                // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                this._constraintClasses?.splice(index, 1);
+        });
+    }
+    /**
+     * Save this RelationshipConstraint's properties to an object for serializing to JSON.
+     */
+    toJSON() {
+        const schemaJson = {};
+        schemaJson.multiplicity = this.multiplicity.toString();
+        schemaJson.roleLabel = this.roleLabel;
+        schemaJson.polymorphic = this.polymorphic;
+        if (undefined !== this._abstractConstraint)
+            schemaJson.abstractConstraint = this._abstractConstraint.fullName;
+        if (undefined !== this.constraintClasses && this.constraintClasses.length > 0)
+            schemaJson.constraintClasses = this.constraintClasses.map((constraintClass) => constraintClass.fullName);
+        const customAttributes = serializeCustomAttributes(this.customAttributes);
+        if (undefined !== customAttributes)
+            schemaJson.customAttributes = customAttributes;
+        return schemaJson;
+    }
+    /** @internal */
+    async toXml(schemaXml) {
+        const elementName = this.isSource ? "Source" : "Target";
+        const itemElement = schemaXml.createElement(elementName);
+        if (undefined !== this.polymorphic)
+            itemElement.setAttribute("polymorphic", this.polymorphic.toString());
+        if (undefined !== this.roleLabel)
+            itemElement.setAttribute("roleLabel", this.roleLabel);
+        if (undefined !== this.multiplicity)
+            itemElement.setAttribute("multiplicity", this.multiplicity.toString());
+        const abstractConstraint = await this.abstractConstraint;
+        if (undefined !== abstractConstraint) {
+            const abstractConstraintName = XmlSerializationUtils.createXmlTypedName(this.schema, abstractConstraint.schema, abstractConstraint.name);
+            itemElement.setAttribute("abstractConstraint", abstractConstraintName);
+        }
+        if (undefined !== this.constraintClasses) {
+            for (const item of this.constraintClasses) {
+                const constraintClass = await item;
+                const classElement = schemaXml.createElement("Class");
+                const constraintClassName = XmlSerializationUtils.createXmlTypedName(this.schema, constraintClass.schema, constraintClass.name);
+                classElement.setAttribute("class", constraintClassName);
+                itemElement.appendChild(classElement);
+            }
+        }
+        if (this._customAttributes) {
+            const caContainerElement = schemaXml.createElement("ECCustomAttributes");
+            for (const [name, attribute] of this._customAttributes) {
+                const caElement = await XmlSerializationUtils.writeCustomAttribute(name, attribute, schemaXml, this.schema);
+                caContainerElement.appendChild(caElement);
+            }
+            itemElement.appendChild(caContainerElement);
+        }
+        return itemElement;
+    }
+    fromJSONSync(relationshipConstraintProps) {
+        this._roleLabel = relationshipConstraintProps.roleLabel;
+        this._polymorphic = relationshipConstraintProps.polymorphic;
+        const parsedMultiplicity = RelationshipMultiplicity.fromString(relationshipConstraintProps.multiplicity);
+        if (!parsedMultiplicity)
+            throw new ECObjectsError(ECObjectsStatus.InvalidMultiplicity, ``);
+        this._multiplicity = parsedMultiplicity;
+        const relClassSchema = this.relationshipClass.schema;
+        if (undefined !== relationshipConstraintProps.abstractConstraint) {
+            const abstractConstraintSchemaItemKey = relClassSchema.getSchemaItemKey(relationshipConstraintProps.abstractConstraint);
+            if (!abstractConstraintSchemaItemKey)
+                throw new ECObjectsError(ECObjectsStatus.InvalidECJson, `Unable to locate the abstractConstraint ${relationshipConstraintProps.abstractConstraint}.`);
+            this.abstractConstraint = new DelayedPromiseWithProps(abstractConstraintSchemaItemKey, async () => {
+                const tempAbstractConstraint = await relClassSchema.lookupItem(relationshipConstraintProps.abstractConstraint);
+                if (undefined === tempAbstractConstraint)
+                    throw new ECObjectsError(ECObjectsStatus.InvalidECJson, `Unable to locate the abstractConstraint ${relationshipConstraintProps.abstractConstraint}.`);
+                return tempAbstractConstraint;
+            });
+        }
+        const loadEachConstraint = (constraintClassName) => {
+            const tempConstraintClass = relClassSchema.lookupItemSync(constraintClassName);
+            if (!tempConstraintClass)
+                throw new ECObjectsError(ECObjectsStatus.InvalidECJson, ``);
+            return tempConstraintClass;
+        };
+        for (const constraintClassName of relationshipConstraintProps.constraintClasses) {
+            const constraintClass = loadEachConstraint(constraintClassName);
+            this.addClass(constraintClass);
+        }
+    }
+    async fromJSON(relationshipConstraintProps) {
+        this.fromJSONSync(relationshipConstraintProps);
+    }
+    /**
+     * Indicates if the provided [[ECClass]] is supported by this [[RelationshipConstraint]].
+     * @param ecClass The class to check.
+     */
+    async supportsClass(ecClass) {
+        if (!this.constraintClasses) {
+            if (this.relationshipClass.baseClass) {
+                const baseRelationship = await this.relationshipClass.baseClass;
+                const baseConstraint = this.isSource ? baseRelationship.source : baseRelationship.target;
+                return baseConstraint.supportsClass(ecClass);
+            }
+            return false;
+        }
+        if (ecClass.schemaItemType !== SchemaItemType.EntityClass && ecClass.schemaItemType !== SchemaItemType.RelationshipClass &&
+            ecClass.schemaItemType !== SchemaItemType.Mixin) {
+            return false;
+        }
+        const abstractConstraint = await this.abstractConstraint;
+        if (abstractConstraint && await RelationshipConstraint.classCompatibleWithConstraint(abstractConstraint, ecClass, this.polymorphic || false))
+            return true;
+        for (const constraint of this.constraintClasses) {
+            if (await RelationshipConstraint.classCompatibleWithConstraint(await constraint, ecClass, this.polymorphic || false))
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Indicates if an ECClass is of the type or applies to the type (if a mixin) of the ECClass specified by the constraintClass parameter.
+     * @param constraintClass The ECClass that is a constraint class of a relationship.
+     * @param testClass The ECClass to check against the constraint class.
+     * @param isPolymorphic Indicates if the testClass should be checked polymorphically.
+     */
+    static async classCompatibleWithConstraint(constraintClass, testClass, isPolymorphic) {
+        if (SchemaItem.equalByKey(constraintClass, testClass))
+            return true;
+        if (isPolymorphic) {
+            if (testClass.schemaItemType === SchemaItemType.EntityClass || testClass.schemaItemType === SchemaItemType.RelationshipClass) {
+                return testClass.is(constraintClass);
+            }
+            if (testClass.schemaItemType === SchemaItemType.Mixin) {
+                if (constraintClass.schemaItemType === SchemaItemType.EntityClass)
+                    return testClass.applicableTo(constraintClass);
+                else
+                    return testClass.is(constraintClass);
+            }
+        }
+        return false;
+    }
+    /**
+     * @internal
+     */
+    static isRelationshipConstraint(object) {
+        const relationshipConstrait = object;
+        return relationshipConstrait !== undefined && relationshipConstrait.polymorphic !== undefined && relationshipConstrait.multiplicity !== undefined
+            && relationshipConstrait.relationshipEnd !== undefined && relationshipConstrait._relationshipClass !== undefined;
+    }
+    addCustomAttribute(customAttribute) {
+        if (!this._customAttributes)
+            this._customAttributes = new Map();
+        this._customAttributes.set(customAttribute.className, customAttribute);
+    }
+}
+/**
+ * Hackish approach that works like a "friend class" so we can access protected members without making them public.
+ * @internal
+ */
+export class MutableRelationshipConstraint extends RelationshipConstraint {
+}
+const INT32_MAX = 2147483647;
+/**
+ * @beta
+ */
+export class RelationshipMultiplicity {
+    constructor(lowerLimit, upperLimit) {
+        this.lowerLimit = lowerLimit;
+        this.upperLimit = upperLimit;
+    }
+    static fromString(str) {
+        const matches = /^\(([0-9]*)\.\.([0-9]*|\*)\)$/.exec(str);
+        if (matches === null || matches.length !== 3)
+            return undefined;
+        const lowerLimit = parseInt(matches[1], 10);
+        const upperLimit = matches[2] === "*" ? INT32_MAX : parseInt(matches[2], 10);
+        if (0 === lowerLimit && 1 === upperLimit)
+            return RelationshipMultiplicity.zeroOne;
+        else if (0 === lowerLimit && INT32_MAX === upperLimit)
+            return RelationshipMultiplicity.zeroMany;
+        else if (1 === lowerLimit && 1 === upperLimit)
+            return RelationshipMultiplicity.oneOne;
+        else if (1 === lowerLimit && INT32_MAX === upperLimit)
+            return RelationshipMultiplicity.oneMany;
+        return new RelationshipMultiplicity(lowerLimit, upperLimit);
+    }
+    equals(rhs) {
+        return this.lowerLimit === rhs.lowerLimit && this.upperLimit === rhs.upperLimit;
+    }
+    toString() {
+        return `(${this.lowerLimit}..${this.upperLimit === INT32_MAX ? "*" : this.upperLimit})`;
+    }
+}
+RelationshipMultiplicity.zeroOne = new RelationshipMultiplicity(0, 1);
+RelationshipMultiplicity.zeroMany = new RelationshipMultiplicity(0, INT32_MAX);
+RelationshipMultiplicity.oneOne = new RelationshipMultiplicity(1, 1);
+RelationshipMultiplicity.oneMany = new RelationshipMultiplicity(1, INT32_MAX);
+/**
+ * @internal
+ * An abstract class used for schema editing.
+ */
+export class MutableRelationshipClass extends RelationshipClass {
+    get source() { return this._source; }
+    get target() { return this._target; }
+}
+//# sourceMappingURL=RelationshipClass.js.map