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

package/lib/esm/ECName.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ECName.js","sourceRoot":"","sources":["../../src/ECName.ts"],"names":[],"mappings":"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","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 { assert } from \"@itwin/core-bentley\";\r\nimport { ECObjectsError, ECObjectsStatus } from \"./Exception\";\r\n\r\nconst validECNameRegex = /^([a-zA-Z_]+[a-zA-Z0-9_]*)$/i;\r\nconst ecNameReplacerRegex = /__x([0-9a-fA-F]{4})__/g;\r\nconst leadingDigits = [\"0000\", \"000\", \"00\", \"0\", \"\"];\r\n\r\nfunction isDigit(character: string): boolean {\r\n  assert(1 === character.length);\r\n  return character >= \"0\" && character <= \"9\";\r\n}\r\n\r\nfunction isValidAlphaNumericCharacter(c: string): boolean {\r\n  assert(1 === c.length);\r\n  return (((c >= \"0\" && c <= \"9\") || (c >= \"A\" && c <= \"Z\") || (c >= \"a\" && c <= \"z\") || c === \"_\"));\r\n}\r\n\r\n/** The name of an item in a [[Schema]], encoded to meet restrictions on the characters usable in such names.\r\n * An ECName meets the following criteria:\r\n *  - Contains at least one character.\r\n *  - Does not begin with a digit.\r\n *  - Consists entirely of characters in the ASCII ranges A-Z, a-z, and 0-9; and the underscore (\"_\") character.\r\n *\r\n * All characters not meeting the above criteria are encoded as \"__x####__\" where \"####\" is the UTF-16 character code.\r\n * Such names are often automatically generated from the item's display label, which is unrestricted in the characters it may contain.\r\n * @public\r\n */\r\nexport class ECName {\r\n  private _name: string;\r\n\r\n  /** Construct a new ECName from a valid EC name.\r\n   * throws ECObjectsError if `name` does not meet the criteria for a valid EC name.\r\n   */\r\n  constructor(name: string) {\r\n    if (!ECName.validate(name))\r\n      throw new ECObjectsError(ECObjectsStatus.InvalidECName);\r\n\r\n    this._name = name;\r\n  }\r\n\r\n  /** Returns true if a string meets the criteria of a valid EC name. */\r\n  public static validate(name: string): boolean {\r\n    return validECNameRegex.test(name);\r\n  }\r\n\r\n  /** The underlying name as a string. */\r\n  public get name(): string {\r\n    return this._name;\r\n  }\r\n\r\n  /** Create an ECName from an arbitrary string, encoding any special characters as \"__x####__\" where \"####\" is the UTF-16 character code.\r\n   * @throws ECObjectsError if `input` is an empty string.\r\n   */\r\n  public static encode(input: string): ECName {\r\n    if (0 === input.length)\r\n      throw new ECObjectsError(ECObjectsStatus.InvalidECName);\r\n\r\n    if (ECName.validate(input)) {\r\n      // It's already a valid EC name.\r\n      return new ECName(input);\r\n    }\r\n\r\n    let output = \"\";\r\n\r\n    function appendEncodedCharacter(index: number): void {\r\n      const hex = input.charCodeAt(index).toString(16).toUpperCase();\r\n      assert(hex.length > 0 && hex.length < 5);\r\n      output += `__x${leadingDigits[hex.length]}${hex}__`;\r\n    }\r\n\r\n    // First character cannot be a digit.\r\n    const firstCharIsDigit = isDigit(input[0]);\r\n    if (firstCharIsDigit)\r\n      appendEncodedCharacter(0);\r\n\r\n    for (let i = firstCharIsDigit ? 1 : 0; i < input.length; i++) {\r\n      const char = input[i];\r\n      if (!isValidAlphaNumericCharacter(char))\r\n        appendEncodedCharacter(i);\r\n      else\r\n        output += char;\r\n    }\r\n\r\n    return new ECName(output);\r\n  }\r\n\r\n  /** Decode this ECName, replacing encoded special characters with the characters they encode. */\r\n  public decode(): string {\r\n    return this.name.replace(ecNameReplacerRegex, (_match, hex) => String.fromCharCode(Number.parseInt(hex, 16)));\r\n  }\r\n}\r\n"]}

