@horizon36596/zenith-schema 0.1.1

package/dist/auto.d.ts

@@ -0,0 +1,1882 @@
+import { z } from "zod";
+/**
+ * The highest number of Bezier control points a v1 auto file may carry, so the highest degree is
+ * four (start, three controls, end).
+ *
+ * Read off the pinned Pedro snapshot: `Paths.curve(Pose...)` is variadic,
+ * `BezierCurve(List<Vector2D>)` accepts any control polygon of three points or more, and the
+ * runtime hands every pose in `control[]` straight to `Paths.curve`. The owner's ruling was
+ * "whatever Pedro allows", so the file format allows one to three control points. Changing this
+ * number changes the file format, not just the code.
+ */
+export declare const MAX_BEZIER_CONTROL_POINTS = 3;
+export declare const lineSegmentSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"line">;
+    from: z.ZodUnion<[z.ZodLiteral<"current">, z.ZodObject<{
+        ref: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        ref: string;
+    }, {
+        ref: string;
+    }>, z.ZodObject<{
+        xIn: z.ZodNumber;
+        yIn: z.ZodNumber;
+        headingRad: z.ZodOptional<z.ZodNumber>;
+        provenance: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    }, {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    }>]>;
+    to: z.ZodUnion<[z.ZodLiteral<"current">, z.ZodObject<{
+        ref: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        ref: string;
+    }, {
+        ref: string;
+    }>, z.ZodObject<{
+        xIn: z.ZodNumber;
+        yIn: z.ZodNumber;
+        headingRad: z.ZodOptional<z.ZodNumber>;
+        provenance: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    }, {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    }>]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "line";
+    from: {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    } | {
+        ref: string;
+    } | "current";
+    to: {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    } | {
+        ref: string;
+    } | "current";
+}, {
+    kind: "line";
+    from: {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    } | {
+        ref: string;
+    } | "current";
+    to: {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    } | {
+        ref: string;
+    } | "current";
+}>;
+export declare const bezierSegmentSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"bezier">;
+    from: z.ZodUnion<[z.ZodLiteral<"current">, z.ZodObject<{
+        ref: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        ref: string;
+    }, {
+        ref: string;
+    }>, z.ZodObject<{
+        xIn: z.ZodNumber;
+        yIn: z.ZodNumber;
+        headingRad: z.ZodOptional<z.ZodNumber>;
+        provenance: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    }, {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    }>]>;
+    control: z.ZodArray<z.ZodObject<{
+        xIn: z.ZodNumber;
+        yIn: z.ZodNumber;
+        headingRad: z.ZodOptional<z.ZodNumber>;
+        provenance: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    }, {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    }>, "many">;
+    to: z.ZodUnion<[z.ZodLiteral<"current">, z.ZodObject<{
+        ref: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        ref: string;
+    }, {
+        ref: string;
+    }>, z.ZodObject<{
+        xIn: z.ZodNumber;
+        yIn: z.ZodNumber;
+        headingRad: z.ZodOptional<z.ZodNumber>;
+        provenance: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    }, {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    }>]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "bezier";
+    from: {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    } | {
+        ref: string;
+    } | "current";
+    to: {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    } | {
+        ref: string;
+    } | "current";
+    control: {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    }[];
+}, {
+    kind: "bezier";
+    from: {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    } | {
+        ref: string;
+    } | "current";
+    to: {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    } | {
+        ref: string;
+    } | "current";
+    control: {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    }[];
+}>;
+export declare const segmentSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"line">;
+    from: z.ZodUnion<[z.ZodLiteral<"current">, z.ZodObject<{
+        ref: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        ref: string;
+    }, {
+        ref: string;
+    }>, z.ZodObject<{
+        xIn: z.ZodNumber;
+        yIn: z.ZodNumber;
+        headingRad: z.ZodOptional<z.ZodNumber>;
+        provenance: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    }, {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    }>]>;
+    to: z.ZodUnion<[z.ZodLiteral<"current">, z.ZodObject<{
+        ref: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        ref: string;
+    }, {
+        ref: string;
+    }>, z.ZodObject<{
+        xIn: z.ZodNumber;
+        yIn: z.ZodNumber;
+        headingRad: z.ZodOptional<z.ZodNumber>;
+        provenance: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    }, {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    }>]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "line";
+    from: {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    } | {
+        ref: string;
+    } | "current";
+    to: {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    } | {
+        ref: string;
+    } | "current";
+}, {
+    kind: "line";
+    from: {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    } | {
+        ref: string;
+    } | "current";
+    to: {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    } | {
+        ref: string;
+    } | "current";
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"bezier">;
+    from: z.ZodUnion<[z.ZodLiteral<"current">, z.ZodObject<{
+        ref: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        ref: string;
+    }, {
+        ref: string;
+    }>, z.ZodObject<{
+        xIn: z.ZodNumber;
+        yIn: z.ZodNumber;
+        headingRad: z.ZodOptional<z.ZodNumber>;
+        provenance: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    }, {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    }>]>;
+    control: z.ZodArray<z.ZodObject<{
+        xIn: z.ZodNumber;
+        yIn: z.ZodNumber;
+        headingRad: z.ZodOptional<z.ZodNumber>;
+        provenance: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    }, {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    }>, "many">;
+    to: z.ZodUnion<[z.ZodLiteral<"current">, z.ZodObject<{
+        ref: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        ref: string;
+    }, {
+        ref: string;
+    }>, z.ZodObject<{
+        xIn: z.ZodNumber;
+        yIn: z.ZodNumber;
+        headingRad: z.ZodOptional<z.ZodNumber>;
+        provenance: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    }, {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    }>]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "bezier";
+    from: {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    } | {
+        ref: string;
+    } | "current";
+    to: {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    } | {
+        ref: string;
+    } | "current";
+    control: {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    }[];
+}, {
+    kind: "bezier";
+    from: {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    } | {
+        ref: string;
+    } | "current";
+    to: {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    } | {
+        ref: string;
+    } | "current";
+    control: {
+        xIn: number;
+        yIn: number;
+        provenance?: string | undefined;
+        headingRad?: number | undefined;
+    }[];
+}>]>;
+/**
+ * The heading one range of a `piecewise` heading carries: any mode but `piecewise` itself. Inside a
+ * range, `linear` turns from `fromRad` at the range's start to `toRad` at its end.
+ */
+export declare const rangeHeadingSchema: z.ZodDiscriminatedUnion<"mode", [z.ZodObject<{
+    mode: z.ZodLiteral<"tangent">;
+}, "strip", z.ZodTypeAny, {
+    mode: "tangent";
+}, {
+    mode: "tangent";
+}>, z.ZodObject<{
+    mode: z.ZodLiteral<"tangentReversed">;
+}, "strip", z.ZodTypeAny, {
+    mode: "tangentReversed";
+}, {
+    mode: "tangentReversed";
+}>, z.ZodObject<{
+    mode: z.ZodLiteral<"constant">;
+    headingRad: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    headingRad: number;
+    mode: "constant";
+}, {
+    headingRad: number;
+    mode: "constant";
+}>, z.ZodObject<{
+    mode: z.ZodLiteral<"linear">;
+    fromRad: z.ZodNumber;
+    toRad: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    mode: "linear";
+    fromRad: number;
+    toRad: number;
+}, {
+    mode: "linear";
+    fromRad: number;
+    toRad: number;
+}>, z.ZodObject<{
+    mode: z.ZodLiteral<"facePoint">;
+    xIn: z.ZodNumber;
+    yIn: z.ZodNumber;
+    offsetRad: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    xIn: number;
+    yIn: number;
+    mode: "facePoint";
+    offsetRad?: number | undefined;
+}, {
+    xIn: number;
+    yIn: number;
+    mode: "facePoint";
+    offsetRad?: number | undefined;
+}>]>;
+/**
+ * One stretch of a `piecewise` heading (format version 3): from `startT` to `endT` along the step,
+ * as fractions of its arc length (no unit), with its own heading. Pedro's
+ * `Interpolator.piecewise().until(t, ...)` needs the ranges to run from 0 to exactly 1, in order,
+ * with no gap and no overlap; the schema only bounds each number and `HEADING_RANGES` checks the
+ * rest, so a half-edited file still loads and says what is wrong with it.
+ */
+export declare const headingRangeSchema: z.ZodObject<{
+    startT: z.ZodNumber;
+    endT: z.ZodNumber;
+    heading: z.ZodDiscriminatedUnion<"mode", [z.ZodObject<{
+        mode: z.ZodLiteral<"tangent">;
+    }, "strip", z.ZodTypeAny, {
+        mode: "tangent";
+    }, {
+        mode: "tangent";
+    }>, z.ZodObject<{
+        mode: z.ZodLiteral<"tangentReversed">;
+    }, "strip", z.ZodTypeAny, {
+        mode: "tangentReversed";
+    }, {
+        mode: "tangentReversed";
+    }>, z.ZodObject<{
+        mode: z.ZodLiteral<"constant">;
+        headingRad: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        headingRad: number;
+        mode: "constant";
+    }, {
+        headingRad: number;
+        mode: "constant";
+    }>, z.ZodObject<{
+        mode: z.ZodLiteral<"linear">;
+        fromRad: z.ZodNumber;
+        toRad: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        mode: "linear";
+        fromRad: number;
+        toRad: number;
+    }, {
+        mode: "linear";
+        fromRad: number;
+        toRad: number;
+    }>, z.ZodObject<{
+        mode: z.ZodLiteral<"facePoint">;
+        xIn: z.ZodNumber;
+        yIn: z.ZodNumber;
+        offsetRad: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        xIn: number;
+        yIn: number;
+        mode: "facePoint";
+        offsetRad?: number | undefined;
+    }, {
+        xIn: number;
+        yIn: number;
+        mode: "facePoint";
+        offsetRad?: number | undefined;
+    }>]>;
+}, "strip", z.ZodTypeAny, {
+    startT: number;
+    endT: number;
+    heading: {
+        mode: "tangent";
+    } | {
+        mode: "tangentReversed";
+    } | {
+        headingRad: number;
+        mode: "constant";
+    } | {
+        mode: "linear";
+        fromRad: number;
+        toRad: number;
+    } | {
+        xIn: number;
+        yIn: number;
+        mode: "facePoint";
+        offsetRad?: number | undefined;
+    };
+}, {
+    startT: number;
+    endT: number;
+    heading: {
+        mode: "tangent";
+    } | {
+        mode: "tangentReversed";
+    } | {
+        headingRad: number;
+        mode: "constant";
+    } | {
+        mode: "linear";
+        fromRad: number;
+        toRad: number;
+    } | {
+        xIn: number;
+        yIn: number;
+        mode: "facePoint";
+        offsetRad?: number | undefined;
+    };
+}>;
+/** The heading modes of site/docs/file-format.md, as h(t). */
+export declare const headingSchema: z.ZodDiscriminatedUnion<"mode", [z.ZodObject<{
+    mode: z.ZodLiteral<"tangent">;
+}, "strip", z.ZodTypeAny, {
+    mode: "tangent";
+}, {
+    mode: "tangent";
+}>, z.ZodObject<{
+    mode: z.ZodLiteral<"tangentReversed">;
+}, "strip", z.ZodTypeAny, {
+    mode: "tangentReversed";
+}, {
+    mode: "tangentReversed";
+}>, z.ZodObject<{
+    mode: z.ZodLiteral<"constant">;
+    headingRad: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    headingRad: number;
+    mode: "constant";
+}, {
+    headingRad: number;
+    mode: "constant";
+}>, z.ZodObject<{
+    mode: z.ZodLiteral<"linear">;
+    fromRad: z.ZodNumber;
+    toRad: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    mode: "linear";
+    fromRad: number;
+    toRad: number;
+}, {
+    mode: "linear";
+    fromRad: number;
+    toRad: number;
+}>, z.ZodObject<{
+    mode: z.ZodLiteral<"facePoint">;
+    xIn: z.ZodNumber;
+    yIn: z.ZodNumber;
+    offsetRad: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    xIn: number;
+    yIn: number;
+    mode: "facePoint";
+    offsetRad?: number | undefined;
+}, {
+    xIn: number;
+    yIn: number;
+    mode: "facePoint";
+    offsetRad?: number | undefined;
+}>, z.ZodObject<{
+    mode: z.ZodLiteral<"piecewise">;
+    ranges: z.ZodArray<z.ZodObject<{
+        startT: z.ZodNumber;
+        endT: z.ZodNumber;
+        heading: z.ZodDiscriminatedUnion<"mode", [z.ZodObject<{
+            mode: z.ZodLiteral<"tangent">;
+        }, "strip", z.ZodTypeAny, {
+            mode: "tangent";
+        }, {
+            mode: "tangent";
+        }>, z.ZodObject<{
+            mode: z.ZodLiteral<"tangentReversed">;
+        }, "strip", z.ZodTypeAny, {
+            mode: "tangentReversed";
+        }, {
+            mode: "tangentReversed";
+        }>, z.ZodObject<{
+            mode: z.ZodLiteral<"constant">;
+            headingRad: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            headingRad: number;
+            mode: "constant";
+        }, {
+            headingRad: number;
+            mode: "constant";
+        }>, z.ZodObject<{
+            mode: z.ZodLiteral<"linear">;
+            fromRad: z.ZodNumber;
+            toRad: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            mode: "linear";
+            fromRad: number;
+            toRad: number;
+        }, {
+            mode: "linear";
+            fromRad: number;
+            toRad: number;
+        }>, z.ZodObject<{
+            mode: z.ZodLiteral<"facePoint">;
+            xIn: z.ZodNumber;
+            yIn: z.ZodNumber;
+            offsetRad: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            xIn: number;
+            yIn: number;
+            mode: "facePoint";
+            offsetRad?: number | undefined;
+        }, {
+            xIn: number;
+            yIn: number;
+            mode: "facePoint";
+            offsetRad?: number | undefined;
+        }>]>;
+    }, "strip", z.ZodTypeAny, {
+        startT: number;
+        endT: number;
+        heading: {
+            mode: "tangent";
+        } | {
+            mode: "tangentReversed";
+        } | {
+            headingRad: number;
+            mode: "constant";
+        } | {
+            mode: "linear";
+            fromRad: number;
+            toRad: number;
+        } | {
+            xIn: number;
+            yIn: number;
+            mode: "facePoint";
+            offsetRad?: number | undefined;
+        };
+    }, {
+        startT: number;
+        endT: number;
+        heading: {
+            mode: "tangent";
+        } | {
+            mode: "tangentReversed";
+        } | {
+            headingRad: number;
+            mode: "constant";
+        } | {
+            mode: "linear";
+            fromRad: number;
+            toRad: number;
+        } | {
+            xIn: number;
+            yIn: number;
+            mode: "facePoint";
+            offsetRad?: number | undefined;
+        };
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    mode: "piecewise";
+    ranges: {
+        startT: number;
+        endT: number;
+        heading: {
+            mode: "tangent";
+        } | {
+            mode: "tangentReversed";
+        } | {
+            headingRad: number;
+            mode: "constant";
+        } | {
+            mode: "linear";
+            fromRad: number;
+            toRad: number;
+        } | {
+            xIn: number;
+            yIn: number;
+            mode: "facePoint";
+            offsetRad?: number | undefined;
+        };
+    }[];
+}, {
+    mode: "piecewise";
+    ranges: {
+        startT: number;
+        endT: number;
+        heading: {
+            mode: "tangent";
+        } | {
+            mode: "tangentReversed";
+        } | {
+            headingRad: number;
+            mode: "constant";
+        } | {
+            mode: "linear";
+            fromRad: number;
+            toRad: number;
+        } | {
+            xIn: number;
+            yIn: number;
+            mode: "facePoint";
+            offsetRad?: number | undefined;
+        };
+    }[];
+}>]>;
+export declare const markerAtSchema: z.ZodUnion<[z.ZodObject<{
+    t: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    t: number;
+}, {
+    t: number;
+}>, z.ZodObject<{
+    distanceIn: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    distanceIn: number;
+}, {
+    distanceIn: number;
+}>, z.ZodObject<{
+    distanceFromEndIn: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    distanceFromEndIn: number;
+}, {
+    distanceFromEndIn: number;
+}>]>;
+export declare const commandCallSchema: z.ZodObject<{
+    name: z.ZodString;
+    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    args?: Record<string, string | number | boolean> | undefined;
+}, {
+    name: string;
+    args?: Record<string, string | number | boolean> | undefined;
+}>;
+export declare const markerSchema: z.ZodObject<{
+    at: z.ZodUnion<[z.ZodObject<{
+        t: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        t: number;
+    }, {
+        t: number;
+    }>, z.ZodObject<{
+        distanceIn: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        distanceIn: number;
+    }, {
+        distanceIn: number;
+    }>, z.ZodObject<{
+        distanceFromEndIn: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        distanceFromEndIn: number;
+    }, {
+        distanceFromEndIn: number;
+    }>]>;
+    command: z.ZodObject<{
+        name: z.ZodString;
+        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        args?: Record<string, string | number | boolean> | undefined;
+    }, {
+        name: string;
+        args?: Record<string, string | number | boolean> | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    at: {
+        t: number;
+    } | {
+        distanceIn: number;
+    } | {
+        distanceFromEndIn: number;
+    };
+    command: {
+        name: string;
+        args?: Record<string, string | number | boolean> | undefined;
+    };
+}, {
+    at: {
+        t: number;
+    } | {
+        distanceIn: number;
+    } | {
+        distanceFromEndIn: number;
+    };
+    command: {
+        name: string;
+        args?: Record<string, string | number | boolean> | undefined;
+    };
+}>;
+export declare const conditionRefSchema: z.ZodObject<{
+    condition: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    condition: string;
+}, {
+    condition: string;
+}>;
+/** Planner-only annotations; the runtime ignores them (site/docs/file-format.md, `expect`). */
+export declare const expectSchema: z.ZodObject<{
+    collectFrom: z.ZodOptional<z.ZodString>;
+    count: z.ZodOptional<z.ZodNumber>;
+    launchesInto: z.ZodOptional<z.ZodString>;
+    tip: z.ZodOptional<z.ZodEnum<["own", "opponent"]>>;
+}, "strip", z.ZodTypeAny, {
+    collectFrom?: string | undefined;
+    count?: number | undefined;
+    launchesInto?: string | undefined;
+    tip?: "own" | "opponent" | undefined;
+}, {
+    collectFrom?: string | undefined;
+    count?: number | undefined;
+    launchesInto?: string | undefined;
+    tip?: "own" | "opponent" | undefined;
+}>;
+export declare const pathStepSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"path">;
+    timeoutS: z.ZodOptional<z.ZodNumber>;
+    segments: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"line">;
+        from: z.ZodUnion<[z.ZodLiteral<"current">, z.ZodObject<{
+            ref: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            ref: string;
+        }, {
+            ref: string;
+        }>, z.ZodObject<{
+            xIn: z.ZodNumber;
+            yIn: z.ZodNumber;
+            headingRad: z.ZodOptional<z.ZodNumber>;
+            provenance: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        }, {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        }>]>;
+        to: z.ZodUnion<[z.ZodLiteral<"current">, z.ZodObject<{
+            ref: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            ref: string;
+        }, {
+            ref: string;
+        }>, z.ZodObject<{
+            xIn: z.ZodNumber;
+            yIn: z.ZodNumber;
+            headingRad: z.ZodOptional<z.ZodNumber>;
+            provenance: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        }, {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        }>]>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "line";
+        from: {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        } | {
+            ref: string;
+        } | "current";
+        to: {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        } | {
+            ref: string;
+        } | "current";
+    }, {
+        kind: "line";
+        from: {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        } | {
+            ref: string;
+        } | "current";
+        to: {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        } | {
+            ref: string;
+        } | "current";
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"bezier">;
+        from: z.ZodUnion<[z.ZodLiteral<"current">, z.ZodObject<{
+            ref: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            ref: string;
+        }, {
+            ref: string;
+        }>, z.ZodObject<{
+            xIn: z.ZodNumber;
+            yIn: z.ZodNumber;
+            headingRad: z.ZodOptional<z.ZodNumber>;
+            provenance: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        }, {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        }>]>;
+        control: z.ZodArray<z.ZodObject<{
+            xIn: z.ZodNumber;
+            yIn: z.ZodNumber;
+            headingRad: z.ZodOptional<z.ZodNumber>;
+            provenance: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        }, {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        }>, "many">;
+        to: z.ZodUnion<[z.ZodLiteral<"current">, z.ZodObject<{
+            ref: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            ref: string;
+        }, {
+            ref: string;
+        }>, z.ZodObject<{
+            xIn: z.ZodNumber;
+            yIn: z.ZodNumber;
+            headingRad: z.ZodOptional<z.ZodNumber>;
+            provenance: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        }, {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        }>]>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "bezier";
+        from: {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        } | {
+            ref: string;
+        } | "current";
+        to: {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        } | {
+            ref: string;
+        } | "current";
+        control: {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        }[];
+    }, {
+        kind: "bezier";
+        from: {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        } | {
+            ref: string;
+        } | "current";
+        to: {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        } | {
+            ref: string;
+        } | "current";
+        control: {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        }[];
+    }>]>, "many">;
+    heading: z.ZodOptional<z.ZodDiscriminatedUnion<"mode", [z.ZodObject<{
+        mode: z.ZodLiteral<"tangent">;
+    }, "strip", z.ZodTypeAny, {
+        mode: "tangent";
+    }, {
+        mode: "tangent";
+    }>, z.ZodObject<{
+        mode: z.ZodLiteral<"tangentReversed">;
+    }, "strip", z.ZodTypeAny, {
+        mode: "tangentReversed";
+    }, {
+        mode: "tangentReversed";
+    }>, z.ZodObject<{
+        mode: z.ZodLiteral<"constant">;
+        headingRad: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        headingRad: number;
+        mode: "constant";
+    }, {
+        headingRad: number;
+        mode: "constant";
+    }>, z.ZodObject<{
+        mode: z.ZodLiteral<"linear">;
+        fromRad: z.ZodNumber;
+        toRad: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        mode: "linear";
+        fromRad: number;
+        toRad: number;
+    }, {
+        mode: "linear";
+        fromRad: number;
+        toRad: number;
+    }>, z.ZodObject<{
+        mode: z.ZodLiteral<"facePoint">;
+        xIn: z.ZodNumber;
+        yIn: z.ZodNumber;
+        offsetRad: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        xIn: number;
+        yIn: number;
+        mode: "facePoint";
+        offsetRad?: number | undefined;
+    }, {
+        xIn: number;
+        yIn: number;
+        mode: "facePoint";
+        offsetRad?: number | undefined;
+    }>, z.ZodObject<{
+        mode: z.ZodLiteral<"piecewise">;
+        ranges: z.ZodArray<z.ZodObject<{
+            startT: z.ZodNumber;
+            endT: z.ZodNumber;
+            heading: z.ZodDiscriminatedUnion<"mode", [z.ZodObject<{
+                mode: z.ZodLiteral<"tangent">;
+            }, "strip", z.ZodTypeAny, {
+                mode: "tangent";
+            }, {
+                mode: "tangent";
+            }>, z.ZodObject<{
+                mode: z.ZodLiteral<"tangentReversed">;
+            }, "strip", z.ZodTypeAny, {
+                mode: "tangentReversed";
+            }, {
+                mode: "tangentReversed";
+            }>, z.ZodObject<{
+                mode: z.ZodLiteral<"constant">;
+                headingRad: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                headingRad: number;
+                mode: "constant";
+            }, {
+                headingRad: number;
+                mode: "constant";
+            }>, z.ZodObject<{
+                mode: z.ZodLiteral<"linear">;
+                fromRad: z.ZodNumber;
+                toRad: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                mode: "linear";
+                fromRad: number;
+                toRad: number;
+            }, {
+                mode: "linear";
+                fromRad: number;
+                toRad: number;
+            }>, z.ZodObject<{
+                mode: z.ZodLiteral<"facePoint">;
+                xIn: z.ZodNumber;
+                yIn: z.ZodNumber;
+                offsetRad: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                xIn: number;
+                yIn: number;
+                mode: "facePoint";
+                offsetRad?: number | undefined;
+            }, {
+                xIn: number;
+                yIn: number;
+                mode: "facePoint";
+                offsetRad?: number | undefined;
+            }>]>;
+        }, "strip", z.ZodTypeAny, {
+            startT: number;
+            endT: number;
+            heading: {
+                mode: "tangent";
+            } | {
+                mode: "tangentReversed";
+            } | {
+                headingRad: number;
+                mode: "constant";
+            } | {
+                mode: "linear";
+                fromRad: number;
+                toRad: number;
+            } | {
+                xIn: number;
+                yIn: number;
+                mode: "facePoint";
+                offsetRad?: number | undefined;
+            };
+        }, {
+            startT: number;
+            endT: number;
+            heading: {
+                mode: "tangent";
+            } | {
+                mode: "tangentReversed";
+            } | {
+                headingRad: number;
+                mode: "constant";
+            } | {
+                mode: "linear";
+                fromRad: number;
+                toRad: number;
+            } | {
+                xIn: number;
+                yIn: number;
+                mode: "facePoint";
+                offsetRad?: number | undefined;
+            };
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        mode: "piecewise";
+        ranges: {
+            startT: number;
+            endT: number;
+            heading: {
+                mode: "tangent";
+            } | {
+                mode: "tangentReversed";
+            } | {
+                headingRad: number;
+                mode: "constant";
+            } | {
+                mode: "linear";
+                fromRad: number;
+                toRad: number;
+            } | {
+                xIn: number;
+                yIn: number;
+                mode: "facePoint";
+                offsetRad?: number | undefined;
+            };
+        }[];
+    }, {
+        mode: "piecewise";
+        ranges: {
+            startT: number;
+            endT: number;
+            heading: {
+                mode: "tangent";
+            } | {
+                mode: "tangentReversed";
+            } | {
+                headingRad: number;
+                mode: "constant";
+            } | {
+                mode: "linear";
+                fromRad: number;
+                toRad: number;
+            } | {
+                xIn: number;
+                yIn: number;
+                mode: "facePoint";
+                offsetRad?: number | undefined;
+            };
+        }[];
+    }>]>>;
+    speedFraction: z.ZodOptional<z.ZodNumber>;
+    markers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        at: z.ZodUnion<[z.ZodObject<{
+            t: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            t: number;
+        }, {
+            t: number;
+        }>, z.ZodObject<{
+            distanceIn: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            distanceIn: number;
+        }, {
+            distanceIn: number;
+        }>, z.ZodObject<{
+            distanceFromEndIn: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            distanceFromEndIn: number;
+        }, {
+            distanceFromEndIn: number;
+        }>]>;
+        command: z.ZodObject<{
+            name: z.ZodString;
+            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            args?: Record<string, string | number | boolean> | undefined;
+        }, {
+            name: string;
+            args?: Record<string, string | number | boolean> | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        at: {
+            t: number;
+        } | {
+            distanceIn: number;
+        } | {
+            distanceFromEndIn: number;
+        };
+        command: {
+            name: string;
+            args?: Record<string, string | number | boolean> | undefined;
+        };
+    }, {
+        at: {
+            t: number;
+        } | {
+            distanceIn: number;
+        } | {
+            distanceFromEndIn: number;
+        };
+        command: {
+            name: string;
+            args?: Record<string, string | number | boolean> | undefined;
+        };
+    }>, "many">>;
+    endCondition: z.ZodOptional<z.ZodObject<{
+        condition: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        condition: string;
+    }, {
+        condition: string;
+    }>>;
+    expect: z.ZodOptional<z.ZodObject<{
+        collectFrom: z.ZodOptional<z.ZodString>;
+        count: z.ZodOptional<z.ZodNumber>;
+        launchesInto: z.ZodOptional<z.ZodString>;
+        tip: z.ZodOptional<z.ZodEnum<["own", "opponent"]>>;
+    }, "strip", z.ZodTypeAny, {
+        collectFrom?: string | undefined;
+        count?: number | undefined;
+        launchesInto?: string | undefined;
+        tip?: "own" | "opponent" | undefined;
+    }, {
+        collectFrom?: string | undefined;
+        count?: number | undefined;
+        launchesInto?: string | undefined;
+        tip?: "own" | "opponent" | undefined;
+    }>>;
+    notes: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    kind: "path";
+    segments: ({
+        kind: "line";
+        from: {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        } | {
+            ref: string;
+        } | "current";
+        to: {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        } | {
+            ref: string;
+        } | "current";
+    } | {
+        kind: "bezier";
+        from: {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        } | {
+            ref: string;
+        } | "current";
+        to: {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        } | {
+            ref: string;
+        } | "current";
+        control: {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        }[];
+    })[];
+    heading?: {
+        mode: "tangent";
+    } | {
+        mode: "tangentReversed";
+    } | {
+        headingRad: number;
+        mode: "constant";
+    } | {
+        mode: "linear";
+        fromRad: number;
+        toRad: number;
+    } | {
+        xIn: number;
+        yIn: number;
+        mode: "facePoint";
+        offsetRad?: number | undefined;
+    } | {
+        mode: "piecewise";
+        ranges: {
+            startT: number;
+            endT: number;
+            heading: {
+                mode: "tangent";
+            } | {
+                mode: "tangentReversed";
+            } | {
+                headingRad: number;
+                mode: "constant";
+            } | {
+                mode: "linear";
+                fromRad: number;
+                toRad: number;
+            } | {
+                xIn: number;
+                yIn: number;
+                mode: "facePoint";
+                offsetRad?: number | undefined;
+            };
+        }[];
+    } | undefined;
+    id?: string | undefined;
+    timeoutS?: number | undefined;
+    speedFraction?: number | undefined;
+    markers?: {
+        at: {
+            t: number;
+        } | {
+            distanceIn: number;
+        } | {
+            distanceFromEndIn: number;
+        };
+        command: {
+            name: string;
+            args?: Record<string, string | number | boolean> | undefined;
+        };
+    }[] | undefined;
+    endCondition?: {
+        condition: string;
+    } | undefined;
+    expect?: {
+        collectFrom?: string | undefined;
+        count?: number | undefined;
+        launchesInto?: string | undefined;
+        tip?: "own" | "opponent" | undefined;
+    } | undefined;
+    notes?: string | undefined;
+}, {
+    kind: "path";
+    segments: ({
+        kind: "line";
+        from: {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        } | {
+            ref: string;
+        } | "current";
+        to: {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        } | {
+            ref: string;
+        } | "current";
+    } | {
+        kind: "bezier";
+        from: {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        } | {
+            ref: string;
+        } | "current";
+        to: {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        } | {
+            ref: string;
+        } | "current";
+        control: {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        }[];
+    })[];
+    heading?: {
+        mode: "tangent";
+    } | {
+        mode: "tangentReversed";
+    } | {
+        headingRad: number;
+        mode: "constant";
+    } | {
+        mode: "linear";
+        fromRad: number;
+        toRad: number;
+    } | {
+        xIn: number;
+        yIn: number;
+        mode: "facePoint";
+        offsetRad?: number | undefined;
+    } | {
+        mode: "piecewise";
+        ranges: {
+            startT: number;
+            endT: number;
+            heading: {
+                mode: "tangent";
+            } | {
+                mode: "tangentReversed";
+            } | {
+                headingRad: number;
+                mode: "constant";
+            } | {
+                mode: "linear";
+                fromRad: number;
+                toRad: number;
+            } | {
+                xIn: number;
+                yIn: number;
+                mode: "facePoint";
+                offsetRad?: number | undefined;
+            };
+        }[];
+    } | undefined;
+    id?: string | undefined;
+    timeoutS?: number | undefined;
+    speedFraction?: number | undefined;
+    markers?: {
+        at: {
+            t: number;
+        } | {
+            distanceIn: number;
+        } | {
+            distanceFromEndIn: number;
+        };
+        command: {
+            name: string;
+            args?: Record<string, string | number | boolean> | undefined;
+        };
+    }[] | undefined;
+    endCondition?: {
+        condition: string;
+    } | undefined;
+    expect?: {
+        collectFrom?: string | undefined;
+        count?: number | undefined;
+        launchesInto?: string | undefined;
+        tip?: "own" | "opponent" | undefined;
+    } | undefined;
+    notes?: string | undefined;
+}>;
+export declare const commandStepSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"command">;
+    name: z.ZodString;
+    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    timeoutS: z.ZodOptional<z.ZodNumber>;
+    expect: z.ZodOptional<z.ZodObject<{
+        collectFrom: z.ZodOptional<z.ZodString>;
+        count: z.ZodOptional<z.ZodNumber>;
+        launchesInto: z.ZodOptional<z.ZodString>;
+        tip: z.ZodOptional<z.ZodEnum<["own", "opponent"]>>;
+    }, "strip", z.ZodTypeAny, {
+        collectFrom?: string | undefined;
+        count?: number | undefined;
+        launchesInto?: string | undefined;
+        tip?: "own" | "opponent" | undefined;
+    }, {
+        collectFrom?: string | undefined;
+        count?: number | undefined;
+        launchesInto?: string | undefined;
+        tip?: "own" | "opponent" | undefined;
+    }>>;
+    notes: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    kind: "command";
+    name: string;
+    args?: Record<string, string | number | boolean> | undefined;
+    id?: string | undefined;
+    timeoutS?: number | undefined;
+    expect?: {
+        collectFrom?: string | undefined;
+        count?: number | undefined;
+        launchesInto?: string | undefined;
+        tip?: "own" | "opponent" | undefined;
+    } | undefined;
+    notes?: string | undefined;
+}, {
+    kind: "command";
+    name: string;
+    args?: Record<string, string | number | boolean> | undefined;
+    id?: string | undefined;
+    timeoutS?: number | undefined;
+    expect?: {
+        collectFrom?: string | undefined;
+        count?: number | undefined;
+        launchesInto?: string | undefined;
+        tip?: "own" | "opponent" | undefined;
+    } | undefined;
+    notes?: string | undefined;
+}>;
+/**
+ * A wait ends one way or the other: after `seconds`, or when `until` reads true. Carrying both is
+ * refused rather than resolved, because the two readings disagree by the whole of `seconds` — the
+ * estimator would budget the number and the generated Java would emit a `WaitUntilCommand` and
+ * ignore it.
+ */
+export declare const waitStepSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"wait">;
+    seconds: z.ZodOptional<z.ZodNumber>;
+    until: z.ZodOptional<z.ZodString>;
+    timeoutS: z.ZodOptional<z.ZodNumber>;
+    notes: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    kind: "wait";
+    id?: string | undefined;
+    timeoutS?: number | undefined;
+    notes?: string | undefined;
+    seconds?: number | undefined;
+    until?: string | undefined;
+}, {
+    kind: "wait";
+    id?: string | undefined;
+    timeoutS?: number | undefined;
+    notes?: string | undefined;
+    seconds?: number | undefined;
+    until?: string | undefined;
+}>, {
+    kind: "wait";
+    id?: string | undefined;
+    timeoutS?: number | undefined;
+    notes?: string | undefined;
+    seconds?: number | undefined;
+    until?: string | undefined;
+}, {
+    kind: "wait";
+    id?: string | undefined;
+    timeoutS?: number | undefined;
+    notes?: string | undefined;
+    seconds?: number | undefined;
+    until?: string | undefined;
+}>, {
+    kind: "wait";
+    id?: string | undefined;
+    timeoutS?: number | undefined;
+    notes?: string | undefined;
+    seconds?: number | undefined;
+    until?: string | undefined;
+}, {
+    kind: "wait";
+    id?: string | undefined;
+    timeoutS?: number | undefined;
+    notes?: string | undefined;
+    seconds?: number | undefined;
+    until?: string | undefined;
+}>;
+export type PathStep = z.infer<typeof pathStepSchema>;
+export type CommandStep = z.infer<typeof commandStepSchema>;
+export type WaitStep = z.infer<typeof waitStepSchema>;
+/** Written by hand because the type is recursive: sequence, parallel and branch steps hold steps. */
+export interface SequenceStep {
+    id?: string;
+    kind: "sequence";
+    /** Run one after another, exactly like the top-level list; the group ends when the last does. */
+    steps: Step[];
+    notes?: string;
+}
+export interface ParallelStep {
+    id?: string;
+    kind: "parallel";
+    mode: "all" | "race" | "deadline";
+    deadline?: string;
+    steps: Step[];
+    notes?: string;
+}
+export interface BranchStep {
+    id?: string;
+    kind: "branch";
+    condition: string;
+    then: Step[];
+    else?: Step[];
+    notes?: string;
+}
+export type Step = PathStep | CommandStep | WaitStep | SequenceStep | ParallelStep | BranchStep;
+/** The step kinds that hold other steps. */
+export type GroupStep = SequenceStep | ParallelStep | BranchStep;
+/** Every step kind, in the order the editor's insert menu lists them. */
+export declare const STEP_KINDS: readonly ["path", "command", "wait", "sequence", "parallel", "branch"];
+export type StepKind = (typeof STEP_KINDS)[number];
+/**
+ * The lists of steps a step holds, in document order: none for a leaf, one for a sequence or a
+ * parallel group, `then` and (when present) `else` for a branch. Every walk over the step tree
+ * goes through this and `withChildLists`, so a new group kind is one change here and not one in
+ * every walker.
+ */
+export declare function childLists(step: Step): Step[][];
+/**
+ * The same step with its child lists replaced, in the order `childLists` returned them. The
+ * input is not mutated. A leaf is returned as it is.
+ */
+export declare function withChildLists(step: Step, lists: readonly Step[][]): Step;
+/** True for the step kinds that hold other steps. */
+export declare const isGroupStep: (step: Step) => step is GroupStep;
+/**
+ * A `sequence` runs its steps one after another and ends when the last one does (format version
+ * 2). On its own at the top level it changes nothing; its point is inside a `parallel` group or a
+ * branch arm, where it lets several steps act as one member, such as intake on, wait, intake off
+ * running alongside a drive.
+ */
+export declare const sequenceStepSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"sequence">;
+    steps: z.ZodArray<z.ZodLazy<z.ZodType<Step, z.ZodTypeDef, Step>>, "many">;
+    notes: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    kind: "sequence";
+    steps: Step[];
+    id?: string | undefined;
+    notes?: string | undefined;
+}, {
+    kind: "sequence";
+    steps: Step[];
+    id?: string | undefined;
+    notes?: string | undefined;
+}>;
+export declare const parallelStepSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"parallel">;
+    mode: z.ZodEnum<["all", "race", "deadline"]>;
+    deadline: z.ZodOptional<z.ZodString>;
+    steps: z.ZodArray<z.ZodLazy<z.ZodType<Step, z.ZodTypeDef, Step>>, "many">;
+    notes: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    kind: "parallel";
+    mode: "all" | "race" | "deadline";
+    steps: Step[];
+    id?: string | undefined;
+    notes?: string | undefined;
+    deadline?: string | undefined;
+}, {
+    kind: "parallel";
+    mode: "all" | "race" | "deadline";
+    steps: Step[];
+    id?: string | undefined;
+    notes?: string | undefined;
+    deadline?: string | undefined;
+}>;
+export declare const branchStepSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"branch">;
+    condition: z.ZodString;
+    then: z.ZodArray<z.ZodLazy<z.ZodType<Step, z.ZodTypeDef, Step>>, "many">;
+    else: z.ZodOptional<z.ZodArray<z.ZodLazy<z.ZodType<Step, z.ZodTypeDef, Step>>, "many">>;
+    notes: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    kind: "branch";
+    condition: string;
+    then: Step[];
+    id?: string | undefined;
+    notes?: string | undefined;
+    else?: Step[] | undefined;
+}, {
+    kind: "branch";
+    condition: string;
+    then: Step[];
+    id?: string | undefined;
+    notes?: string | undefined;
+    else?: Step[] | undefined;
+}>;
+export declare const stepSchema: z.ZodType<Step>;
+/**
+ * `*.auto.json`: one routine. Steps run in sequence (site/docs/file-format.md).
+ * Key declaration order is the canonical file order.
+ */
+export declare const autoSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    formatVersion: z.ZodLiteral<3>;
+    name: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    robot: z.ZodOptional<z.ZodString>;
+    field: z.ZodOptional<z.ZodString>;
+    alliance: z.ZodEnum<["RED", "BLUE"]>;
+    authors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    created: z.ZodOptional<z.ZodString>;
+    start: z.ZodObject<{
+        pose: z.ZodUnion<[z.ZodObject<{
+            ref: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            ref: string;
+        }, {
+            ref: string;
+        }>, z.ZodObject<{
+            xIn: z.ZodNumber;
+            yIn: z.ZodNumber;
+            headingRad: z.ZodOptional<z.ZodNumber>;
+            provenance: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        }, {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        }>]>;
+        holds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        pose: {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        } | {
+            ref: string;
+        };
+        holds?: Record<string, number> | undefined;
+    }, {
+        pose: {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        } | {
+            ref: string;
+        };
+        holds?: Record<string, number> | undefined;
+    }>;
+    steps: z.ZodArray<z.ZodType<Step, z.ZodTypeDef, Step>, "many">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    steps: Step[];
+    formatVersion: 3;
+    alliance: "RED" | "BLUE";
+    start: {
+        pose: {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        } | {
+            ref: string;
+        };
+        holds?: Record<string, number> | undefined;
+    };
+    robot?: string | undefined;
+    field?: string | undefined;
+    $schema?: string | undefined;
+    title?: string | undefined;
+    description?: string | undefined;
+    authors?: string[] | undefined;
+    created?: string | undefined;
+}, {
+    name: string;
+    steps: Step[];
+    formatVersion: 3;
+    alliance: "RED" | "BLUE";
+    start: {
+        pose: {
+            xIn: number;
+            yIn: number;
+            provenance?: string | undefined;
+            headingRad?: number | undefined;
+        } | {
+            ref: string;
+        };
+        holds?: Record<string, number> | undefined;
+    };
+    robot?: string | undefined;
+    field?: string | undefined;
+    $schema?: string | undefined;
+    title?: string | undefined;
+    description?: string | undefined;
+    authors?: string[] | undefined;
+    created?: string | undefined;
+}>;
+export type LineSegment = z.infer<typeof lineSegmentSchema>;
+export type BezierSegment = z.infer<typeof bezierSegmentSchema>;
+export type Segment = z.infer<typeof segmentSchema>;
+export type Heading = z.infer<typeof headingSchema>;
+export type HeadingMode = Heading["mode"];
+export type RangeHeading = z.infer<typeof rangeHeadingSchema>;
+export type HeadingRange = z.infer<typeof headingRangeSchema>;
+export type MarkerAt = z.infer<typeof markerAtSchema>;
+export type Marker = z.infer<typeof markerSchema>;
+export type CommandCall = z.infer<typeof commandCallSchema>;
+export type Expect = z.infer<typeof expectSchema>;
+export type Auto = z.infer<typeof autoSchema>;
+//# sourceMappingURL=auto.d.ts.map