evo360-types 1.3.407 → 1.3.408

package/dist/apps/hub-automation/zod-schemas.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zAutomationDryRunRequestSchema = exports.zHubAutomationConfigSchema = exports.zAutomationRoutineSchema = exports.zAutomationBranchModeSchema = exports.zAutomationBranchSchema = exports.zAutomationOutputSchema = exports.zAutomationHumanTaskOutputSchema = exports.zAutomationAutoTaskOutputSchema = exports.zAutomationExecuteAtSchema = exports.zAutomationConditionGroupSchema = exports.zAutomationConditionSchema = exports.zAutomationOperatorSchema = exports.zAutomationSelectionSchema = exports.zAutomationAppointmentSelectionSchema = exports.zAutomationDateWindowSchema = exports.zAutomationDateOffsetModeSchema = exports.zAutomationTriggerSchema = exports.zAutomationCronTriggerSchema = void 0;
+const zod_1 = require("zod");
+const zod_schemas_1 = require("../evo-task/zod-schemas");
+// ------------------------------------------------------
+// Trigger (F1: cron only)
+// ------------------------------------------------------
+exports.zAutomationCronTriggerSchema = zod_1.z.object({
+    type: zod_1.z.literal("cron"),
+    cron: zod_1.z.object({
+        expression: zod_1.z.string().min(1),
+        timezone: zod_1.z.string().optional(),
+    }),
+});
+exports.zAutomationTriggerSchema = exports.zAutomationCronTriggerSchema;
+// ------------------------------------------------------
+// Selection (F1: appointment target only)
+// ------------------------------------------------------
+exports.zAutomationDateOffsetModeSchema = zod_1.z.enum(["calendar", "business"]);
+exports.zAutomationDateWindowSchema = zod_1.z.object({
+    offset_days: zod_1.z.number().int(), // may be negative (retroactive routines)
+    offset_mode: exports.zAutomationDateOffsetModeSchema,
+});
+exports.zAutomationAppointmentSelectionSchema = zod_1.z.object({
+    target: zod_1.z.literal("appointment"),
+    appointment: zod_1.z.object({
+        calendar_ids: zod_1.z.array(zod_1.z.string()).optional(),
+        date_window: exports.zAutomationDateWindowSchema,
+        status_in: zod_1.z.array(zod_1.z.string()).optional(),
+        status_base_in: zod_1.z.array(zod_1.z.string()).optional(),
+        appointment_type_not_in: zod_1.z.array(zod_1.z.string()).optional(),
+    }),
+});
+exports.zAutomationSelectionSchema = exports.zAutomationAppointmentSelectionSchema;
+// ------------------------------------------------------
+// Conditions (recursive AND/OR groups via z.lazy)
+// ------------------------------------------------------
+exports.zAutomationOperatorSchema = zod_1.z.enum([
+    "eq",
+    "neq",
+    "in",
+    "not_in",
+    "exists",
+    "not_exists",
+    "is_true",
+    "is_false",
+]);
+exports.zAutomationConditionSchema = zod_1.z.object({
+    fact: zod_1.z.string().min(1),
+    operator: exports.zAutomationOperatorSchema,
+    value: zod_1.z.unknown().optional(),
+});
+exports.zAutomationConditionGroupSchema = zod_1.z.lazy(() => zod_1.z.object({
+    combinator: zod_1.z.enum(["and", "or"]),
+    conditions: zod_1.z.array(zod_1.z.union([exports.zAutomationConditionSchema, exports.zAutomationConditionGroupSchema])),
+}));
+// ------------------------------------------------------
+// Outputs (auto Task | human Task)
+// ------------------------------------------------------
+exports.zAutomationExecuteAtSchema = zod_1.z.discriminatedUnion("rule", [
+    zod_1.z.object({ rule: zod_1.z.literal("immediate") }),
+    zod_1.z.object({
+        rule: zod_1.z.literal("send_at_local"),
+        time: zod_1.z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "expected HH:mm"),
+        base: zod_1.z.enum(["target_date", "run_date"]),
+    }),
+]);
+exports.zAutomationAutoTaskOutputSchema = zod_1.z.object({
+    type: zod_1.z.literal("auto_task"),
+    handler: zod_schemas_1.zTaskAutoHandlerSchema,
+    kind: zod_1.z.string().min(1),
+    payload: zod_1.z.record(zod_1.z.unknown()).default({}),
+    execute_at: exports.zAutomationExecuteAtSchema,
+    retry: zod_schemas_1.zTaskRetryPolicySchema.optional(),
+    on_failure: zod_schemas_1.zTaskOnFailureSchema.optional(),
+});
+exports.zAutomationHumanTaskOutputSchema = zod_1.z.object({
+    type: zod_1.z.literal("human_task"),
+    title: zod_1.z.string().min(1),
+    description: zod_1.z.string().optional(),
+    assignee_ref: zod_1.z.string().optional(),
+});
+exports.zAutomationOutputSchema = zod_1.z.discriminatedUnion("type", [
+    exports.zAutomationAutoTaskOutputSchema,
+    exports.zAutomationHumanTaskOutputSchema,
+]);
+// ------------------------------------------------------
+// Branches
+// ------------------------------------------------------
+exports.zAutomationBranchSchema = zod_1.z.object({
+    id: zod_1.z.string().min(1),
+    name: zod_1.z.string().min(1),
+    when: exports.zAutomationConditionGroupSchema.optional(),
+    is_fallback: zod_1.z.boolean().optional(),
+    outputs: zod_1.z.array(exports.zAutomationOutputSchema),
+});
+exports.zAutomationBranchModeSchema = zod_1.z.enum(["all", "exclusive"]);
+// ------------------------------------------------------
+// Routine
+// ------------------------------------------------------
+exports.zAutomationRoutineSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    name: zod_1.z.string().min(1),
+    description: zod_1.z.string().optional(),
+    active: zod_1.z.boolean().default(false),
+    version: zod_1.z.number().int().default(1),
+    trigger: exports.zAutomationTriggerSchema,
+    selection: exports.zAutomationSelectionSchema,
+    branch_mode: exports.zAutomationBranchModeSchema,
+    branches: zod_1.z.array(exports.zAutomationBranchSchema),
+    guards: zod_1.z.object({
+        max_tasks_per_run: zod_1.z.number().int().positive(),
+    }),
+    dry_run_stamp: zod_1.z
+        .object({
+        version: zod_1.z.number().int(),
+        at: zod_1.z.coerce.date(),
+        by: zod_1.z.string(),
+    })
+        .optional(),
+    trigger_state: zod_1.z
+        .object({
+        last_fired_at: zod_1.z.coerce.date().optional(),
+    })
+        .optional(),
+    stats: zod_1.z
+        .object({
+        last_run_at: zod_1.z.coerce.date().optional(),
+        last_materialized_at: zod_1.z.coerce.date().optional(),
+        last_run_id: zod_1.z.string().optional(),
+    })
+        .optional(),
+    created_at: zod_1.z.coerce.date(),
+    updated_at: zod_1.z.coerce.date(),
+});
+// ------------------------------------------------------
+// Module config (mirrors zTaskRunnerConfigSchema: active default false, passthrough)
+// ------------------------------------------------------
+exports.zHubAutomationConfigSchema = zod_1.z
+    .object({
+    active: zod_1.z.boolean().default(false),
+    limits: zod_1.z
+        .object({
+        max_tasks_per_run_default: zod_1.z.number().int().optional(),
+    })
+        .passthrough()
+        .optional(),
+})
+    .passthrough();
+// ------------------------------------------------------
+// Dry-run request (endpoint POST /routines/:id/dry-run)
+// ------------------------------------------------------
+exports.zAutomationDryRunRequestSchema = zod_1.z.object({
+    run_date: zod_1.z
+        .string()
+        .regex(/^\d{4}-\d{2}-\d{2}$/, "expected yyyy-MM-dd")
+        .optional(),
+});

