@trii/types 2.10.686 → 2.10.687

package/dist/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;
@@ -45,11 +55,14 @@ interface IChannel {
     type?: ChannelType | null;
     permissions?: Permission[] | null;
     /**
-     * @deprecated Legacy channel assignment configuration. Use QueueRoutingConfig.
+     * @deprecated Legacy channel assignment configuration. Use
+     * ChannelConversationRoutingConfig; Flow bindings live in FlowEntryPoint.
      */
     assignTo?: ConversationAssigned;
     /**
-     * @deprecated Legacy channel assignment configuration. Use QueueRoutingConfig.
+     * @deprecated Legacy channel assignment configuration. Use
+     * ChannelConversationRoutingConfig; QueueRoutingPolicy controls agent
+     * distribution only after a Queue has been selected.
      */
     assignMethod: AssignMethod;
     /**
@@ -60,6 +73,11 @@ 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;
+     */
+    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 +123,4 @@ declare enum channelStatus {
     SUSPENDED = 7,
     CONFIGURATION_PENDING = 9
 }
-export { IChannel, IChannelInfo, channelStatus, MessagingAvailability };
+export { IChannel, IChannelInfo, ChannelConversationRoutingConfig, channelStatus, MessagingAvailability };

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

@@ -0,0 +1,48 @@
+import { AutomationError, AutomationJsonObject, AutomationJsonSchema, AutomationSourceApplication } from '../Common';
+export declare enum AutomationCapabilityKind {
+    TRIGGER = "trigger",
+    ACTION = "action",
+    CONDITION = "condition"
+}
+/**
+ * Capacidad publicada por una aplicación de negocio para que Automation pueda
+ * descubrirla y representarla sin incorporar reglas de ese dominio.
+ */
+export interface AutomationCapability {
+    code: string;
+    sourceApplication: AutomationSourceApplication;
+    kind: AutomationCapabilityKind;
+    name: string;
+    description?: string | null;
+    inputSchema?: AutomationJsonSchema | null;
+    outputSchema?: AutomationJsonSchema | null;
+    requiredPermissions: string[];
+    enabled: boolean;
+    version: number;
+}
+export interface AutomationCapabilityQuery {
+    sourceApplications?: AutomationSourceApplication[];
+    kinds?: AutomationCapabilityKind[];
+    enabledOnly?: boolean;
+    version?: number;
+}
+export interface AutomationCapabilityReference {
+    code: string;
+    version: number;
+    sourceApplication: AutomationSourceApplication;
+}
+export interface AutomationCapabilityInvocation {
+    invocationId: string;
+    executionId: string;
+    nodeId: string;
+    capability: AutomationCapabilityReference;
+    input: AutomationJsonObject;
+    context: AutomationJsonObject;
+}
+export interface AutomationCapabilityResult {
+    invocationId: string;
+    success: boolean;
+    output?: AutomationJsonObject | null;
+    error?: AutomationError | null;
+    completedAt: string;
+}

package/dist/src/Automations/Capabilities/Capability.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutomationCapabilityKind = void 0;
+var AutomationCapabilityKind;
+(function (AutomationCapabilityKind) {
+    AutomationCapabilityKind["TRIGGER"] = "trigger";
+    AutomationCapabilityKind["ACTION"] = "action";
+    AutomationCapabilityKind["CONDITION"] = "condition";
+})(AutomationCapabilityKind || (exports.AutomationCapabilityKind = AutomationCapabilityKind = {}));

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

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

package/dist/src/Automations/Capabilities/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("./Capability"), exports);

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

