Date and time when this entity was created
Date and time when this entity was last updated
Protected_Raw string representation of Configuration from metadata.
If true, allows querying all rows without pagination limits via API
Controls whether this entity participates in server-side and client-side caching at all. When false (default for non-__mj entities), the entire cache code path is short-circuited: no PreRunView cache check, no auto-cache storage, no HandleBaseEntityEvent fingerprint scan, no client-side IndexedDB cache. Zero overhead on hot save/query paths.
Global flag controlling whether records can be created via API
Global flag controlling whether records can be deleted via API
Whether rows may be DELETEd by SQL that does not go through BaseEntity.Delete() — purge and retention routines, or integration sync reconciling against a remote source.
false (the default) means all deletes are expected to flow through BaseEntity. See
AllowDirectSQLInsert for the full rationale and the TrackRecordChanges /
TrustServerCacheCompletely requirement.
Additionally requires DeleteType to be 'Hard': a direct DELETE removes the row
outright rather than setting DeletedAt, so sanctioning it on a soft-delete entity would
quietly defeat soft delete. A database CHECK refuses the combination.
Whether rows may be INSERTed by SQL that does not go through BaseEntity.Save() — bulk loads, ETL/integration sync, or rows created as a side effect of a stored procedure.
false (the default, and every entity that has not opted in) means all inserts are expected
to flow through BaseEntity, which is the only path where record-change tracking, entity
actions, validation and cache invalidation actually run.
This DECLARES intent; it enforces nothing. No constraint, trigger or grant prevents anyone from executing SQL. It exists so the code paths and tooling that choose to honour the platform contract — bulk/ETL and integration sync, record-set processing, and generators or agents authoring SQL — have one authoritative answer instead of tribal knowledge.
A database CHECK requires TrackRecordChanges and TrustServerCacheCompletely
to both be false when this is set, because a direct insert produces neither an audit row
nor a cache-invalidation event — leaving either on yields an audit trail that looks complete
but is not, and a server cache that serves stale rows indefinitely.
Whether rows may be UPDATEd by SQL that does not go through BaseEntity.Save() — bulk backfills, integration sync, or maintenance routines.
false (the default) means all updates are expected to flow through BaseEntity. See
AllowDirectSQLInsert for the full rationale, the "declares, does not enforce"
caveat, and the TrackRecordChanges / TrustServerCacheCompletely requirement.
When false (default), child types are disjoint — a record can only be one child type at a time. When true, a record can simultaneously exist as multiple child types (e.g., a Person can be both a Member and a Volunteer). This flag is set on the parent entity and controls whether its children are exclusive.
Whether records in this entity can be merged together
Global flag controlling whether records can be updated via API
Whether users can search this entity through the search API
Whether to audit when users access records from this entity
Whether to audit when views are run against this entity
Whether CodeGen automatically updates AllowUserSearchAPI from schema rules.
Whether CodeGen automatically updates FullTextSearchEnabled from database catalog/index availability.
When true (default), CodeGen can automatically set SupportsGeoCoding based on LLM analysis of entity fields. Set to false to lock the value.
The underlying database table name this entity maps to
The database view used as a "wrapper" for accessing this entity's data
Whether the base view is generated by CodeGen (true) or manually created (false)
Case-stable canonical schema name, sourced from the app manifest (mj-app.json schema.name) and persisted on SchemaInfo. When non-null it is used in place of SchemaName to derive the schema prefix for the entity ClassName/CodeName and GraphQL type name, so PostgreSQL installs (whose physical SchemaName is folded to lowercase) still produce PascalCase prefixes matching the published, hand-cased entity packages. NULL means "no override" -> the prefix falls back to SchemaName (every existing install, the core __mj schema, and SQL Server).
Whether to automatically delete related records when a parent is deleted
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
If true, uses a custom resolver for GraphQL operations instead of standard CRUD
Type of delete operation: Hard (physical delete) or Soft (mark as deleted)
Detailed description of the entity's purpose and contents
Whether external changes to records are detected.
Optional display name for the entity. If not provided, the entity Name will be used for display purposes.
Whether field-level (column-level) security is enforced for this entity.
This is the single gate every field-security enforcement point checks first, and it is
explicit — never inferred from whether permission rows happen to exist. It is false for
nearly every entity in nearly every deployment, so enforcement collapses to one boolean
test: no field iteration, no aggregation, no allocation.
Turning it on snapshots the entity's existing entity-level permissions into per-field rows, so enabling changes no behavior until an administrator tightens a field. Turning it off leaves the rows in place, inactive, so re-enabling does not lose the configuration.
Import statement for the entity's TypeScript subclass
Name of the TypeScript subclass for this entity if custom behavior is needed
If set, this entity is backed by an external data source (Snowflake, MongoDB, external SQL/PostgreSQL/MySQL, ...) and is read-only. Reads are proxied live through the registered ExternalDataSourceReadRouter. Null = backed by the MJ database.
Remote object name (table/view/collection) on the external system that backs this entity. Resolved against the data source defaults when unqualified. Only meaningful when ExternalDataSourceID is set.
Name of the SQL Server full-text catalog used for searching
Whether the full-text catalog is generated by CodeGen
Name of the full-text index on this entity
Whether the full-text index is generated by CodeGen
Whether full text search is enabled for this entity
Name of the function used for full-text searching
Whether the full-text search function is generated by CodeGen
When set, CodeGen generates the entity's full base view under THIS name instead of
BaseView, and the application owns BaseView — which is expected to wrap it:
CREATE VIEW vwOrderHeaders AS
SELECT g.*, CASE WHEN ... END AS IsOverdue
FROM vwOrderHeadersGenerated g
This is how an entity gets a custom base view WITHOUT inheriting the generated SQL. With
BaseViewGenerated = 0 alone the application takes over the whole view — every related-entity
display join, the geo join, the recursive root-ID apply — and must hand-maintain it forever;
a foreign key added later then silently never appears, because nothing regenerates the join.
Naming an inner view keeps all of that regenerating underneath a thin, reviewable custom layer.
NULL (the default, and every pre-existing entity) preserves the original behaviour exactly:
BaseViewGenerated alone decides whether CodeGen writes BaseView, and there is no second view.
BaseView remains the public surface either way — field discovery, permissions and the
generated CRUD procedures all target it, so a column added by the custom layer becomes a
first-class virtual EntityField.
CSS class or icon identifier for displaying this entity in the UI
Unique identifier for the entity
Whether this entity is available through the GraphQL API
Unique name of the entity used throughout the system
Optional suffix appended to entity names for display purposes
Reserved for future use - parent entity for hierarchical relationships
Field name that contains the preferred communication method (email, phone, etc.)
Default display type for relationships: Search (type-ahead) or Dropdown
Database schema that contains this entity's table and view
Name of the stored procedure for creating records
Whether the create stored procedure is generated by CodeGen
Name of the stored procedure for deleting records
Whether the delete stored procedure is generated by CodeGen
Name of the stored procedure used for matching/duplicate detection
Name of the stored procedure for updating records
Whether the update stored procedure is generated by CodeGen
Optional JSON configuration specifying declarative prospective subtype resolution on an entity. Stored in the SubtypeSelector column of Entity (shape = IEntitySubtypeSelectorConfig).
When true, this entity participates in geo read features: map view, distance calculations, and similar. That is independent of whether GeoCodeSyncService runs on Save — the service only fires when HasWritableGeoSourceFields is true. Auto-set by CodeGen when LLM detects geo-capable fields.
Whether to track all changes to records in the RecordChange table
When true (default), the server-side RunView cache will store and return cached results for this entity, trusting that all mutations flow through BaseEntity.Save() which fires cache invalidation events. Set to false for entities whose rows are created as side-effects of other operations via raw SQL (e.g., Record Changes created by spCreateRecordChange_Internal), since those inserts bypass BaseEntity and never trigger cache invalidation.
Whether the user form for this entity is generated by CodeGen
Maximum number of rows to return in user views to prevent performance issues
If true, this is a virtual entity not backed by a physical database table
Returns all fields from all parent entities in the IS-A chain, excluding primary keys, virtual fields, and timestamp fields (_mj prefixed). These represent the inherited fields that should be available on child entities.
The BaseTable but with spaces inbetween capital letters
Returns all child entities that have their ParentID set to this entity's ID. These represent IS-A type specializations of this entity. Example: For "Products" entity, might return [Meetings, Publications].
When AllowMultipleSubtypes is true on this entity, multiple children can
coexist for the same parent record (overlapping subtypes). When false (default),
only one child type is allowed per parent record (disjoint subtypes).
Optional JSON configuration bag (shape = IEntityConfiguration).
Nested UI.Form holds generated-form chrome: layout, auto left-nav
threshold, related-role policy, and the Primary related budget.
Parsed lazily on first access and cached using SafeJSONParse.
Parsed Configuration. Null when the column is empty or not valid JSON.
Returns an array of all fields whose TypeScript type is Date. Cached — used per query by the data providers' row post-processing to convert datetime values; recomputing the scan (and the per-field TSType classification) on every query is wasteful.
Array of date/datetime fields
Every entity BELOW this one in the IS-A graph, at any depth — the downward twin of ParentChain, which already walks upward.
ChildEntities is DIRECT children only, and that distinction is a trap: on
Products → Meetings → Webinars, Products.ChildEntities omits Webinars entirely, so a
"find every subtype" written against it misses everything past the first level. Not cached,
because subtypes are discovered by scanning all entities and this is not a hot path; guarded
against cycles the same way ParentChain is.
Returns the DisplayName if it exists, otherwise returns the Name.
Returns an array of all fields that are configured for encryption. These fields will be automatically encrypted at rest and decrypted on load.
Array of encrypted fields
Gets the parsed FieldCategoryInfo map for this entity, keyed by category name. Auto-populated from the 'FieldCategoryInfo' EntitySetting (with legacy 'FieldCategoryIcons' fallback) during EntityInfo construction. Returns null if no category info is configured.
Gets all fields for this entity with their complete metadata.
Array of all entity fields
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.
This is a single-column convenience for the places MJ is single-column by design — foreign-key
targets, keyset ORDER BY, IS-A shared keys, and the bare-value shorthand CompositeKey.LoadFromURLSegment
accepts. Do not use it to construct a load key for an arbitrary entity: that silently drops every
column but the first on a composite key. Build keys with CompositeKey.FromURLSegment(entityInfo, recordId)
or CompositeKey.FromEntityRecord(entityInfo, row), which honor all of PrimaryKeys.
Returns an array of all fields that are foreign keys to other entities.
Array of foreign key fields
The view CodeGen actually WRITES for this entity.
Normally BaseView. When GeneratedBaseViewName is set, the generated SQL goes
there instead and BaseView belongs to the application, which layers over it — see
HasLayeredBaseView.
Resolved in ONE place because the two names must never drift: several call sites decide where to write the view, what to call the emitted file, and which object to refresh, and a disagreement between any two of them produces a view that exists under a name nothing reads.
Derived FROM HasLayeredBaseView rather than re-testing GeneratedBaseViewName, so the
two getters cannot disagree by construction. Testing the raw column here would diverge on a
name that differs from BaseView only by case: HasLayeredBaseView would say "not layered"
(it compares case-insensitively, because SQL Server object names are) while this getter
returned the differently-cased string — leaving CodeGen writing to one object while every
layering-gated code path believed there was no second view at all.
Returns true if ANY field on this entity is Deprecated or Disabled (i.e. not Active).
Computed once on first access and cached for the lifetime of this EntityInfo. The value is a property of the entity definition (shared across every record instance), so the common case — an entity whose fields are all Active — is a single cached boolean.
This is the fast-path gate for active-status enforcement in BaseEntity.Get/Set/SetMany: when it is false those paths skip the per-field status lookup entirely, keeping hot read/write loops free of any deprecation-check overhead.
True when this entity has a generated inner view with an application-owned BaseView on top.
In that arrangement CodeGen still generates everything — related-entity display fields, geo columns, recursive root-ID columns — into GeneratedViewName, so the custom layer stays thin and does not go stale when the schema gains a foreign key.
Convenience alias: returns true when this entity is a parent type that allows
overlapping (non-disjoint) subtypes. Equivalent to checking both
IsParentType and AllowMultipleSubtypes.
True when at least one field is a writable Geo* source (street and/or native lat/lng). Person/Org PrimaryAddress* are virtual display fields and do not count.
This entity's role in the IS-A graph as ONE value, for the common "what is this?" lookup.
Intermediate is the case that makes booleans awkward: an entity can be a child AND a parent
at once (Webinars IS-A Meetings IS-A Products makes Meetings both), so code that branches on
IsChildType alone quietly mishandles the middle of every chain deeper than two.
Returns true if this entity is a child type in an IS-A relationship (has a parent entity).
Returns true when this entity is a LEAF of an IS-A hierarchy: it has a parent type and no subtypes of its own. A leaf is the only kind of IS-A entity that can be created by promotion without also being something else's parent.
Returns true if this entity is a parent type in an IS-A relationship (has child entities).
Returns true when this entity is the ROOT of an IS-A hierarchy: it has subtypes below it and
no parent type above it. The root is where the shared primary key originates and where
AllowMultipleSubtypes is decided, so it is the row most IS-A questions resolve back to.
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.
Gets the organic keys defined on this entity. Organic keys enable cross-entity relationships based on shared business data (email, phone, SSN, etc.) rather than foreign key references. Only active organic keys are included.
Array of organic key definitions with their related entities
Walks the IS-A chain upward from this entity to the root, returning all parent entities. Does NOT include this entity itself. Example: For Webinars (IS-A Meetings IS-A Products), returns [Meetings, Products]. Results are cached after first computation for performance.
Returns a cached Set of field names that belong to parent entities in the IS-A chain, including the shared primary key(s). Used for efficient field routing in BaseEntity.Set/Get/SetMany/Hydrate operations. The Set enables O(1) lookup to determine if a field should be routed to the parent entity.
Note: AllParentFields excludes PKs (they aren't "inherited data" fields), but the routing set must include them so that SetMany and Hydrate can forward the shared IS-A primary key to parent entities.
Returns the parent EntityInfo for IS-A type inheritance, or null if this entity has no parent type. Uses the existing ParentID column on the Entity table. Example: For "Meetings" entity with ParentID pointing to "Products", returns the Products EntityInfo.
Returns true when this entity takes part in an IS-A hierarchy at all, in any role.
The cheap guard for "does IS-A apply here?", which otherwise gets written as
IsChildType || IsParentType at every call site — and gets written as just IsChildType
about half the time, which silently skips every root and intermediate type.
Gets the security permissions for this entity by role.
Array of permission settings
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.
Gets all relationships where other entities reference this entity.
Array of entity relationships
The ROOT entity of this entity's IS-A hierarchy — itself when it is already the root, and
null when it takes part in no hierarchy.
Saves every caller the "walk up until ParentEntityInfo is null" loop, which is where the cycle guard gets forgotten. Backed by ParentChain, which is cached and cycle-safe.
Gets custom configuration settings for this entity.
Array of entity-specific settings
Parsed SubtypeSelector configuration, if configured.
Returns an array of all fields that have unique constraints on them.
Array of fields with unique constraints
StaticCreatedReturns 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
StaticDeletedReturns 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
StaticUpdatedReturns 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
ProtectedcopyCopies initialization data from a plain object to the class instance. Only copies properties that already exist on the class to prevent creating new fields. Special handling for DefaultValue fields to extract actual values from SQL Server syntax.
The initialization data object
O(1) case-insensitive field lookup by name. Use this instead of Fields.find(f => f.Name === name)
on hot paths — it builds a lowercased+trimmed Map once (lazily) and reuses it.
NOTE: this is a field-within-entity index, distinct from the entity-level "Map-backed entity lookups" that were evaluated and skipped (~500 entities, negligible). Here a single entity can be read field-by-field in tight loops, so the index is worthwhile.
field name (matched case-insensitively, whitespace-trimmed)
the matching EntityFieldInfo, or undefined if not found
The set of field names this user may NOT supply a value for when CREATING a record. Same per-request precompute contract as GetDeniedReadFields.
Unlike the update set, this does not drive a rejection: a value supplied for a create-denied field is dropped and the column takes its default.
The set of field names this user may NOT READ on this entity — the per-request primitive every field-security enforcement point is built on.
Compute this ONCE per (entity, user) per request and pass the Set into any row loop.
GetUserFieldPermissions is the per-FIELD primitive; calling it per row costs
fields x rows aggregations (40,000 for a 1,000-row x 40-column result), each of which
re-scans user.UserRoles and allocates. A Set lookup costs neither.
Names are lowercased so callers can match case-insensitively, consistent with
ProjectRowsToFields. Returns an EMPTY set — never null — both when the entity has
field security switched off and when the user is denied nothing, so callers can treat
size === 0 as the single "nothing to do" condition.
The set of field names this user may NOT UPDATE on this entity. Same per-request precompute contract as GetDeniedReadFields.
A field can be readable and not updatable. The reverse cannot happen — Read is required for Update — so denied-read is always a subset of denied-update, but ask for the set you actually need rather than relying on that.
The EFFECTIVE row-filter clause for a user + permission type: role RLS (subject to the role exemption) AND the API-key row filters carried on the session (NOT subject to the role exemption — a key ceiling exists precisely to bind principals whose roles are unrestricted; see UserExemptFromRowLevelSecurity, which exempts off the mere presence of a filter-less permission row). Composition: OR within the role layer (roles are additive), AND across layers (no layer can widen another). Returns '' only when no layer contributes.
This is THE method every enforcement point must call. Deterministic by construction — key-filter clauses render in FilterID order and list tokens sort their elements — because the identical clause participates in the RunView cache fingerprint (INV-2): any nondeterminism silently splits or merges cache slots.
The application-ceiling layer (APIApplicationScope.RowFilterID) is deferred to v2 by design decision; the column ships unused and the term composes here when it lands.
Returns the Permissions for this entity for a given user, based on the roles the user is part of.
Allow rows are OR-aggregated across all of the user's matching roles; any single
Allow on an action yields permission for that action. Deny rows from any matching
role then subtract from the aggregated Allow set — so a Deny on CanDelete
overrides a Delete grant that the user otherwise has from another role. This lets
administrators carve out specific role exclusions without restructuring the Allow
hierarchy. Rows with a missing/unknown Type default to Allow for backwards
compatibility with data written before the Type column existed (Phase 2b).
Returns RLS security info attributes for a given user and permission type.
Only permission rows that GRANT the operation contribute a filter: an Allow row whose matching
Can* flag is true. Deny rows are skipped outright — on a Deny row a set Can* flag means
"deny that operation", and a user carrying one fails the permission gate before this runs
(GetUserPermisions subtracts Deny from Allow), so reading it as a grant would be wrong even
though it is unreachable. The filters of a user's roles are OR'd together by the caller, so a filter collected
from a row that does not grant the operation would WIDEN the clause: a user granted Create by
role A (bound to filter F1) would create against F1 OR F2 when role B keeps a leftover
CreateRLSFilterID = F2 beside CanCreate = false. GetUserPermisions aggregates the flags
across roles, so such a user passes the permission gate on role A alone; nothing else stops
F2 from applying. A user with no granting row gets no clause here — and no permission either.
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.
ROLE RLS ONLY — this method is subject to the role-RLS exemption and silently omits API-key row filters, so a caller reaching for this familiar name gets a clause that is fail-open for filtered API-key sessions. Use GetEffectiveRowFilterWhereClause, which composes every filter layer. A repo test asserts no non-test caller exists outside that method.
Whether this user may supply a value for the named field when CREATING a record. Companion to IsFieldReadableByUser. Fails open on the same three conditions.
Note the server does not REJECT a create-denied value — it drops it and takes the column default. So a UI that leaves such a field editable on a new record silently discards what the user typed, which is the case this exists to prevent.
Whether this user may READ the named field — the single-field question, answered the same way GetDeniedReadFields answers it in bulk.
Exists for display code that is about to read a value it did not choose: a form
toolbar rendering the entity's Name field, an FK control rendering the joined display
column, an IS-A card walking a sibling record's fields. BaseEntity.Get() throws for a
denied field, so those call sites have to ask before they read or they take out the whole
screen instead of hiding one value.
This is a PREDICATE, deliberately — not a value accessor that quietly returns nothing. The caller still decides what to render in place of the value, which is the part that differs per surface and should not be hidden inside a getter.
Fails open on a missing user, a missing field name, or an entity with field security
switched off — matching BaseEntity's own gate and MjFormFieldComponent. The server is
the real boundary; a UI that blanked out fields because no user had resolved yet would be
worse than one that shows them.
PERFORMANCE: this delegates to GetDeniedReadFields, which walks every field on the entity. Fine for the handful of chrome reads it exists for; do NOT call it per row in a grid loop — compute the denied set once and test against it.
the field about to be read
the acting user
Whether this user may UPDATE the named field. Companion to IsFieldReadableByUser, for UI that needs to render a control read-only rather than let a user type into something the server will reject on save. Fails open on the same three conditions.
Default JSON serialization for BaseInfo subclasses.
Emits all non-underscored direct field declarations. For _-prefixed private backing fields
(the MJ pattern for collection storage — e.g. _Fields, _RelatedEntities, _OrganicKeys),
emits the value of the corresponding same-named public getter instead. Purely computed getters
without a backing field (display-name formatters, derived flags) are intentionally skipped —
they can throw when source fields are null and don't belong on the wire anyway.
A _-backed getter that throws is omitted from the output rather than aborting the whole
serialization. That omission is safe ONLY because such getters are recomputable: the backing
field is a lazy cache over other serialized state (e.g. QueryInfo.CategoryPath over CategoryID),
so the value is rebuilt on the next access after a warm boot. Do not add a _-backed getter
whose value cannot be recomputed from the serialized fields — a throw would silently drop it.
Nested BaseInfo instances and arrays of them unwrap automatically via JSON.stringify's native toJSON() protocol.
Subclasses may override to emit a filtered subset or custom shape (see EntityFieldValueInfo).
Determines if a given user, for a given permission type, is exempt from RowLevelSecurity or not.
A permission row confers an exemption only for an operation it GRANTS (the matching Can*
flag is true) and leaves unfiltered. A row that does not grant the operation has no filter
for it either, and that absence means "not applicable", not "unrestricted" — so it must not
lift a filter that another of the user's roles binds. Without the Can* check, a role that
grants only reads (CanCreate=false, hence CreateRLSFilterID=null) made every holder of that
role exempt from CREATE row-level security, which is the shape of the 'UI' role every
authenticated user holds on nearly every entity.
StaticAssertThis 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.
the EntityInfo object to check the status of
the name of the caller that is calling this method, used for logging purposes such as BaseEntity::constructor as an example.
StaticBuildReturns a RunViewParams object configured to query the related entity matched via an organic key. Supports both direct field matching and transitive matching via SQL views/tables.
The current record whose organic key values will be used for matching
The organic key related entity configuration
The parent organic key definition
Optionalfilter: stringOptional additional SQL filter to AND with the organic key filter
OptionalmaxRecords: numberOptional max rows to return
RunViewParams ready to pass to RunView
StaticBuildDefault field values for a new related record so it links back to record.
When the relationship's Configuration declares UI.join.fields, every
listed FK is set (Bill-To AND Ship-To). Otherwise only
RelatedEntityJoinField is set.
StaticBuildDefault field values for a new related record, setting every listed join field to the parent key. Use this when one grid filters on several FKs (Bill-To OR Ship-To) so "New" still auto-links the child to this parent.
Optionalrelationship: EntityRelationshipInfoStaticBuildReturns a RunViewParams object that is setup to filter the related entity for the provided record
Optionalfilter: stringOptionalmaxRecords: numberStaticBuildOne related-entity grid over several join fields (Bill-To OR Ship-To).
Catalog of all entities across all schemas. Contains comprehensive metadata about each entity including its database mappings, security settings, and UI preferences.