package/dist/apps/hub-automation/zod-schemas.ts

@@ -0,0 +1,191 @@
+import { z } from "zod";
+import {
+  zTaskAutoHandlerSchema,
+  zTaskRetryPolicySchema,
+  zTaskOnFailureSchema,
+} from "../evo-task/zod-schemas";
+
+// ------------------------------------------------------
+// Trigger (F1: cron only)
+// ------------------------------------------------------
+export const zAutomationCronTriggerSchema = z.object({
+  type: z.literal("cron"),
+  cron: z.object({
+    expression: z.string().min(1),
+    timezone: z.string().optional(),
+  }),
+});
+
+export const zAutomationTriggerSchema = zAutomationCronTriggerSchema;
+
+// ------------------------------------------------------
+// Selection (F1: appointment target only)
+// ------------------------------------------------------
+export const zAutomationDateOffsetModeSchema = z.enum(["calendar", "business"]);
+
+export const zAutomationDateWindowSchema = z.object({
+  offset_days: z.number().int(), // may be negative (retroactive routines)
+  offset_mode: zAutomationDateOffsetModeSchema,
+});
+
+export const zAutomationAppointmentSelectionSchema = z.object({
+  target: z.literal("appointment"),
+  appointment: z.object({
+    calendar_ids: z.array(z.string()).optional(),
+    date_window: zAutomationDateWindowSchema,
+    status_in: z.array(z.string()).optional(),
+    status_base_in: z.array(z.string()).optional(),
+    appointment_type_not_in: z.array(z.string()).optional(),
+  }),
+});
+
+export const zAutomationSelectionSchema = zAutomationAppointmentSelectionSchema;
+
+// ------------------------------------------------------
+// Conditions (recursive AND/OR groups via z.lazy)
+// ------------------------------------------------------
+export const zAutomationOperatorSchema = z.enum([
+  "eq",
+  "neq",
+  "in",
+  "not_in",
+  "exists",
+  "not_exists",
+  "is_true",
+  "is_false",
+]);
+
+export const zAutomationConditionSchema = z.object({
+  fact: z.string().min(1),
+  operator: zAutomationOperatorSchema,
+  value: z.unknown().optional(),
+});
+
+// z.lazy needs an explicit type annotation for the recursive reference.
+type ZAutomationConditionGroup = {
+  combinator: "and" | "or";
+  conditions: Array<
+    z.infer<typeof zAutomationConditionSchema> | ZAutomationConditionGroup
+  >;
+};
+
+export const zAutomationConditionGroupSchema: z.ZodType<ZAutomationConditionGroup> =
+  z.lazy(() =>
+    z.object({
+      combinator: z.enum(["and", "or"]),
+      conditions: z.array(
+        z.union([zAutomationConditionSchema, zAutomationConditionGroupSchema])
+      ),
+    })
+  );
+
+// ------------------------------------------------------
+// Outputs (auto Task | human Task)
+// ------------------------------------------------------
+export const zAutomationExecuteAtSchema = z.discriminatedUnion("rule", [
+  z.object({ rule: z.literal("immediate") }),
+  z.object({
+    rule: z.literal("send_at_local"),
+    time: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "expected HH:mm"),
+    base: z.enum(["target_date", "run_date"]),
+  }),
+]);
+
+export const zAutomationAutoTaskOutputSchema = z.object({
+  type: z.literal("auto_task"),
+  handler: zTaskAutoHandlerSchema,
+  kind: z.string().min(1),
+  payload: z.record(z.unknown()).default({}),
+  execute_at: zAutomationExecuteAtSchema,
+  retry: zTaskRetryPolicySchema.optional(),
+  on_failure: zTaskOnFailureSchema.optional(),
+});
+
+export const zAutomationHumanTaskOutputSchema = z.object({
+  type: z.literal("human_task"),
+  title: z.string().min(1),
+  description: z.string().optional(),
+  assignee_ref: z.string().optional(),
+});
+
+export const zAutomationOutputSchema = z.discriminatedUnion("type", [
+  zAutomationAutoTaskOutputSchema,
+  zAutomationHumanTaskOutputSchema,
+]);
+
+// ------------------------------------------------------
+// Branches
+// ------------------------------------------------------
+export const zAutomationBranchSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  when: zAutomationConditionGroupSchema.optional(),
+  is_fallback: z.boolean().optional(),
+  outputs: z.array(zAutomationOutputSchema),
+});
+
+export const zAutomationBranchModeSchema = z.enum(["all", "exclusive"]);
+
+// ------------------------------------------------------
+// Routine
+// ------------------------------------------------------
+export const zAutomationRoutineSchema = z.object({
+  id: z.string(),
+  name: z.string().min(1),
+  description: z.string().optional(),
+  active: z.boolean().default(false),
+  version: z.number().int().default(1),
+  trigger: zAutomationTriggerSchema,
+  selection: zAutomationSelectionSchema,
+  branch_mode: zAutomationBranchModeSchema,
+  branches: z.array(zAutomationBranchSchema),
+  guards: z.object({
+    max_tasks_per_run: z.number().int().positive(),
+  }),
+  dry_run_stamp: z
+    .object({
+      version: z.number().int(),
+      at: z.coerce.date(),
+      by: z.string(),
+    })
+    .optional(),
+  trigger_state: z
+    .object({
+      last_fired_at: z.coerce.date().optional(),
+    })
+    .optional(),
+  stats: z
+    .object({
+      last_run_at: z.coerce.date().optional(),
+      last_materialized_at: z.coerce.date().optional(),
+      last_run_id: z.string().optional(),
+    })
+    .optional(),
+  created_at: z.coerce.date(),
+  updated_at: z.coerce.date(),
+});
+
+// ------------------------------------------------------
+// Module config (mirrors zTaskRunnerConfigSchema: active default false, passthrough)
+// ------------------------------------------------------
+export const zHubAutomationConfigSchema = z
+  .object({
+    active: z.boolean().default(false),
+    limits: z
+      .object({
+        max_tasks_per_run_default: z.number().int().optional(),
+      })
+      .passthrough()
+      .optional(),
+  })
+  .passthrough();
+
+// ------------------------------------------------------
+// Dry-run request (endpoint POST /routines/:id/dry-run)
+// ------------------------------------------------------
+export const zAutomationDryRunRequestSchema = z.object({
+  run_date: z
+    .string()
+    .regex(/^\d{4}-\d{2}-\d{2}$/, "expected yyyy-MM-dd")
+    .optional(),
+});

