import { z } from "zod";
import { type FieldSemantic, type JsonSchema, type RiskLabel, type Step, type ToolDescriptor } from "../core/index.js";
export declare const VENDO_CATALOG_FORMAT: "vendo/catalog@1";
/** A deterministic or explicitly registered host-component catalog entry. */
export interface CatalogEntry {
    name: string;
    /** Root-relative module plus export/property path, for example `./src/card.tsx#Card`. */
    exportPath: string;
    /** JSON Schema 2020-12 compatible shape, using the ToolDescriptor.inputSchema convention. */
    propsSchema: JsonSchema;
    /** Human-reviewed when-to-use guidance. Scanners never author this field. */
    description: string;
    /** Human-reviewed JSX snippets. Scanners never author this field. */
    examples?: string[];
    source: "registered" | "scanned";
    disabled?: boolean;
    note?: string;
}
/** Strict because hand edits must fail loudly rather than disappear on parse. */
export declare const catalogEntrySchema: z.ZodObject<{
    name: z.ZodString;
    exportPath: z.ZodString;
    propsSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    description: z.ZodString;
    examples: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    source: z.ZodEnum<["registered", "scanned"]>;
    disabled: z.ZodOptional<z.ZodBoolean>;
    note: z.ZodOptional<z.ZodString>;
}, "strict", z.ZodTypeAny, {
    name: string;
    description: string;
    source: "registered" | "scanned";
    exportPath: string;
    propsSchema: Record<string, unknown>;
    examples?: string[] | undefined;
    note?: string | undefined;
    disabled?: boolean | undefined;
}, {
    name: string;
    description: string;
    source: "registered" | "scanned";
    exportPath: string;
    propsSchema: Record<string, unknown>;
    examples?: string[] | undefined;
    note?: string | undefined;
    disabled?: boolean | undefined;
}>;
export interface CatalogFile {
    format: typeof VENDO_CATALOG_FORMAT;
    entries: CatalogEntry[];
}
export declare const catalogFileSchema: z.ZodEffects<z.ZodObject<{
    format: z.ZodLiteral<"vendo/catalog@1">;
    entries: z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        exportPath: z.ZodString;
        propsSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        description: z.ZodString;
        examples: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        source: z.ZodEnum<["registered", "scanned"]>;
        disabled: z.ZodOptional<z.ZodBoolean>;
        note: z.ZodOptional<z.ZodString>;
    }, "strict", z.ZodTypeAny, {
        name: string;
        description: string;
        source: "registered" | "scanned";
        exportPath: string;
        propsSchema: Record<string, unknown>;
        examples?: string[] | undefined;
        note?: string | undefined;
        disabled?: boolean | undefined;
    }, {
        name: string;
        description: string;
        source: "registered" | "scanned";
        exportPath: string;
        propsSchema: Record<string, unknown>;
        examples?: string[] | undefined;
        note?: string | undefined;
        disabled?: boolean | undefined;
    }>, "many">;
}, "strict", z.ZodTypeAny, {
    entries: {
        name: string;
        description: string;
        source: "registered" | "scanned";
        exportPath: string;
        propsSchema: Record<string, unknown>;
        examples?: string[] | undefined;
        note?: string | undefined;
        disabled?: boolean | undefined;
    }[];
    format: "vendo/catalog@1";
}, {
    entries: {
        name: string;
        description: string;
        source: "registered" | "scanned";
        exportPath: string;
        propsSchema: Record<string, unknown>;
        examples?: string[] | undefined;
        note?: string | undefined;
        disabled?: boolean | undefined;
    }[];
    format: "vendo/catalog@1";
}>, {
    entries: {
        name: string;
        description: string;
        source: "registered" | "scanned";
        exportPath: string;
        propsSchema: Record<string, unknown>;
        examples?: string[] | undefined;
        note?: string | undefined;
        disabled?: boolean | undefined;
    }[];
    format: "vendo/catalog@1";
}, {
    entries: {
        name: string;
        description: string;
        source: "registered" | "scanned";
        exportPath: string;
        propsSchema: Record<string, unknown>;
        examples?: string[] | undefined;
        note?: string | undefined;
        disabled?: boolean | undefined;
    }[];
    format: "vendo/catalog@1";
}>;
/** 04-actions §1: the http methods a binding can carry. */
export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
export declare const httpMethodSchema: z.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
/** 04-actions §1: execution binding for a scanned host route. */
export interface RouteBinding {
    kind: "route";
    method: HttpMethod;
    path: string;
    argsIn: "query" | "body";
}
export declare const routeBindingSchema: z.ZodObject<{
    kind: z.ZodLiteral<"route">;
    method: z.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
    path: z.ZodString;
    argsIn: z.ZodEnum<["query", "body"]>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    kind: z.ZodLiteral<"route">;
    method: z.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
    path: z.ZodString;
    argsIn: z.ZodEnum<["query", "body"]>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    kind: z.ZodLiteral<"route">;
    method: z.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
    path: z.ZodString;
    argsIn: z.ZodEnum<["query", "body"]>;
}, z.ZodTypeAny, "passthrough">>;
/**
 * 04-actions §1: execution binding for an OpenAPI operation.
 * `method` + `path` are carried alongside the contract's `operationId`/`baseUrl`
 * so the runtime can execute without re-reading the spec (additive fields;
 * consumers ignore unknown keys per 01-core §15).
 */
export interface OpenApiBinding {
    kind: "openapi";
    operationId: string;
    baseUrl?: string;
    method: HttpMethod;
    path: string;
}
export declare const openApiBindingSchema: z.ZodObject<{
    kind: z.ZodLiteral<"openapi">;
    operationId: z.ZodString;
    baseUrl: z.ZodOptional<z.ZodString>;
    method: z.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
    path: z.ZodString;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    kind: z.ZodLiteral<"openapi">;
    operationId: z.ZodString;
    baseUrl: z.ZodOptional<z.ZodString>;
    method: z.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
    path: z.ZodString;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    kind: z.ZodLiteral<"openapi">;
    operationId: z.ZodString;
    baseUrl: z.ZodOptional<z.ZodString>;
    method: z.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
    path: z.ZodString;
}, z.ZodTypeAny, "passthrough">>;
/**
 * 04-actions §1 (additive within vendo/tools@3): execution binding for a tRPC
 * procedure. Tool identity is mount + `procedure` dot-path, not a method+path
 * pair. Execution is the tRPC HTTP envelope against the host mount: queries
 * are GET `{mount}/{procedure}?input=...`, mutations POST `{mount}/{procedure}`.
 * `transformer: "superjson"` marks mounts whose tRPC root applies the superjson
 * data transformer, so the runtime wraps/unwraps the `{ json: ... }` envelope.
 */
export interface TrpcBinding {
    kind: "trpc";
    procedure: string;
    type: "query" | "mutation";
    mount: string;
    transformer?: "superjson";
}
export declare const trpcBindingSchema: z.ZodObject<{
    kind: z.ZodLiteral<"trpc">;
    procedure: z.ZodString;
    type: z.ZodEnum<["query", "mutation"]>;
    mount: z.ZodString;
    transformer: z.ZodOptional<z.ZodLiteral<"superjson">>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    kind: z.ZodLiteral<"trpc">;
    procedure: z.ZodString;
    type: z.ZodEnum<["query", "mutation"]>;
    mount: z.ZodString;
    transformer: z.ZodOptional<z.ZodLiteral<"superjson">>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    kind: z.ZodLiteral<"trpc">;
    procedure: z.ZodString;
    type: z.ZodEnum<["query", "mutation"]>;
    mount: z.ZodString;
    transformer: z.ZodOptional<z.ZodLiteral<"superjson">>;
}, z.ZodTypeAny, "passthrough">>;
/**
 * 04-actions §1 (additive within vendo/tools@3): execution binding for a Next.js
 * server action. Tool identity is `module` (root-relative posix path) plus
 * `exportName` — never a method+path pair. Execution is direct in-process
 * dispatch through the registration map the generated wiring file passes into
 * `createVendo({ serverActions })`; `params` carries the action's ordered
 * parameter names so the args object maps onto positional arguments. When the
 * registration map lacks the action, execution fails closed (clear error, no
 * work performed). There are NO Next action-id bindings.
 */
export interface ServerActionBinding {
    kind: "server-action";
    module: string;
    exportName: string;
    params: string[];
}
export declare const serverActionBindingSchema: z.ZodObject<{
    kind: z.ZodLiteral<"server-action">;
    module: z.ZodString;
    exportName: z.ZodString;
    params: z.ZodArray<z.ZodString, "many">;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    kind: z.ZodLiteral<"server-action">;
    module: z.ZodString;
    exportName: z.ZodString;
    params: z.ZodArray<z.ZodString, "many">;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    kind: z.ZodLiteral<"server-action">;
    module: z.ZodString;
    exportName: z.ZodString;
    params: z.ZodArray<z.ZodString, "many">;
}, z.ZodTypeAny, "passthrough">>;
/**
 * 04-actions §6: ordered steps over primitive host/connector tools, reusing the
 * core §11 `Step` shape. Expressions see `{ args, steps, item }`. Compounds are
 * agent-authored: they live in `.vendo/overrides.json` compounds, never `tools.json`.
 */