@@ -0,0 +1,47 @@
+/**
+ * Aplicación propietaria del evento o capacidad consumida por Automation.
+ *
+ * Los valores forman parte del contrato HTTP/event-driven y no deben
+ * traducirse ni depender del nombre visible de la aplicación.
+ */
+export declare enum AutomationSourceApplication {
+    CONVERSATIONS = "conversations",
+    TICKETS = "tickets",
+    MARKETING = "marketing",
+    SALES = "sales",
+    CALLS = "calls",
+    GENERIC = "generic"
+}
+export type AutomationJsonValue = string | number | boolean | null | AutomationJsonObject | AutomationJsonValue[];
+/** Objeto JSON transportable entre aplicaciones y Automation. */
+export interface AutomationJsonObject {
+    [key: string]: AutomationJsonValue;
+}
+/**
+ * Schema JSON deliberadamente abierto. Cada aplicación es propietaria de la
+ * validación del schema que publica en su catálogo de capacidades.
+ */
+export interface AutomationJsonSchema extends AutomationJsonObject {
+    type?: string;
+    title?: string;
+    description?: string;
+    required?: string[];
+    properties?: {
+        [key: string]: AutomationJsonSchema;
+    };
+}
+export interface AutomationPageRequest {
+    skip: number;
+    limit: number;
+}
+export interface AutomationPagedResult<T> {
+    items: T[];
+    total: number;
+    skip: number;
+    limit: number;
+}
+export interface AutomationError {
+    code: string;
+    message: string;
+    details?: AutomationJsonObject | null;
+}

package/dist/src/Automations/Common.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutomationSourceApplication = void 0;
+/**
+ * Aplicación propietaria del evento o capacidad consumida por Automation.
+ *
+ * Los valores forman parte del contrato HTTP/event-driven y no deben
+ * traducirse ni depender del nombre visible de la aplicación.
+ */
+var AutomationSourceApplication;
+(function (AutomationSourceApplication) {
+    AutomationSourceApplication["CONVERSATIONS"] = "conversations";
+    AutomationSourceApplication["TICKETS"] = "tickets";
+    AutomationSourceApplication["MARKETING"] = "marketing";
+    AutomationSourceApplication["SALES"] = "sales";
+    AutomationSourceApplication["CALLS"] = "calls";
+    AutomationSourceApplication["GENERIC"] = "generic";
+})(AutomationSourceApplication || (exports.AutomationSourceApplication = AutomationSourceApplication = {}));

package/dist/src/Automations/Events/Event.d.ts

@@ -0,0 +1,41 @@
+import { AutomationJsonObject, AutomationJsonSchema, AutomationSourceApplication } from '../Common';
+export interface AutomationEventDefinition {
+    eventType: string;
+    version: number;
+    sourceApplication: AutomationSourceApplication;
+    name: string;
+    description?: string | null;
+    payloadSchema: AutomationJsonSchema;
+    filterSchema?: AutomationJsonSchema | null;
+    requiredPermissions: string[];
+    enabled: boolean;
+}
+export interface AutomationEventEnvelope {
+    id: string;
+    spaceId: string;
+    sourceApplication: AutomationSourceApplication;
+    eventType: string;
+    eventVersion: number;
+    occurredAt: string;
+    receivedAt: string;
+    subjectId?: string | null;
+    correlationId?: string | null;
+    causationId?: string | null;
+    idempotencyKey?: string | null;
+    payload: AutomationJsonObject;
+    metadata?: AutomationJsonObject | null;
+}
+export interface ResolveFlowEntryPointsRequest {
+    event: AutomationEventEnvelope;
+}
+export interface ResolvedFlowEntryPoint {
+    flowId: string;
+    flowVersionId: string;
+    entryPointId: string;
+    priority: number;
+    selected: boolean;
+    exclusionReason?: string | null;
+}
+export interface ResolveFlowEntryPointsResult {
+    matches: ResolvedFlowEntryPoint[];
+}

package/dist/src/Automations/Events/Event.js

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

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

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

package/dist/src/Automations/Events/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("./Event"), exports);

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