package/dist/index.d.ts

@@ -23,6 +23,7 @@ export * from "./types/evo-finops";
 export * from "./types/evo-notif-user";
 export * from "./types/evo-notifications";
 export * from "./types/evo-task-runner";
+export * from "./types/hub-automation";
 export * from "./types/evo-integrations";
 export * from "./types/nex-customers";
 export * from "./types/nex-tenants";
@@ -66,4 +67,5 @@ export * from "./apps/evo-notif-user/zod-schemas";
 export * from "./apps/evo-notifications/zod-schemas";
 export * from "./apps/evo-notifications/quick-reply-action/zod-schemas";
 export * from "./apps/evo-task-runner/zod-schemas";
+export * from "./apps/hub-automation/zod-schemas";
 export * from "./apps/evo-integrations/zod-schemas";

package/dist/index.js

@@ -40,6 +40,7 @@ __exportStar(require("./types/evo-finops"), exports);
 __exportStar(require("./types/evo-notif-user"), exports);
 __exportStar(require("./types/evo-notifications"), exports);
 __exportStar(require("./types/evo-task-runner"), exports);
+__exportStar(require("./types/hub-automation"), exports);
 __exportStar(require("./types/evo-integrations"), exports);
 __exportStar(require("./types/nex-customers"), exports);
 __exportStar(require("./types/nex-tenants"), exports);
