/**
 * Schema-derived TypeScript declarations for one screen — the static half of
 * the checks floor.
 *
 * The floor already knows every type a screen file can name: the Kit's props
 * are zod (`core` `kit/specs.ts`), a host component's props are the JSON Schema
 * derived once at composition (`NormalizedCatalogEntry.propsJsonSchema`), and a
 * query's result is the tool's declared `outputSchema`. This module turns all
 * of that into ambient declaration text so `tsc` — the real compiler, not a
 * bespoke walker — decides whether a screen names components that exist, sets
 * props that exist with types that fit, reaches fields the data really carries,
 * and aggregates over field names the rows really have.
 *
 * Everything here is DERIVED. No hand-written component list, no hand-written
 * prop list: the component vocabulary comes from `KIT_SCREEN_COMPONENT_NAMES` + the
 * catalog. There is no CALL vocabulary to declare any more — a `{...}` gap is a
 * JavaScript expression, so `invoices.data.reduce((t, r) => t + r.amount, 0)`
 * type-checks against the query's own declared result type with nothing
 * ambient in the way. The old `sum`/`count`/`group_by`/`pick` declarations
 * existed only to give tsc a shape for a closed dialect that no longer exists;
 * shipping them now would type-check calls the renderer cannot evaluate.
 *
 * Pure and deterministic: same input, byte-identical output. No compiler, no
 * I/O — {@link screenTscFindings} in screen-tsc.ts is the half that runs one.
 */
import { type JsonSchema } from "@vendoai/core";
import { type NormalizedCatalog } from "../../contract/index.js";
import type { ZodTypeAny } from "zod";
import { type HostToolInfo } from "./deps.js";
/**
 * Where a construct neither printer can model is announced.
 *
 * Both printers degrade an unknown construct to `any` — never to an error,
 * because a prop we cannot type precisely must not become a false finding. The
 * cost is invisible: the gate quietly stops checking that prop. A caller that
 * passes a sink learns which ones went dark; one that passes nothing keeps the
 * old silence.
 */
export type TypeNote = (reason: string) => void;
/** One query a screen declares: `<Query id="invoices" tool="maple_invoices_list"/>`.
 *  Structurally the floor's own `tree.queries` entry. */
export interface ScreenQueryDeclaration {
    readonly name: string;
    readonly tool: string;
}
export interface ScreenTypingsInput {
    /** The host catalog. A schema-less entry is LEGAL (01-core §14) and gets a
     *  permissive type — never an error. */
    readonly catalog: NormalizedCatalog;
    /** The screen's declared queries, in source order. */
    readonly queries: readonly ScreenQueryDeclaration[];
    /**
     * tool name → the tool's DECLARED output JSON Schema
     * (`ToolDescriptor.outputSchema`). The only source: a declaration is the
     * host's contract, and nothing samples the host anymore.
     */
    readonly toolOutputSchemas?: Readonly<Record<string, JsonSchema | undefined>>;
}
/** The virtual path the declarations occupy in the check's program. */
export declare const SCREEN_TYPINGS_FILE = "/vendo-screen-typings.d.ts";
/**
 * What a slot may hold — an element tree, or a function that returns one.
 *
 * One law for every slot: the element, or the function that makes it. The VM
 * calls whichever it was given (`genui/component/vm-program.ts` `emitSlot`) and
 * emits the result where the slot sits, so `header={() => <Text/>}` is as real as
 * `header={<Text/>}`.
 *
 * The ARITY is the only thing that differs, and it is what this alias states: a
 * slot painted ONCE has no row to be a function of, so its function takes
 * nothing. A `(row) => …` written here would be called with no row and read a
 * field off `undefined` — the compiler is the only thing that can refuse it, and
 * {@link ROW_SLOT_TYPE} is the other arity.
 *
 * The wire printer keeps the permissive alias: a stored document's slot holds a
 * SERIALIZED element (an `$element`-sigilled object) that no type here
 * describes, and JSON cannot carry a closure, so neither form reaches it.
 */
export declare const SLOT_TYPE = "VendoSlot";
/**
 * The same law at the other arity: a slot the Kit paints once PER ROW, whose
 * function is handed the row.
 *
 * A per-row slot is painted once for every row, so a function of the row is the
 * only way to say something different in each — and it is what React trains
 * anyone to write. The VM calls it once per row and hands the component that
 * row's own element (`vm-program.ts` `emitSlot`), so the closure is real: the
 * handler inside `rowActions={(row) => <Button onClick={() => …row.id…}/>}` is
 * that row's handler and nobody else's.
 *
 * A separate alias rather than a widened {@link SLOT_TYPE} because the ARGUMENTS
 * differ, not the law: a function of the row written in a slot painted once is
 * called with no row, and this is the only place that can say so.
 */
export declare const ROW_SLOT_TYPE = "VendoRowSlot";
/**
 * What a FORMATTER may hold — the same law as a slot, at a text arity.
 *
 * A chart's figures are the screen's own text now, so the two aliases below are
 * {@link SLOT_TYPE}'s siblings with the one thing narrowed that matters: the
 * return is a STRING. A formatter that hands back a component compiles clean
 * against a slot type and then paints `[object Object]` on an axis, which is
 * exactly the class of silent breakage this printer exists to refuse.
 *
 * The per-row alias is the one every Kit formatter actually uses; the base is what
 * a text slot painted ONCE would print, and the substitution between them is the
 * same one the slots take ({@link componentPropsText}).
 */
export declare const TEXT_TYPE = "VendoText";
export declare const ROW_TEXT_TYPE = "VendoRowText";
/** The Kit's zod vocabulary is closed — it is our own schema file — so a
 *  direct walker beats a converter dependency (see the module note in the PR).
 *  Anything outside the vocabulary degrades to `any`: a prop we cannot type
 *  precisely must never become a false positive. */