@@ -0,0 +1,114 @@
+import { AutomationError, AutomationJsonObject, AutomationPageRequest, AutomationSourceApplication } from '../Common';
+export declare enum AutomationExecutionStatus {
+    QUEUED = "queued",
+    RUNNING = "running",
+    WAITING = "waiting",
+    SUCCEEDED = "succeeded",
+    FAILED = "failed",
+    CANCELLED = "cancelled",
+    TIMED_OUT = "timedOut"
+}
+export declare enum AutomationExecutionStepStatus {
+    PENDING = "pending",
+    RUNNING = "running",
+    WAITING = "waiting",
+    SUCCEEDED = "succeeded",
+    FAILED = "failed",
+    SKIPPED = "skipped",
+    CANCELLED = "cancelled"
+}
+/**
+ * Referencia genérica al evento que inició una ejecución.
+ */
+export interface AutomationExecutionTrigger {
+    entryPointId: string;
+    sourceApplication: AutomationSourceApplication;
+    eventType: string;
+    referenceId?: string | null;
+    occurredAt?: string | null;
+    payload?: AutomationJsonObject | null;
+}
+/** Identidad completa que debe persistir una ejecución transversal. */
+export interface AutomationFlowExecutionReference {
+    flowId: string;
+    flowVersionId: string;
+    entryPointId: string;
+    executionId: string;
+}
+export interface AutomationExecution {
+    id: string;
+    spaceId: string;
+    flowId: string;
+    flowVersionId: string;
+    flowVersion: number;
+    entryPointId: string;
+    status: AutomationExecutionStatus;
+    trigger: AutomationExecutionTrigger;
+    input: AutomationJsonObject;
+    context: AutomationJsonObject;
+    output?: AutomationJsonObject | null;
+    error?: AutomationError | null;
+    createdAt: string;
+    startedAt?: string | null;
+    completedAt?: string | null;
+    cancelledAt?: string | null;
+    cancelledBy?: string | null;
+    correlationId?: string | null;
+    parentExecutionId?: string | null;
+    usage: AutomationExecutionUsage;
+}
+export interface AutomationExecutionStep {
+    id: string;
+    executionId: string;
+    nodeId: string;
+    nodeDefinitionCode: string;
+    nodeDefinitionVersion: number;
+    sequence: number;
+    attempt: number;
+    status: AutomationExecutionStepStatus;
+    input?: AutomationJsonObject | null;
+    output?: AutomationJsonObject | null;
+    error?: AutomationError | null;
+    startedAt?: string | null;
+    completedAt?: string | null;
+    usage: AutomationExecutionUsage;
+}
+export interface AutomationExecutionUsage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    totalCost: number;
+    currency: string;
+    durationMs: number;
+}
+export interface AutomationExecutionQuery extends AutomationPageRequest {
+    flowId?: string | null;
+    flowVersionId?: string | null;
+    entryPointId?: string | null;
+    statuses?: AutomationExecutionStatus[] | null;
+    createdFrom?: string | null;
+    createdTo?: string | null;
+    correlationId?: string | null;
+}
+export interface StartAutomationExecutionRequest {
+    flowId: string;
+    flowVersionId: string;
+    entryPointId: string;
+    trigger: AutomationExecutionTrigger;
+    input: AutomationJsonObject;
+    context: AutomationJsonObject;
+    idempotencyKey?: string | null;
+    correlationId?: string | null;
+    parentExecutionId?: string | null;
+}
+export interface CancelAutomationExecutionRequest {
+    reason?: string | null;
+}
+export interface RetryAutomationExecutionRequest {
+    fromStepId?: string | null;
+    inputOverrides?: AutomationJsonObject | null;
+}
+export interface AutomationExecutionDetails {
+    execution: AutomationExecution;
+    steps: AutomationExecutionStep[];
+}

package/dist/src/Automations/Executions/Execution.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutomationExecutionStepStatus = exports.AutomationExecutionStatus = void 0;
+var AutomationExecutionStatus;
+(function (AutomationExecutionStatus) {
+    AutomationExecutionStatus["QUEUED"] = "queued";
+    AutomationExecutionStatus["RUNNING"] = "running";
+    AutomationExecutionStatus["WAITING"] = "waiting";
+    AutomationExecutionStatus["SUCCEEDED"] = "succeeded";
+    AutomationExecutionStatus["FAILED"] = "failed";
+    AutomationExecutionStatus["CANCELLED"] = "cancelled";
+    AutomationExecutionStatus["TIMED_OUT"] = "timedOut";
+})(AutomationExecutionStatus || (exports.AutomationExecutionStatus = AutomationExecutionStatus = {}));
+var AutomationExecutionStepStatus;
+(function (AutomationExecutionStepStatus) {
+    AutomationExecutionStepStatus["PENDING"] = "pending";
+    AutomationExecutionStepStatus["RUNNING"] = "running";
+    AutomationExecutionStepStatus["WAITING"] = "waiting";
+    AutomationExecutionStepStatus["SUCCEEDED"] = "succeeded";
+    AutomationExecutionStepStatus["FAILED"] = "failed";
+    AutomationExecutionStepStatus["SKIPPED"] = "skipped";
+    AutomationExecutionStepStatus["CANCELLED"] = "cancelled";
+})(AutomationExecutionStepStatus || (exports.AutomationExecutionStepStatus = AutomationExecutionStepStatus = {}));

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

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

