@memberjunction/global 2.111.0 → 2.112.0

package/dist/generic/entityInfo.d.ts

@@ -0,0 +1,983 @@
+import { BaseInfo } from './baseInfo';
+import { RunViewParams } from '../views/runView';
+import { BaseEntity } from './baseEntity';
+import { RowLevelSecurityFilterInfo, UserInfo } from './securityInfo';
+import { CompositeKey } from './compositeKey';
+/**
+ * The possible status values for a record change
+ */
+export declare const RecordChangeStatus: {
+    readonly Pending: "Pending";
+    readonly Complete: "Complete";
+    readonly Error: "Error";
+};
+export type RecordChangeStatus = (typeof RecordChangeStatus)[keyof typeof RecordChangeStatus];
+/**
+ * Record Change object has information on a change to a record in the Record Changes entity
+ */
+export declare class RecordChange extends BaseInfo {
+    ID: string;
+    EntityID: string;
+    RecordID: any;
+    ChangedAt: Date;
+    ChangesJSON: string;
+    ChangesDescription: string;
+    FullRecordJSON: string;
+    Status: string;
+    get StatusValue(): RecordChangeStatus;
+    get Changes(): any;
+    get FullRecord(): any;
+    constructor(initData: any);
+}
+/**
+ * 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.
+ */
+export declare class EntityRelationshipInfo extends BaseInfo {
+    ID: string;
+    EntityID: string;
+    Sequence: number;
+    RelatedEntityID: string;
+    BundleInAPI: boolean;
+    IncludeInParentAllQuery: boolean;
+    Type: string;
+    EntityKeyField: string;
+    RelatedEntityJoinField: string;
+    JoinView: string;
+    JoinEntityJoinField: string;
+    JoinEntityInverseJoinField: string;
+    DisplayInForm: boolean;
+    DisplayLocation: 'After Field Tabs' | 'Before Field Tabs';
+    DisplayName: string;
+    DisplayIconType: 'Related Entity Icon' | 'Custom' | 'None';
+    DisplayIcon: string;
+    DisplayUserViewID: string;
+    DisplayComponentID: string;
+    DisplayComponentConfiguration: string;
+    __mj_CreatedAt: Date;
+    __mj_UpdatedAt: Date;
+    /**
+     * * 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.
+     */
+    AutoUpdateFromSchema: boolean;
+    Entity: string;
+    EntityBaseTable: string;
+    EntityBaseView: string;
+    RelatedEntity: string;
+    RelatedEntityBaseTable: string;
+    RelatedEntityBaseView: string;
+    RelatedEntityCodeName: string;
+    RelatedEntityClassName: string;
+    RelatedEntityBaseTableCodeName: string;
+    DisplayUserViewName: string;
+    DisplayComponent: string;
+    constructor(initData: any);
+}
+export declare const EntityPermissionType: {
+    readonly Read: "Read";
+    readonly Create: "Create";
+    readonly Update: "Update";
+    readonly Delete: "Delete";
+};
+export type EntityPermissionType = (typeof EntityPermissionType)[keyof typeof EntityPermissionType];
+export declare class EntityUserPermissionInfo {
+    ID: string;
+    Entity: EntityInfo;
+    User: UserInfo;
+    CanCreate: boolean;
+    CanRead: boolean;
+    CanUpdate: boolean;
+    CanDelete: boolean;
+}
+/**
+ * Security settings for each entity.
+ * Controls which roles can perform create, read, update, and delete operations.
+ */
+export declare class EntityPermissionInfo extends BaseInfo {
+    ID: string;
+    EntityID: string;
+    RoleID: string;
+    CanCreate: boolean;
+    CanRead: boolean;
+    CanUpdate: boolean;
+    CanDelete: boolean;
+    ReadRLSFilterID: string;
+    CreateRLSFilterID: string;
+    UpdateRLSFilterID: string;
+    DeleteRLSFilterID: string;
+    __mj_CreatedAt: Date;
+    __mj_UpdatedAt: Date;
+    Entity: string;
+    Role: string;
+    RoleSQLName: string;
+    ReadRLSFilter: string;
+    CreateRLSFilter: string;
+    UpdateRLSFilter: string;
+    DeleteRLSFilter: string;
+    get CreateRLSFilterObject(): RowLevelSecurityFilterInfo;
+    get ReadRLSFilterObject(): RowLevelSecurityFilterInfo;
+    get UpdateRLSFilterObject(): RowLevelSecurityFilterInfo;
+    get DeleteRLSFilterObject(): RowLevelSecurityFilterInfo;
+    RLSFilter(type: EntityPermissionType): RowLevelSecurityFilterInfo;
+    constructor(initData: any);
+}
+export declare const EntityFieldTSType: {
+    readonly String: "string";
+    readonly Number: "number";
+    readonly Date: "Date";
+    readonly Boolean: "boolean";
+};
+export type EntityFieldTSType = (typeof EntityFieldTSType)[keyof typeof EntityFieldTSType];
+export declare const EntityFieldGraphQLType: {
+    readonly Int: "Int";
+    readonly Float: "Float";
+    readonly String: "String";
+    readonly Boolean: "Boolean";
+    readonly Timestamp: "Timestamp";
+};
+export type EntityFieldGraphQLType = (typeof EntityFieldGraphQLType)[keyof typeof EntityFieldGraphQLType];
+export declare const EntityFieldValueListType: {
+    readonly None: "None";
+    readonly List: "List";
+    readonly ListOrUserEntry: "ListOrUserEntry";
+};
+export type EntityFieldValueListType = (typeof EntityFieldValueListType)[keyof typeof EntityFieldValueListType];
+/**
+ * Defines allowed values for entity fields with value lists.
+ * Supports dropdowns, validations, and data integrity constraints.
+ */
+export declare class EntityFieldValueInfo extends BaseInfo {
+    ID: string;
+    EntityFieldID: string;
+    Sequence: number;
+    Value: string;
+    Code: string;
+    Description: string;
+    __mj_CreatedAt: Date;
+    __mj_UpdatedAt: Date;
+    constructor(initData: any);
+}
+export declare const GeneratedFormSectionType: {
+    readonly Top: "Top";
+    readonly Details: "Details";
+    readonly Category: "Category";
+};
+export type GeneratedFormSectionType = (typeof GeneratedFormSectionType)[keyof typeof GeneratedFormSectionType];
+/**
+ * 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.
+ */
+export declare class EntityFieldInfo extends BaseInfo {
+    ID: string;
+    /**
+     * Foreign key to the Entities entity.
+     */
+    EntityID: string;
+    /**
+     * The sequence of the field within the entity, typically the intended display order
+     */
+    Sequence: number;
+    Name: string;
+    /**
+     * 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.
+     */
+    DisplayName: string;
+    Description: string;
+    /**
+     * If true, the field is the primary key for the entity. There must be one primary key field per entity.
+     */
+    IsPrimaryKey: boolean;
+    /**
+     * If true, the field is a unique key for the entity. There can be zero to many unique key fields per entity.
+     */
+    IsUnique: boolean;
+    Category: string;
+    Type: string;
+    Length: number;
+    Precision: number;
+    Scale: number;
+    AllowsNull: boolean;
+    DefaultValue: string;
+    AutoIncrement: boolean;
+    ValueListType: string;
+    ExtendedType: string;
+    DefaultInView: boolean;
+    ViewCellTemplate: string;
+    DefaultColumnWidth: number;
+    AllowUpdateAPI: boolean;
+    AllowUpdateInView: boolean;
+    IncludeInUserSearchAPI: boolean;
+    FullTextSearchEnabled: boolean;
+    UserSearchParamFormatAPI: string;
+    IncludeInGeneratedForm: boolean;
+    GeneratedFormSection: string;
+    IsVirtual: boolean;
+    IsNameField: boolean;
+    RelatedEntityID: string;
+    RelatedEntityFieldName: string;
+    IncludeRelatedEntityNameFieldInBaseView: boolean;
+    RelatedEntityNameFieldMap: string;
+    RelatedEntityDisplayType: 'Search' | 'Dropdown';
+    EntityIDFieldName: string;
+    __mj_CreatedAt: Date;
+    __mj_UpdatedAt: Date;
+    /**
+     * * 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.
+     */
+    ScopeDefault: string | 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.
+     */
+    AutoUpdateRelatedEntityInfo: boolean;
+    /**
+     * * 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.
+     */
+    ValuesToPackWithSchema: 'Auto' | 'None' | 'All';
+    /**
+     * * 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.
+     */
+    GeneratedValidationFunctionName: string | 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.
+     */
+    GeneratedValidationFunctionDescription: string | 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.
+     */
+    GeneratedValidationFunctionCode: string | 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.
+     */
+    GeneratedValidationFunctionCheckConstraint: string | 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
+     */
+    Status: 'Active' | 'Deprecated' | 'Disabled';
+    FieldCodeName: string;
+    Entity: string;
+    SchemaName: string;
+    BaseTable: string;
+    BaseView: string;
+    EntityCodeName: string;
+    EntityClassName: string;
+    RelatedEntity: string;
+    RelatedEntitySchemaName: string;
+    RelatedEntityBaseTable: string;
+    RelatedEntityBaseView: string;
+    RelatedEntityCodeName: string;
+    RelatedEntityClassName: string;
+    IsFloat: boolean;
+    _RelatedEntityTableAlias: string;
+    _RelatedEntityNameFieldIsVirtual: boolean;
+    _EntityFieldValues: EntityFieldValueInfo[];
+    _RelatedEntityNameFieldMap: string;
+    get EntityFieldValues(): EntityFieldValueInfo[];
+    /**
+     * Returns the ValueListType using the EntityFieldValueListType enum.
+     */
+    get ValueListTypeEnum(): EntityFieldValueListType;
+    get GeneratedFormSectionType(): GeneratedFormSectionType;
+    /**
+     * 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(): EntityFieldTSType;
+    /**
+     * Returns true if the field type is a binary type such as binary, varbinary, or image.
+     */
+    get IsBinaryFieldType(): boolean;
+    /**
+     * Returns the Unicode prefix (N) if the field type requires it, otherwise returns an empty string.
+     */
+    get UnicodePrefix(): string;
+    /**
+     * Returns true if the field type requires a Unicode prefix (N) when used in a SQL statement.
+     */
+    get RequiredUnicodePrefix(): boolean;
+    /**
+     * Returns true if the field type requires quotes around the value when used in a SQL statement
+     */
+    get NeedsQuotes(): boolean;
+    /**
+     * 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
+     */
+    private _codeName;
+    get CodeName(): string;
+    get GraphQLType(): EntityFieldGraphQLType;
+    /**
+     * 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(): string;
+    get MaxLength(): number;
+    get ReadOnly(): boolean;
+    /**
+     * 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(): boolean;
+    /**
+     * 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(): boolean;
+    /**
+     * 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(): boolean;
+    /**
+     * 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(): boolean;
+    /**
+     * Returns true if the field is a uniqueidentifier in the database.
+     */
+    get IsUniqueIdentifier(): boolean;
+    /**
+     * Returns true if the field has a default value set
+     */
+    get HasDefaultValue(): boolean;
+    /**
+     * 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(): boolean;
+    /**
+     * Returns the DisplayName if it exists, otherwise returns the Name.
+     */
+    get DisplayNameOrName(): string;
+    /**
+     * 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: any, decimals?: number, currency?: string, maxLength?: number, trailingChars?: string): string;
+    constructor(initData?: any);
+    /**
+     * 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: EntityFieldInfo, callerName: string): void;
+    /**
+     * Readonly array of SQL Server date/time functions that return the current date/time
+     */
+    private static readonly SQL_CURRENT_DATE_FUNCTIONS;
+    /**
+     * 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: string | null | undefined): boolean;
+}
+/**
+ * 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.
+ */
+export declare class EntityDocumentTypeInfo extends BaseInfo {
+    ID: string;
+    Name: string;
+    Description: string;
+    __mj_CreatedAt: Date;
+    __mj_UpdatedAt: Date;
+    constructor(initData?: any);
+}
+/**
+ * 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.
+ */
+export declare class EntitySettingInfo extends BaseInfo {
+    ID: string;
+    EntityID: string;
+    Name: string;
+    Value: string;
+    Comments: string;
+    __mj_CreatedAt: Date;
+    __mj_UpdatedAt: Date;
+    constructor(initData?: any);
+}
+/**
+ * Catalog of all entities across all schemas.
+ * Contains comprehensive metadata about each entity including its database mappings, security settings, and UI preferences.
+ */
+export declare class EntityInfo extends BaseInfo {
+    /**
+     * Unique identifier for the entity
+     */
+    ID: string;
+    /**
+     * Reserved for future use - parent entity for hierarchical relationships
+     */
+    ParentID: string;
+    /**
+     * Unique name of the entity used throughout the system
+     */
+    Name: string;
+    /**
+     * Optional display name for the entity. If not provided, the entity Name will be used for display purposes.
+     */
+    DisplayName: string;
+    /**
+     * Optional suffix appended to entity names for display purposes
+     */
+    NameSuffix: string;
+    /**
+     * Detailed description of the entity's purpose and contents
+     */
+    Description: string;
+    /**
+     * The underlying database table name this entity maps to
+     */
+    BaseTable: string;
+    /**
+     * The database view used as a "wrapper" for accessing this entity's data
+     */
+    BaseView: string;
+    /**
+     * Whether the base view is generated by CodeGen (true) or manually created (false)
+     */
+    BaseViewGenerated: boolean;
+    /**
+     * Database schema that contains this entity's table and view
+     */
+    SchemaName: string;
+    /**
+     * If true, this is a virtual entity not backed by a physical database table
+     */
+    VirtualEntity: boolean;
+    /**
+     * Whether to track all changes to records in the RecordChange table
+     */
+    TrackRecordChanges: boolean;
+    /**
+     * Whether to audit when users access records from this entity
+     */
+    AuditRecordAccess: boolean;
+    /**
+     * Whether to audit when views are run against this entity
+     */
+    AuditViewRuns: boolean;
+    /**
+     * Whether this entity is available through the GraphQL API
+     */
+    IncludeInAPI: boolean;
+    /**
+     * If true, allows querying all rows without pagination limits via API
+     */
+    AllowAllRowsAPI: boolean;
+    /**
+     * Global flag controlling whether records can be updated via API
+     */
+    AllowUpdateAPI: boolean;
+    /**
+     * Global flag controlling whether records can be created via API
+     */
+    AllowCreateAPI: boolean;
+    /**
+     * Global flag controlling whether records can be deleted via API
+     */
+    AllowDeleteAPI: boolean;
+    /**
+     * If true, uses a custom resolver for GraphQL operations instead of standard CRUD
+     */
+    CustomResolverAPI: boolean;
+    /**
+     * Whether users can search this entity through the search API
+     */
+    AllowUserSearchAPI: boolean;
+    /**
+     * Whether full-text search is enabled for this entity
+     */
+    FullTextSearchEnabled: boolean;
+    /**
+     * Name of the SQL Server full-text catalog used for searching
+     */
+    FullTextCatalog: string;
+    /**
+     * Whether the full-text catalog is generated by CodeGen
+     */
+    FullTextCatalogGenerated: boolean;
+    /**
+     * Name of the full-text index on this entity
+     */
+    FullTextIndex: string;
+    /**
+     * Whether the full-text index is generated by CodeGen
+     */
+    FullTextIndexGenerated: boolean;
+    /**
+     * Name of the function used for full-text searching
+     */
+    FullTextSearchFunction: string;
+    /**
+     * Whether the full-text search function is generated by CodeGen
+     */
+    FullTextSearchFunctionGenerated: boolean;
+    /**
+     * Maximum number of rows to return in user views to prevent performance issues
+     */
+    UserViewMaxRows: number;
+    /**
+     * Name of the stored procedure for creating records
+     */
+    spCreate: string;
+    /**
+     * Name of the stored procedure for updating records
+     */
+    spUpdate: string;
+    /**
+     * Name of the stored procedure for deleting records
+     */
+    spDelete: string;
+    /**
+     * Whether the create stored procedure is generated by CodeGen
+     */
+    spCreateGenerated: boolean;
+    /**
+     * Whether the update stored procedure is generated by CodeGen
+     */
+    spUpdateGenerated: boolean;
+    /**
+     * Whether the delete stored procedure is generated by CodeGen
+     */
+    spDeleteGenerated: boolean;
+    /**
+     * Whether to automatically delete related records when a parent is deleted
+     */
+    CascadeDeletes: boolean;
+    /**
+     * Type of delete operation: Hard (physical delete) or Soft (mark as deleted)
+     */
+    DeleteType: 'Hard' | 'Soft';
+    /**
+     * Whether records in this entity can be merged together
+     */
+    AllowRecordMerge: boolean;
+    /**
+     * Name of the stored procedure used for matching/duplicate detection
+     */
+    spMatch: string;
+    /**
+     * Default display type for relationships: Search (type-ahead) or Dropdown
+     */
+    RelationshipDefaultDisplayType: 'Search' | 'Dropdown';
+    /**
+     * Whether the user form for this entity is generated by CodeGen
+     */
+    UserFormGenerated: boolean;
+    /**
+     * Name of the TypeScript subclass for this entity if custom behavior is needed
+     */
+    EntityObjectSubclassName: string;
+    /**
+     * Import statement for the entity's TypeScript subclass
+     */
+    EntityObjectSubclassImport: string;
+    /**
+     * Field name that contains the preferred communication method (email, phone, etc.)
+     */
+    PreferredCommunicationField: string;
+    /**
+     * CSS class or icon identifier for displaying this entity in the UI
+     */
+    Icon: string;
+    /**
+     * Date and time when this entity was created
+     */
+    __mj_CreatedAt: Date;
+    /**
+     * Date and time when this entity was last updated
+     */
+    __mj_UpdatedAt: Date;
+    /**
+     * * 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.
+     */
+    ScopeDefault: string | 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.
+     */
+    RowsToPackWithSchema: 'None' | 'Sample' | 'All';
+    /**
+     * * 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.
+     */
+    RowsToPackSampleMethod: 'random' | 'top n' | 'bottom n';
+    /**
+     * * 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.
+     */
+    RowsToPackSampleCount: number;
+    /**
+     * * 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.
+     */
+    RowsToPackSampleOrder: string | 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.
+     */
+    AutoRowCountFrequency: number | 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.
+     */
+    RowCount: number | 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.
+     */
+    RowCountRunAt: Date | 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.
+     */
+    Status: 'Active' | 'Deprecated' | 'Disabled';
+    /**
+     * 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
+     */
+    CodeName: string;
+    ClassName: string;
+    BaseTableCodeName: string;
+    ParentEntity: number;
+    ParentBaseTable: string;
+    ParentBaseView: string;
+    private _Fields;
+    private _RelatedEntities;
+    private _Permissions;
+    private _Settings;
+    _hasIdField: boolean;
+    _virtualCount: number;
+    _manyToManyCount: number;
+    _oneToManyCount: number;
+    _floatCount: number;
+    /**
+     * 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(): EntityFieldInfo;
+    /**
+     * 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(): EntityFieldInfo[];
+    /**
+     * Returns an array of all fields that have unique constraints on them.
+     * @returns {EntityFieldInfo[]} Array of fields with unique constraints
+     */
+    get UniqueKeys(): EntityFieldInfo[];
+    /**
+     * Returns an array of all fields that are foreign keys to other entities.
+     * @returns {EntityFieldInfo[]} Array of foreign key fields
+     */
+    get ForeignKeys(): EntityFieldInfo[];
+    /**
+     * Gets all fields for this entity with their complete metadata.
+     * @returns {EntityFieldInfo[]} Array of all entity fields
+     */
+    get Fields(): EntityFieldInfo[];
+    /**
+     * Gets all relationships where other entities reference this entity.
+     * @returns {EntityRelationshipInfo[]} Array of entity relationships
+     */
+    get RelatedEntities(): EntityRelationshipInfo[];
+    /**
+     * Gets the security permissions for this entity by role.
+     * @returns {EntityPermissionInfo[]} Array of permission settings
+     */
+    get Permissions(): EntityPermissionInfo[];
+    /**
+     * Gets custom configuration settings for this entity.
+     * @returns {EntitySettingInfo[]} Array of entity-specific settings
+     */
+    get Settings(): EntitySettingInfo[];
+    private static __createdAtFieldName;
+    private static __updatedAtFieldName;
+    private static __deletedAtFieldName;
+    /**
+     * 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(): string;
+    /**
+     * 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(): string;
+    /**
+     * 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(): string;
+    /**
+     * 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: EntityInfo, callerName: string): void;
+    /**
+     * @returns The BaseTable but with spaces inbetween capital letters
+     * */
+    get BaseTableDisplayName(): string;
+    /**
+     * Returns the DisplayName if it exists, otherwise returns the Name.
+     */
+    get DisplayNameOrName(): string;
+    /**
+     * 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(): EntityFieldInfo | null;
+    /**
+     * Returns the Permissions for this entity for a given user, based on the roles the user is part of
+     * @param user
+     * @returns
+     */
+    GetUserPermisions(user: UserInfo): EntityUserPermissionInfo;
+    /**
+     * Determines if a given user, for a given permission type, is exempt from RowLevelSecurity or not
+     * @param user
+     * @param type
+     * @returns
+     */
+    UserExemptFromRowLevelSecurity(user: UserInfo, type: EntityPermissionType): boolean;
+    /**
+     * Returns RLS security info attributes for a given user and permission type
+     * @param user
+     * @param type
+     * @returns
+     */
+    GetUserRowLevelSecurityInfo(user: UserInfo, type: EntityPermissionType): RowLevelSecurityFilterInfo[];
+    /**
+     * 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: UserInfo, type: EntityPermissionType, returnPrefix: string): string;
+    /**
+     * 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: BaseEntity, relationship: EntityRelationshipInfo, filter?: string, maxRecords?: number): RunViewParams;
+    /**
+     * 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: BaseEntity, relationship: EntityRelationshipInfo): any;
+    constructor(initData?: any);
+    private prepareSpecialFields;
+}
+/**
+ * Information about the link between two entities
+ */
+export declare class EntityDependency {
+    /**
+     * The name of the entity that is the "parent" in the relationship
+     */
+    EntityName: string;
+    /**
+     * The name of the entity that is the "child" in the relationship
+     */
+    RelatedEntityName: string;
+    /**
+     * The name of the field in the related entity that is the foreign key field back to the primary key of the "parent" entity
+     */
+    FieldName: string;
+}
+/**
+ * Information about the link between two records
+ */
+export declare class RecordDependency {
+    /**
+     * The name of the entity that is the "parent" in the relationship
+     */
+    EntityName: string;
+    /**
+     * The name of the entity that is the "child" in the relationship
+     */
+    RelatedEntityName: string;
+    /**
+     * The name of the field in the related entity that is the foreign key field back to the primary key of the "parent" entity
+     */
+    FieldName: string;
+    /**
+     * The value of the primary key field in the parent record. MemberJunction supports composite(multi-field) primary keys. However, foreign keys only support links to single-valued primary keys in their linked entity.
+     */
+    PrimaryKey: CompositeKey;
+}
+/**
+ * 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.
+ */
+export declare class RecordMergeRequest {
+    /**
+     * The name of the entity to merge records for
+     */
+    EntityName: string;
+    /**
+     * The composite key for the surviving record
+     */
+    SurvivingRecordCompositeKey: CompositeKey;
+    /**
+     * The composite key(s) for the record(s) to merge into the surviving record
+     */
+    RecordsToMerge: CompositeKey[];
+    /**
+     * If you want to keep the values in the fields of the surviving record as they are, leave this blank. If you want to override the values in the surviving record with other values, specify the values you would like for each field in this array of objects. Each object has two properties, FieldName and Value. The FieldName is the name of the field to set and the Value is the value to set in it.
+     */
+    FieldMap?: {
+        FieldName: string;
+        Value: any;
+    }[];
+}
+/**
+ * The result of a merge request for a single record
+ */
+export declare class RecordMergeDetailResult {
+    /**
+     * The primary key value(s) for a record that was merged
+     */
+    CompositeKey: CompositeKey;
+    /**
+     * True if the merge for this specific record was successful, false if not
+     */
+    Success: boolean;
+    /**
+     * Deletion Log ID for the specific record that was merged
+     */
+    RecordMergeDeletionLogID: number | null;
+    /**
+     * Status message, if any, for the specific record that was merged
+     */
+    Message?: string;
+}
+/**
+ * The result of a merge request
+ */
+export declare class RecordMergeResult {
+    /**
+     * True if the merge was successful, false if not
+     */
+    Success: boolean;
+    /**
+     * Status message on the overall operation
+     */
+    OverallStatus: string;
+    /**
+     * The ID of the log record for the merge operation
+     */
+    RecordMergeLogID: string | null;
+    /**
+     * The details of the merge operation, including the status of each record that was merged
+     */
+    RecordStatus: RecordMergeDetailResult[];
+    /**
+     * The original merge request that was passed in
+     */
+    Request: RecordMergeRequest;
+}
+//# sourceMappingURL=entityInfo.d.ts.map