export interface CompoundBinding {
    kind: "compound";
    steps: Step[];
}
export declare const compoundBindingSchema: z.ZodEffects<z.ZodObject<{
    kind: z.ZodLiteral<"compound">;
    steps: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        tool: z.ZodString;
        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        if: z.ZodOptional<z.ZodString>;
        forEach: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        tool: z.ZodString;
        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        if: z.ZodOptional<z.ZodString>;
        forEach: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        tool: z.ZodString;
        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        if: z.ZodOptional<z.ZodString>;
        forEach: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    kind: z.ZodLiteral<"compound">;
    steps: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        tool: z.ZodString;
        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        if: z.ZodOptional<z.ZodString>;
        forEach: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        tool: z.ZodString;
        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        if: z.ZodOptional<z.ZodString>;
        forEach: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        tool: z.ZodString;
        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        if: z.ZodOptional<z.ZodString>;
        forEach: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    kind: z.ZodLiteral<"compound">;
    steps: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        tool: z.ZodString;
        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        if: z.ZodOptional<z.ZodString>;
        forEach: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        tool: z.ZodString;
        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        if: z.ZodOptional<z.ZodString>;
        forEach: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        tool: z.ZodString;
        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        if: z.ZodOptional<z.ZodString>;
        forEach: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
    kind: z.ZodLiteral<"compound">;
    steps: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        tool: z.ZodString;
        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        if: z.ZodOptional<z.ZodString>;
        forEach: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        tool: z.ZodString;
        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        if: z.ZodOptional<z.ZodString>;
        forEach: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        tool: z.ZodString;
        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        if: z.ZodOptional<z.ZodString>;
        forEach: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    kind: z.ZodLiteral<"compound">;
    steps: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        tool: z.ZodString;
        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        if: z.ZodOptional<z.ZodString>;
        forEach: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        tool: z.ZodString;
        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        if: z.ZodOptional<z.ZodString>;
        forEach: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        tool: z.ZodString;
        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        if: z.ZodOptional<z.ZodString>;
        forEach: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
}, z.ZodTypeAny, "passthrough">>;
/** The bindings deterministic extraction may emit into `.vendo/tools.json`. */
export type PrimitiveToolBinding = RouteBinding | OpenApiBinding | TrpcBinding | ServerActionBinding;
export type ToolBinding = RouteBinding | OpenApiBinding | TrpcBinding | ServerActionBinding | CompoundBinding;
export declare const toolBindingSchema: z.ZodUnion<[z.ZodObject<{
    kind: z.ZodLiteral<"route">;
    method: z.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
    path: z.ZodString;
    argsIn: z.ZodEnum<["query", "body"]>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    kind: z.ZodLiteral<"route">;
    method: z.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
    path: z.ZodString;
    argsIn: z.ZodEnum<["query", "body"]>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    kind: z.ZodLiteral<"route">;
    method: z.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
    path: z.ZodString;
    argsIn: z.ZodEnum<["query", "body"]>;
}, z.ZodTypeAny, "passthrough">>, z.ZodObject<{
    kind: z.ZodLiteral<"openapi">;
    operationId: z.ZodString;
    baseUrl: z.ZodOptional<z.ZodString>;
    method: z.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
    path: z.ZodString;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    kind: z.ZodLiteral<"openapi">;
    operationId: z.ZodString;
    baseUrl: z.ZodOptional<z.ZodString>;
    method: z.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
    path: z.ZodString;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    kind: z.ZodLiteral<"openapi">;
    operationId: z.ZodString;
    baseUrl: z.ZodOptional<z.ZodString>;
    method: z.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
    path: z.ZodString;
}, z.ZodTypeAny, "passthrough">>, z.ZodObject<{
    kind: z.ZodLiteral<"trpc">;
    procedure: z.ZodString;
    type: z.ZodEnum<["query", "mutation"]>;
    mount: z.ZodString;
    transformer: z.ZodOptional<z.ZodLiteral<"superjson">>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    kind: z.ZodLiteral<"trpc">;
    procedure: z.ZodString;
    type: z.ZodEnum<["query", "mutation"]>;
    mount: z.ZodString;
    transformer: z.ZodOptional<z.ZodLiteral<"superjson">>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    kind: z.ZodLiteral<"trpc">;
    procedure: z.ZodString;
    type: z.ZodEnum<["query", "mutation"]>;
    mount: z.ZodString;
    transformer: z.ZodOptional<z.ZodLiteral<"superjson">>;
}, z.ZodTypeAny, "passthrough">>, z.ZodObject<{
    kind: z.ZodLiteral<"server-action">;
    module: z.ZodString;
    exportName: z.ZodString;
    params: z.ZodArray<z.ZodString, "many">;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    kind: z.ZodLiteral<"server-action">;
    module: z.ZodString;
    exportName: z.ZodString;
    params: z.ZodArray<z.ZodString, "many">;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    kind: z.ZodLiteral<"server-action">;
    module: z.ZodString;
    exportName: z.ZodString;
    params: z.ZodArray<z.ZodString, "many">;
}, z.ZodTypeAny, "passthrough">>, z.ZodEffects<z.ZodObject<{
    kind: z.ZodLiteral<"compound">;
    steps: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        tool: z.ZodString;
        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        if: z.ZodOptional<z.ZodString>;
        forEach: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        tool: z.ZodString;
        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        if: z.ZodOptional<z.ZodString>;
        forEach: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        tool: z.ZodString;
        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        if: z.ZodOptional<z.ZodString>;
        forEach: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    kind: z.ZodLiteral<"compound">;
    steps: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        tool: z.ZodString;
        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        if: z.ZodOptional<z.ZodString>;
        forEach: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        tool: z.ZodString;
        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        if: z.ZodOptional<z.ZodString>;
        forEach: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        tool: z.ZodString;
        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        if: z.ZodOptional<z.ZodString>;
        forEach: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    kind: z.ZodLiteral<"compound">;
    steps: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        tool: z.ZodString;
        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        if: z.ZodOptional<z.ZodString>;
        forEach: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        tool: z.ZodString;
        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        if: z.ZodOptional<z.ZodString>;
        forEach: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        tool: z.ZodString;
        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        if: z.ZodOptional<z.ZodString>;
        forEach: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
    kind: z.ZodLiteral<"compound">;
    steps: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        tool: z.ZodString;
        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        if: z.ZodOptional<z.ZodString>;
        forEach: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        tool: z.ZodString;
        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        if: z.ZodOptional<z.ZodString>;
        forEach: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        tool: z.ZodString;
        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        if: z.ZodOptional<z.ZodString>;
        forEach: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    kind: z.ZodLiteral<"compound">;
    steps: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        tool: z.ZodString;
        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        if: z.ZodOptional<z.ZodString>;
        forEach: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        tool: z.ZodString;
        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        if: z.ZodOptional<z.ZodString>;
        forEach: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        tool: z.ZodString;
        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        if: z.ZodOptional<z.ZodString>;
        forEach: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
}, z.ZodTypeAny, "passthrough">>]>;
/**
 * `.vendo/` is TWO files split by AUTHOR: `tools.json` (vendo/tools@3) is the
 * machine layer `vendo sync` regenerates wholesale, `overrides.json`
 * (vendo/overrides@3) is the only human-edited file.
 */
export declare const VENDO_TOOLS_FORMAT: "vendo/tools@3";
export declare const VENDO_OVERRIDES_FORMAT: "vendo/overrides@3";
/** Which rung of the trust ladder produced a schema. "unknown" is explicit, not
 *  absence: `inputSchema` is REQUIRED on every descriptor (core tools.ts), so
 *  only this can tell a derived no-argument schema from one nothing could read.
 *  It is also the AI fill gate — `patchToolSchemas` refuses an occupied slot. */
export type SchemaSource = "declared" | "types" | "inferred" | "unknown";
export declare const schemaSourceSchema: z.ZodEnum<["declared", "types", "inferred", "unknown"]>;
/** Absent ≡ "unknown": a pre-marker file reads as blind. */
export declare const schemaIsBlind: (source: SchemaSource | undefined) => boolean;
/** 04-actions §2: a descriptor plus its execution binding — one entry of `.vendo/tools.json`.
 *
 *  `outputSchema` (the host's DECLARED response body, recorded by sync) is a plain
 *  `ToolDescriptor` field, not extraction-only provenance: the registry carries it
 *  and every surface lists it. Generation's `toolShapes` are built from it
 *  (`shapeFromJsonSchema`) — nothing samples the host anymore. */