package/dist/src/Automations/Executions/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("./Execution"), exports);

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

@@ -0,0 +1,86 @@
+import { AutomationJsonObject, AutomationJsonValue } from '../Common';
+export declare enum AutomationFlowVariableType {
+    STRING = "string",
+    NUMBER = "number",
+    BOOLEAN = "boolean",
+    DATE = "date",
+    JSON = "json",
+    ARRAY = "array"
+}
+export declare enum AutomationNodeKind {
+    TRIGGER = "trigger",
+    ACTION = "action",
+    CONDITION = "condition",
+    AGENT = "agent",
+    TOOL = "tool",
+    MESSAGE = "message",
+    CONTROL = "control"
+}
+export declare enum AutomationNodeHandleType {
+    SOURCE = "source",
+    TARGET = "target"
+}
+export declare enum AutomationNodeHandlePosition {
+    LEFT = "left",
+    RIGHT = "right",
+    TOP = "top",
+    BOTTOM = "bottom"
+}
+export interface AutomationFlowVariable {
+    name: string;
+    description?: string | null;
+    type: AutomationFlowVariableType;
+    isInput: boolean;
+    isOutput: boolean;
+    schema?: AutomationJsonObject | null;
+    defaultValue?: AutomationJsonValue;
+}
+export interface AutomationFlowViewport {
+    x: number;
+    y: number;
+    zoom: number;
+}
+export interface AutomationNodePosition {
+    x: number;
+    y: number;
+}
+export interface AutomationFlowNode {
+    id: string;
+    /** Clave del renderer visual; no representa una regla de negocio. */
+    type: string;
+    data: AutomationNodeInstance;
+    position: AutomationNodePosition;
+}
+export interface AutomationNodeInstance {
+    definitionCode: string;
+    definitionVersion: number;
+    kind: AutomationNodeKind;
+    name: string;
+    values: AutomationJsonObject;
+    metadata?: AutomationJsonObject | null;
+    disabled: boolean;
+}
+export interface AutomationFlowEdge {
+    id: string;
+    type: string;
+    source: string;
+    sourceHandle?: string | null;
+    target: string;
+    targetHandle?: string | null;
+    data: AutomationFlowEdgeData;
+}
+export interface AutomationFlowEdgeData {
+    label?: string | null;
+    metadata?: AutomationJsonObject | null;
+}
+export interface AutomationNodeHandle {
+    id: string;
+    name: string;
+    type: AutomationNodeHandleType;
+    position: AutomationNodeHandlePosition;
+    multiple: boolean;
+    showName: boolean;
+    tags: string[];
+    showWhen?: AutomationJsonObject | null;
+    hideWhen?: AutomationJsonObject | null;
+}

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutomationNodeHandlePosition = exports.AutomationNodeHandleType = exports.AutomationNodeKind = exports.AutomationFlowVariableType = void 0;
+var AutomationFlowVariableType;
+(function (AutomationFlowVariableType) {
+    AutomationFlowVariableType["STRING"] = "string";
+    AutomationFlowVariableType["NUMBER"] = "number";
+    AutomationFlowVariableType["BOOLEAN"] = "boolean";
+    AutomationFlowVariableType["DATE"] = "date";
+    AutomationFlowVariableType["JSON"] = "json";
+    AutomationFlowVariableType["ARRAY"] = "array";
+})(AutomationFlowVariableType || (exports.AutomationFlowVariableType = AutomationFlowVariableType = {}));
+var AutomationNodeKind;
+(function (AutomationNodeKind) {
+    AutomationNodeKind["TRIGGER"] = "trigger";
+    AutomationNodeKind["ACTION"] = "action";
+    AutomationNodeKind["CONDITION"] = "condition";
+    AutomationNodeKind["AGENT"] = "agent";
+    AutomationNodeKind["TOOL"] = "tool";
+    AutomationNodeKind["MESSAGE"] = "message";
+    AutomationNodeKind["CONTROL"] = "control";
+})(AutomationNodeKind || (exports.AutomationNodeKind = AutomationNodeKind = {}));
+var AutomationNodeHandleType;
+(function (AutomationNodeHandleType) {
+    AutomationNodeHandleType["SOURCE"] = "source";
+    AutomationNodeHandleType["TARGET"] = "target";
+})(AutomationNodeHandleType || (exports.AutomationNodeHandleType = AutomationNodeHandleType = {}));
+var AutomationNodeHandlePosition;
+(function (AutomationNodeHandlePosition) {
+    AutomationNodeHandlePosition["LEFT"] = "left";
+    AutomationNodeHandlePosition["RIGHT"] = "right";
+    AutomationNodeHandlePosition["TOP"] = "top";
+    AutomationNodeHandlePosition["BOTTOM"] = "bottom";
+})(AutomationNodeHandlePosition || (exports.AutomationNodeHandlePosition = AutomationNodeHandlePosition = {}));

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

