import * as z from "zod";
/**
 * Any JSON value accepted by an authoring field (`input.example`,
 * `defaults.run_input`, node bindings, JSON Schema documents).
 *
 * Structurally identical to zod's own `util.JSONType`, and mutually assignable
 * with it — the only difference is that the array member is a **named**
 * interface instead of the anonymous `JSONType[]`.
 *
 * That difference is load-bearing for every frontend consumer. Vue's
 * `UnwrapRef<T>` maps an array member to a fresh anonymous mapped type at each
 * level (`{ [K in keyof T]: UnwrapRefSimple<T[K]> }`), so TypeScript's
 * recursion-identity check never fires on a self-recursive JSON alias and the
 * instantiation depth limit is hit instead:
 *
 * ```
 * error TS2589: Type instantiation is excessively deep and possibly infinite.
 * ```
 *
 * A consumer sees that error on their own `const d = ref<FlowDefinition>(…)`
 * line, with nothing pointing back here. Naming the array member gives the
 * recursion a stable identity, so the check fires and `ref<FlowDefinition>()`
 * resolves. Verified against both TypeScript 5.9 and 6.0.
 *
 * Do not replace `FlowJsonArray` with `FlowJsonValue[]` — that reintroduces the
 * regression. `packages/bridge-vue/test/flow-definition-vue-ref.test-d.ts`
 * guards it.
 */
