@trii/types 2.10.686 → 2.10.688

package/dist/src/Automations/Flows/Flow.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowEntryPointExecutionMode = exports.AutomationFlowVersionStatus = exports.AutomationFlowStatus = exports.AutomationFlowKind = void 0;
+var AutomationFlowKind;
+(function (AutomationFlowKind) {
+    AutomationFlowKind["CONVERSATIONAL"] = "conversational";
+    AutomationFlowKind["VOICE"] = "voice";
+    AutomationFlowKind["CAMPAIGN"] = "campaign";
+    AutomationFlowKind["MARKETING"] = "marketing";
+    AutomationFlowKind["TICKET"] = "ticket";
+    AutomationFlowKind["SALES"] = "sales";
+    AutomationFlowKind["GENERIC"] = "generic";
+})(AutomationFlowKind || (exports.AutomationFlowKind = AutomationFlowKind = {}));
+var AutomationFlowStatus;
+(function (AutomationFlowStatus) {
+    AutomationFlowStatus["DRAFT"] = "draft";
+    AutomationFlowStatus["ACTIVE"] = "active";
+    AutomationFlowStatus["DISABLED"] = "disabled";
+    AutomationFlowStatus["ARCHIVED"] = "archived";
+})(AutomationFlowStatus || (exports.AutomationFlowStatus = AutomationFlowStatus = {}));
+var AutomationFlowVersionStatus;
+(function (AutomationFlowVersionStatus) {
+    AutomationFlowVersionStatus["DRAFT"] = "draft";
+    AutomationFlowVersionStatus["TESTING"] = "testing";
+    AutomationFlowVersionStatus["PUBLISHED"] = "published";
+    AutomationFlowVersionStatus["DEPRECATED"] = "deprecated";
+})(AutomationFlowVersionStatus || (exports.AutomationFlowVersionStatus = AutomationFlowVersionStatus = {}));
+var FlowEntryPointExecutionMode;
+(function (FlowEntryPointExecutionMode) {
+    /** Un evento inicia como máximo una ejecución de esta versión del Flow. */
+    FlowEntryPointExecutionMode["SINGLE"] = "single";
+    /** El solapamiento fue habilitado explícitamente. */
+    FlowEntryPointExecutionMode["MULTIPLE"] = "multiple";
+})(FlowEntryPointExecutionMode || (exports.FlowEntryPointExecutionMode = FlowEntryPointExecutionMode = {}));

package/dist/src/Automations/Flows/Requests.d.ts

@@ -0,0 +1,71 @@
+import { AutomationPageRequest } from '../Common';
+import { AutomationFlowDefinition, AutomationFlowKind, AutomationFlowStatus, AutomationFlowVersion, AutomationFlowVersionStatus, AutomationFlowCanvas, FlowEntryPoint } from './Flow';
+import { AutomationFlowValidationResult } from './Validation';
+export interface CreateAutomationFlowRequest {
+    name: string;
+    description?: string | null;
+    kind: AutomationFlowKind;
+    ownerId?: string | null;
+    tags: string[];
+    initialCanvas?: AutomationFlowCanvas | null;
+    entryPoints: FlowEntryPoint[];
+}
+export interface UpdateAutomationFlowRequest {
+    name: string;
+    description?: string | null;
+    kind: AutomationFlowKind;
+    ownerId?: string | null;
+    tags: string[];
+}
+export interface AutomationFlowSummary {
+    id: string;
+    name: string;
+    description?: string | null;
+    kind: AutomationFlowKind;
+    status: AutomationFlowStatus;
+    ownerId?: string | null;
+    tags: string[];
+    draftVersionId?: string | null;
+    activeVersionId?: string | null;
+    updatedAt?: string | null;
+}
+export interface AutomationFlowDetails {
+    definition: AutomationFlowDefinition;
+    draftVersion?: AutomationFlowVersion | null;
+    activeVersion?: AutomationFlowVersion | null;
+}
+export interface CreateAutomationFlowVersionRequest {
+    sourceVersionId?: string | null;
+    schemaVersion: number;
+    canvas?: AutomationFlowCanvas | null;
+    entryPoints?: FlowEntryPoint[] | null;
+}
+export interface UpdateAutomationFlowDraftRequest {
+    expectedRevision: number;
+    status: AutomationFlowVersionStatus;
+    schemaVersion: number;
+    canvas: AutomationFlowCanvas;
+    entryPoints: FlowEntryPoint[];
+}
+export interface PublishAutomationFlowVersionRequest {
+    expectedRevision: number;
+    validateOnly: boolean;
+}
+export interface PublishAutomationFlowVersionResult {
+    definition: AutomationFlowDefinition;
+    version: AutomationFlowVersion;
+    validation: AutomationFlowValidationResult;
+    published: boolean;
+}
+export interface ReplaceFlowEntryPointsRequest {
+    expectedRevision: number;
+    entryPoints: FlowEntryPoint[];
+}
+export interface AutomationFlowQuery extends AutomationPageRequest {
+    search?: string | null;
+    kinds?: AutomationFlowKind[] | null;
+    statuses?: AutomationFlowStatus[] | null;
+    ownerId?: string | null;
+    tags?: string[] | null;
+    includeArchived: boolean;
+}