package/lib/esm/ECObjects.d.ts

@@ -0,0 +1,166 @@
+/** @packageDocumentation
+ * @module Metadata
+ */
+export { PropertyType } from "./PropertyTypes";
+/** @beta */
+export declare enum ECClassModifier {
+    None = 0,
+    Abstract = 1,
+    Sealed = 2
+}
+/**
+ * An enumeration that has all the schema item type names as values
+ * @beta */
+export declare enum SchemaItemType {
+    EntityClass = "EntityClass",
+    Mixin = "Mixin",
+    StructClass = "StructClass",
+    CustomAttributeClass = "CustomAttributeClass",
+    RelationshipClass = "RelationshipClass",
+    Enumeration = "Enumeration",
+    KindOfQuantity = "KindOfQuantity",
+    PropertyCategory = "PropertyCategory",
+    Unit = "Unit",
+    InvertedUnit = "InvertedUnit",
+    Constant = "Constant",
+    Phenomenon = "Phenomenon",
+    UnitSystem = "UnitSystem",
+    Format = "Format"
+}
+/**
+ * Primitive data types for ECProperties.
+ * @beta
+ */
+export declare enum PrimitiveType {
+    Uninitialized = 0,
+    Binary = 257,
+    Boolean = 513,
+    DateTime = 769,
+    Double = 1025,
+    Integer = 1281,
+    Long = 1537,
+    Point2d = 1793,
+    Point3d = 2049,
+    String = 2305,
+    IGeometry = 2561
+}
+/**
+ * Defines the valid CustomAttribute container types.
+ * @beta
+ */
+export declare enum CustomAttributeContainerType {
+    Schema = 1,
+    EntityClass = 2,
+    CustomAttributeClass = 4,
+    StructClass = 8,
+    RelationshipClass = 16,
+    AnyClass = 30,
+    PrimitiveProperty = 32,
+    StructProperty = 64,
+    PrimitiveArrayProperty = 128,
+    StructArrayProperty = 256,
+    NavigationProperty = 512,
+    AnyProperty = 992,
+    SourceRelationshipConstraint = 1024,
+    TargetRelationshipConstraint = 2048,
+    AnyRelationshipConstraint = 3072,
+    Any = 4095
+}
+/**
+ * Defines what sort of match should be used when locating a schema.
+ * @beta
+ */
+export declare enum SchemaMatchType {
+    Identical = 0,
+    Exact = 1,
+    LatestWriteCompatible = 2,
+    Latest = 3,
+    LatestReadCompatible = 4
+}
+/**
+ * Identifer for an ECRelationshipConstraint. Used to determine the side of the relationship the constraint is representing.
+ * @beta
+ */
+export declare enum RelationshipEnd {
+    Source = 0,
+    Target = 1
+}
+/** @beta */
+export declare enum StrengthType {
+    Referencing = 0,
+    Holding = 1,
+    Embedding = 2
+}
+/** @beta */
+export declare enum StrengthDirection {
+    Forward = 1,
+    Backward = 2
+}
+/**
+ * Parses the provided string into an ECClassModifier if the string is a valid modifier.
+ * @param modifier The modifier string to parse.
+ * @beta
+ */
+export declare function parseClassModifier(modifier: string): ECClassModifier | undefined;
+/**
+ * @return A string representing the provided ECClassModifier. If the modifier is not valid, an empty string is returned.
+ * @beta
+ */
+export declare function classModifierToString(modifier: ECClassModifier): string;
+/**
+ * Tries to parse the given string as one of the 8 schema item types.
+ * @param type The schema item type string to parse.
+ * @returns A valid SchemaItemType if successfully parsed. Otherwise, undefined if the provided string is not a valid SchemaItemType.
+ * @beta
+ */
+export declare function parseSchemaItemType(type: string): SchemaItemType | undefined;
+/**
+ * Converts a valid SchemaItemType to a display string.
+ * @param value The SchemaItemType to stringify.
+ * @return A string representing the provided SchemaItemType. If the type is not valid, an empty string is returned.
+ * @beta
+ * @deprecated in 4.6.0 SchemaItemType is a string enum so just use it directly
+ */
+export declare function schemaItemTypeToString(value: SchemaItemType): string;
+/** @internal */
+export declare function schemaItemTypeToXmlString(value: SchemaItemType): string;
+/**
+ * Tries to parse the given string as one of the 10 primitive types.
+ * @param type The primitive type string to parse.
+ * @returns A valid PrimitiveType if successfully parsed, or undefined if the provided string is not a valid PrimitiveType.
+ * @beta
+ */
+export declare function parsePrimitiveType(type: string): PrimitiveType | undefined;
+/** @beta */
+export declare function primitiveTypeToString(type: PrimitiveType): string;
+/**
+ * Parses the given string into the appropriate CustomAttributeContainerType if the string is valid.
+ * @param type The container type string to parse.
+ * @beta
+ */
+export declare function parseCustomAttributeContainerType(type: string): CustomAttributeContainerType | undefined;
+/**
+ * Creates a string representing a valid CustomAttributeContainerType.
+ * @param value The CustomAttributeContainerType to stringify.
+ * @return A string representing the provided CustomAttributeContainerType. If the type is not valid, an empty string is returned.
+ * @beta
+ */
+export declare function containerTypeToString(type: CustomAttributeContainerType): string;
+/** @beta */
+export declare function parseRelationshipEnd(end: string): RelationshipEnd | undefined;
+/** @beta */
+export declare function relationshipEndToString(end: RelationshipEnd): string;
+/**
+ * Takes a string representing a StrengthType, will parse it and return the corresponding StrengthType.
+ * @throws ECObjectsStatus.InvalidStrength if the provided string that is not valid
+ * @param strength
+ * @beta
+ */
+export declare function parseStrength(strength: string): StrengthType | undefined;
+/** @beta */
+export declare function strengthToString(strength: StrengthType): string;
+/** @beta */
+export declare function parseStrengthDirection(direction: string): StrengthDirection | undefined;
+/** @beta */
+export declare function strengthDirectionToString(direction: StrengthDirection): string;
+//# sourceMappingURL=ECObjects.d.ts.map