@@ -84,4 +85,5 @@ __exportStar(require("./apps/evo-notif-user/zod-schemas"), exports);
 __exportStar(require("./apps/evo-notifications/zod-schemas"), exports);
 __exportStar(require("./apps/evo-notifications/quick-reply-action/zod-schemas"), exports);
 __exportStar(require("./apps/evo-task-runner/zod-schemas"), exports);
+__exportStar(require("./apps/hub-automation/zod-schemas"), exports);
 __exportStar(require("./apps/evo-integrations/zod-schemas"), exports);

package/dist/index.ts

@@ -24,6 +24,7 @@ export * from "./types/evo-finops";
 export * from "./types/evo-notif-user";
 export * from "./types/evo-notifications";
 export * from "./types/evo-task-runner";
+export * from "./types/hub-automation";
 export * from "./types/evo-integrations";
 export * from "./types/nex-customers";
 export * from "./types/nex-tenants";
@@ -69,4 +70,5 @@ export * from "./apps/evo-notif-user/zod-schemas";
 export * from "./apps/evo-notifications/zod-schemas";
 export * from "./apps/evo-notifications/quick-reply-action/zod-schemas";
 export * from "./apps/evo-task-runner/zod-schemas";
+export * from "./apps/hub-automation/zod-schemas";
 export * from "./apps/evo-integrations/zod-schemas";

package/dist/types/hub-automation/fb_collections.d.ts

@@ -0,0 +1,4 @@
+export declare const HUB_AUTOMATION_APP = "hub-automation";
+export declare const ROUTINES_COLLECTION = "routines";
+export declare const RUNS_COLLECTION = "runs";
+export declare const HUB_AUTOMATION_CONFIG_DOC = "config";