package/dist/src/Automations/Flows/Requests.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/Automations/Flows/Validation.d.ts

@@ -0,0 +1,28 @@
+import { AutomationJsonObject } from '../Common';
+export declare enum AutomationValidationSeverity {
+    INFO = "info",
+    WARNING = "warning",
+    ERROR = "error"
+}
+export interface AutomationValidationIssue {
+    code: string;
+    severity: AutomationValidationSeverity;
+    message: string;
+    path?: string | null;
+    nodeId?: string | null;
+    entryPointId?: string | null;
+    details?: AutomationJsonObject | null;
+}
+export interface AutomationFlowValidationResult {
+    flowId: string;
+    flowVersionId: string;
+    valid: boolean;
+    issues: AutomationValidationIssue[];
+    validatedAt: string;
+}
+export interface FlowEntryPointOverlap {
+    firstEntryPointId: string;
+    secondEntryPointId: string;
+    reason: string;
+    allowsMultipleExecutions: boolean;
+}

package/dist/src/Automations/Flows/Validation.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutomationValidationSeverity = void 0;
+var AutomationValidationSeverity;
+(function (AutomationValidationSeverity) {
+    AutomationValidationSeverity["INFO"] = "info";
+    AutomationValidationSeverity["WARNING"] = "warning";
+    AutomationValidationSeverity["ERROR"] = "error";
+})(AutomationValidationSeverity || (exports.AutomationValidationSeverity = AutomationValidationSeverity = {}));

package/dist/src/Automations/Flows/index.d.ts

@@ -0,0 +1,4 @@
+export * from './Flow';
+export * from './Canvas';
+export * from './Requests';
+export * from './Validation';

package/dist/src/Automations/Flows/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Flow"), exports);
+__exportStar(require("./Canvas"), exports);
+__exportStar(require("./Requests"), exports);
+__exportStar(require("./Validation"), exports);

package/dist/src/Automations/Nodes/Node.d.ts

@@ -0,0 +1,75 @@
+import { AutomationJsonObject, AutomationJsonSchema, AutomationJsonValue, AutomationPageRequest, AutomationSourceApplication } from '../Common';
+import { AutomationCapabilityReference } from '../Capabilities';
+import { AutomationNodeHandle, AutomationNodeKind } from '../Flows';
+export declare enum AutomationNodePropertyEditor {
+    STRING = "string",
+    NUMBER = "number",
+    BOOLEAN = "boolean",
+    PASSWORD = "password",
+    JSON = "json",
+    DATE = "date",
+    FILE = "file",
+    CODE = "code",
+    OPTIONS = "options",
+    MULTI_OPTIONS = "multiOptions",
+    ASYNC_OPTIONS = "asyncOptions",
+    ASYNC_MULTI_OPTIONS = "asyncMultiOptions"
+}
+export interface AutomationNodeDefinition {
+    code: string;
+    version: number;
+    kind: AutomationNodeKind;
+    sourceApplication: AutomationSourceApplication;
+    name: string;
+    description?: string | null;
+    icon?: string | null;
+    color?: string | null;
+    tags: string[];
+    requiredPermissions: string[];
+    capability?: AutomationCapabilityReference | null;
+    inputs: AutomationNodeHandle[];
+    outputs: AutomationNodeHandle[];
+    properties: AutomationNodePropertyDefinition[];
+    inputSchema?: AutomationJsonSchema | null;
+    outputSchema?: AutomationJsonSchema | null;
+    enabled: boolean;
+}
+export interface AutomationNodePropertyDefinition {
+    id: string;
+    label: string;
+    description?: string | null;
+    editor: AutomationNodePropertyEditor;
+    required: boolean;
+    defaultValue?: AutomationJsonValue;
+    schema?: AutomationJsonSchema | null;
+    options: AutomationNodeOption[];
+    optionsCapabilityCode?: string | null;
+    ui?: AutomationJsonObject | null;
+    showWhen?: AutomationJsonObject | null;
+    hideWhen?: AutomationJsonObject | null;
+}
+export interface AutomationNodeOption {
+    id: string;
+    label: string;
+    description?: string | null;
+    imageUrl?: string | null;
+    metadata?: AutomationJsonObject | null;
+}
+export interface AutomationNodeDefinitionQuery extends AutomationPageRequest {
+    search?: string | null;
+    kinds?: AutomationNodeKind[] | null;
+    sourceApplications?: AutomationSourceApplication[] | null;
+    tags?: string[] | null;
+    enabledOnly: boolean;
+}
+export interface AutomationNodeOptionsRequest {
+    definitionCode: string;
+    definitionVersion: number;
+    propertyId: string;
+    currentValues: AutomationJsonObject;
+    context: AutomationJsonObject;
+}
+export interface AutomationNodeOptionsResult {
+    options: AutomationNodeOption[];
+    continuationToken?: string | null;
+}

