@hatua/schema 0.0.0 → 0.1.0

package/dist/generated/definition.d.ts

@@ -0,0 +1,309 @@
+import { z } from 'zod';
+/**
+ * A name that has to survive being a path segment. Every user-chosen name sits one segment below a reserved root — `steps.<id>`, `triggers.<id>`, `var.<key>`, `block.<id>` — so a name the expression grammar cannot parse is a name nothing can ever address. Refused here rather than accepted into a file and reported as a broken Reference on every use of it.
+ */
+export declare const identifier: z.ZodString;
+export type Identifier = z.infer<typeof identifier>;
+/**
+ * One Board: a step tree whose root is this contract rather than the workflow's triggers.
+ * Step ids are scoped to the block, so `{{steps.put}}` inside one names that block's `put` and two blocks may each have a step by the same name. A block's `vars` are its own and are rebuilt on every invocation, which is why a block called twice carries nothing between calls.
+ */
+export declare const block: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    params: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        k: z.ZodString;
+        label: z.ZodString;
+        t: z.ZodEnum<{
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            text: "text";
+            datetime: "datetime";
+            list: "list";
+        }>;
+        of: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>>;
+    }, z.core.$strict>>>;
+    outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        k: z.ZodString;
+        label: z.ZodString;
+        t: z.ZodEnum<{
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            text: "text";
+            datetime: "datetime";
+            list: "list";
+        }>;
+        of: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>>;
+    }, z.core.$strict>>>;
+    vars: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        t: z.ZodEnum<{
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            text: "text";
+            datetime: "datetime";
+            list: "list";
+        }>;
+        of: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            k: z.ZodString;
+            label: z.ZodString;
+            t: z.ZodEnum<{
+                number: "number";
+                boolean: "boolean";
+                object: "object";
+                text: "text";
+                datetime: "datetime";
+                list: "list";
+            }>;
+            of: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>>;
+        }, z.core.$strict>>>;
+        value: z.ZodUnknown;
+    }, z.core.$strict>>>;
+    steps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        use: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        with: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        branches: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            when: z.ZodOptional<z.ZodString>;
+            steps: z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>;
+        }, z.core.$strict>>>;
+        steps: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>>;
+        handler: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>>;
+        until: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type Block = z.infer<typeof block>;
+/**
+ * One parameter or one output. Spelled `{k, label, t, of}` exactly as a Component Manifest's output and a Run Context key are — ADR-0012 rejected inventing a second spelling for an idea the contract already has one of, and the reasoning holds here unchanged.
+ */
+export declare const declaration: z.ZodObject<{
+    k: z.ZodString;
+    label: z.ZodString;
+    t: z.ZodEnum<{
+        number: "number";
+        boolean: "boolean";
+        object: "object";
+        text: "text";
+        datetime: "datetime";
+        list: "list";
+    }>;
+    of: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>>;
+}, z.core.$strict>;
+export type Declaration = z.infer<typeof declaration>;
+export declare const connection: z.ZodObject<{
+    id: z.ZodString;
+    ref: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type Connection = z.infer<typeof connection>;
+export declare const trigger: z.ZodObject<{
+    id: z.ZodString;
+    use: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    with: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type Trigger = z.infer<typeof trigger>;
+/**
+ * A list of key/value objects rather than a map, which is what let `t` be added here without inventing a second spelling for a variable.
+ * NOT a `declaration`. A declaration is a contract with nothing in it; a variable carries a value, and its key is its own label — the builder shows `var.digest_to`, not a friendly name. `t` and `of` are spelled identically to a declaration's so one function reads both, but three shared fields out of five is not one idea.
+ */
+export declare const variable: z.ZodObject<{
+    key: z.ZodString;
+    t: z.ZodEnum<{
+        number: "number";
+        boolean: "boolean";
+        object: "object";
+        text: "text";
+        datetime: "datetime";
+        list: "list";
+    }>;
+    of: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        k: z.ZodString;
+        label: z.ZodString;
+        t: z.ZodEnum<{
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            text: "text";
+            datetime: "datetime";
+            list: "list";
+        }>;
+        of: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>>;
+    }, z.core.$strict>>>;
+    value: z.ZodUnknown;
+}, z.core.$strict>;
+export type Variable = z.infer<typeof variable>;
+export declare const step: z.ZodObject<{
+    id: z.ZodString;
+    use: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    with: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    branches: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        when: z.ZodOptional<z.ZodString>;
+        steps: z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>;
+    }, z.core.$strict>>>;
+    steps: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>>;
+    handler: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>>;
+    until: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type Step = z.infer<typeof step>;
+export declare const branch: z.ZodObject<{
+    label: z.ZodString;
+    when: z.ZodOptional<z.ZodString>;
+    steps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        use: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        with: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        branches: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>>;
+        steps: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>>;
+        handler: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>>;
+        until: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type Branch = z.infer<typeof branch>;
+/**
+ * Field values keyed by the manifest's `FieldSpec.k`. Templates remain `{{…}}` strings so the document round-trips and a step can be renamed without breaking a mapping.
+ * A `map` field holds a list of `{key, value, type}` objects rather than a scalar — see `core.map` on `use`. That shape is deliberately NOT declared as a `$def` here: which key holds a map field is decided by the Component Manifest, not by this schema, so JSON Schema cannot reach it. It is checked where the manifest is known, in `@hatua/model` and the Go SDK, and an unreferenced definition would be a promise this file does not keep.
+ * `key` is how downstream steps address the entry — `{{<step id>.<key>}}`. `type` is declared rather than inferred from `value`, for the same reason every other field's type is: the expression is checked against the declared type, never the reverse.
+ */
+export declare const values: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export type Values = z.infer<typeof values>;
+/**
+ * The declarative description of a workflow — its steps, the mapping between one step's typed outputs and the next step's inputs, branches and loops. Read AND written by Hatua, unlike a Workflow Execution which is only ever read.
+ * Steps form a TREE, nesting through `branches` (forks) and `steps` (loops); they are never an arbitrary graph. There is deliberately no position data anywhere in this document: node placement is computed from the tree on every render, which is what makes it impossible for a hand-edited file and the flow map to disagree. See ADR-0001.
+ */
+export declare const workflowDefinition: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodNumber;
+    status: z.ZodEnum<{
+        published: "published";
+        draft: "draft";
+        archived: "archived";
+    }>;
+    connections: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        ref: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>>;
+    triggers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        use: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        with: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>>;
+    vars: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        t: z.ZodEnum<{
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            text: "text";
+            datetime: "datetime";
+            list: "list";
+        }>;
+        of: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            k: z.ZodString;
+            label: z.ZodString;
+            t: z.ZodEnum<{
+                number: "number";
+                boolean: "boolean";
+                object: "object";
+                text: "text";
+                datetime: "datetime";
+                list: "list";
+            }>;
+            of: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>>;
+        }, z.core.$strict>>>;
+        value: z.ZodUnknown;
+    }, z.core.$strict>>>;
+    blocks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            k: z.ZodString;
+            label: z.ZodString;
+            t: z.ZodEnum<{
+                number: "number";
+                boolean: "boolean";
+                object: "object";
+                text: "text";
+                datetime: "datetime";
+                list: "list";
+            }>;
+            of: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>>;
+        }, z.core.$strict>>>;
+        outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            k: z.ZodString;
+            label: z.ZodString;
+            t: z.ZodEnum<{
+                number: "number";
+                boolean: "boolean";
+                object: "object";
+                text: "text";
+                datetime: "datetime";
+                list: "list";
+            }>;
+            of: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>>;
+        }, z.core.$strict>>>;
+        vars: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            t: z.ZodEnum<{
+                number: "number";
+                boolean: "boolean";
+                object: "object";
+                text: "text";
+                datetime: "datetime";
+                list: "list";
+            }>;
+            of: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                k: z.ZodString;
+                label: z.ZodString;
+                t: z.ZodEnum<{
+                    number: "number";
+                    boolean: "boolean";
+                    object: "object";
+                    text: "text";
+                    datetime: "datetime";
+                    list: "list";
+                }>;
+                of: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>>;
+            }, z.core.$strict>>>;
+            value: z.ZodUnknown;
+        }, z.core.$strict>>>;
+        steps: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            use: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            with: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            branches: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                when: z.ZodOptional<z.ZodString>;
+                steps: z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>;
+            }, z.core.$strict>>>;
+            steps: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>>;
+            handler: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>>;
+            until: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+    steps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        use: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        with: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        branches: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            when: z.ZodOptional<z.ZodString>;
+            steps: z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>;
+        }, z.core.$strict>>>;
+        steps: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>>;
+        handler: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>>;
+        until: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type WorkflowDefinition = z.infer<typeof workflowDefinition>;

