@memberjunction/core-entities 5.51.0 → 6.1.0-edge.0

package/dist/generated/entity_subclasses.js

@@ -307,7 +307,7 @@ export const MJActionExecutionLogSchema = z.object({
         * * Field Name: Params
         * * Display Name: Params
         * * SQL Data Type: nvarchar(MAX)
-        * * Description: JSON-formatted input parameters passed to the action during execution, storing the exact values used for this specific run.`),
+        * * Description: JSON-formatted input parameters AS THE ACTION WAS CALLED, captured once when execution starts and never overwritten. Custom and Generated actions mutate their parameter array in place, so this is the only durable record of the values actually passed in; the final state lives in ResultParams. Parameter values may be redacted per ActionParam.LogValue / EntityActionParam.LogValue, and whole-record value types are never written - see the parameter's own documentation.`),
     ResultCode: z.string().nullable().describe(`
         * * Field Name: ResultCode
         * * Display Name: Result Code
@@ -337,7 +337,35 @@ export const MJActionExecutionLogSchema = z.object({
         * * Field Name: Message
         * * Display Name: Message
         * * SQL Data Type: nvarchar(MAX)
-        * * Description: JSON-formatted output data or response from the action execution`),
+        * * Description: Human-readable summary message returned by the action - the reason for a refusal, or a short description of what was done. Not the action's output data: parameter values live in Params and ResultParams, and the outcome code in ResultCode.`),
+    EntityActionID: z.string().nullable().describe(`
+        * * Field Name: EntityActionID
+        * * Display Name: Entity Action ID
+        * * SQL Data Type: uniqueidentifier
+        * * Related Entity/Foreign Key: MJ: Entity Actions (vwEntityActions.ID)
+        * * Description: Optional. The Entity Action binding that caused this run. NULL when the action was invoked directly - from a resolver, a script, an agent step or a scheduled action.`),
+    EntityActionInvocationTypeID: z.string().nullable().describe(`
+        * * Field Name: EntityActionInvocationTypeID
+        * * Display Name: Entity Action Invocation Type ID
+        * * SQL Data Type: uniqueidentifier
+        * * Related Entity/Foreign Key: MJ: Entity Action Invocation Types (vwEntityActionInvocationTypes.ID)
+        * * Description: Optional. Which lifecycle event fired the binding - AfterUpdate, Validate, List and so on. Recorded separately from EntityActionID because one binding may be attached to several invocation types, and telling a Validate refusal apart from an AfterUpdate side effect is the first question anyone asks of this log.`),
+    TargetEntityID: z.string().nullable().describe(`
+        * * Field Name: TargetEntityID
+        * * Display Name: Target Entity ID
+        * * SQL Data Type: uniqueidentifier
+        * * Related Entity/Foreign Key: MJ: Entities (vwEntities.ID)
+        * * Description: Optional. The entity of the record this run operated on. Deliberately denormalized rather than joined through EntityActionID: it survives the binding being deleted or retargeted, and it lets the log be queried by record with no join. Kept generic because every invoker has a subject - not only Entity Actions.`),
+    TargetRecordID: z.string().nullable().describe(`
+        * * Field Name: TargetRecordID
+        * * Display Name: Target Record ID
+        * * SQL Data Type: nvarchar(450)
+        * * Description: Optional. The primary key of the record this run operated on, as text, paired with TargetEntityID. For multi-record invocation types (List, View) one log row is written per record, so this is always a single record.`),
+    ResultParams: z.string().nullable().describe(`
+        * * Field Name: ResultParams
+        * * Display Name: Result Params
+        * * SQL Data Type: nvarchar(MAX)
+        * * Description: JSON-formatted FINAL parameter set captured when the action finished - the inputs as the action left them, plus any output parameters it produced. Written on FAILURE exactly as on success, under the same redaction rules: a failed run's partially-mutated inputs are usually the most diagnostic thing available, and an audit trail that records only successes is not an audit trail. Distinct from Params, which holds the values the action was called with and is never overwritten. NULL means one thing only - the run never finished (process died, host killed) - so it is a signal rather than an absence, and must not be backfilled.`),
     Action: z.string().describe(`
         * * Field Name: Action
         * * Display Name: Action
@@ -346,6 +374,18 @@ export const MJActionExecutionLogSchema = z.object({
         * * Field Name: User
         * * Display Name: User
         * * SQL Data Type: nvarchar(100)`),
+    EntityAction: z.string().nullable().describe(`
+        * * Field Name: EntityAction
+        * * Display Name: Entity Action
+        * * SQL Data Type: nvarchar(425)`),
+    EntityActionInvocationType: z.string().nullable().describe(`
+        * * Field Name: EntityActionInvocationType
+        * * Display Name: Entity Action Invocation Type
+        * * SQL Data Type: nvarchar(255)`),
+    TargetEntity: z.string().nullable().describe(`
+        * * Field Name: TargetEntity
+        * * Display Name: Target Entity
+        * * SQL Data Type: nvarchar(255)`),
 });
 /**
  * zod schema definition for the entity MJ: Action Filters
@@ -515,6 +555,12 @@ export const MJActionParamSchema = z.object({
     *   * Image
     *   * Video
         * * Description: Specifies the type of media this parameter outputs when ValueType is MediaOutput. Used for action discovery and validation.`),
+    LogValue: z.boolean().describe(`
+        * * Field Name: LogValue
+        * * Display Name: Log Value
+        * * SQL Data Type: bit
+        * * Default Value: 1
+        * * Description: Whether this parameter's VALUE may be written to ActionExecutionLog.Params. Default 1. Set to 0 for parameters that carry records, credentials or personal data - for example the Data payload of Execute Agent. Independent of the hard rule that Entity Action params of ValueType 'Entity Object' or 'Entity Object Data' are never logged regardless of this flag. When logging is suppressed the log records the parameter name, its type and a redaction marker, never the value.`),
     Action: z.string().describe(`
         * * Field Name: Action
         * * Display Name: Action
@@ -7942,6 +7988,12 @@ export const MJAPIApplicationScopeSchema = z.object({
         * * Display Name: Updated At
         * * SQL Data Type: datetimeoffset
         * * Default Value: getutcdate()`),
+    RowFilterID: z.string().nullable().describe(`
+        * * Field Name: RowFilterID
+        * * Display Name: Row Filter ID
+        * * SQL Data Type: uniqueidentifier
+        * * Related Entity/Foreign Key: MJ: Row Level Security Filters (vwRowLevelSecurityFilters.ID)
+        * * Description: Optional row-level filter acting as a CEILING for every API key operating under this application — a restriction keys inherit and cannot widen. Composes with the per-key filter (APIKeyScope.RowFilterID) and with role-based RLS using AND, never OR, so no layer can broaden another. References the same RowLevelSecurityFilter catalog used by role-based RLS. NULL (the default) means the application imposes no row ceiling. The same authoring constraints as APIKeyScope.RowFilterID apply: exact single-entity resource pattern, all referenced columns must exist on that entity, and all referrers of the filter record must resolve to the same entity.`),
     Application: z.string().describe(`
         * * Field Name: Application
         * * Display Name: Application Name
@@ -7950,6 +8002,10 @@ export const MJAPIApplicationScopeSchema = z.object({
         * * Field Name: Scope
         * * Display Name: Scope Name
         * * SQL Data Type: nvarchar(100)`),
+    RowFilter: z.string().nullable().describe(`
+        * * Field Name: RowFilter
+        * * Display Name: Row Filter
+        * * SQL Data Type: nvarchar(100)`),
 });
 /**
  * zod schema definition for the entity MJ: API Applications
@@ -8083,6 +8139,12 @@ export const MJAPIKeyScopeSchema = z.object({
         * * SQL Data Type: int
         * * Default Value: 0
         * * Description: Rule evaluation order. Higher priority rules are evaluated first. Within same priority, deny rules are evaluated before allow rules.`),
+    RowFilterID: z.string().nullable().describe(`
+        * * Field Name: RowFilterID
+        * * Display Name: Row Filter ID
+        * * SQL Data Type: uniqueidentifier
+        * * Related Entity/Foreign Key: MJ: Row Level Security Filters (vwRowLevelSecurityFilters.ID)
+        * * Description: Optional row-level filter narrowing WHICH RECORDS this scope grant applies to, in addition to the resource pattern that governs which entities. References the same RowLevelSecurityFilter catalog used by role-based RLS, so the filter text flows through the standard {{Token}} substitution engine and every existing RLS enforcement point (RunView, Load by primary key, save, delete, search). NULL (the default) means no row restriction — behavior identical to before this column existed. When set, the rule's ResourcePattern must name a single exact entity (no wildcards, no comma-separated lists), every column the filter references must resolve to a real non-virtual field on that entity, and every other referrer of the same filter record must resolve to that same entity. Critically, this filter is evaluated INDEPENDENTLY of the role-RLS exemption: a user exempt from role RLS is still bound by their key's filter, because narrowing a principal below what their roles allow is the entire purpose of a key ceiling.`),
     APIKey: z.string().describe(`
         * * Field Name: APIKey
         * * Display Name: API Key
@@ -8091,6 +8153,10 @@ export const MJAPIKeyScopeSchema = z.object({
         * * Field Name: Scope
         * * Display Name: Scope
         * * SQL Data Type: nvarchar(100)`),
+    RowFilter: z.string().nullable().describe(`
+        * * Field Name: RowFilter
+        * * Display Name: Row Filter
+        * * SQL Data Type: nvarchar(100)`),
 });
 /**
  * zod schema definition for the entity MJ: API Key Usage Logs
@@ -11799,12 +11865,12 @@ export const MJContentItemChunkSchema = z.object({
         * * Description: Exclusive character offset where this chunk ends within the parent Content Item's extracted text. See StartOffset. NULL for media segments.`),
     StartMs: z.number().nullable().describe(`
         * * Field Name: StartMs
-        * * Display Name: Start (ms)
+        * * Display Name: Start Milliseconds
         * * SQL Data Type: int
         * * Description: Start of this chunk's time window, in milliseconds from the beginning of the parent audio or video asset. Set by transcript- or window-based segmentation; enables time-windowed playback deep-links from a search result (for example 14:22-15:05 of a session recording). NULL for text segments.`),
     EndMs: z.number().nullable().describe(`
         * * Field Name: EndMs
-        * * Display Name: End (ms)
+        * * Display Name: End Milliseconds
         * * SQL Data Type: int
         * * Description: End of this chunk's time window, in milliseconds from the beginning of the parent audio or video asset. See StartMs. NULL for text segments.`),
     PageNumber: z.number().nullable().describe(`
@@ -11840,8 +11906,12 @@ export const MJContentItemChunkSchema = z.object({
         * * Description: Optional self-reference to another chunk of the same Content Item that is the parent of this one, expressing a chapter to sub-chapter hierarchy — for example a five-minute chapter of a recording and the individual speaker turns within it, or a document section and its subsections. NULL for top-level segments.`),
     ContentItem: z.string().nullable().describe(`
         * * Field Name: ContentItem
-        * * Display Name: Content Item
+        * * Display Name: Content Item Name
         * * SQL Data Type: nvarchar(250)`),
+    ParentChunk: z.string().nullable().describe(`
+        * * Field Name: ParentChunk
+        * * Display Name: Parent Chunk Name
+        * * SQL Data Type: nvarchar(500)`),
     RootParentChunkID: z.string().nullable().describe(`
         * * Field Name: RootParentChunkID
         * * Display Name: Root Parent Chunk
@@ -15953,7 +16023,7 @@ export const MJEntitySchema = z.object({
         * * Description: When set to 1 AND TrackRecordChanges is also 1, the external change detection system will scan this entity for changes made outside the MJ framework (direct SQL, third-party tools, etc.) and replay them through Save() to create proper RecordChange audit entries. Default is 0 (opt-out) because most entities, especially __mj schema metadata tables, are managed by migrations/CodeGen and should not be scanned.`),
     ExternalDataSourceID: z.string().nullable().describe(`
         * * Field Name: ExternalDataSourceID
-        * * Display Name: External Data Source ID
+        * * Display Name: External Data Source
         * * SQL Data Type: uniqueidentifier
         * * Related Entity/Foreign Key: MJ: External Data Sources (vwExternalDataSources.ID)`),
     ExternalObjectName: z.string().nullable().describe(`
@@ -15961,6 +16031,29 @@ export const MJEntitySchema = z.object({
         * * Display Name: External Object Name
         * * SQL Data Type: nvarchar(255)
         * * Description: Remote object name (table / view / collection) on the external system that backs this entity. Resolved against the data source DefaultSchema/DefaultDatabase when unqualified. Only meaningful when ExternalDataSourceID is set.`),
+    GeneratedBaseViewName: z.string().nullable().describe(`
+        * * Field Name: GeneratedBaseViewName
+        * * Display Name: Generated Base View Name
+        * * SQL Data Type: nvarchar(255)
+        * * Description: 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 (SELECT g.*, <extras> FROM <GeneratedBaseViewName> g). This gives an entity a custom base view WITHOUT inheriting the generated SQL: related-entity display joins, geo columns and recursive root-ID columns keep regenerating underneath, so a foreign key added later still appears. NULL (the default, and every pre-existing row) means the previous all-or-nothing behaviour: BaseViewGenerated alone decides whether CodeGen writes BaseView, and there is no second view. BaseView remains the public surface — entity field discovery, permissions and the generated CRUD procedures all target it. SQL SERVER ONLY: layering relies on sp_refreshview to re-resolve the application-owned outer view's SELECT * against a regenerated inner view. PostgreSQL freezes a view's column list at creation and has no refresh equivalent, so CodeGen rejects this column on PostgreSQL rather than let the outer view go silently stale.`),
+    AllowDirectSQLInsert: z.boolean().describe(`
+        * * Field Name: AllowDirectSQLInsert
+        * * Display Name: Allow Direct SQL Insert
+        * * SQL Data Type: bit
+        * * Default Value: 0
+        * * Description: When 1, this entity may be populated by INSERT statements that do not go through BaseEntity.Save() — bulk loads, ETL/integration sync, or rows created as a side effect of a stored procedure. Default 0, meaning every insert is expected to flow through BaseEntity so that record-change tracking, entity actions, validation and cache invalidation all run. This column DECLARES intent for the code paths and tooling that consult it; it does not and cannot prevent anyone from executing SQL. Requires TrackRecordChanges = 0 and TrustServerCacheCompletely = 0, because a direct insert produces neither an audit row nor a cache-invalidation event.`),
+    AllowDirectSQLUpdate: z.boolean().describe(`
+        * * Field Name: AllowDirectSQLUpdate
+        * * Display Name: Allow Direct SQL Update
+        * * SQL Data Type: bit
+        * * Default Value: 0
+        * * Description: When 1, this entity may be modified by UPDATE statements that do not go through BaseEntity.Save() — bulk backfills, integration sync, or maintenance routines. Default 0, meaning every update is expected to flow through BaseEntity so that record-change tracking, entity actions, validation and cache invalidation all run. This column DECLARES intent for the code paths and tooling that consult it; it does not and cannot prevent anyone from executing SQL. Requires TrackRecordChanges = 0 and TrustServerCacheCompletely = 0, because a direct update produces neither an audit row nor a cache-invalidation event.`),
+    AllowDirectSQLDelete: z.boolean().describe(`
+        * * Field Name: AllowDirectSQLDelete
+        * * Display Name: Allow Direct SQL Delete
+        * * SQL Data Type: bit
+        * * Default Value: 0
+        * * Description: When 1, this entity may have rows removed by DELETE statements that do not go through BaseEntity.Delete() — purge and retention routines, or integration sync reconciling a remote source. Default 0, meaning every delete is expected to flow through BaseEntity so that record-change tracking, entity actions, cascade handling and cache invalidation all run. This column DECLARES intent for the code paths and tooling that consult it; it does not and cannot prevent anyone from executing SQL. Requires TrackRecordChanges = 0 and TrustServerCacheCompletely = 0, and additionally requires DeleteType = 'Hard' — a direct DELETE removes the row outright rather than setting DeletedAt, which would defeat soft delete.`),
     CodeName: z.string().nullable().describe(`
         * * Field Name: CodeName
         * * Display Name: Code Name
@@ -16155,7 +16248,7 @@ export const MJEntityActionParamSchema = z.object({
         * * Display Name: Action Parameter ID
         * * SQL Data Type: uniqueidentifier
         * * Related Entity/Foreign Key: MJ: Action Params (vwActionParams.ID)`),
-    ValueType: z.union([z.literal('Entity Field'), z.literal('Entity Object'), z.literal('Script'), z.literal('Static')]).describe(`
+    ValueType: z.union([z.literal('Entity Field'), z.literal('Entity Object'), z.literal('Entity Object Data'), z.literal('Script'), z.literal('Static')]).describe(`
         * * Field Name: ValueType
         * * Display Name: Value Type
         * * SQL Data Type: nvarchar(20)
@@ -16163,9 +16256,10 @@ export const MJEntityActionParamSchema = z.object({
     * * Possible Values 
     *   * Entity Field
     *   * Entity Object
+    *   * Entity Object Data
     *   * Script
     *   * Static
-        * * Description: Type of the value, which can be Static, Entity Object, or Script.`),
+        * * Description: How the parameter value is produced at invocation time. Static = the literal Value (parsed as JSON when it parses). Entity Object = the live BaseEntity instance, for actions that call entity methods. Entity Object Data = entity.GetAll(), a plain object - use this for any action that SERIALIZES the value, such as the Data payload of Execute Agent, because a BaseEntity serializes to {} (its fields are getters, not enumerable own properties). Entity Field = the named field's value. Script = evaluated expression with the entity in scope.`),
     Value: z.string().nullable().describe(`
         * * Field Name: Value
         * * Display Name: Value
@@ -16186,6 +16280,11 @@ export const MJEntityActionParamSchema = z.object({
         * * Display Name: Updated At
         * * SQL Data Type: datetimeoffset
         * * Default Value: getutcdate()`),
+    LogValue: z.boolean().nullable().describe(`
+        * * Field Name: LogValue
+        * * Display Name: Log Value
+        * * SQL Data Type: bit
+        * * Description: Optional per-binding override of ActionParam.LogValue. NULL (the default) inherits the parameter definition. Set to 0 when this particular binding passes something sensitive through a parameter that is ordinarily safe to log - a message body through a generic Text parameter, for instance. Cannot re-enable logging for a value type the hard rule suppresses.`),
     EntityAction: z.string().describe(`
         * * Field Name: EntityAction
         * * Display Name: Entity Action
@@ -16235,6 +16334,34 @@ export const MJEntityActionSchema = z.object({
         * * Display Name: ID
         * * SQL Data Type: uniqueidentifier
         * * Default Value: newsequentialid()`),
+    Sequence: z.number().describe(`
+        * * Field Name: Sequence
+        * * Display Name: Sequence
+        * * SQL Data Type: int
+        * * Default Value: 0
+        * * Description: Execution order when multiple Entity Actions are bound to the same entity and invocation type. Lower runs first; ties fall back to creation order. Defaults to 0 so existing rows are unaffected.`),
+    ScopeEntityID: z.string().nullable().describe(`
+        * * Field Name: ScopeEntityID
+        * * Display Name: Scope Entity ID
+        * * SQL Data Type: uniqueidentifier
+        * * Related Entity/Foreign Key: MJ: Entities (vwEntities.ID)
+        * * Description: Optional. Together with ScopeRecordID, narrows this Entity Action to records related to ONE specific record - for example a single Deal Type, Contract Type, Pipeline or Company - rather than every record of EntityID. NULL (the default) means the action applies to all records, which is the pre-existing behaviour. How a scope record relates to the subject record is resolved by the app that owns the scope entity; the framework only stores and filters on the pair.`),
+    ScopeRecordID: z.string().nullable().describe(`
+        * * Field Name: ScopeRecordID
+        * * Display Name: Scope Record ID
+        * * SQL Data Type: nvarchar(450)
+        * * Description: Optional. The primary key of the scope record, as text, paired with ScopeEntityID. Both columns are NULL or both are set (CK_EntityAction_Scope). Lets a configuration record such as a Deal Type surface "the workflows bound to me" as a real relationship rather than something buried in filter code.`),
+    LoggingMode: z.union([z.literal('All'), z.literal('FailuresOnly'), z.literal('None')]).describe(`
+        * * Field Name: LoggingMode
+        * * Display Name: Logging Mode
+        * * SQL Data Type: nvarchar(20)
+        * * Default Value: All
+    * * Value List Type: List
+    * * Possible Values 
+    *   * All
+    *   * FailuresOnly
+    *   * None
+        * * Description: How much of this binding's activity reaches ActionExecutionLog. All (default) writes a row per invocation. FailuresOnly writes only runs that did not succeed - the right setting for a high-frequency binding on a busy entity, where the successful runs are noise. None disables logging for the binding entirely and should be rare, because it also removes the failure record.`),
     Entity: z.string().describe(`
         * * Field Name: Entity
         * * Display Name: Entity
@@ -16243,6 +16370,10 @@ export const MJEntityActionSchema = z.object({
         * * Field Name: Action
         * * Display Name: Action
         * * SQL Data Type: nvarchar(425)`),
+    ScopeEntity: z.string().nullable().describe(`
+        * * Field Name: ScopeEntity
+        * * Display Name: Scope Entity
+        * * SQL Data Type: nvarchar(255)`),
 });
 /**
  * zod schema definition for the entity MJ: Entity AI Actions
@@ -30872,11 +31003,12 @@ export const MJUserViewCategorySchema = z.object({
 export const MJUserViewRunDetailSchema = z.object({
     ID: z.string().describe(`
         * * Field Name: ID
+        * * Display Name: ID
         * * SQL Data Type: uniqueidentifier
         * * Default Value: newsequentialid()`),
     UserViewRunID: z.string().describe(`
         * * Field Name: UserViewRunID
-        * * Display Name: User View Run ID
+        * * Display Name: User View Run
         * * SQL Data Type: uniqueidentifier
         * * Related Entity/Foreign Key: MJ: User View Runs (vwUserViewRuns.ID)`),
     RecordID: z.string().describe(`
@@ -30894,6 +31026,10 @@ export const MJUserViewRunDetailSchema = z.object({
         * * Display Name: Updated At
         * * SQL Data Type: datetimeoffset
         * * Default Value: getutcdate()`),
+    UserViewRun: z.string().describe(`
+        * * Field Name: UserViewRun
+        * * Display Name: User View Run Name
+        * * SQL Data Type: nvarchar(100)`),
     UserViewID: z.string().describe(`
         * * Field Name: UserViewID
         * * Display Name: User View
@@ -32762,7 +32898,7 @@ let MJActionExecutionLogEntity = class MJActionExecutionLogEntity extends BaseEn
     * * Field Name: Params
     * * Display Name: Params
     * * SQL Data Type: nvarchar(MAX)
-    * * Description: JSON-formatted input parameters passed to the action during execution, storing the exact values used for this specific run.
+    * * Description: JSON-formatted input parameters AS THE ACTION WAS CALLED, captured once when execution starts and never overwritten. Custom and Generated actions mutate their parameter array in place, so this is the only durable record of the values actually passed in; the final state lives in ResultParams. Parameter values may be redacted per ActionParam.LogValue / EntityActionParam.LogValue, and whole-record value types are never written - see the parameter's own documentation.
     */
     get Params() {
         return this.Get('Params');
@@ -32828,7 +32964,7 @@ let MJActionExecutionLogEntity = class MJActionExecutionLogEntity extends BaseEn
     * * Field Name: Message
     * * Display Name: Message
     * * SQL Data Type: nvarchar(MAX)
-    * * Description: JSON-formatted output data or response from the action execution
+    * * Description: Human-readable summary message returned by the action - the reason for a refusal, or a short description of what was done. Not the action's output data: parameter values live in Params and ResultParams, and the outcome code in ResultCode.
     */
     get Message() {
         return this.Get('Message');
@@ -32837,6 +32973,69 @@ let MJActionExecutionLogEntity = class MJActionExecutionLogEntity extends BaseEn
         this.Set('Message', value);
     }
     /**
+    * * Field Name: EntityActionID
+    * * Display Name: Entity Action ID
+    * * SQL Data Type: uniqueidentifier
+    * * Related Entity/Foreign Key: MJ: Entity Actions (vwEntityActions.ID)
+    * * Description: Optional. The Entity Action binding that caused this run. NULL when the action was invoked directly - from a resolver, a script, an agent step or a scheduled action.
+    */
+    get EntityActionID() {
+        return this.Get('EntityActionID');
+    }
+    set EntityActionID(value) {
+        this.Set('EntityActionID', value);
+    }
+    /**
+    * * Field Name: EntityActionInvocationTypeID
+    * * Display Name: Entity Action Invocation Type ID
+    * * SQL Data Type: uniqueidentifier
+    * * Related Entity/Foreign Key: MJ: Entity Action Invocation Types (vwEntityActionInvocationTypes.ID)
+    * * Description: Optional. Which lifecycle event fired the binding - AfterUpdate, Validate, List and so on. Recorded separately from EntityActionID because one binding may be attached to several invocation types, and telling a Validate refusal apart from an AfterUpdate side effect is the first question anyone asks of this log.
+    */
+    get EntityActionInvocationTypeID() {
+        return this.Get('EntityActionInvocationTypeID');
+    }
+    set EntityActionInvocationTypeID(value) {
+        this.Set('EntityActionInvocationTypeID', value);
+    }
+    /**
+    * * Field Name: TargetEntityID
+    * * Display Name: Target Entity ID
+    * * SQL Data Type: uniqueidentifier
+    * * Related Entity/Foreign Key: MJ: Entities (vwEntities.ID)
+    * * Description: Optional. The entity of the record this run operated on. Deliberately denormalized rather than joined through EntityActionID: it survives the binding being deleted or retargeted, and it lets the log be queried by record with no join. Kept generic because every invoker has a subject - not only Entity Actions.
+    */
+    get TargetEntityID() {
+        return this.Get('TargetEntityID');
+    }
+    set TargetEntityID(value) {
+        this.Set('TargetEntityID', value);
+    }
+    /**
+    * * Field Name: TargetRecordID
+    * * Display Name: Target Record ID
+    * * SQL Data Type: nvarchar(450)
+    * * Description: Optional. The primary key of the record this run operated on, as text, paired with TargetEntityID. For multi-record invocation types (List, View) one log row is written per record, so this is always a single record.
+    */
+    get TargetRecordID() {
+        return this.Get('TargetRecordID');
+    }
+    set TargetRecordID(value) {
+        this.Set('TargetRecordID', value);
+    }
+    /**
+    * * Field Name: ResultParams
+    * * Display Name: Result Params
+    * * SQL Data Type: nvarchar(MAX)
+    * * Description: JSON-formatted FINAL parameter set captured when the action finished - the inputs as the action left them, plus any output parameters it produced. Written on FAILURE exactly as on success, under the same redaction rules: a failed run's partially-mutated inputs are usually the most diagnostic thing available, and an audit trail that records only successes is not an audit trail. Distinct from Params, which holds the values the action was called with and is never overwritten. NULL means one thing only - the run never finished (process died, host killed) - so it is a signal rather than an absence, and must not be backfilled.
+    */
+    get ResultParams() {
+        return this.Get('ResultParams');
+    }
+    set ResultParams(value) {
+        this.Set('ResultParams', value);
+    }
+    /**
     * * Field Name: Action
     * * Display Name: Action
     * * SQL Data Type: nvarchar(425)
@@ -32852,6 +33051,30 @@ let MJActionExecutionLogEntity = class MJActionExecutionLogEntity extends BaseEn
     get User() {
         return this.Get('User');
     }
+    /**
+    * * Field Name: EntityAction
+    * * Display Name: Entity Action
+    * * SQL Data Type: nvarchar(425)
+    */
+    get EntityAction() {
+        return this.Get('EntityAction');
+    }
+    /**
+    * * Field Name: EntityActionInvocationType
+    * * Display Name: Entity Action Invocation Type
+    * * SQL Data Type: nvarchar(255)
+    */
+    get EntityActionInvocationType() {
+        return this.Get('EntityActionInvocationType');
+    }
+    /**
+    * * Field Name: TargetEntity
+    * * Display Name: Target Entity
+    * * SQL Data Type: nvarchar(255)
+    */
+    get TargetEntity() {
+        return this.Get('TargetEntity');
+    }
 };
 MJActionExecutionLogEntity = __decorate([
     RegisterClass(BaseEntity, 'MJ: Action Execution Logs')
@@ -33271,6 +33494,19 @@ let MJActionParamEntity = class MJActionParamEntity extends BaseEntity {
         this.Set('MediaModality', value);
     }
     /**
+    * * Field Name: LogValue
+    * * Display Name: Log Value
+    * * SQL Data Type: bit
+    * * Default Value: 1
+    * * Description: Whether this parameter's VALUE may be written to ActionExecutionLog.Params. Default 1. Set to 0 for parameters that carry records, credentials or personal data - for example the Data payload of Execute Agent. Independent of the hard rule that Entity Action params of ValueType 'Entity Object' or 'Entity Object Data' are never logged regardless of this flag. When logging is suppressed the log records the parameter name, its type and a redaction marker, never the value.
+    */
+    get LogValue() {
+        return this.Get('LogValue');
+    }
+    set LogValue(value) {
+        this.Set('LogValue', value);
+    }
+    /**
     * * Field Name: Action
     * * Display Name: Action
     * * SQL Data Type: nvarchar(425)
@@ -42113,7 +42349,7 @@ let MJAIAgentTypeEntity = class MJAIAgentTypeEntity extends BaseEntity {
     * @method
     */
     ValidateCompactionTriggerPercentRange(result) {
-        if (this.CompactionTriggerPercent != null && (this.CompactionTriggerPercent < 1 || this.CompactionTriggerPercent > 100)) {
+        if (this.CompactionTriggerPercent < 1 || this.CompactionTriggerPercent > 100) {
             result.Errors.push(new ValidationErrorInfo("CompactionTriggerPercent", "Compaction trigger percentage must be between 1 and 100.", this.CompactionTriggerPercent, ValidationErrorType.Failure));
         }
     }
@@ -52265,6 +52501,19 @@ let MJAPIApplicationScopeEntity = class MJAPIApplicationScopeEntity extends Base
         return this.Get('__mj_UpdatedAt');
     }
     /**
+    * * Field Name: RowFilterID
+    * * Display Name: Row Filter ID
+    * * SQL Data Type: uniqueidentifier
+    * * Related Entity/Foreign Key: MJ: Row Level Security Filters (vwRowLevelSecurityFilters.ID)
+    * * Description: Optional row-level filter acting as a CEILING for every API key operating under this application — a restriction keys inherit and cannot widen. Composes with the per-key filter (APIKeyScope.RowFilterID) and with role-based RLS using AND, never OR, so no layer can broaden another. References the same RowLevelSecurityFilter catalog used by role-based RLS. NULL (the default) means the application imposes no row ceiling. The same authoring constraints as APIKeyScope.RowFilterID apply: exact single-entity resource pattern, all referenced columns must exist on that entity, and all referrers of the filter record must resolve to the same entity.
+    */
+    get RowFilterID() {
+        return this.Get('RowFilterID');
+    }
+    set RowFilterID(value) {
+        this.Set('RowFilterID', value);
+    }
+    /**
     * * Field Name: Application
     * * Display Name: Application Name
     * * SQL Data Type: nvarchar(100)
@@ -52280,6 +52529,14 @@ let MJAPIApplicationScopeEntity = class MJAPIApplicationScopeEntity extends Base
     get Scope() {
         return this.Get('Scope');
     }
+    /**
+    * * Field Name: RowFilter
+    * * Display Name: Row Filter
+    * * SQL Data Type: nvarchar(100)
+    */
+    get RowFilter() {
+        return this.Get('RowFilter');
+    }
 };
 MJAPIApplicationScopeEntity = __decorate([
     RegisterClass(BaseEntity, 'MJ: API Application Scopes')
@@ -52628,6 +52885,19 @@ let MJAPIKeyScopeEntity = class MJAPIKeyScopeEntity extends BaseEntity {
         this.Set('Priority', value);
     }
     /**
+    * * Field Name: RowFilterID
+    * * Display Name: Row Filter ID
+    * * SQL Data Type: uniqueidentifier
+    * * Related Entity/Foreign Key: MJ: Row Level Security Filters (vwRowLevelSecurityFilters.ID)
+    * * Description: Optional row-level filter narrowing WHICH RECORDS this scope grant applies to, in addition to the resource pattern that governs which entities. References the same RowLevelSecurityFilter catalog used by role-based RLS, so the filter text flows through the standard {{Token}} substitution engine and every existing RLS enforcement point (RunView, Load by primary key, save, delete, search). NULL (the default) means no row restriction — behavior identical to before this column existed. When set, the rule's ResourcePattern must name a single exact entity (no wildcards, no comma-separated lists), every column the filter references must resolve to a real non-virtual field on that entity, and every other referrer of the same filter record must resolve to that same entity. Critically, this filter is evaluated INDEPENDENTLY of the role-RLS exemption: a user exempt from role RLS is still bound by their key's filter, because narrowing a principal below what their roles allow is the entire purpose of a key ceiling.
+    */
+    get RowFilterID() {
+        return this.Get('RowFilterID');
+    }
+    set RowFilterID(value) {
+        this.Set('RowFilterID', value);
+    }
+    /**
     * * Field Name: APIKey
     * * Display Name: API Key
     * * SQL Data Type: nvarchar(255)
@@ -52643,6 +52913,14 @@ let MJAPIKeyScopeEntity = class MJAPIKeyScopeEntity extends BaseEntity {
     get Scope() {
         return this.Get('Scope');
     }
+    /**
+    * * Field Name: RowFilter
+    * * Display Name: Row Filter
+    * * SQL Data Type: nvarchar(100)
+    */
+    get RowFilter() {
+        return this.Get('RowFilter');
+    }
 };
 MJAPIKeyScopeEntity = __decorate([
     RegisterClass(BaseEntity, 'MJ: API Key Scopes')
@@ -61685,7 +61963,7 @@ let MJContentItemChunkEntity = class MJContentItemChunkEntity extends BaseEntity
     }
     /**
     * * Field Name: StartMs
-    * * Display Name: Start (ms)
+    * * Display Name: Start Milliseconds
     * * SQL Data Type: int
     * * Description: Start of this chunk's time window, in milliseconds from the beginning of the parent audio or video asset. Set by transcript- or window-based segmentation; enables time-windowed playback deep-links from a search result (for example 14:22-15:05 of a session recording). NULL for text segments.
     */
@@ -61697,7 +61975,7 @@ let MJContentItemChunkEntity = class MJContentItemChunkEntity extends BaseEntity
     }
     /**
     * * Field Name: EndMs
-    * * Display Name: End (ms)
+    * * Display Name: End Milliseconds
     * * SQL Data Type: int
     * * Description: End of this chunk's time window, in milliseconds from the beginning of the parent audio or video asset. See StartMs. NULL for text segments.
     */
@@ -61782,13 +62060,21 @@ let MJContentItemChunkEntity = class MJContentItemChunkEntity extends BaseEntity
     }
     /**
     * * Field Name: ContentItem
-    * * Display Name: Content Item
+    * * Display Name: Content Item Name
     * * SQL Data Type: nvarchar(250)
     */
     get ContentItem() {
         return this.Get('ContentItem');
     }
     /**
+    * * Field Name: ParentChunk
+    * * Display Name: Parent Chunk Name
+    * * SQL Data Type: nvarchar(500)
+    */
+    get ParentChunk() {
+        return this.Get('ParentChunk');
+    }
+    /**
     * * Field Name: RootParentChunkID
     * * Display Name: Root Parent Chunk
     * * SQL Data Type: uniqueidentifier
@@ -71345,6 +71631,10 @@ let MJEntityEntity = class MJEntityEntity extends BaseEntity {
     /**
     * Validate() method override for MJ: Entities entity. This is an auto-generated method that invokes the generated validators for this entity for the following fields:
     * * Table-Level: This rule ensures that if deleting via the API is allowed and the delete type is set to 'Soft', then record merging must also be allowed. In other words, you cannot allow API deletes with a soft delete type without also allowing record merging.
+    * * Table-Level: If direct SQL deletion is allowed, the delete type must be set to 'Hard' to ensure data integrity.
+    * * Table-Level: Direct SQL operations (Insert, Update, and Delete) must be disabled if Track Record Changes or Trust Server Cache Completely is enabled, ensuring that cache integrity and change tracking are not bypassed.
+    * * Table-Level: If the base view is marked as generated, the generated base view name must be null. A generated base view name can only be set when the base view is not marked as generated.
+    * * Table-Level: If a generated base view name is specified, a base view must also be defined, and the generated base view name cannot be the same as the base view name to prevent naming conflicts.
     * @public
     * @method
     * @override
@@ -71352,6 +71642,10 @@ let MJEntityEntity = class MJEntityEntity extends BaseEntity {
     Validate() {
         const result = super.Validate();
         this.ValidateAllowRecordMergeForSoftDeleteAPI(result);
+        this.ValidateDeleteTypeForDirectSQLDelete(result);
+        this.ValidateDirectSQLAndTrackingConstraints(result);
+        this.ValidateGeneratedBaseViewNameAndBaseViewGenerated(result);
+        this.ValidateGeneratedBaseViewNameDifferentFromBaseView(result);
         result.Success = result.Success && (result.Errors.length === 0);
         return result;
     }
@@ -71367,6 +71661,55 @@ let MJEntityEntity = class MJEntityEntity extends BaseEntity {
         }
     }
     /**
+    * If direct SQL deletion is allowed, the delete type must be set to 'Hard' to ensure data integrity.
+    * @param result - the ValidationResult object to add any errors or warnings to
+    * @public
+    * @method
+    */
+    ValidateDeleteTypeForDirectSQLDelete(result) {
+        if (this.AllowDirectSQLDelete && this.DeleteType !== "Hard") {
+            result.Errors.push(new ValidationErrorInfo("DeleteType", "Delete Type must be 'Hard' if Allow Direct SQL Delete is enabled.", this.DeleteType, ValidationErrorType.Failure));
+        }
+    }
+    /**
+    * Direct SQL operations (Insert, Update, and Delete) must be disabled if Track Record Changes or Trust Server Cache Completely is enabled, ensuring that cache integrity and change tracking are not bypassed.
+    * @param result - the ValidationResult object to add any errors or warnings to
+    * @public
+    * @method
+    */
+    ValidateDirectSQLAndTrackingConstraints(result) {
+        if ((this.AllowDirectSQLInsert || this.AllowDirectSQLUpdate || this.AllowDirectSQLDelete) && (this.TrackRecordChanges || this.TrustServerCacheCompletely)) {
+            result.Errors.push(new ValidationErrorInfo("AllowDirectSQLInsert", "Direct SQL operations (Insert, Update, Delete) cannot be enabled when Track Record Changes or Trust Server Cache Completely is enabled.", this.AllowDirectSQLInsert, ValidationErrorType.Failure));
+        }
+    }
+    /**
+    * If the base view is marked as generated, the generated base view name must be null. A generated base view name can only be set when the base view is not marked as generated.
+    * @param result - the ValidationResult object to add any errors or warnings to
+    * @public
+    * @method
+    */
+    ValidateGeneratedBaseViewNameAndBaseViewGenerated(result) {
+        if (this.GeneratedBaseViewName != null && this.BaseViewGenerated) {
+            result.Errors.push(new ValidationErrorInfo("GeneratedBaseViewName", "Generated Base View Name must be empty when Base View Generated is enabled.", this.GeneratedBaseViewName, ValidationErrorType.Failure));
+        }
+    }
+    /**
+    * If a generated base view name is specified, a base view must also be defined, and the generated base view name cannot be the same as the base view name to prevent naming conflicts.
+    * @param result - the ValidationResult object to add any errors or warnings to
+    * @public
+    * @method
+    */
+    ValidateGeneratedBaseViewNameDifferentFromBaseView(result) {
+        if (this.GeneratedBaseViewName != null && this.GeneratedBaseViewName.trim() !== "") {
+            if (this.BaseView == null || this.BaseView.trim() === "") {
+                result.Errors.push(new ValidationErrorInfo("GeneratedBaseViewName", "A Base View must be specified when a Generated Base View Name is provided.", this.GeneratedBaseViewName, ValidationErrorType.Failure));
+            }
+            else if (this.GeneratedBaseViewName === this.BaseView) {
+                result.Errors.push(new ValidationErrorInfo("GeneratedBaseViewName", "The Generated Base View Name cannot be the same as the Base View name.", this.GeneratedBaseViewName, ValidationErrorType.Failure));
+            }
+        }
+    }
+    /**
     * * Field Name: ID
     * * Display Name: ID
     * * SQL Data Type: uniqueidentifier
@@ -72197,7 +72540,7 @@ let MJEntityEntity = class MJEntityEntity extends BaseEntity {
     }
     /**
     * * Field Name: ExternalDataSourceID
-    * * Display Name: External Data Source ID
+    * * Display Name: External Data Source
     * * SQL Data Type: uniqueidentifier
     * * Related Entity/Foreign Key: MJ: External Data Sources (vwExternalDataSources.ID)
     */
@@ -72220,6 +72563,57 @@ let MJEntityEntity = class MJEntityEntity extends BaseEntity {
         this.Set('ExternalObjectName', value);
     }
     /**
+    * * Field Name: GeneratedBaseViewName
+    * * Display Name: Generated Base View Name
+    * * SQL Data Type: nvarchar(255)
+    * * Description: 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 (SELECT g.*, <extras> FROM <GeneratedBaseViewName> g). This gives an entity a custom base view WITHOUT inheriting the generated SQL: related-entity display joins, geo columns and recursive root-ID columns keep regenerating underneath, so a foreign key added later still appears. NULL (the default, and every pre-existing row) means the previous all-or-nothing behaviour: BaseViewGenerated alone decides whether CodeGen writes BaseView, and there is no second view. BaseView remains the public surface — entity field discovery, permissions and the generated CRUD procedures all target it. SQL SERVER ONLY: layering relies on sp_refreshview to re-resolve the application-owned outer view's SELECT * against a regenerated inner view. PostgreSQL freezes a view's column list at creation and has no refresh equivalent, so CodeGen rejects this column on PostgreSQL rather than let the outer view go silently stale.
+    */
+    get GeneratedBaseViewName() {
+        return this.Get('GeneratedBaseViewName');
+    }
+    set GeneratedBaseViewName(value) {
+        this.Set('GeneratedBaseViewName', value);
+    }
+    /**
+    * * Field Name: AllowDirectSQLInsert
+    * * Display Name: Allow Direct SQL Insert
+    * * SQL Data Type: bit
+    * * Default Value: 0
+    * * Description: When 1, this entity may be populated by INSERT statements that do not go through BaseEntity.Save() — bulk loads, ETL/integration sync, or rows created as a side effect of a stored procedure. Default 0, meaning every insert is expected to flow through BaseEntity so that record-change tracking, entity actions, validation and cache invalidation all run. This column DECLARES intent for the code paths and tooling that consult it; it does not and cannot prevent anyone from executing SQL. Requires TrackRecordChanges = 0 and TrustServerCacheCompletely = 0, because a direct insert produces neither an audit row nor a cache-invalidation event.
+    */
+    get AllowDirectSQLInsert() {
+        return this.Get('AllowDirectSQLInsert');
+    }
+    set AllowDirectSQLInsert(value) {
+        this.Set('AllowDirectSQLInsert', value);
+    }
+    /**
+    * * Field Name: AllowDirectSQLUpdate
+    * * Display Name: Allow Direct SQL Update
+    * * SQL Data Type: bit
+    * * Default Value: 0
+    * * Description: When 1, this entity may be modified by UPDATE statements that do not go through BaseEntity.Save() — bulk backfills, integration sync, or maintenance routines. Default 0, meaning every update is expected to flow through BaseEntity so that record-change tracking, entity actions, validation and cache invalidation all run. This column DECLARES intent for the code paths and tooling that consult it; it does not and cannot prevent anyone from executing SQL. Requires TrackRecordChanges = 0 and TrustServerCacheCompletely = 0, because a direct update produces neither an audit row nor a cache-invalidation event.
+    */
+    get AllowDirectSQLUpdate() {
+        return this.Get('AllowDirectSQLUpdate');
+    }
+    set AllowDirectSQLUpdate(value) {
+        this.Set('AllowDirectSQLUpdate', value);
+    }
+    /**
+    * * Field Name: AllowDirectSQLDelete
+    * * Display Name: Allow Direct SQL Delete
+    * * SQL Data Type: bit
+    * * Default Value: 0
+    * * Description: When 1, this entity may have rows removed by DELETE statements that do not go through BaseEntity.Delete() — purge and retention routines, or integration sync reconciling a remote source. Default 0, meaning every delete is expected to flow through BaseEntity so that record-change tracking, entity actions, cascade handling and cache invalidation all run. This column DECLARES intent for the code paths and tooling that consult it; it does not and cannot prevent anyone from executing SQL. Requires TrackRecordChanges = 0 and TrustServerCacheCompletely = 0, and additionally requires DeleteType = 'Hard' — a direct DELETE removes the row outright rather than setting DeletedAt, which would defeat soft delete.
+    */
+    get AllowDirectSQLDelete() {
+        return this.Get('AllowDirectSQLDelete');
+    }
+    set AllowDirectSQLDelete(value) {
+        this.Set('AllowDirectSQLDelete', value);
+    }
+    /**
     * * Field Name: CodeName
     * * Display Name: Code Name
     * * SQL Data Type: nvarchar(MAX)
@@ -72720,9 +73114,10 @@ let MJEntityActionParamEntity = class MJEntityActionParamEntity extends BaseEnti
     * * Possible Values
     *   * Entity Field
     *   * Entity Object
+    *   * Entity Object Data
     *   * Script
     *   * Static
-    * * Description: Type of the value, which can be Static, Entity Object, or Script.
+    * * Description: How the parameter value is produced at invocation time. Static = the literal Value (parsed as JSON when it parses). Entity Object = the live BaseEntity instance, for actions that call entity methods. Entity Object Data = entity.GetAll(), a plain object - use this for any action that SERIALIZES the value, such as the Data payload of Execute Agent, because a BaseEntity serializes to {} (its fields are getters, not enumerable own properties). Entity Field = the named field's value. Script = evaluated expression with the entity in scope.
     */
     get ValueType() {
         return this.Get('ValueType');
@@ -72773,6 +73168,18 @@ let MJEntityActionParamEntity = class MJEntityActionParamEntity extends BaseEnti
         return this.Get('__mj_UpdatedAt');
     }
     /**
+    * * Field Name: LogValue
+    * * Display Name: Log Value
+    * * SQL Data Type: bit
+    * * Description: Optional per-binding override of ActionParam.LogValue. NULL (the default) inherits the parameter definition. Set to 0 when this particular binding passes something sensitive through a parameter that is ordinarily safe to log - a message body through a generic Text parameter, for instance. Cannot re-enable logging for a value type the hard rule suppresses.
+    */
+    get LogValue() {
+        return this.Get('LogValue');
+    }
+    set LogValue(value) {
+        this.Set('LogValue', value);
+    }
+    /**
     * * Field Name: EntityAction
     * * Display Name: Entity Action
     * * SQL Data Type: nvarchar(425)
@@ -72822,6 +73229,30 @@ let MJEntityActionEntity = class MJEntityActionEntity extends BaseEntity {
         return await super.InnerLoad(compositeKey, EntityRelationshipsToLoad);
     }
     /**
+    * Validate() method override for MJ: Entity Actions entity. This is an auto-generated method that invokes the generated validators for this entity for the following fields:
+    * * Table-Level: Both Scope Entity and Scope Record must be provided together, or both must be left blank. You cannot specify one without the other.
+    * @public
+    * @method
+    * @override
+    */
+    Validate() {
+        const result = super.Validate();
+        this.ValidateScopeEntityAndRecordCoexistence(result);
+        result.Success = result.Success && (result.Errors.length === 0);
+        return result;
+    }
+    /**
+    * Both Scope Entity and Scope Record must be provided together, or both must be left blank. You cannot specify one without the other.
+    * @param result - the ValidationResult object to add any errors or warnings to
+    * @public
+    * @method
+    */
+    ValidateScopeEntityAndRecordCoexistence(result) {
+        if ((this.ScopeEntityID == null && this.ScopeRecordID != null) || (this.ScopeEntityID != null && this.ScopeRecordID == null)) {
+            result.Errors.push(new ValidationErrorInfo("ScopeEntityID", "Scope Entity and Scope Record must either both be specified or both be empty.", this.ScopeEntityID, ValidationErrorType.Failure));
+        }
+    }
+    /**
     * * Field Name: EntityID
     * * Display Name: Entity ID
     * * SQL Data Type: uniqueidentifier
@@ -72894,6 +73325,62 @@ let MJEntityActionEntity = class MJEntityActionEntity extends BaseEntity {
         this.Set('ID', value);
     }
     /**
+    * * Field Name: Sequence
+    * * Display Name: Sequence
+    * * SQL Data Type: int
+    * * Default Value: 0
+    * * Description: Execution order when multiple Entity Actions are bound to the same entity and invocation type. Lower runs first; ties fall back to creation order. Defaults to 0 so existing rows are unaffected.
+    */
+    get Sequence() {
+        return this.Get('Sequence');
+    }
+    set Sequence(value) {
+        this.Set('Sequence', value);
+    }
+    /**
+    * * Field Name: ScopeEntityID
+    * * Display Name: Scope Entity ID
+    * * SQL Data Type: uniqueidentifier
+    * * Related Entity/Foreign Key: MJ: Entities (vwEntities.ID)
+    * * Description: Optional. Together with ScopeRecordID, narrows this Entity Action to records related to ONE specific record - for example a single Deal Type, Contract Type, Pipeline or Company - rather than every record of EntityID. NULL (the default) means the action applies to all records, which is the pre-existing behaviour. How a scope record relates to the subject record is resolved by the app that owns the scope entity; the framework only stores and filters on the pair.
+    */
+    get ScopeEntityID() {
+        return this.Get('ScopeEntityID');
+    }
+    set ScopeEntityID(value) {
+        this.Set('ScopeEntityID', value);
+    }
+    /**
+    * * Field Name: ScopeRecordID
+    * * Display Name: Scope Record ID
+    * * SQL Data Type: nvarchar(450)
+    * * Description: Optional. The primary key of the scope record, as text, paired with ScopeEntityID. Both columns are NULL or both are set (CK_EntityAction_Scope). Lets a configuration record such as a Deal Type surface "the workflows bound to me" as a real relationship rather than something buried in filter code.
+    */
+    get ScopeRecordID() {
+        return this.Get('ScopeRecordID');
+    }
+    set ScopeRecordID(value) {
+        this.Set('ScopeRecordID', value);
+    }
+    /**
+    * * Field Name: LoggingMode
+    * * Display Name: Logging Mode
+    * * SQL Data Type: nvarchar(20)
+    * * Default Value: All
+    * * Value List Type: List
+    * * Possible Values
+    *   * All
+    *   * FailuresOnly
+    *   * None
+    * * Description: How much of this binding's activity reaches ActionExecutionLog. All (default) writes a row per invocation. FailuresOnly writes only runs that did not succeed - the right setting for a high-frequency binding on a busy entity, where the successful runs are noise. None disables logging for the binding entirely and should be rare, because it also removes the failure record.
+    */
+    get LoggingMode() {
+        return this.Get('LoggingMode');
+    }
+    set LoggingMode(value) {
+        this.Set('LoggingMode', value);
+    }
+    /**
     * * Field Name: Entity
     * * Display Name: Entity
     * * SQL Data Type: nvarchar(255)
@@ -72909,6 +73396,14 @@ let MJEntityActionEntity = class MJEntityActionEntity extends BaseEntity {
     get Action() {
         return this.Get('Action');
     }
+    /**
+    * * Field Name: ScopeEntity
+    * * Display Name: Scope Entity
+    * * SQL Data Type: nvarchar(255)
+    */
+    get ScopeEntity() {
+        return this.Get('ScopeEntity');
+    }
 };
 MJEntityActionEntity = __decorate([
     RegisterClass(BaseEntity, 'MJ: Entity Actions')
@@ -109148,6 +109643,7 @@ let MJUserViewRunDetailEntity = class MJUserViewRunDetailEntity extends BaseEnti
     }
     /**
     * * Field Name: ID
+    * * Display Name: ID
     * * SQL Data Type: uniqueidentifier
     * * Default Value: newsequentialid()
     */
@@ -109159,7 +109655,7 @@ let MJUserViewRunDetailEntity = class MJUserViewRunDetailEntity extends BaseEnti
     }
     /**
     * * Field Name: UserViewRunID
-    * * Display Name: User View Run ID
+    * * Display Name: User View Run
     * * SQL Data Type: uniqueidentifier
     * * Related Entity/Foreign Key: MJ: User View Runs (vwUserViewRuns.ID)
     */
@@ -109200,6 +109696,14 @@ let MJUserViewRunDetailEntity = class MJUserViewRunDetailEntity extends BaseEnti
         return this.Get('__mj_UpdatedAt');
     }
     /**
+    * * Field Name: UserViewRun
+    * * Display Name: User View Run Name
+    * * SQL Data Type: nvarchar(100)
+    */
+    get UserViewRun() {
+        return this.Get('UserViewRun');
+    }
+    /**
     * * Field Name: UserViewID
     * * Display Name: User View
     * * SQL Data Type: uniqueidentifier