package/dist/types/hub-automation/fb_collections.js

@@ -0,0 +1,16 @@
+"use strict";
+// Firestore collection/doc identifiers for the hub-automation module.
+// Base path: tenants/{tenant}/apps/hub-automation/...
+// - `config` subcollection reuses the shared CONFIG_COLLECTION ("config")
+// - HUB_AUTOMATION_CONFIG_DOC is the fixed doc id inside that subcollection
+//   (path: tenants/{tenant}/apps/hub-automation/config/config)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HUB_AUTOMATION_CONFIG_DOC = exports.RUNS_COLLECTION = exports.ROUTINES_COLLECTION = exports.HUB_AUTOMATION_APP = void 0;
+// ----- App identifier (Firestore path: tenants/{t}/apps/hub-automation/...)
+exports.HUB_AUTOMATION_APP = "hub-automation";
+// ----- Routines collection: tenants/{t}/apps/hub-automation/routines/{routineId}
+exports.ROUTINES_COLLECTION = "routines";
+// ----- Run traces collection: tenants/{t}/apps/hub-automation/runs/{runId}
+exports.RUNS_COLLECTION = "runs";
+// ----- Fixed config doc id inside the shared `config` subcollection
+exports.HUB_AUTOMATION_CONFIG_DOC = "config";

package/dist/types/hub-automation/fb_collections.ts

@@ -0,0 +1,17 @@
+// Firestore collection/doc identifiers for the hub-automation module.
+// Base path: tenants/{tenant}/apps/hub-automation/...
+// - `config` subcollection reuses the shared CONFIG_COLLECTION ("config")
+// - HUB_AUTOMATION_CONFIG_DOC is the fixed doc id inside that subcollection
+//   (path: tenants/{tenant}/apps/hub-automation/config/config)
+
+// ----- App identifier (Firestore path: tenants/{t}/apps/hub-automation/...)
+export const HUB_AUTOMATION_APP = "hub-automation";
+
+// ----- Routines collection: tenants/{t}/apps/hub-automation/routines/{routineId}
+export const ROUTINES_COLLECTION = "routines";
+
+// ----- Run traces collection: tenants/{t}/apps/hub-automation/runs/{runId}
+export const RUNS_COLLECTION = "runs";
+
+// ----- Fixed config doc id inside the shared `config` subcollection
+export const HUB_AUTOMATION_CONFIG_DOC = "config";

package/dist/types/hub-automation/index.d.ts

