@engenty/wizards 0.0.0-stage → 0.7.10

package/dist/openui/index.d.ts

@@ -0,0 +1,2485 @@
+import { $strip } from 'zod/v4/core';
+import { DefinedComponent } from '@openuidev/react-lang';
+import { Library } from '@openuidev/react-lang';
+import { z } from 'zod';
+import { ZodObject } from 'zod';
+import { ZodOptional } from 'zod';
+import { ZodRecord } from 'zod';
+import { ZodString } from 'zod';
+import { ZodUnknown } from 'zod';
+
+/**
+ * The library with the Wizard component among a Card's children. A server passes `WizardSpec`
+ * for its prompt, the browser the drawing `Wizard`; both make the same prompt.
+ */
+export declare function addWizard<L extends Library>(library: L, component?: typeof WizardSpec): Library;
+
+declare interface AskBase {
+    id: string;
+    stepId: string;
+    /** Why the wizard asks, in the person's language. */
+    reason: string;
+    at: string;
+}
+
+declare interface AssetRef {
+    id: string;
+    /** image | video | html | text | json */
+    kind: string;
+    mime: string;
+    name: string;
+    /**
+     * Media a model made ("generated") or changed ("edited"). Shown with a label wherever it is
+     * displayed; the file itself carries the marking in its metadata (EU AI Act, Art. 50).
+     */
+    ai?: "generated" | "edited";
+}
+
+/** What a decision over a step's `ask` branches found. */
+declare interface BranchDecision {
+    /** The index of the rule in the step's `next`, or null: none of them, go on. */
+    rule: number | null;
+    source: "systemone" | "llm";
+    probabilities?: Record<string, number>;
+    at: string;
+}
+
+declare interface BrandView {
+    name: string;
+    accent: string | null;
+    logoUrl: string | null;
+    /** How the pages look: the run page sets its tokens from it. */
+    theme: RunTheme;
+}
+
+/** A choice drawn as a card, as the runner gets it. */
+declare interface CardOption {
+    value: string;
+    label: string;
+    image?: string;
+    subtitle?: string;
+    meta?: string;
+    link?: string;
+}
+
+declare type ChoiceShape = Named & {
+    kind: "choice";
+    options: string[];
+};
+
+/** A page's choice whose values lead to a step this runtime has no model for. */
+declare interface ClosedChoice {
+    /** The options (or a toggle's true / false) that lead there; empty = the field as a whole. */
+    values: (string | boolean)[];
+    /** What is missing on the way. */
+    classes: ModelClass[];
+}
+
+/** Names the runtime the Wizard component talks to. Once, before the first render. */
+export declare function configureWizards(config: WizardsConfig): void;
+
+/** A running step wants to change something in one of the person's accounts and asks first. */
+declare interface ConfirmAsk extends AskBase {
+    kind: "confirm";
+    /** The connected service, e.g. "Notion". */
+    service: string;
+    action: {
+        id: string;
+        summary: string;
+        destructive: boolean;
+    };
+    /** What would be sent, as readable JSON. */
+    input: string;
+}
+
+/** Kinds of accounts a wizard can ask the person to connect. */
+declare const CONNECTION_KINDS: readonly ["mail"];
+
+declare type ConnectionKind = (typeof CONNECTION_KINDS)[number];
+
+declare interface ConnectionView {
+    id: string;
+    kind: ConnectionKind | null;
+    /** The imported connector behind the connection, if it is one. */
+    connector: string | null;
+    title: string | null;
+    description: string | null;
+    /** Set when the person has connected an account. */
+    account: {
+        connector: string;
+        label: string;
+        connectedAt: string;
+    } | null;
+    connectors: ConnectorOption[];
+}
+
+/** A connector the person can pick for a connection: an OAuth sign-in or a credentials form. */
+declare interface ConnectorOption {
+    id: string;
+    name: string;
+    auth: "oauth2" | "api_key";
+    /** `api_key` connectors: the form, in order. */
+    fields?: {
+        key: string;
+        label: string;
+        secret?: boolean;
+        placeholder?: string;
+        required?: boolean;
+    }[];
+    /** Shown under the form: where to get the values. */
+    hint?: string;
+}
+
+declare type FieldShape = LeafShape | ListShape | ScoreShape | TableShape;
+
+declare type Format = (typeof FORMATS)[number];
+
+declare const FORMATS: readonly ["png", "mp4", "mp3", "pdf", "docx", "html", "md", "txt", "csv", "xlsx", "json", "zip"];
+
+/** What fills a line's gaps: words, a number (written the language's way), or a list of them. */
+declare type Gap = string | number | readonly Gap[];
+
+declare type Lang = (typeof LANGS)[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.
+ */
+declare const LANGS: readonly ["en", "de"];
+
+declare type LeafShape = TextShape | NumberShape | YesNoShape | ChoiceShape | RefShape;
+
+/**
+ * What a wizard keeps between runs for one person: lists (tabular data), files and connected
+ * accounts. The wizard definition says which lists and connections exist; the content belongs
+ * to the person who ran it.
+ */
+/** A list is an engenty data table: typed columns, rows of cells keyed by column id. */
+declare interface ListDef {
+    id: string;
+    title: string;
+    description?: string;
+    columns: TableColumn[];
+    /** Column whose value identifies a row: saving a row with a known key updates it. */
+    key?: string;
+    /**
+     * The rows are gone through one by one in a review: `file` holds the path of a kept file
+     * shown beside the row, `status` is a select whose options are the answers (first = open).
+     */
+    check?: {
+        file?: string;
+        status?: string;
+    };
+    /** Every run reads and writes the same rows; kept as a table of the space, not per person. */
+    shared?: boolean;
+}
+
+declare interface ListRow {
+    id: string;
+    cells: Record<string, unknown>;
+    updatedAt: string;
+}
+
+declare type ListShape = Named & {
+    kind: "list";
+    of: LeafShape | ObjectShape;
+};
+
+/** Reads the published wizards behind these tokens from a runtime; ones it cannot read are left out. */
+export declare function loadWizards(runtimeUrl: string, tokens: string[]): Promise<WizardInfo[]>;
+
+/**
+ * A running step asks the person to sign in on a page the wizard's browser has open. What the
+ * person types goes into that page; the model never sees it.
+ */
+declare interface LoginAsk extends AskBase {
+    kind: "login";
+    site: {
+        host: string;
+        title: string;
+    };
+    /** Inputs found on the page, to fill here instead of clicking into the picture. */
+    fields: {
+        id: string;
+        label: string;
+        secret: boolean;
+    }[];
+}
+
+declare interface MascotProps {
+    kind: string;
+    size?: number;
+    fluffy?: boolean;
+}
+
+declare const MODEL_CLASSES: readonly ["classifier", "standard", "high", "highest", "image", "video", "audio", "speech"];
+
+declare type ModelClass = (typeof MODEL_CLASSES)[number];
+
+declare interface Named {
+    /** What people read: a column's head, a part's title, "add …". Without one, the key. */
+    label?: string;
+    /** What the model is to put there. */
+    description?: string;
+}
+
+/** What fills a note's gaps: words, numbers, other notes (said in the same language), lists. */
+declare type NoteGap = Gap | RunNote | readonly NoteGap[];
+
+/**
+ * What a step reports while it works, in words for each language: the runtime writes the English
+ * line into the run's log, a runner shows it in the language the person reads. The runtime's
+ * answers to the person running a shared wizard (a refusal, a failure) are notes too: it answers
+ * them in the wizard's language.
+ */
+declare const NOTES_EN: {
+    readonly entry: "Entry {n} of {total}";
+    readonly deciding: "Deciding what to do next…";
+    readonly choosingFields: "Choosing the right questions…";
+    readonly batchDone: "{done} of {total} done";
+    readonly editing: "Editing {n} of {total}";
+    readonly filming: "Filming {n} of {total}";
+    readonly clipsRendering: {
+        readonly one: "Rendering {count} clip – this takes a few minutes.";
+        readonly other: "Rendering {count} clips – this takes a few minutes.";
+    };
+    readonly videoRendering: "Rendering the video – this usually takes 1–3 minutes.";
+    readonly photo: "Looking at photo {n} of {total}";
+    readonly found: "{label}: {name}";
+    readonly listen: "Listening to “{label}”…";
+    readonly listenFailed: "“{label}” couldn’t be transcribed.";
+    readonly filmCutting: "Cutting the film – this takes about a minute.";
+    readonly filmProgress: "{pct} % cut";
+    readonly filmError: "The film reports: {detail}";
+    readonly widgetError: "The widget reports an error: {detail}";
+    readonly mcpConnected: "Connected to {names}";
+    readonly mcpUnreachable: "MCP server unreachable: {detail}";
+    readonly reads: "Reading {name}";
+    readonly readsMany: {
+        readonly one: "Reading {count} document";
+        readonly other: "Reading {count} documents";
+    };
+    readonly opens: "Opening {name}";
+    readonly clicks: "Clicking in the browser";
+    readonly clicksOn: "Clicking “{name}”";
+    readonly types: "Typing in the browser";
+    readonly typesText: "Typing “{text}”";
+    readonly selects: "Choosing “{option}”";
+    readonly scrolls: "Scrolling";
+    readonly presses: "Pressing {key}";
+    readonly goesBack: "Going back a page";
+    readonly waitsForPage: "Waiting for the page";
+    readonly fastLoop: "Doing in the browser: {goal}";
+    readonly personDrives: "You’re driving the browser – the wizard waits";
+    readonly agentDrives: "The wizard carries on in the browser";
+    readonly looksAtPage: "Looking at the page";
+    readonly waitsForSignIn: "Waiting for you to sign in to {name}";
+    readonly downloads: "Downloading {name}";
+    readonly runs: "Running: {command}";
+    readonly python: "Running Python";
+    readonly runsProgram: "Working through the data in one go";
+    readonly drawing: "Drawing an image";
+    readonly writesPage: "Writing the page “{title}”";
+    readonly searchesDocuments: "Searching the documents: {query}";
+    readonly searchesKnowledge: "Searching knowledge: {query} – {relevant} of {candidates} fit";
+    readonly listsKnowledge: "Listing knowledge";
+    readonly searchesMail: "Searching {label}";
+    readonly savesReceipts: {
+        readonly one: "Saving {count} receipt from {label}";
+        readonly other: "Saving {count} receipts from {label}";
+    };
+    readonly remembers: "Remembering {title}";
+    readonly files: {
+        readonly one: "Filing {count} file";
+        readonly other: "Filing {count} files";
+    };
+    readonly filmSetup: "Setting up the folder for the film";
+    readonly filmClient: "{client} is working on the film – this usually takes 10–40 minutes.";
+    readonly filmTask: "On the film: {task}";
+    readonly filmLooks: "Looking at frames of the film";
+    readonly filmFix: "The film didn’t render – Claude Code is fixing it";
+    readonly filmResume: "Picking the film up where it stopped";
+    readonly wizardUnavailable: "This wizard isn’t available right now.";
+    readonly translationFailed: "This wizard can’t be translated right now. It’s shown as it was written.";
+    readonly translationOff: "This wizard is only offered as it was written.";
+    readonly translationPlaceholder: "The translation of “{text}” needs every placeholder in curly brackets the original has.";
+    readonly wizardLimit: "This wizard has reached its limit for today. Try again tomorrow.";
+    readonly confirmHuman: "Confirm that you’re a person.";
+    readonly tooManyRuns: "You’ve started a lot of runs just now. Try again in an hour.";
+    readonly clientRefused: "This app may not start runs here.";
+    readonly clientLimit: "This app has started a lot of runs just now. Try again later.";
+    readonly runOver: "The run is over.";
+    readonly runBusy: "The wizard is working right now.";
+    readonly pageOutdated: "This page is out of date.";
+    readonly noStepBefore: "There is no step before this one.";
+    readonly checkFields: "Check the marked fields.";
+    readonly talkOff: "Live conversations aren’t turned on for this wizard.";
+    readonly talkKeyRefused: "The conversation couldn’t start: the OpenAI API key was refused.";
+    readonly talkFailed: "The conversation couldn’t start ({status}).";
+    readonly talkNoSecret: "The conversation couldn’t start: no access key came back.";
+    readonly tryLater: "Try again later.";
+    readonly recordingTooLarge: "The recording can be 10 MB at most.";
+    readonly fileTooLarge: "Choose a file of {mb} MB or less.";
+    readonly askClosed: "This question is no longer open.";
+    readonly noBrowser: "The wizard has no browser open right now.";
+    readonly notWaiting: "The wizard isn’t waiting for you right now.";
+    readonly pageActFailed: "That didn’t work on the page.";
+    readonly linkGone: "This link has expired or was withdrawn.";
+    readonly connected: "Connected. You can close this window.";
+    readonly connectFailed: "Connecting didn’t work. Try again.";
+    readonly connectCancelled: "Connecting was cancelled.";
+    readonly appleOff: "Apple Intelligence is turned off on this Mac. Turn it on in System Settings → Apple Intelligence & Siri.";
+    readonly appleLoading: "Apple is still loading the model for Apple Intelligence onto this Mac. Try again in a moment.";
+    readonly appleMissing: "The helper for Apple Intelligence (wizards-apple) is missing from this install.";
+    readonly appleOs: "Apple Intelligence needs macOS 26 or later.";
+    readonly appleDevice: "Apple Intelligence only works on a Mac with Apple silicon.";
+    readonly appleBusy: "Apple Intelligence isn’t taking more requests right now. Try again in a moment.";
+    readonly appleTooLong: "The text is too long for Apple Intelligence on this Mac (4,096 tokens for question and answer). Choose another model for this class under Settings → Models.";
+    readonly appleRefused: "Apple Intelligence turned the request down: Apple’s content rules don’t allow it.";
+    readonly appleLanguage: "Apple Intelligence doesn’t understand the language of this request.";
+    readonly appleFormat: "Apple Intelligence can’t answer in this format: {detail}";
+    readonly appleFailed: "Apple Intelligence: {detail}";
+    readonly appleNoFfmpeg: "Apple Intelligence can’t read {type}, and without ffmpeg the recording can’t be converted. Install ffmpeg or record as MP4 in the browser.";
+    readonly appleNotConverted: "Apple Intelligence couldn’t convert the recording: {detail}";
+    readonly connectorAlreadyExistsSpace: "The connector “{id}” already exists in this space.";
+    readonly connectorNotExist: "This connector doesn’t exist.";
+    readonly fieldMissing: "“{label}” is missing.";
+    readonly mailServerNotExist: "The mail server{host} doesn’t exist. Enter the IMAP server. For Gmail and Google Workspace, it’s imap.gmail.com.";
+    readonly mailServerNotResponding: "The mail server{host} isn’t responding. Check the IMAP server and port.";
+    readonly connectingNotWork: "Connecting didn’t work{host}: {detail}";
+    readonly connectEngentyAccountFirst: "Connect your engenty account first (Settings → Account). Then you can connect Google here.";
+    readonly engentyAccountNotReached: "Your engenty account can’t be reached right now. Try again later.";
+    readonly googleNoLongerAccepts: "Google no longer accepts this connection. Connect the account again.";
+    readonly googleNotConnectedThrough: "Google can’t be connected through your engenty account right now.";
+    readonly stepNeedsToolPlugin: "This step needs the tool “{id}”. The plugin “{plugin}” isn’t installed here.";
+    readonly clientNotSignedIn: "{name} isn’t signed in on this computer. Sign in under Settings → Models.";
+    readonly clientNotInstalled: "{name} isn’t installed on this computer. Install it under Settings → Models.";
+    readonly clientNoCredit: "The account {name} is signed in with has no credit or quota left.";
+    readonly clientAccountNotServed: "{name} no longer serves the account it is signed in with. Sign it in with another account, or choose another way under Settings → Models.";
+    readonly anthropicAccountClaudeCode: "The Anthropic account Claude Code is signed in with has no credit. Sign Claude Code in with your subscription under Settings → Models.";
+    readonly chatgptAccountCodexSigned: "The ChatGPT account Codex is signed in with has used up its quota. Try again later or choose another client.";
+    readonly builtTerminalNotAvailable: "The built-in terminal isn’t available on this computer. Run the command in your own terminal.";
+    readonly terminalNoLongerExists: "This terminal no longer exists.";
+    readonly imageTypeNotReadable: "Images of type {mime} can’t be read (PNG, JPEG and WebP work).";
+    readonly fileNotReadable: "“{name}” ({mime}) can’t be read.";
+    readonly creditsNotSignedIn: "This is set to run on credits, but you’re not signed in to an account.";
+    readonly accountNoLongerSigned: "The account is no longer signed in. Sign in again under Settings → Account.";
+    readonly modelNotUsedYet: "The model “{ref}” can’t be used yet. Add an API key under Settings → Models, or sign in to an account.";
+    readonly noModelForImages: "No model is set up for images.";
+    readonly noModelForVideos: "No model is set up for videos.";
+    readonly noModelForSpeech: "No model is set up for speech.";
+    readonly noOpenaiApiKey: "No OpenAI API key is set for voice conversations (Settings → Models).";
+    readonly modelNotAvailableAccount: "This model isn’t available with your account.";
+    readonly accountNoModelSet: "Your account has no model set up for this.";
+    readonly claudeCodeMakesFilms: "Claude Code makes films on this computer, using your subscription. Set it up as an AI subscription under Settings → Models.";
+    readonly macNeedsFfmpegTranscribe: "This Mac needs ffmpeg to transcribe recordings from Chrome or Firefox (WebM, Ogg). Safari and the app don’t. Install ffmpeg, e.g. with “brew install ffmpeg”.";
+    readonly fieldRequired: "Required";
+    readonly chooseAtLeast: "Choose at least {min}";
+    readonly chooseAtMost: "At most {max} – remove some";
+    readonly enterNumber: "Enter a number";
+    readonly invalidChoice: "Invalid choice";
+    readonly timeNotOffered: "This time isn’t offered";
+    readonly notValidEmailAddress: "Not a valid email address";
+    readonly notValidUrl: "Not a valid URL";
+    readonly wizardRunOutCredits: "This wizard has run out of credits for now. Try again later.";
+    readonly providerCreditLow: "Your credit with the model provider isn’t enough for this (videos need a minimum balance there). Top up there and try again.";
+    readonly aiServiceBusyRight: "The AI service is busy right now. Try again in a moment.";
+    readonly stepTookTooLong: "The step took too long. Try again.";
+    readonly aiServiceNotReached: "The AI service can’t be reached right now. Try again later.";
+    readonly notAvailableNow: "That isn’t available here right now.";
+    readonly fileNotFound: "File not found";
+    readonly connectFirst: "Connect first";
+    readonly noEntriesStepWork: "There are no entries for this step to work on.";
+    readonly stepNotReturnResult: "The step didn’t return a result.";
+    readonly documentNotCreated: "The document couldn’t be created.";
+    readonly stepMissingSourcesImages: "This step is missing its sources (images or scenes).";
+    readonly noTextReadAloud: "There is no text to read aloud.";
+    readonly wizardStillErrors: "The wizard still has errors.";
+    readonly noLanguageModelSet: "No language model is set up here.";
+    readonly creditsUsedUp: "Your credits are used up.";
+    readonly chooseFile: "Choose a file.";
+    readonly pageNotReached: "The page can’t be reached.";
+    readonly unknownEntry: "Unknown entry.";
+    readonly chooseWizardFileMb: "Choose a wizard file ({PACKAGE_EXTENSION}) of 30 MB or less.";
+    readonly recordingMbMost: "The recording can be 10 MB at most.";
+    readonly onlyFinishedResultsShared: "Only finished results can be shared.";
+    readonly gradientFailed: "Couldn’t make a gradient from that. Try describing it differently.";
+    readonly onlyOneSpaceAllowed: "Only one space is allowed here.";
+    readonly mostSpaces: {
+        readonly one: "You can have at most {count} space here.";
+        readonly other: "You can have at most {count} spaces here.";
+    };
+    readonly twoEntriesSameKey: "Two entries have the same key.";
+    readonly notDeleteLastSpace: "You can’t delete the last space.";
+    readonly notFound: "This doesn’t exist or was deleted.";
+    readonly categoryNeedsName: "A category needs a name.";
+    readonly unknownCategoryType: "Unknown type “{type}”.";
+    readonly spaceMostCategories: {
+        readonly one: "A space can have at most {count} category.";
+        readonly other: "A space can have at most {count} categories.";
+    };
+    readonly categoryAlreadyExists: "The category “{name}” already exists.";
+    readonly onlyChoiceCategoriesValues: "Only choice categories have values.";
+    readonly onlyValuesOneCategory: "Only values of one category can be merged.";
+    readonly templateNeedsNewerVersion: "This template needs a newer version of engenty wizards. Update engenty wizards first.";
+    readonly chatNotExist: "This chat doesn’t exist.";
+    readonly unknownRunner: "There’s no runner “{unknown}” here.";
+    readonly leastOneRunnerStay: "At least one runner has to stay on.";
+    readonly linkOpenRunnerTurned: "The link has to open a runner that’s turned on.";
+    readonly jobNotExistAlready: "This job doesn’t exist or has already finished.";
+    readonly accountAlreadySpace: "This account already has a space here.";
+    readonly accountAlreadySpaces: {
+        readonly one: "This account already has {count} space here.";
+        readonly other: "This account already has {count} spaces here.";
+    };
+    readonly roomMostPublishedWizards: {
+        readonly one: "There’s room for at most {count} published wizard here.";
+        readonly other: "There’s room for at most {count} published wizards here.";
+    };
+    readonly spaceIdAlreadyExists: "A space with this ID already exists here and didn’t come from your computer.";
+    readonly wizardIdAlreadyBelongs: "A wizard with this ID already belongs to another space here.";
+    readonly idAlreadyUse: "This ID is already in use here.";
+    readonly wizardNotSpace: "This wizard isn’t in the space.";
+    readonly invalidColumns: "Invalid columns.";
+    readonly spaceMostTables: {
+        readonly one: "A space can have at most {count} table.";
+        readonly other: "A space can have at most {count} tables.";
+    };
+    readonly tableBelongsOneWizard: "This table belongs to one of the wizard’s lists. Its columns come from the wizard.";
+    readonly entryAlreadyExists: "This entry already exists.";
+    readonly tableMostRows: {
+        readonly one: "A table can have at most {count} row.";
+        readonly other: "A table can have at most {count} rows.";
+    };
+    readonly spaceMostPages: {
+        readonly one: "A space can have at most {count} page.";
+        readonly other: "A space can have at most {count} pages.";
+    };
+    readonly pageNotSubpages: "This page can’t have subpages.";
+    readonly pageNotOwnSubpage: "A page can’t be its own subpage.";
+    readonly pageNeedsTitle: "A page needs a title.";
+    readonly unknownSpace: "There’s no space “{space}”.";
+    readonly noParentPage: "There’s no page with the key “{parent}” to put this page under.";
+    readonly onlyTeamAdmins: "Only team admins can do that. As a member, you can edit the wizards that already exist.";
+    readonly spaceEditedLocally: "You edit this space in engenty wizards on your computer, not here.";
+    readonly wizardsRunOncePublished: "Wizards run here once you publish them in engenty wizards on your computer. You build and edit them there.";
+    readonly logoImagePngSvg: "A logo is an image (PNG, SVG, JPEG, WebP).";
+    readonly patternImageSvgPng: "A pattern is an image (SVG, PNG, JPEG, WebP).";
+    readonly filesGoHere: "Images, videos, audio, PDFs, fonts, Lottie and 3D models go here. Texts to look things up in go under knowledge.";
+    readonly addressNotReached: "The address can’t be reached.";
+    readonly addressResponded: "The address responded with {status}.";
+    readonly addressLeadsWebPage: "The address leads to a web page, not an image.";
+    readonly addressFileTooLarge: "The file is too large.";
+    readonly onlyDocumentsIndex: "Only documents are in the index.";
+    readonly emptyTooLargeDocument: "“{name}” is empty or too large for a document.";
+    readonly spaceMostDocuments: {
+        readonly one: "A space can have at most {count} document.";
+        readonly other: "A space can have at most {count} documents.";
+    };
+    readonly accountSignedOut: "The account is signed out. Sign in again.";
+    readonly cloudNotReachedRight: "The cloud can’t be reached right now.";
+    readonly publishWizardFirst: "Publish the wizard first.";
+    readonly wizardJsonUnreadable: "This isn’t a wizard file: its wizard.json can’t be read.";
+    readonly wizardFileComesNewer: "This wizard file comes from a newer version, or it’s damaged. Update engenty wizards or export the wizard again.";
+    readonly fileOver5Mb: "{name} is larger than 5 MB.";
+    readonly wizardFileTooLarge: "The wizard file is too large: a workspace holds at most 200 files and 25 MB.";
+    readonly wizardFileNotOpened: "The wizard file can’t be opened. Export the wizard again and try once more.";
+    readonly wizardJsonMissing: "This isn’t a wizard file: wizard.json is missing.";
+    readonly notValidFilePath: "“{name}” isn’t a valid file path.";
+    readonly workspaceWizardFileLarger: "The workspace in the wizard file is larger than 25 MB.";
+    readonly unknownTemplate: "There’s no template “{starterId}”.";
+    readonly wizardChangedMeantime: "The wizard was changed in the meantime.";
+    readonly valueNotExist: "This value doesn’t exist.";
+    readonly nothingFiledUnderValue: "Nothing is filed under this value yet.";
+    readonly filmNotRenderedNeeds: "The film couldn’t be rendered. It needs ffmpeg and a timeline in the widget.";
+    readonly signInRefused: "The sign-in was refused{host}. Are the address and (app) password right? Gmail and Google Workspace need an app password and IMAP turned on.{answer}";
+    readonly serverSaid: " The server said: {answer}";
+    readonly viaAccountFailed: "Connecting through your engenty account didn’t work ({code}).";
+    readonly pluginInvalidInput: "“{id}” got invalid input: {path} – {problem}";
+    readonly filmClientStopped: "{name} stopped working on the film: {detail}. The work is saved. A new try carries on from there.";
+    readonly filmWorkSaved: "{problem} The work is saved. A new try carries on from there.";
+    readonly filmRenderFailed: "The film couldn’t be rendered: {detail}";
+    readonly commandNotStarted: "The command couldn’t start: {detail}";
+    readonly providerKeyMissing: "{provider} is chosen for {makes}, but no API key is set.";
+    readonly noModelFor: "No model is set up for {makes}.";
+    readonly noApiKeyFor: "No API key is set for {provider}.";
+    readonly freeTier: "Your AI Gateway key is on Vercel’s free tier, which doesn’t include {model}. Top up at Vercel ({url}) or choose another model under Settings → Models.";
+    readonly thisModel: "this model";
+    readonly quoted: "“{text}”";
+    readonly viewErrors: "The view has errors: {detail}";
+    readonly blockedSteps: "{steps}: {problem}";
+    readonly joined: "{first} {second}";
+    readonly stepFailed: "This step failed: {detail}";
+    readonly answersMissing: "Answers are missing or don’t fit: {answers}";
+    readonly fieldError: "{field} – {message}";
+    readonly templateNeedsPlugins: {
+        readonly one: "This template needs the plugin {plugins}: included with Pro on engenty.ai.";
+        readonly other: "This template needs the plugins {plugins}: included with Pro on engenty.ai.";
+    };
+    readonly pageMostChars: {
+        readonly one: "A page can have at most {count} character.";
+        readonly other: "A page can have at most {count} characters.";
+    };
+    readonly chooseFileUpTo: "Choose a file of {mb} MB or less.";
+    readonly roomMostFiles: {
+        readonly one: "There’s room for at most {count} file here.";
+        readonly other: "There’s room for at most {count} files here.";
+    };
+    readonly makesText: "text";
+    readonly makesImages: "images";
+    readonly makesVideos: "videos";
+    readonly makesSpeech: "speech";
+    readonly makesVoiceNotes: "voice notes";
+};
+
+declare type NumberShape = Named & {
+    kind: "number";
+    unit?: string;
+};
+
+declare interface ObjectShape extends Named {
+    kind: "object";
+    fields: Record<string, FieldShape>;
+}
+
+/** A field of a wizard's page, as `PublicWizard.fields` lists it. */
+declare interface PublicField {
+    id: string;
+    label: string;
+    kind: string;
+    options?: string[];
+    required?: boolean;
+}
+
+/** An entry of a top-level list of the same output, by its `id`. */
+declare type RefShape = Named & {
+    kind: "ref";
+    to: string;
+};
+
+/** What a running step asks the person; the step waits for the answer. */
+declare type RunAsk = LoginAsk | ConfirmAsk;
+
+declare interface RunEvent {
+    id: number;
+    at: string;
+    stepId: string | null;
+    type: "step_started" | "step_done" | "tool" | "info" | "error";
+    /** In German, as the run's log keeps it. */
+    message: string;
+    /** The same as a note a runner shows in the person's language; null for free text. */
+    note?: RunNote | null;
+    /** A picture of the run this is about (a photo being looked at, an image just made). */
+    asset?: string | null;
+}
+
+/** A line of `RUN_NOTES` with what goes into its gaps. */
+declare interface RunNote {
+    code: RunNoteCode;
+    params?: Record<string, NoteGap | undefined>;
+}
+
+declare type RunNoteCode = keyof typeof NOTES_EN;
+
+/**
+ * A run as the runner drives it: the view, and the commands a person can give. `useRun` in the
+ * studio (a server-sent stream), `useLocalRun` in the WordPress plugin (one request per step).
+ */
+declare interface RunSource {
+    view: RunView | null;
+    notFound: boolean;
+    error: string | null;
+    busy: boolean;
+    fieldErrors: Record<string, string>;
+    submitPage(stepId: string, values: Record<string, unknown>): Promise<boolean>;
+    accept(stepId: string, edits?: Record<string, string | Record<string, unknown>>): Promise<boolean>;
+    regenerate(stepId: string, target: string, note: string, items?: number[]): Promise<boolean>;
+    back(): Promise<boolean>;
+    retry(): Promise<boolean>;
+    /** A finished result's text in the language the run is read in (a translated wizard). */
+    translateResult?(stepId: string): Promise<boolean>;
+}
+
+declare type RunStatus = "waiting_input" | "running" | "done" | "failed" | "cancelled";
+
+/** How a wizard's pages look, taken from its space's brand (`runTheme`). Null: the runner's own. */
+declare interface RunTheme {
+    /** Buttons and marks. */
+    accent: string | null;
+    /** What is there, done or good to know: ticks, tips, group headings. */
+    second: string | null;
+    /** The ground the pages stand on; its hue tints paper and ink. */
+    background: string | null;
+    /** Typefaces as CSS names them. */
+    display: string | null;
+    body: string | null;
+    /** The brand stands on a dark ground. */
+    dark: boolean;
+}
+
+/** How a run in the viewer's language shows. */
+declare interface RunTranslation {
+    /** The language, by its code ("fr"): any language, not only one of `LANGS`. */
+    lang: string;
+    /** What a choice shows, by its value. */
+    labels: Record<string, string>;
+    /** A model wrote some of it; false where the author wrote every text by hand. */
+    machine: boolean;
+    /** Results shown in this language, by step (`RunState.translated`). */
+    results: Record<string, string>;
+}
+
+declare interface RunView {
+    id: string;
+    status: RunStatus;
+    mode: "test" | "live";
+    wizard: Pick<WizardDefinition, "title" | "description" | "avatar" | "intro">;
+    /** The language the wizard speaks, by its code: what is read aloud, and in which voice. */
+    lang: string;
+    /**
+     * The run in the viewer's language (a wizard translated on request): every text of the view
+     * is written in it, the choices keep their values and show `labels[value]`. Null: the
+     * wizard's own words.
+     */
+    translation: RunTranslation | null;
+    /** A live conversation can be started on this run: the runtime has a model for it and the wizard has live voice or video on (always in a test). */
+    talk: boolean;
+    /** The step the person is on (interactive) or the one running. */
+    step: Step | null;
+    /** Pages and reviews answered before it, oldest first: what a chat shows above the current step. */
+    answered: Step[];
+    values: Record<string, unknown>;
+    /** What fields of the current page start with, from earlier steps (`prefill`). */
+    prefill: Record<string, unknown>;
+    /** What the `when` of the current page's fields read from before the page, by reference. */
+    known?: Record<string, unknown>;
+    /** Choices of the current page's fields that come from earlier data (`optionsFrom`). */
+    options?: Record<string, string[]>;
+    /** The same choices as cards, for fields that have `cards`. */
+    cards?: Record<string, CardOption[]>;
+    /** The decided fields (`ask`, `group`) of the current page that a decision kept. */
+    decidedFields?: string[];
+    /**
+     * What decided branches answered so far, by step, with the branches decided over (test runs:
+     * the studio shows them while the draft's branches are still those).
+     */
+    decisions?: Record<string, ShownDecision>;
+    /** Choices of the current page that lead to a step without a model here, by field id. */
+    closed: Record<string, ClosedChoice>;
+    outputs: Record<string, StepOutput>;
+    /** Steps whose outputs the current step shows, with their definitions. */
+    shown: {
+        step: Step;
+        output: StepOutput | null;
+        formats: Format[];
+        label: string | null;
+    }[];
+    progress: {
+        done: number;
+        total: number;
+    };
+    canBack: boolean;
+    error: string | null;
+    events: RunEvent[];
+    brand: BrandView;
+    /** What the running step asks the person right now. */
+    ask: RunAsk | null;
+    /** Stored lists the current step shows (a page's list fields, a review, the result). */
+    lists: ShownList[];
+    /** The wizard's connections with what the person has connected. */
+    connections: ConnectionView[];
+    /** The wizard keeps things for the person between runs (lists, files, accounts). */
+    keeps: boolean;
+    /** Set once the result is shared. */
+    shareUrl: string | null;
+    /** When the run and its shared link are deleted; null = kept. */
+    expiresAt: string | null;
+}
+
+/** `fields` only: a decision's levels, lowest first. */
+declare type ScoreShape = Named & {
+    kind: "score";
+    options: string[];
+};
+
+/** A branch decision as the studio sees it: with the step's branches it was made over. */
+declare interface ShownDecision extends BranchDecision {
+    over: NonNullable<Step["next"]>;
+}
+
+/** A stored list the current step shows. */
+declare interface ShownList {
+    def: ListDef;
+    rows: ListRow[];
+    formats: Format[];
+    label: string | null;
+}
+
+declare type Step = z.infer<typeof stepSchema>;
+
+declare interface StepOutput {
+    text?: string;
+    json?: unknown;
+    /** A decision step: how probable each answer is (1 or 0 where a language model answered). */
+    decided?: Record<string, number>;
+    /** A view from the surface catalog and the data it is bound to. */
+    surface?: Surface;
+    assets?: AssetRef[];
+    /**
+     * What the person did in the step's view, kept with the run: a checklist's ticks by component
+     * id, a widget's own state (`wizard.save`).
+     */
+    view?: Record<string, unknown>;
+    /** Widgets: what loading it with this run's data showed. */
+    widget?: {
+        /** Seconds of animation the widget registered for video export; null = a still widget. */
+        duration: number | null;
+        errors: string[];
+    };
+    at: string;
+}
+
+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";
+        code: "code";
+        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";
+    }>>;
+    from: z.ZodOptional<z.ZodString>;
+    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">;
+
+/** What a run shows: the components and the data they are bound to. */
+declare interface Surface {
+    components: SurfaceComponent[];
+    data: Record<string, unknown>;
+}
+
+declare type SurfaceComponent = z.infer<typeof surfaceComponentSchema>;
+
+/** One component: its id, its kind, its children (ids, or a template repeated over an array). */
+declare const surfaceComponentSchema: 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>;
+
+declare type TableColumn = z.infer<typeof tableColumnSchema>;
+
+declare const tableColumnSchema: 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">;
+
+/** `fields` only: rows of text or numbers; without columns the model picks them. */
+declare type TableShape = Named & {
+    kind: "table";
+    columns?: string[];
+};
+
+declare type TextShape = Named & {
+    kind: "text";
+    long?: boolean;
+};
+
+/**
+ * One run, live: the runtime's stream of the whole view, plus the commands a person gives. The
+ * same as the studio's `useRun` (apps/web/src/runner/useRun.ts), on the runner's own client, so
+ * it talks to whichever runtime `configureWizards` named. `prefill` starts a page's fields with
+ * answers the chat already knows; the person still sees and sends the page.
+ */
+export declare function useWizardRun(runId: string | null, prefill: Record<string, unknown> | undefined): RunSource;
+
+/** The component an OpenUI library gets: `Wizard("<token>", "<note>", {prefill})`. */
+export declare const Wizard: DefinedComponent<ZodObject<    {
+wizard: ZodString;
+note: ZodOptional<ZodString>;
+prefill: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+}, $strip>>;
+
+/**
+ * The model's half of the Wizard component: its props, its description and the rules a system
+ * prompt gets. Nothing here draws, so a chat server builds its prompt from this file alone.
+ */
+export declare const WIZARD_COMPONENT = "Wizard";
+
+export declare const WIZARD_DESCRIPTION = "Runs a predefined wizard inline: its pages, AI steps, review and result, exactly as its author defined them. Use it whenever a listed wizard fits the request; never rebuild a wizard's pages with Form components.";
+
+declare type WizardDefinition = z.infer<typeof wizardSchema>;
+
+/** A wizard as the chat server lists it to the model. */
+export declare interface WizardInfo {
+    token: string;
+    title: string;
+    description: string;
+    fields: PublicField[];
+}
+
+export declare type WizardProps = z.infer<typeof wizardProps>;
+
+export declare const wizardProps: z.ZodObject<{
+    wizard: z.ZodString;
+    note: z.ZodOptional<z.ZodString>;
+    prefill: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+
+/** The rules a system prompt adds for the Wizard component: when to use it and which wizards exist. */
+export declare function wizardRules(wizards: WizardInfo[]): string[];
+
+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";
+            code: "code";
+            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";
+        }>>;
+        from: z.ZodOptional<z.ZodString>;
+        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 declare interface WizardsConfig {
+    /**
+     * Where the runtime answers, as the browser reaches it: a path the host proxies to it
+     * (`/wizards-runtime`, so the runner's cookie stays first-party) or the runtime's address.
+     */
+    runtime: string;
+    /** The language of the runner's own words: `en` unless given. */
+    lang?: Lang;
+    /** The wizard's mascot above its pages; a plain dot in the wizard's colour unless given. */
+    Mascot?: (props: MascotProps) => React.ReactNode;
+}
+
+/** The component as a prompt sees it: the same name and props, nothing to draw. */
+export declare const WizardSpec: DefinedComponent<z.ZodObject<{
+wizard: z.ZodString;
+note: z.ZodOptional<z.ZodString>;
+prefill: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>>;
+
+declare type YesNoShape = Named & {
+    kind: "yesno";
+    yes?: string;
+    no?: string;
+};
+
+export { }