@memberjunction/global 2.111.0 → 2.112.0

package/dist/generic/entityInfo.js

@@ -0,0 +1,1401 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecordMergeResult = exports.RecordMergeDetailResult = exports.RecordMergeRequest = exports.RecordDependency = exports.EntityDependency = exports.EntityInfo = exports.EntitySettingInfo = exports.EntityDocumentTypeInfo = exports.EntityFieldInfo = exports.GeneratedFormSectionType = exports.EntityFieldValueInfo = exports.EntityFieldValueListType = exports.EntityFieldGraphQLType = exports.EntityFieldTSType = exports.EntityPermissionInfo = exports.EntityUserPermissionInfo = exports.EntityPermissionType = exports.EntityRelationshipInfo = exports.RecordChange = exports.RecordChangeStatus = void 0;
+const baseInfo_1 = require("./baseInfo");
+const metadata_1 = require("./metadata");
+const util_1 = require("./util");
+const logging_1 = require("./logging");
+/**
+ * The possible status values for a record change
+ */
+exports.RecordChangeStatus = {
+    Pending: 'Pending',
+    Complete: 'Complete',
+    Error: 'Error',
+};
+/**
+ * Record Change object has information on a change to a record in the Record Changes entity
+ */
+class RecordChange extends baseInfo_1.BaseInfo {
+    get StatusValue() {
+        return exports.RecordChangeStatus[this.Status?.trim()];
+    }
+    get Changes() {
+        return JSON.parse(this.ChangesJSON);
+    }
+    get FullRecord() {
+        return JSON.parse(this.FullRecordJSON);
+    }
+    constructor(initData) {
+        super();
+        this.ID = null;
+        this.EntityID = null;
+        this.RecordID = null;
+        this.ChangedAt = null;
+        this.ChangesJSON = null;
+        this.ChangesDescription = null;
+        this.FullRecordJSON = null;
+        this.Status = null;
+        this.copyInitData(initData);
+    }
+}
+exports.RecordChange = RecordChange;
+/**
+ * Information about the Entity Relationship between the Entity and the Related Entity - this class
+ * maps to information in the Entity Relationships metadata entity.
+ */
+/**
+ * Metadata about relationships between entities including display preferences for the UI.
+ * Defines foreign key relationships and how they should be represented in the user interface.
+ */
+class EntityRelationshipInfo extends baseInfo_1.BaseInfo {
+    constructor(initData) {
+        super();
+        this.ID = null;
+        this.EntityID = null;
+        this.Sequence = null;
+        this.RelatedEntityID = null;
+        this.BundleInAPI = null;
+        this.IncludeInParentAllQuery = null;
+        this.Type = null;
+        this.EntityKeyField = null;
+        this.RelatedEntityJoinField = null;
+        this.JoinView = null;
+        this.JoinEntityJoinField = null;
+        this.JoinEntityInverseJoinField = null;
+        this.DisplayInForm = null;
+        this.DisplayLocation = 'After Field Tabs';
+        this.DisplayName = null;
+        this.DisplayIconType = 'Related Entity Icon';
+        this.DisplayIcon = null;
+        this.DisplayUserViewID = null;
+        this.DisplayComponentID = null;
+        this.DisplayComponentConfiguration = null;
+        this.__mj_CreatedAt = null;
+        this.__mj_UpdatedAt = null;
+        /**
+         * * Field Name: AutoUpdateFromSchema
+         * * Display Name: Auto Update From Schema
+         * * SQL Data Type: bit
+         * * Default Value: true
+         * * Description: Indicates whether this relationship should be automatically updated by CodeGen. When set to 0, the record will not be modified by CodeGen. Defaults to true.
+         */
+        this.AutoUpdateFromSchema = true;
+        // virtual fields - returned by the database VIEW
+        this.Entity = null;
+        this.EntityBaseTable = null;
+        this.EntityBaseView = null;
+        this.RelatedEntity = null;
+        this.RelatedEntityBaseTable = null;
+        this.RelatedEntityBaseView = null;
+        this.RelatedEntityCodeName = null;
+        this.RelatedEntityClassName = null;
+        this.RelatedEntityBaseTableCodeName = null;
+        this.DisplayUserViewName = null;
+        this.DisplayComponent = null;
+        this.copyInitData(initData);
+    }
+}
+exports.EntityRelationshipInfo = EntityRelationshipInfo;
+exports.EntityPermissionType = {
+    Read: 'Read',
+    Create: 'Create',
+    Update: 'Update',
+    Delete: 'Delete',
+};
+class EntityUserPermissionInfo {
+    constructor() {
+        this.ID = null;
+    }
+}
+exports.EntityUserPermissionInfo = EntityUserPermissionInfo;
+/**
+ * Security settings for each entity.
+ * Controls which roles can perform create, read, update, and delete operations.
+ */
+class EntityPermissionInfo extends baseInfo_1.BaseInfo {
+    get CreateRLSFilterObject() {
+        return this.RLSFilter(exports.EntityPermissionType.Create);
+    }
+    get ReadRLSFilterObject() {
+        return this.RLSFilter(exports.EntityPermissionType.Read);
+    }
+    get UpdateRLSFilterObject() {
+        return this.RLSFilter(exports.EntityPermissionType.Update);
+    }
+    get DeleteRLSFilterObject() {
+        return this.RLSFilter(exports.EntityPermissionType.Delete);
+    }
+    RLSFilter(type) {
+        let fID = '';
+        switch (type) {
+            case exports.EntityPermissionType.Read:
+                fID = this.ReadRLSFilterID;
+                break;
+            case exports.EntityPermissionType.Create:
+                fID = this.CreateRLSFilterID;
+                break;
+            case exports.EntityPermissionType.Update:
+                fID = this.UpdateRLSFilterID;
+                break;
+            case exports.EntityPermissionType.Delete:
+                fID = this.DeleteRLSFilterID;
+                break;
+        }
+        if (fID && fID.length > 0)
+            return metadata_1.Metadata.Provider.RowLevelSecurityFilters.find((f) => f.ID === fID);
+    }
+    constructor(initData) {
+        super();
+        this.ID = null;
+        this.EntityID = null;
+        this.RoleID = null;
+        this.CanCreate = null;
+        this.CanRead = null;
+        this.CanUpdate = null;
+        this.CanDelete = null;
+        this.ReadRLSFilterID = null;
+        this.CreateRLSFilterID = null;
+        this.UpdateRLSFilterID = null;
+        this.DeleteRLSFilterID = null;
+        this.__mj_CreatedAt = null;
+        this.__mj_UpdatedAt = null;
+        // virtual fields - returned by the database VIEW
+        this.Entity = null;
+        this.Role = null;
+        this.RoleSQLName = null;
+        this.ReadRLSFilter = null;
+        this.CreateRLSFilter = null;
+        this.UpdateRLSFilter = null;
+        this.DeleteRLSFilter = null;
+        this.copyInitData(initData);
+    }
+}
+exports.EntityPermissionInfo = EntityPermissionInfo;
+exports.EntityFieldTSType = {
+    String: 'string',
+    Number: 'number',
+    Date: 'Date',
+    Boolean: 'boolean',
+};
+exports.EntityFieldGraphQLType = {
+    Int: 'Int',
+    Float: 'Float',
+    String: 'String',
+    Boolean: 'Boolean',
+    Timestamp: 'Timestamp',
+};
+exports.EntityFieldValueListType = {
+    None: 'None',
+    List: 'List',
+    ListOrUserEntry: 'ListOrUserEntry',
+};
+/**
+ * Defines allowed values for entity fields with value lists.
+ * Supports dropdowns, validations, and data integrity constraints.
+ */
+class EntityFieldValueInfo extends baseInfo_1.BaseInfo {
+    constructor(initData) {
+        super();
+        this.ID = null;
+        this.EntityFieldID = null; // EntityFieldID is a uniqueidentifier column
+        this.Sequence = null;
+        this.Value = null;
+        this.Code = null;
+        this.Description = null;
+        this.__mj_CreatedAt = null;
+        this.__mj_UpdatedAt = null;
+        this.copyInitData(initData);
+    }
+}
+exports.EntityFieldValueInfo = EntityFieldValueInfo;
+exports.GeneratedFormSectionType = {
+    Top: 'Top',
+    Details: 'Details',
+    Category: 'Category',
+};
+/**
+ * Field information within an entity - object models data from the Entity Fields entity in the metadata
+ */
+/**
+ * List of all fields within each entity with metadata about each field.
+ * Includes data types, relationships, defaults, and UI display preferences.
+ */
+class EntityFieldInfo extends baseInfo_1.BaseInfo {
+    get EntityFieldValues() {
+        return this._EntityFieldValues;
+    }
+    /**
+     * Returns the ValueListType using the EntityFieldValueListType enum.
+     */
+    get ValueListTypeEnum() {
+        if (this.ValueListType == null)
+            return exports.EntityFieldValueListType.None;
+        else {
+            // iterate through list of possibilities from enum and compare lcase
+            for (let enumMember in exports.EntityFieldValueListType) {
+                if (typeof exports.EntityFieldValueListType[enumMember] === 'string' &&
+                    enumMember.toLowerCase().trim() === this.ValueListType.toLowerCase().trim()) {
+                    return exports.EntityFieldValueListType[enumMember];
+                }
+            }
+        }
+    }
+    get GeneratedFormSectionType() {
+        return exports.GeneratedFormSectionType[this.GeneratedFormSection];
+    }
+    /**
+     * Provides the TypeScript type for a given Entity Field. This is useful to map
+     * a wide array of database types to a narrower set of TypeScript types.
+     */
+    get TSType() {
+        switch ((0, util_1.TypeScriptTypeFromSQLType)(this.Type).toLowerCase()) {
+            case 'number':
+                return exports.EntityFieldTSType.Number;
+            case 'boolean':
+                return exports.EntityFieldTSType.Boolean;
+            case 'date':
+                return exports.EntityFieldTSType.Date;
+            default:
+                return exports.EntityFieldTSType.String;
+        }
+    }
+    /**
+     * Returns true if the field type is a binary type such as binary, varbinary, or image.
+     */
+    get IsBinaryFieldType() {
+        switch (this.Type.trim().toLowerCase()) {
+            case 'binary':
+            case 'varbinary':
+            case 'image':
+                return true;
+            default:
+                return false;
+        }
+    }
+    /**
+     * Returns the Unicode prefix (N) if the field type requires it, otherwise returns an empty string.
+     */
+    get UnicodePrefix() {
+        if (this.RequiredUnicodePrefix) {
+            return 'N';
+        }
+        else {
+            return '';
+        }
+    }
+    /**
+     * Returns true if the field type requires a Unicode prefix (N) when used in a SQL statement.
+     */
+    get RequiredUnicodePrefix() {
+        switch (this.Type.trim().toLowerCase()) {
+            case 'nchar':
+            case 'nvarchar':
+            case 'ntext':
+                return true;
+            default:
+                return false;
+        }
+    }
+    /**
+     * Returns true if the field type requires quotes around the value when used in a SQL statement
+     */
+    get NeedsQuotes() {
+        switch (this.TSType) {
+            case exports.EntityFieldTSType.Number:
+            case exports.EntityFieldTSType.Boolean:
+                return false;
+            default:
+                return true;
+        }
+    }
+    get CodeName() {
+        if (this._codeName === null) {
+            this._codeName = (0, util_1.CodeNameFromString)(this.Name);
+        }
+        return this._codeName;
+    }
+    get GraphQLType() {
+        switch ((0, util_1.TypeScriptTypeFromSQLType)(this.Type).toLowerCase()) {
+            case 'number':
+                // either an int or float if not an int
+                switch (this.Type.toLowerCase().trim()) {
+                    case 'int':
+                    case 'smallint':
+                    case 'tinyint':
+                    case 'bigint':
+                        return exports.EntityFieldGraphQLType.Int;
+                    default:
+                        return exports.EntityFieldGraphQLType.Float;
+                }
+            case 'boolean':
+                return exports.EntityFieldGraphQLType.Boolean;
+            case 'date':
+                return exports.EntityFieldGraphQLType.Timestamp;
+            default:
+                return exports.EntityFieldGraphQLType.String;
+        }
+    }
+    /**
+     * Returns a string with the full SQL data type that combines, as appropriate, Type, Length, Precision and Scale where these attributes are relevant to the Type
+     */
+    get SQLFullType() {
+        return (0, util_1.SQLFullType)(this.Type, this.Length, this.Precision, this.Scale);
+    }
+    get MaxLength() {
+        return (0, util_1.SQLMaxLength)(this.Type, this.Length);
+    }
+    get ReadOnly() {
+        return this.IsVirtual || !this.AllowUpdateAPI || this.IsPrimaryKey || this.IsSpecialDateField;
+    }
+    /**
+     * Helper method that returns true if the field is one of the special reserved MJ date fields for tracking CreatedAt and UpdatedAt timestamps as well as the DeletedAt timestamp used for entities that
+     * have DeleteType=Soft. This is only used when the entity has TrackRecordChanges=1 or for entities where DeleteType=Soft
+     */
+    get IsSpecialDateField() {
+        return this.IsCreatedAtField || this.IsUpdatedAtField || this.IsDeletedAtField;
+    }
+    /**
+     * Returns true if the field is the CreatedAt field, a special field that is used to track the creation date of a record. This is only used when the entity has TrackRecordChanges=1
+     */
+    get IsCreatedAtField() {
+        return this.Name.trim().toLowerCase() === EntityInfo.CreatedAtFieldName.trim().toLowerCase();
+    }
+    /**
+     * Returns true if the field is the UpdatedAt field, a special field that is used to track the last update date of a record. This is only used when the entity has TrackRecordChanges=1
+     */
+    get IsUpdatedAtField() {
+        return this.Name.trim().toLowerCase() === EntityInfo.UpdatedAtFieldName.trim().toLowerCase();
+    }
+    /**
+     * Returns true if the field is the DeletedAt field, a special field that is used to track the deletion date of a record. This is only used when the entity has DeleteType=Soft
+     */
+    get IsDeletedAtField() {
+        return this.Name.trim().toLowerCase() === EntityInfo.DeletedAtFieldName.trim().toLowerCase();
+    }
+    /**
+     * Returns true if the field is a uniqueidentifier in the database.
+     */
+    get IsUniqueIdentifier() {
+        return this.Type.trim().toLowerCase() === 'uniqueidentifier';
+    }
+    /**
+     * Returns true if the field has a default value set
+     */
+    get HasDefaultValue() {
+        return this.DefaultValue && this.DefaultValue.trim().length > 0;
+    }
+    /**
+     * Returns true if the field is a "special" field (see list below) and is handled inside the DB layer and should be ignored in validation by the BaseEntity architecture
+     * Also, we skip validation if we have a field that is:
+     *  - the primary key
+     *  - an autoincrement field
+     *  - the field is virtual
+     *  - the field is readonly
+     *  - the field is a special date field
+     */
+    get SkipValidation() {
+        const name = this.Name.toLowerCase().trim();
+        return this.IsSpecialDateField || this.IsPrimaryKey || this.AutoIncrement === true || this.IsVirtual === true || this.ReadOnly === true;
+    }
+    /**
+     * Returns the DisplayName if it exists, otherwise returns the Name.
+     */
+    get DisplayNameOrName() {
+        return this.DisplayName ? this.DisplayName : this.Name;
+    }
+    /**
+     * Formats a value based on the parameters passed in. This is a wrapper utility method that already know the SQL type from the entity field definition and simply calls the generic FormatValue() function that is also exported by @memberjunction/core
+     * @param value - Value to format
+     * @param decimals Number of decimals to show, defaults to 2
+     * @param currency Currency to use when formatting, defaults to USD
+     * @param maxLength Maximum length of the string to return, if the formatted value is longer than this length then the string will be truncated and the trailingChars will be appended to the end of the string
+     * @param trailingChars Only used if maxLength is > 0 and the string being formatted is > maxLength, this is the string that will be appended to the end of the string to indicate that it was truncated, defaults to "..."
+     * @returns either the original string value or a formatted version. If the format cannot be applied an an exception occurs it is captured and the error is put to the log, and the original value is returned
+     */
+    FormatValue(value, decimals = 2, currency = 'USD', maxLength = 0, trailingChars = '...') {
+        return (0, util_1.FormatValue)(this.Type, value, decimals, currency, maxLength, trailingChars);
+    }
+    constructor(initData = null) {
+        super();
+        this.ID = null;
+        /**
+         * Foreign key to the Entities entity.
+         */
+        this.EntityID = null;
+        /**
+         * The sequence of the field within the entity, typically the intended display order
+         */
+        this.Sequence = null;
+        this.Name = null;
+        /**
+         * Optional property that provides the display name for the field, if null, use the Name property.
+         * The DisplayNameOrName() method is a helper function that does this for you with a single method call.
+         */
+        this.DisplayName = null;
+        this.Description = null;
+        /**
+         * If true, the field is the primary key for the entity. There must be one primary key field per entity.
+         */
+        this.IsPrimaryKey = null;
+        /**
+         * If true, the field is a unique key for the entity. There can be zero to many unique key fields per entity.
+         */
+        this.IsUnique = null;
+        this.Category = null;
+        this.Type = null;
+        this.Length = null;
+        this.Precision = null;
+        this.Scale = null;
+        this.AllowsNull = null;
+        this.DefaultValue = null;
+        this.AutoIncrement = null;
+        this.ValueListType = null;
+        this.ExtendedType = null;
+        this.DefaultInView = null;
+        this.ViewCellTemplate = null;
+        this.DefaultColumnWidth = null;
+        this.AllowUpdateAPI = null;
+        this.AllowUpdateInView = null;
+        this.IncludeInUserSearchAPI = null;
+        this.FullTextSearchEnabled = false;
+        this.UserSearchParamFormatAPI = null;
+        this.IncludeInGeneratedForm = null;
+        this.GeneratedFormSection = null;
+        this.IsVirtual = null;
+        this.IsNameField = null;
+        this.RelatedEntityID = null;
+        this.RelatedEntityFieldName = null;
+        this.IncludeRelatedEntityNameFieldInBaseView = null;
+        this.RelatedEntityNameFieldMap = null;
+        this.RelatedEntityDisplayType = null;
+        this.EntityIDFieldName = null;
+        this.__mj_CreatedAt = null;
+        this.__mj_UpdatedAt = null;
+        /**
+         * * Field Name: ScopeDefault
+         * * Display Name: Scope Default
+         * * SQL Data Type: nvarchar(100)
+         * * Description: A comma-delimited string indicating the default scope for field visibility. Options include Users, Admins, AI, and All. Defaults to All when NULL. This is used for a simple method of filtering field defaults for visibility, not security enforcement.
+         */
+        this.ScopeDefault = null;
+        /**
+         * * Field Name: AutoUpdateRelatedEntityInfo
+         * * Display Name: Auto Update Related Entity Info
+         * * SQL Data Type: bit
+         * * Default Value: 1
+         * * Description: Indicates whether the related entity information should be automatically updated from the database schema. When set to 0, relationships not part of the database schema can be manually defined at the application and AI agent level. Defaults to 1.
+         */
+        this.AutoUpdateRelatedEntityInfo = true;
+        /**
+         * * Field Name: ValuesToPackWithSchema
+         * * Display Name: Values To Pack With Schema
+         * * SQL Data Type: nvarchar(10)
+         * * Default Value: Auto
+         * * Value List Type: List
+         * * Possible Values
+         *   * Auto
+         *   * None
+         *   * All
+         * * Description: Determines whether values for the field should be included when the schema is packed. Options: Auto (include manually set or auto-derived values), None (exclude all values), All (include all distinct values from the table). Defaults to Auto.
+         */
+        this.ValuesToPackWithSchema = 'Auto';
+        /**
+         * * Field Name: GeneratedValidationFunctionName
+         * * Display Name: Generated Validation Function Name
+         * * SQL Data Type: nvarchar(255)
+         * * Default Value: null
+         * * Description: Contains the name of the generated field validation function, if it exists, null otherwise.
+         */
+        this.GeneratedValidationFunctionName = null;
+        /**
+         * * Field Name: GeneratedValidationFunctionDescription
+         * * Display Name: Generated Validation Function Description
+         * * SQL Data Type: nvarchar(max)
+         * * Default Value: null
+         * * Description: Contains a description for business users of what the validation function for this field does, if it exists.
+         */
+        this.GeneratedValidationFunctionDescription = null;
+        /**
+         * * Field Name: GeneratedValidationFunctionCode
+         * * Display Name: Generated Validation Function Code
+         * * SQL Data Type: nvarchar(max)
+         * * Default Value: null
+         * * Description: Contains the generated code for the field validation function, if it exists, null otherwise.
+         */
+        this.GeneratedValidationFunctionCode = null;
+        /**
+         * * Field Name: GeneratedValidationFunctionCheckConstraint
+         * * Display Name: Generated Validation Function Check Constraint
+         * * SQL Data Type: nvarchar(max)
+         * * Default Value: null
+         * * Description: If a generated validation function was generated previously, this stores the text from the source CHECK constraint in the database. This is stored so that regeneration of the validation function will only occur when the source CHECK constraint changes.
+         */
+        this.GeneratedValidationFunctionCheckConstraint = null;
+        /**
+         * * Field Name: Status
+         * * Display Name: Status
+         * * SQL Data Type: nvarchar(25)
+         * * Default Value: Active
+         * * Value List Type: List
+         * * Possible Values
+         *   * Active
+         *   * Deprecated
+         *   * Disabled
+         * * Description: Current status of the entity field - Active fields are available for use, Deprecated fields are discouraged but still functional, Disabled fields are not available for use
+         */
+        this.Status = 'Active';
+        // virtual fields - returned by the database VIEW
+        this.FieldCodeName = null;
+        this.Entity = null;
+        this.SchemaName = null;
+        this.BaseTable = null;
+        this.BaseView = null;
+        this.EntityCodeName = null;
+        this.EntityClassName = null;
+        this.RelatedEntity = null;
+        this.RelatedEntitySchemaName = null;
+        this.RelatedEntityBaseTable = null;
+        this.RelatedEntityBaseView = null;
+        this.RelatedEntityCodeName = null;
+        this.RelatedEntityClassName = null;
+        /**
+         * For fields in the database that have characters invalid for SQL identifiers in them, we need to replace those characters with _ in order to create variables for stored procedures.
+         * This property returns a consistent CodeName you can use everywhere to refer to the field when generated variable names
+         */
+        this._codeName = null;
+        if (initData) {
+            this.copyInitData(initData);
+            // do some special handling to create class instances instead of just data objects
+            // copy the Entity Field Values
+            this._EntityFieldValues = [];
+            const efv = initData.EntityFieldValues || initData._EntityFieldValues;
+            if (efv) {
+                for (let j = 0; j < efv.length; j++) {
+                    this._EntityFieldValues.push(new EntityFieldValueInfo(efv[j]));
+                }
+            }
+        }
+    }
+    /**
+     * This static factory method is used to check to see if the entity field in question is active or not
+     * If it is not active, it will throw an exception or log a warning depending on the status of the entity field being
+     * either Deprecated or Disabled.
+     * @param entityField - the EntityFieldInfo object to check the status of
+     * @param callerName - the name of the caller that is calling this method, used for logging purposes such as EntityField::constructor as an example.
+     */
+    static AssertEntityFieldActiveStatus(entityField, callerName) {
+        if (!entityField) {
+            throw new Error(`Entity must be provided to call AssertEntityFieldActiveStatus. Caller: ${callerName}`);
+        }
+        if (entityField.Status === 'Active') {
+            return; // no need to check further, the field is active
+        }
+        if (entityField.Status?.trim().toLowerCase() === 'deprecated') {
+            // warning
+            console.warn(`${callerName}: Entity Field ${entityField.Entity}.${entityField.Name} is deprecated and should not be used as it could be removed in the future.`);
+        }
+        else if (entityField.Status?.trim().toLowerCase() === 'disabled') {
+            // console.error and throw the exception
+            const exceptionString = `${callerName}: Entity Field ${entityField.Entity}.${entityField.Name} is disabled and cannot be used.`;
+            (0, logging_1.LogError)(exceptionString);
+            throw new Error(exceptionString);
+        }
+    }
+    /**
+     * Checks if a default value is a SQL Server function that returns the current date/time
+     * @param defaultValue - The default value to check
+     * @returns true if the default value is a SQL current date/time function, false otherwise
+     */
+    static IsDefaultValueSQLCurrentDateFunction(defaultValue) {
+        if (!defaultValue) {
+            return false;
+        }
+        // Trim and lowercase the value for comparison
+        const normalizedValue = defaultValue.trim().toLowerCase();
+        // Check if the normalized value contains any of our known current date functions
+        // Using includes() because the value might be wrapped in parentheses like (getdate())
+        return EntityFieldInfo.SQL_CURRENT_DATE_FUNCTIONS.some((func) => normalizedValue.includes(func));
+    }
+}
+exports.EntityFieldInfo = EntityFieldInfo;
+/**
+ * Readonly array of SQL Server date/time functions that return the current date/time
+ */
+EntityFieldInfo.SQL_CURRENT_DATE_FUNCTIONS = [
+    'getdate()',
+    'getutcdate()',
+    'sysdatetimeoffset()',
+    'current_timestamp',
+    'sysdatetime()',
+    'sysutcdatetime()',
+];
+/**
+ * Entity Document Type Info object has information about the document types that exist across all entities. When Entity Documents are created they are associated with a document type.
+ */
+/**
+ * Defines types of documents that can be generated from entity data.
+ * Supports various output formats for entity records.
+ */
+class EntityDocumentTypeInfo extends baseInfo_1.BaseInfo {
+    constructor(initData = null) {
+        super();
+        this.ID = null;
+        this.Name = null;
+        this.Description = null;
+        this.__mj_CreatedAt = null;
+        this.__mj_UpdatedAt = null;
+        this.copyInitData(initData);
+    }
+}
+exports.EntityDocumentTypeInfo = EntityDocumentTypeInfo;
+/**
+ * Settings allow you to store key/value pairs of information that can be used to configure the behavior of the entity.
+ */
+/**
+ * Stores entity-specific configuration settings.
+ * Allows customization of how entities function within the system.
+ */
+class EntitySettingInfo extends baseInfo_1.BaseInfo {
+    constructor(initData = null) {
+        super();
+        this.ID = null;
+        this.EntityID = null;
+        this.Name = null;
+        this.Value = null;
+        this.Comments = null;
+        this.__mj_CreatedAt = null;
+        this.__mj_UpdatedAt = null;
+        this.copyInitData(initData);
+    }
+}
+exports.EntitySettingInfo = EntitySettingInfo;
+/**
+ * Catalog of all entities across all schemas.
+ * Contains comprehensive metadata about each entity including its database mappings, security settings, and UI preferences.
+ */
+class EntityInfo extends baseInfo_1.BaseInfo {
+    /**
+     * Returns the primary key field for the entity. For entities with a composite primary key, use the PrimaryKeys property which returns all.
+     * In the case of a composite primary key, the PrimaryKey property will return the first field in the sequence of the primary key fields.
+     */
+    get FirstPrimaryKey() {
+        return this.Fields.find((f) => f.IsPrimaryKey);
+    }
+    /**
+     * Returns an array of all fields that are part of the primary key for the entity. If the entity has a single primary key, the array will have a single element.
+     */
+    get PrimaryKeys() {
+        return this.Fields.filter((f) => f.IsPrimaryKey);
+    }
+    /**
+     * Returns an array of all fields that have unique constraints on them.
+     * @returns {EntityFieldInfo[]} Array of fields with unique constraints
+     */
+    get UniqueKeys() {
+        return this.Fields.filter((f) => f.IsUnique);
+    }
+    /**
+     * Returns an array of all fields that are foreign keys to other entities.
+     * @returns {EntityFieldInfo[]} Array of foreign key fields
+     */
+    get ForeignKeys() {
+        return this.Fields.filter((f) => f.RelatedEntityID && f.RelatedEntityID.length > 0);
+    }
+    /**
+     * Gets all fields for this entity with their complete metadata.
+     * @returns {EntityFieldInfo[]} Array of all entity fields
+     */
+    get Fields() {
+        return this._Fields;
+    }
+    /**
+     * Gets all relationships where other entities reference this entity.
+     * @returns {EntityRelationshipInfo[]} Array of entity relationships
+     */
+    get RelatedEntities() {
+        return this._RelatedEntities;
+    }
+    /**
+     * Gets the security permissions for this entity by role.
+     * @returns {EntityPermissionInfo[]} Array of permission settings
+     */
+    get Permissions() {
+        return this._Permissions;
+    }
+    /**
+     * Gets custom configuration settings for this entity.
+     * @returns {EntitySettingInfo[]} Array of entity-specific settings
+     */
+    get Settings() {
+        return this._Settings;
+    }
+    /**
+     * Returns the name of the special reserved field that is used to store the CreatedAt timestamp across all of MJ. This is only used when an entity has TrackRecordChanges turned on
+     */
+    static get CreatedAtFieldName() {
+        return EntityInfo.__createdAtFieldName;
+    }
+    /**
+     * Returns the name of the special reserved field that is used to store the UpdatedAt timestamp across all of MJ. This is only used when an entity has TrackRecordChanges turned on
+     */
+    static get UpdatedAtFieldName() {
+        return EntityInfo.__updatedAtFieldName;
+    }
+    /**
+     * Returns the name of the special reserved field that is used to store the DeletedAt timestamp across all of MJ. This is only used when an entity has DeleteType=Soft
+     */
+    static get DeletedAtFieldName() {
+        return EntityInfo.__deletedAtFieldName;
+    }
+    /**
+     * This static factory method is used to check to see if the entity in question is active or not
+     * If it is not active, it will throw an exception or log a warning depending on the status of the entity being
+     * either Deprecated or Disabled.
+     * @param entity - the EntityInfo object to check the status of
+     * @param callerName - the name of the caller that is calling this method, used for logging purposes such as BaseEntity::constructor as an example.
+     */
+    static AssertEntityActiveStatus(entity, callerName) {
+        if (!entity) {
+            throw new Error(`Entity must be provided to call AssertEntityActiveStatus. Caller: ${callerName}`);
+        }
+        if (entity.Status?.trim().toLowerCase() === 'deprecated') {
+            // warning
+            console.warn(`${callerName}: Entity ${entity.Name} is deprecated and should not be used as it could be removed in the future.`);
+        }
+        else if (entity.Status?.trim().toLowerCase() === 'disabled') {
+            // console.error and throw the exception
+            const exceptionString = `${callerName}: Entity ${entity.Name} is disabled and cannot be used.`;
+            (0, logging_1.LogError)(exceptionString);
+            throw new Error(exceptionString);
+        }
+    }
+    /**
+     * @returns The BaseTable but with spaces inbetween capital letters
+     * */
+    get BaseTableDisplayName() {
+        return this.BaseTable.replace(/([A-Z])/g, ' $1').trim();
+    }
+    /**
+     * Returns the DisplayName if it exists, otherwise returns the Name.
+     */
+    get DisplayNameOrName() {
+        return this.DisplayName ? this.DisplayName : this.Name;
+    }
+    /**
+     * Returns the EntityField object for the Field that has IsNameField set to true. If multiple fields have IsNameField on, the function will return the first field (by sequence) that matches.
+     * If no fields match, if there is a field called "Name", that is returned. If there is no field called "Name", null is returned.
+     */
+    get NameField() {
+        for (let j = 0; j < this.Fields.length; j++) {
+            const ef = this.Fields[j];
+            if (ef.IsNameField)
+                return ef;
+        }
+        // at this point, we return the first field called "Name" if it exists, and the below line will return NULL if we can't find a field called "Name"
+        return this.Fields.find((f) => f.Name.toLowerCase() === 'name');
+    }
+    /**
+     * Returns the Permissions for this entity for a given user, based on the roles the user is part of
+     * @param user
+     * @returns
+     */
+    GetUserPermisions(user) {
+        try {
+            const permissionList = [];
+            for (let j = 0; j < this.Permissions.length; j++) {
+                const ep = this.Permissions[j];
+                const roleMatch = user.UserRoles.find((r) => r.RoleID === ep.RoleID);
+                if (roleMatch)
+                    // user has this role
+                    permissionList.push(ep);
+            }
+            // now that we have matched any number of EntityPermissions to the current user, aggregate the permissions
+            const userPermission = new EntityUserPermissionInfo();
+            userPermission.CanCreate = false;
+            userPermission.CanDelete = false;
+            userPermission.CanRead = false;
+            userPermission.CanUpdate = false;
+            for (let j = 0; j < permissionList.length; j++) {
+                const ep = permissionList[j];
+                userPermission.CanCreate = userPermission.CanCreate || ep.CanCreate;
+                userPermission.CanRead = userPermission.CanRead || ep.CanRead;
+                userPermission.CanUpdate = userPermission.CanUpdate || ep.CanUpdate;
+                userPermission.CanDelete = userPermission.CanDelete || ep.CanDelete;
+            }
+            userPermission.Entity = this;
+            userPermission.User = user;
+            return userPermission;
+        }
+        catch (err) {
+            console.log(err);
+            return null;
+        }
+    }
+    /**
+     * Determines if a given user, for a given permission type, is exempt from RowLevelSecurity or not
+     * @param user
+     * @param type
+     * @returns
+     */
+    UserExemptFromRowLevelSecurity(user, type) {
+        for (let j = 0; j < this.Permissions.length; j++) {
+            const ep = this.Permissions[j];
+            const roleMatch = user.UserRoles.find((r) => r.RoleID === ep.RoleID);
+            if (roleMatch) {
+                // user has this role
+                switch (type) {
+                    case exports.EntityPermissionType.Create:
+                        if (!ep.CreateRLSFilterID)
+                            return true;
+                        break;
+                    case exports.EntityPermissionType.Read:
+                        if (!ep.ReadRLSFilterID)
+                            return true;
+                        break;
+                    case exports.EntityPermissionType.Update:
+                        if (!ep.UpdateRLSFilterID)
+                            return true;
+                        break;
+                    case exports.EntityPermissionType.Delete:
+                        if (!ep.DeleteRLSFilterID)
+                            return true;
+                        break;
+                }
+            }
+        }
+        return false; // if we get here, the user is NOT exempt from RLS for this Permission Type
+    }
+    /**
+     * Returns RLS security info attributes for a given user and permission type
+     * @param user
+     * @param type
+     * @returns
+     */
+    GetUserRowLevelSecurityInfo(user, type) {
+        const rlsList = [];
+        for (let j = 0; j < this.Permissions.length; j++) {
+            const ep = this.Permissions[j];
+            const roleMatch = user.UserRoles.find((r) => r.RoleID === ep.RoleID);
+            if (roleMatch) {
+                // user has this role
+                let matchObject = null;
+                switch (type) {
+                    case exports.EntityPermissionType.Create:
+                        if (ep.CreateRLSFilterID)
+                            matchObject = ep.CreateRLSFilterObject;
+                        break;
+                    case exports.EntityPermissionType.Read:
+                        if (ep.ReadRLSFilterID)
+                            matchObject = ep.ReadRLSFilterObject;
+                        break;
+                    case exports.EntityPermissionType.Update:
+                        if (ep.UpdateRLSFilterID)
+                            matchObject = ep.UpdateRLSFilterObject;
+                        break;
+                    case exports.EntityPermissionType.Delete:
+                        if (ep.DeleteRLSFilterID)
+                            matchObject = ep.DeleteRLSFilterObject;
+                        break;
+                }
+                if (matchObject) {
+                    // we have a match, so add it to the list if it isn't already there
+                    const existingMatch = rlsList.find((r) => r.ID === matchObject.ID);
+                    if (!existingMatch)
+                        rlsList.push(matchObject);
+                }
+            }
+        }
+        return rlsList;
+    }
+    /**
+     * Generates a where clause for SQL filtering for a given entity for a given user and permission type. If there is no RLS for a given entity or the user is exempt from RLS for the entity, a blank string is returned.
+     * @param user
+     * @param type
+     * @param returnPrefix
+     * @returns
+     */
+    GetUserRowLevelSecurityWhereClause(user, type, returnPrefix) {
+        const userRLS = this.GetUserRowLevelSecurityInfo(user, type);
+        if (userRLS && userRLS.length > 0) {
+            // userRLS has all of the objects that apply to this user. The user is NOT exempt from RLS, so we need to OR together all of the RLS object filters
+            let sRLSSQL = '';
+            userRLS.forEach((rls) => {
+                if (sRLSSQL.length > 0)
+                    sRLSSQL += ' OR ';
+                sRLSSQL += `(${rls.MarkupFilterText(user)})`;
+            });
+            return sRLSSQL.length > 0 ? `${returnPrefix && returnPrefix.length > 0 ? returnPrefix + ' ' : ''}${sRLSSQL}` : '';
+        }
+        else
+            return '';
+    }
+    /**
+     * Returns a RunViewParams object that is setup to filter the related entity for the provided record
+     * @param record
+     * @param relationship
+     * @param filter
+     * @returns
+     */
+    static BuildRelationshipViewParams(record, relationship, filter, maxRecords) {
+        const params = {};
+        let quotes = '';
+        let keyValue = '';
+        if (relationship.EntityKeyField && relationship.EntityKeyField.length > 0) {
+            keyValue = record.Get(relationship.EntityKeyField);
+            quotes = record.EntityInfo.Fields.find((f) => f.Name.trim().toLowerCase() === relationship.EntityKeyField.trim().toLowerCase())
+                .NeedsQuotes
+                ? "'"
+                : '';
+        }
+        else {
+            // currently we only support a single value for FOREIGN KEYS, so we can just grab the first value in the primary key
+            const firstKey = record.FirstPrimaryKey;
+            keyValue = firstKey.Value;
+            //When creating a new record, the keyValue is null and the quotes are not needed
+            quotes = keyValue && firstKey.NeedsQuotes ? "'" : '';
+        }
+        if (relationship.Type.trim().toLowerCase() === 'one to many') {
+            // one to many
+            params.ExtraFilter = `[${relationship.RelatedEntityJoinField}] = ${quotes}${keyValue}${quotes}`;
+        }
+        else {
+            // many to many
+            params.ExtraFilter = `[${relationship.RelatedEntityJoinField}] IN (SELECT [${relationship.JoinEntityInverseJoinField}] FROM [${relationship.JoinView}] WHERE [${relationship.JoinEntityJoinField}] = ${quotes}${keyValue}${quotes})`;
+        }
+        if (filter && filter.length > 0)
+            params.ExtraFilter = `(${params.ExtraFilter}) AND (${filter})`; // caller provided their own filter, so AND it in with the relationship filter we have here
+        if (relationship.DisplayUserViewID && relationship.DisplayUserViewID.length > 0) {
+            // we have been given a specific view to run, use it
+            params.ViewID = relationship.DisplayUserViewID;
+        }
+        else {
+            // no view specified, so specify the entity instead
+            params.EntityName = relationship.RelatedEntity;
+        }
+        if (maxRecords && maxRecords > 0)
+            params.MaxRows = maxRecords;
+        return params;
+    }
+    /**
+     * Builds a simple javascript object that will pre-populate a new record in the related entity with values that link back to the specified record.
+     * This is useful, for example, when creating a new contact from an account, we want to pre-populate the account ID in the new contact record
+     */
+    static BuildRelationshipNewRecordValues(record, relationship) {
+        // we want to build a simple javascript object that will pre-populate a new record in the related entity with values that link
+        // abck to the current record. This is useful for example when creating a new contact from an account, we want to pre-populate the
+        // account ID in the new contact record
+        const obj = {};
+        if (record && relationship) {
+            const keyField = relationship.EntityKeyField && relationship.EntityKeyField.trim().length > 0
+                ? relationship.EntityKeyField
+                : record.FirstPrimaryKey.Name;
+            obj[relationship.RelatedEntityJoinField] = record.Get(keyField);
+        }
+        return obj;
+    }
+    constructor(initData = null) {
+        super();
+        /**
+         * Unique identifier for the entity
+         */
+        this.ID = null;
+        /**
+         * Reserved for future use - parent entity for hierarchical relationships
+         */
+        this.ParentID = null;
+        /**
+         * Unique name of the entity used throughout the system
+         */
+        this.Name = null;
+        /**
+         * Optional display name for the entity. If not provided, the entity Name will be used for display purposes.
+         */
+        this.DisplayName = null;
+        /**
+         * Optional suffix appended to entity names for display purposes
+         */
+        this.NameSuffix = null;
+        /**
+         * Detailed description of the entity's purpose and contents
+         */
+        this.Description = null;
+        /**
+         * The underlying database table name this entity maps to
+         */
+        this.BaseTable = null;
+        /**
+         * The database view used as a "wrapper" for accessing this entity's data
+         */
+        this.BaseView = null;
+        /**
+         * Whether the base view is generated by CodeGen (true) or manually created (false)
+         */
+        this.BaseViewGenerated = null;
+        /**
+         * Database schema that contains this entity's table and view
+         */
+        this.SchemaName = null;
+        /**
+         * If true, this is a virtual entity not backed by a physical database table
+         */
+        this.VirtualEntity = null;
+        /**
+         * Whether to track all changes to records in the RecordChange table
+         */
+        this.TrackRecordChanges = null;
+        /**
+         * Whether to audit when users access records from this entity
+         */
+        this.AuditRecordAccess = null;
+        /**
+         * Whether to audit when views are run against this entity
+         */
+        this.AuditViewRuns = null;
+        /**
+         * Whether this entity is available through the GraphQL API
+         */
+        this.IncludeInAPI = false;
+        /**
+         * If true, allows querying all rows without pagination limits via API
+         */
+        this.AllowAllRowsAPI = false;
+        /**
+         * Global flag controlling whether records can be updated via API
+         */
+        this.AllowUpdateAPI = false;
+        /**
+         * Global flag controlling whether records can be created via API
+         */
+        this.AllowCreateAPI = false;
+        /**
+         * Global flag controlling whether records can be deleted via API
+         */
+        this.AllowDeleteAPI = false;
+        /**
+         * If true, uses a custom resolver for GraphQL operations instead of standard CRUD
+         */
+        this.CustomResolverAPI = false;
+        /**
+         * Whether users can search this entity through the search API
+         */
+        this.AllowUserSearchAPI = false;
+        /**
+         * Whether full-text search is enabled for this entity
+         */
+        this.FullTextSearchEnabled = false;
+        /**
+         * Name of the SQL Server full-text catalog used for searching
+         */
+        this.FullTextCatalog = null;
+        /**
+         * Whether the full-text catalog is generated by CodeGen
+         */
+        this.FullTextCatalogGenerated = true;
+        /**
+         * Name of the full-text index on this entity
+         */
+        this.FullTextIndex = null;
+        /**
+         * Whether the full-text index is generated by CodeGen
+         */
+        this.FullTextIndexGenerated = true;
+        /**
+         * Name of the function used for full-text searching
+         */
+        this.FullTextSearchFunction = null;
+        /**
+         * Whether the full-text search function is generated by CodeGen
+         */
+        this.FullTextSearchFunctionGenerated = true;
+        /**
+         * Maximum number of rows to return in user views to prevent performance issues
+         */
+        this.UserViewMaxRows = null;
+        /**
+         * Name of the stored procedure for creating records
+         */
+        this.spCreate = null;
+        /**
+         * Name of the stored procedure for updating records
+         */
+        this.spUpdate = null;
+        /**
+         * Name of the stored procedure for deleting records
+         */
+        this.spDelete = null;
+        /**
+         * Whether the create stored procedure is generated by CodeGen
+         */
+        this.spCreateGenerated = null;
+        /**
+         * Whether the update stored procedure is generated by CodeGen
+         */
+        this.spUpdateGenerated = null;
+        /**
+         * Whether the delete stored procedure is generated by CodeGen
+         */
+        this.spDeleteGenerated = null;
+        /**
+         * Whether to automatically delete related records when a parent is deleted
+         */
+        this.CascadeDeletes = null;
+        /**
+         * Type of delete operation: Hard (physical delete) or Soft (mark as deleted)
+         */
+        this.DeleteType = 'Hard';
+        /**
+         * Whether records in this entity can be merged together
+         */
+        this.AllowRecordMerge = null;
+        /**
+         * Name of the stored procedure used for matching/duplicate detection
+         */
+        this.spMatch = null;
+        /**
+         * Default display type for relationships: Search (type-ahead) or Dropdown
+         */
+        this.RelationshipDefaultDisplayType = null;
+        /**
+         * Whether the user form for this entity is generated by CodeGen
+         */
+        this.UserFormGenerated = null;
+        /**
+         * Name of the TypeScript subclass for this entity if custom behavior is needed
+         */
+        this.EntityObjectSubclassName = null;
+        /**
+         * Import statement for the entity's TypeScript subclass
+         */
+        this.EntityObjectSubclassImport = null;
+        /**
+         * Field name that contains the preferred communication method (email, phone, etc.)
+         */
+        this.PreferredCommunicationField = null;
+        /**
+         * CSS class or icon identifier for displaying this entity in the UI
+         */
+        this.Icon = null;
+        /**
+         * Date and time when this entity was created
+         */
+        this.__mj_CreatedAt = null;
+        /**
+         * Date and time when this entity was last updated
+         */
+        this.__mj_UpdatedAt = null;
+        /**
+         * * Field Name: ScopeDefault
+         * * Display Name: Scope Default
+         * * SQL Data Type: nvarchar(100)
+         * * Description: Optional, comma-delimited string indicating the default scope for entity visibility. Options include Users, Admins, AI, and All. Defaults to All when NULL. This is used for simple defaults for filtering entity visibility, not security enforcement.
+         */
+        this.ScopeDefault = null;
+        /**
+         * * Field Name: RowsToPackWithSchema
+         * * Display Name: Rows To Pack With Schema
+         * * SQL Data Type: nvarchar(20)
+         * * Default Value: None
+         * * Value List Type: List
+         * * Possible Values
+         *   * None
+         *   * Sample
+         *   * All
+         * * Description: Determines how entity rows should be packaged for external use. Options include None, Sample, and All. Defaults to None.
+         */
+        this.RowsToPackWithSchema = 'None';
+        /**
+         * * Field Name: RowsToPackSampleMethod
+         * * Display Name: Rows To Pack Sample Method
+         * * SQL Data Type: nvarchar(20)
+         * * Default Value: random
+         * * Value List Type: List
+         * * Possible Values
+         *   * random
+         *   * top n
+         *   * bottom n
+         * * Description: Defines the sampling method for row packing when RowsToPackWithSchema is set to Sample. Options include random, top n, and bottom n. Defaults to random.
+         */
+        this.RowsToPackSampleMethod = 'random';
+        /**
+         * * Field Name: RowsToPackSampleCount
+         * * Display Name: Rows To Pack Sample Count
+         * * SQL Data Type: int
+         * * Default Value: 0
+         * * Description: The number of rows to pack when RowsToPackWithSchema is set to Sample, based on the designated sampling method. Defaults to 0.
+         */
+        this.RowsToPackSampleCount = 0;
+        /**
+         * * Field Name: RowsToPackSampleOrder
+         * * Display Name: Rows To Pack Sample Order
+         * * SQL Data Type: nvarchar(MAX)
+         * * Description: An optional ORDER BY clause for row packing when RowsToPackWithSchema is set to Sample. Allows custom ordering for selected entity data when using top n and bottom n.
+         */
+        this.RowsToPackSampleOrder = null;
+        /**
+         * * Field Name: AutoRowCountFrequency
+         * * Display Name: Auto Row Count Frequency
+         * * SQL Data Type: int
+         * * Description: Frequency in hours for automatically performing row counts on this entity. If NULL, automatic row counting is disabled. If greater than 0, schedules recurring SELECT COUNT(*) queries at the specified interval.
+         */
+        this.AutoRowCountFrequency = null;
+        /**
+         * * Field Name: RowCount
+         * * Display Name: Row Count
+         * * SQL Data Type: bigint
+         * * Description: Cached row count for this entity, populated by automatic row count processes when AutoRowCountFrequency is configured.
+         */
+        this.RowCount = null;
+        /**
+         * * Field Name: RowCountRunAt
+         * * Display Name: Row Count Run At
+         * * SQL Data Type: datetimeoffset
+         * * Description: Timestamp indicating when the last automatic row count was performed for this entity.
+         */
+        this.RowCountRunAt = null;
+        /**
+         * * Field Name: Status
+         * * Display Name: Status
+         * * SQL Data Type: nvarchar(25)
+         * * Default Value: Active
+         * * Description: Status of the entity. Active: fully functional; Deprecated: functional but generates console warnings when used; Disabled: not available for use even though metadata and physical table remain.
+         */
+        this.Status = 'Active';
+        // virtual fields - returned by the database VIEW
+        /**
+         * CodeName is a unique name that can be used for various programatic purposes, singular version of the entity name but modified from entity name in some cases to remove whitespace and prefix with _ in the event that the entity name begins with a number or other non-alpha character
+         */
+        this.CodeName = null;
+        this.ClassName = null;
+        this.BaseTableCodeName = null;
+        this.ParentEntity = null;
+        this.ParentBaseTable = null;
+        this.ParentBaseView = null;
+        this._hasIdField = false;
+        this._virtualCount = 0;
+        this._manyToManyCount = 0;
+        this._oneToManyCount = 0;
+        this._floatCount = 0;
+        if (initData) {
+            this.copyInitData(initData);
+            // do some special handling to create class instances instead of just data objects
+            // copy the Entity Fields
+            this._Fields = [];
+            const ef = initData.EntityFields || initData._Fields;
+            if (ef) {
+                for (let j = 0; j < ef.length; j++) {
+                    this._Fields.push(new EntityFieldInfo(ef[j]));
+                }
+            }
+            // copy the Entity Permissions
+            this._Permissions = [];
+            const ep = initData.EntityPermissions || initData._Permissions;
+            if (ep) {
+                for (let j = 0; j < ep.length; j++) {
+                    this._Permissions.push(new EntityPermissionInfo(ep[j]));
+                }
+            }
+            // copy the Entity settings
+            this._Settings = [];
+            const es = initData.EntitySettings || initData._Settings;
+            if (es) {
+                es.map((s) => this._Settings.push(new EntitySettingInfo(s)));
+            }
+            // copy the Related Entities
+            this._RelatedEntities = [];
+            const er = initData.EntityRelationships || initData._RelatedEntities;
+            if (er) {
+                // check to see if ANY of the records in the er array have a non-null or non-zero sequence value. The reason is
+                // if we have any sequence values populated we want to sort by that sequence, and we want to consider null to be a high number
+                // so that it sorts to the end of the list
+                let bHasSequence = false;
+                for (const j of er) {
+                    if (j.Sequence !== null && j.Sequence !== undefined && j.Sequence !== 0) {
+                        bHasSequence = true;
+                        break;
+                    }
+                }
+                if (bHasSequence) {
+                    // sort by sequence if we have any populated sequence values
+                    er.sort((a, b) => {
+                        const aSeq = a.Sequence !== null && a.Sequence !== undefined ? a.Sequence : 999999;
+                        const bSeq = b.Sequence !== null && b.Sequence !== undefined ? b.Sequence : 999999;
+                        return aSeq - bSeq;
+                    });
+                }
+                // now that we have prepared the er array by sorting it, if needed, let's load up the related entities
+                for (let j = 0; j < er.length; j++) {
+                    this._RelatedEntities.push(new EntityRelationshipInfo(er[j]));
+                }
+            }
+            this.prepareSpecialFields();
+        }
+    }
+    prepareSpecialFields() {
+        try {
+            let virtualCount = 0;
+            let manyToManyCount = 0;
+            let oneToManyCount = 0;
+            let floatCount = 0;
+            let hasIdField = false;
+            for (let j = 0; j < this.Fields.length; ++j) {
+                const f = this.Fields[j];
+                if (f.Name.trim().toUpperCase() === 'ID')
+                    hasIdField = true;
+                virtualCount += f.IsVirtual ? 1 : 0;
+                floatCount += f.IsFloat ? 1 : 0;
+            }
+            this._hasIdField = hasIdField;
+            this._floatCount = floatCount;
+            this._virtualCount = virtualCount;
+            // now see if there are any relationships and count the one to many and many to many
+            for (let j = 0; j < this.RelatedEntities.length; ++j) {
+                const r = this.RelatedEntities[j];
+                if (r.Type.trim().toUpperCase() === 'ONE TO MANY')
+                    oneToManyCount++;
+                else
+                    manyToManyCount++;
+            }
+            this._manyToManyCount = manyToManyCount;
+            this._oneToManyCount = oneToManyCount;
+        }
+        catch (e) {
+            (0, logging_1.LogError)(e);
+        }
+    }
+}
+exports.EntityInfo = EntityInfo;
+EntityInfo.__createdAtFieldName = '__mj_CreatedAt';
+EntityInfo.__updatedAtFieldName = '__mj_UpdatedAt';
+EntityInfo.__deletedAtFieldName = '__mj_DeletedAt';
+/**
+ * Information about the link between two entities
+ */
+class EntityDependency {
+}
+exports.EntityDependency = EntityDependency;
+/**
+ * Information about the link between two records
+ */
+class RecordDependency {
+}
+exports.RecordDependency = RecordDependency;
+/**
+ * Information about a merge request including the entity, the surviving record and the records to merge into the surviving record. Additionally, there is an optional field map that can be used to override field values in the surviving record to values specified.
+ */
+class RecordMergeRequest {
+}
+exports.RecordMergeRequest = RecordMergeRequest;
+/**
+ * The result of a merge request for a single record
+ */
+class RecordMergeDetailResult {
+}
+exports.RecordMergeDetailResult = RecordMergeDetailResult;
+/**
+ * The result of a merge request
+ */
+class RecordMergeResult {
+}
+exports.RecordMergeResult = RecordMergeResult;
+//# sourceMappingURL=entityInfo.js.map