export type ExtractedTool = ToolDescriptor & {
    binding: PrimitiveToolBinding;
    /** Fail-closed extraction (04 §1): a route the scanner can't classify is emitted disabled, never silently auto-allowed. */
    disabled?: boolean;
    note?: string;
    /** Who can legitimately call this through the product's own auth —
     *  extraction's provenance for the default exclusion of non-end-user tools. */
    audience?: "end-user" | "operator" | "internal";
    /** Sync-inferred field semantics, keyed by collapsed dot path into the
     *  response (core semantics.ts). Host corrections live in overrides.json. */
    semantics?: Record<string, FieldSemantic>;
    /** Which rung of the trust ladder filled each schema slot. Absent = a
     *  pre-marker file, read as "unknown". Machine layer and reports only —
     *  never forwarded to `descriptors()` (registry.ts's descriptor whitelist). */
    inputSchemaSource?: SchemaSource;
    outputSchemaSource?: SchemaSource;
    /** The handler-source content hash incremental sync diffs against. */
    srcHash?: string;
};
export declare const extractedToolSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
    name: z.ZodString;
    description: z.ZodString;
    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
    confirmEach: z.ZodOptional<z.ZodBoolean>;
    title: z.ZodOptional<z.ZodString>;
    toolkit: z.ZodOptional<z.ZodString>;
} & {
    binding: z.ZodType<PrimitiveToolBinding, z.ZodTypeDef, PrimitiveToolBinding>;
    disabled: z.ZodOptional<z.ZodBoolean>;
    note: z.ZodOptional<z.ZodString>;
    audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
    semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
    inputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
    outputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
    srcHash: z.ZodOptional<z.ZodString>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    name: z.ZodString;
    description: z.ZodString;
    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
    confirmEach: z.ZodOptional<z.ZodBoolean>;
    title: z.ZodOptional<z.ZodString>;
    toolkit: z.ZodOptional<z.ZodString>;
} & {
    binding: z.ZodType<PrimitiveToolBinding, z.ZodTypeDef, PrimitiveToolBinding>;
    disabled: z.ZodOptional<z.ZodBoolean>;
    note: z.ZodOptional<z.ZodString>;
    audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
    semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
    inputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
    outputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
    srcHash: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    name: z.ZodString;
    description: z.ZodString;
    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
    confirmEach: z.ZodOptional<z.ZodBoolean>;
    title: z.ZodOptional<z.ZodString>;
    toolkit: z.ZodOptional<z.ZodString>;
} & {
    binding: z.ZodType<PrimitiveToolBinding, z.ZodTypeDef, PrimitiveToolBinding>;
    disabled: z.ZodOptional<z.ZodBoolean>;
    note: z.ZodOptional<z.ZodString>;
    audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
    semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
    inputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
    outputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
    srcHash: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
    name: z.ZodString;
    description: z.ZodString;
    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
    confirmEach: z.ZodOptional<z.ZodBoolean>;
    title: z.ZodOptional<z.ZodString>;
    toolkit: z.ZodOptional<z.ZodString>;
} & {
    binding: z.ZodType<PrimitiveToolBinding, z.ZodTypeDef, PrimitiveToolBinding>;
    disabled: z.ZodOptional<z.ZodBoolean>;
    note: z.ZodOptional<z.ZodString>;
    audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
    semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
    inputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
    outputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
    srcHash: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    name: z.ZodString;
    description: z.ZodString;
    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
    confirmEach: z.ZodOptional<z.ZodBoolean>;
    title: z.ZodOptional<z.ZodString>;
    toolkit: z.ZodOptional<z.ZodString>;
} & {
    binding: z.ZodType<PrimitiveToolBinding, z.ZodTypeDef, PrimitiveToolBinding>;
    disabled: z.ZodOptional<z.ZodBoolean>;
    note: z.ZodOptional<z.ZodString>;
    audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
    semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
    inputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
    outputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
    srcHash: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
    name: z.ZodString;
    description: z.ZodString;
    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
    confirmEach: z.ZodOptional<z.ZodBoolean>;
    title: z.ZodOptional<z.ZodString>;
    toolkit: z.ZodOptional<z.ZodString>;
} & {
    binding: z.ZodType<PrimitiveToolBinding, z.ZodTypeDef, PrimitiveToolBinding>;
    disabled: z.ZodOptional<z.ZodBoolean>;
    note: z.ZodOptional<z.ZodString>;
    audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
    semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
    inputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
    outputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
    srcHash: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">, unknown>;
/** `.vendo/tools.json` — generated, regenerated wholesale by `vendo sync`,
 *  never hand-edited. Passthrough like every generated artifact. */
export interface ToolsFile {
    format: typeof VENDO_TOOLS_FORMAT;
    tools: ExtractedTool[];
}
export declare const toolsFileSchema: z.ZodObject<{
    format: z.ZodLiteral<"vendo/tools@3">;
    tools: z.ZodArray<z.ZodEffects<z.ZodEffects<z.ZodObject<{
        name: z.ZodString;
        description: z.ZodString;
        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
        confirmEach: z.ZodOptional<z.ZodBoolean>;
        title: z.ZodOptional<z.ZodString>;
        toolkit: z.ZodOptional<z.ZodString>;
    } & {
        binding: z.ZodType<PrimitiveToolBinding, z.ZodTypeDef, PrimitiveToolBinding>;
        disabled: z.ZodOptional<z.ZodBoolean>;
        note: z.ZodOptional<z.ZodString>;
        audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
        semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
        inputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        outputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        srcHash: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        name: z.ZodString;
        description: z.ZodString;
        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
        confirmEach: z.ZodOptional<z.ZodBoolean>;
        title: z.ZodOptional<z.ZodString>;
        toolkit: z.ZodOptional<z.ZodString>;
    } & {
        binding: z.ZodType<PrimitiveToolBinding, z.ZodTypeDef, PrimitiveToolBinding>;
        disabled: z.ZodOptional<z.ZodBoolean>;
        note: z.ZodOptional<z.ZodString>;
        audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
        semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
        inputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        outputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        srcHash: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        name: z.ZodString;
        description: z.ZodString;
        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
        confirmEach: z.ZodOptional<z.ZodBoolean>;
        title: z.ZodOptional<z.ZodString>;
        toolkit: z.ZodOptional<z.ZodString>;
    } & {
        binding: z.ZodType<PrimitiveToolBinding, z.ZodTypeDef, PrimitiveToolBinding>;
        disabled: z.ZodOptional<z.ZodBoolean>;
        note: z.ZodOptional<z.ZodString>;
        audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
        semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
        inputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        outputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        srcHash: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
        name: z.ZodString;
        description: z.ZodString;
        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
        confirmEach: z.ZodOptional<z.ZodBoolean>;
        title: z.ZodOptional<z.ZodString>;
        toolkit: z.ZodOptional<z.ZodString>;
    } & {
        binding: z.ZodType<PrimitiveToolBinding, z.ZodTypeDef, PrimitiveToolBinding>;
        disabled: z.ZodOptional<z.ZodBoolean>;
        note: z.ZodOptional<z.ZodString>;
        audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
        semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
        inputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        outputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        srcHash: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        name: z.ZodString;
        description: z.ZodString;
        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
        confirmEach: z.ZodOptional<z.ZodBoolean>;
        title: z.ZodOptional<z.ZodString>;
        toolkit: z.ZodOptional<z.ZodString>;
    } & {
        binding: z.ZodType<PrimitiveToolBinding, z.ZodTypeDef, PrimitiveToolBinding>;
        disabled: z.ZodOptional<z.ZodBoolean>;
        note: z.ZodOptional<z.ZodString>;
        audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
        semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
        inputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        outputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        srcHash: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
        name: z.ZodString;
        description: z.ZodString;
        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
        confirmEach: z.ZodOptional<z.ZodBoolean>;
        title: z.ZodOptional<z.ZodString>;
        toolkit: z.ZodOptional<z.ZodString>;
    } & {
        binding: z.ZodType<PrimitiveToolBinding, z.ZodTypeDef, PrimitiveToolBinding>;
        disabled: z.ZodOptional<z.ZodBoolean>;
        note: z.ZodOptional<z.ZodString>;
        audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
        semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
        inputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        outputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        srcHash: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, unknown>, "many">;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    format: z.ZodLiteral<"vendo/tools@3">;
    tools: z.ZodArray<z.ZodEffects<z.ZodEffects<z.ZodObject<{
        name: z.ZodString;
        description: z.ZodString;
        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
        confirmEach: z.ZodOptional<z.ZodBoolean>;
        title: z.ZodOptional<z.ZodString>;
        toolkit: z.ZodOptional<z.ZodString>;
    } & {
        binding: z.ZodType<PrimitiveToolBinding, z.ZodTypeDef, PrimitiveToolBinding>;
        disabled: z.ZodOptional<z.ZodBoolean>;
        note: z.ZodOptional<z.ZodString>;
        audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
        semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
        inputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        outputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        srcHash: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        name: z.ZodString;
        description: z.ZodString;
        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
        confirmEach: z.ZodOptional<z.ZodBoolean>;
        title: z.ZodOptional<z.ZodString>;
        toolkit: z.ZodOptional<z.ZodString>;
    } & {
        binding: z.ZodType<PrimitiveToolBinding, z.ZodTypeDef, PrimitiveToolBinding>;
        disabled: z.ZodOptional<z.ZodBoolean>;
        note: z.ZodOptional<z.ZodString>;
        audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
        semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
        inputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        outputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        srcHash: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        name: z.ZodString;
        description: z.ZodString;
        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
        confirmEach: z.ZodOptional<z.ZodBoolean>;
        title: z.ZodOptional<z.ZodString>;
        toolkit: z.ZodOptional<z.ZodString>;
    } & {
        binding: z.ZodType<PrimitiveToolBinding, z.ZodTypeDef, PrimitiveToolBinding>;
        disabled: z.ZodOptional<z.ZodBoolean>;
        note: z.ZodOptional<z.ZodString>;
        audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
        semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
        inputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        outputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        srcHash: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
        name: z.ZodString;
        description: z.ZodString;
        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
        confirmEach: z.ZodOptional<z.ZodBoolean>;
        title: z.ZodOptional<z.ZodString>;
        toolkit: z.ZodOptional<z.ZodString>;
    } & {
        binding: z.ZodType<PrimitiveToolBinding, z.ZodTypeDef, PrimitiveToolBinding>;
        disabled: z.ZodOptional<z.ZodBoolean>;
        note: z.ZodOptional<z.ZodString>;
        audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
        semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
        inputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        outputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        srcHash: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        name: z.ZodString;
        description: z.ZodString;
        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
        confirmEach: z.ZodOptional<z.ZodBoolean>;
        title: z.ZodOptional<z.ZodString>;
        toolkit: z.ZodOptional<z.ZodString>;
    } & {
        binding: z.ZodType<PrimitiveToolBinding, z.ZodTypeDef, PrimitiveToolBinding>;
        disabled: z.ZodOptional<z.ZodBoolean>;
        note: z.ZodOptional<z.ZodString>;
        audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
        semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
        inputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        outputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        srcHash: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
        name: z.ZodString;
        description: z.ZodString;
        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
        confirmEach: z.ZodOptional<z.ZodBoolean>;
        title: z.ZodOptional<z.ZodString>;
        toolkit: z.ZodOptional<z.ZodString>;
    } & {
        binding: z.ZodType<PrimitiveToolBinding, z.ZodTypeDef, PrimitiveToolBinding>;
        disabled: z.ZodOptional<z.ZodBoolean>;
        note: z.ZodOptional<z.ZodString>;
        audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
        semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
        inputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        outputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        srcHash: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, unknown>, "many">;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    format: z.ZodLiteral<"vendo/tools@3">;
    tools: z.ZodArray<z.ZodEffects<z.ZodEffects<z.ZodObject<{
        name: z.ZodString;
        description: z.ZodString;
        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
        confirmEach: z.ZodOptional<z.ZodBoolean>;
        title: z.ZodOptional<z.ZodString>;
        toolkit: z.ZodOptional<z.ZodString>;
    } & {
        binding: z.ZodType<PrimitiveToolBinding, z.ZodTypeDef, PrimitiveToolBinding>;
        disabled: z.ZodOptional<z.ZodBoolean>;
        note: z.ZodOptional<z.ZodString>;
        audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
        semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
        inputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        outputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        srcHash: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        name: z.ZodString;
        description: z.ZodString;
        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
        confirmEach: z.ZodOptional<z.ZodBoolean>;
        title: z.ZodOptional<z.ZodString>;
        toolkit: z.ZodOptional<z.ZodString>;
    } & {
        binding: z.ZodType<PrimitiveToolBinding, z.ZodTypeDef, PrimitiveToolBinding>;
        disabled: z.ZodOptional<z.ZodBoolean>;
        note: z.ZodOptional<z.ZodString>;
        audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
        semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
        inputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        outputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        srcHash: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        name: z.ZodString;
        description: z.ZodString;
        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
        confirmEach: z.ZodOptional<z.ZodBoolean>;
        title: z.ZodOptional<z.ZodString>;
        toolkit: z.ZodOptional<z.ZodString>;
    } & {
        binding: z.ZodType<PrimitiveToolBinding, z.ZodTypeDef, PrimitiveToolBinding>;
        disabled: z.ZodOptional<z.ZodBoolean>;
        note: z.ZodOptional<z.ZodString>;
        audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
        semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
        inputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        outputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        srcHash: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
        name: z.ZodString;
        description: z.ZodString;
        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
        confirmEach: z.ZodOptional<z.ZodBoolean>;
        title: z.ZodOptional<z.ZodString>;
        toolkit: z.ZodOptional<z.ZodString>;
    } & {
        binding: z.ZodType<PrimitiveToolBinding, z.ZodTypeDef, PrimitiveToolBinding>;
        disabled: z.ZodOptional<z.ZodBoolean>;
        note: z.ZodOptional<z.ZodString>;
        audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
        semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
        inputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        outputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        srcHash: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        name: z.ZodString;
        description: z.ZodString;
        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
        confirmEach: z.ZodOptional<z.ZodBoolean>;
        title: z.ZodOptional<z.ZodString>;
        toolkit: z.ZodOptional<z.ZodString>;
    } & {
        binding: z.ZodType<PrimitiveToolBinding, z.ZodTypeDef, PrimitiveToolBinding>;
        disabled: z.ZodOptional<z.ZodBoolean>;
        note: z.ZodOptional<z.ZodString>;
        audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
        semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
        inputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        outputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        srcHash: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
        name: z.ZodString;
        description: z.ZodString;
        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
        confirmEach: z.ZodOptional<z.ZodBoolean>;
        title: z.ZodOptional<z.ZodString>;
        toolkit: z.ZodOptional<z.ZodString>;
    } & {
        binding: z.ZodType<PrimitiveToolBinding, z.ZodTypeDef, PrimitiveToolBinding>;
        disabled: z.ZodOptional<z.ZodBoolean>;
        note: z.ZodOptional<z.ZodString>;
        audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
        semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
        inputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        outputSchemaSource: z.ZodOptional<z.ZodEnum<["declared", "types", "inferred", "unknown"]>>;
        srcHash: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, unknown>, "many">;
}, z.ZodTypeAny, "passthrough">>;
/**
 * `.vendo/overrides.json` — human-written, respected forever (04 §1).
 * Strict on purpose: a typo in a hand-written override must fail loudly,
 * never be silently ignored.
 */
export interface ToolOverride {
    risk?: ToolDescriptor["risk"];
    confirmEach?: boolean;
    disabled?: boolean;
    description?: string;
    /** The short human label people see for this tool (MCP client menus,
     *  approval cards). Presentation, not capability — the authored copy is the
     *  last word over whatever sync's enrichment proposed. */
    title?: string;
    /** Who can legitimately call this through the product's own auth. Extraction
     *  records it as provenance for the default exclusion of non-end-user tools
     *  (operator/internal surfaces never reach the embedded agent unreviewed). */
    audience?: "end-user" | "operator" | "internal";
    /** W3 — host-declared field semantics for this tool's RESPONSE, keyed by
     *  collapsed dot path (arrays collapse: `data.amountCents`). The highest
     *  authority in `.vendo/overrides.json`: annotation > sync-time inference. */
    semantics?: Record<string, FieldSemantic>;
}
export declare const toolOverrideSchema: z.ZodEffects<z.ZodObject<{
    risk: z.ZodOptional<z.ZodEnum<["read", "write", "destructive", "ungraded"]>>;
    confirmEach: z.ZodOptional<z.ZodBoolean>;
    disabled: z.ZodOptional<z.ZodBoolean>;
    description: z.ZodOptional<z.ZodString>;
    title: z.ZodOptional<z.ZodString>;
    audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
    semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
}, "strict", z.ZodTypeAny, {
    description?: string | undefined;
    risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
    confirmEach?: boolean | undefined;
    title?: string | undefined;
    disabled?: boolean | undefined;
    audience?: "internal" | "end-user" | "operator" | undefined;
    semantics?: Record<string, FieldSemantic> | undefined;
}, {
    description?: string | undefined;
    risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
    confirmEach?: boolean | undefined;
    title?: string | undefined;
    disabled?: boolean | undefined;
    audience?: "internal" | "end-user" | "operator" | undefined;
    semantics?: Record<string, FieldSemantic> | undefined;
}>, {
    description?: string | undefined;
    risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
    confirmEach?: boolean | undefined;
    title?: string | undefined;
    disabled?: boolean | undefined;
    audience?: "internal" | "end-user" | "operator" | undefined;
    semantics?: Record<string, FieldSemantic> | undefined;
}, unknown>;
/**
 * 04-actions §1: a capability brief — reviewed prose the agent layer may attach
 * to primitive tools. Carried and validated today; consumed by later milestones.
 */
export interface CapabilityBrief {
    name: string;
    text: string;
    tools?: string[];
}
export declare const capabilityBriefSchema: z.ZodObject<{
    name: z.ZodString;
    text: z.ZodString;
    tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    name: z.ZodString;
    text: z.ZodString;
    tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    name: z.ZodString;
    text: z.ZodString;
    tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, z.ZodTypeAny, "passthrough">>;
/** 04-actions §6: one agent-authored compound tool of `.vendo/overrides.json`. */
export type CompoundTool = ToolDescriptor & {
    binding: CompoundBinding;
    disabled?: boolean;
    note?: string;
};
export declare const compoundToolSchema: z.ZodEffects<z.ZodObject<{
    name: z.ZodString;
    description: z.ZodString;
    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
    confirmEach: z.ZodOptional<z.ZodBoolean>;
    title: z.ZodOptional<z.ZodString>;
    toolkit: z.ZodOptional<z.ZodString>;
} & {
    binding: z.ZodEffects<z.ZodObject<{
        kind: z.ZodLiteral<"compound">;
        steps: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        kind: z.ZodLiteral<"compound">;
        steps: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        kind: z.ZodLiteral<"compound">;
        steps: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
        kind: z.ZodLiteral<"compound">;
        steps: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        kind: z.ZodLiteral<"compound">;
        steps: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>;
    disabled: z.ZodOptional<z.ZodBoolean>;
    note: z.ZodOptional<z.ZodString>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    name: z.ZodString;
    description: z.ZodString;
    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
    confirmEach: z.ZodOptional<z.ZodBoolean>;
    title: z.ZodOptional<z.ZodString>;
    toolkit: z.ZodOptional<z.ZodString>;
} & {
    binding: z.ZodEffects<z.ZodObject<{
        kind: z.ZodLiteral<"compound">;
        steps: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        kind: z.ZodLiteral<"compound">;
        steps: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        kind: z.ZodLiteral<"compound">;
        steps: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
        kind: z.ZodLiteral<"compound">;
        steps: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        kind: z.ZodLiteral<"compound">;
        steps: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>;
    disabled: z.ZodOptional<z.ZodBoolean>;
    note: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    name: z.ZodString;
    description: z.ZodString;
    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
    confirmEach: z.ZodOptional<z.ZodBoolean>;
    title: z.ZodOptional<z.ZodString>;
    toolkit: z.ZodOptional<z.ZodString>;
} & {
    binding: z.ZodEffects<z.ZodObject<{
        kind: z.ZodLiteral<"compound">;
        steps: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        kind: z.ZodLiteral<"compound">;
        steps: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        kind: z.ZodLiteral<"compound">;
        steps: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
        kind: z.ZodLiteral<"compound">;
        steps: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        kind: z.ZodLiteral<"compound">;
        steps: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>;
    disabled: z.ZodOptional<z.ZodBoolean>;
    note: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
    name: z.ZodString;
    description: z.ZodString;
    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
    confirmEach: z.ZodOptional<z.ZodBoolean>;
    title: z.ZodOptional<z.ZodString>;
    toolkit: z.ZodOptional<z.ZodString>;
} & {
    binding: z.ZodEffects<z.ZodObject<{
        kind: z.ZodLiteral<"compound">;
        steps: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        kind: z.ZodLiteral<"compound">;
        steps: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        kind: z.ZodLiteral<"compound">;
        steps: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
        kind: z.ZodLiteral<"compound">;
        steps: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        kind: z.ZodLiteral<"compound">;
        steps: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodString;
            tool: z.ZodString;
            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            if: z.ZodOptional<z.ZodString>;
            forEach: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
    }, z.ZodTypeAny, "passthrough">>;
    disabled: z.ZodOptional<z.ZodBoolean>;
    note: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">, unknown>;
/**
 * `.vendo/overrides.json` (vendo/overrides@3) — the AUTHORED layer, the only
 * human-edited file: per-tool overrides plus the agent-authored `compounds`
 * and `briefs`, and remix slot opt-outs. Strict on purpose — a typo must fail
 * loudly — except compounds and briefs entries, which keep their passthrough
 * (additive) behavior.
 */
/** The host-curated tool menu for ONE surface. Curation, not security: a menu
 *  decides what a surface OFFERS, never what the guard allows — `disabled`,
 *  guard rules, and audience exclusions are untouched by it. */
export interface SurfaceMenu {
    tools: string[];
}
/** Per-surface menus. The key set is a CLOSED enum on purpose: a typo'd
 *  surface name in an authored file must fail loudly at parse rather than
 *  silently curate nothing. `cli` and friends join when they are real. */
export interface OverridesSurfaces {
    agent?: SurfaceMenu;
    mcp?: SurfaceMenu;
}
export interface OverridesFile {
    format: typeof VENDO_OVERRIDES_FORMAT;
    tools: Record<string, ToolOverride>;
    compounds?: CompoundTool[];
    briefs?: CapabilityBrief[];
    surfaces?: OverridesSurfaces;
    /** `ignoreSlots` — slots that resolve but must not be captured. `sources` —
     *  extra directories `vendo sync` scans for `<Remixable>` wrappers, resolved
     *  from the project root and free to sit outside it (a repo whose app is
     *  `host/` and whose screens are `../demos/`). */
    remix?: {
        ignoreSlots?: string[];
        sources?: string[];
    };
}
export declare const overridesFileSchema: z.ZodObject<{
    format: z.ZodLiteral<"vendo/overrides@3">;
    tools: z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodObject<{
        risk: z.ZodOptional<z.ZodEnum<["read", "write", "destructive", "ungraded"]>>;
        confirmEach: z.ZodOptional<z.ZodBoolean>;
        disabled: z.ZodOptional<z.ZodBoolean>;
        description: z.ZodOptional<z.ZodString>;
        title: z.ZodOptional<z.ZodString>;
        audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
        semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
    }, "strict", z.ZodTypeAny, {
        description?: string | undefined;
        risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
        confirmEach?: boolean | undefined;
        title?: string | undefined;
        disabled?: boolean | undefined;
        audience?: "internal" | "end-user" | "operator" | undefined;
        semantics?: Record<string, FieldSemantic> | undefined;
    }, {
        description?: string | undefined;
        risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
        confirmEach?: boolean | undefined;
        title?: string | undefined;
        disabled?: boolean | undefined;
        audience?: "internal" | "end-user" | "operator" | undefined;
        semantics?: Record<string, FieldSemantic> | undefined;
    }>, {
        description?: string | undefined;
        risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
        confirmEach?: boolean | undefined;
        title?: string | undefined;
        disabled?: boolean | undefined;
        audience?: "internal" | "end-user" | "operator" | undefined;
        semantics?: Record<string, FieldSemantic> | undefined;
    }, unknown>>;
    compounds: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
        name: z.ZodString;
        description: z.ZodString;
        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
        confirmEach: z.ZodOptional<z.ZodBoolean>;
        title: z.ZodOptional<z.ZodString>;
        toolkit: z.ZodOptional<z.ZodString>;
    } & {
        binding: z.ZodEffects<z.ZodObject<{
            kind: z.ZodLiteral<"compound">;
            steps: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">>, "many">;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            kind: z.ZodLiteral<"compound">;
            steps: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">>, "many">;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            kind: z.ZodLiteral<"compound">;
            steps: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">>, "many">;
        }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
            kind: z.ZodLiteral<"compound">;
            steps: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">>, "many">;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            kind: z.ZodLiteral<"compound">;
            steps: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">>, "many">;
        }, z.ZodTypeAny, "passthrough">>;
        disabled: z.ZodOptional<z.ZodBoolean>;
        note: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        name: z.ZodString;
        description: z.ZodString;
        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
        confirmEach: z.ZodOptional<z.ZodBoolean>;
        title: z.ZodOptional<z.ZodString>;
        toolkit: z.ZodOptional<z.ZodString>;
    } & {
        binding: z.ZodEffects<z.ZodObject<{
            kind: z.ZodLiteral<"compound">;
            steps: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">>, "many">;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            kind: z.ZodLiteral<"compound">;
            steps: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">>, "many">;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            kind: z.ZodLiteral<"compound">;
            steps: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">>, "many">;
        }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
            kind: z.ZodLiteral<"compound">;
            steps: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">>, "many">;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            kind: z.ZodLiteral<"compound">;
            steps: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">>, "many">;
        }, z.ZodTypeAny, "passthrough">>;
        disabled: z.ZodOptional<z.ZodBoolean>;
        note: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        name: z.ZodString;
        description: z.ZodString;
        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
        confirmEach: z.ZodOptional<z.ZodBoolean>;
        title: z.ZodOptional<z.ZodString>;
        toolkit: z.ZodOptional<z.ZodString>;
    } & {
        binding: z.ZodEffects<z.ZodObject<{
            kind: z.ZodLiteral<"compound">;
            steps: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">>, "many">;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            kind: z.ZodLiteral<"compound">;
            steps: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">>, "many">;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            kind: z.ZodLiteral<"compound">;
            steps: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">>, "many">;
        }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
            kind: z.ZodLiteral<"compound">;
            steps: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">>, "many">;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            kind: z.ZodLiteral<"compound">;
            steps: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">>, "many">;
        }, z.ZodTypeAny, "passthrough">>;
        disabled: z.ZodOptional<z.ZodBoolean>;
        note: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
        name: z.ZodString;
        description: z.ZodString;
        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
        confirmEach: z.ZodOptional<z.ZodBoolean>;
        title: z.ZodOptional<z.ZodString>;
        toolkit: z.ZodOptional<z.ZodString>;
    } & {
        binding: z.ZodEffects<z.ZodObject<{
            kind: z.ZodLiteral<"compound">;
            steps: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">>, "many">;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            kind: z.ZodLiteral<"compound">;
            steps: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">>, "many">;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            kind: z.ZodLiteral<"compound">;
            steps: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">>, "many">;
        }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
            kind: z.ZodLiteral<"compound">;
            steps: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">>, "many">;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            kind: z.ZodLiteral<"compound">;
            steps: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">>, "many">;
        }, z.ZodTypeAny, "passthrough">>;
        disabled: z.ZodOptional<z.ZodBoolean>;
        note: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, unknown>, "many">>;
    briefs: z.ZodOptional<z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        text: z.ZodString;
        tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        name: z.ZodString;
        text: z.ZodString;
        tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        name: z.ZodString;
        text: z.ZodString;
        tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">>, "many">>;
    surfaces: z.ZodOptional<z.ZodObject<{
        agent: z.ZodOptional<z.ZodObject<{
            tools: z.ZodArray<z.ZodString, "many">;
        }, "strict", z.ZodTypeAny, {
            tools: string[];
        }, {
            tools: string[];
        }>>;
        mcp: z.ZodOptional<z.ZodObject<{
            tools: z.ZodArray<z.ZodString, "many">;
        }, "strict", z.ZodTypeAny, {
            tools: string[];
        }, {
            tools: string[];
        }>>;
    }, "strict", z.ZodTypeAny, {
        agent?: {
            tools: string[];
        } | undefined;
        mcp?: {
            tools: string[];
        } | undefined;
    }, {
        agent?: {
            tools: string[];
        } | undefined;
        mcp?: {
            tools: string[];
        } | undefined;
    }>>;
    remix: z.ZodOptional<z.ZodObject<{
        ignoreSlots: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        sources: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "strict", z.ZodTypeAny, {
        ignoreSlots?: string[] | undefined;
        sources?: string[] | undefined;
    }, {
        ignoreSlots?: string[] | undefined;
        sources?: string[] | undefined;
    }>>;
}, "strict", z.ZodTypeAny, {
    format: "vendo/overrides@3";
    tools: Record<string, {
        description?: string | undefined;
        risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
        confirmEach?: boolean | undefined;
        title?: string | undefined;
        disabled?: boolean | undefined;
        audience?: "internal" | "end-user" | "operator" | undefined;
        semantics?: Record<string, FieldSemantic> | undefined;
    }>;
    compounds?: z.objectOutputType<{
        name: z.ZodString;
        description: z.ZodString;
        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        risk: z.ZodEnum<["read", "write", "destructive", "ungraded"]>;
        confirmEach: z.ZodOptional<z.ZodBoolean>;
        title: z.ZodOptional<z.ZodString>;
        toolkit: z.ZodOptional<z.ZodString>;
    } & {
        binding: z.ZodEffects<z.ZodObject<{
            kind: z.ZodLiteral<"compound">;
            steps: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">>, "many">;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            kind: z.ZodLiteral<"compound">;
            steps: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">>, "many">;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            kind: z.ZodLiteral<"compound">;
            steps: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">>, "many">;
        }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
            kind: z.ZodLiteral<"compound">;
            steps: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">>, "many">;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            kind: z.ZodLiteral<"compound">;
            steps: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodString;
                tool: z.ZodString;
                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                if: z.ZodOptional<z.ZodString>;
                forEach: z.ZodOptional<z.ZodString>;
            }, z.ZodTypeAny, "passthrough">>, "many">;
        }, z.ZodTypeAny, "passthrough">>;
        disabled: z.ZodOptional<z.ZodBoolean>;
        note: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">[] | undefined;
    briefs?: z.objectOutputType<{
        name: z.ZodString;
        text: z.ZodString;
        tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">[] | undefined;
    surfaces?: {
        agent?: {
            tools: string[];
        } | undefined;
        mcp?: {
            tools: string[];
        } | undefined;
    } | undefined;
    remix?: {
        ignoreSlots?: string[] | undefined;
        sources?: string[] | undefined;
    } | undefined;
}, {
    format: "vendo/overrides@3";
    tools: Record<string, unknown>;
    compounds?: unknown[] | undefined;
    briefs?: z.objectInputType<{
        name: z.ZodString;
        text: z.ZodString;
        tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, z.ZodTypeAny, "passthrough">[] | undefined;
    surfaces?: {
        agent?: {
            tools: string[];
        } | undefined;
        mcp?: {
            tools: string[];
        } | undefined;
    } | undefined;
    remix?: {
        ignoreSlots?: string[] | undefined;
        sources?: string[] | undefined;
    } | undefined;
}>;
/**
 * `.vendo/judgments.json` — the AI layer, the third file of `.vendo/`, split
 * from `tools.json` by AUTHOR the same way `overrides.json` is: the model
 * writes here, the deterministic scanner never does, and a human never has to.
 * Generated, regenerated by the judge pass, keyed by tool name.
 */
export declare const VENDO_JUDGMENTS_FORMAT: "vendo/judgments@1";
/** The AI-writable surface — same field family as ToolOverride so the three
 *  layers merge with one shape vocabulary. */
export interface JudgmentFields {
    description?: string;
    title?: string;
    risk?: RiskLabel;
    confirmEach?: boolean;
    /** true = harden; false = approved wake-up (only ever arrives here after a
     *  human accepted the queued loosening — the model cannot write it itself). */
    disabled?: boolean;
    audience?: "end-user" | "operator" | "internal";
    semantics?: Record<string, FieldSemantic>;
}
export declare const judgmentFieldsSchema: z.ZodEffects<z.ZodObject<{
    description: z.ZodOptional<z.ZodString>;
    title: z.ZodOptional<z.ZodString>;
    risk: z.ZodOptional<z.ZodEnum<["read", "write", "destructive", "ungraded"]>>;
    confirmEach: z.ZodOptional<z.ZodBoolean>;
    disabled: z.ZodOptional<z.ZodBoolean>;
    audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
    semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
}, "strict", z.ZodTypeAny, {
    description?: string | undefined;
    risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
    confirmEach?: boolean | undefined;
    title?: string | undefined;
    disabled?: boolean | undefined;
    audience?: "internal" | "end-user" | "operator" | undefined;
    semantics?: Record<string, FieldSemantic> | undefined;
}, {
    description?: string | undefined;
    risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
    confirmEach?: boolean | undefined;
    title?: string | undefined;
    disabled?: boolean | undefined;
    audience?: "internal" | "end-user" | "operator" | undefined;
    semantics?: Record<string, FieldSemantic> | undefined;
}>, {
    description?: string | undefined;
    risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
    confirmEach?: boolean | undefined;
    title?: string | undefined;
    disabled?: boolean | undefined;
    audience?: "internal" | "end-user" | "operator" | undefined;
    semantics?: Record<string, FieldSemantic> | undefined;
}, unknown>;
/** One queued loosening awaiting human review. NEVER merged at runtime: the
 *  only fields a loosening can touch are the four capability grades, and each
 *  one costs a quoted piece of evidence. */
export interface PendingLoosening {
    field: "risk" | "confirmEach" | "disabled" | "audience";
    value: string | boolean;
    evidence: string;
    reason?: string;
}
export declare const pendingLooseningSchema: z.ZodEffects<z.ZodObject<{
    field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
    value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
    evidence: z.ZodString;
    reason: z.ZodOptional<z.ZodString>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
    value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
    evidence: z.ZodString;
    reason: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
    value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
    evidence: z.ZodString;
    reason: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
    field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
    value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
    evidence: z.ZodString;
    reason: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">, unknown>;
export interface ToolJudgment {
    /** bindingIdentity(tool.binding) at judgment time — a mismatch makes the
     *  whole entry inert rather than applying a judgment of another handler. */
    binding: string;
    srcHash?: string;
    fields: JudgmentFields;
    /** The quoted handler snippet the judgment rests on. REQUIRED: a grade with
     *  no evidence is an opinion, and opinions do not move capability. */
    evidence: string;
    pending?: PendingLoosening[];
}
export declare const toolJudgmentSchema: z.ZodObject<{
    binding: z.ZodString;
    srcHash: z.ZodOptional<z.ZodString>;
    fields: z.ZodEffects<z.ZodObject<{
        description: z.ZodOptional<z.ZodString>;
        title: z.ZodOptional<z.ZodString>;
        risk: z.ZodOptional<z.ZodEnum<["read", "write", "destructive", "ungraded"]>>;
        confirmEach: z.ZodOptional<z.ZodBoolean>;
        disabled: z.ZodOptional<z.ZodBoolean>;
        audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
        semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
    }, "strict", z.ZodTypeAny, {
        description?: string | undefined;
        risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
        confirmEach?: boolean | undefined;
        title?: string | undefined;
        disabled?: boolean | undefined;
        audience?: "internal" | "end-user" | "operator" | undefined;
        semantics?: Record<string, FieldSemantic> | undefined;
    }, {
        description?: string | undefined;
        risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
        confirmEach?: boolean | undefined;
        title?: string | undefined;
        disabled?: boolean | undefined;
        audience?: "internal" | "end-user" | "operator" | undefined;
        semantics?: Record<string, FieldSemantic> | undefined;
    }>, {
        description?: string | undefined;
        risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
        confirmEach?: boolean | undefined;
        title?: string | undefined;
        disabled?: boolean | undefined;
        audience?: "internal" | "end-user" | "operator" | undefined;
        semantics?: Record<string, FieldSemantic> | undefined;
    }, unknown>;
    evidence: z.ZodString;
    pending: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
        field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
        value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
        evidence: z.ZodString;
        reason: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
        value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
        evidence: z.ZodString;
        reason: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
        value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
        evidence: z.ZodString;
        reason: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
        field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
        value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
        evidence: z.ZodString;
        reason: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, unknown>, "many">>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    binding: z.ZodString;
    srcHash: z.ZodOptional<z.ZodString>;
    fields: z.ZodEffects<z.ZodObject<{
        description: z.ZodOptional<z.ZodString>;
        title: z.ZodOptional<z.ZodString>;
        risk: z.ZodOptional<z.ZodEnum<["read", "write", "destructive", "ungraded"]>>;
        confirmEach: z.ZodOptional<z.ZodBoolean>;
        disabled: z.ZodOptional<z.ZodBoolean>;
        audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
        semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
    }, "strict", z.ZodTypeAny, {
        description?: string | undefined;
        risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
        confirmEach?: boolean | undefined;
        title?: string | undefined;
        disabled?: boolean | undefined;
        audience?: "internal" | "end-user" | "operator" | undefined;
        semantics?: Record<string, FieldSemantic> | undefined;
    }, {
        description?: string | undefined;
        risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
        confirmEach?: boolean | undefined;
        title?: string | undefined;
        disabled?: boolean | undefined;
        audience?: "internal" | "end-user" | "operator" | undefined;
        semantics?: Record<string, FieldSemantic> | undefined;
    }>, {
        description?: string | undefined;
        risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
        confirmEach?: boolean | undefined;
        title?: string | undefined;
        disabled?: boolean | undefined;
        audience?: "internal" | "end-user" | "operator" | undefined;
        semantics?: Record<string, FieldSemantic> | undefined;
    }, unknown>;
    evidence: z.ZodString;
    pending: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
        field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
        value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
        evidence: z.ZodString;
        reason: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
        value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
        evidence: z.ZodString;
        reason: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
        value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
        evidence: z.ZodString;
        reason: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
        field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
        value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
        evidence: z.ZodString;
        reason: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, unknown>, "many">>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    binding: z.ZodString;
    srcHash: z.ZodOptional<z.ZodString>;
    fields: z.ZodEffects<z.ZodObject<{
        description: z.ZodOptional<z.ZodString>;
        title: z.ZodOptional<z.ZodString>;
        risk: z.ZodOptional<z.ZodEnum<["read", "write", "destructive", "ungraded"]>>;
        confirmEach: z.ZodOptional<z.ZodBoolean>;
        disabled: z.ZodOptional<z.ZodBoolean>;
        audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
        semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
    }, "strict", z.ZodTypeAny, {
        description?: string | undefined;
        risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
        confirmEach?: boolean | undefined;
        title?: string | undefined;
        disabled?: boolean | undefined;
        audience?: "internal" | "end-user" | "operator" | undefined;
        semantics?: Record<string, FieldSemantic> | undefined;
    }, {
        description?: string | undefined;
        risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
        confirmEach?: boolean | undefined;
        title?: string | undefined;
        disabled?: boolean | undefined;
        audience?: "internal" | "end-user" | "operator" | undefined;
        semantics?: Record<string, FieldSemantic> | undefined;
    }>, {
        description?: string | undefined;
        risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
        confirmEach?: boolean | undefined;
        title?: string | undefined;
        disabled?: boolean | undefined;
        audience?: "internal" | "end-user" | "operator" | undefined;
        semantics?: Record<string, FieldSemantic> | undefined;
    }, unknown>;
    evidence: z.ZodString;
    pending: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
        field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
        value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
        evidence: z.ZodString;
        reason: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
        value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
        evidence: z.ZodString;
        reason: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
        value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
        evidence: z.ZodString;
        reason: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
        field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
        value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
        evidence: z.ZodString;
        reason: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, unknown>, "many">>;
}, z.ZodTypeAny, "passthrough">>;
export interface JudgmentsFile {
    format: typeof VENDO_JUDGMENTS_FORMAT;
    tools: Record<string, ToolJudgment>;
}
/** Passthrough at the file level (generated-artifact convention), but every
 *  bound above is load-bearing: this file can carry DISABLES, so a malformed
 *  one must fail loudly at parse. Silently ignoring it would silently loosen. */
export declare const judgmentsFileSchema: z.ZodObject<{
    format: z.ZodLiteral<"vendo/judgments@1">;
    tools: z.ZodRecord<z.ZodString, z.ZodObject<{
        binding: z.ZodString;
        srcHash: z.ZodOptional<z.ZodString>;
        fields: z.ZodEffects<z.ZodObject<{
            description: z.ZodOptional<z.ZodString>;
            title: z.ZodOptional<z.ZodString>;
            risk: z.ZodOptional<z.ZodEnum<["read", "write", "destructive", "ungraded"]>>;
            confirmEach: z.ZodOptional<z.ZodBoolean>;
            disabled: z.ZodOptional<z.ZodBoolean>;
            audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
            semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
        }, "strict", z.ZodTypeAny, {
            description?: string | undefined;
            risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
            confirmEach?: boolean | undefined;
            title?: string | undefined;
            disabled?: boolean | undefined;
            audience?: "internal" | "end-user" | "operator" | undefined;
            semantics?: Record<string, FieldSemantic> | undefined;
        }, {
            description?: string | undefined;
            risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
            confirmEach?: boolean | undefined;
            title?: string | undefined;
            disabled?: boolean | undefined;
            audience?: "internal" | "end-user" | "operator" | undefined;
            semantics?: Record<string, FieldSemantic> | undefined;
        }>, {
            description?: string | undefined;
            risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
            confirmEach?: boolean | undefined;
            title?: string | undefined;
            disabled?: boolean | undefined;
            audience?: "internal" | "end-user" | "operator" | undefined;
            semantics?: Record<string, FieldSemantic> | undefined;
        }, unknown>;
        evidence: z.ZodString;
        pending: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, unknown>, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        binding: z.ZodString;
        srcHash: z.ZodOptional<z.ZodString>;
        fields: z.ZodEffects<z.ZodObject<{
            description: z.ZodOptional<z.ZodString>;
            title: z.ZodOptional<z.ZodString>;
            risk: z.ZodOptional<z.ZodEnum<["read", "write", "destructive", "ungraded"]>>;
            confirmEach: z.ZodOptional<z.ZodBoolean>;
            disabled: z.ZodOptional<z.ZodBoolean>;
            audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
            semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
        }, "strict", z.ZodTypeAny, {
            description?: string | undefined;
            risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
            confirmEach?: boolean | undefined;
            title?: string | undefined;
            disabled?: boolean | undefined;
            audience?: "internal" | "end-user" | "operator" | undefined;
            semantics?: Record<string, FieldSemantic> | undefined;
        }, {
            description?: string | undefined;
            risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
            confirmEach?: boolean | undefined;
            title?: string | undefined;
            disabled?: boolean | undefined;
            audience?: "internal" | "end-user" | "operator" | undefined;
            semantics?: Record<string, FieldSemantic> | undefined;
        }>, {
            description?: string | undefined;
            risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
            confirmEach?: boolean | undefined;
            title?: string | undefined;
            disabled?: boolean | undefined;
            audience?: "internal" | "end-user" | "operator" | undefined;
            semantics?: Record<string, FieldSemantic> | undefined;
        }, unknown>;
        evidence: z.ZodString;
        pending: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, unknown>, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        binding: z.ZodString;
        srcHash: z.ZodOptional<z.ZodString>;
        fields: z.ZodEffects<z.ZodObject<{
            description: z.ZodOptional<z.ZodString>;
            title: z.ZodOptional<z.ZodString>;
            risk: z.ZodOptional<z.ZodEnum<["read", "write", "destructive", "ungraded"]>>;
            confirmEach: z.ZodOptional<z.ZodBoolean>;
            disabled: z.ZodOptional<z.ZodBoolean>;
            audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
            semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
        }, "strict", z.ZodTypeAny, {
            description?: string | undefined;
            risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
            confirmEach?: boolean | undefined;
            title?: string | undefined;
            disabled?: boolean | undefined;
            audience?: "internal" | "end-user" | "operator" | undefined;
            semantics?: Record<string, FieldSemantic> | undefined;
        }, {
            description?: string | undefined;
            risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
            confirmEach?: boolean | undefined;
            title?: string | undefined;
            disabled?: boolean | undefined;
            audience?: "internal" | "end-user" | "operator" | undefined;
            semantics?: Record<string, FieldSemantic> | undefined;
        }>, {
            description?: string | undefined;
            risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
            confirmEach?: boolean | undefined;
            title?: string | undefined;
            disabled?: boolean | undefined;
            audience?: "internal" | "end-user" | "operator" | undefined;
            semantics?: Record<string, FieldSemantic> | undefined;
        }, unknown>;
        evidence: z.ZodString;
        pending: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, unknown>, "many">>;
    }, z.ZodTypeAny, "passthrough">>>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    format: z.ZodLiteral<"vendo/judgments@1">;
    tools: z.ZodRecord<z.ZodString, z.ZodObject<{
        binding: z.ZodString;
        srcHash: z.ZodOptional<z.ZodString>;
        fields: z.ZodEffects<z.ZodObject<{
            description: z.ZodOptional<z.ZodString>;
            title: z.ZodOptional<z.ZodString>;
            risk: z.ZodOptional<z.ZodEnum<["read", "write", "destructive", "ungraded"]>>;
            confirmEach: z.ZodOptional<z.ZodBoolean>;
            disabled: z.ZodOptional<z.ZodBoolean>;
            audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
            semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
        }, "strict", z.ZodTypeAny, {
            description?: string | undefined;
            risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
            confirmEach?: boolean | undefined;
            title?: string | undefined;
            disabled?: boolean | undefined;
            audience?: "internal" | "end-user" | "operator" | undefined;
            semantics?: Record<string, FieldSemantic> | undefined;
        }, {
            description?: string | undefined;
            risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
            confirmEach?: boolean | undefined;
            title?: string | undefined;
            disabled?: boolean | undefined;
            audience?: "internal" | "end-user" | "operator" | undefined;
            semantics?: Record<string, FieldSemantic> | undefined;
        }>, {
            description?: string | undefined;
            risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
            confirmEach?: boolean | undefined;
            title?: string | undefined;
            disabled?: boolean | undefined;
            audience?: "internal" | "end-user" | "operator" | undefined;
            semantics?: Record<string, FieldSemantic> | undefined;
        }, unknown>;
        evidence: z.ZodString;
        pending: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, unknown>, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        binding: z.ZodString;
        srcHash: z.ZodOptional<z.ZodString>;
        fields: z.ZodEffects<z.ZodObject<{
            description: z.ZodOptional<z.ZodString>;
            title: z.ZodOptional<z.ZodString>;
            risk: z.ZodOptional<z.ZodEnum<["read", "write", "destructive", "ungraded"]>>;
            confirmEach: z.ZodOptional<z.ZodBoolean>;
            disabled: z.ZodOptional<z.ZodBoolean>;
            audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
            semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
        }, "strict", z.ZodTypeAny, {
            description?: string | undefined;
            risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
            confirmEach?: boolean | undefined;
            title?: string | undefined;
            disabled?: boolean | undefined;
            audience?: "internal" | "end-user" | "operator" | undefined;
            semantics?: Record<string, FieldSemantic> | undefined;
        }, {
            description?: string | undefined;
            risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
            confirmEach?: boolean | undefined;
            title?: string | undefined;
            disabled?: boolean | undefined;
            audience?: "internal" | "end-user" | "operator" | undefined;
            semantics?: Record<string, FieldSemantic> | undefined;
        }>, {
            description?: string | undefined;
            risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
            confirmEach?: boolean | undefined;
            title?: string | undefined;
            disabled?: boolean | undefined;
            audience?: "internal" | "end-user" | "operator" | undefined;
            semantics?: Record<string, FieldSemantic> | undefined;
        }, unknown>;
        evidence: z.ZodString;
        pending: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, unknown>, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        binding: z.ZodString;
        srcHash: z.ZodOptional<z.ZodString>;
        fields: z.ZodEffects<z.ZodObject<{
            description: z.ZodOptional<z.ZodString>;
            title: z.ZodOptional<z.ZodString>;
            risk: z.ZodOptional<z.ZodEnum<["read", "write", "destructive", "ungraded"]>>;
            confirmEach: z.ZodOptional<z.ZodBoolean>;
            disabled: z.ZodOptional<z.ZodBoolean>;
            audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
            semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
        }, "strict", z.ZodTypeAny, {
            description?: string | undefined;
            risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
            confirmEach?: boolean | undefined;
            title?: string | undefined;
            disabled?: boolean | undefined;
            audience?: "internal" | "end-user" | "operator" | undefined;
            semantics?: Record<string, FieldSemantic> | undefined;
        }, {
            description?: string | undefined;
            risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
            confirmEach?: boolean | undefined;
            title?: string | undefined;
            disabled?: boolean | undefined;
            audience?: "internal" | "end-user" | "operator" | undefined;
            semantics?: Record<string, FieldSemantic> | undefined;
        }>, {
            description?: string | undefined;
            risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
            confirmEach?: boolean | undefined;
            title?: string | undefined;
            disabled?: boolean | undefined;
            audience?: "internal" | "end-user" | "operator" | undefined;
            semantics?: Record<string, FieldSemantic> | undefined;
        }, unknown>;
        evidence: z.ZodString;
        pending: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, unknown>, "many">>;
    }, z.ZodTypeAny, "passthrough">>>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    format: z.ZodLiteral<"vendo/judgments@1">;
    tools: z.ZodRecord<z.ZodString, z.ZodObject<{
        binding: z.ZodString;
        srcHash: z.ZodOptional<z.ZodString>;
        fields: z.ZodEffects<z.ZodObject<{
            description: z.ZodOptional<z.ZodString>;
            title: z.ZodOptional<z.ZodString>;
            risk: z.ZodOptional<z.ZodEnum<["read", "write", "destructive", "ungraded"]>>;
            confirmEach: z.ZodOptional<z.ZodBoolean>;
            disabled: z.ZodOptional<z.ZodBoolean>;
            audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
            semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
        }, "strict", z.ZodTypeAny, {
            description?: string | undefined;
            risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
            confirmEach?: boolean | undefined;
            title?: string | undefined;
            disabled?: boolean | undefined;
            audience?: "internal" | "end-user" | "operator" | undefined;
            semantics?: Record<string, FieldSemantic> | undefined;
        }, {
            description?: string | undefined;
            risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
            confirmEach?: boolean | undefined;
            title?: string | undefined;
            disabled?: boolean | undefined;
            audience?: "internal" | "end-user" | "operator" | undefined;
            semantics?: Record<string, FieldSemantic> | undefined;
        }>, {
            description?: string | undefined;
            risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
            confirmEach?: boolean | undefined;
            title?: string | undefined;
            disabled?: boolean | undefined;
            audience?: "internal" | "end-user" | "operator" | undefined;
            semantics?: Record<string, FieldSemantic> | undefined;
        }, unknown>;
        evidence: z.ZodString;
        pending: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, unknown>, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        binding: z.ZodString;
        srcHash: z.ZodOptional<z.ZodString>;
        fields: z.ZodEffects<z.ZodObject<{
            description: z.ZodOptional<z.ZodString>;
            title: z.ZodOptional<z.ZodString>;
            risk: z.ZodOptional<z.ZodEnum<["read", "write", "destructive", "ungraded"]>>;
            confirmEach: z.ZodOptional<z.ZodBoolean>;
            disabled: z.ZodOptional<z.ZodBoolean>;
            audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
            semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
        }, "strict", z.ZodTypeAny, {
            description?: string | undefined;
            risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
            confirmEach?: boolean | undefined;
            title?: string | undefined;
            disabled?: boolean | undefined;
            audience?: "internal" | "end-user" | "operator" | undefined;
            semantics?: Record<string, FieldSemantic> | undefined;
        }, {
            description?: string | undefined;
            risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
            confirmEach?: boolean | undefined;
            title?: string | undefined;
            disabled?: boolean | undefined;
            audience?: "internal" | "end-user" | "operator" | undefined;
            semantics?: Record<string, FieldSemantic> | undefined;
        }>, {
            description?: string | undefined;
            risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
            confirmEach?: boolean | undefined;
            title?: string | undefined;
            disabled?: boolean | undefined;
            audience?: "internal" | "end-user" | "operator" | undefined;
            semantics?: Record<string, FieldSemantic> | undefined;
        }, unknown>;
        evidence: z.ZodString;
        pending: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, unknown>, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        binding: z.ZodString;
        srcHash: z.ZodOptional<z.ZodString>;
        fields: z.ZodEffects<z.ZodObject<{
            description: z.ZodOptional<z.ZodString>;
            title: z.ZodOptional<z.ZodString>;
            risk: z.ZodOptional<z.ZodEnum<["read", "write", "destructive", "ungraded"]>>;
            confirmEach: z.ZodOptional<z.ZodBoolean>;
            disabled: z.ZodOptional<z.ZodBoolean>;
            audience: z.ZodOptional<z.ZodEnum<["end-user", "operator", "internal"]>>;
            semantics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<FieldSemantic, z.ZodTypeDef, FieldSemantic>>>;
        }, "strict", z.ZodTypeAny, {
            description?: string | undefined;
            risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
            confirmEach?: boolean | undefined;
            title?: string | undefined;
            disabled?: boolean | undefined;
            audience?: "internal" | "end-user" | "operator" | undefined;
            semantics?: Record<string, FieldSemantic> | undefined;
        }, {
            description?: string | undefined;
            risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
            confirmEach?: boolean | undefined;
            title?: string | undefined;
            disabled?: boolean | undefined;
            audience?: "internal" | "end-user" | "operator" | undefined;
            semantics?: Record<string, FieldSemantic> | undefined;
        }>, {
            description?: string | undefined;
            risk?: "read" | "write" | "destructive" | "ungraded" | undefined;
            confirmEach?: boolean | undefined;
            title?: string | undefined;
            disabled?: boolean | undefined;
            audience?: "internal" | "end-user" | "operator" | undefined;
            semantics?: Record<string, FieldSemantic> | undefined;
        }, unknown>;
        evidence: z.ZodString;
        pending: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
            field: z.ZodEnum<["risk", "confirmEach", "disabled", "audience"]>;
            value: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
            evidence: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, unknown>, "many">>;
    }, z.ZodTypeAny, "passthrough">>>;
}, z.ZodTypeAny, "passthrough">>;
/**
 * Remixable component baseline captured by sync (06 §8, written to
 * `.vendo/remixable/<slot>.json`) — ONE shape, owned by the contract door.
 * Actions used to carry a structural copy of it; the console reads the same
 * bytes from a browser, so the door is where it belongs.
 */
export type { SeedBaseline, SeedSubSource, SeedStyle, } from "../core/apps/index.js";
export { seedBaselineSchema } from "../core/apps/index.js";
/**
 * The component-bundle format (`CapturedModule`, `CapturedHostComponent` and
 * their schemas) lives on the contract door — `@vendoai/vendo/core/apps` — because
 * the console and the jail renderer read the same bytes from the browser. Sync
 * writes them; re-exported here so this package's surface is unchanged.
 */
export { capturedHostComponentSchema, capturedModuleSchema, hostComponentEntrySource, HOST_COMPONENT_SKIP_REASONS, type CapturedHostComponent, type CapturedModule, type HostComponentSampleGap, type HostComponentSkip, type HostComponentSkipReason, } from "../core/apps/index.js";
/** 04-actions §1 */
export interface BreakingChange {
    tool: string;
    change: "removed" | "input-narrowed" | "renamed";
}
/** 04-actions §1 */
export interface SyncReport {
    tools: {
        added: string[];
        removed: string[];
        changed: string[];
    };
    breaking: BreakingChange[];
    /** `pruned` (absent when empty) — stale baselines deleted because no
     *  `<Remixable>` wrapper names their slot anymore. `ported` (absent when
     *  empty) — the slots the wiring file covers, which is what makes the report
     *  say the wiring's TWO hookup call sites out loud. `unattributed` (absent
     *  when empty) — `<Remixable>` wrappers sync FOUND and could not trace back
     *  to `@vendoai/vendo/ui`, each one "file:line — what to do about it". */
    pins: {
        captured: string[];
        drifted: string[];
        pruned?: string[];
        ported?: string[];
        unattributed?: string[];
    };
    catalog: {
        discovered: number;
        registered: number;
    };
    /** Registered host components whose source sync captured, so the console can
     *  render them for real. `skipped` = could not be captured at all;
     *  `withoutSamples` = captured, but the registration declares no usable
     *  `examples`, so a preview can only show a labeled placeholder. */
    components: {
        captured: string[];
        drifted: string[];
        pruned?: string[];
        skipped?: string[];
        withoutSamples?: string[];
    };
    /** Schema coverage across the whole catalog, BOTH slots. `unknown` names the
     *  blind tools by name because a count alone is not actionable: the agent
     *  must pass those outputs through whole and cannot know their arguments. */
    toolSchemas: {
        total: number;
        inputs: {
            known: number;
            unknown: string[];
        };
        outputs: {
            known: number;
            unknown: string[];
        };
    };
}