@trii/types 2.10.765 → 2.10.766

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

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

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

@@ -0,0 +1,18 @@
+"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);
+__exportStar(require("./Testing"), exports);

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

@@ -0,0 +1,103 @@
+import { AutomationJsonObject, AutomationJsonSchema, AutomationJsonValue } from '../Common';
+import type { AutomationNodeVisibilityRule } from '../Nodes';
+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;
+    /** JSON Schema que restringe el valor permitido para la variable. */
+    schema?: AutomationJsonSchema | null;
+    defaultValue?: AutomationJsonValue;
+}
+export interface AutomationFlowViewport {
+    x: number;
+    y: number;
+    zoom: number;
+}
+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. */
+    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?: AutomationNodeVisibilityRule | null;
+    hideWhen?: AutomationNodeVisibilityRule | null;
+}

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutomationCanvasAnnotationType = 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 = {}));
+var AutomationCanvasAnnotationType;
+(function (AutomationCanvasAnnotationType) {
+    AutomationCanvasAnnotationType["NOTE"] = "note";
+})(AutomationCanvasAnnotationType || (exports.AutomationCanvasAnnotationType = AutomationCanvasAnnotationType = {}));

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

@@ -0,0 +1,147 @@
+import { AutomationCapabilityReference } from '../Capabilities';
+import { AutomationJsonObject, AutomationJsonValue, AutomationSourceApplication } from '../Common';
+import { AutomationFlowEdge, AutomationCanvasAnnotation, 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"
+}
+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.
+ */
+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[];
+    /** Anotaciones visuales que no forman parte del grafo ejecutable. */
+    annotations?: AutomationCanvasAnnotation[];
+    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;
+    /** Grupo vacío acepta cualquier evento del tipo configurado. */
+    filters: AutomationFilterGroup;
+    enabled: boolean;
+    triggerNodeId: string;
+    priority: number;
+    executionMode: FlowEntryPointExecutionMode;
+    metadata?: AutomationJsonObject | null;
+}

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutomationFilterOperator = exports.AutomationFilterLogicalOperator = 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 = {}));
+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/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/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,113 @@
+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 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;
+    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: AutomationNodePropertyUi;
+    showWhen?: AutomationNodeVisibilityRule | null;
+    hideWhen?: AutomationNodeVisibilityRule | 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;
+    /** 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;
+}