package/dist/generated/execution.d.ts

@@ -0,0 +1,148 @@
+import { z } from 'zod';
+export declare const stepExecution: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        pending: "pending";
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+        skipped: "skipped";
+    }>;
+    duration_ms: z.ZodOptional<z.ZodNumber>;
+    resolved_input: z.ZodOptional<z.ZodUnknown>;
+    output: z.ZodOptional<z.ZodUnknown>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    error: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        code: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    iterations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        status: z.ZodEnum<{
+            pending: "pending";
+            running: "running";
+            succeeded: "succeeded";
+            failed: "failed";
+            skipped: "skipped";
+        }>;
+        duration_ms: z.ZodOptional<z.ZodNumber>;
+        steps: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>>;
+        error: z.ZodOptional<z.ZodObject<{
+            message: z.ZodString;
+            code: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type StepExecution = z.infer<typeof stepExecution>;
+export declare const iteration: z.ZodObject<{
+    index: z.ZodNumber;
+    status: z.ZodEnum<{
+        pending: "pending";
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+        skipped: "skipped";
+    }>;
+    duration_ms: z.ZodOptional<z.ZodNumber>;
+    steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            pending: "pending";
+            running: "running";
+            succeeded: "succeeded";
+            failed: "failed";
+            skipped: "skipped";
+        }>;
+        duration_ms: z.ZodOptional<z.ZodNumber>;
+        resolved_input: z.ZodOptional<z.ZodUnknown>;
+        output: z.ZodOptional<z.ZodUnknown>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        error: z.ZodOptional<z.ZodObject<{
+            message: z.ZodString;
+            code: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        iterations: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>>;
+    }, z.core.$strict>>>;
+    error: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        code: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type Iteration = z.infer<typeof iteration>;
+export declare const error: z.ZodObject<{
+    message: z.ZodString;
+    code: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type Error = z.infer<typeof error>;
+export declare const logEntry: z.ZodObject<{
+    at: z.ZodISODateTime;
+    step: z.ZodOptional<z.ZodString>;
+    channel: z.ZodOptional<z.ZodString>;
+    message: z.ZodString;
+}, z.core.$strict>;
+export type LogEntry = z.infer<typeof logEntry>;
+/**
+ * The record of one run of a Workflow Definition, handed to Hatua by the Host and rendered as run history. Read-only: Hatua never produces one, because it never executes anything.
+ * An execution REFERENCES its definition by version rather than embedding it. That is why published versions are immutable and retained — painting a three-week-old run against today's definition would put durations on steps that did not exist and silently drop steps that did.
+ * There is no run-level metadata block. Totals and pivots (`tokens per model`, `tokens per step`) are derived by Hatua from the per-step values below, using the `measure` / `dimension` roles the component manifests declare. That keeps runners from each inventing their own summary shape.
+ */
+export declare const workflowExecution: z.ZodObject<{
+    run_id: z.ZodString;
+    status: z.ZodEnum<{
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+    }>;
+    workflow: z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodNumber;
+    }, z.core.$strict>;
+    trigger: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>;
+    started_at: z.ZodISODateTime;
+    finished_at: z.ZodOptional<z.ZodISODateTime>;
+    duration_ms: z.ZodOptional<z.ZodNumber>;
+    steps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            pending: "pending";
+            running: "running";
+            succeeded: "succeeded";
+            failed: "failed";
+            skipped: "skipped";
+        }>;
+        duration_ms: z.ZodOptional<z.ZodNumber>;
+        resolved_input: z.ZodOptional<z.ZodUnknown>;
+        output: z.ZodOptional<z.ZodUnknown>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        error: z.ZodOptional<z.ZodObject<{
+            message: z.ZodString;
+            code: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        iterations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            index: z.ZodNumber;
+            status: z.ZodEnum<{
+                pending: "pending";
+                running: "running";
+                succeeded: "succeeded";
+                failed: "failed";
+                skipped: "skipped";
+            }>;
+            duration_ms: z.ZodOptional<z.ZodNumber>;
+            steps: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>>;
+            error: z.ZodOptional<z.ZodObject<{
+                message: z.ZodString;
+                code: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    log: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        at: z.ZodISODateTime;
+        step: z.ZodOptional<z.ZodString>;
+        channel: z.ZodOptional<z.ZodString>;
+        message: z.ZodString;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type WorkflowExecution = z.infer<typeof workflowExecution>;

package/dist/generated/function.d.ts

@@ -0,0 +1,193 @@
+import { z } from 'zod';
+export declare const functionNamespace: z.ZodObject<{
+    kind: z.ZodEnum<{
+        function: "function";
+    }>;
+    namespace: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+    functions: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodEnum<{
+                number: "number";
+                boolean: "boolean";
+                object: "object";
+                text: "text";
+                null: "null";
+                unknown: "unknown";
+                datetime: "datetime";
+                list: "list";
+                item: "item";
+            }>;
+            description: z.ZodOptional<z.ZodString>;
+            optional: z.ZodOptional<z.ZodBoolean>;
+            variadic: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>>;
+        returns: z.ZodEnum<{
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            text: "text";
+            null: "null";
+            unknown: "unknown";
+            datetime: "datetime";
+            list: "list";
+            item: "item";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type FunctionNamespace = z.infer<typeof functionNamespace>;
+export declare const functionSpec: z.ZodObject<{
+    name: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+    params: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            text: "text";
+            null: "null";
+            unknown: "unknown";
+            datetime: "datetime";
+            list: "list";
+            item: "item";
+        }>;
+        description: z.ZodOptional<z.ZodString>;
+        optional: z.ZodOptional<z.ZodBoolean>;
+        variadic: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>>;
+    returns: z.ZodEnum<{
+        number: "number";
+        boolean: "boolean";
+        object: "object";
+        text: "text";
+        null: "null";
+        unknown: "unknown";
+        datetime: "datetime";
+        list: "list";
+        item: "item";
+    }>;
+}, z.core.$strict>;
+export type FunctionSpec = z.infer<typeof functionSpec>;
+export declare const param: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        number: "number";
+        boolean: "boolean";
+        object: "object";
+        text: "text";
+        null: "null";
+        unknown: "unknown";
+        datetime: "datetime";
+        list: "list";
+        item: "item";
+    }>;
+    description: z.ZodOptional<z.ZodString>;
+    optional: z.ZodOptional<z.ZodBoolean>;
+    variadic: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type Param = z.infer<typeof param>;
+/**
+ * The Component Manifest's output types, plus the two that exist only in the expression language: `unknown` for a value whose type cannot be known statically — which is accepted with a warning and checked at run time — and `null`, the one absent value, which satisfies any declared type.
+ */
+export declare const valueType: z.ZodEnum<{
+    number: "number";
+    boolean: "boolean";
+    object: "object";
+    text: "text";
+    null: "null";
+    unknown: "unknown";
+    datetime: "datetime";
+    list: "list";
+    item: "item";
+}>;
+export type ValueType = z.infer<typeof valueType>;
+/**
+ * The Host-supplied declaration of functions an Expression may call — `crm.owner_of(...)`, `pricing.tier(...)`. Hatua ships its own set under `dt`, `text`, `num`, `list` and `json`; the format is identical and the only difference is who wrote the file.
+ * Hatua never implements a Host function. It reads the signature so the builder can offer it, check its arity and argument types, and know what it returns; the Host's runner supplies the code. A declaration with no implementation behind it fails when the registry is built, not at a call site in production.
+ * This is a separate file rather than a third `kind:` inside the Component Manifest. A conditional manifest shape — `if kind is function then ...` — would need the JSON-Schema-to-zod generator to grow `if`/`then` support, and ADR-0006 keeps that generator deliberately narrow precisely because a silent mistranslation there is the failure the whole decision prevents.
+ * A namespace and name Hatua already declares is a loud error at merge time. Either silent winner — Hatua's or the Host's — is a workflow that behaves differently depending on which registry was built first, and neither is discoverable from the workflow.
+ */
+export declare const functionManifest: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodEnum<{
+        function: "function";
+    }>;
+    namespace: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+    functions: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodEnum<{
+                number: "number";
+                boolean: "boolean";
+                object: "object";
+                text: "text";
+                null: "null";
+                unknown: "unknown";
+                datetime: "datetime";
+                list: "list";
+                item: "item";
+            }>;
+            description: z.ZodOptional<z.ZodString>;
+            optional: z.ZodOptional<z.ZodBoolean>;
+            variadic: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>>;
+        returns: z.ZodEnum<{
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            text: "text";
+            null: "null";
+            unknown: "unknown";
+            datetime: "datetime";
+            list: "list";
+            item: "item";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    namespaces: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            function: "function";
+        }>;
+        namespace: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+        functions: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            summary: z.ZodOptional<z.ZodString>;
+            params: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodEnum<{
+                    number: "number";
+                    boolean: "boolean";
+                    object: "object";
+                    text: "text";
+                    null: "null";
+                    unknown: "unknown";
+                    datetime: "datetime";
+                    list: "list";
+                    item: "item";
+                }>;
+                description: z.ZodOptional<z.ZodString>;
+                optional: z.ZodOptional<z.ZodBoolean>;
+                variadic: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>>;
+            returns: z.ZodEnum<{
+                number: "number";
+                boolean: "boolean";
+                object: "object";
+                text: "text";
+                null: "null";
+                unknown: "unknown";
+                datetime: "datetime";
+                list: "list";
+                item: "item";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>]>;
+export type FunctionManifest = z.infer<typeof functionManifest>;

package/dist/generated/index.d.ts

@@ -0,0 +1,5 @@
+export * from './component';
+export * from './context';
+export * from './definition';
+export * from './execution';
+export * from './function';

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The contract. Types and runtime validation for the three payloads.
+ *
+ * Most of this package is GENERATED from `schemas/*.schema.yaml`, which is the
+ * source of truth — see `schemas/README.md` for why the schema is hand-authored
+ * as JSON Schema rather than as zod. Only behaviour that no schema can express
+ * is hand-written here.
+ */
+export * from './generated';
+export * from './references';