@@ -0,0 +1,102 @@
+import { AutomationCapabilityReference } from '../Capabilities';
+import { AutomationJsonObject, AutomationSourceApplication } from '../Common';
+import { AutomationFlowEdge, AutomationFlowNode, AutomationFlowVariable, AutomationFlowViewport } from './Canvas';
+export declare enum AutomationFlowKind {
+    CONVERSATIONAL = "conversational",
+    VOICE = "voice",
+    CAMPAIGN = "campaign",
+    MARKETING = "marketing",
+    TICKET = "ticket",
+    SALES = "sales",
+    GENERIC = "generic"
+}
+export declare enum AutomationFlowStatus {
+    DRAFT = "draft",
+    ACTIVE = "active",
+    DISABLED = "disabled",
+    ARCHIVED = "archived"
+}
+export declare enum AutomationFlowVersionStatus {
+    DRAFT = "draft",
+    TESTING = "testing",
+    PUBLISHED = "published",
+    DEPRECATED = "deprecated"
+}
+export declare enum FlowEntryPointExecutionMode {
+    /** Un evento inicia como máximo una ejecución de esta versión del Flow. */
+    SINGLE = "single",
+    /** El solapamiento fue habilitado explícitamente. */
+    MULTIPLE = "multiple"
+}
+/**
+ * Identidad estable del Flow. El contenido ejecutable vive en FlowVersion.
+ */
+export interface AutomationFlowDefinition {
+    id: string;
+    spaceId: string;
+    name: string;
+    description?: string | null;
+    kind: AutomationFlowKind;
+    status: AutomationFlowStatus;
+    ownerId?: string | null;
+    tags: string[];
+    draftVersionId?: string | null;
+    activeVersionId?: string | null;
+    createdAt: string;
+    createdBy: string;
+    updatedAt?: string | null;
+    updatedBy?: string | null;
+    deletedAt?: string | null;
+}
+/**
+ * Snapshot del canvas.
+ *
+ * El canvas pertenece a Automations y no depende de contratos de otras
+ * aplicaciones.
+ */
+export interface AutomationFlowCanvas {
+    variables: AutomationFlowVariable[];
+    nodes: AutomationFlowNode[];
+    edges: AutomationFlowEdge[];
+    viewport: AutomationFlowViewport;
+}
+/**
+ * Snapshot versionado e inmutable una vez publicado.
+ */
+export interface AutomationFlowVersion {
+    id: string;
+    flowId: string;
+    version: number;
+    schemaVersion: number;
+    revision: number;
+    status: AutomationFlowVersionStatus;
+    canvas: AutomationFlowCanvas;
+    entryPoints: FlowEntryPoint[];
+    createdAt: string;
+    createdBy: string;
+    updatedAt?: string | null;
+    updatedBy?: string | null;
+    publishedAt?: string | null;
+    publishedBy?: string | null;
+}
+/**
+ * Evento de entrada que puede iniciar una versión concreta de un Flow.
+ *
+ * La configuración autoritativa vive en esta entidad. El nodo trigger es su
+ * representación en el canvas y se vincula mediante triggerNodeId.
+ */
+export interface FlowEntryPoint {
+    id: string;
+    flowId: string;
+    flowVersionId: string;
+    name: string;
+    sourceApplication: AutomationSourceApplication;
+    eventType: string;
+    triggerCapability?: AutomationCapabilityReference | null;
+    filters: AutomationJsonObject;
+    enabled: boolean;
+    triggerNodeId: string;
+    priority: number;
+    executionMode: FlowEntryPointExecutionMode;
+    metadata?: AutomationJsonObject | null;
+}