@trii/types 2.10.692 → 2.10.695

package/dist/Automations/Capabilities/Capability.d.ts

@@ -4,6 +4,37 @@ export declare enum AutomationCapabilityKind {
     ACTION = "action",
     CONDITION = "condition"
 }
+export declare enum AutomationCapabilityEffectClass {
+    NONE = "none",
+    READ = "read",
+    WRITE = "write",
+    COMMUNICATION = "communication",
+    BULK = "bulk"
+}
+export declare enum AutomationCapabilityIdempotency {
+    NONE = "none",
+    SUPPORTED = "supported",
+    REQUIRED = "required"
+}
+/** Capacidades operativas que el runtime puede aplicar de forma confiable. */
+export interface AutomationCapabilityExecutionSupport {
+    effectClass: AutomationCapabilityEffectClass;
+    supportsSimulation: boolean;
+    supportsTestTargets: boolean;
+    supportsUntilNode: boolean;
+    supportsFromNode: boolean;
+    supportsNodeOnly: boolean;
+    supportsCancellation: boolean;
+    idempotency: AutomationCapabilityIdempotency;
+    defaultTimeoutMs?: number | null;
+    maxAttempts?: number | null;
+    maxTestItems?: number | null;
+    inputSchema?: AutomationJsonSchema | null;
+    outputSchema?: AutomationJsonSchema | null;
+    simulationOutputSchema?: AutomationJsonSchema | null;
+    sensitivePaths?: string[] | null;
+    requiredPermissions?: string[] | null;
+}
 /**
  * Capacidad publicada por una aplicación de negocio para que Automation pueda
  * descubrirla y representarla sin incorporar reglas de ese dominio.
@@ -19,6 +50,8 @@ export interface AutomationCapability {
     requiredPermissions: string[];
     enabled: boolean;
     version: number;
+    /** Metadata opcional para definitions anteriores a la política de ejecución. */
+    executionSupport?: AutomationCapabilityExecutionSupport | null;
 }
 export interface AutomationCapabilityQuery {
     sourceApplications?: AutomationSourceApplication[];

package/dist/Automations/Capabilities/Capability.js

@@ -1,9 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AutomationCapabilityKind = void 0;
+exports.AutomationCapabilityIdempotency = exports.AutomationCapabilityEffectClass = exports.AutomationCapabilityKind = void 0;
 var AutomationCapabilityKind;
 (function (AutomationCapabilityKind) {
     AutomationCapabilityKind["TRIGGER"] = "trigger";
     AutomationCapabilityKind["ACTION"] = "action";
     AutomationCapabilityKind["CONDITION"] = "condition";
 })(AutomationCapabilityKind || (exports.AutomationCapabilityKind = AutomationCapabilityKind = {}));
+var AutomationCapabilityEffectClass;
+(function (AutomationCapabilityEffectClass) {
+    AutomationCapabilityEffectClass["NONE"] = "none";
+    AutomationCapabilityEffectClass["READ"] = "read";
+    AutomationCapabilityEffectClass["WRITE"] = "write";
+    AutomationCapabilityEffectClass["COMMUNICATION"] = "communication";
+    AutomationCapabilityEffectClass["BULK"] = "bulk";
+})(AutomationCapabilityEffectClass || (exports.AutomationCapabilityEffectClass = AutomationCapabilityEffectClass = {}));
+var AutomationCapabilityIdempotency;
+(function (AutomationCapabilityIdempotency) {
+    AutomationCapabilityIdempotency["NONE"] = "none";
+    AutomationCapabilityIdempotency["SUPPORTED"] = "supported";
+    AutomationCapabilityIdempotency["REQUIRED"] = "required";
+})(AutomationCapabilityIdempotency || (exports.AutomationCapabilityIdempotency = AutomationCapabilityIdempotency = {}));

package/dist/Automations/Executions/Execution.d.ts

@@ -1,4 +1,5 @@
 import { AutomationCustomer, AutomationError, AutomationJsonObject, AutomationPageRequest, AutomationResourceReference, AutomationSourceApplication } from '../Common';
+import { AutomationCapabilityEffectClass } from '../Capabilities';
 export declare enum AutomationExecutionStatus {
     QUEUED = "queued",
     RUNNING = "running",
@@ -17,6 +18,89 @@ export declare enum AutomationExecutionStepStatus {
     SKIPPED = "skipped",
     CANCELLED = "cancelled"
 }
+export declare enum AutomationExecutionPurpose {
+    PRODUCTION = "production",
+    TEST = "test"
+}
+export declare enum AutomationExecutionEffectMode {
+    SIMULATE = "simulate",
+    TEST_TARGETS = "testTargets",
+    REAL = "real"
+}
+export declare enum AutomationExecutionScopeKind {
+    FULL = "full",
+    UNTIL_NODE = "untilNode",
+    FROM_NODE = "fromNode",
+    NODE_ONLY = "nodeOnly"
+}
+export declare enum AutomationExecutionSourceKind {
+    MANUAL = "manual",
+    FIXTURE = "fixture",
+    CAPTURED_EVENT = "capturedEvent",
+    EXECUTION = "execution",
+    STEP_OUTPUT = "stepOutput"
+}
+export declare enum AutomationExecutionLineageOperation {
+    NEW = "new",
+    REPLAY = "replay",
+    RETRY = "retry"
+}
+export declare enum AutomationExecutionEffectDecision {
+    EXECUTED = "executed",
+    SIMULATED = "simulated",
+    REDIRECTED = "redirected",
+    BLOCKED = "blocked"
+}
+export interface AutomationExecutionScope {
+    kind: AutomationExecutionScopeKind;
+    startNodeId?: string | null;
+    stopNodeId?: string | null;
+}
+/** Referencia inmutable a la definición exacta utilizada por una ejecución. */
+export interface AutomationFlowSnapshotReference {
+    flowId: string;
+    flowVersionId?: string | null;
+    snapshotId?: string | null;
+    revision: number;
+    contentHash: string;
+}
+export interface AutomationExecutionSource {
+    kind: AutomationExecutionSourceKind;
+    fixtureId?: string | null;
+    capturedEventId?: string | null;
+    executionId?: string | null;
+    stepId?: string | null;
+}
+export interface AutomationExecutionLineage {
+    operation: AutomationExecutionLineageOperation;
+    sourceExecutionId?: string | null;
+    sourceStepId?: string | null;
+    rootExecutionId?: string | null;
+}
+/** Resumen seguro; la política interna completa nunca se expone al caller. */
+export interface AutomationExecutionPolicySummary {
+    maxDurationMs?: number | null;
+    maxSteps?: number | null;
+    maxIterations?: number | null;
+    maxItems?: number | null;
+    maxCost?: number | null;
+    currency?: string | null;
+    simulatedClockAt?: string | null;
+    requiresConfirmation: boolean;
+}
+export interface AutomationExecutionEffectRecord {
+    id: string;
+    nodeId: string;
+    effectClass: AutomationCapabilityEffectClass;
+    action: string;
+    decision: AutomationExecutionEffectDecision;
+    originalTarget?: AutomationResourceReference | null;
+    effectiveTarget?: AutomationResourceReference | null;
+    preview?: AutomationJsonObject | null;
+    providerReference?: string | null;
+    idempotencyKey?: string | null;
+    warnings?: string[] | null;
+}
 /**
  * Referencia genérica al evento que inició una ejecución.
  */
@@ -85,6 +169,18 @@ export interface AutomationExecution {
     correlationId?: string | null;
     parentExecutionId?: string | null;
     usage: AutomationExecutionUsage;
+    /** Ausente únicamente en ejecuciones creadas con contratos anteriores. */
+    purpose?: AutomationExecutionPurpose | null;
+    requestedEffectMode?: AutomationExecutionEffectMode | null;
+    effectiveEffectMode?: AutomationExecutionEffectMode | null;
+    scope?: AutomationExecutionScope | null;
+    source?: AutomationExecutionSource | null;
+    snapshot?: AutomationFlowSnapshotReference | null;
+    lineage?: AutomationExecutionLineage | null;
+    startedBy?: AutomationResourceReference | null;
+    policySummary?: AutomationExecutionPolicySummary | null;
+    testCaseId?: string | null;
+    testCaseRevision?: number | null;
 }
 export interface AutomationExecutionStep {
     id: string;
@@ -101,6 +197,13 @@ export interface AutomationExecutionStep {
     startedAt?: string | null;
     completedAt?: string | null;
     usage: AutomationExecutionUsage;
+    waitingReason?: string | null;
+    skippedReason?: string | null;
+    itemIndex?: number | null;
+    iteration?: number | null;
+    parentStepId?: string | null;
+    takenEdgeIds?: string[] | null;
+    effects?: AutomationExecutionEffectRecord[] | null;
 }
 export interface AutomationExecutionUsage {
     inputTokens: number;
@@ -121,6 +224,9 @@ export interface AutomationExecutionQuery extends AutomationPageRequest {
     createdFrom?: string | null;
     createdTo?: string | null;
     correlationId?: string | null;
+    purposes?: AutomationExecutionPurpose[] | null;
+    effectModes?: AutomationExecutionEffectMode[] | null;
+    testCaseId?: string | null;
 }
 export interface StartAutomationExecutionRequest {
     flowId: string;

package/dist/Automations/Executions/Execution.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AutomationExecutionStepStatus = exports.AutomationExecutionStatus = void 0;
+exports.AutomationExecutionEffectDecision = exports.AutomationExecutionLineageOperation = exports.AutomationExecutionSourceKind = exports.AutomationExecutionScopeKind = exports.AutomationExecutionEffectMode = exports.AutomationExecutionPurpose = exports.AutomationExecutionStepStatus = exports.AutomationExecutionStatus = void 0;
 var AutomationExecutionStatus;
 (function (AutomationExecutionStatus) {
     AutomationExecutionStatus["QUEUED"] = "queued";
@@ -21,3 +21,42 @@ var AutomationExecutionStepStatus;
     AutomationExecutionStepStatus["SKIPPED"] = "skipped";
     AutomationExecutionStepStatus["CANCELLED"] = "cancelled";
 })(AutomationExecutionStepStatus || (exports.AutomationExecutionStepStatus = AutomationExecutionStepStatus = {}));
+var AutomationExecutionPurpose;
+(function (AutomationExecutionPurpose) {
+    AutomationExecutionPurpose["PRODUCTION"] = "production";
+    AutomationExecutionPurpose["TEST"] = "test";
+})(AutomationExecutionPurpose || (exports.AutomationExecutionPurpose = AutomationExecutionPurpose = {}));
+var AutomationExecutionEffectMode;
+(function (AutomationExecutionEffectMode) {
+    AutomationExecutionEffectMode["SIMULATE"] = "simulate";
+    AutomationExecutionEffectMode["TEST_TARGETS"] = "testTargets";
+    AutomationExecutionEffectMode["REAL"] = "real";
+})(AutomationExecutionEffectMode || (exports.AutomationExecutionEffectMode = AutomationExecutionEffectMode = {}));
+var AutomationExecutionScopeKind;
+(function (AutomationExecutionScopeKind) {
+    AutomationExecutionScopeKind["FULL"] = "full";
+    AutomationExecutionScopeKind["UNTIL_NODE"] = "untilNode";
+    AutomationExecutionScopeKind["FROM_NODE"] = "fromNode";
+    AutomationExecutionScopeKind["NODE_ONLY"] = "nodeOnly";
+})(AutomationExecutionScopeKind || (exports.AutomationExecutionScopeKind = AutomationExecutionScopeKind = {}));
+var AutomationExecutionSourceKind;
+(function (AutomationExecutionSourceKind) {
+    AutomationExecutionSourceKind["MANUAL"] = "manual";
+    AutomationExecutionSourceKind["FIXTURE"] = "fixture";
+    AutomationExecutionSourceKind["CAPTURED_EVENT"] = "capturedEvent";
+    AutomationExecutionSourceKind["EXECUTION"] = "execution";
+    AutomationExecutionSourceKind["STEP_OUTPUT"] = "stepOutput";
+})(AutomationExecutionSourceKind || (exports.AutomationExecutionSourceKind = AutomationExecutionSourceKind = {}));
+var AutomationExecutionLineageOperation;
+(function (AutomationExecutionLineageOperation) {
+    AutomationExecutionLineageOperation["NEW"] = "new";
+    AutomationExecutionLineageOperation["REPLAY"] = "replay";
+    AutomationExecutionLineageOperation["RETRY"] = "retry";
+})(AutomationExecutionLineageOperation || (exports.AutomationExecutionLineageOperation = AutomationExecutionLineageOperation = {}));
+var AutomationExecutionEffectDecision;
+(function (AutomationExecutionEffectDecision) {
+    AutomationExecutionEffectDecision["EXECUTED"] = "executed";
+    AutomationExecutionEffectDecision["SIMULATED"] = "simulated";
+    AutomationExecutionEffectDecision["REDIRECTED"] = "redirected";
+    AutomationExecutionEffectDecision["BLOCKED"] = "blocked";
+})(AutomationExecutionEffectDecision || (exports.AutomationExecutionEffectDecision = AutomationExecutionEffectDecision = {}));

package/dist/Automations/Executions/Testing.d.ts

@@ -0,0 +1,166 @@
+import { AutomationCustomer, AutomationJsonObject, AutomationJsonSchema, AutomationJsonValue, AutomationResourceReference } from '../Common';
+import { AutomationCapabilityEffectClass } from '../Capabilities';
+import { AutomationExecutionContextInput, AutomationExecutionEffectMode, AutomationExecutionScope, AutomationExecutionSource, AutomationFlowSnapshotReference } from './Execution';
+export declare enum AutomationArtifactStatus {
+    UPLOADING = "uploading",
+    SCANNING = "scanning",
+    AVAILABLE = "available",
+    REJECTED = "rejected",
+    EXPIRED = "expired"
+}
+export declare enum AutomationArtifactOrigin {
+    UPLOAD = "upload",
+    CAPTURED_EVENT = "capturedEvent",
+    EXECUTION = "execution",
+    GENERATED = "generated"
+}
+export interface AutomationArtifactReference {
+    id: string;
+    name: string;
+    mimeType: string;
+    size: number;
+    origin: AutomationArtifactOrigin;
+    status: AutomationArtifactStatus;
+    checksum?: string | null;
+    expiresAt?: string | null;
+    owner?: AutomationResourceReference | null;
+}
+export declare enum AutomationTestCaseVisibility {
+    PRIVATE = "private",
+    SHARED = "shared"
+}
+export declare enum AutomationTestAssertionKind {
+    EXECUTION_STATUS = "executionStatus",
+    NODE_REACHED = "nodeReached",
+    NODE_NOT_REACHED = "nodeNotReached",
+    PATH_EXISTS = "pathExists",
+    PATH_TYPE = "pathType",
+    PATH_VALUE = "pathValue",
+    ERROR_CODE = "errorCode",
+    MAX_DURATION = "maxDuration",
+    MAX_COST = "maxCost"
+}
+export declare enum AutomationTestAssertionStatus {
+    PENDING = "pending",
+    PASSED = "passed",
+    FAILED = "failed",
+    SKIPPED = "skipped"
+}
+export interface AutomationTestAssertion {
+    id: string;
+    kind: AutomationTestAssertionKind;
+    nodeId?: string | null;
+    path?: string | null;
+    expected?: AutomationJsonValue;
+    configuration?: AutomationJsonObject | null;
+}
+export interface AutomationTestAssertionResult {
+    assertionId: string;
+    status: AutomationTestAssertionStatus;
+    message?: string | null;
+    actual?: AutomationJsonValue;
+}
+/** Configuración común utilizada por preflight e inicio de una prueba. */
+export interface AutomationTestConfiguration {
+    flowId: string;
+    flowVersionId?: string | null;
+    draftRevision?: number | null;
+    entryPointId: string;
+    scope: AutomationExecutionScope;
+    requestedEffectMode: AutomationExecutionEffectMode;
+    source: AutomationExecutionSource;
+    customer?: AutomationCustomer | null;
+    input?: AutomationJsonObject | null;
+    context?: AutomationExecutionContextInput | null;
+    nodeInputOverrides?: Record<string, AutomationJsonObject> | null;
+    artifactIds?: string[] | null;
+    testTargetOverrides?: AutomationJsonObject | null;
+}
+export interface StartAutomationTestRequest extends AutomationTestConfiguration {
+    idempotencyKey: string;
+    correlationId?: string | null;
+    testCaseId?: string | null;
+    testCaseRevision?: number | null;
+    preflightToken?: string | null;
+}
+export interface AutomationTestPreflightRequest extends AutomationTestConfiguration {
+}
+export declare enum AutomationTestPreflightStatus {
+    READY = "ready",
+    WARNING = "warning",
+    BLOCKED = "blocked"
+}
+export declare enum AutomationTestPreflightIssueSeverity {
+    INFO = "info",
+    WARNING = "warning",
+    BLOCKER = "blocker"
+}
+export interface AutomationTestPreflightIssue {
+    code: string;
+    severity: AutomationTestPreflightIssueSeverity;
+    message: string;
+    nodeId?: string | null;
+    details?: AutomationJsonObject | null;
+}
+export interface AutomationTestPreflightNode {
+    nodeId: string;
+    nodeDefinitionCode: string;
+    nodeDefinitionVersion: number;
+    reachable: boolean;
+    executable: boolean;
+    issues: AutomationTestPreflightIssue[];
+}
+export interface AutomationTestPreflightEffect {
+    nodeId: string;
+    effectClass: AutomationCapabilityEffectClass;
+    action: string;
+    description?: string | null;
+    originalTarget?: AutomationResourceReference | null;
+    effectiveTarget?: AutomationResourceReference | null;
+    estimatedItems?: number | null;
+}
+export interface AutomationTestPreflightLimits {
+    maxDurationMs?: number | null;
+    maxSteps?: number | null;
+    maxIterations?: number | null;
+    maxItems?: number | null;
+    estimatedCost?: number | null;
+    currency?: string | null;
+}
+export interface AutomationTestPreflightResult {
+    status: AutomationTestPreflightStatus;
+    snapshot: AutomationFlowSnapshotReference;
+    requestedEffectMode: AutomationExecutionEffectMode;
+    effectiveEffectMode: AutomationExecutionEffectMode;
+    nodes: AutomationTestPreflightNode[];
+    effects: AutomationTestPreflightEffect[];
+    issues: AutomationTestPreflightIssue[];
+    limits: AutomationTestPreflightLimits;
+    requiresConfirmation: boolean;
+    preflightToken: string;
+    expiresAt: string;
+}
+export interface AutomationTestCase {
+    id: string;
+    spaceId: string;
+    flowId: string;
+    name: string;
+    description?: string | null;
+    revision: number;
+    visibility: AutomationTestCaseVisibility;
+    configuration: AutomationTestConfiguration;
+    assertions: AutomationTestAssertion[];
+    createdBy: string;
+    createdAt: string;
+    updatedBy?: string | null;
+    updatedAt?: string | null;
+}
+/** Schema opcional para que el Estudio genere un simulador por Entry Point. */
+export interface AutomationEntryPointTestSchema {
+    entryPointId: string;
+    inputSchema?: AutomationJsonSchema | null;
+    contextSchema?: AutomationJsonSchema | null;
+    allowedArtifactMimeTypes?: string[] | null;
+    maxArtifactSize?: number | null;
+    maxArtifacts?: number | null;
+}

package/dist/Automations/Executions/Testing.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutomationTestPreflightIssueSeverity = exports.AutomationTestPreflightStatus = exports.AutomationTestAssertionStatus = exports.AutomationTestAssertionKind = exports.AutomationTestCaseVisibility = exports.AutomationArtifactOrigin = exports.AutomationArtifactStatus = void 0;
+var AutomationArtifactStatus;
+(function (AutomationArtifactStatus) {
+    AutomationArtifactStatus["UPLOADING"] = "uploading";
+    AutomationArtifactStatus["SCANNING"] = "scanning";
+    AutomationArtifactStatus["AVAILABLE"] = "available";
+    AutomationArtifactStatus["REJECTED"] = "rejected";
+    AutomationArtifactStatus["EXPIRED"] = "expired";
+})(AutomationArtifactStatus || (exports.AutomationArtifactStatus = AutomationArtifactStatus = {}));
+var AutomationArtifactOrigin;
+(function (AutomationArtifactOrigin) {
+    AutomationArtifactOrigin["UPLOAD"] = "upload";
+    AutomationArtifactOrigin["CAPTURED_EVENT"] = "capturedEvent";
+    AutomationArtifactOrigin["EXECUTION"] = "execution";
+    AutomationArtifactOrigin["GENERATED"] = "generated";
+})(AutomationArtifactOrigin || (exports.AutomationArtifactOrigin = AutomationArtifactOrigin = {}));
+var AutomationTestCaseVisibility;
+(function (AutomationTestCaseVisibility) {
+    AutomationTestCaseVisibility["PRIVATE"] = "private";
+    AutomationTestCaseVisibility["SHARED"] = "shared";
+})(AutomationTestCaseVisibility || (exports.AutomationTestCaseVisibility = AutomationTestCaseVisibility = {}));
+var AutomationTestAssertionKind;
+(function (AutomationTestAssertionKind) {
+    AutomationTestAssertionKind["EXECUTION_STATUS"] = "executionStatus";
+    AutomationTestAssertionKind["NODE_REACHED"] = "nodeReached";
+    AutomationTestAssertionKind["NODE_NOT_REACHED"] = "nodeNotReached";
+    AutomationTestAssertionKind["PATH_EXISTS"] = "pathExists";
+    AutomationTestAssertionKind["PATH_TYPE"] = "pathType";
+    AutomationTestAssertionKind["PATH_VALUE"] = "pathValue";
+    AutomationTestAssertionKind["ERROR_CODE"] = "errorCode";
+    AutomationTestAssertionKind["MAX_DURATION"] = "maxDuration";
+    AutomationTestAssertionKind["MAX_COST"] = "maxCost";
+})(AutomationTestAssertionKind || (exports.AutomationTestAssertionKind = AutomationTestAssertionKind = {}));
+var AutomationTestAssertionStatus;
+(function (AutomationTestAssertionStatus) {
+    AutomationTestAssertionStatus["PENDING"] = "pending";
+    AutomationTestAssertionStatus["PASSED"] = "passed";
+    AutomationTestAssertionStatus["FAILED"] = "failed";
+    AutomationTestAssertionStatus["SKIPPED"] = "skipped";
+})(AutomationTestAssertionStatus || (exports.AutomationTestAssertionStatus = AutomationTestAssertionStatus = {}));
+var AutomationTestPreflightStatus;
+(function (AutomationTestPreflightStatus) {
+    AutomationTestPreflightStatus["READY"] = "ready";
+    AutomationTestPreflightStatus["WARNING"] = "warning";
+    AutomationTestPreflightStatus["BLOCKED"] = "blocked";
+})(AutomationTestPreflightStatus || (exports.AutomationTestPreflightStatus = AutomationTestPreflightStatus = {}));
+var AutomationTestPreflightIssueSeverity;
+(function (AutomationTestPreflightIssueSeverity) {
+    AutomationTestPreflightIssueSeverity["INFO"] = "info";
+    AutomationTestPreflightIssueSeverity["WARNING"] = "warning";
+    AutomationTestPreflightIssueSeverity["BLOCKER"] = "blocker";
+})(AutomationTestPreflightIssueSeverity || (exports.AutomationTestPreflightIssueSeverity = AutomationTestPreflightIssueSeverity = {}));

package/dist/Automations/Executions/index.d.ts

@@ -1 +1,2 @@
 export * from './Execution';
+export * from './Testing';

package/dist/Automations/Executions/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./Execution"), exports);
+__exportStar(require("./Testing"), exports);

package/dist/Conversations/Conversation.d.ts

@@ -210,35 +210,35 @@ export type ConversationAssignmentSnapshot = {
     offerExpiresAt?: never;
     assignedAt?: never;
     acceptedAt?: never;
-} | QueuedConversationAssignmentBase & {
+} | (QueuedConversationAssignmentBase & {
     status: 'queued' | 'routing';
     owner: NoConversationOwner;
     offeredAt?: never;
     offerExpiresAt?: never;
     assignedAt?: never;
     acceptedAt?: never;
-} | QueuedConversationAssignmentBase & {
+}) | (QueuedConversationAssignmentBase & {
     status: 'offered';
     owner: UserConversationOwner;
     offeredAt: Date;
     offerExpiresAt?: Date;
     assignedAt?: never;
     acceptedAt?: never;
-} | QueuedConversationAssignmentBase & {
+}) | (QueuedConversationAssignmentBase & {
     status: 'assigned';
     owner: UserConversationOwner;
     offeredAt?: Date;
     offerExpiresAt?: Date;
     assignedAt: Date;
     acceptedAt?: never;
-} | QueuedConversationAssignmentBase & {
+}) | (QueuedConversationAssignmentBase & {
     status: 'accepted';
     owner: UserConversationOwner;
     offeredAt?: Date;
     offerExpiresAt?: Date;
     assignedAt: Date;
     acceptedAt: Date;
-};
+});
 export type ActorType = 'user' | 'contact' | 'bot' | 'flow' | 'system';
 export type ParticipantRole = 'owner' | 'collaborator' | 'follower' | 'mentioned' | 'supervisor' | 'bot' | 'flow' | 'historical';
 export type ConversationEventType = 'conversation_created' | 'queued' | 'assigned' | 'accepted' | 'transferred' | 'consult_requested' | 'collaborator_added' | 'participant_added' | 'participant_removed' | 'participation_abandoned' | 'follow_started' | 'follow_stopped' | 'message_sent' | 'message_received' | 'internal_note_added' | 'bot_started' | 'bot_finished' | 'flow_started' | 'flow_finished' | 'status_changed' | 'resolved' | 'reopened' | 'sla_warning' | 'sla_breached' | 'sla_started' | 'sla_paused' | 'sla_resumed' | 'sla_met' | 'sla_overridden';
@@ -272,15 +272,15 @@ interface ConversationSubscriptionBase {
  * A subscription is persistent product intent. Assignment or participation
  * visibility must not create it unless an explicit auto-follow policy applies.
  */
-export type ConversationSubscription = ConversationSubscriptionBase & {
+export type ConversationSubscription = (ConversationSubscriptionBase & {
     status: 'following';
     followedAt: Date;
     unfollowedAt?: never;
-} | ConversationSubscriptionBase & {
+}) | (ConversationSubscriptionBase & {
     status: 'unfollowed';
     followedAt: Date;
     unfollowedAt: Date;
-};
+});
 export type InboxVisibilityReason = 'manual_follow' | 'assigned_to_user' | 'shared_queue_member' | 'queue_claimable' | 'active_participant' | 'sla_warning_owner' | 'sla_breached_owner' | 'supervised_queue_sla' | 'supervisor_escalation' | 'resolved_visible';
 export interface ConversationInboxSnapshot {
     interactionKind: 'private' | 'wall_post' | 'comment' | 'mention';

package/dist/Conversations/InboxMongo.d.ts

@@ -11,7 +11,7 @@ export declare const INBOX_PROCESSOR_RECEIPTS_COLLECTION = "inbox_processor_rece
  * InboxAudienceResolver receives as input.
  */
 export declare const CONVERSATION_SUBSCRIPTION_INDEXES: readonly [{
-    readonly name: "uq_subscription_user_conversation";
+    readonly name: 'uq_subscription_user_conversation';
     readonly key: {
         readonly spaceId: 1;
         readonly userId: 1;
@@ -19,7 +19,7 @@ export declare const CONVERSATION_SUBSCRIPTION_INDEXES: readonly [{
     };
     readonly unique: true;
 }, {
-    readonly name: "ix_subscription_conversation_followers";
+    readonly name: 'ix_subscription_conversation_followers';
     readonly key: {
         readonly spaceId: 1;
         readonly conversationId: 1;
@@ -35,7 +35,7 @@ export declare const CONVERSATION_SUBSCRIPTION_INDEXES: readonly [{
  * must not combine multiple array paths.
  */
 export declare const USER_INBOX_ITEM_INDEXES: readonly [{
-    readonly name: "uq_inbox_item_user_conversation";
+    readonly name: 'uq_inbox_item_user_conversation';
     readonly key: {
         readonly spaceId: 1;
         readonly userId: 1;
@@ -43,7 +43,7 @@ export declare const USER_INBOX_ITEM_INDEXES: readonly [{
     };
     readonly unique: true;
 }, {
-    readonly name: "ix_inbox_view_activity";
+    readonly name: 'ix_inbox_view_activity';
     readonly key: {
         readonly spaceId: 1;
         readonly userId: 1;
@@ -53,7 +53,7 @@ export declare const USER_INBOX_ITEM_INDEXES: readonly [{
         readonly id: -1;
     };
 }, {
-    readonly name: "ix_inbox_view_priority";
+    readonly name: 'ix_inbox_view_priority';
     readonly key: {
         readonly spaceId: 1;
         readonly userId: 1;
@@ -64,7 +64,7 @@ export declare const USER_INBOX_ITEM_INDEXES: readonly [{
         readonly id: -1;
     };
 }, {
-    readonly name: "ix_inbox_view_status_activity";
+    readonly name: 'ix_inbox_view_status_activity';
     readonly key: {
         readonly spaceId: 1;
         readonly userId: 1;
@@ -74,7 +74,7 @@ export declare const USER_INBOX_ITEM_INDEXES: readonly [{
         readonly id: -1;
     };
 }, {
-    readonly name: "ix_inbox_view_queue_activity";
+    readonly name: 'ix_inbox_view_queue_activity';
     readonly key: {
         readonly spaceId: 1;
         readonly userId: 1;
@@ -91,7 +91,7 @@ export declare const USER_INBOX_ITEM_INDEXES: readonly [{
  * spaceId + userId prefix.
  */
 export declare const USER_INBOX_COUNTER_INDEXES: readonly [{
-    readonly name: "uq_inbox_counter_user_view";
+    readonly name: 'uq_inbox_counter_user_view';
     readonly key: {
         readonly spaceId: 1;
         readonly userId: 1;
@@ -103,7 +103,7 @@ export declare const USER_INBOX_COUNTER_INDEXES: readonly [{
  * MongoDB indexes for durable processor idempotency receipts.
  */
 export declare const INBOX_PROCESSOR_RECEIPT_INDEXES: readonly [{
-    readonly name: "uq_inbox_processor_source_scope";
+    readonly name: 'uq_inbox_processor_source_scope';
     readonly key: {
         readonly processor: 1;
         readonly sourceEventId: 1;
@@ -144,11 +144,11 @@ interface InboxPageQueryBase {
     viewId: InboxViewId;
     limit: number;
 }
-export type InboxPageQuery = InboxPageQueryBase & {
+export type InboxPageQuery = (InboxPageQueryBase & {
     sort: 'activity';
     cursor?: InboxActivityCursor;
-} | InboxPageQueryBase & {
+}) | (InboxPageQueryBase & {
     sort: 'priority';
     cursor?: InboxPriorityCursor;
-};
+});
 export {};