@trii/types 2.10.731 → 2.10.732

package/dist/src/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/src/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/src/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/src/Automations/Executions/index.d.ts

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

package/dist/src/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/src/Automations/Flows/Canvas.d.ts

@@ -1,4 +1,5 @@
-import { AutomationJsonObject, AutomationJsonValue } from '../Common';
+import { AutomationJsonObject, AutomationJsonSchema, AutomationJsonValue } from '../Common';
+import type { AutomationNodeVisibilityRule } from '../Nodes';
 export declare enum AutomationFlowVariableType {
     STRING = "string",
     NUMBER = "number",
@@ -32,7 +33,8 @@ export interface AutomationFlowVariable {
     type: AutomationFlowVariableType;
     isInput: boolean;
     isOutput: boolean;
-    schema?: AutomationJsonObject | null;
+    /** JSON Schema que restringe el valor permitido para la variable. */
+    schema?: AutomationJsonSchema | null;
     defaultValue?: AutomationJsonValue;
 }
 export interface AutomationFlowViewport {
@@ -44,6 +46,21 @@ export interface AutomationNodePosition {
     x: number;
     y: number;
 }
+export declare enum AutomationCanvasAnnotationType {
+    NOTE = "note"
+}
+/** Elemento puramente visual del canvas; no participa de la ejecución. */
+export interface AutomationCanvasAnnotation {
+    id: string;
+    type: AutomationCanvasAnnotationType;
+    title?: string | null;
+    text: string;
+    position: AutomationNodePosition;
+    width: number;
+    height: number;
+    color: string;
+    metadata?: AutomationJsonObject | null;
+}
 export interface AutomationFlowNode {
     id: string;
     /** Clave del renderer visual; no representa una regla de negocio. */
@@ -81,6 +98,6 @@ export interface AutomationNodeHandle {
     multiple: boolean;
     showName: boolean;
     tags: string[];
-    showWhen?: AutomationJsonObject | null;
-    hideWhen?: AutomationJsonObject | null;
+    showWhen?: AutomationNodeVisibilityRule | null;
+    hideWhen?: AutomationNodeVisibilityRule | null;
 }

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AutomationNodeHandlePosition = exports.AutomationNodeHandleType = exports.AutomationNodeKind = exports.AutomationFlowVariableType = void 0;
+exports.AutomationCanvasAnnotationType = exports.AutomationNodeHandlePosition = exports.AutomationNodeHandleType = exports.AutomationNodeKind = exports.AutomationFlowVariableType = void 0;
 var AutomationFlowVariableType;
 (function (AutomationFlowVariableType) {
     AutomationFlowVariableType["STRING"] = "string";
@@ -32,3 +32,7 @@ var AutomationNodeHandlePosition;
     AutomationNodeHandlePosition["TOP"] = "top";
     AutomationNodeHandlePosition["BOTTOM"] = "bottom";
 })(AutomationNodeHandlePosition || (exports.AutomationNodeHandlePosition = AutomationNodeHandlePosition = {}));
+var AutomationCanvasAnnotationType;
+(function (AutomationCanvasAnnotationType) {
+    AutomationCanvasAnnotationType["NOTE"] = "note";
+})(AutomationCanvasAnnotationType || (exports.AutomationCanvasAnnotationType = AutomationCanvasAnnotationType = {}));

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

@@ -1,6 +1,6 @@
 import { AutomationCapabilityReference } from '../Capabilities';
-import { AutomationJsonObject, AutomationSourceApplication } from '../Common';
-import { AutomationFlowEdge, AutomationFlowNode, AutomationFlowVariable, AutomationFlowViewport } from './Canvas';
+import { AutomationJsonObject, AutomationJsonValue, AutomationSourceApplication } from '../Common';
+import { AutomationFlowEdge, AutomationCanvasAnnotation, AutomationFlowNode, AutomationFlowVariable, AutomationFlowViewport } from './Canvas';
 export declare enum AutomationFlowKind {
     CONVERSATIONAL = "conversational",
     VOICE = "voice",
@@ -28,6 +28,48 @@ export declare enum FlowEntryPointExecutionMode {
     /** El solapamiento fue habilitado explícitamente. */
     MULTIPLE = "multiple"
 }
+export declare enum AutomationFilterLogicalOperator {
+    /** Todas las condiciones y grupos hijos deben cumplirse. */
+    ALL = "all",
+    /** Al menos una condición o grupo hijo debe cumplirse. */
+    ANY = "any"
+}
+export declare enum AutomationFilterOperator {
+    EQUALS = "equals",
+    NOT_EQUALS = "notEquals",
+    CONTAINS = "contains",
+    NOT_CONTAINS = "notContains",
+    STARTS_WITH = "startsWith",
+    ENDS_WITH = "endsWith",
+    GREATER_THAN = "greaterThan",
+    GREATER_THAN_OR_EQUAL = "greaterThanOrEqual",
+    LESS_THAN = "lessThan",
+    LESS_THAN_OR_EQUAL = "lessThanOrEqual",
+    IN = "in",
+    NOT_IN = "notIn",
+    EXISTS = "exists",
+    NOT_EXISTS = "notExists"
+}
+/** Comparación tipada aplicada a un campo de un evento. */
+export interface AutomationFilterCondition {
+    /** JSON Pointer RFC 6901 absoluto dentro del envelope. */
+    path: string;
+    /** Operación utilizada para comparar el campo. */
+    operator: AutomationFilterOperator;
+    /** Valor esperado; no aplica a exists/notExists. */
+    value?: AutomationJsonValue;
+    /** Sensibilidad de comparaciones de strings; por defecto es true. */
+    caseSensitive?: boolean | null;
+}
+/** Grupo recursivo de filtros combinados mediante all o any. */
+export interface AutomationFilterGroup {
+    /** Forma en que se combinan condiciones y grupos hijos. */
+    logicalOperator: AutomationFilterLogicalOperator;
+    /** Comparaciones directas pertenecientes al grupo. */
+    conditions: AutomationFilterCondition[];
+    /** Grupos anidados. */
+    groups: AutomationFilterGroup[];
+}
 /**
  * Identidad estable del Flow. El contenido ejecutable vive en FlowVersion.
  */
@@ -58,6 +100,8 @@ export interface AutomationFlowCanvas {
     variables: AutomationFlowVariable[];
     nodes: AutomationFlowNode[];
     edges: AutomationFlowEdge[];
+    /** Anotaciones visuales que no forman parte del grafo ejecutable. */
+    annotations?: AutomationCanvasAnnotation[];
     viewport: AutomationFlowViewport;
 }
 /**
@@ -93,7 +137,8 @@ export interface FlowEntryPoint {
     sourceApplication: AutomationSourceApplication;
     eventType: string;
     triggerCapability?: AutomationCapabilityReference | null;
-    filters: AutomationJsonObject;
+    /** Grupo vacío acepta cualquier evento del tipo configurado. */
+    filters: AutomationFilterGroup;
     enabled: boolean;
     triggerNodeId: string;
     priority: number;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FlowEntryPointExecutionMode = exports.AutomationFlowVersionStatus = exports.AutomationFlowStatus = exports.AutomationFlowKind = void 0;
+exports.AutomationFilterOperator = exports.AutomationFilterLogicalOperator = exports.FlowEntryPointExecutionMode = exports.AutomationFlowVersionStatus = exports.AutomationFlowStatus = exports.AutomationFlowKind = void 0;
 var AutomationFlowKind;
 (function (AutomationFlowKind) {
     AutomationFlowKind["CONVERSATIONAL"] = "conversational";
@@ -32,3 +32,27 @@ var FlowEntryPointExecutionMode;
     /** El solapamiento fue habilitado explícitamente. */
     FlowEntryPointExecutionMode["MULTIPLE"] = "multiple";
 })(FlowEntryPointExecutionMode || (exports.FlowEntryPointExecutionMode = FlowEntryPointExecutionMode = {}));
+var AutomationFilterLogicalOperator;
+(function (AutomationFilterLogicalOperator) {
+    /** Todas las condiciones y grupos hijos deben cumplirse. */
+    AutomationFilterLogicalOperator["ALL"] = "all";
+    /** Al menos una condición o grupo hijo debe cumplirse. */
+    AutomationFilterLogicalOperator["ANY"] = "any";
+})(AutomationFilterLogicalOperator || (exports.AutomationFilterLogicalOperator = AutomationFilterLogicalOperator = {}));
+var AutomationFilterOperator;
+(function (AutomationFilterOperator) {
+    AutomationFilterOperator["EQUALS"] = "equals";
+    AutomationFilterOperator["NOT_EQUALS"] = "notEquals";
+    AutomationFilterOperator["CONTAINS"] = "contains";
+    AutomationFilterOperator["NOT_CONTAINS"] = "notContains";
+    AutomationFilterOperator["STARTS_WITH"] = "startsWith";
+    AutomationFilterOperator["ENDS_WITH"] = "endsWith";
+    AutomationFilterOperator["GREATER_THAN"] = "greaterThan";
+    AutomationFilterOperator["GREATER_THAN_OR_EQUAL"] = "greaterThanOrEqual";
+    AutomationFilterOperator["LESS_THAN"] = "lessThan";
+    AutomationFilterOperator["LESS_THAN_OR_EQUAL"] = "lessThanOrEqual";
+    AutomationFilterOperator["IN"] = "in";
+    AutomationFilterOperator["NOT_IN"] = "notIn";
+    AutomationFilterOperator["EXISTS"] = "exists";
+    AutomationFilterOperator["NOT_EXISTS"] = "notExists";
+})(AutomationFilterOperator || (exports.AutomationFilterOperator = AutomationFilterOperator = {}));

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

@@ -15,6 +15,37 @@ export declare enum AutomationNodePropertyEditor {
     ASYNC_OPTIONS = "asyncOptions",
     ASYNC_MULTI_OPTIONS = "asyncMultiOptions"
 }
+export declare enum AutomationNodeVisibilityLogicalOperator {
+    ALL = "all",
+    ANY = "any"
+}
+export declare enum AutomationNodeConditionOperator {
+    EQUALS = "equals"
+}
+export interface AutomationNodeCondition {
+    propertyId: string;
+    operator: AutomationNodeConditionOperator;
+    value?: AutomationJsonValue;
+}
+export interface AutomationNodeVisibilityRule {
+    logicalOperator: AutomationNodeVisibilityLogicalOperator;
+    conditions: AutomationNodeCondition[];
+}
+export interface AutomationNodePropertyUi {
+    tabId: string;
+    tabLabel: string;
+    order: number;
+    labelKey?: string | null;
+    placeholder?: string | null;
+    rows?: number | null;
+    numberMin?: number | null;
+    numberMax?: number | null;
+    step?: number | null;
+    acceptVariable?: boolean | null;
+    acceptEmojis?: boolean | null;
+    allowMaximizeInput?: boolean | null;
+    itemProperties: AutomationNodePropertyDefinition[];
+}
 export interface AutomationNodeDefinition {
     code: string;
     version: number;
@@ -44,9 +75,9 @@ export interface AutomationNodePropertyDefinition {
     schema?: AutomationJsonSchema | null;
     options: AutomationNodeOption[];
     optionsCapabilityCode?: string | null;
-    ui?: AutomationJsonObject | null;
-    showWhen?: AutomationJsonObject | null;
-    hideWhen?: AutomationJsonObject | null;
+    ui: AutomationNodePropertyUi;
+    showWhen?: AutomationNodeVisibilityRule | null;
+    hideWhen?: AutomationNodeVisibilityRule | null;
 }
 export interface AutomationNodeOption {
     id: string;
@@ -68,8 +99,15 @@ export interface AutomationNodeOptionsRequest {
     propertyId: string;
     currentValues: AutomationJsonObject;
     context: AutomationJsonObject;
+    /** Optional provider-defined, case-insensitive text search. */
+    search?: string | null;
+    /** Opaque cursor returned by the previous response. */
+    continuationToken?: string | null;
+    /** Preferred page size. The API clamps it to the supported range (1-200). */
+    limit?: number;
 }
 export interface AutomationNodeOptionsResult {
     options: AutomationNodeOption[];
+    /** Opaque cursor for the next page; null or omitted means the last page. */
     continuationToken?: string | null;
 }

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AutomationNodePropertyEditor = void 0;
+exports.AutomationNodeConditionOperator = exports.AutomationNodeVisibilityLogicalOperator = exports.AutomationNodePropertyEditor = void 0;
 var AutomationNodePropertyEditor;
 (function (AutomationNodePropertyEditor) {
     AutomationNodePropertyEditor["STRING"] = "string";
@@ -16,3 +16,12 @@ var AutomationNodePropertyEditor;
     AutomationNodePropertyEditor["ASYNC_OPTIONS"] = "asyncOptions";
     AutomationNodePropertyEditor["ASYNC_MULTI_OPTIONS"] = "asyncMultiOptions";
 })(AutomationNodePropertyEditor || (exports.AutomationNodePropertyEditor = AutomationNodePropertyEditor = {}));
+var AutomationNodeVisibilityLogicalOperator;
+(function (AutomationNodeVisibilityLogicalOperator) {
+    AutomationNodeVisibilityLogicalOperator["ALL"] = "all";
+    AutomationNodeVisibilityLogicalOperator["ANY"] = "any";
+})(AutomationNodeVisibilityLogicalOperator || (exports.AutomationNodeVisibilityLogicalOperator = AutomationNodeVisibilityLogicalOperator = {}));
+var AutomationNodeConditionOperator;
+(function (AutomationNodeConditionOperator) {
+    AutomationNodeConditionOperator["EQUALS"] = "equals";
+})(AutomationNodeConditionOperator || (exports.AutomationNodeConditionOperator = AutomationNodeConditionOperator = {}));

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

@@ -55,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;
     /**
@@ -72,8 +75,7 @@ interface IChannel {
     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.
+     * Flow. Store only the Queue id;
      */
     conversationRouting?: ChannelConversationRoutingConfig | null;
     /**

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

@@ -357,4 +357,94 @@ export interface UserInboxCounterDocument {
     projectionVersion: number;
     updatedAt: Date;
 }
+export interface CursorPage<T> {
+    items: T[];
+    nextCursor?: string;
+    hasMore: boolean;
+    generatedAt: Date;
+}
+export interface ConversationCapabilitiesDto {
+    canView: boolean;
+    canReply: boolean;
+    canFollow: boolean;
+    canAbandon: boolean;
+    canClaim: boolean;
+    canAccept: boolean;
+    canRelease: boolean;
+    canTransfer: boolean;
+    canResolve: boolean;
+    canReopen: boolean;
+    canChangePriority: boolean;
+    canManageLabels: boolean;
+    canManageSla: boolean;
+    canViewAssignmentHistory: boolean;
+    canViewRoutingDecisions: boolean;
+}
+export interface InboxViewSummaryDto {
+    id: InboxViewId | 'supervised_target';
+    label: string;
+    scope: 'personal' | 'supervision' | 'history';
+    order: number;
+    total: number;
+    requiresAction: number;
+    unread: number;
+    enabled: boolean;
+    targetRequired: boolean;
+    capabilities: string[];
+}
+export interface InboxViewsResponse {
+    views: InboxViewSummaryDto[];
+    countersGeneratedAt: Date;
+    projectionLagMs?: number;
+}
+export interface InboxFilterDto {
+    text?: string;
+    queueIds?: ID[];
+    ownerUserIds?: ID[];
+    channelTypes?: string[];
+    statuses?: ConversationStatus[];
+    priorities?: Array<'low' | 'normal' | 'high' | 'urgent'>;
+    slaStatuses?: Array<'none' | 'running' | 'warning' | 'breached' | 'met'>;
+    labelIds?: ID[];
+    unread?: boolean;
+    requiresAction?: boolean;
+    pinned?: boolean;
+    lastActivity?: {
+        from?: Date;
+        to?: Date;
+    };
+    sort: {
+        type: 'activity';
+    } | {
+        type: 'priority';
+    };
+}
+export type InboxConversationItemDto = Pick<UserInboxItemDocument, 'conversationId' | 'views' | 'snapshot' | 'pinned' | 'priorityScore' | 'sortAt'> & {
+    capabilities: Pick<ConversationCapabilitiesDto, 'canView' | 'canReply' | 'canClaim' | 'canTransfer'>;
+};
+export interface InboxConversationPage extends CursorPage<InboxConversationItemDto> {
+    appliedFilter: InboxFilterDto;
+    facets?: unknown;
+}
+/**
+ * DTO API - GET /inbox/views/{viewId}/filter-options.
+ */
+export interface InboxFacetOptionDto {
+    id: string;
+    label: string;
+    count: number;
+}
+export interface InboxFacetsDto {
+    queues: InboxFacetOptionDto[];
+    owners: InboxFacetOptionDto[];
+    channels: InboxFacetOptionDto[];
+    statuses: InboxFacetOptionDto[];
+    priorities: InboxFacetOptionDto[];
+    slaStatuses: InboxFacetOptionDto[];
+    labels: InboxFacetOptionDto[];
+}
+export interface InboxFilterOptionsResponse {
+    facets: InboxFacetsDto;
+    generatedAt: Date;
+}
 export {};