export interface FlowJsonArray extends Array<FlowJsonValue> {
}
/** @see {@link FlowJsonArray} for why the array member is a named interface. */
export type FlowJsonValue = string | number | boolean | null | FlowJsonArray | {
    [key: string]: FlowJsonValue;
};
declare const modelTier: z.ZodEnum<{
    default: "default";
    small: "small";
    deep: "deep";
}>;
export declare const InputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
    kind: z.ZodLiteral<"text">;
    multiline: z.ZodOptional<z.ZodBoolean>;
}, z.core.$strict>, z.ZodObject<{
    kind: z.ZodLiteral<"choice">;
    options: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        label: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>>;
    multiple: z.ZodOptional<z.ZodBoolean>;
}, z.core.$strict>, z.ZodObject<{
    kind: z.ZodLiteral<"form">;
    fields: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        label: z.ZodString;
        type: z.ZodEnum<{
            number: "number";
            boolean: "boolean";
            file: "file";
            text: "text";
            choice: "choice";
            textarea: "textarea";
            date: "date";
        }>;
        required: z.ZodOptional<z.ZodBoolean>;
        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            label: z.ZodString;
            description: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>>>;
        accept: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$strict>>;
}, z.core.$strict>, z.ZodObject<{
    kind: z.ZodLiteral<"file">;
    accept: z.ZodOptional<z.ZodArray<z.ZodString>>;
    maxSize: z.ZodOptional<z.ZodNumber>;
    multiple: z.ZodOptional<z.ZodBoolean>;
}, z.core.$strict>], "kind">;
/** Validates normalized field shapes without applying authored-v2 graph semantics. */
export declare function parseFlowDefinitionStructure(data: unknown): z.ZodSafeParseResult<{
    schemaVersion: 2;
    id: string;
    version: string;
    name: string;
    nodes: {
        id: string;
        label: string;
        description: string;
        run: {
            kind: "agent";
            instruction: string;
            assets?: string[] | undefined;
            model?: "default" | "small" | "deep" | undefined;
        } | {
            kind: "subprompt";
            instruction: string;
            assets?: string[] | undefined;
            model?: "default" | "small" | "deep" | undefined;
        } | {
            command: string;
            kind: "function";
            assets?: string[] | undefined;
            runtime?: "shell" | "node" | "python" | undefined;
            cwd?: string | undefined;
            successExit?: number[] | undefined;
            capture?: {
                stdout?: string | undefined;
                stderr?: string | undefined;
            } | undefined;
        } | {
            command: string;
            kind: "check";
            onFail: "escalate" | "fail";
            assets?: string[] | undefined;
            runtime?: "shell" | "node" | "python" | undefined;
            cwd?: string | undefined;
            successExit?: number[] | undefined;
            capture?: {
                stdout?: string | undefined;
                stderr?: string | undefined;
            } | undefined;
        } | {
            kind: "gate";
            prompt: string;
            schema: {
                kind: "text";
                multiline?: boolean | undefined;
            } | {
                kind: "choice";
                options: {
                    id: string;
                    label: string;
                    description?: string | undefined;
                }[];
                multiple?: boolean | undefined;
            } | {
                kind: "form";
                fields: {
                    id: string;
                    label: string;
                    type: "number" | "boolean" | "file" | "text" | "choice" | "textarea" | "date";
                    required?: boolean | undefined;
                    options?: {
                        id: string;
                        label: string;
                        description?: string | undefined;
                    }[] | undefined;
                    accept?: string[] | undefined;
                }[];
            } | {
                kind: "file";
                accept?: string[] | undefined;
                maxSize?: number | undefined;
                multiple?: boolean | undefined;
            };
            assets?: string[] | undefined;
        } | {
            kind: "router";
            routes: {
                when: string;
                target: string | null;
            }[];
            assets?: string[] | undefined;
        } | {
            kind: "sub-flow";
            flow: string;
            assets?: string[] | undefined;
            passContext?: boolean | undefined;
        };
        phase?: string | undefined;
        contract?: {
            requires?: {
                expr: string;
                message?: string | undefined;
            }[] | undefined;
            input?: Record<string, FlowJsonValue> | undefined;
            output?: {
                fields?: Record<string, FlowJsonValue> | undefined;
                artifacts?: {
                    kind: string;
                    lifetime: "session" | "persistent";
                }[] | undefined;
            } | undefined;
        } | undefined;
        gate?: {
            approval: "none" | "optional" | "mandatory";
        } | undefined;
        control?: {
            optional?: boolean | undefined;
            retries?: number | undefined;
            timeoutSec?: number | undefined;
            parallelGroup?: string | undefined;
        } | undefined;
    }[];
    edges: {
        id: string;
        source: string;
        target: string;
        type: "flow" | "optional" | "parallel";
    }[];
    $schema?: string | undefined;
    description?: string | undefined;
    input?: {
        schema: Record<string, FlowJsonValue>;
        example?: FlowJsonValue | undefined;
        labelField?: string | undefined;
    } | undefined;
    output?: {
        schema: Record<string, FlowJsonValue>;
    } | undefined;
    defaults?: {
        approval?: "manual" | "auto" | "checkpoint" | undefined;
        researchDepth?: string | undefined;
        autoReview?: boolean | undefined;
        verbosity?: string | undefined;
        cliMode?: boolean | undefined;
        run_input?: FlowJsonValue | undefined;
        parameters?: Record<string, FlowJsonValue> | undefined;
    } | undefined;
    entry?: string | undefined;
    meta?: {
        icon?: string | undefined;
        category?: string | undefined;
        tags?: string[] | undefined;
        stage?: string | undefined;
        onboarding?: {
            input_style: "repo" | "freeform" | "structured";
            placeholder?: string | undefined;
            fields?: string[] | undefined;
        } | undefined;
    } | undefined;
}>;
/** Authoritative strict runtime schema for authored, acyclic Flow v2 definitions. */
export declare const FlowDefinitionSchema: z.ZodObject<{
    $schema: z.ZodOptional<z.ZodString>;
    schemaVersion: z.ZodLiteral<2>;
    id: z.ZodString;
    version: z.ZodString;
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    input: z.ZodOptional<z.ZodObject<{
        schema: z.ZodRecord<z.ZodString, z.ZodType<FlowJsonValue, FlowJsonValue, z.core.$ZodTypeInternals<FlowJsonValue, FlowJsonValue>>>;
        example: z.ZodOptional<z.ZodType<FlowJsonValue, FlowJsonValue, z.core.$ZodTypeInternals<FlowJsonValue, FlowJsonValue>>>;
        labelField: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>>;
    output: z.ZodOptional<z.ZodObject<{
        schema: z.ZodRecord<z.ZodString, z.ZodType<FlowJsonValue, FlowJsonValue, z.core.$ZodTypeInternals<FlowJsonValue, FlowJsonValue>>>;
    }, z.core.$strict>>;
    defaults: z.ZodOptional<z.ZodObject<{
        approval: z.ZodOptional<z.ZodEnum<{
            manual: "manual";
            auto: "auto";
            checkpoint: "checkpoint";
        }>>;
        researchDepth: z.ZodOptional<z.ZodString>;
        autoReview: z.ZodOptional<z.ZodBoolean>;
        verbosity: z.ZodOptional<z.ZodString>;
        cliMode: z.ZodOptional<z.ZodBoolean>;
        run_input: z.ZodOptional<z.ZodType<FlowJsonValue, FlowJsonValue, z.core.$ZodTypeInternals<FlowJsonValue, FlowJsonValue>>>;
        parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FlowJsonValue, FlowJsonValue, z.core.$ZodTypeInternals<FlowJsonValue, FlowJsonValue>>>>;
    }, z.core.$strict>>;
    entry: z.ZodOptional<z.ZodString>;
    nodes: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        label: z.ZodString;
        description: z.ZodString;
        phase: z.ZodOptional<z.ZodString>;
        run: z.ZodDiscriminatedUnion<[z.ZodObject<{
            assets: z.ZodOptional<z.ZodArray<z.ZodString>>;
            kind: z.ZodLiteral<"agent">;
            instruction: z.ZodString;
            model: z.ZodOptional<z.ZodEnum<{
                default: "default";
                small: "small";
                deep: "deep";
            }>>;
        }, z.core.$strict>, z.ZodObject<{
            assets: z.ZodOptional<z.ZodArray<z.ZodString>>;
            kind: z.ZodLiteral<"subprompt">;
            instruction: z.ZodString;
            model: z.ZodOptional<z.ZodEnum<{
                default: "default";
                small: "small";
                deep: "deep";
            }>>;
        }, z.core.$strict>, z.ZodObject<{
            assets: z.ZodOptional<z.ZodArray<z.ZodString>>;
            runtime: z.ZodOptional<z.ZodEnum<{
                shell: "shell";
                node: "node";
                python: "python";
            }>>;
            command: z.ZodString;
            cwd: z.ZodOptional<z.ZodString>;
            successExit: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
            capture: z.ZodOptional<z.ZodObject<{
                stdout: z.ZodOptional<z.ZodString>;
                stderr: z.ZodOptional<z.ZodString>;
            }, z.core.$strict>>;
            kind: z.ZodLiteral<"function">;
        }, z.core.$strict>, z.ZodObject<{
            assets: z.ZodOptional<z.ZodArray<z.ZodString>>;
            runtime: z.ZodOptional<z.ZodEnum<{
                shell: "shell";
                node: "node";
                python: "python";
            }>>;
            command: z.ZodString;
            cwd: z.ZodOptional<z.ZodString>;
            successExit: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
            capture: z.ZodOptional<z.ZodObject<{
                stdout: z.ZodOptional<z.ZodString>;
                stderr: z.ZodOptional<z.ZodString>;
            }, z.core.$strict>>;
            kind: z.ZodLiteral<"check">;
            onFail: z.ZodDefault<z.ZodEnum<{
                escalate: "escalate";
                fail: "fail";
            }>>;
        }, z.core.$strict>, z.ZodObject<{
            assets: z.ZodOptional<z.ZodArray<z.ZodString>>;
            kind: z.ZodLiteral<"gate">;
            prompt: z.ZodString;
            schema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                kind: z.ZodLiteral<"text">;
                multiline: z.ZodOptional<z.ZodBoolean>;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"choice">;
                options: z.ZodArray<z.ZodObject<{
                    id: z.ZodString;
                    label: z.ZodString;
                    description: z.ZodOptional<z.ZodString>;
                }, z.core.$strict>>;
                multiple: z.ZodOptional<z.ZodBoolean>;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"form">;
                fields: z.ZodArray<z.ZodObject<{
                    id: z.ZodString;
                    label: z.ZodString;
                    type: z.ZodEnum<{
                        number: "number";
                        boolean: "boolean";
                        file: "file";
                        text: "text";
                        choice: "choice";
                        textarea: "textarea";
                        date: "date";
                    }>;
                    required: z.ZodOptional<z.ZodBoolean>;
                    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        id: z.ZodString;
                        label: z.ZodString;
                        description: z.ZodOptional<z.ZodString>;
                    }, z.core.$strict>>>;
                    accept: z.ZodOptional<z.ZodArray<z.ZodString>>;
                }, z.core.$strict>>;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"file">;
                accept: z.ZodOptional<z.ZodArray<z.ZodString>>;
                maxSize: z.ZodOptional<z.ZodNumber>;
                multiple: z.ZodOptional<z.ZodBoolean>;
            }, z.core.$strict>], "kind">;
        }, z.core.$strict>, z.ZodObject<{
            assets: z.ZodOptional<z.ZodArray<z.ZodString>>;
            kind: z.ZodLiteral<"router">;
            routes: z.ZodArray<z.ZodObject<{
                when: z.ZodString;
                target: z.ZodNullable<z.ZodString>;
            }, z.core.$strict>>;
        }, z.core.$strict>, z.ZodObject<{
            assets: z.ZodOptional<z.ZodArray<z.ZodString>>;
            kind: z.ZodLiteral<"sub-flow">;
            flow: z.ZodString;
            passContext: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strict>], "kind">;
        contract: z.ZodOptional<z.ZodObject<{
            requires: z.ZodOptional<z.ZodArray<z.ZodObject<{
                expr: z.ZodString;
                message: z.ZodOptional<z.ZodString>;
            }, z.core.$strict>>>;
            input: z.ZodOptional<z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodType<FlowJsonValue, FlowJsonValue, z.core.$ZodTypeInternals<FlowJsonValue, FlowJsonValue>>>>>;
            output: z.ZodOptional<z.ZodObject<{
                fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FlowJsonValue, FlowJsonValue, z.core.$ZodTypeInternals<FlowJsonValue, FlowJsonValue>>>>;
                artifacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    kind: z.ZodString;
                    lifetime: z.ZodEnum<{
                        session: "session";
                        persistent: "persistent";
                    }>;
                }, z.core.$strict>>>;
            }, z.core.$strict>>;
        }, z.core.$strict>>;
        gate: z.ZodOptional<z.ZodObject<{
            approval: z.ZodEnum<{
                none: "none";
                optional: "optional";
                mandatory: "mandatory";
            }>;
        }, z.core.$strict>>;
        control: z.ZodOptional<z.ZodObject<{
            optional: z.ZodOptional<z.ZodBoolean>;
            retries: z.ZodOptional<z.ZodNumber>;
            timeoutSec: z.ZodOptional<z.ZodNumber>;
            parallelGroup: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>>;
    }, z.core.$strict>>;
    edges: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        source: z.ZodString;
        target: z.ZodString;
        type: z.ZodEnum<{
            flow: "flow";
            optional: "optional";
            parallel: "parallel";
        }>;
    }, z.core.$strict>>;
    meta: z.ZodOptional<z.ZodObject<{
        icon: z.ZodOptional<z.ZodString>;
        category: z.ZodOptional<z.ZodString>;
        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
        stage: z.ZodOptional<z.ZodString>;
        onboarding: z.ZodOptional<z.ZodObject<{
            input_style: z.ZodEnum<{
                repo: "repo";
                freeform: "freeform";
                structured: "structured";
            }>;
            placeholder: z.ZodOptional<z.ZodString>;
            fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
        }, z.core.$strict>>;
    }, z.core.$strict>>;
}, z.core.$strict>;
/** Validated authoring content that is strict, acyclic, and always schema version 2. */
export type FlowDefinition = z.infer<typeof FlowDefinitionSchema>;
/** Graph vertex whose execution identity comes only from its `run.kind`. */
export type FlowNode = FlowDefinition["nodes"][number];
/** Directed dependency link whose authored array position remains content-significant. */
export type FlowEdge = FlowDefinition["edges"][number];
/** Closed execution-owner declaration with no dispatch or conversation-mode switches. */
export type FlowNodeRun = FlowNode["run"];
/** Closed vocabulary of the seven supported execution-owner identities. */
export type FlowNodeKind = FlowNodeRun["kind"];
/** Validation boundary applied to values entering a Flow run. */
export type FlowInputContract = NonNullable<FlowDefinition["input"]>;
/** Validation boundary applied to values leaving a Flow run. */
export type FlowOutputContract = NonNullable<FlowDefinition["output"]>;
/** Node admission and data contract; output typing is paid only when downstream consumers need it. */
export type FlowNodeContract = NonNullable<FlowNode["contract"]>;
/** Availability and failure policy that never changes execution ownership. */
export type FlowNodeControl = NonNullable<FlowNode["control"]>;
/** Named values resolved at the consumer boundary before admission. */
export type FlowNodeBindings = NonNullable<FlowNode["contract"]>["input"];
/** Bounded deterministic admission condition; arbitrary calls and property access are invalid. */
export type FlowNodePrecondition = NonNullable<FlowNode["contract"]>["requires"] extends Array<infer T> | undefined ? T : never;
/** Ordered router branch; the first matching condition owns the routing decision. */
export type FlowRoute = Extract<FlowNodeRun, {
    kind: "router";
}>["routes"][number];
/** Asset requirement independent of node identity and available on every run kind. */
export type FlowAssetRef = NonNullable<FlowNodeRun["assets"]>[number];
/** Model tier for `agent` and `subprompt` runs; `default` inherits the session model
 * (`agent`) or the runtime default (`subprompt`) rather than naming a concrete model. */
export type FlowModelTier = z.infer<typeof modelTier>;
export {};
//# sourceMappingURL=schema.d.ts.map