@memberjunction/core-entities 6.2.0-edge.1 → 6.2.0-edge.3

package/dist/generated/remote_operations.d.ts

@@ -413,6 +413,315 @@ export interface PredictiveStudioTrainModelOutput {
     /** Lifecycle status of the produced model (always `Draft` immediately after training). */
     status: string;
 }
+/** A single primary-key field/value pair identifying a record. */
+export interface RecordCloneKeyValuePair {
+    /** Primary-key field name (e.g. "ID"). */
+    FieldName: string;
+    /** Primary-key value as a string. */
+    Value: string;
+}
+/** Record key expressed as composite key-value pairs. */
+export interface RecordCloneKey {
+    KeyValuePairs: RecordCloneKeyValuePair[];
+}
+/** Input for `RecordClone.Describe`. */
+export interface RecordCloneDescribeInput {
+    /** Registered entity name to inspect for cloning capabilities. */
+    EntityName: string;
+    /** Optional specific record key to inspect. */
+    Key?: RecordCloneKey;
+}
+/** Relationship clone policy and status. */
+export interface RecordCloneDescribeRelationship {
+    /** Relationship display name or target entity. */
+    Name: string;
+    /** Related entity name. */
+    RelatedEntity: string;
+    /** Default clone policy applied to this relationship. */
+    DefaultPolicy: 'Deep' | 'Reference' | 'Skip';
+    /** Whether policy changes are locked by configuration or database constraint. */
+    Locked: boolean;
+    /** Optional count of child records for the specified record. */
+    ChildCount?: number;
+}
+/** Output for `RecordClone.Describe`. */
+export interface RecordCloneDescribeOutput {
+    /** Whether the entity can be cloned. */
+    CanClone: boolean;
+    /** Optional explanation if cloning is disabled or blocked. */
+    Reason?: string;
+    /** Presets configured on the entity. */
+    Presets?: string[];
+    /** Granularity of user editing allowed. */
+    UserEditable?: 'none' | 'fields' | 'scope' | 'all';
+    /** Direct relationships and their clone policies. */
+    Relationships: RecordCloneDescribeRelationship[];
+    /** Authorization check result for the calling user. */
+    Authorization?: {
+        Name: string;
+        Granted: boolean;
+    };
+    /** Whether the calling user holds `Clone Records: Fire Hooks`, so the UI may offer the Fire Entity Actions toggle. */
+    CanFireHooks?: boolean;
+    /** Whether the calling user holds `Clone Records: Override Scope`, so the UI may offer scope overrides beyond the entity's configuration. */
+    CanOverrideScope?: boolean;
+}
+/** Options controlling clone execution. */
+export interface RecordCloneExecuteOptions {
+    /** Plan and validate only: returns the plan in `Plan` and writes nothing. */
+    DryRun?: boolean;
+    Preset?: string;
+    MaxDepth?: number;
+    MaxRecords?: number;
+    Subtypes?: 'include' | 'exclude';
+    Hierarchy?: 'subtree' | 'node';
+    SoftLinks?: 'skip' | 'include';
+    /** Whether Entity Actions run on the cloned rows. Default from the entity's `Hooks` (else 'fire'); changing it needs `Clone Records: Fire Hooks`. */
+    EntityActions?: 'suppress' | 'fire';
+    /** Whether Entity AI Actions run. Default from the entity's `Hooks` (else 'suppress'); changing it needs `Clone Records: Fire Hooks`. */
+    AIActions?: 'suppress' | 'fire';
+    Embeddings?: 'copy' | 'regenerate';
+    FieldOverrides?: Record<string, string | number | boolean | null>;
+    PromptedValues?: Record<string, string | number | boolean | null>;
+    /** Point foreign keys on the root at other records. Only fields listed in the entity's `Clone.UI.RetargetFields` apply. */
+    Retarget?: Array<{
+        EntityName: string;
+        Field: string;
+        Value: string;
+    }>;
+    NamingTemplate?: string;
+    NamingStrategy?: 'suffix' | 'increment' | 'prompt' | 'none';
+    Naming?: {
+        Template?: string;
+        Strategy?: 'suffix' | 'increment' | 'prompt' | 'none';
+    };
+    Reason?: string;
+}
+/** Per-edge policy override. */
+export interface RecordCloneEdgeOverride {
+    RelationshipID?: string;
+    Policy: 'Deep' | 'Reference' | 'Skip';
+}
+/** Input for `RecordClone.Execute`. */
+export interface RecordCloneExecuteInput {
+    EntityName?: string;
+    SourceRecordKey?: RecordCloneKey;
+    Roots?: Array<{
+        EntityName: string;
+        Key: RecordCloneKey;
+    }>;
+    Options?: RecordCloneExecuteOptions;
+    EdgeOverrides?: RecordCloneEdgeOverride[];
+    ExpectedPlanHash?: string;
+}
+/** Record mapping result from clone execution. */
+export interface RecordCloneRecordMapping {
+    EntityName: string;
+    SourceKey: string;
+    TargetKey: string;
+    Depth?: number;
+}
+/** Record skipped during clone execution. */
+export interface RecordCloneSkippedRecord {
+    EntityName: string;
+    SourceKey: string;
+    Reason: string;
+}
+/** Warning or execution issue. */
+export interface RecordCloneExecuteWarning {
+    Code: string;
+    Severity: 'Info' | 'Warning' | 'Error';
+    NodeKey?: string;
+    Field?: string;
+    Message: string;
+}
+/** Output for `RecordClone.Execute`. */
+export interface RecordCloneExecuteOutput {
+    /** Whether the clone succeeded. */
+    Success: boolean;
+    /** Outcome code. */
+    ResultCode: 'SUCCESS' | 'PLAN_CHANGED' | 'BLOCKED' | 'FORBIDDEN' | 'EXECUTION_ERROR';
+    /** ID of the created MJ: Record Clone Logs header row, if written. */
+    CloneLogID: string | null;
+    /** Mappings for the root records. */
+    Roots: RecordCloneRecordMapping[];
+    /** Mappings for all successfully created records. */
+    Created: RecordCloneRecordMapping[];
+    /** Records that were skipped. */
+    Skipped: RecordCloneSkippedRecord[];
+    /** Aggregate counts. */
+    Counts: {
+        ByEntity: Record<string, {
+            Create: number;
+            Reference: number;
+            Skip: number;
+        }>;
+        Create: number;
+        Total: number;
+    };
+    /** Warnings emitted during planning or execution. */
+    Warnings: RecordCloneExecuteWarning[];
+    /** Updated plan returned on PLAN_CHANGED or BLOCKED. */
+    Plan?: RecordClonePlanDetails;
+    /** Error message on failure. */
+    ErrorMessage?: string;
+}
+/** Input for `RecordClone.GetLineage`. */
+export interface RecordCloneGetLineageInput {
+    /** Registered entity name. */
+    EntityName: string;
+    /** Composite key of the record whose clone lineage is being queried. */
+    Key: RecordCloneKey;
+    /** Direction of traversal: ancestors ('up'), descendants ('down'), or both ('both'). Defaults to 'both'. */
+    Direction?: 'up' | 'down' | 'both';
+}
+/** Single item in a record's clone lineage. */
+export interface RecordCloneLineageItem {
+    /** Entity name of the record. */
+    EntityName: string;
+    /** Primary key of the record. */
+    RecordID: string;
+    /** Human-readable display name of the record. */
+    DisplayName?: string;
+    /** ID of the MJ: Record Clone Logs header row that produced this clone, if known. */
+    CloneLogID?: string;
+    /** ISO timestamp when the clone occurred, if known. */
+    ClonedAt?: string;
+    /** User ID or display name who initiated the clone, if known. */
+    ClonedBy?: string;
+}
+/** Output for `RecordClone.GetLineage`. */
+export interface RecordCloneGetLineageOutput {
+    /** Chain of ancestor records cloned from, ordered oldest to immediate parent. */
+    Ancestors: RecordCloneLineageItem[];
+    /** Direct descendant records cloned from this record. */
+    Clones: RecordCloneLineageItem[];
+    /** Total count of direct descendant clones. */
+    TotalClones: number;
+}
+/** Options controlling plan generation. */
+export interface RecordClonePlanOptions {
+    DryRun?: boolean;
+    Preset?: string;
+    MaxDepth?: number;
+    MaxRecords?: number;
+    Subtypes?: 'include' | 'exclude';
+    Hierarchy?: 'subtree' | 'node';
+    SoftLinks?: 'skip' | 'include';
+    /** Whether Entity Actions run on the cloned rows. Default from the entity's `Hooks` (else 'fire'); changing it needs `Clone Records: Fire Hooks`. */
+    EntityActions?: 'suppress' | 'fire';
+    /** Whether Entity AI Actions run. Default from the entity's `Hooks` (else 'suppress'); changing it needs `Clone Records: Fire Hooks`. */
+    AIActions?: 'suppress' | 'fire';
+    Embeddings?: 'copy' | 'regenerate';
+    FieldOverrides?: Record<string, string | number | boolean | null>;
+    PromptedValues?: Record<string, string | number | boolean | null>;
+    /** Point foreign keys on the root at other records. Only fields listed in the entity's `Clone.UI.RetargetFields` apply. */
+    Retarget?: Array<{
+        EntityName: string;
+        Field: string;
+        Value: string;
+    }>;
+    NamingTemplate?: string;
+    NamingStrategy?: 'suffix' | 'increment' | 'prompt' | 'none';
+    Naming?: {
+        Template?: string;
+        Strategy?: 'suffix' | 'increment' | 'prompt' | 'none';
+    };
+    Reason?: string;
+}
+/** Input for `RecordClone.Plan`. */
+export interface RecordClonePlanInput {
+    EntityName?: string;
+    SourceRecordKey?: RecordCloneKey;
+    Roots?: Array<{
+        EntityName: string;
+        Key: RecordCloneKey;
+    }>;
+    Options?: RecordClonePlanOptions;
+    EdgeOverrides?: RecordCloneEdgeOverride[];
+    ExpectedPlanHash?: string;
+}
+/** A single field change in the planned record clone. */
+export interface RecordClonePlanFieldChange {
+    Field: string;
+    Kind: string;
+    OldValue: string | number | boolean | null;
+    NewValue: string | number | boolean | null;
+    Reason: string;
+}
+/** Warning or validation issue identified during planning. */
+export interface RecordClonePlanWarning {
+    Code: string;
+    Severity: 'Info' | 'Warning' | 'Error';
+    NodeKey?: string;
+    Field?: string;
+    Message: string;
+}
+/** Node in the planned record clone graph. */
+export interface RecordClonePlanNode {
+    Key: string;
+    EntityName: string;
+    SourceKey: string;
+    TargetKey: string | null;
+    Action: 'Create' | 'Reference' | 'Skip' | 'Blocked';
+    Reason: string;
+    Depth: number;
+    ParentKey: string | null;
+    DisplayName: string;
+    IsSubtypeRow?: boolean;
+    FieldChanges: RecordClonePlanFieldChange[];
+    Warnings: RecordClonePlanWarning[];
+    Route: string;
+}
+/** Relationship edge in the planned record clone graph. */
+export interface RecordClonePlanEdge {
+    FromKey: string;
+    ToKey: string;
+    Kind: string;
+    RelatedEntityName: string;
+    JoinField: string;
+    RelationshipID?: string;
+    CollectionName?: string;
+    IsSoftLink?: boolean;
+    Policy: 'Deep' | 'Reference' | 'Skip';
+    Locked: boolean;
+    PolicySource: string;
+}
+/** Execution options effectively applied to the plan. */
+export interface RecordClonePlanEffectiveOptions {
+    MaxDepth: number;
+    MaxRecords: number;
+    Subtypes: 'include' | 'exclude';
+    Hierarchy: 'subtree' | 'node';
+    SoftLinks: 'skip' | 'include';
+    EntityActions: 'suppress' | 'fire';
+    AIActions: 'suppress' | 'fire';
+    Embeddings: 'copy' | 'regenerate';
+}
+/** Complete clone plan returned by RecordClone.Plan. */
+export interface RecordClonePlanDetails {
+    PlanVersion: 1;
+    Hash: string;
+    Roots: string[];
+    Nodes: RecordClonePlanNode[];
+    Edges: RecordClonePlanEdge[];
+    Counts: {
+        ByEntity: Record<string, {
+            Create: number;
+            Reference: number;
+            Skip: number;
+        }>;
+        Create: number;
+        Total: number;
+    };
+    Warnings: RecordClonePlanWarning[];
+    Blocked: boolean;
+    EffectiveOptions: RecordClonePlanEffectiveOptions;
+}
+/** Output for `RecordClone.Plan`. */
+export interface RecordClonePlanOutput {
+    Plan: RecordClonePlanDetails;
+}
 /** A single primary-key field/value pair identifying a record to compare. */
 export interface RecordComparisonKeyValuePair {
     /** Primary-key field name (e.g. "ID"). */
@@ -657,7 +966,7 @@ export interface TaskGraphSubmitInput {
             tempId: string;
             name: string;
             description: string;
-            kind: 'Agent' | 'Action' | 'Human' | 'Prompt' | 'ForEach' | 'While' | 'External';
+            kind: 'Agent' | 'Action' | 'Human' | 'Prompt' | 'ForEach' | 'While' | 'External' | 'Decision';
             configuration: {
                 agentName: string;
                 message?: string;
@@ -684,6 +993,27 @@ export interface TaskGraphSubmitInput {
             } | {
                 domain: string;
                 ref?: string;
+            } | {
+                promptName?: string;
+                state?: string;
+                questions: Record<string, {
+                    kind: 'Likelihood';
+                    instructions: string;
+                    minConfidence?: number;
+                } | {
+                    kind: 'Choice';
+                    instructions: string;
+                    options: Array<{
+                        value: string;
+                        description: string;
+                    }>;
+                    minConfidence?: number;
+                } | {
+                    kind: 'Score';
+                    instructions: string;
+                    levels: string[];
+                    minConfidence?: number;
+                }>;
             };
             dependsOn: Array<string | {
                 tempId: string;
@@ -836,6 +1166,184 @@ export interface WebSearchQueryOutput {
      */
     attempts: WebSearchQueryAttempt[];
 }
+/** Input for `WorkQueue.DiscardDelivery`. */
+export interface WorkQueueDiscardDeliveryInput {
+    subscriptionName: string;
+    /** A pending, dead-lettered or in-flight delivery. */
+    deliveryID: string;
+    /** Why the work is being dropped. Required; at most 1000 characters. */
+    reason: string;
+}
+/** Output of `WorkQueue.DiscardDelivery`. */
+export interface WorkQueueDiscardDeliveryOutput {
+    /** False when the transport cannot discard this kind of delivery (for example any SQS message). */
+    supported: boolean;
+    /** True when the delivery is now Discarded, or (for an in-flight delivery) its cancel was recorded. */
+    discarded: boolean;
+    /**
+     * True when the delivery was in flight: CancelRequestedAt is set, the running handler's next heartbeat (30 s at
+     * most) aborts it with reason 'Cancelled', and the row becomes Discarded when the handler acknowledges — or at
+     * lease expiry if its worker is gone (03 §7).
+     */
+    cancelRequested: boolean;
+}
+/** Input for `WorkQueue.GetBacklog`. */
+export interface WorkQueueGetBacklogInput {
+    subscriptionName: string;
+}
+/** Output of `WorkQueue.GetBacklog` — the autoscaler metric for one subscription. */
+export interface WorkQueueGetBacklogOutput {
+    /** False when the subscription's transport cannot report a backlog (AWS — scale Lambda from the queue's own metrics). */
+    supported: boolean;
+    /** Pending deliveries that a worker could claim right now (partition rules applied). */
+    claimable: number;
+    /** Deliveries currently leased by a worker. */
+    inFlight: number;
+    /** claimable + inFlight — the value a scheduler should scale on. */
+    total: number;
+    /** True when either count hit its cap of 1000: the real backlog is at least this large. */
+    capped: boolean;
+}
+/** Input for `WorkQueue.GetSubscriptionStats`. */
+export interface WorkQueueGetSubscriptionStatsInput {
+    /** One subscription by name (case-insensitive). Omit for every subscription. */
+    subscriptionName?: string;
+}
+/** One subscription's counts, read from its transport. */
+export interface WorkQueueSubscriptionStatsRow {
+    SubscriptionName: string;
+    Pending: number;
+    InFlight: number;
+    DeadLettered: number;
+    /** Null when the transport cannot count blocked keys. */
+    BlockedKeys: number | null;
+    /** Null when unknown (always null on AWS in Phase 1). */
+    OldestPendingAgeSeconds: number | null;
+    /** Null unless the transport keeps completed rows. */
+    CompletedLastHour: number | null;
+    /** ISO 8601 time the counts were read. */
+    AsOf: string;
+}
+/** A subscription whose stats could not be read. camelCase, as 03 §8 writes it. */
+export interface WorkQueueStatsFailureRow {
+    subscriptionName: string;
+    /** A sanitised message — never raw driver or SQL text. */
+    error: string;
+}
+/** Output of `WorkQueue.GetSubscriptionStats`. */
+export interface WorkQueueGetSubscriptionStatsOutput {
+    subscriptions: WorkQueueSubscriptionStatsRow[];
+    /** Populated only when no subscriptionName was given; a named subscription that fails fails the operation. */
+    failures: WorkQueueStatsFailureRow[];
+}
+/** Input for `WorkQueue.ListDeadLetters`. */
+export interface WorkQueueListDeadLettersInput {
+    /** The subscription to read (case-insensitive). */
+    subscriptionName: string;
+    /** The nextCursor of a previous page. Omit for the first page. */
+    cursor?: string;
+    /** 1–500; default 50. */
+    pageSize?: number;
+}
+/** Reference to data held outside the queue (claim-check). */
+export interface WorkQueuePayloadRefRow {
+    Uri: string;
+    ContentType?: string;
+    SizeBytes?: number;
+    Checksum?: string;
+}
+/** The dead-lettered message envelope. */
+export interface WorkQueueDeadLetterMessageRow {
+    MessageID: string;
+    Topic: string;
+    PartitionKey?: string;
+    Attributes: Record<string, string>;
+    /** The inline payload serialized as JSON, or null when the message carries none. */
+    PayloadJSON: string | null;
+    PayloadRef?: WorkQueuePayloadRefRow;
+    CorrelationID?: string;
+    /** ISO 8601 publish time. */
+    PublishedAt: string;
+}
+/** One dead-lettered delivery. */
+export interface WorkQueueDeadLetterRow {
+    /** Database: MJ: Work Queue Deliveries ID. AWS: the envelope MessageID. */
+    DeliveryID: string;
+    Message: WorkQueueDeadLetterMessageRow;
+    PartitionKey: string | null;
+    Attempts: number;
+    /** Handler reason, MaxAttemptsExceeded, LeaseExpired, HandlerNotRegistered, RedrivePolicy, InvalidEnvelope, … */
+    Reason: string;
+    LastError: string | null;
+    DeadLetteredAt: string | null;
+    /** True when this delivery is the dead-lettered head of an Ordered key (Database transport). */
+    BlocksKey: boolean;
+}
+/** Output of `WorkQueue.ListDeadLetters`. */
+export interface WorkQueueListDeadLettersOutput {
+    /** False when the subscription's transport cannot list dead letters; items is then empty. */
+    supported: boolean;
+    items: WorkQueueDeadLetterRow[];
+    nextCursor: string | null;
+}
+/** Input for `WorkQueue.ListPartitions`. */
+export interface WorkQueueListPartitionsInput {
+    /** The subscription to read (case-insensitive). */
+    subscriptionName: string;
+    /** Only keys in this condition. Omit for every non-idle key. */
+    condition?: 'Idle' | 'InFlight' | 'Blocked';
+    /** The nextCursor of a previous page. Omit for the first page. */
+    cursor?: string;
+    /** 1–500; default 50. */
+    pageSize?: number;
+}
+/** One partition key's derived condition. */
+export interface WorkQueuePartitionStateRow {
+    PartitionKey: string;
+    Condition: 'Idle' | 'InFlight' | 'Blocked';
+    /** The head delivery: in flight, or dead-lettered when Blocked. */
+    HeadDeliveryID: string | null;
+    /** Deliveries waiting behind the head. */
+    WaitingItems: number;
+}
+/** Output of `WorkQueue.ListPartitions`. */
+export interface WorkQueueListPartitionsOutput {
+    /** False when the subscription's transport cannot list partitions (AWS); items is then empty. */
+    supported: boolean;
+    items: WorkQueuePartitionStateRow[];
+    nextCursor: string | null;
+}
+/** Input for `WorkQueue.ReplayDeadLetter`. */
+export interface WorkQueueReplayDeadLetterInput {
+    subscriptionName: string;
+    /** A DeliveryID from WorkQueue.ListDeadLetters. */
+    deliveryID: string;
+    /** Optional operator note stored with the resolution; at most 1000 characters. */
+    note?: string;
+}
+/** Output of `WorkQueue.ReplayDeadLetter`. */
+export interface WorkQueueReplayDeadLetterOutput {
+    /** False when the subscription's transport cannot replay a single dead letter. */
+    supported: boolean;
+    /** False when the delivery does not exist or is not dead-lettered. */
+    replayed: boolean;
+}
+/** Input for `WorkQueue.ValidateBindings`. */
+export interface WorkQueueValidateBindingsInput {
+    /** Validate only this transport's bindings against its resources. Omit to validate the whole topology. */
+    transportName?: string;
+}
+/** One validation finding. */
+export interface WorkQueueBindingIssueRow {
+    Severity: 'Error' | 'Warning';
+    /** The topic, subscription or resource the finding is about. */
+    Subject: string;
+    Message: string;
+}
+/** Output of `WorkQueue.ValidateBindings`. */
+export interface WorkQueueValidateBindingsOutput {
+    issues: WorkQueueBindingIssueRow[];
+}
 /** Input for `Workflow.Draft`. */
 export interface WorkflowDraftInput {
     /** What the person wants done, in their own words. */
@@ -862,7 +1370,7 @@ export interface WorkflowDraftOutput {
             tempId: string;
             name: string;
             description: string;
-            kind: 'Agent' | 'Action' | 'Human' | 'Prompt' | 'ForEach' | 'While' | 'External';
+            kind: 'Agent' | 'Action' | 'Human' | 'Prompt' | 'ForEach' | 'While' | 'External' | 'Decision';
             configuration: {
                 agentName: string;
                 message?: string;
@@ -889,6 +1397,27 @@ export interface WorkflowDraftOutput {
             } | {
                 domain: string;
                 ref?: string;
+            } | {
+                promptName?: string;
+                state?: string;
+                questions: Record<string, {
+                    kind: 'Likelihood';
+                    instructions: string;
+                    minConfidence?: number;
+                } | {
+                    kind: 'Choice';
+                    instructions: string;
+                    options: Array<{
+                        value: string;
+                        description: string;
+                    }>;
+                    minConfidence?: number;
+                } | {
+                    kind: 'Score';
+                    instructions: string;
+                    levels: string[];
+                    minConfidence?: number;
+                }>;
             };
             dependsOn: Array<string | {
                 tempId: string;
@@ -936,7 +1465,7 @@ export interface WorkflowSaveInput {
                 tempId: string;
                 name: string;
                 description: string;
-                kind: 'Agent' | 'Action' | 'Human' | 'Prompt' | 'ForEach' | 'While' | 'External';
+                kind: 'Agent' | 'Action' | 'Human' | 'Prompt' | 'ForEach' | 'While' | 'External' | 'Decision';
                 configuration: {
                     agentName: string;
                     message?: string;
@@ -963,6 +1492,27 @@ export interface WorkflowSaveInput {
                 } | {
                     domain: string;
                     ref?: string;
+                } | {
+                    promptName?: string;
+                    state?: string;
+                    questions: Record<string, {
+                        kind: 'Likelihood';
+                        instructions: string;
+                        minConfidence?: number;
+                    } | {
+                        kind: 'Choice';
+                        instructions: string;
+                        options: Array<{
+                            value: string;
+                            description: string;
+                        }>;
+                        minConfidence?: number;
+                    } | {
+                        kind: 'Score';
+                        instructions: string;
+                        levels: string[];
+                        minConfidence?: number;
+                    }>;
                 };
                 dependsOn: Array<string | {
                     tempId: string;
@@ -1155,6 +1705,54 @@ export declare class PredictiveStudioTrainModelOperation extends BaseRemotableOp
     readonly RequiredScope = "predictive:execute";
     readonly RequiresSystemUser = false;
 }
+/**
+ * Describe Record Clone
+ * Inspect an entity or specific record for clone capability, policies, relationship policies, and authorization. Implemented by RecordCloneDescribeServerOperation in @memberjunction/record-cloning.
+ * GenerationType=Manual — the server body is supplied by a hand-authored subclass registered
+ * under 'RecordClone.Describe'. This generated base provides the typed contract only (client-safe).
+ */
+export declare class RecordCloneDescribeOperation extends BaseRemotableOperation<RecordCloneDescribeInput, RecordCloneDescribeOutput> {
+    readonly OperationKey = "RecordClone.Describe";
+    readonly ExecutionMode: "Sync";
+    readonly RequiredScope = "recordclone:read";
+    readonly RequiresSystemUser = false;
+}
+/**
+ * Execute Record Clone
+ * Execute an entity record clone plan within an entity transaction, staging entities and writing clone logs and links. Implemented by RecordCloneExecuteServerOperation in @memberjunction/record-cloning.
+ * GenerationType=Manual — the server body is supplied by a hand-authored subclass registered
+ * under 'RecordClone.Execute'. This generated base provides the typed contract only (client-safe).
+ */
+export declare class RecordCloneExecuteOperation extends BaseRemotableOperation<RecordCloneExecuteInput, RecordCloneExecuteOutput> {
+    readonly OperationKey = "RecordClone.Execute";
+    readonly ExecutionMode: "LongRunning";
+    readonly RequiredScope = "recordclone:execute";
+    readonly RequiresSystemUser = false;
+}
+/**
+ * Get Record Clone Lineage
+ * Traverse record links and clone logs to return clone ancestors and descendants for a record. Implemented by RecordCloneGetLineageServerOperation in @memberjunction/record-cloning.
+ * GenerationType=Manual — the server body is supplied by a hand-authored subclass registered
+ * under 'RecordClone.GetLineage'. This generated base provides the typed contract only (client-safe).
+ */
+export declare class RecordCloneGetLineageOperation extends BaseRemotableOperation<RecordCloneGetLineageInput, RecordCloneGetLineageOutput> {
+    readonly OperationKey = "RecordClone.GetLineage";
+    readonly ExecutionMode: "Sync";
+    readonly RequiredScope = "recordclone:read";
+    readonly RequiresSystemUser = false;
+}
+/**
+ * Plan Record Clone
+ * Plan a deterministic record clone graph traversal with pre-minted target keys and field transformations. Implemented by RecordClonePlanServerOperation in @memberjunction/record-cloning.
+ * GenerationType=Manual — the server body is supplied by a hand-authored subclass registered
+ * under 'RecordClone.Plan'. This generated base provides the typed contract only (client-safe).
+ */
+export declare class RecordClonePlanOperation extends BaseRemotableOperation<RecordClonePlanInput, RecordClonePlanOutput> {
+    readonly OperationKey = "RecordClone.Plan";
+    readonly ExecutionMode: "Sync";
+    readonly RequiredScope = "recordclone:read";
+    readonly RequiresSystemUser = false;
+}
 /**
  * Compare Records
  * Load a set of an entity's records (by composite key, column 0 = survivor/reference) and compute the field-level delta matrix between them. Read-only. Returns the loaded records + per-field deltas. Implemented by RecordComparisonCompareServerOperation in @memberjunction/record-comparison.
@@ -1394,6 +1992,90 @@ export declare class WebSearchQueryOperation extends BaseRemotableOperation<WebS
     readonly RequiredScope = "websearch:execute";
     readonly RequiresSystemUser = false;
 }
+/**
+ * Discard Work Queue Delivery
+ * Resolves one delivery without processing it, with a required reason. A pending or dead-lettered delivery becomes Discarded immediately; discarding a dead-lettered Ordered head unblocks its key. An in-flight delivery is cancelled instead (cancelRequested = true): the running handler is told to stop within one heartbeat interval (30 s at most) and the delivery becomes Discarded as soon as the handler acknowledges, or at lease expiry if its worker is gone. Implemented by WorkQueueDiscardDeliveryServerOperation in @memberjunction/work-queue-engine.
+ * GenerationType=Manual — the server body is supplied by a hand-authored subclass registered
+ * under 'WorkQueue.DiscardDelivery'. This generated base provides the typed contract only (client-safe).
+ */
+export declare class WorkQueueDiscardDeliveryOperation extends BaseRemotableOperation<WorkQueueDiscardDeliveryInput, WorkQueueDiscardDeliveryOutput> {
+    readonly OperationKey = "WorkQueue.DiscardDelivery";
+    readonly ExecutionMode: "Sync";
+    readonly RequiredScope = "workqueue:operate";
+    readonly RequiresSystemUser = false;
+}
+/**
+ * Get Work Queue Backlog
+ * Returns the autoscaler metric for one subscription: claimable pending deliveries (partition rules applied) plus in-flight deliveries. Both counts matter — schedulers such as KEDA subtract running executions from the metric, so a pending-only count starves the queue. Each count is capped at 1000 (capped = true). Implemented by WorkQueueGetBacklogServerOperation in @memberjunction/work-queue-engine.
+ * GenerationType=Manual — the server body is supplied by a hand-authored subclass registered
+ * under 'WorkQueue.GetBacklog'. This generated base provides the typed contract only (client-safe).
+ */
+export declare class WorkQueueGetBacklogOperation extends BaseRemotableOperation<WorkQueueGetBacklogInput, WorkQueueGetBacklogOutput> {
+    readonly OperationKey = "WorkQueue.GetBacklog";
+    readonly ExecutionMode: "Sync";
+    readonly RequiredScope = "workqueue:read";
+    readonly RequiresSystemUser = false;
+}
+/**
+ * Get Work Queue Subscription Stats
+ * Returns pending, in-flight and dead-lettered counts (plus blocked keys, oldest pending age and recent completions where the transport supports them) for one work-queue subscription or all of them. Implemented by WorkQueueGetSubscriptionStatsServerOperation in @memberjunction/work-queue-engine.
+ * GenerationType=Manual — the server body is supplied by a hand-authored subclass registered
+ * under 'WorkQueue.GetSubscriptionStats'. This generated base provides the typed contract only (client-safe).
+ */
+export declare class WorkQueueGetSubscriptionStatsOperation extends BaseRemotableOperation<WorkQueueGetSubscriptionStatsInput, WorkQueueGetSubscriptionStatsOutput> {
+    readonly OperationKey = "WorkQueue.GetSubscriptionStats";
+    readonly ExecutionMode: "Sync";
+    readonly RequiredScope = "workqueue:read";
+    readonly RequiresSystemUser = false;
+}
+/**
+ * List Work Queue Dead Letters
+ * Pages through one subscription's dead-lettered deliveries with their message, attempts, reason, last error and whether each blocks its partition key. Implemented by WorkQueueListDeadLettersServerOperation in @memberjunction/work-queue-engine.
+ * GenerationType=Manual — the server body is supplied by a hand-authored subclass registered
+ * under 'WorkQueue.ListDeadLetters'. This generated base provides the typed contract only (client-safe).
+ */
+export declare class WorkQueueListDeadLettersOperation extends BaseRemotableOperation<WorkQueueListDeadLettersInput, WorkQueueListDeadLettersOutput> {
+    readonly OperationKey = "WorkQueue.ListDeadLetters";
+    readonly ExecutionMode: "Sync";
+    readonly RequiredScope = "workqueue:read";
+    readonly RequiresSystemUser = false;
+}
+/**
+ * List Work Queue Partitions
+ * Pages through one subscription's partition keys that are in flight or blocked by a dead-lettered Ordered head, optionally filtered to one condition. Implemented by WorkQueueListPartitionsServerOperation in @memberjunction/work-queue-engine.
+ * GenerationType=Manual — the server body is supplied by a hand-authored subclass registered
+ * under 'WorkQueue.ListPartitions'. This generated base provides the typed contract only (client-safe).
+ */
+export declare class WorkQueueListPartitionsOperation extends BaseRemotableOperation<WorkQueueListPartitionsInput, WorkQueueListPartitionsOutput> {
+    readonly OperationKey = "WorkQueue.ListPartitions";
+    readonly ExecutionMode: "Sync";
+    readonly RequiredScope = "workqueue:read";
+    readonly RequiresSystemUser = false;
+}
+/**
+ * Replay Work Queue Dead Letter
+ * Returns one dead-lettered delivery to Pending with its attempts reset; an Ordered head keeps its position, so its key resumes once the replay completes. Implemented by WorkQueueReplayDeadLetterServerOperation in @memberjunction/work-queue-engine.
+ * GenerationType=Manual — the server body is supplied by a hand-authored subclass registered
+ * under 'WorkQueue.ReplayDeadLetter'. This generated base provides the typed contract only (client-safe).
+ */
+export declare class WorkQueueReplayDeadLetterOperation extends BaseRemotableOperation<WorkQueueReplayDeadLetterInput, WorkQueueReplayDeadLetterOutput> {
+    readonly OperationKey = "WorkQueue.ReplayDeadLetter";
+    readonly ExecutionMode: "Sync";
+    readonly RequiredScope = "workqueue:operate";
+    readonly RequiresSystemUser = false;
+}
+/**
+ * Validate Work Queue Bindings
+ * Validates work-queue topology and cloud resource bindings: with no transport name, the whole topology; with one, every topic and subscription bound to that transport against the resources it names. Implemented by WorkQueueValidateBindingsServerOperation in @memberjunction/work-queue-engine.
+ * GenerationType=Manual — the server body is supplied by a hand-authored subclass registered
+ * under 'WorkQueue.ValidateBindings'. This generated base provides the typed contract only (client-safe).
+ */
+export declare class WorkQueueValidateBindingsOperation extends BaseRemotableOperation<WorkQueueValidateBindingsInput, WorkQueueValidateBindingsOutput> {
+    readonly OperationKey = "WorkQueue.ValidateBindings";
+    readonly ExecutionMode: "Sync";
+    readonly RequiredScope = "workqueue:read";
+    readonly RequiresSystemUser = false;
+}
 /**
  * Draft Workflow
  * Draft a workflow's steps from a plain-English description. Returns a TaskGraphSpec and persists NOTHING — the draft goes to the canvas for the author to review, and only Workflow.Save commits it, which is what makes the front door's "nothing is saved until you approve it" promise true rather than merely stated. Constrained to agents that actually exist on the instance, because a workflow referencing an unknown agent cannot be saved and a draft that cannot be saved wastes the author's time. Validated with the SAME ValidateTaskGraphSpec the canvas and Workflow.Save run, so a draft that comes back cannot be rejected later for a reason drafting never checked. Implemented by WorkflowDraftServerOperation in @memberjunction/task-graph.