@@ -0,0 +1,181 @@
+export * from "./fb_collections";
+import type { TaskAutoHandler, ITaskRetryPolicy, ITaskOnFailure } from "../evo-task";
+export declare const HubAutomationPermissions: {
+    readonly Read: "hub_automation_read";
+    readonly Write: "hub_automation_write";
+};
+export type HubAutomationPermissions = (typeof HubAutomationPermissions)[keyof typeof HubAutomationPermissions];
+export interface IAutomationCronTrigger {
+    type: "cron";
+    cron: {
+        expression: string;
+        timezone?: string;
+    };
+}
+export type IAutomationTrigger = IAutomationCronTrigger;
+export type AutomationDateOffsetMode = "calendar" | "business";
+export interface IAutomationDateWindow {
+    offset_days: number;
+    offset_mode: AutomationDateOffsetMode;
+}
+export interface IAutomationAppointmentSelection {
+    target: "appointment";
+    appointment: {
+        calendar_ids?: string[];
+        date_window: IAutomationDateWindow;
+        status_in?: string[];
+        status_base_in?: string[];
+        appointment_type_not_in?: string[];
+    };
+}
+export type IAutomationSelection = IAutomationAppointmentSelection;
+export declare const AUTOMATION_APPOINTMENT_FACTS: readonly ["appointment.status", "appointment.status_base", "appointment.appointment_type", "appointment.appointment_base_type", "appointment.appointment_mode", "appointment.professional_id", "appointment.procedure_ids", "appointment.payment_status", "appointment.calendar_id"];
+export type AutomationAppointmentFact = (typeof AUTOMATION_APPOINTMENT_FACTS)[number];
+export type AutomationFact = AutomationAppointmentFact;
+export declare const AutomationOperatorEnum: {
+    readonly Eq: "eq";
+    readonly Neq: "neq";
+    readonly In: "in";
+    readonly NotIn: "not_in";
+    readonly Exists: "exists";
+    readonly NotExists: "not_exists";
+    readonly IsTrue: "is_true";
+    readonly IsFalse: "is_false";
+};
+export type AutomationOperator = (typeof AutomationOperatorEnum)[keyof typeof AutomationOperatorEnum];
+export interface IAutomationCondition {
+    fact: string;
+    operator: AutomationOperator;
+    value?: unknown;
+}
+export type AutomationCombinator = "and" | "or";
+export interface IAutomationConditionGroup {
+    combinator: AutomationCombinator;
+    conditions: Array<IAutomationCondition | IAutomationConditionGroup>;
+}
+export declare const AutomationOutputTypeEnum: {
+    readonly AutoTask: "auto_task";
+    readonly HumanTask: "human_task";
+};
+export type AutomationOutputType = (typeof AutomationOutputTypeEnum)[keyof typeof AutomationOutputTypeEnum];
+export type IAutomationExecuteAt = {
+    rule: "immediate";
+} | {
+    rule: "send_at_local";
+    time: string;
+    base: "target_date" | "run_date";
+};
+export interface IAutomationAutoTaskOutput {
+    type: "auto_task";
+    handler: TaskAutoHandler;
+    kind: string;
+    payload: Record<string, unknown>;
+    execute_at: IAutomationExecuteAt;
+    retry?: ITaskRetryPolicy;
+    on_failure?: ITaskOnFailure;
+}
+export interface IAutomationHumanTaskOutput {
+    type: "human_task";
+    title: string;
+    description?: string;
+    assignee_ref?: string;
+}
+export type IAutomationOutput = IAutomationAutoTaskOutput | IAutomationHumanTaskOutput;
+export interface IAutomationBranch {
+    id: string;
+    name: string;
+    when?: IAutomationConditionGroup;
+    is_fallback?: boolean;
+    outputs: IAutomationOutput[];
+}
+export type AutomationBranchMode = "all" | "exclusive";
+export interface IAutomationRoutine {
+    id: string;
+    name: string;
+    description?: string;
+    active: boolean;
+    version: number;
+    trigger: IAutomationTrigger;
+    selection: IAutomationSelection;
+    branch_mode: AutomationBranchMode;
+    branches: IAutomationBranch[];
+    guards: {
+        max_tasks_per_run: number;
+    };
+    dry_run_stamp?: {
+        version: number;
+        at: Date;
+        by: string;
+    };
+    trigger_state?: {
+        last_fired_at?: Date;
+    };
+    stats?: {
+        last_run_at?: Date;
+        last_materialized_at?: Date;
+        last_run_id?: string;
+    };
+    created_at: Date;
+    updated_at: Date;
+}
+export interface IHubAutomationConfig {
+    active: boolean;
+    limits?: {
+        max_tasks_per_run_default?: number;
+    };
+}
+export declare const AutomationRunStatusEnum: {
+    readonly Ok: "ok";
+    readonly Limited: "limited";
+    readonly BlockedDryRunRequired: "blocked_dry_run_required";
+    readonly Error: "error";
+};
+export type AutomationRunStatus = (typeof AutomationRunStatusEnum)[keyof typeof AutomationRunStatusEnum];
+export interface IAutomationConditionResult {
+    fact: string;
+    op: AutomationOperator;
+    value?: unknown;
+    actual?: unknown;
+    passed: boolean;
+}
+export interface IAutomationRunBranchCounts {
+    matched: number;
+    created: number;
+    already_existed: number;
+}
+export interface IAutomationRunSample {
+    appointment_id: string;
+    branch_id?: string;
+    decision: string;
+    conditions?: IAutomationConditionResult[];
+    [key: string]: unknown;
+}
+export interface IAutomationRunTrace {
+    routine_id: string;
+    routine_version: number;
+    trigger: {
+        type: string;
+        fired_at: Date;
+        cron_expression?: string;
+    };
+    dry_run: boolean;
+    window: {
+        target_dates: string[];
+        timezone: string;
+    };
+    status: AutomationRunStatus;
+    counts: {
+        targets_scanned: number;
+        tasks_created: number;
+        tasks_already_existed: number;
+        tasks_suppressed_by_limit: number;
+        per_branch: Record<string, IAutomationRunBranchCounts>;
+    };
+    samples?: IAutomationRunSample[];
+    error?: {
+        message: string;
+        code?: string | number;
+        details?: Record<string, unknown>;
+    };
+    duration_ms: number;
+}