package/lib/esm/ECObjects.d.ts.map

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

package/lib/esm/ECObjects.js

@@ -0,0 +1,422 @@
+/*---------------------------------------------------------------------------------------------
+* 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 { ECStringConstants } from "./Constants";
+import { ECObjectsError, ECObjectsStatus } from "./Exception";
+export { PropertyType } from "./PropertyTypes";
+// NEEDSWORK: This shim is currently required to use async iterators.  See https://github.com/Microsoft/TypeScript/issues/14151
+if (!Symbol.asyncIterator) {
+    Symbol.asyncIterator = Symbol.for("Symbol.asyncIterator");
+}
+/** @beta */
+export var ECClassModifier;
+(function (ECClassModifier) {
+    ECClassModifier[ECClassModifier["None"] = 0] = "None";
+    ECClassModifier[ECClassModifier["Abstract"] = 1] = "Abstract";
+    ECClassModifier[ECClassModifier["Sealed"] = 2] = "Sealed";
+})(ECClassModifier || (ECClassModifier = {}));
+/**
+ * An enumeration that has all the schema item type names as values
+ * @beta */
+export var SchemaItemType;
+(function (SchemaItemType) {
+    SchemaItemType["EntityClass"] = "EntityClass";
+    SchemaItemType["Mixin"] = "Mixin";
+    SchemaItemType["StructClass"] = "StructClass";
+    SchemaItemType["CustomAttributeClass"] = "CustomAttributeClass";
+    SchemaItemType["RelationshipClass"] = "RelationshipClass";
+    SchemaItemType["Enumeration"] = "Enumeration";
+    SchemaItemType["KindOfQuantity"] = "KindOfQuantity";
+    SchemaItemType["PropertyCategory"] = "PropertyCategory";
+    SchemaItemType["Unit"] = "Unit";
+    SchemaItemType["InvertedUnit"] = "InvertedUnit";
+    SchemaItemType["Constant"] = "Constant";
+    SchemaItemType["Phenomenon"] = "Phenomenon";
+    SchemaItemType["UnitSystem"] = "UnitSystem";
+    SchemaItemType["Format"] = "Format";
+})(SchemaItemType || (SchemaItemType = {}));
+/**
+ * Primitive data types for ECProperties.
+ * @beta
+ */
+export var PrimitiveType;
+(function (PrimitiveType) {
+    PrimitiveType[PrimitiveType["Uninitialized"] = 0] = "Uninitialized";
+    PrimitiveType[PrimitiveType["Binary"] = 257] = "Binary";
+    PrimitiveType[PrimitiveType["Boolean"] = 513] = "Boolean";
+    PrimitiveType[PrimitiveType["DateTime"] = 769] = "DateTime";
+    PrimitiveType[PrimitiveType["Double"] = 1025] = "Double";
+    PrimitiveType[PrimitiveType["Integer"] = 1281] = "Integer";
+    PrimitiveType[PrimitiveType["Long"] = 1537] = "Long";
+    PrimitiveType[PrimitiveType["Point2d"] = 1793] = "Point2d";
+    PrimitiveType[PrimitiveType["Point3d"] = 2049] = "Point3d";
+    PrimitiveType[PrimitiveType["String"] = 2305] = "String";
+    PrimitiveType[PrimitiveType["IGeometry"] = 2561] = "IGeometry";
+})(PrimitiveType || (PrimitiveType = {}));
+/**
+ * Defines the valid CustomAttribute container types.
+ * @beta
+ */
+export var CustomAttributeContainerType;
+(function (CustomAttributeContainerType) {
+    CustomAttributeContainerType[CustomAttributeContainerType["Schema"] = 1] = "Schema";
+    CustomAttributeContainerType[CustomAttributeContainerType["EntityClass"] = 2] = "EntityClass";
+    CustomAttributeContainerType[CustomAttributeContainerType["CustomAttributeClass"] = 4] = "CustomAttributeClass";
+    CustomAttributeContainerType[CustomAttributeContainerType["StructClass"] = 8] = "StructClass";
+    CustomAttributeContainerType[CustomAttributeContainerType["RelationshipClass"] = 16] = "RelationshipClass";
+    CustomAttributeContainerType[CustomAttributeContainerType["AnyClass"] = 30] = "AnyClass";
+    CustomAttributeContainerType[CustomAttributeContainerType["PrimitiveProperty"] = 32] = "PrimitiveProperty";
+    CustomAttributeContainerType[CustomAttributeContainerType["StructProperty"] = 64] = "StructProperty";
+    CustomAttributeContainerType[CustomAttributeContainerType["PrimitiveArrayProperty"] = 128] = "PrimitiveArrayProperty";
+    CustomAttributeContainerType[CustomAttributeContainerType["StructArrayProperty"] = 256] = "StructArrayProperty";
+    CustomAttributeContainerType[CustomAttributeContainerType["NavigationProperty"] = 512] = "NavigationProperty";
+    CustomAttributeContainerType[CustomAttributeContainerType["AnyProperty"] = 992] = "AnyProperty";
+    CustomAttributeContainerType[CustomAttributeContainerType["SourceRelationshipConstraint"] = 1024] = "SourceRelationshipConstraint";
+    CustomAttributeContainerType[CustomAttributeContainerType["TargetRelationshipConstraint"] = 2048] = "TargetRelationshipConstraint";
+    CustomAttributeContainerType[CustomAttributeContainerType["AnyRelationshipConstraint"] = 3072] = "AnyRelationshipConstraint";
+    CustomAttributeContainerType[CustomAttributeContainerType["Any"] = 4095] = "Any";
+})(CustomAttributeContainerType || (CustomAttributeContainerType = {}));
+/**
+ * Defines what sort of match should be used when locating a schema.
+ * @beta
+ */
+export var SchemaMatchType;
+(function (SchemaMatchType) {
+    // Find exact VersionRead, VersionWrite, VersionMinor match as well as Data
+    SchemaMatchType[SchemaMatchType["Identical"] = 0] = "Identical";
+    // Find exact VersionRead, VersionWrite, VersionMinor match.
+    SchemaMatchType[SchemaMatchType["Exact"] = 1] = "Exact";
+    // Find latest version with matching VersionRead and VersionWrite
+    SchemaMatchType[SchemaMatchType["LatestWriteCompatible"] = 2] = "LatestWriteCompatible";
+    // Find latest version.
+    SchemaMatchType[SchemaMatchType["Latest"] = 3] = "Latest";
+    // Find latest version with matching VersionRead
+    SchemaMatchType[SchemaMatchType["LatestReadCompatible"] = 4] = "LatestReadCompatible";
+})(SchemaMatchType || (SchemaMatchType = {}));
+/**
+ * Identifer for an ECRelationshipConstraint. Used to determine the side of the relationship the constraint is representing.
+ * @beta
+ */
+export var RelationshipEnd;
+(function (RelationshipEnd) {
+    RelationshipEnd[RelationshipEnd["Source"] = 0] = "Source";
+    RelationshipEnd[RelationshipEnd["Target"] = 1] = "Target";
+})(RelationshipEnd || (RelationshipEnd = {}));
+/** @beta */
+export var StrengthType;
+(function (StrengthType) {
+    StrengthType[StrengthType["Referencing"] = 0] = "Referencing";
+    StrengthType[StrengthType["Holding"] = 1] = "Holding";
+    StrengthType[StrengthType["Embedding"] = 2] = "Embedding";
+})(StrengthType || (StrengthType = {}));
+/** @beta */
+export var StrengthDirection;
+(function (StrengthDirection) {
+    StrengthDirection[StrengthDirection["Forward"] = 1] = "Forward";
+    StrengthDirection[StrengthDirection["Backward"] = 2] = "Backward";
+})(StrengthDirection || (StrengthDirection = {}));
+// Helper methods for going to/from string for the above Enumerations.
+/**
+ * Parses the provided string into an ECClassModifier if the string is a valid modifier.
+ * @param modifier The modifier string to parse.
+ * @beta
+ */
+export function parseClassModifier(modifier) {
+    const lowerModifier = modifier.toLowerCase();
+    switch (lowerModifier) {
+        case "abstract": return ECClassModifier.Abstract;
+        case "none": return ECClassModifier.None;
+        case "sealed": return ECClassModifier.Sealed;
+    }
+    return undefined;
+}
+/**
+ * @return A string representing the provided ECClassModifier. If the modifier is not valid, an empty string is returned.
+ * @beta
+ */
+export function classModifierToString(modifier) {
+    switch (modifier) {
+        case ECClassModifier.Abstract: return "Abstract";
+        case ECClassModifier.None: return "None";
+        case ECClassModifier.Sealed: return "Sealed";
+        default: throw new ECObjectsError(ECObjectsStatus.InvalidModifier, "An invalid ECClassModifier has been provided.");
+    }
+}
+/**
+ * Tries to parse the given string as one of the 8 schema item types.
+ * @param type The schema item type string to parse.
+ * @returns A valid SchemaItemType if successfully parsed. Otherwise, undefined if the provided string is not a valid SchemaItemType.
+ * @beta
+ */
+export function parseSchemaItemType(type) {
+    switch (type.toLowerCase()) {
+        case "entityclass": return SchemaItemType.EntityClass;
+        case "mixin": return SchemaItemType.Mixin;
+        case "structclass": return SchemaItemType.StructClass;
+        case "customattributeclass": return SchemaItemType.CustomAttributeClass;
+        case "relationshipclass": return SchemaItemType.RelationshipClass;
+        case "enumeration": return SchemaItemType.Enumeration;
+        case "kindofquantity": return SchemaItemType.KindOfQuantity;
+        case "propertycategory": return SchemaItemType.PropertyCategory;
+        case "unit": return SchemaItemType.Unit;
+        case "invertedunit": return SchemaItemType.InvertedUnit;
+        case "constant": return SchemaItemType.Constant;
+        case "phenomenon": return SchemaItemType.Phenomenon;
+        case "unitsystem": return SchemaItemType.UnitSystem;
+        case "format": return SchemaItemType.Format;
+    }
+    return undefined;
+}
+/**
+ * Converts a valid SchemaItemType to a display string.
+ * @param value The SchemaItemType to stringify.
+ * @return A string representing the provided SchemaItemType. If the type is not valid, an empty string is returned.
+ * @beta
+ * @deprecated in 4.6.0 SchemaItemType is a string enum so just use it directly
+ */
+export function schemaItemTypeToString(value) {
+    return value; // TODO: Remove
+}
+/** @internal */
+export function schemaItemTypeToXmlString(value) {
+    switch (value) {
+        case SchemaItemType.EntityClass: return "ECEntityClass";
+        case SchemaItemType.Mixin: return "ECEntityClass";
+        case SchemaItemType.StructClass: return "ECStructClass";
+        case SchemaItemType.CustomAttributeClass: return "ECCustomAttributeClass";
+        case SchemaItemType.RelationshipClass: return "ECRelationshipClass";
+        case SchemaItemType.Enumeration: return "ECEnumeration";
+        case SchemaItemType.KindOfQuantity: return "KindOfQuantity";
+        case SchemaItemType.PropertyCategory: return "PropertyCategory";
+        case SchemaItemType.Unit: return "Unit";
+        case SchemaItemType.InvertedUnit: return "InvertedUnit";
+        case SchemaItemType.Constant: return "Constant";
+        case SchemaItemType.Phenomenon: return "Phenomenon";
+        case SchemaItemType.UnitSystem: return "UnitSystem";
+        case SchemaItemType.Format: return "Format";
+        default: throw new ECObjectsError(ECObjectsStatus.InvalidSchemaItemType, "An invalid SchemaItemType has been provided.");
+    }
+}
+/**
+ * Tries to parse the given string as one of the 10 primitive types.
+ * @param type The primitive type string to parse.
+ * @returns A valid PrimitiveType if successfully parsed, or undefined if the provided string is not a valid PrimitiveType.
+ * @beta
+ */
+export function parsePrimitiveType(type) {
+    switch (type.toLowerCase()) {
+        case "binary": return PrimitiveType.Binary;
+        case "boolean":
+        case "bool": return PrimitiveType.Boolean;
+        case "datetime": return PrimitiveType.DateTime;
+        case "double": return PrimitiveType.Double;
+        case "int": return PrimitiveType.Integer;
+        case "long": return PrimitiveType.Long;
+        case "point2d": return PrimitiveType.Point2d;
+        case "point3d": return PrimitiveType.Point3d;
+        case "string": return PrimitiveType.String;
+        case "bentley.geometry.common.igeometry": return PrimitiveType.IGeometry;
+    }
+    return undefined;
+}
+/** @beta */
+export function primitiveTypeToString(type) {
+    switch (type) {
+        case PrimitiveType.Binary: return "binary";
+        case PrimitiveType.Boolean: return "boolean";
+        case PrimitiveType.DateTime: return "dateTime";
+        case PrimitiveType.Double: return "double";
+        case PrimitiveType.Integer: return "int";
+        case PrimitiveType.IGeometry: return "Bentley.Geometry.Common.IGeometry";
+        case PrimitiveType.Long: return "long";
+        case PrimitiveType.Point2d: return "point2d";
+        case PrimitiveType.Point3d: return "point3d";
+        case PrimitiveType.String: return "string";
+        default: throw new ECObjectsError(ECObjectsStatus.InvalidPrimitiveType, "An invalid PrimitiveType has been provided.");
+    }
+}
+/**
+ * Parses the given string into the appropriate CustomAttributeContainerType if the string is valid.
+ * @param type The container type string to parse.
+ * @beta
+ */
+export function parseCustomAttributeContainerType(type) {
+    const typeTokens = type.split(/[|,;]+/);
+    let containerType = 0;
+    typeTokens.forEach((typeToken) => {
+        typeToken = typeToken.trim();
+        if (typeToken.length === 0)
+            return;
+        typeToken = typeToken.toLowerCase();
+        switch (typeToken) {
+            case "schema":
+                containerType = containerType | CustomAttributeContainerType.Schema;
+                break;
+            case "entityclass":
+                containerType = containerType | CustomAttributeContainerType.EntityClass;
+                break;
+            case "customattributeclass":
+                containerType = containerType | CustomAttributeContainerType.CustomAttributeClass;
+                break;
+            case "structclass":
+                containerType = containerType | CustomAttributeContainerType.StructClass;
+                break;
+            case "relationshipclass":
+                containerType = containerType | CustomAttributeContainerType.RelationshipClass;
+                break;
+            case "anyclass":
+                containerType = containerType | CustomAttributeContainerType.AnyClass;
+                break;
+            case "primitiveproperty":
+                containerType = containerType | CustomAttributeContainerType.PrimitiveProperty;
+                break;
+            case "structproperty":
+                containerType = containerType | CustomAttributeContainerType.StructProperty;
+                break;
+            case "arrayproperty":
+                containerType = containerType | CustomAttributeContainerType.PrimitiveArrayProperty;
+                break;
+            case "structarrayproperty":
+                containerType = containerType | CustomAttributeContainerType.StructArrayProperty;
+                break;
+            case "navigationproperty":
+                containerType = containerType | CustomAttributeContainerType.NavigationProperty;
+                break;
+            case "anyproperty":
+                containerType = containerType | CustomAttributeContainerType.AnyProperty;
+                break;
+            case "sourcerelationshipconstraint":
+                containerType = containerType | CustomAttributeContainerType.SourceRelationshipConstraint;
+                break;
+            case "targetrelationshipconstraint":
+                containerType = containerType | CustomAttributeContainerType.TargetRelationshipConstraint;
+                break;
+            case "anyrelationshipconstraint":
+                containerType = containerType | CustomAttributeContainerType.AnyRelationshipConstraint;
+                break;
+            case "any":
+                containerType = containerType | CustomAttributeContainerType.Any;
+                break;
+            default:
+                throw new ECObjectsError(ECObjectsStatus.InvalidContainerType, `${typeToken} is not a valid CustomAttributeContainerType value.`);
+        }
+    });
+    return containerType;
+}
+/**
+ * Creates a string representing a valid CustomAttributeContainerType.
+ * @param value The CustomAttributeContainerType to stringify.
+ * @return A string representing the provided CustomAttributeContainerType. If the type is not valid, an empty string is returned.
+ * @beta
+ */
+export function containerTypeToString(type) {
+    const testContainerTypeValue = (compareType, otherType) => {
+        return (compareType === (compareType & otherType));
+    };
+    if (testContainerTypeValue(CustomAttributeContainerType.Any, type))
+        return ECStringConstants.CONTAINERTYPE_ANY;
+    let containerType = "";
+    const setOrAppend = (val) => {
+        if (containerType.length === 0)
+            containerType = val;
+        else
+            containerType = `${containerType}, ${val}`;
+    };
+    if (testContainerTypeValue(CustomAttributeContainerType.Schema, type))
+        setOrAppend("Schema");
+    if (testContainerTypeValue(CustomAttributeContainerType.AnyClass, type))
+        setOrAppend("AnyClass");
+    else {
+        if (testContainerTypeValue(CustomAttributeContainerType.EntityClass, type))
+            setOrAppend(ECStringConstants.CONTAINERTYPE_ENTITYCLASS);
+        if (testContainerTypeValue(CustomAttributeContainerType.CustomAttributeClass, type))
+            setOrAppend(ECStringConstants.CONTAINERTYPE_CUSTOMATTRIBUTECLASS);
+        if (testContainerTypeValue(CustomAttributeContainerType.StructClass, type))
+            setOrAppend(ECStringConstants.CONTAINERTYPE_STRUCTCLASS);
+        if (testContainerTypeValue(CustomAttributeContainerType.RelationshipClass, type))
+            setOrAppend(ECStringConstants.CONTAINERTYPE_RELATIONSHIPCLASS);
+    }
+    if (testContainerTypeValue(CustomAttributeContainerType.AnyProperty, type))
+        setOrAppend(ECStringConstants.CONTAINERTYPE_ANYPROPERTY);
+    else {
+        if (testContainerTypeValue(CustomAttributeContainerType.PrimitiveProperty, type))
+            setOrAppend(ECStringConstants.CONTAINERTYPE_PRIMITIVEPROPERTY);
+        if (testContainerTypeValue(CustomAttributeContainerType.StructProperty, type))
+            setOrAppend(ECStringConstants.CONTAINERTYPE_STRUCTPROPERTY);
+        if (testContainerTypeValue(CustomAttributeContainerType.PrimitiveArrayProperty, type))
+            setOrAppend(ECStringConstants.CONTAINERTYPE_PRIMITIVEARRAYPROPERTY);
+        if (testContainerTypeValue(CustomAttributeContainerType.StructArrayProperty, type))
+            setOrAppend(ECStringConstants.CONTAINERTYPE_STRUCTARRAYPROPERTY);
+        if (testContainerTypeValue(CustomAttributeContainerType.NavigationProperty, type))
+            setOrAppend(ECStringConstants.CONTAINERTYPE_NAVIGATIONPROPERTY);
+    }
+    if (testContainerTypeValue(CustomAttributeContainerType.AnyRelationshipConstraint, type))
+        setOrAppend(ECStringConstants.CONTAINERTYPE_ANYRELATIONSHIPCONSTRAINT);
+    else {
+        if (testContainerTypeValue(CustomAttributeContainerType.SourceRelationshipConstraint, type))
+            setOrAppend(ECStringConstants.CONTAINERTYPE_SOURCERELATIONSHIPCONSTRAINT);
+        if (testContainerTypeValue(CustomAttributeContainerType.TargetRelationshipConstraint, type))
+            setOrAppend(ECStringConstants.CONTAINERTYPE_TARGETRELATIONSHIPCONSTRAINT);
+    }
+    return containerType;
+}
+/** @beta */
+export function parseRelationshipEnd(end) {
+    switch (end.toLowerCase()) {
+        case "source": return RelationshipEnd.Source;
+        case "target": return RelationshipEnd.Target;
+    }
+    return undefined;
+}
+/** @beta */
+export function relationshipEndToString(end) {
+    switch (end) {
+        case RelationshipEnd.Source: return ECStringConstants.RELATIONSHIP_END_SOURCE;
+        case RelationshipEnd.Target: return ECStringConstants.RELATIONSHIP_END_TARGET;
+        default: throw new ECObjectsError(ECObjectsStatus.InvalidRelationshipEnd, `An invalid RelationshipEnd has been provided.`);
+    }
+}
+/**
+ * Takes a string representing a StrengthType, will parse it and return the corresponding StrengthType.
+ * @throws ECObjectsStatus.InvalidStrength if the provided string that is not valid
+ * @param strength
+ * @beta
+ */
+export function parseStrength(strength) {
+    switch (strength.toLowerCase()) {
+        case "referencing": return StrengthType.Referencing;
+        case "holding": return StrengthType.Holding;
+        case "embedding": return StrengthType.Embedding;
+    }
+    return undefined;
+}
+/** @beta */
+export function strengthToString(strength) {
+    switch (strength) {
+        case StrengthType.Embedding: return "Embedding";
+        case StrengthType.Holding: return "Holding";
+        case StrengthType.Referencing: return "Referencing";
+        default: throw new ECObjectsError(ECObjectsStatus.InvalidStrength, `An invalid Strength has been provided.`);
+    }
+}
+/** @beta */
+export function parseStrengthDirection(direction) {
+    switch (direction.toLowerCase()) {
+        case "forward": return StrengthDirection.Forward;
+        case "backward": return StrengthDirection.Backward;
+    }
+    return undefined;
+}
+/** @beta */
+export function strengthDirectionToString(direction) {
+    switch (direction) {
+        case StrengthDirection.Forward: return "Forward";
+        case StrengthDirection.Backward: return "Backward";
+        default: throw new ECObjectsError(ECObjectsStatus.InvalidStrengthDirection, `An invalid StrengthDirection has been provided.`);
+    }
+}
+//# sourceMappingURL=ECObjects.js.map