@scarn/sdk 0.0.0-stage → 0.0.0

package/dist/contracts/pipeline-document/schema.d.ts

@@ -0,0 +1,780 @@
+/**
+ * The zod schema for pipeline JSON documents (schema version 1) and the JSON
+ * Schema exported from it.
+ *
+ * The schema checks structure only. Features that are in the format but not
+ * in v1 (retry delays, wait timeouts, pipeline timeouts, event/timer waits,
+ * routing to another pipeline) are accepted here and rejected by the
+ * validator, so their errors carry a clear "not supported in v1" message.
+ */
+import { z } from "zod";
+import type { JsonValue } from "./json";
+import { CONDITION_OPERATORS, COMPUTED_FUNCTIONS } from "./conditions/operators";
+export declare const NODE_ID_PATTERN: RegExp;
+export declare const ALIAS_PATTERN: RegExp;
+export declare const literalSchema: z.ZodObject<{
+    value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+}, z.core.$strict>;
+/** An array built from references and literals, one element each. */
+export declare const listSchema: z.ZodObject<{
+    list: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>;
+/** A reference string, `{ "value": ... }` for a literal, or `{ "list": [...] }`. */
+export declare const argValueSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+}, z.core.$strict>, z.ZodObject<{
+    list: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>]>;
+export declare const computedSourceSchema: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+    path: z.ZodString;
+    field: z.ZodOptional<z.ZodString>;
+    where: z.ZodOptional<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+}, z.core.$strict>]>;
+/**
+ * One condition. All keys are optional at the structural level; which
+ * combinations are allowed (one left side, `value` xor `ref`, `where` only
+ * with list operators, ...) is checked by the refinement below so errors
+ * point at the exact key instead of an opaque union failure.
+ */
+export interface Condition {
+    all?: Condition[];
+    any?: Condition[];
+    not?: Condition;
+    path?: string;
+    sum?: ComputedSource;
+    avg?: ComputedSource;
+    min?: ComputedSource;
+    max?: ComputedSource;
+    count?: ComputedSource;
+    weights?: number[];
+    op?: ConditionOperator;
+    value?: JsonValue;
+    ref?: string;
+    where?: Condition;
+}
+export type ComputedSource = string[] | {
+    path: string;
+    field?: string;
+    where?: Condition;
+};
+export type ConditionOperator = (typeof CONDITION_OPERATORS)[number];
+export type ComputedFunction = (typeof COMPUTED_FUNCTIONS)[number];
+export declare const conditionSchema: z.ZodType<Condition>;
+export declare const toleratedFailuresSchema: z.ZodUnion<readonly [z.ZodObject<{
+    count: z.ZodInt;
+}, z.core.$strict>, z.ZodObject<{
+    percent: z.ZodNumber;
+}, z.core.$strict>]>;
+export declare const eachSchema: z.ZodObject<{
+    over: z.ZodString;
+    maxConcurrency: z.ZodOptional<z.ZodInt>;
+    toleratedFailures: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        count: z.ZodInt;
+    }, z.core.$strict>, z.ZodObject<{
+        percent: z.ZodNumber;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>;
+export declare const routeSchema: z.ZodObject<{
+    when: z.ZodOptional<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+    to: z.ZodString;
+    pipeline: z.ZodOptional<z.ZodString>;
+    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        list: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>]>>>;
+    each: z.ZodOptional<z.ZodObject<{
+        over: z.ZodString;
+        maxConcurrency: z.ZodOptional<z.ZodInt>;
+        toleratedFailures: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            count: z.ZodInt;
+        }, z.core.$strict>, z.ZodObject<{
+            percent: z.ZodNumber;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>>;
+    partial: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$strict>;
+/** The route taken when no route matched. It has no `when`. */
+export declare const otherwiseSchema: z.ZodObject<{
+    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        list: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>]>>>;
+    each: z.ZodOptional<z.ZodObject<{
+        over: z.ZodString;
+        maxConcurrency: z.ZodOptional<z.ZodInt>;
+        toleratedFailures: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            count: z.ZodInt;
+        }, z.core.$strict>, z.ZodObject<{
+            percent: z.ZodNumber;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>>;
+    to: z.ZodString;
+    partial: z.ZodOptional<z.ZodLiteral<true>>;
+    pipeline: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** The pipeline's first route. It can't split or merge. */
+export declare const startSchema: z.ZodObject<{
+    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        list: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>]>>>;
+    each: z.ZodOptional<z.ZodObject<{
+        over: z.ZodString;
+        maxConcurrency: z.ZodOptional<z.ZodInt>;
+        toleratedFailures: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            count: z.ZodInt;
+        }, z.core.$strict>, z.ZodObject<{
+            percent: z.ZodNumber;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>>;
+    when: z.ZodOptional<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+    to: z.ZodString;
+    pipeline: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * How a node picks its routes: `"first"` (the default) takes the first
+ * match, `"all"` takes every match, each as a lane.
+ */
+export declare const MATCH_MODES: readonly ["first", "all"];
+export declare const nextSchema: z.ZodObject<{
+    match: z.ZodOptional<z.ZodEnum<{
+        all: "all";
+        first: "first";
+    }>>;
+    routes: z.ZodArray<z.ZodObject<{
+        when: z.ZodOptional<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+        to: z.ZodString;
+        pipeline: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            list: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+            }, z.core.$strict>]>>;
+        }, z.core.$strict>]>>>;
+        each: z.ZodOptional<z.ZodObject<{
+            over: z.ZodString;
+            maxConcurrency: z.ZodOptional<z.ZodInt>;
+            toleratedFailures: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                count: z.ZodInt;
+            }, z.core.$strict>, z.ZodObject<{
+                percent: z.ZodNumber;
+            }, z.core.$strict>]>>;
+        }, z.core.$strict>>;
+        partial: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strict>>;
+    otherwise: z.ZodOptional<z.ZodObject<{
+        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            list: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+            }, z.core.$strict>]>>;
+        }, z.core.$strict>]>>>;
+        each: z.ZodOptional<z.ZodObject<{
+            over: z.ZodString;
+            maxConcurrency: z.ZodOptional<z.ZodInt>;
+            toleratedFailures: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                count: z.ZodInt;
+            }, z.core.$strict>, z.ZodObject<{
+                percent: z.ZodNumber;
+            }, z.core.$strict>]>>;
+        }, z.core.$strict>>;
+        to: z.ZodString;
+        partial: z.ZodOptional<z.ZodLiteral<true>>;
+        pipeline: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const retrySchema: z.ZodObject<{
+    on: z.ZodArray<z.ZodString>;
+    maxAttempts: z.ZodInt;
+    intervalSeconds: z.ZodOptional<z.ZodNumber>;
+    backoffRate: z.ZodOptional<z.ZodNumber>;
+    maxDelaySeconds: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const catchSchema: z.ZodObject<{
+    on: z.ZodArray<z.ZodString>;
+    to: z.ZodString;
+    pipeline: z.ZodOptional<z.ZodString>;
+    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        list: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>]>>>;
+}, z.core.$strict>;
+export declare const stepNodeSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"step">;
+    title: z.ZodOptional<z.ZodString>;
+    step: z.ZodString;
+    next: z.ZodOptional<z.ZodObject<{
+        match: z.ZodOptional<z.ZodEnum<{
+            all: "all";
+            first: "first";
+        }>>;
+        routes: z.ZodArray<z.ZodObject<{
+            when: z.ZodOptional<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+            to: z.ZodString;
+            pipeline: z.ZodOptional<z.ZodString>;
+            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+            }, z.core.$strict>, z.ZodObject<{
+                list: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+                }, z.core.$strict>]>>;
+            }, z.core.$strict>]>>>;
+            each: z.ZodOptional<z.ZodObject<{
+                over: z.ZodString;
+                maxConcurrency: z.ZodOptional<z.ZodInt>;
+                toleratedFailures: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                    count: z.ZodInt;
+                }, z.core.$strict>, z.ZodObject<{
+                    percent: z.ZodNumber;
+                }, z.core.$strict>]>>;
+            }, z.core.$strict>>;
+            partial: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$strict>>;
+        otherwise: z.ZodOptional<z.ZodObject<{
+            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+            }, z.core.$strict>, z.ZodObject<{
+                list: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+                }, z.core.$strict>]>>;
+            }, z.core.$strict>]>>>;
+            each: z.ZodOptional<z.ZodObject<{
+                over: z.ZodString;
+                maxConcurrency: z.ZodOptional<z.ZodInt>;
+                toleratedFailures: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                    count: z.ZodInt;
+                }, z.core.$strict>, z.ZodObject<{
+                    percent: z.ZodNumber;
+                }, z.core.$strict>]>>;
+            }, z.core.$strict>>;
+            to: z.ZodString;
+            partial: z.ZodOptional<z.ZodLiteral<true>>;
+            pipeline: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    retry: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        on: z.ZodArray<z.ZodString>;
+        maxAttempts: z.ZodInt;
+        intervalSeconds: z.ZodOptional<z.ZodNumber>;
+        backoffRate: z.ZodOptional<z.ZodNumber>;
+        maxDelaySeconds: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>;
+    catch: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        on: z.ZodArray<z.ZodString>;
+        to: z.ZodString;
+        pipeline: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            list: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+            }, z.core.$strict>]>>;
+        }, z.core.$strict>]>>>;
+    }, z.core.$strict>>>;
+    timeoutSeconds: z.ZodOptional<z.ZodInt>;
+    heartbeatSeconds: z.ZodOptional<z.ZodInt>;
+    maxRuns: z.ZodOptional<z.ZodInt>;
+    maxTurns: z.ZodOptional<z.ZodInt>;
+}, z.core.$strict>;
+/** A step node's `maxTurns` when the document leaves it out. */
+export declare const DEFAULT_MAX_TURNS = 2;
+/** Whether a decision action needs a body. A missing `body` means `"optional"`. */
+export declare const DECISION_BODY_MODES: readonly ["optional", "required"];
+/** One choice a `decision` wait offers, in button order. */
+export declare const decisionActionSchema: z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    body: z.ZodOptional<z.ZodEnum<{
+        required: "required";
+        optional: "optional";
+    }>>;
+}, z.core.$strict>;
+export declare const waitNodeSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"wait">;
+    title: z.ZodOptional<z.ZodString>;
+    for: z.ZodEnum<{
+        event: "event";
+        decision: "decision";
+        reply: "reply";
+        timer: "timer";
+    }>;
+    actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        body: z.ZodOptional<z.ZodEnum<{
+            required: "required";
+            optional: "optional";
+        }>>;
+    }, z.core.$strict>>>;
+    next: z.ZodOptional<z.ZodObject<{
+        match: z.ZodOptional<z.ZodEnum<{
+            all: "all";
+            first: "first";
+        }>>;
+        routes: z.ZodArray<z.ZodObject<{
+            when: z.ZodOptional<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+            to: z.ZodString;
+            pipeline: z.ZodOptional<z.ZodString>;
+            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+            }, z.core.$strict>, z.ZodObject<{
+                list: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+                }, z.core.$strict>]>>;
+            }, z.core.$strict>]>>>;
+            each: z.ZodOptional<z.ZodObject<{
+                over: z.ZodString;
+                maxConcurrency: z.ZodOptional<z.ZodInt>;
+                toleratedFailures: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                    count: z.ZodInt;
+                }, z.core.$strict>, z.ZodObject<{
+                    percent: z.ZodNumber;
+                }, z.core.$strict>]>>;
+            }, z.core.$strict>>;
+            partial: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$strict>>;
+        otherwise: z.ZodOptional<z.ZodObject<{
+            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+            }, z.core.$strict>, z.ZodObject<{
+                list: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+                }, z.core.$strict>]>>;
+            }, z.core.$strict>]>>>;
+            each: z.ZodOptional<z.ZodObject<{
+                over: z.ZodString;
+                maxConcurrency: z.ZodOptional<z.ZodInt>;
+                toleratedFailures: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                    count: z.ZodInt;
+                }, z.core.$strict>, z.ZodObject<{
+                    percent: z.ZodNumber;
+                }, z.core.$strict>]>>;
+            }, z.core.$strict>>;
+            to: z.ZodString;
+            partial: z.ZodOptional<z.ZodLiteral<true>>;
+            pipeline: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    catch: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        on: z.ZodArray<z.ZodString>;
+        to: z.ZodString;
+        pipeline: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            list: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+            }, z.core.$strict>]>>;
+        }, z.core.$strict>]>>>;
+    }, z.core.$strict>>>;
+    timeoutSeconds: z.ZodOptional<z.ZodInt>;
+    maxRuns: z.ZodOptional<z.ZodInt>;
+}, z.core.$strict>;
+export declare const succeedNodeSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"succeed">;
+    title: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const failNodeSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"fail">;
+    title: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+    cause: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const nodeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"step">;
+    title: z.ZodOptional<z.ZodString>;
+    step: z.ZodString;
+    next: z.ZodOptional<z.ZodObject<{
+        match: z.ZodOptional<z.ZodEnum<{
+            all: "all";
+            first: "first";
+        }>>;
+        routes: z.ZodArray<z.ZodObject<{
+            when: z.ZodOptional<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+            to: z.ZodString;
+            pipeline: z.ZodOptional<z.ZodString>;
+            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+            }, z.core.$strict>, z.ZodObject<{
+                list: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+                }, z.core.$strict>]>>;
+            }, z.core.$strict>]>>>;
+            each: z.ZodOptional<z.ZodObject<{
+                over: z.ZodString;
+                maxConcurrency: z.ZodOptional<z.ZodInt>;
+                toleratedFailures: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                    count: z.ZodInt;
+                }, z.core.$strict>, z.ZodObject<{
+                    percent: z.ZodNumber;
+                }, z.core.$strict>]>>;
+            }, z.core.$strict>>;
+            partial: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$strict>>;
+        otherwise: z.ZodOptional<z.ZodObject<{
+            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+            }, z.core.$strict>, z.ZodObject<{
+                list: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+                }, z.core.$strict>]>>;
+            }, z.core.$strict>]>>>;
+            each: z.ZodOptional<z.ZodObject<{
+                over: z.ZodString;
+                maxConcurrency: z.ZodOptional<z.ZodInt>;
+                toleratedFailures: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                    count: z.ZodInt;
+                }, z.core.$strict>, z.ZodObject<{
+                    percent: z.ZodNumber;
+                }, z.core.$strict>]>>;
+            }, z.core.$strict>>;
+            to: z.ZodString;
+            partial: z.ZodOptional<z.ZodLiteral<true>>;
+            pipeline: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    retry: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        on: z.ZodArray<z.ZodString>;
+        maxAttempts: z.ZodInt;
+        intervalSeconds: z.ZodOptional<z.ZodNumber>;
+        backoffRate: z.ZodOptional<z.ZodNumber>;
+        maxDelaySeconds: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>;
+    catch: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        on: z.ZodArray<z.ZodString>;
+        to: z.ZodString;
+        pipeline: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            list: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+            }, z.core.$strict>]>>;
+        }, z.core.$strict>]>>>;
+    }, z.core.$strict>>>;
+    timeoutSeconds: z.ZodOptional<z.ZodInt>;
+    heartbeatSeconds: z.ZodOptional<z.ZodInt>;
+    maxRuns: z.ZodOptional<z.ZodInt>;
+    maxTurns: z.ZodOptional<z.ZodInt>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"wait">;
+    title: z.ZodOptional<z.ZodString>;
+    for: z.ZodEnum<{
+        event: "event";
+        decision: "decision";
+        reply: "reply";
+        timer: "timer";
+    }>;
+    actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        body: z.ZodOptional<z.ZodEnum<{
+            required: "required";
+            optional: "optional";
+        }>>;
+    }, z.core.$strict>>>;
+    next: z.ZodOptional<z.ZodObject<{
+        match: z.ZodOptional<z.ZodEnum<{
+            all: "all";
+            first: "first";
+        }>>;
+        routes: z.ZodArray<z.ZodObject<{
+            when: z.ZodOptional<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+            to: z.ZodString;
+            pipeline: z.ZodOptional<z.ZodString>;
+            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+            }, z.core.$strict>, z.ZodObject<{
+                list: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+                }, z.core.$strict>]>>;
+            }, z.core.$strict>]>>>;
+            each: z.ZodOptional<z.ZodObject<{
+                over: z.ZodString;
+                maxConcurrency: z.ZodOptional<z.ZodInt>;
+                toleratedFailures: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                    count: z.ZodInt;
+                }, z.core.$strict>, z.ZodObject<{
+                    percent: z.ZodNumber;
+                }, z.core.$strict>]>>;
+            }, z.core.$strict>>;
+            partial: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$strict>>;
+        otherwise: z.ZodOptional<z.ZodObject<{
+            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+            }, z.core.$strict>, z.ZodObject<{
+                list: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+                }, z.core.$strict>]>>;
+            }, z.core.$strict>]>>>;
+            each: z.ZodOptional<z.ZodObject<{
+                over: z.ZodString;
+                maxConcurrency: z.ZodOptional<z.ZodInt>;
+                toleratedFailures: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                    count: z.ZodInt;
+                }, z.core.$strict>, z.ZodObject<{
+                    percent: z.ZodNumber;
+                }, z.core.$strict>]>>;
+            }, z.core.$strict>>;
+            to: z.ZodString;
+            partial: z.ZodOptional<z.ZodLiteral<true>>;
+            pipeline: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    catch: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        on: z.ZodArray<z.ZodString>;
+        to: z.ZodString;
+        pipeline: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            list: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+            }, z.core.$strict>]>>;
+        }, z.core.$strict>]>>>;
+    }, z.core.$strict>>>;
+    timeoutSeconds: z.ZodOptional<z.ZodInt>;
+    maxRuns: z.ZodOptional<z.ZodInt>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"succeed">;
+    title: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"fail">;
+    title: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+    cause: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>], "kind">;
+export declare const pipelineDocumentSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    schemaVersion: z.ZodLiteral<1>;
+    key: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    timeoutSeconds: z.ZodOptional<z.ZodInt>;
+    workItemFields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    start: z.ZodObject<{
+        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            list: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+            }, z.core.$strict>]>>;
+        }, z.core.$strict>]>>>;
+        each: z.ZodOptional<z.ZodObject<{
+            over: z.ZodString;
+            maxConcurrency: z.ZodOptional<z.ZodInt>;
+            toleratedFailures: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                count: z.ZodInt;
+            }, z.core.$strict>, z.ZodObject<{
+                percent: z.ZodNumber;
+            }, z.core.$strict>]>>;
+        }, z.core.$strict>>;
+        when: z.ZodOptional<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+        to: z.ZodString;
+        pipeline: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    nodes: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"step">;
+        title: z.ZodOptional<z.ZodString>;
+        step: z.ZodString;
+        next: z.ZodOptional<z.ZodObject<{
+            match: z.ZodOptional<z.ZodEnum<{
+                all: "all";
+                first: "first";
+            }>>;
+            routes: z.ZodArray<z.ZodObject<{
+                when: z.ZodOptional<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+                to: z.ZodString;
+                pipeline: z.ZodOptional<z.ZodString>;
+                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    list: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                        value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+                    }, z.core.$strict>]>>;
+                }, z.core.$strict>]>>>;
+                each: z.ZodOptional<z.ZodObject<{
+                    over: z.ZodString;
+                    maxConcurrency: z.ZodOptional<z.ZodInt>;
+                    toleratedFailures: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        count: z.ZodInt;
+                    }, z.core.$strict>, z.ZodObject<{
+                        percent: z.ZodNumber;
+                    }, z.core.$strict>]>>;
+                }, z.core.$strict>>;
+                partial: z.ZodOptional<z.ZodLiteral<true>>;
+            }, z.core.$strict>>;
+            otherwise: z.ZodOptional<z.ZodObject<{
+                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    list: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                        value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+                    }, z.core.$strict>]>>;
+                }, z.core.$strict>]>>>;
+                each: z.ZodOptional<z.ZodObject<{
+                    over: z.ZodString;
+                    maxConcurrency: z.ZodOptional<z.ZodInt>;
+                    toleratedFailures: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        count: z.ZodInt;
+                    }, z.core.$strict>, z.ZodObject<{
+                        percent: z.ZodNumber;
+                    }, z.core.$strict>]>>;
+                }, z.core.$strict>>;
+                to: z.ZodString;
+                partial: z.ZodOptional<z.ZodLiteral<true>>;
+                pipeline: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        retry: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            on: z.ZodArray<z.ZodString>;
+            maxAttempts: z.ZodInt;
+            intervalSeconds: z.ZodOptional<z.ZodNumber>;
+            backoffRate: z.ZodOptional<z.ZodNumber>;
+            maxDelaySeconds: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>;
+        catch: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            on: z.ZodArray<z.ZodString>;
+            to: z.ZodString;
+            pipeline: z.ZodOptional<z.ZodString>;
+            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+            }, z.core.$strict>, z.ZodObject<{
+                list: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+                }, z.core.$strict>]>>;
+            }, z.core.$strict>]>>>;
+        }, z.core.$strict>>>;
+        timeoutSeconds: z.ZodOptional<z.ZodInt>;
+        heartbeatSeconds: z.ZodOptional<z.ZodInt>;
+        maxRuns: z.ZodOptional<z.ZodInt>;
+        maxTurns: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"wait">;
+        title: z.ZodOptional<z.ZodString>;
+        for: z.ZodEnum<{
+            event: "event";
+            decision: "decision";
+            reply: "reply";
+            timer: "timer";
+        }>;
+        actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodString;
+            body: z.ZodOptional<z.ZodEnum<{
+                required: "required";
+                optional: "optional";
+            }>>;
+        }, z.core.$strict>>>;
+        next: z.ZodOptional<z.ZodObject<{
+            match: z.ZodOptional<z.ZodEnum<{
+                all: "all";
+                first: "first";
+            }>>;
+            routes: z.ZodArray<z.ZodObject<{
+                when: z.ZodOptional<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>;
+                to: z.ZodString;
+                pipeline: z.ZodOptional<z.ZodString>;
+                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    list: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                        value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+                    }, z.core.$strict>]>>;
+                }, z.core.$strict>]>>>;
+                each: z.ZodOptional<z.ZodObject<{
+                    over: z.ZodString;
+                    maxConcurrency: z.ZodOptional<z.ZodInt>;
+                    toleratedFailures: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        count: z.ZodInt;
+                    }, z.core.$strict>, z.ZodObject<{
+                        percent: z.ZodNumber;
+                    }, z.core.$strict>]>>;
+                }, z.core.$strict>>;
+                partial: z.ZodOptional<z.ZodLiteral<true>>;
+            }, z.core.$strict>>;
+            otherwise: z.ZodOptional<z.ZodObject<{
+                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    list: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                        value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+                    }, z.core.$strict>]>>;
+                }, z.core.$strict>]>>>;
+                each: z.ZodOptional<z.ZodObject<{
+                    over: z.ZodString;
+                    maxConcurrency: z.ZodOptional<z.ZodInt>;
+                    toleratedFailures: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        count: z.ZodInt;
+                    }, z.core.$strict>, z.ZodObject<{
+                        percent: z.ZodNumber;
+                    }, z.core.$strict>]>>;
+                }, z.core.$strict>>;
+                to: z.ZodString;
+                partial: z.ZodOptional<z.ZodLiteral<true>>;
+                pipeline: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        catch: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            on: z.ZodArray<z.ZodString>;
+            to: z.ZodString;
+            pipeline: z.ZodOptional<z.ZodString>;
+            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+            }, z.core.$strict>, z.ZodObject<{
+                list: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+                }, z.core.$strict>]>>;
+            }, z.core.$strict>]>>>;
+        }, z.core.$strict>>>;
+        timeoutSeconds: z.ZodOptional<z.ZodInt>;
+        maxRuns: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"succeed">;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"fail">;
+        title: z.ZodOptional<z.ZodString>;
+        error: z.ZodOptional<z.ZodString>;
+        cause: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>;
+export type ArgValue = z.infer<typeof argValueSchema>;
+export type ListArg = z.infer<typeof listSchema>;
+export type Each = z.infer<typeof eachSchema>;
+export type ToleratedFailures = z.infer<typeof toleratedFailuresSchema>;
+export type Route = z.infer<typeof routeSchema>;
+export type Otherwise = z.infer<typeof otherwiseSchema>;
+export type Start = z.infer<typeof startSchema>;
+export type Next = z.infer<typeof nextSchema>;
+export type MatchMode = (typeof MATCH_MODES)[number];
+export type Retry = z.infer<typeof retrySchema>;
+export type Catch = z.infer<typeof catchSchema>;
+export type StepNode = z.infer<typeof stepNodeSchema>;
+export type WaitNode = z.infer<typeof waitNodeSchema>;
+export type DecisionAction = z.infer<typeof decisionActionSchema>;
+export type DecisionBody = (typeof DECISION_BODY_MODES)[number];
+export type SucceedNode = z.infer<typeof succeedNodeSchema>;
+export type FailNode = z.infer<typeof failNodeSchema>;
+export type PipelineNode = z.infer<typeof nodeSchema>;
+export type PipelineDocument = z.infer<typeof pipelineDocumentSchema>;
+/** The JSON Schema for pipeline documents, for editors and external tools. */
+export declare function pipelineDocumentJsonSchema(): Record<string, unknown>;