export declare const zodTypeText: (schema: ZodTypeAny | undefined, depth?: number, note?: TypeNote) => string;
/**
 * The ambient declarations for one screen. A global script (no import, no
 * export) so the screen file needs no module envelope — blueprint §5.2 D6
 * keeps the wire envelope-free.
 */
export declare function screenTypings(input: ScreenTypingsInput): string;
/**
 * The one module a component screen imports its surface from. `react` is the
 * only other import it may name, and NOTHING else exists: no DOM lib is loaded
 * into the check's program, so `document`, `fetch` and `<div>` go red because
 * they genuinely are not there — not because a deny-list remembered them.
 */
export declare const SCREEN_MODULE = "@vendo/screen";
/**
 * One component a screen may import: the name, and the props schema the
 * composition derived for it (`NormalizedCatalogEntry.propsJsonSchema`).
 *
 * A BARE NAME is the schema-less case, which is legal (contract `catalog.ts`:
 * "Schema-less entries are legal: the model infers props and validation is
 * permissive") — a host that registered no props schema keeps the permissive
 * shape, so its working screens are not suddenly rejected. A Kit name is always
 * bare: it is typed from its own zod spec, which is the stricter source.
 */
export type ScreenCatalogEntry = string | {
    readonly name: string;
    readonly propsJsonSchema?: JsonSchema;
};
/** The NAMES, in order — the vocabulary the renderer boots with and the tree
 *  check measures against. Exactly the list that flowed here before props rode
 *  along, because the declared surface must stay the renderer's surface. */
export declare const screenCatalogNames: (catalog: readonly ScreenCatalogEntry[]) => string[];
/**
 * What a screen may import from `@vendo/screen`: the WHOLE Kit plus this host's
 * own catalog.
 *
 * The whole Kit, not the wire-safe subset — a screen writes JSX, so the
 * element-valued slots the wire dialect could never express (`Accordion`) are
 * ordinary here.
 *
 * Composed once, and to match the RENDERER exactly (`packages/ui` renderer.tsx
 * boots the VM with `[...KIT_COMPONENT_NAMES, ...host components]`): a name this
 * check admits and the renderer does not is a screen that passes every gate and
 * paints nothing, and a name the renderer has and the check does not is a type
 * error over working code.
 *
 * A host entry brings its derived props schema along, because the type check has
 * no other way to learn a host component's props and a name alone degrades every
 * one of them to `any` — which makes a guessed prop on a host component compile,
 * the one thing the skill promises it will not. The Kit half stays bare NAMES:
 * those are typed from their own zod specs, the stricter source.
 */
export declare const screenCatalog: (catalog: readonly {
    name: string;
    propsJsonSchema?: JsonSchema;
}[]) => ScreenCatalogEntry[];
/** `Promise`, and no DOM: a handler awaits a tool call, and `document`/`fetch`
 *  must stay undeclared so reaching for them is an error.
 *
 *  It is also what declares `Intl` — `NumberFormat`, `formatToParts`, `dateStyle`,
 *  and the locale-taking `toLocaleString`/`toLocaleDateString` overloads — and
 *  those declarations are TRUE inside the box: the VM carries no ICU and borrows
 *  the host's real `Intl` across the wall (`genui/component/vm-program.ts`
 *  `INTL_SOURCE`). A smaller lib here would refuse the one idiom every model
 *  writes for money and dates while the VM ran it perfectly well.
 *
 *  THIS PIN DECIDES WHAT THE BRIDGE MUST CARRY. Every value-side name in this
 *  lib's `Intl` is a name a screen may write and the box therefore has to answer;
 *  one that is declared and unbridged is a green check over a screen that dies on
 *  its first paint. Moving the pin moves that obligation — `ListFormat` and the
 *  `formatRange` family arrive with es2021 and es2023 — so a bump lands together
 *  with the bridge's new methods, and `tests/checking/screen-intl-parity.test.ts`
 *  walks the two surfaces and refuses any difference either way. */
export declare const COMPONENT_SCREEN_LIB: string[];
export interface ComponentScreenTypingsInput {
    /** The components this screen may import. A Kit name is typed from its own zod
     *  spec; anything else is a host component, typed from the one props schema it
     *  registered — or permissively, when it registered none. */
    readonly catalog: readonly ScreenCatalogEntry[];
    /** The host tools: read tools become `useQuery` overloads, and every tool
     *  becomes a `tools` member typed from its input schema. */
    readonly tools: readonly HostToolInfo[];
    /** Where the printers announce what they could not model. */
    readonly note?: TypeNote;
    /** This screen is the splitter's PORT of a host component, so its tags take the
     *  host's `className`. Unset — every screen a model authored — and there is no
     *  such prop to write.
     *
     *  The boundary is the SCREEN, not the node, and it cannot be otherwise: a
     *  remix's first act is a model edit of the ported file, so inside a port there
     *  is no line to draw between ported and written. Do not reach for per-node
     *  provenance to tighten this — there is none to read. */
    readonly ported?: boolean;
}
/**
 * The ambient declarations for one COMPONENT screen — the plain-TSX artifact.
 *
 * Same derivation as {@link screenTypings} and the same printers, a different
 * shape: a screen file is a real module now, so the surface is declared as the
 * two modules it may import instead of as bare globals. Data arrives through
 * `useQuery`, overloaded once per read tool with that tool's declared result
 * type, and actions through `tools`, typed per tool input schema — so "reads a
 * field the response does not carry" and "calls a tool with the wrong payload
 * key" are both answered by the compiler.
 */
export declare function componentScreenTypings(input: ComponentScreenTypingsInput): string;
//# sourceMappingURL=screen-typings.d.ts.map