package/dist/src/Automations/Nodes/Node.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutomationNodePropertyEditor = void 0;
+var AutomationNodePropertyEditor;
+(function (AutomationNodePropertyEditor) {
+    AutomationNodePropertyEditor["STRING"] = "string";
+    AutomationNodePropertyEditor["NUMBER"] = "number";
+    AutomationNodePropertyEditor["BOOLEAN"] = "boolean";
+    AutomationNodePropertyEditor["PASSWORD"] = "password";
+    AutomationNodePropertyEditor["JSON"] = "json";
+    AutomationNodePropertyEditor["DATE"] = "date";
+    AutomationNodePropertyEditor["FILE"] = "file";
+    AutomationNodePropertyEditor["CODE"] = "code";
+    AutomationNodePropertyEditor["OPTIONS"] = "options";
+    AutomationNodePropertyEditor["MULTI_OPTIONS"] = "multiOptions";
+    AutomationNodePropertyEditor["ASYNC_OPTIONS"] = "asyncOptions";
+    AutomationNodePropertyEditor["ASYNC_MULTI_OPTIONS"] = "asyncMultiOptions";
+})(AutomationNodePropertyEditor || (exports.AutomationNodePropertyEditor = AutomationNodePropertyEditor = {}));

package/dist/src/Automations/Nodes/index.d.ts

@@ -0,0 +1 @@
+export * from './Node';

package/dist/src/Automations/Nodes/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Node"), exports);

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

@@ -0,0 +1,6 @@
+export * from './Common';
+export * from './Flows';
+export * from './Capabilities';
+export * from './Executions';
+export * from './Nodes';
+export * from './Events';

package/dist/src/Automations/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Common"), exports);
+__exportStar(require("./Flows"), exports);
+__exportStar(require("./Capabilities"), exports);
+__exportStar(require("./Executions"), exports);
+__exportStar(require("./Nodes"), exports);
+__exportStar(require("./Events"), exports);

package/dist/src/Common/Channels/Channel.d.ts

@@ -37,6 +37,16 @@ interface IChannelInfo {
      */
     status?: string;
 }
