@engenty/wizards-runtime 0.0.0-stage → 0.7.5

package/node_modules/@engenty-wizards/shared/dist/definition.d.ts

@@ -0,0 +1,2922 @@
+import { z } from "zod";
+import { type ObjectShape } from "./shape.js";
+import { type SurfaceComponent } from "./surface.js";
+/** The engenty avatars a wizard can wear. Same cast as engenty's ui-core. */
+export declare const ENGENTY_KINDS: readonly ["round", "drop", "dome", "flame", "oval", "bean", "pebble", "sprout", "tower", "wedge"];
+export type EngentyKind = (typeof ENGENTY_KINDS)[number];
+/**
+ * The languages engenty speaks: the studio, the runner, the mails, a wizard's own words. A
+ * language joins once its strings are written; English is the one every string has, and what a
+ * language still lacks is said in English.
+ */
+export declare const LANGS: readonly ["en", "de"];
+export type Lang = (typeof LANGS)[number];
+/** Each language's name, in that language: what a switch or a menu shows. */
+export declare const LANG_NAMES: Record<Lang, string>;
+/** The locale amounts and dates are written in for a language. */
+export declare const LOCALES: Record<Lang, string>;
+/** The locale speech is heard and spoken in for a language (recognition, voices). */
+export declare const SPEECH_LOCALES: Record<Lang, string>;
+export declare function isLang(value: unknown): value is Lang;
+/** The language of a tag such as "de-AT", "fr" or "pt_BR", where engenty speaks it. */
+export declare function langOf(tag: string | null | undefined): Lang | null;
+/**
+ * The languages a wizard is offered in when its author picks one: English, German and the main
+ * languages of Europe. A wizard may name any other real language by its code as well.
+ */
+export declare const WIZARD_LANGS: readonly string[];
+/**
+ * The person's own language beside English: the first of their languages (the browser's, in
+ * its order) that engenty speaks, else the main language of the country their time zone lies
+ * in; null where neither names one.
+ */
+export declare function localLang(languages: readonly string[], timeZone?: string | null): Lang | null;
+/**
+ * A language a wizard can be translated into: any language, by its two- or three-letter code
+ * ("fr", "it", "pl"), not only those of `LANGS`.
+ */
+export declare const LANG_CODE: RegExp;
+/** The code of a tag such as "fr-CA" or "pt_BR"; null where it names no language. */
+export declare function langCodeOf(tag: string | null | undefined): string | null;
+/**
+ * A real language, as the platform's own language data knows it: "it" and "nb" are, "xx" is
+ * not. The schema only checks the shape of a code; this checks that it names a language.
+ */
+export declare function isRealLanguage(code: string): boolean;
+/** The language engenty's own strings are read in for any language: itself where they are written, else English. */
+export declare function textLang(code: string): Lang;
+/**
+ * The language the person reads, for a wizard translated on request: the first of their
+ * languages (the browser's, in its order), else the main language of the country their time
+ * zone lies in. Any language, not only one engenty's own strings are written in.
+ */
+export declare function viewerLang(languages: readonly string[], timeZone?: string | null): string | null;
+/** A language's name in that language, as a switch shows it: "Italiano", "Polski". */
+export declare function langName(code: string): string;
+/** A language's name in English, for a model told what to write in: "Italian". */
+export declare function langNameEn(code: string): string;
+/** The locale amounts, dates and plural forms are written in for any language. */
+export declare function localeOf(code: string): string;
+/** The locale speech is recognised and read aloud in for any language. */
+export declare function speechLocaleOf(code: string): string;
+export declare const FIELD_KINDS: readonly ["text", "textarea", "number", "select", "multiselect", "date", "email", "url", "toggle", "color", "image", "file", "items", "connection", "list", "location", "audio", "signature", "slot"];
+export type FieldKind = (typeof FIELD_KINDS)[number];
+/**
+ * How a field is answered without the page's form: `typed` as text, `tapped` from its choices,
+ * `value` as a plain value (a colour, line items, a place), `device` only with the person's
+ * device or account (a file, a recording, a signature, a connection, a kept list). The chat
+ * types and taps; an AI client over MCP gives every way but `device`.
+ */
+export type FieldWay = "typed" | "tapped" | "value" | "device";
+export declare const FIELD_WAYS: Record<FieldKind, FieldWay>;
+/**
+ * What a `location` field holds: where the person stands (from the device), a place they typed,
+ * or both — the label is then the address of the position.
+ */
+export interface LocationValue {
+    lat?: number;
+    lng?: number;
+    /** Radius in metres the device vouches for. */
+    accuracy?: number;
+    label?: string;
+}
+/** What an `audio` field holds: the recording, and what is said in it once it was listened to. */
+export interface AudioValue {
+    /** Upload id of the recording. */
+    asset: string;
+    seconds?: number;
+    transcript?: string;
+    /** The language the runner was in when the note was taken: what it is most likely spoken in. */
+    lang?: Lang;
+}
+export declare function isLocationValue(v: unknown): v is LocationValue;
+export declare function isAudioValue(v: unknown): v is AudioValue;
+/** A position the way a person reads it: "Hauptplatz 1, Graz (47.07071, 15.43950, ±12 m)". */
+export declare function locationText(v: LocationValue): string;
+/** A field takes at most this many files. */
+export declare const MAX_FILES = 30;
+export declare const TOOL_IDS: readonly ["web_search", "web_fetch", "browser", "sandbox", "image", "http", "pages"];
+/**
+ * A tool a plugin of the runtime adds: `<plugin id>.<tool name>`. A wizard that names one runs
+ * only where that plugin is installed.
+ */
+export declare const PLUGIN_ID: RegExp;
+export declare const PLUGIN_TOOL_NAME: RegExp;
+export type PluginToolId = `${string}.${string}`;
+/** The plugin and the tool a step's tool id names, or null for one of the built-in tools. */
+export declare function pluginToolOf(id: string): {
+    plugin: string;
+    tool: string;
+} | null;
+/**
+ * The kinds of model a step can ask for. A step names a class; which model serves it is bound
+ * outside the wizard (the model-gateway, or the settings of a runtime that runs alone).
+ */
+export declare const TEXT_CLASSES: readonly ["classifier", "standard", "high", "highest"];
+export type TextClass = (typeof TEXT_CLASSES)[number];
+export declare const MODEL_CLASSES: readonly ["classifier", "standard", "high", "highest", "image", "video", "audio", "speech"];
+export type ModelClass = (typeof MODEL_CLASSES)[number];
+/** How hard the model should think, where the bound model can be told. */
+export declare const EFFORTS: readonly ["low", "medium", "high"];
+export type Effort = (typeof EFFORTS)[number];
+export type ToolId = (typeof TOOL_IDS)[number];
+export declare const ASSET_KINDS: readonly ["image", "video", "voice", "document", "dashboard"];
+export type AssetKind = (typeof ASSET_KINDS)[number];
+export declare const FORMATS: readonly ["png", "mp4", "mp3", "pdf", "docx", "html", "md", "txt", "csv", "xlsx", "json", "zip"];
+export type Format = (typeof FORMATS)[number];
+export declare const ASPECT_RATIOS: readonly ["1:1", "16:9", "9:16", "4:5", "3:2", "2:3"];
+/** What a video model renders at: 720p unless the step asks for less. Never more. */
+export declare const VIDEO_RESOLUTIONS: readonly ["720p", "480p"];
+export type VideoResolution = (typeof VIDEO_RESOLUTIONS)[number];
+export declare const itemColumnSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    kind: z.ZodEnum<{
+        money: "money";
+        number: "number";
+        text: "text";
+    }>;
+}, z.core.$strip>;
+export declare const CONDITION_OPS: readonly ["equals", "notEquals", "in", "notEmpty", "empty", "gt", "lt", "contains"];
+export type ConditionOp = (typeof CONDITION_OPS)[number];
+/**
+ * One test on what the run knows: an answer by field id, an output of an agent step as
+ * "steps.<step>.<field>", or how many rows a stored list has as "lists.<list>.count".
+ */
+export declare const conditionSchema: z.ZodObject<{
+    field: z.ZodString;
+    op: z.ZodEnum<{
+        contains: "contains";
+        empty: "empty";
+        equals: "equals";
+        gt: "gt";
+        in: "in";
+        lt: "lt";
+        notEmpty: "notEmpty";
+        notEquals: "notEquals";
+    }>;
+    value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+}, z.core.$strip>;
+export type Condition = z.infer<typeof conditionSchema>;
+/** One condition, or several that must all hold. */
+export declare const whenSchema: z.ZodUnion<readonly [z.ZodObject<{
+    field: z.ZodString;
+    op: z.ZodEnum<{
+        contains: "contains";
+        empty: "empty";
+        equals: "equals";
+        gt: "gt";
+        in: "in";
+        lt: "lt";
+        notEmpty: "notEmpty";
+        notEquals: "notEquals";
+    }>;
+    value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+}, z.core.$strip>, z.ZodArray<z.ZodObject<{
+    field: z.ZodString;
+    op: z.ZodEnum<{
+        contains: "contains";
+        empty: "empty";
+        equals: "equals";
+        gt: "gt";
+        in: "in";
+        lt: "lt";
+        notEmpty: "notEmpty";
+        notEquals: "notEquals";
+    }>;
+    value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+}, z.core.$strip>>]>;
+export type When = z.infer<typeof whenSchema>;
+/** What a card of a choice shows: the columns of the table the choices come from. */
+export declare const cardsSchema: z.ZodObject<{
+    label: z.ZodString;
+    value: z.ZodOptional<z.ZodString>;
+    image: z.ZodOptional<z.ZodString>;
+    subtitle: z.ZodOptional<z.ZodString>;
+    meta: z.ZodOptional<z.ZodString>;
+    link: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CardsDef = z.infer<typeof cardsSchema>;
+/** A choice drawn as a card, as the runner gets it. */
+export interface CardOption {
+    value: string;
+    label: string;
+    image?: string;
+    subtitle?: string;
+    meta?: string;
+    link?: string;
+}
+export declare const fieldSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    kind: z.ZodEnum<{
+        audio: "audio";
+        color: "color";
+        connection: "connection";
+        date: "date";
+        email: "email";
+        file: "file";
+        image: "image";
+        items: "items";
+        list: "list";
+        location: "location";
+        multiselect: "multiselect";
+        number: "number";
+        select: "select";
+        signature: "signature";
+        slot: "slot";
+        text: "text";
+        textarea: "textarea";
+        toggle: "toggle";
+        url: "url";
+    }>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    help: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    columns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        kind: z.ZodEnum<{
+            money: "money";
+            number: "number";
+            text: "text";
+        }>;
+    }, z.core.$strip>>>;
+    vat: z.ZodOptional<z.ZodObject<{
+        rate: z.ZodOptional<z.ZodNumber>;
+        field: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    currency: z.ZodOptional<z.ZodString>;
+    multiple: z.ZodOptional<z.ZodBoolean>;
+    min: z.ZodOptional<z.ZodNumber>;
+    max: z.ZodOptional<z.ZodNumber>;
+    camera: z.ZodOptional<z.ZodBoolean>;
+    video: z.ZodOptional<z.ZodBoolean>;
+    listen: z.ZodOptional<z.ZodBoolean>;
+    scan: z.ZodOptional<z.ZodBoolean>;
+    connection: z.ZodOptional<z.ZodString>;
+    list: z.ZodOptional<z.ZodString>;
+    prefill: z.ZodOptional<z.ZodString>;
+    when: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        field: z.ZodString;
+        op: z.ZodEnum<{
+            contains: "contains";
+            empty: "empty";
+            equals: "equals";
+            gt: "gt";
+            in: "in";
+            lt: "lt";
+            notEmpty: "notEmpty";
+            notEquals: "notEquals";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        op: z.ZodEnum<{
+            contains: "contains";
+            empty: "empty";
+            equals: "equals";
+            gt: "gt";
+            in: "in";
+            lt: "lt";
+            notEmpty: "notEmpty";
+            notEquals: "notEquals";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strip>>]>>;
+    optionsFrom: z.ZodOptional<z.ZodString>;
+    cards: z.ZodOptional<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodOptional<z.ZodString>;
+        image: z.ZodOptional<z.ZodString>;
+        subtitle: z.ZodOptional<z.ZodString>;
+        meta: z.ZodOptional<z.ZodString>;
+        link: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    ask: z.ZodOptional<z.ZodString>;
+    group: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type Field = z.infer<typeof fieldSchema>;
+export declare const fieldGroupSchema: z.ZodObject<{
+    id: z.ZodString;
+    instructions: z.ZodString;
+    optional: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const nextRuleSchema: z.ZodObject<{
+    when: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        field: z.ZodString;
+        op: z.ZodEnum<{
+            contains: "contains";
+            empty: "empty";
+            equals: "equals";
+            gt: "gt";
+            in: "in";
+            lt: "lt";
+            notEmpty: "notEmpty";
+            notEquals: "notEquals";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        op: z.ZodEnum<{
+            contains: "contains";
+            empty: "empty";
+            equals: "equals";
+            gt: "gt";
+            in: "in";
+            lt: "lt";
+            notEmpty: "notEmpty";
+            notEquals: "notEquals";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strip>>]>>;
+    ask: z.ZodOptional<z.ZodString>;
+    goto: z.ZodString;
+    max: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type NextRule = z.infer<typeof nextRuleSchema>;
+export declare const outputFieldSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        choice: "choice";
+        list: "list";
+        number: "number";
+        score: "score";
+        table: "table";
+        text: "text";
+        yesno: "yesno";
+    }>;
+    description: z.ZodOptional<z.ZodString>;
+    columns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const pageStepSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    next: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        when: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>>]>>;
+        ask: z.ZodOptional<z.ZodString>;
+        goto: z.ZodString;
+        max: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    type: z.ZodLiteral<"page">;
+    fields: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        kind: z.ZodEnum<{
+            audio: "audio";
+            color: "color";
+            connection: "connection";
+            date: "date";
+            email: "email";
+            file: "file";
+            image: "image";
+            items: "items";
+            list: "list";
+            location: "location";
+            multiselect: "multiselect";
+            number: "number";
+            select: "select";
+            signature: "signature";
+            slot: "slot";
+            text: "text";
+            textarea: "textarea";
+            toggle: "toggle";
+            url: "url";
+        }>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        placeholder: z.ZodOptional<z.ZodString>;
+        help: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        columns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            kind: z.ZodEnum<{
+                money: "money";
+                number: "number";
+                text: "text";
+            }>;
+        }, z.core.$strip>>>;
+        vat: z.ZodOptional<z.ZodObject<{
+            rate: z.ZodOptional<z.ZodNumber>;
+            field: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        currency: z.ZodOptional<z.ZodString>;
+        multiple: z.ZodOptional<z.ZodBoolean>;
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+        camera: z.ZodOptional<z.ZodBoolean>;
+        video: z.ZodOptional<z.ZodBoolean>;
+        listen: z.ZodOptional<z.ZodBoolean>;
+        scan: z.ZodOptional<z.ZodBoolean>;
+        connection: z.ZodOptional<z.ZodString>;
+        list: z.ZodOptional<z.ZodString>;
+        prefill: z.ZodOptional<z.ZodString>;
+        when: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>>]>>;
+        optionsFrom: z.ZodOptional<z.ZodString>;
+        cards: z.ZodOptional<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodOptional<z.ZodString>;
+            image: z.ZodOptional<z.ZodString>;
+            subtitle: z.ZodOptional<z.ZodString>;
+            meta: z.ZodOptional<z.ZodString>;
+            link: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        ask: z.ZodOptional<z.ZodString>;
+        group: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    groups: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        instructions: z.ZodString;
+        optional: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    cta: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const agentStepSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    next: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        when: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>>]>>;
+        ask: z.ZodOptional<z.ZodString>;
+        goto: z.ZodString;
+        max: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    type: z.ZodLiteral<"agent">;
+    instructions: z.ZodDefault<z.ZodString>;
+    call: z.ZodOptional<z.ZodObject<{
+        tool: z.ZodTemplateLiteral<`${string}.${string}`>;
+        input: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    tools: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+        browser: "browser";
+        http: "http";
+        image: "image";
+        pages: "pages";
+        sandbox: "sandbox";
+        web_fetch: "web_fetch";
+        web_search: "web_search";
+    }>, z.ZodTemplateLiteral<`${string}.${string}`>]>>>;
+    mcp: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    connections: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    output: z.ZodDefault<z.ZodObject<{
+        format: z.ZodEnum<{
+            json: "json";
+            markdown: "markdown";
+            text: "text";
+        }>;
+        fields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                choice: "choice";
+                list: "list";
+                number: "number";
+                score: "score";
+                table: "table";
+                text: "text";
+                yesno: "yesno";
+            }>;
+            description: z.ZodOptional<z.ZodString>;
+            columns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        schema: z.ZodOptional<z.ZodType<ObjectShape, unknown, z.core.$ZodTypeInternals<ObjectShape, unknown>>>;
+        surface: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            component: z.ZodEnum<{
+                Actions: "Actions";
+                Badge: "Badge";
+                BarChart: "BarChart";
+                Button: "Button";
+                Callout: "Callout";
+                Card: "Card";
+                Checklist: "Checklist";
+                Chips: "Chips";
+                Column: "Column";
+                DetailGrid: "DetailGrid";
+                DonutChart: "DonutChart";
+                Fold: "Fold";
+                Grid: "Grid";
+                Group: "Group";
+                Image: "Image";
+                LineChart: "LineChart";
+                Link: "Link";
+                List: "List";
+                Metric: "Metric";
+                Row: "Row";
+                Steps: "Steps";
+                Table: "Table";
+                Tabs: "Tabs";
+                Text: "Text";
+            }>;
+            children: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+                path: z.ZodString;
+                componentId: z.ZodString;
+            }, z.core.$strip>]>>;
+        }, z.core.$loose>>]>>;
+    }, z.core.$strip>>;
+    model: z.ZodOptional<z.ZodEnum<{
+        classifier: "classifier";
+        high: "high";
+        highest: "highest";
+        standard: "standard";
+    }>>;
+    effort: z.ZodOptional<z.ZodEnum<{
+        high: "high";
+        low: "low";
+        medium: "medium";
+    }>>;
+    each: z.ZodOptional<z.ZodString>;
+    working: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const generateStepSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    next: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        when: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>>]>>;
+        ask: z.ZodOptional<z.ZodString>;
+        goto: z.ZodString;
+        max: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    type: z.ZodLiteral<"generate">;
+    asset: z.ZodEnum<{
+        dashboard: "dashboard";
+        document: "document";
+        image: "image";
+        video: "video";
+        voice: "voice";
+    }>;
+    prompt: z.ZodString;
+    options: z.ZodOptional<z.ZodObject<{
+        aspectRatio: z.ZodOptional<z.ZodEnum<{
+            "16:9": "16:9";
+            "1:1": "1:1";
+            "2:3": "2:3";
+            "3:2": "3:2";
+            "4:5": "4:5";
+            "9:16": "9:16";
+        }>>;
+        duration: z.ZodOptional<z.ZodNumber>;
+        resolution: z.ZodOptional<z.ZodEnum<{
+            "480p": "480p";
+            "720p": "720p";
+        }>>;
+        style: z.ZodOptional<z.ZodString>;
+        template: z.ZodOptional<z.ZodEnum<{
+            briefing: "briefing";
+            free: "free";
+            invoice: "invoice";
+            letter: "letter";
+            offer: "offer";
+            report: "report";
+        }>>;
+    }, z.core.$strip>>;
+    referenceImage: z.ZodOptional<z.ZodString>;
+    each: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodEnum<{
+        classifier: "classifier";
+        high: "high";
+        highest: "highest";
+        standard: "standard";
+    }>>;
+    effort: z.ZodOptional<z.ZodEnum<{
+        high: "high";
+        low: "low";
+        medium: "medium";
+    }>>;
+    working: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const widgetStepSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    next: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        when: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>>]>>;
+        ask: z.ZodOptional<z.ZodString>;
+        goto: z.ZodString;
+        max: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    type: z.ZodLiteral<"widget">;
+    entry: z.ZodString;
+    data: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    sample: z.ZodOptional<z.ZodString>;
+    layout: z.ZodOptional<z.ZodEnum<{
+        fixed: "fixed";
+        page: "page";
+    }>>;
+    size: z.ZodOptional<z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>>;
+    video: z.ZodOptional<z.ZodBoolean>;
+    working: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Formats a film step makes; the composition is drawn for this frame. */
+export declare const FILM_FORMATS: readonly ["16:9", "9:16", "1:1"];
+export type FilmFormat = (typeof FILM_FORMATS)[number];
+export declare const FILM_SIZES: Record<FilmFormat, {
+    width: number;
+    height: number;
+}>;
+/**
+ * A film the AI client installed on this machine makes in a folder of its own: it writes the
+ * composition as code (HTML, CSS, JS) with the skills it is given, looks at its frames and fixes
+ * them; the runtime renders the MP4. It runs on the person's subscription, never on credits.
+ */
+export declare const filmStepSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    next: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        when: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>>]>>;
+        ask: z.ZodOptional<z.ZodString>;
+        goto: z.ZodString;
+        max: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    type: z.ZodLiteral<"film">;
+    brief: z.ZodString;
+    skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    kit: z.ZodOptional<z.ZodString>;
+    inputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    format: z.ZodDefault<z.ZodEnum<{
+        "16:9": "16:9";
+        "1:1": "1:1";
+        "9:16": "9:16";
+    }>>;
+    seconds: z.ZodOptional<z.ZodNumber>;
+    model: z.ZodOptional<z.ZodEnum<{
+        classifier: "classifier";
+        high: "high";
+        highest: "highest";
+        standard: "standard";
+    }>>;
+    effort: z.ZodOptional<z.ZodEnum<{
+        high: "high";
+        low: "low";
+        medium: "medium";
+    }>>;
+    working: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** A piece a decided surface may show: its components (the first has the piece's id) and what it shows. */
+export declare const surfaceCandidateSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    components: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        component: z.ZodEnum<{
+            Actions: "Actions";
+            Badge: "Badge";
+            BarChart: "BarChart";
+            Button: "Button";
+            Callout: "Callout";
+            Card: "Card";
+            Checklist: "Checklist";
+            Chips: "Chips";
+            Column: "Column";
+            DetailGrid: "DetailGrid";
+            DonutChart: "DonutChart";
+            Fold: "Fold";
+            Grid: "Grid";
+            Group: "Group";
+            Image: "Image";
+            LineChart: "LineChart";
+            Link: "Link";
+            List: "List";
+            Metric: "Metric";
+            Row: "Row";
+            Steps: "Steps";
+            Table: "Table";
+            Tabs: "Tabs";
+            Text: "Text";
+        }>;
+        children: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+            path: z.ZodString;
+            componentId: z.ZodString;
+        }, z.core.$strip>]>>;
+    }, z.core.$loose>>;
+    group: z.ZodOptional<z.ZodString>;
+    required: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const surfaceStepSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    next: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        when: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>>]>>;
+        ask: z.ZodOptional<z.ZodString>;
+        goto: z.ZodString;
+        max: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    type: z.ZodLiteral<"surface">;
+    components: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        component: z.ZodEnum<{
+            Actions: "Actions";
+            Badge: "Badge";
+            BarChart: "BarChart";
+            Button: "Button";
+            Callout: "Callout";
+            Card: "Card";
+            Checklist: "Checklist";
+            Chips: "Chips";
+            Column: "Column";
+            DetailGrid: "DetailGrid";
+            DonutChart: "DonutChart";
+            Fold: "Fold";
+            Grid: "Grid";
+            Group: "Group";
+            Image: "Image";
+            LineChart: "LineChart";
+            Link: "Link";
+            List: "List";
+            Metric: "Metric";
+            Row: "Row";
+            Steps: "Steps";
+            Table: "Table";
+            Tabs: "Tabs";
+            Text: "Text";
+        }>;
+        children: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+            path: z.ZodString;
+            componentId: z.ZodString;
+        }, z.core.$strip>]>>;
+    }, z.core.$loose>>>;
+    candidates: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        components: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            component: z.ZodEnum<{
+                Actions: "Actions";
+                Badge: "Badge";
+                BarChart: "BarChart";
+                Button: "Button";
+                Callout: "Callout";
+                Card: "Card";
+                Checklist: "Checklist";
+                Chips: "Chips";
+                Column: "Column";
+                DetailGrid: "DetailGrid";
+                DonutChart: "DonutChart";
+                Fold: "Fold";
+                Grid: "Grid";
+                Group: "Group";
+                Image: "Image";
+                LineChart: "LineChart";
+                Link: "Link";
+                List: "List";
+                Metric: "Metric";
+                Row: "Row";
+                Steps: "Steps";
+                Table: "Table";
+                Tabs: "Tabs";
+                Text: "Text";
+            }>;
+            children: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+                path: z.ZodString;
+                componentId: z.ZodString;
+            }, z.core.$strip>]>>;
+        }, z.core.$loose>>;
+        group: z.ZodOptional<z.ZodString>;
+        required: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    groups: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        instructions: z.ZodString;
+        optional: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    data: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    working: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * The components of a decided surface for the pieces kept: one root column holding them in
+ * their order. Every piece kept is the same as all of them for the validator.
+ */
+export declare function assembleSurface(candidates: {
+    id: string;
+    components: SurfaceComponent[];
+}[], kept: Iterable<string>): SurfaceComponent[];
+export declare const reviewStepSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    next: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        when: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>>]>>;
+        ask: z.ZodOptional<z.ZodString>;
+        goto: z.ZodString;
+        max: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    type: z.ZodLiteral<"review">;
+    show: z.ZodArray<z.ZodString>;
+    edit: z.ZodOptional<z.ZodBoolean>;
+    regenerate: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const deliverableSchema: z.ZodObject<{
+    from: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    formats: z.ZodArray<z.ZodEnum<{
+        csv: "csv";
+        docx: "docx";
+        html: "html";
+        json: "json";
+        md: "md";
+        mp3: "mp3";
+        mp4: "mp4";
+        pdf: "pdf";
+        png: "png";
+        txt: "txt";
+        xlsx: "xlsx";
+        zip: "zip";
+    }>>;
+}, z.core.$strip>;
+export declare const resultStepSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    next: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        when: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>>]>>;
+        ask: z.ZodOptional<z.ZodString>;
+        goto: z.ZodString;
+        max: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    type: z.ZodLiteral<"result">;
+    message: z.ZodOptional<z.ZodString>;
+    deliverables: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        formats: z.ZodArray<z.ZodEnum<{
+            csv: "csv";
+            docx: "docx";
+            html: "html";
+            json: "json";
+            md: "md";
+            mp3: "mp3";
+            mp4: "mp4";
+            pdf: "pdf";
+            png: "png";
+            txt: "txt";
+            xlsx: "xlsx";
+            zip: "zip";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const stepSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    next: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        when: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>>]>>;
+        ask: z.ZodOptional<z.ZodString>;
+        goto: z.ZodString;
+        max: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    type: z.ZodLiteral<"page">;
+    fields: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        kind: z.ZodEnum<{
+            audio: "audio";
+            color: "color";
+            connection: "connection";
+            date: "date";
+            email: "email";
+            file: "file";
+            image: "image";
+            items: "items";
+            list: "list";
+            location: "location";
+            multiselect: "multiselect";
+            number: "number";
+            select: "select";
+            signature: "signature";
+            slot: "slot";
+            text: "text";
+            textarea: "textarea";
+            toggle: "toggle";
+            url: "url";
+        }>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        placeholder: z.ZodOptional<z.ZodString>;
+        help: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        columns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            kind: z.ZodEnum<{
+                money: "money";
+                number: "number";
+                text: "text";
+            }>;
+        }, z.core.$strip>>>;
+        vat: z.ZodOptional<z.ZodObject<{
+            rate: z.ZodOptional<z.ZodNumber>;
+            field: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        currency: z.ZodOptional<z.ZodString>;
+        multiple: z.ZodOptional<z.ZodBoolean>;
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+        camera: z.ZodOptional<z.ZodBoolean>;
+        video: z.ZodOptional<z.ZodBoolean>;
+        listen: z.ZodOptional<z.ZodBoolean>;
+        scan: z.ZodOptional<z.ZodBoolean>;
+        connection: z.ZodOptional<z.ZodString>;
+        list: z.ZodOptional<z.ZodString>;
+        prefill: z.ZodOptional<z.ZodString>;
+        when: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>>]>>;
+        optionsFrom: z.ZodOptional<z.ZodString>;
+        cards: z.ZodOptional<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodOptional<z.ZodString>;
+            image: z.ZodOptional<z.ZodString>;
+            subtitle: z.ZodOptional<z.ZodString>;
+            meta: z.ZodOptional<z.ZodString>;
+            link: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        ask: z.ZodOptional<z.ZodString>;
+        group: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    groups: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        instructions: z.ZodString;
+        optional: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    cta: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    next: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        when: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>>]>>;
+        ask: z.ZodOptional<z.ZodString>;
+        goto: z.ZodString;
+        max: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    type: z.ZodLiteral<"agent">;
+    instructions: z.ZodDefault<z.ZodString>;
+    call: z.ZodOptional<z.ZodObject<{
+        tool: z.ZodTemplateLiteral<`${string}.${string}`>;
+        input: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    tools: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+        browser: "browser";
+        http: "http";
+        image: "image";
+        pages: "pages";
+        sandbox: "sandbox";
+        web_fetch: "web_fetch";
+        web_search: "web_search";
+    }>, z.ZodTemplateLiteral<`${string}.${string}`>]>>>;
+    mcp: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    connections: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    output: z.ZodDefault<z.ZodObject<{
+        format: z.ZodEnum<{
+            json: "json";
+            markdown: "markdown";
+            text: "text";
+        }>;
+        fields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                choice: "choice";
+                list: "list";
+                number: "number";
+                score: "score";
+                table: "table";
+                text: "text";
+                yesno: "yesno";
+            }>;
+            description: z.ZodOptional<z.ZodString>;
+            columns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        schema: z.ZodOptional<z.ZodType<ObjectShape, unknown, z.core.$ZodTypeInternals<ObjectShape, unknown>>>;
+        surface: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            component: z.ZodEnum<{
+                Actions: "Actions";
+                Badge: "Badge";
+                BarChart: "BarChart";
+                Button: "Button";
+                Callout: "Callout";
+                Card: "Card";
+                Checklist: "Checklist";
+                Chips: "Chips";
+                Column: "Column";
+                DetailGrid: "DetailGrid";
+                DonutChart: "DonutChart";
+                Fold: "Fold";
+                Grid: "Grid";
+                Group: "Group";
+                Image: "Image";
+                LineChart: "LineChart";
+                Link: "Link";
+                List: "List";
+                Metric: "Metric";
+                Row: "Row";
+                Steps: "Steps";
+                Table: "Table";
+                Tabs: "Tabs";
+                Text: "Text";
+            }>;
+            children: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+                path: z.ZodString;
+                componentId: z.ZodString;
+            }, z.core.$strip>]>>;
+        }, z.core.$loose>>]>>;
+    }, z.core.$strip>>;
+    model: z.ZodOptional<z.ZodEnum<{
+        classifier: "classifier";
+        high: "high";
+        highest: "highest";
+        standard: "standard";
+    }>>;
+    effort: z.ZodOptional<z.ZodEnum<{
+        high: "high";
+        low: "low";
+        medium: "medium";
+    }>>;
+    each: z.ZodOptional<z.ZodString>;
+    working: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    next: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        when: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>>]>>;
+        ask: z.ZodOptional<z.ZodString>;
+        goto: z.ZodString;
+        max: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    type: z.ZodLiteral<"generate">;
+    asset: z.ZodEnum<{
+        dashboard: "dashboard";
+        document: "document";
+        image: "image";
+        video: "video";
+        voice: "voice";
+    }>;
+    prompt: z.ZodString;
+    options: z.ZodOptional<z.ZodObject<{
+        aspectRatio: z.ZodOptional<z.ZodEnum<{
+            "16:9": "16:9";
+            "1:1": "1:1";
+            "2:3": "2:3";
+            "3:2": "3:2";
+            "4:5": "4:5";
+            "9:16": "9:16";
+        }>>;
+        duration: z.ZodOptional<z.ZodNumber>;
+        resolution: z.ZodOptional<z.ZodEnum<{
+            "480p": "480p";
+            "720p": "720p";
+        }>>;
+        style: z.ZodOptional<z.ZodString>;
+        template: z.ZodOptional<z.ZodEnum<{
+            briefing: "briefing";
+            free: "free";
+            invoice: "invoice";
+            letter: "letter";
+            offer: "offer";
+            report: "report";
+        }>>;
+    }, z.core.$strip>>;
+    referenceImage: z.ZodOptional<z.ZodString>;
+    each: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodEnum<{
+        classifier: "classifier";
+        high: "high";
+        highest: "highest";
+        standard: "standard";
+    }>>;
+    effort: z.ZodOptional<z.ZodEnum<{
+        high: "high";
+        low: "low";
+        medium: "medium";
+    }>>;
+    working: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    next: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        when: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>>]>>;
+        ask: z.ZodOptional<z.ZodString>;
+        goto: z.ZodString;
+        max: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    type: z.ZodLiteral<"widget">;
+    entry: z.ZodString;
+    data: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    sample: z.ZodOptional<z.ZodString>;
+    layout: z.ZodOptional<z.ZodEnum<{
+        fixed: "fixed";
+        page: "page";
+    }>>;
+    size: z.ZodOptional<z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>>;
+    video: z.ZodOptional<z.ZodBoolean>;
+    working: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    next: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        when: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>>]>>;
+        ask: z.ZodOptional<z.ZodString>;
+        goto: z.ZodString;
+        max: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    type: z.ZodLiteral<"surface">;
+    components: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        component: z.ZodEnum<{
+            Actions: "Actions";
+            Badge: "Badge";
+            BarChart: "BarChart";
+            Button: "Button";
+            Callout: "Callout";
+            Card: "Card";
+            Checklist: "Checklist";
+            Chips: "Chips";
+            Column: "Column";
+            DetailGrid: "DetailGrid";
+            DonutChart: "DonutChart";
+            Fold: "Fold";
+            Grid: "Grid";
+            Group: "Group";
+            Image: "Image";
+            LineChart: "LineChart";
+            Link: "Link";
+            List: "List";
+            Metric: "Metric";
+            Row: "Row";
+            Steps: "Steps";
+            Table: "Table";
+            Tabs: "Tabs";
+            Text: "Text";
+        }>;
+        children: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+            path: z.ZodString;
+            componentId: z.ZodString;
+        }, z.core.$strip>]>>;
+    }, z.core.$loose>>>;
+    candidates: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        components: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            component: z.ZodEnum<{
+                Actions: "Actions";
+                Badge: "Badge";
+                BarChart: "BarChart";
+                Button: "Button";
+                Callout: "Callout";
+                Card: "Card";
+                Checklist: "Checklist";
+                Chips: "Chips";
+                Column: "Column";
+                DetailGrid: "DetailGrid";
+                DonutChart: "DonutChart";
+                Fold: "Fold";
+                Grid: "Grid";
+                Group: "Group";
+                Image: "Image";
+                LineChart: "LineChart";
+                Link: "Link";
+                List: "List";
+                Metric: "Metric";
+                Row: "Row";
+                Steps: "Steps";
+                Table: "Table";
+                Tabs: "Tabs";
+                Text: "Text";
+            }>;
+            children: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+                path: z.ZodString;
+                componentId: z.ZodString;
+            }, z.core.$strip>]>>;
+        }, z.core.$loose>>;
+        group: z.ZodOptional<z.ZodString>;
+        required: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    groups: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        instructions: z.ZodString;
+        optional: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    data: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    working: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    next: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        when: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>>]>>;
+        ask: z.ZodOptional<z.ZodString>;
+        goto: z.ZodString;
+        max: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    type: z.ZodLiteral<"film">;
+    brief: z.ZodString;
+    skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    kit: z.ZodOptional<z.ZodString>;
+    inputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    format: z.ZodDefault<z.ZodEnum<{
+        "16:9": "16:9";
+        "1:1": "1:1";
+        "9:16": "9:16";
+    }>>;
+    seconds: z.ZodOptional<z.ZodNumber>;
+    model: z.ZodOptional<z.ZodEnum<{
+        classifier: "classifier";
+        high: "high";
+        highest: "highest";
+        standard: "standard";
+    }>>;
+    effort: z.ZodOptional<z.ZodEnum<{
+        high: "high";
+        low: "low";
+        medium: "medium";
+    }>>;
+    working: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    next: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        when: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>>]>>;
+        ask: z.ZodOptional<z.ZodString>;
+        goto: z.ZodString;
+        max: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    type: z.ZodLiteral<"review">;
+    show: z.ZodArray<z.ZodString>;
+    edit: z.ZodOptional<z.ZodBoolean>;
+    regenerate: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    next: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        when: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                empty: "empty";
+                equals: "equals";
+                gt: "gt";
+                in: "in";
+                lt: "lt";
+                notEmpty: "notEmpty";
+                notEquals: "notEquals";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>>]>>;
+        ask: z.ZodOptional<z.ZodString>;
+        goto: z.ZodString;
+        max: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    type: z.ZodLiteral<"result">;
+    message: z.ZodOptional<z.ZodString>;
+    deliverables: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        formats: z.ZodArray<z.ZodEnum<{
+            csv: "csv";
+            docx: "docx";
+            html: "html";
+            json: "json";
+            md: "md";
+            mp3: "mp3";
+            mp4: "mp4";
+            pdf: "pdf";
+            png: "png";
+            txt: "txt";
+            xlsx: "xlsx";
+            zip: "zip";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>], "type">;
+export type Step = z.infer<typeof stepSchema>;
+export type PageStep = z.infer<typeof pageStepSchema>;
+export type SurfaceStep = z.infer<typeof surfaceStepSchema>;
+export type AgentStep = z.infer<typeof agentStepSchema>;
+/**
+ * A decision: a step on the classifier class that uses no tools and whose output is only
+ * yes/no and choice fields. It is answered in one call, which a model that only decides
+ * (no text) can take.
+ */
+export declare function isDecisionStep(step: AgentStep): boolean;
+/**
+ * What an agent step's json output holds: its schema, or its fields as one. Undefined when it
+ * names neither (the model then returns one table).
+ */
+export declare function declaredShape(step: AgentStep): ObjectShape | undefined;
+/** What an agent step's json output holds: its declared shape, or else one table. */
+export declare function stepShape(step: AgentStep): ObjectShape;
+/** The top-level keys of an agent step's output: what `steps.<id>.<key>` may name. */
+export declare function outputKeys(step: AgentStep): string[];
+export type GenerateStep = z.infer<typeof generateStepSchema>;
+export type WidgetStep = z.infer<typeof widgetStepSchema>;
+export type FilmStep = z.infer<typeof filmStepSchema>;
+export type ReviewStep = z.infer<typeof reviewStepSchema>;
+export type ResultStep = z.infer<typeof resultStepSchema>;
+export type StepType = Step["type"];
+export declare const listSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    columns: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        edit: z.ZodOptional<z.ZodEnum<{
+            inline: "inline";
+            popout: "popout";
+        }>>;
+        id: z.ZodString;
+        name: z.ZodString;
+        required: z.ZodOptional<z.ZodBoolean>;
+        format: z.ZodOptional<z.ZodObject<{
+            style: z.ZodDefault<z.ZodEnum<{
+                markdown: "markdown";
+                multiline: "multiline";
+                single: "single";
+            }>>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"text">;
+    }, z.core.$strip>, z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        edit: z.ZodOptional<z.ZodEnum<{
+            inline: "inline";
+            popout: "popout";
+        }>>;
+        id: z.ZodString;
+        name: z.ZodString;
+        required: z.ZodOptional<z.ZodBoolean>;
+        format: z.ZodObject<{
+            currency: z.ZodOptional<z.ZodString>;
+            fractionDigits: z.ZodOptional<z.ZodNumber>;
+            grouping: z.ZodOptional<z.ZodBoolean>;
+            style: z.ZodEnum<{
+                currency: "currency";
+                decimal: "decimal";
+                integer: "integer";
+                percent: "percent";
+            }>;
+        }, z.core.$strip>;
+        type: z.ZodLiteral<"number">;
+    }, z.core.$strip>, z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        edit: z.ZodOptional<z.ZodEnum<{
+            inline: "inline";
+            popout: "popout";
+        }>>;
+        id: z.ZodString;
+        name: z.ZodString;
+        required: z.ZodOptional<z.ZodBoolean>;
+        format: z.ZodObject<{
+            dateStyle: z.ZodOptional<z.ZodEnum<{
+                iso: "iso";
+                long: "long";
+                medium: "medium";
+                short: "short";
+            }>>;
+            kind: z.ZodEnum<{
+                date: "date";
+                datetime: "datetime";
+                time: "time";
+            }>;
+            timePrecision: z.ZodOptional<z.ZodEnum<{
+                hours: "hours";
+                minutes: "minutes";
+                seconds: "seconds";
+            }>>;
+        }, z.core.$strip>;
+        type: z.ZodLiteral<"date">;
+    }, z.core.$strip>, z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        edit: z.ZodOptional<z.ZodEnum<{
+            inline: "inline";
+            popout: "popout";
+        }>>;
+        id: z.ZodString;
+        name: z.ZodString;
+        required: z.ZodOptional<z.ZodBoolean>;
+        format: z.ZodObject<{
+            display: z.ZodEnum<{
+                "decimal-hours": "decimal-hours";
+                hms: "hms";
+                hours: "hours";
+                iso: "iso";
+                minutes: "minutes";
+            }>;
+            inputUnit: z.ZodEnum<{
+                days: "days";
+                hours: "hours";
+                milliseconds: "milliseconds";
+                minutes: "minutes";
+                seconds: "seconds";
+            }>;
+        }, z.core.$strip>;
+        type: z.ZodLiteral<"duration">;
+    }, z.core.$strip>, z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        edit: z.ZodOptional<z.ZodEnum<{
+            inline: "inline";
+            popout: "popout";
+        }>>;
+        id: z.ZodString;
+        name: z.ZodString;
+        required: z.ZodOptional<z.ZodBoolean>;
+        format: z.ZodObject<{
+            allowCustom: z.ZodBoolean;
+            multiple: z.ZodOptional<z.ZodBoolean>;
+            options: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        type: z.ZodLiteral<"select">;
+    }, z.core.$strip>, z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        edit: z.ZodOptional<z.ZodEnum<{
+            inline: "inline";
+            popout: "popout";
+        }>>;
+        id: z.ZodString;
+        name: z.ZodString;
+        required: z.ZodOptional<z.ZodBoolean>;
+        type: z.ZodLiteral<"boolean">;
+    }, z.core.$strip>], "type">>;
+    key: z.ZodOptional<z.ZodString>;
+    check: z.ZodOptional<z.ZodObject<{
+        file: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    shared: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const connectionSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodOptional<z.ZodEnum<{
+        mail: "mail";
+    }>>;
+    connector: z.ZodOptional<z.ZodString>;
+    actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    policy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+        allow: "allow";
+        ask: "ask";
+    }>>>;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** The version of the definition this app writes and reads; raised only by a breaking change. */
+export declare const DEFINITION_VERSION: 1;
+export declare const wizardSchema: z.ZodObject<{
+    version: z.ZodDefault<z.ZodLiteral<1>>;
+    title: z.ZodString;
+    description: z.ZodDefault<z.ZodString>;
+    avatar: z.ZodDefault<z.ZodEnum<{
+        bean: "bean";
+        dome: "dome";
+        drop: "drop";
+        flame: "flame";
+        oval: "oval";
+        pebble: "pebble";
+        round: "round";
+        sprout: "sprout";
+        tower: "tower";
+        wedge: "wedge";
+    }>>;
+    intro: z.ZodOptional<z.ZodString>;
+    lang: z.ZodOptional<z.ZodString>;
+    lists: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        columns: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            edit: z.ZodOptional<z.ZodEnum<{
+                inline: "inline";
+                popout: "popout";
+            }>>;
+            id: z.ZodString;
+            name: z.ZodString;
+            required: z.ZodOptional<z.ZodBoolean>;
+            format: z.ZodOptional<z.ZodObject<{
+                style: z.ZodDefault<z.ZodEnum<{
+                    markdown: "markdown";
+                    multiline: "multiline";
+                    single: "single";
+                }>>;
+            }, z.core.$strip>>;
+            type: z.ZodLiteral<"text">;
+        }, z.core.$strip>, z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            edit: z.ZodOptional<z.ZodEnum<{
+                inline: "inline";
+                popout: "popout";
+            }>>;
+            id: z.ZodString;
+            name: z.ZodString;
+            required: z.ZodOptional<z.ZodBoolean>;
+            format: z.ZodObject<{
+                currency: z.ZodOptional<z.ZodString>;
+                fractionDigits: z.ZodOptional<z.ZodNumber>;
+                grouping: z.ZodOptional<z.ZodBoolean>;
+                style: z.ZodEnum<{
+                    currency: "currency";
+                    decimal: "decimal";
+                    integer: "integer";
+                    percent: "percent";
+                }>;
+            }, z.core.$strip>;
+            type: z.ZodLiteral<"number">;
+        }, z.core.$strip>, z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            edit: z.ZodOptional<z.ZodEnum<{
+                inline: "inline";
+                popout: "popout";
+            }>>;
+            id: z.ZodString;
+            name: z.ZodString;
+            required: z.ZodOptional<z.ZodBoolean>;
+            format: z.ZodObject<{
+                dateStyle: z.ZodOptional<z.ZodEnum<{
+                    iso: "iso";
+                    long: "long";
+                    medium: "medium";
+                    short: "short";
+                }>>;
+                kind: z.ZodEnum<{
+                    date: "date";
+                    datetime: "datetime";
+                    time: "time";
+                }>;
+                timePrecision: z.ZodOptional<z.ZodEnum<{
+                    hours: "hours";
+                    minutes: "minutes";
+                    seconds: "seconds";
+                }>>;
+            }, z.core.$strip>;
+            type: z.ZodLiteral<"date">;
+        }, z.core.$strip>, z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            edit: z.ZodOptional<z.ZodEnum<{
+                inline: "inline";
+                popout: "popout";
+            }>>;
+            id: z.ZodString;
+            name: z.ZodString;
+            required: z.ZodOptional<z.ZodBoolean>;
+            format: z.ZodObject<{
+                display: z.ZodEnum<{
+                    "decimal-hours": "decimal-hours";
+                    hms: "hms";
+                    hours: "hours";
+                    iso: "iso";
+                    minutes: "minutes";
+                }>;
+                inputUnit: z.ZodEnum<{
+                    days: "days";
+                    hours: "hours";
+                    milliseconds: "milliseconds";
+                    minutes: "minutes";
+                    seconds: "seconds";
+                }>;
+            }, z.core.$strip>;
+            type: z.ZodLiteral<"duration">;
+        }, z.core.$strip>, z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            edit: z.ZodOptional<z.ZodEnum<{
+                inline: "inline";
+                popout: "popout";
+            }>>;
+            id: z.ZodString;
+            name: z.ZodString;
+            required: z.ZodOptional<z.ZodBoolean>;
+            format: z.ZodObject<{
+                allowCustom: z.ZodBoolean;
+                multiple: z.ZodOptional<z.ZodBoolean>;
+                options: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            type: z.ZodLiteral<"select">;
+        }, z.core.$strip>, z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            edit: z.ZodOptional<z.ZodEnum<{
+                inline: "inline";
+                popout: "popout";
+            }>>;
+            id: z.ZodString;
+            name: z.ZodString;
+            required: z.ZodOptional<z.ZodBoolean>;
+            type: z.ZodLiteral<"boolean">;
+        }, z.core.$strip>], "type">>;
+        key: z.ZodOptional<z.ZodString>;
+        check: z.ZodOptional<z.ZodObject<{
+            file: z.ZodOptional<z.ZodString>;
+            status: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        shared: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    connections: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodOptional<z.ZodEnum<{
+            mail: "mail";
+        }>>;
+        connector: z.ZodOptional<z.ZodString>;
+        actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        policy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+            allow: "allow";
+            ask: "ask";
+        }>>>;
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        next: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            when: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                field: z.ZodString;
+                op: z.ZodEnum<{
+                    contains: "contains";
+                    empty: "empty";
+                    equals: "equals";
+                    gt: "gt";
+                    in: "in";
+                    lt: "lt";
+                    notEmpty: "notEmpty";
+                    notEquals: "notEquals";
+                }>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+            }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                op: z.ZodEnum<{
+                    contains: "contains";
+                    empty: "empty";
+                    equals: "equals";
+                    gt: "gt";
+                    in: "in";
+                    lt: "lt";
+                    notEmpty: "notEmpty";
+                    notEquals: "notEquals";
+                }>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+            }, z.core.$strip>>]>>;
+            ask: z.ZodOptional<z.ZodString>;
+            goto: z.ZodString;
+            max: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        type: z.ZodLiteral<"page">;
+        fields: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            kind: z.ZodEnum<{
+                audio: "audio";
+                color: "color";
+                connection: "connection";
+                date: "date";
+                email: "email";
+                file: "file";
+                image: "image";
+                items: "items";
+                list: "list";
+                location: "location";
+                multiselect: "multiselect";
+                number: "number";
+                select: "select";
+                signature: "signature";
+                slot: "slot";
+                text: "text";
+                textarea: "textarea";
+                toggle: "toggle";
+                url: "url";
+            }>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            placeholder: z.ZodOptional<z.ZodString>;
+            help: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+            columns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                kind: z.ZodEnum<{
+                    money: "money";
+                    number: "number";
+                    text: "text";
+                }>;
+            }, z.core.$strip>>>;
+            vat: z.ZodOptional<z.ZodObject<{
+                rate: z.ZodOptional<z.ZodNumber>;
+                field: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            currency: z.ZodOptional<z.ZodString>;
+            multiple: z.ZodOptional<z.ZodBoolean>;
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+            camera: z.ZodOptional<z.ZodBoolean>;
+            video: z.ZodOptional<z.ZodBoolean>;
+            listen: z.ZodOptional<z.ZodBoolean>;
+            scan: z.ZodOptional<z.ZodBoolean>;
+            connection: z.ZodOptional<z.ZodString>;
+            list: z.ZodOptional<z.ZodString>;
+            prefill: z.ZodOptional<z.ZodString>;
+            when: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                field: z.ZodString;
+                op: z.ZodEnum<{
+                    contains: "contains";
+                    empty: "empty";
+                    equals: "equals";
+                    gt: "gt";
+                    in: "in";
+                    lt: "lt";
+                    notEmpty: "notEmpty";
+                    notEquals: "notEquals";
+                }>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+            }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                op: z.ZodEnum<{
+                    contains: "contains";
+                    empty: "empty";
+                    equals: "equals";
+                    gt: "gt";
+                    in: "in";
+                    lt: "lt";
+                    notEmpty: "notEmpty";
+                    notEquals: "notEquals";
+                }>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+            }, z.core.$strip>>]>>;
+            optionsFrom: z.ZodOptional<z.ZodString>;
+            cards: z.ZodOptional<z.ZodObject<{
+                label: z.ZodString;
+                value: z.ZodOptional<z.ZodString>;
+                image: z.ZodOptional<z.ZodString>;
+                subtitle: z.ZodOptional<z.ZodString>;
+                meta: z.ZodOptional<z.ZodString>;
+                link: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            ask: z.ZodOptional<z.ZodString>;
+            group: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        groups: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            instructions: z.ZodString;
+            optional: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        cta: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        next: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            when: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                field: z.ZodString;
+                op: z.ZodEnum<{
+                    contains: "contains";
+                    empty: "empty";
+                    equals: "equals";
+                    gt: "gt";
+                    in: "in";
+                    lt: "lt";
+                    notEmpty: "notEmpty";
+                    notEquals: "notEquals";
+                }>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+            }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                op: z.ZodEnum<{
+                    contains: "contains";
+                    empty: "empty";
+                    equals: "equals";
+                    gt: "gt";
+                    in: "in";
+                    lt: "lt";
+                    notEmpty: "notEmpty";
+                    notEquals: "notEquals";
+                }>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+            }, z.core.$strip>>]>>;
+            ask: z.ZodOptional<z.ZodString>;
+            goto: z.ZodString;
+            max: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        type: z.ZodLiteral<"agent">;
+        instructions: z.ZodDefault<z.ZodString>;
+        call: z.ZodOptional<z.ZodObject<{
+            tool: z.ZodTemplateLiteral<`${string}.${string}`>;
+            input: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>;
+        tools: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+            browser: "browser";
+            http: "http";
+            image: "image";
+            pages: "pages";
+            sandbox: "sandbox";
+            web_fetch: "web_fetch";
+            web_search: "web_search";
+        }>, z.ZodTemplateLiteral<`${string}.${string}`>]>>>;
+        mcp: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        connections: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        output: z.ZodDefault<z.ZodObject<{
+            format: z.ZodEnum<{
+                json: "json";
+                markdown: "markdown";
+                text: "text";
+            }>;
+            fields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodEnum<{
+                    choice: "choice";
+                    list: "list";
+                    number: "number";
+                    score: "score";
+                    table: "table";
+                    text: "text";
+                    yesno: "yesno";
+                }>;
+                description: z.ZodOptional<z.ZodString>;
+                columns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>>;
+            schema: z.ZodOptional<z.ZodType<ObjectShape, unknown, z.core.$ZodTypeInternals<ObjectShape, unknown>>>;
+            surface: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                component: z.ZodEnum<{
+                    Actions: "Actions";
+                    Badge: "Badge";
+                    BarChart: "BarChart";
+                    Button: "Button";
+                    Callout: "Callout";
+                    Card: "Card";
+                    Checklist: "Checklist";
+                    Chips: "Chips";
+                    Column: "Column";
+                    DetailGrid: "DetailGrid";
+                    DonutChart: "DonutChart";
+                    Fold: "Fold";
+                    Grid: "Grid";
+                    Group: "Group";
+                    Image: "Image";
+                    LineChart: "LineChart";
+                    Link: "Link";
+                    List: "List";
+                    Metric: "Metric";
+                    Row: "Row";
+                    Steps: "Steps";
+                    Table: "Table";
+                    Tabs: "Tabs";
+                    Text: "Text";
+                }>;
+                children: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+                    path: z.ZodString;
+                    componentId: z.ZodString;
+                }, z.core.$strip>]>>;
+            }, z.core.$loose>>]>>;
+        }, z.core.$strip>>;
+        model: z.ZodOptional<z.ZodEnum<{
+            classifier: "classifier";
+            high: "high";
+            highest: "highest";
+            standard: "standard";
+        }>>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            high: "high";
+            low: "low";
+            medium: "medium";
+        }>>;
+        each: z.ZodOptional<z.ZodString>;
+        working: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        next: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            when: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                field: z.ZodString;
+                op: z.ZodEnum<{
+                    contains: "contains";
+                    empty: "empty";
+                    equals: "equals";
+                    gt: "gt";
+                    in: "in";
+                    lt: "lt";
+                    notEmpty: "notEmpty";
+                    notEquals: "notEquals";
+                }>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+            }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                op: z.ZodEnum<{
+                    contains: "contains";
+                    empty: "empty";
+                    equals: "equals";
+                    gt: "gt";
+                    in: "in";
+                    lt: "lt";
+                    notEmpty: "notEmpty";
+                    notEquals: "notEquals";
+                }>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+            }, z.core.$strip>>]>>;
+            ask: z.ZodOptional<z.ZodString>;
+            goto: z.ZodString;
+            max: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        type: z.ZodLiteral<"generate">;
+        asset: z.ZodEnum<{
+            dashboard: "dashboard";
+            document: "document";
+            image: "image";
+            video: "video";
+            voice: "voice";
+        }>;
+        prompt: z.ZodString;
+        options: z.ZodOptional<z.ZodObject<{
+            aspectRatio: z.ZodOptional<z.ZodEnum<{
+                "16:9": "16:9";
+                "1:1": "1:1";
+                "2:3": "2:3";
+                "3:2": "3:2";
+                "4:5": "4:5";
+                "9:16": "9:16";
+            }>>;
+            duration: z.ZodOptional<z.ZodNumber>;
+            resolution: z.ZodOptional<z.ZodEnum<{
+                "480p": "480p";
+                "720p": "720p";
+            }>>;
+            style: z.ZodOptional<z.ZodString>;
+            template: z.ZodOptional<z.ZodEnum<{
+                briefing: "briefing";
+                free: "free";
+                invoice: "invoice";
+                letter: "letter";
+                offer: "offer";
+                report: "report";
+            }>>;
+        }, z.core.$strip>>;
+        referenceImage: z.ZodOptional<z.ZodString>;
+        each: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodEnum<{
+            classifier: "classifier";
+            high: "high";
+            highest: "highest";
+            standard: "standard";
+        }>>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            high: "high";
+            low: "low";
+            medium: "medium";
+        }>>;
+        working: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        next: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            when: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                field: z.ZodString;
+                op: z.ZodEnum<{
+                    contains: "contains";
+                    empty: "empty";
+                    equals: "equals";
+                    gt: "gt";
+                    in: "in";
+                    lt: "lt";
+                    notEmpty: "notEmpty";
+                    notEquals: "notEquals";
+                }>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+            }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                op: z.ZodEnum<{
+                    contains: "contains";
+                    empty: "empty";
+                    equals: "equals";
+                    gt: "gt";
+                    in: "in";
+                    lt: "lt";
+                    notEmpty: "notEmpty";
+                    notEquals: "notEquals";
+                }>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+            }, z.core.$strip>>]>>;
+            ask: z.ZodOptional<z.ZodString>;
+            goto: z.ZodString;
+            max: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        type: z.ZodLiteral<"widget">;
+        entry: z.ZodString;
+        data: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        sample: z.ZodOptional<z.ZodString>;
+        layout: z.ZodOptional<z.ZodEnum<{
+            fixed: "fixed";
+            page: "page";
+        }>>;
+        size: z.ZodOptional<z.ZodObject<{
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+        }, z.core.$strip>>;
+        video: z.ZodOptional<z.ZodBoolean>;
+        working: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        next: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            when: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                field: z.ZodString;
+                op: z.ZodEnum<{
+                    contains: "contains";
+                    empty: "empty";
+                    equals: "equals";
+                    gt: "gt";
+                    in: "in";
+                    lt: "lt";
+                    notEmpty: "notEmpty";
+                    notEquals: "notEquals";
+                }>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+            }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                op: z.ZodEnum<{
+                    contains: "contains";
+                    empty: "empty";
+                    equals: "equals";
+                    gt: "gt";
+                    in: "in";
+                    lt: "lt";
+                    notEmpty: "notEmpty";
+                    notEquals: "notEquals";
+                }>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+            }, z.core.$strip>>]>>;
+            ask: z.ZodOptional<z.ZodString>;
+            goto: z.ZodString;
+            max: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        type: z.ZodLiteral<"surface">;
+        components: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            component: z.ZodEnum<{
+                Actions: "Actions";
+                Badge: "Badge";
+                BarChart: "BarChart";
+                Button: "Button";
+                Callout: "Callout";
+                Card: "Card";
+                Checklist: "Checklist";
+                Chips: "Chips";
+                Column: "Column";
+                DetailGrid: "DetailGrid";
+                DonutChart: "DonutChart";
+                Fold: "Fold";
+                Grid: "Grid";
+                Group: "Group";
+                Image: "Image";
+                LineChart: "LineChart";
+                Link: "Link";
+                List: "List";
+                Metric: "Metric";
+                Row: "Row";
+                Steps: "Steps";
+                Table: "Table";
+                Tabs: "Tabs";
+                Text: "Text";
+            }>;
+            children: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+                path: z.ZodString;
+                componentId: z.ZodString;
+            }, z.core.$strip>]>>;
+        }, z.core.$loose>>>;
+        candidates: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+            components: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                component: z.ZodEnum<{
+                    Actions: "Actions";
+                    Badge: "Badge";
+                    BarChart: "BarChart";
+                    Button: "Button";
+                    Callout: "Callout";
+                    Card: "Card";
+                    Checklist: "Checklist";
+                    Chips: "Chips";
+                    Column: "Column";
+                    DetailGrid: "DetailGrid";
+                    DonutChart: "DonutChart";
+                    Fold: "Fold";
+                    Grid: "Grid";
+                    Group: "Group";
+                    Image: "Image";
+                    LineChart: "LineChart";
+                    Link: "Link";
+                    List: "List";
+                    Metric: "Metric";
+                    Row: "Row";
+                    Steps: "Steps";
+                    Table: "Table";
+                    Tabs: "Tabs";
+                    Text: "Text";
+                }>;
+                children: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+                    path: z.ZodString;
+                    componentId: z.ZodString;
+                }, z.core.$strip>]>>;
+            }, z.core.$loose>>;
+            group: z.ZodOptional<z.ZodString>;
+            required: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        groups: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            instructions: z.ZodString;
+            optional: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        data: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        working: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        next: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            when: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                field: z.ZodString;
+                op: z.ZodEnum<{
+                    contains: "contains";
+                    empty: "empty";
+                    equals: "equals";
+                    gt: "gt";
+                    in: "in";
+                    lt: "lt";
+                    notEmpty: "notEmpty";
+                    notEquals: "notEquals";
+                }>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+            }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                op: z.ZodEnum<{
+                    contains: "contains";
+                    empty: "empty";
+                    equals: "equals";
+                    gt: "gt";
+                    in: "in";
+                    lt: "lt";
+                    notEmpty: "notEmpty";
+                    notEquals: "notEquals";
+                }>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+            }, z.core.$strip>>]>>;
+            ask: z.ZodOptional<z.ZodString>;
+            goto: z.ZodString;
+            max: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        type: z.ZodLiteral<"film">;
+        brief: z.ZodString;
+        skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        kit: z.ZodOptional<z.ZodString>;
+        inputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        format: z.ZodDefault<z.ZodEnum<{
+            "16:9": "16:9";
+            "1:1": "1:1";
+            "9:16": "9:16";
+        }>>;
+        seconds: z.ZodOptional<z.ZodNumber>;
+        model: z.ZodOptional<z.ZodEnum<{
+            classifier: "classifier";
+            high: "high";
+            highest: "highest";
+            standard: "standard";
+        }>>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            high: "high";
+            low: "low";
+            medium: "medium";
+        }>>;
+        working: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        next: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            when: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                field: z.ZodString;
+                op: z.ZodEnum<{
+                    contains: "contains";
+                    empty: "empty";
+                    equals: "equals";
+                    gt: "gt";
+                    in: "in";
+                    lt: "lt";
+                    notEmpty: "notEmpty";
+                    notEquals: "notEquals";
+                }>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+            }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                op: z.ZodEnum<{
+                    contains: "contains";
+                    empty: "empty";
+                    equals: "equals";
+                    gt: "gt";
+                    in: "in";
+                    lt: "lt";
+                    notEmpty: "notEmpty";
+                    notEquals: "notEquals";
+                }>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+            }, z.core.$strip>>]>>;
+            ask: z.ZodOptional<z.ZodString>;
+            goto: z.ZodString;
+            max: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        type: z.ZodLiteral<"review">;
+        show: z.ZodArray<z.ZodString>;
+        edit: z.ZodOptional<z.ZodBoolean>;
+        regenerate: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        next: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            when: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                field: z.ZodString;
+                op: z.ZodEnum<{
+                    contains: "contains";
+                    empty: "empty";
+                    equals: "equals";
+                    gt: "gt";
+                    in: "in";
+                    lt: "lt";
+                    notEmpty: "notEmpty";
+                    notEquals: "notEquals";
+                }>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+            }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                op: z.ZodEnum<{
+                    contains: "contains";
+                    empty: "empty";
+                    equals: "equals";
+                    gt: "gt";
+                    in: "in";
+                    lt: "lt";
+                    notEmpty: "notEmpty";
+                    notEquals: "notEquals";
+                }>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+            }, z.core.$strip>>]>>;
+            ask: z.ZodOptional<z.ZodString>;
+            goto: z.ZodString;
+            max: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        type: z.ZodLiteral<"result">;
+        message: z.ZodOptional<z.ZodString>;
+        deliverables: z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            formats: z.ZodArray<z.ZodEnum<{
+                csv: "csv";
+                docx: "docx";
+                html: "html";
+                json: "json";
+                md: "md";
+                mp3: "mp3";
+                mp4: "mp4";
+                pdf: "pdf";
+                png: "png";
+                txt: "txt";
+                xlsx: "xlsx";
+                zip: "zip";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>], "type">>;
+}, z.core.$strip>;
+export type WizardDefinition = z.infer<typeof wizardSchema>;
+export declare const INTERACTIVE: ReadonlySet<StepType>;
+/** Which formats each producing step can be downloaded in. */
+export declare function formatsFor(step: Step): Format[];
+/** Formats a stored list can be downloaded in; zip = the kept files its rows name, with the list. */
+export declare const LIST_FORMATS: Format[];
+/** "lists.providers" → "providers"; anything else → null. */
+export declare function listRef(ref: string): string | null;
+export declare const DEFAULT_WIDGET_SIZE: {
+    width: number;
+    height: number;
+};
+export declare function widgetSize(step: WidgetStep): {
+    width: number;
+    height: number;
+};
+/** A widget data reference without braces: "{{steps.x}}" and "steps.x" mean the same. */
+export declare function dataRef(raw: string): string;
+export interface ValidationIssue {
+    stepId?: string;
+    message: string;
+}
+export declare function templateRefs(template: string): string[];
+/**
+ * Structural checks the schema cannot express: ids, references between steps,
+ * templates naming things that exist by the time the step runs.
+ */
+export declare function validateWizard(def: WizardDefinition, files?: string[]): ValidationIssue[];
+/** Parse + validate in one go. */
+export declare function parseWizard(input: unknown, files?: string[]): {
+    ok: true;
+    wizard: WizardDefinition;
+    issues: ValidationIssue[];
+} | {
+    ok: false;
+    issues: ValidationIssue[];
+};
+/** Where the shape is wrong, a step named by its id: `steps[2] "draft".title: …`. */
+export declare function shapeIssues(error: z.ZodError, raw: unknown): ValidationIssue[];
+/**
+ * What branch rules can read in a run: the person's answers by field id, and the structured
+ * output of the steps run so far as `steps.<step>.<field>`.
+ */
+export declare function branchValues(values: Record<string, unknown>, outputs: Record<string, {
+    json?: unknown;
+    decided?: Record<string, number>;
+}>, 
+/** Rows per stored list, read as `lists.<list>.count`. */
+listCounts?: Record<string, number>): Record<string, unknown>;
+/** A branch back to an earlier step without `max` is taken at most this often in one run. */
+export declare const DEFAULT_LOOP_MAX = 10;
+/** How a run counts the times it took a branch: "<step>→<goto>". */
+export declare function loopKey(stepId: string, goto: string): string;
+/** Whether a rule may still send the run on: one with `max`, or one back, stops after so many. */
+export declare function ruleOpen(def: WizardDefinition, stepId: string, rule: NextRule, loops?: Record<string, number>): boolean;
+/**
+ * Where a run goes after a step: the first open `when` rule that holds (`rule` is its index in
+ * `next`), else a decision over the open `ask` rules, else the next step in the list. `cursor`
+ * null = the end.
+ */
+export type RuleOutcome = {
+    kind: "go";
+    cursor: string | null;
+    rule: number | null;
+} | {
+    kind: "decide";
+    rules: number[];
+};
+export declare function followRules(def: WizardDefinition, stepId: string, values: Record<string, unknown>, loops?: Record<string, number>): RuleOutcome;
+/** A rule with neither a condition nor a statement: where the run goes when no other rule holds. */
+export declare function isOtherwise(rule: NextRule): boolean;
+/**
+ * Where a step goes when none of its rules holds: its "otherwise" rule (`rule` is its index in
+ * `next`), else the next step in the list. `cursor` null = the end.
+ */
+export declare function otherwiseOf(def: WizardDefinition, stepId: string, loops?: Record<string, number>): {
+    cursor: string | null;
+    rule: number | null;
+};
+/** The step after `step` by its `when` rules alone. `null` = the end. */
+export declare function nextStepId(def: WizardDefinition, stepId: string, values: Record<string, unknown>): string | null;
+/** The conditions of a rule or a field, as a list: one, several, or none. */
+export declare function conditionsOf(when: When | undefined): Condition[];
+export declare function conditionMatches(c: Condition, values: Record<string, unknown>): boolean;
+/** Whether every condition holds; no conditions hold trivially. */
+export declare function whenHolds(when: When | undefined, values: Record<string, unknown>): boolean;
+/** Whether a `when` rule holds. An `ask` rule never holds here: a decision takes it (see decide). */
+export declare function ruleMatches(rule: NextRule, values: Record<string, unknown>): boolean;
+/** A page with decided fields has at most this many; it shows at most MAX_SHOWN_FIELDS of them. */
+export declare const MAX_DECIDED_FIELDS = 12;
+export declare const MAX_SHOWN_FIELDS = 5;
+/** Whether a field is shown only when a decision keeps it. */
+export declare function isDecidedField(field: Field): boolean;
+/**
+ * The fields of a page that are shown: those whose `when` holds on what was known before the
+ * page (`known`) and what the page holds so far (`page`). A hidden field's value does not count
+ * for the fields after it.
+ */
+export declare function shownFields(fields: Field[], known: Record<string, unknown>, page: Record<string, unknown>): Field[];
+/** The references the `when` of a page's fields read outside the page: what the page must know. */
+export declare function pageNeeds(fields: Field[]): string[];
+/** At most this many choices come from data. */
+export declare const MAX_DATA_OPTIONS = 100;
+/**
+ * The choices an `optionsFrom` reference finds in a run: the entries of a list output, one
+ * column of a table output, or one column of a stored list — as text, without duplicates and
+ * empties. Empty when the data is not there (yet).
+ */
+export declare function optionsFromData(ref: string, outputs: Record<string, {
+    json?: unknown;
+}>, lists?: Record<string, {
+    rows: {
+        cells: Record<string, unknown>;
+    }[];
+}>, cards?: CardsDef): string[];
+/** The rows of a table output as cards: what `optionsFrom` with `cards` finds in the run. */
+export declare function cardsFromData(ref: string, outputs: Record<string, {
+    json?: unknown;
+}>, cards: CardsDef): CardOption[];
+/** An offered appointment time read on its own clock: the offset it was written with. */
+export interface SlotTime {
+    /** The calendar day there: "2026-10-12". */
+    day: string;
+    /** The time of day there: "09:00". */
+    time: string;
+    /** That day and time as if it were UTC — to name the weekday and month without moving it. */
+    wall: Date;
+}
+/**
+ * A slot option as day and time in its own offset (the business's time zone, not the reader's).
+ * Null when it is not an ISO 8601 date-time with an offset.
+ */
+export declare function slotTime(iso: string): SlotTime | null;
+/** The weekday and date of a slot's day: "Montag, 12. Oktober" / "Monday, 12 October". */
+export declare function slotDayText(iso: string, lang?: string): string;
+/** A chosen slot as a person reads it back: "Di 13.10.2026, 10:30" / "Tue 13/10/2026, 10:30". */
+export declare function slotText(iso: string, lang?: string): string;
+/**
+ * The slot among `options` that is the same moment as `value`, written as offered — so an answer
+ * in another offset ("…T07:00:00Z" for "…T09:00:00+02:00") picks the offered time.
+ */
+export declare function offeredSlot(value: string, options: string[]): string | undefined;
+export interface ItemsTotals {
+    rows: Record<string, unknown>[];
+    net: number;
+    vatRate: number;
+    vat: number;
+    gross: number;
+    currency: string;
+}
+export declare function itemsTotals(field: Field, value: unknown, values: Record<string, unknown>): ItemsTotals;
+export declare function allFields(def: WizardDefinition): Field[];
+/**
+ * The language a wizard speaks to people: the one it names, else read from its own words
+ * (titles, labels, intro) — English where they are not clearly German.
+ */
+export declare function wizardLang(def: WizardDefinition): string;
+/** True when this app's schema reads the definition without losing anything of it. */
+export declare function readable(definition: unknown): boolean;