+/**
+ * Fallback routing used only when no published Flow entry point matches the
+ * channel, or when the selected Flow cannot produce a valid disposition.
+ *
+ * Flow-to-channel bindings remain authoritative in FlowEntryPoint.
+ */
+interface ChannelConversationRoutingConfig {
+    /** Stable id of a ConversationQueue in the same space as the channel. */
+    defaultQueueId: string;
+}
 interface IChannel {
     id?: string | null;
     spaceId?: string | null;
@@ -60,6 +70,12 @@ interface IChannel {
      * habilita la creacion de conversaciones para este canal, si esta en false, los mensajes entrantes no generaran conversaciones
      */
     conversationsEnabled: boolean | false;
+    /**
+     * Default Queue for newly-created conversations that are not handled by a
+     * Flow. Store only the Queue id; Queue configuration remains authoritative
+     * in the Conversations domain.
+     */
+    conversationRouting?: ChannelConversationRoutingConfig | null;
     /**
      * Gets or sets a value indicating whether webhook notifications are enabled.
      * Redirects incoming messages to the specified webhook URL when set to true.
@@ -105,4 +121,4 @@ declare enum channelStatus {
     SUSPENDED = 7,
     CONFIGURATION_PENDING = 9
 }
-export { IChannel, IChannelInfo, channelStatus, MessagingAvailability };
+export { IChannel, IChannelInfo, ChannelConversationRoutingConfig, channelStatus, MessagingAvailability };

package/dist/src/Conversations/Conversation.d.ts

@@ -4,10 +4,13 @@ import { GroupInfo } from "./Groups/Group";
 import { Channels } from "../Common/index";
 import { IContactAddress, IContactInfo } from "../Contacts/contacts";
 import { IEnding } from "./Ending";
+import { ChatType } from "../Chats/Chat";
 export interface IConversation {
     id: string;
     spaceId: string;
     version: number;
+    /** @deprecated Use assignment.owner. */
+    type: ChatType;
     /**only for Front-End */
     chatName: string;
     chatImage: string;
@@ -21,6 +24,8 @@ export interface IConversation {
     status: ConversationStatus;
     priority: 'low' | 'normal' | 'high' | 'urgent';
     assignment: ConversationAssignmentSnapshot;
+    /** @deprecated Use owner and assignment.*/
+    assignedTo?: ConversationAssigned;
     sla: {
         status: 'none' | 'running' | 'warning' | 'breached' | 'met';
         deadlineAt?: Date;
@@ -36,7 +41,13 @@ export interface IConversation {
     lastAgentActivityAt?: Date;
     labels: ILabel[];
     pinned: boolean;
+    /** @deprecated A transfer is represented by an event and the resulting current state. */
+    transferBy?: string;
+    /** @deprecated A transfer is represented by an event and the resulting current state. */
+    transferTo?: ConversationAssigned;
     expired: boolean;
+    /** @deprecated Expiration does not own a separate assignment snapshot.*/
+    expiredAssignedTo: ConversationAssigned;
     participants: UserInfo[];
     archived: boolean;
     spam: boolean;

package/dist/src/Conversations/Queue.d.ts

@@ -64,3 +64,44 @@ export interface ConversationQueue {
     updatedAt: Date;
     updatedByUserId?: ID;
 }
+/**
+ * Editable Queue definition sent by clients.
+ *
+ * It excludes id, version and audit fields controlled by the backend. Nested
+ * routing, SLA and audience objects use full-replacement semantics.
+ */
+export interface ConversationQueueDefinitionInput {
+    name: string;
+    description?: string;
+    color?: string;
+    enabled: boolean;
+    priority: number;
+    memberGroupIds: ID[];
+    supervisorGroupIds: ID[];
+    routing: QueueRoutingPolicy;
+    sla: ConversationQueueSlaConfig;
+    audience: ConversationQueueAudienceConfig;
+}
+/**
+ * Creates a Queue. commandId makes retries idempotent. The backend assigns
+ * queue id, version and audit fields.
+ */
+export interface CreateConversationQueueRequest {
+    commandId: ID;
+    spaceId: ID;
+    definition: ConversationQueueDefinitionInput;
+}
+/**
+ * Replaces the editable definition of an existing Queue.
+ *
+ * expectedVersion is the version loaded by the client; it is not incremented
+ * by the client. The backend rejects stale writes and returns the updated
+ * ConversationQueue with its new version and audit fields.
+ */
+export interface UpdateConversationQueueRequest {
+    commandId: ID;
+    spaceId: ID;
+    queueId: ID;
+    expectedVersion: number;
+    definition: ConversationQueueDefinitionInput;
+}

package/dist/src/Conversations/Sla.d.ts

@@ -0,0 +1,227 @@
+import type { ISchedule } from '../Common/Schedules/Schedules';
+import type { ConversationEventType, ConversationStatus, ID } from './Conversation';
+import type { OutboxEvent } from './Outbox';
+export declare const CONVERSATION_SLA_POLICIES_COLLECTION = "conversation_sla_policies";
+export declare const CONVERSATION_SLA_CYCLES_COLLECTION = "conversation_sla_cycles";
+export declare const CONVERSATION_SLA_EVENTS_COLLECTION = "conversation_sla_events";
+export type ConversationSlaMetric = 'first_response' | 'next_response' | 'assignment' | 'acceptance' | 'resolution';
+/**
+ * continuous counts natural elapsed time, including nights and holidays.
+ * schedule counts only ranges allowed by the referenced customer ISchedule.
+ */
+export type ConversationSlaTimeCalculation = {
+    mode: 'continuous';
+    scheduleId?: never;
+} | {
+    mode: 'schedule';
+    scheduleId: Exclude<ISchedule['id'], null>;
+};
+export interface ConversationSlaWarningThreshold {
+    id: ID;
+    percentage: number;
+}
+export interface ConversationSlaTarget {
+    metric: ConversationSlaMetric;
+    durationSeconds: number;
+    warningThresholds: ConversationSlaWarningThreshold[];
+}
+/**
+ * Threshold received by the SLA policy write API.
+ *
+ * Existing thresholds keep their id. New thresholds may omit it so the
+ * backend can assign the canonical identifier returned in
+ * ConversationSlaPolicy.
+ */
+export interface ConversationSlaWarningThresholdInput {
+    id?: ID;
+    percentage: number;
+}
+/**
+ * Target received by the SLA policy write API.
+ * durationSeconds is stored as seconds regardless of the unit used by the UI.
+ */
+export interface ConversationSlaTargetInput {
+    metric: ConversationSlaMetric;
+    durationSeconds: number;
+    warningThresholds: ConversationSlaWarningThresholdInput[];
+}
+export type ConversationSlaResumeBehavior = 'continue' | 'restart' | 'recalculate';
+export type ConversationSlaReopenBehavior = 'preserve' | 'restart' | 'recalculate' | 'do_not_start';
+export interface ConversationSlaClockBehavior {
+    /**
+     * Conversation statuses that pause every running SLA cycle.
+     *
+     * Entering one of these statuses pauses the clock. Leaving all of them
+     * resumes it according to onResume. An empty array means that conversation
+     * status changes never pause the SLA clock.
+     */
+    pauseOnStatuses: ConversationStatus[];
+    /**
+     * Behavior applied when the conversation leaves the last status included
+     * in pauseOnStatuses.
+     *
+     * continue: keeps the current cycle and its consumed/remaining time.
+     * restart: resets the current cycle from the resume timestamp.
+     * recalculate: keeps the applied policy snapshot and recalculates the
+     * schedule-derived warnings/deadline. It does not select another policy
+     * version.
+     */
+    onResume: ConversationSlaResumeBehavior;
+    /**
+     * Behavior applied when a resolved/finalized conversation is reopened.
+     * Reopening is independent from resuming a status-paused clock.
+     *
+     * preserve: preserves the previous cycle state.
+     * restart: starts a new cycle from the reopen timestamp.
+     * recalculate: recalculates the cycle using the applied policy snapshot.
+     * do_not_start: does not start an SLA cycle because of the reopen action.
+     */
+    onReopen: ConversationSlaReopenBehavior;
+}
+/**
+ * Immutable, versioned policy referenced by ConversationQueue.sla.
+ * Editing a published policy creates a new version.
+ */
+export interface ConversationSlaPolicy {
+    id: ID;
+    spaceId: ID;
+    name: string;
+    description?: string;
+    enabled: boolean;
+    version: number;
+    timeCalculation: ConversationSlaTimeCalculation;
+    targets: ConversationSlaTarget[];
+    clockBehavior: ConversationSlaClockBehavior;
+    createdAt: Date;
+    createdByUserId?: ID;
+    updatedAt: Date;
+    updatedByUserId?: ID;
+}
+/**
+ * Editable definition sent by clients.
+ *
+ * It intentionally excludes policy id/version and audit fields controlled by
+ * the backend. targets is full-replacement: omitted metrics are disabled in
+ * the newly published policy version.
+ */
+export interface ConversationSlaPolicyDefinitionInput {
+    name: string;
+    description?: string;
+    enabled: boolean;
+    timeCalculation: ConversationSlaTimeCalculation;
+    targets: ConversationSlaTargetInput[];
+    clockBehavior: ConversationSlaClockBehavior;
+}
+/**
+ * Creates the first immutable version of an SLA policy.
+ *
+ * commandId provides idempotency for retries. The authenticated backend
+ * context supplies createdByUserId and the audit timestamps.
+ */
+export interface CreateConversationSlaPolicyRequest {
+    commandId: ID;
+    spaceId: ID;
+    definition: ConversationSlaPolicyDefinitionInput;
+}
+/**
+ * Publishes a new immutable version of an existing SLA policy.
+ *
+ * expectedVersion implements optimistic concurrency. The backend rejects the
+ * request when another version was published after the client loaded it.
+ * version, updatedAt and updatedByUserId are always assigned by the backend.
+ */
+export interface PublishConversationSlaPolicyVersionRequest {
+    commandId: ID;
+    spaceId: ID;
+    policyId: ID;
+    expectedVersion: number;
+    definition: ConversationSlaPolicyDefinitionInput;
+}
+export type ConversationSlaClockAction = 'start' | 'evaluate' | 'pause' | 'resume' | 'complete' | 'recalculate' | 'cancel';
+export type ConversationSlaClockReason = 'conversation_created' | 'conversation_enqueued' | 'customer_message' | 'agent_response' | 'assignment_changed' | 'status_changed' | 'queue_transfer' | 'conversation_reopened' | 'deadline_due' | 'policy_override';
+/**
+ * Idempotent input for the conversation-sla-worker.
+ * policyId/policyVersion identify the immutable policy snapshot to apply.
+ */
+export interface SlaClockCommand {
+    commandId: ID;
+    sourceEventId: ID;
+    spaceId: ID;
+    conversationId: ID;
+    expectedConversationVersion: number;
+    action: ConversationSlaClockAction;
+    reason: ConversationSlaClockReason;
+    metric?: ConversationSlaMetric;
+    policyId: ID;
+    policyVersion: number;
+    queueId?: ID;
+    occurredAt: Date;
+    requestedAt: Date;
+}
+export type ConversationSlaCycleStatus = 'running' | 'paused' | 'met' | 'breached' | 'cancelled';
+export interface ConversationSlaPausePeriod {
+    startedAt: Date;
+    endedAt?: Date;
+    reason: ConversationSlaClockReason;
+    sourceEventId: ID;
+}
+/**
+ * Durable metric cycle. The target and time calculation are copied from the
+ * selected policy version so later policy edits cannot alter active history.
+ */
+export interface ConversationSlaCycle {
+    id: ID;
+    spaceId: ID;
+    conversationId: ID;
+    metric: ConversationSlaMetric;
+    sequence: number;
+    status: ConversationSlaCycleStatus;
+    policyId: ID;
+    policyVersion: number;
+    timeCalculation: ConversationSlaTimeCalculation;
+    target: ConversationSlaTarget;
+    startedAt: Date;
+    deadlineAt?: Date;
+    nextWarningAt?: Date;
+    pausedAt?: Date;
+    completedAt?: Date;
+    breachedAt?: Date;
+    cancelledAt?: Date;
+    elapsedSeconds: number;
+    pausedSeconds: number;
+    pausePeriods: ConversationSlaPausePeriod[];
+    startedByEventId: ID;
+    completedByEventId?: ID;
+    version: number;
+    updatedAt: Date;
+}
+export type ConversationSlaEventType = Extract<ConversationEventType, 'sla_started' | 'sla_paused' | 'sla_resumed' | 'sla_warning' | 'sla_breached' | 'sla_met' | 'sla_overridden'>;
+/**
+ * Immutable SLA event. Corrections are represented by a later event.
+ */
+export interface ConversationSlaEvent {
+    eventId: ID;
+    sourceEventId: ID;
+    type: ConversationSlaEventType;
+    schemaVersion: 1;
+    spaceId: ID;
+    conversationId: ID;
+    conversationVersion: number;
+    cycleId: ID;
+    metric: ConversationSlaMetric;
+    policyId: ID;
+    policyVersion: number;
+    status: ConversationSlaCycleStatus;
+    deadlineAt?: Date;
+    warningThresholdId?: ID;
+    reason: ConversationSlaClockReason;
+    correlationId: ID;
+    causationId: ID;
+    occurredAt: Date;
+    recordedAt: Date;
+}
+export type ConversationSlaOutboxEvent = OutboxEvent<ConversationSlaEvent> & {
+    aggregateType: 'conversation';
+    eventType: `conversation.${ConversationSlaEventType}`;
+    schemaVersion: 1;
+};

package/dist/src/Conversations/Sla.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONVERSATION_SLA_EVENTS_COLLECTION = exports.CONVERSATION_SLA_CYCLES_COLLECTION = exports.CONVERSATION_SLA_POLICIES_COLLECTION = void 0;
+exports.CONVERSATION_SLA_POLICIES_COLLECTION = 'conversation_sla_policies';
+exports.CONVERSATION_SLA_CYCLES_COLLECTION = 'conversation_sla_cycles';
+exports.CONVERSATION_SLA_EVENTS_COLLECTION = 'conversation_sla_events';