# Images API reference

> Exports of @gramforge/images.

Source: https://gramforge.n.yatsyk.com/docs/images/jsdoc

## Functions

### rasterizeSvgResvgWasm

Rasterize an SVG string to PNG via `@resvg/resvg-wasm` (portable). The resvg
wasm binary is injected and initialized once per process.

```ts
rasterizeSvgResvgWasm(svg: string, wasm: InitInput): Promise<RasterizeResult>
```

### rasterizeSvgSharp

Rasterize an SVG string to PNG via sharp (Node-only).

```ts
rasterizeSvgSharp(svg: string, width: number, height: number): Promise<RasterizeResult>
```

### resetBackendSelection

Test-only: clear the memoized native probe.

```ts
resetBackendSelection(): void
```

### selectBackend

Select the backend to serve renders. Native probing is memoized per process;
forcing and wasm selection are evaluated fresh each call (they carry
per-call injected inputs).

```ts
selectBackend(options?: SelectBackendOptions): Promise<BackendSelection>
```

### toRendererBackend

Map a `BackendSelection` to the `RendererBackend` reported in `RenderMeta`.

```ts
toRendererBackend(selection: BackendSelection): RendererBackend
```

### tryCreateTakumiNativeBackend

Attempt to construct the native backend: dynamic-import the napi binding,
instantiate a `Renderer`, and register the provided font buffers once.

```ts
tryCreateTakumiNativeBackend(fonts: readonly Uint8Array[]): Promise<NativeLoadResult>
```

### createTakumiWasmBackend

Create the wasm backend. Instantiation of the wasm module and font
registration happen lazily on the first `renderPng` call so this factory is
synchronous and side-effect-free until a render is actually requested.

```ts
createTakumiWasmBackend(inputs: TakumiWasmInputs): ImageBackend
```

### createInMemoryFileIdCacheStore

A process-lifetime `Map`-backed store for development/testing.

```ts
createInMemoryFileIdCacheStore(): FileIdCacheStore
```

### recordUpload

Record a newly-uploaded `file_id` into the store. The single place a caller
writes a `file_id` back — this package itself never performs the upload.

```ts
recordUpload(store: FileIdCacheStore, hash: ContentHash, botId: BotId, fileId: TelegramFileId): Promise<void>
```

### chartToSvg

Render a validated `ChartSpec` to an SVG string (pure, no rasterization).

```ts
chartToSvg(spec: ChartSpec, dimensions: ChartDimensions): string
```

### renderChart

Render a chart spec to PNG bytes. Validates the spec, generates the SVG via
ECharts SSR, then rasterizes with sharp. Returns the shared `RenderResult` DU.

```ts
renderChart(spec: ChartSpec, dimensions?: ChartDimensions): Promise<RenderResult>
```

### containsColorEmoji

True when `input` contains at least one codepoint in a color-emoji
presentation range (emoticons, symbols/pictographs, transport, supplemental,
regional indicators, and the common Misc-Symbols/Dingbats emoji subset).

```ts
containsColorEmoji(input: string): boolean
```

### emojiCodepoints

Collect the distinct emoji codepoints (as `U+XXXX` strings) in `input`.

```ts
emojiCodepoints(input: string): string[]
```

### loadBundledFont

The bundled font bytes, read once and memoized for the process lifetime.

```ts
loadBundledFont(): Uint8Array
```

### computeContentHash

SHA-256 of `bytes`, returned as a branded lowercase-hex `ContentHash`.

```ts
computeContentHash(bytes: Uint8Array): Promise<ContentHash>
```

### resetDiagnostics

Test-only: clear the dedup set between tests.

```ts
resetDiagnostics(): void
```

### setDiagnosticHook

```ts
setDiagnosticHook(fn: ((e: DiagnosticEvent) => void) | null): void
```

### warnDegraded

```ts
warnDegraded(context: string, detail: string): void
```

### warnNotImplemented

```ts
warnNotImplemented(category: string, detail: string): void
```

### warnUnexpected

```ts
warnUnexpected(context: string, detail: string, data?: Record<string, unknown>): void
```

### chartCard

```ts
chartCard(input: ChartCardInput): CardTemplate
```

### completionCard

```ts
completionCard(input: CompletionCardInput): CardTemplate
```

### failureCard

```ts
failureCard(input: FailureCardInput): CardTemplate
```

### fleetOverviewCard

```ts
fleetOverviewCard(input: FleetOverviewCardInput): CardTemplate
```

### needsInputCard

```ts
needsInputCard(input: Omit<NeedsInputCardInput, "options"> & { readonly options: NonEmptyArray<NeedsInputOption>; }): CardTemplate
```

### renderCard

Validate a card input, optionally short-circuit via the file_id cache, else
render the matching template. Never throws for expected failures.

```ts
renderCard(input: CardInput, options?: RenderCardOptions): Promise<RenderResult | CachedFileHit>
```

### renderCardTree

Render a neutral card tree to a `RenderResult`. `contentHash` is supplied by
the caller (card path uses the input hash; callers may pass a byte hash).

```ts
renderCardTree(node: CardNode, dims: RenderPngOptions, contentHash: ContentHash, options?: RenderCardTreeOptions): Promise<RenderResult>
```

### statusCard

```ts
statusCard(input: StatusCardInput): CardTemplate
```

### col

A vertical flex container (`flexDirection: column`).

```ts
col(style: CardStyle, children: readonly CardNode[]): BoxNode
```

### div

A generic flex container.

```ts
div(style: CardStyle, children: readonly CardNode[]): BoxNode
```

### img

An image leaf carrying raw bytes (e.g. a rendered chart PNG).

```ts
img(input: { readonly src: Uint8Array; readonly width: number; readonly height: number; readonly style?: CardStyle; }): ImageNode
```

### row

A horizontal flex container (`flexDirection: row`).

```ts
row(style: CardStyle, children: readonly CardNode[]): BoxNode
```

### text

A text leaf.

```ts
text(value: string, style?: CardStyle): TextNode
```

## Types

### RasterizeResult

```ts
type RasterizeResult = | {
      readonly ok: true;
      readonly bytes: Uint8Array;
      readonly width: number;
      readonly height: number;
    }
  | { readonly ok: false; readonly message: string }
```

### BackendSelection

```ts
type BackendSelection = | { readonly kind: "takumi-native"; readonly backend: ImageBackend }
  | { readonly kind: "takumi-wasm"; readonly backend: ImageBackend }
  | { readonly kind: "fallback"; readonly reason: RendererFallbackReason }
```

### ForcedBackend

```ts
type ForcedBackend = "takumi-native" | "takumi-wasm" | "fallback"
```

### NativeLoadResult

```ts
type NativeLoadResult = | { readonly ok: true; readonly backend: ImageBackend }
  | { readonly ok: false; readonly error: unknown }
```

### BackendKind

```ts
type BackendKind = "takumi-native" | "takumi-wasm"
```

### DiagnosticKind

Runtime diagnostics — the house alternative to deferred-work comments.

Three functions: `warnNotImplemented`, `warnDegraded`, `warnUnexpected`.
Each fires once per stable key (except `warnUnexpected`, which always fires),
is greppable, and can be piped into a UI panel via {@link setDiagnosticHook}.

Usage:
  warnDegraded("MyModule.fallback", "linear interp — cubic deferred, spec:120-140");
  warnNotImplemented("MyModule.featureX", "spec §4 not yet lowered");
  warnUnexpected("MyModule.parse", "expected number, got string", { value });

```ts
type DiagnosticKind = "not-implemented" | "degraded" | "unexpected"
```

### NonEmptyArray

```ts
type NonEmptyArray = NonEmptyArray<T>
```

### BotId

```ts
type BotId = string & z.BRAND<"BotId">
```

### CachedFileHit

```ts
type CachedFileHit = { hit?: true; fileId?: string & z.BRAND<"TelegramFileId">; contentHash?: string & z.BRAND<"ContentHash">; }
```

### CardInput

```ts
type CardInput = { template?: "status"; agentName?: string; level?: "ok" | "warn" | "error"; headline?: string; detail?: { kind?: "none"; } | { kind?: "text"; value?: string; }; timestampIso?: string; } | { title?: string; template?: "fleet-overview"; timestampIso?: string; agents?: { name?: string; level?: "ok" | "warn" | "error"; note?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }[]; chart?: { kind?: "none"; } | { kind?: "spec"; spec?: { kind?: "bar" | "line"; title?: string; categories?: string[]; series?: { values?: number[]; name?: string; }[]; }; }; } | { options?: { label?: string; hint?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }[]; template?: "needs-input"; agentName?: string; timestampIso?: string; question?: string; } | { template?: "completion"; agentName?: string; headline?: string; timestampIso?: string; summary?: { kind?: "none"; } | { kind?: "text"; value?: string; }; durationMs?: number; } | { template?: "failure"; agentName?: string; headline?: string; detail?: { kind?: "none"; } | { kind?: "text"; value?: string; }; timestampIso?: string; } | { template?: "chart"; spec?: { kind?: "bar" | "line"; title?: string; categories?: string[]; series?: { values?: number[]; name?: string; }[]; }; caption?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }
```

### ChartCardInput

```ts
type ChartCardInput = { template?: "chart"; spec?: { kind?: "bar" | "line"; title?: string; categories?: string[]; series?: { values?: number[]; name?: string; }[]; }; caption?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }
```

### ChartKind

```ts
type ChartKind = "bar" | "line"
```

### ChartSeries

```ts
type ChartSeries = { values?: number[]; name?: string; }
```

### ChartSpec

```ts
type ChartSpec = { kind?: "bar" | "line"; title?: string; categories?: string[]; series?: { values?: number[]; name?: string; }[]; }
```

### CompletionCardInput

```ts
type CompletionCardInput = { template?: "completion"; agentName?: string; headline?: string; timestampIso?: string; summary?: { kind?: "none"; } | { kind?: "text"; value?: string; }; durationMs?: number; }
```

### ContentHash

```ts
type ContentHash = string & z.BRAND<"ContentHash">
```

### FailureCardInput

```ts
type FailureCardInput = { template?: "failure"; agentName?: string; headline?: string; detail?: { kind?: "none"; } | { kind?: "text"; value?: string; }; timestampIso?: string; }
```

### FleetAgent

```ts
type FleetAgent = { name?: string; level?: "ok" | "warn" | "error"; note?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }
```

### FleetOverviewCardInput

```ts
type FleetOverviewCardInput = { title?: string; template?: "fleet-overview"; timestampIso?: string; agents?: { name?: string; level?: "ok" | "warn" | "error"; note?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }[]; chart?: { kind?: "none"; } | { kind?: "spec"; spec?: { kind?: "bar" | "line"; title?: string; categories?: string[]; series?: { values?: number[]; name?: string; }[]; }; }; }
```

### NeedsInputCardInput

```ts
type NeedsInputCardInput = { options?: { label?: string; hint?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }[]; template?: "needs-input"; agentName?: string; timestampIso?: string; question?: string; }
```

### NeedsInputOption

```ts
type NeedsInputOption = { label?: string; hint?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }
```

### NetworkUsage

```ts
type NetworkUsage = { kind?: "offline"; } | { kind?: "emoji-font-fetch"; codepoints?: string[]; }
```

### RenderErr

```ts
type RenderErr = { readonly ok: false; readonly error: RenderFailure }
```

### RendererBackend

```ts
type RendererBackend = { kind?: "takumi"; } | { kind?: "satori-sharp"; reason?: { kind?: "native-module-load-failed"; platform?: string; arch?: string; } | { kind?: "forced-fallback"; }; }
```

### RendererFallbackReason

```ts
type RendererFallbackReason = { kind?: "native-module-load-failed"; platform?: string; arch?: string; } | { kind?: "forced-fallback"; }
```

### RenderFailure

```ts
type RenderFailure = { kind?: "invalid-template-input"; issues?: string[]; } | { kind?: "renderer-unavailable"; attempted?: ({ kind?: "takumi"; } | { kind?: "satori-sharp"; reason?: { kind?: "native-module-load-failed"; platform?: string; arch?: string; } | { kind?: "forced-fallback"; }; })[]; } | { kind?: "rasterize-failed"; message?: string; } | { kind?: "chart-spec-invalid"; issues?: string[]; }
```

### RenderMeta

```ts
type RenderMeta = { contentHash?: string & z.BRAND<"ContentHash">; backend?: { kind?: "takumi"; } | { kind?: "satori-sharp"; reason?: { kind?: "native-module-load-failed"; platform?: string; arch?: string; } | { kind?: "forced-fallback"; }; }; network?: { kind?: "offline"; } | { kind?: "emoji-font-fetch"; codepoints?: string[]; }; renderMs?: number; widthPx?: number; heightPx?: number; }
```

### RenderOk

```ts
type RenderOk = { readonly ok: true; readonly bytes: Uint8Array; readonly meta: RenderMeta }
```

### RenderResult

```ts
type RenderResult = RenderOk | RenderErr
```

### StatusCardInput

```ts
type StatusCardInput = { template?: "status"; agentName?: string; level?: "ok" | "warn" | "error"; headline?: string; detail?: { kind?: "none"; } | { kind?: "text"; value?: string; }; timestampIso?: string; }
```

### StatusLevel

```ts
type StatusLevel = "ok" | "warn" | "error"
```

### TelegramFileId

```ts
type TelegramFileId = string & z.BRAND<"TelegramFileId">
```

### BoxNode

```ts
type BoxNode = {
  readonly kind: "box";
  readonly style: CardStyle;
  readonly children: readonly CardNode[];
}
```

### CardNode

```ts
type CardNode = BoxNode | TextNode | ImageNode
```

### FlexAlign

```ts
type FlexAlign = "flex-start" | "center" | "flex-end" | "stretch" | "baseline"
```

### FlexDirection

The single flexbox-safe authoring format for both backends.

Card templates build a neutral `CardNode` tree via `div`/`row`/`col`/`text`/
`img`. The backends convert it to their native shape (Takumi's
`{ type: "container" | "text" | "image" }` nodes, or a satori element tree).
`CardStyle` deliberately exposes only flexbox-compatible props — there is no
CSS Grid and no free-form `style: string` escape hatch, so a template that
type-checks renders consistently on Takumi and satori alike.

```ts
type FlexDirection = "row" | "column"
```

### FlexJustify

```ts
type FlexJustify = | "flex-start"
  | "center"
  | "flex-end"
  | "space-between"
  | "space-around"
  | "space-evenly"
```

### FlexWrap

```ts
type FlexWrap = "nowrap" | "wrap"
```

### ImageNode

```ts
type ImageNode = {
  readonly kind: "image";
  readonly style: CardStyle;
  readonly src: Uint8Array;
  readonly width: number;
  readonly height: number;
}
```

### ObjectFit

```ts
type ObjectFit = "fill" | "contain" | "cover"
```

### TextAlign

```ts
type TextAlign = "left" | "center" | "right"
```

### TextNode

```ts
type TextNode = { readonly kind: "text"; readonly style: CardStyle; readonly text: string }
```

## Interfaces

### SelectBackendOptions

```ts
interface SelectBackendOptions
```

- `force: ForcedBackend`
- `fonts: readonly Uint8Array<ArrayBufferLike>[]` — Font buffers for the native backend (defaults handled by the caller).
- `wasm: TakumiWasmInputs` — Required to select the wasm backend.

### TakumiWasmInputs

```ts
interface TakumiWasmInputs
```

- `wasm: SyncInitInput` — The `takumi_wasm_bg.wasm` bytes or a precompiled module.
- `fonts: readonly Uint8Array<ArrayBufferLike>[]` — Font buffers to register (e.g. a Latin/monospace font).

### ImageBackend

```ts
interface ImageBackend
```

- `kind: BackendKind`
- `renderPng(node: CardNode, opts: RenderPngOptions): Promise<Uint8Array>`

### RenderPngOptions

```ts
interface RenderPngOptions
```

- `width: number`
- `height: number`

### FileIdCacheStore

Pluggable storage port. The in-memory default ships here; callers substitute
a persistent (SQLite/Redis) implementation without any change to `renderCard`.

```ts
interface FileIdCacheStore
```

- `get(hash: ContentHash, botId: BotId): Promise<TelegramFileId | null>`
- `set(hash: ContentHash, botId: BotId, fileId: TelegramFileId): Promise<void>`

### ChartDimensions

```ts
interface ChartDimensions
```

- `width: number`
- `height: number`

### DiagnosticEvent

```ts
interface DiagnosticEvent
```

- `kind: DiagnosticKind`
- `category: string`
- `detail: string`
- `stack: string`
- `data: Record<string, unknown>`
- `timestamp: number`

### CardTemplate

```ts
interface CardTemplate
```

- `template: "status" | "fleet-overview" | "chart" | "needs-input" | "completion" | "failure"`
- `dimensions: RenderPngOptions`
- `buildTree(): Promise<CardNode>`
- `render(options?: RenderCardTreeOptions): Promise<RenderResult>`

### RenderCardOptions

```ts
interface RenderCardOptions
```

- `lookup: FileIdCacheStore`
- `botId: string & import("/home/andrew/gits/github/gramforge/gramforge-sf-phase3-npmf/node_modules/.pnpm/zod@3.25.76/node_modules/zod/index").BRAND<"BotId">`

### RenderCardTreeOptions

```ts
interface RenderCardTreeOptions
```

- `force: ForcedBackend`
- `fonts: readonly Uint8Array<ArrayBufferLike>[]`
- `wasm: TakumiWasmInputs`

### CardStyle

The flexbox-only style subset. Every property is optional at the type level,
but there is no `[k: string]: unknown` index signature and no raw string
escape hatch, so unsupported CSS (grid, position tricks) cannot be expressed.

```ts
interface CardStyle
```

- `flexDirection: FlexDirection`
- `alignItems: FlexAlign`
- `justifyContent: FlexJustify`
- `flexWrap: FlexWrap`
- `flexGrow: number`
- `flexShrink: number`
- `flexBasis: string | number`
- `gap: number`
- `padding: string | number`
- `margin: string | number`
- `width: string | number`
- `height: string | number`
- `minWidth: string | number`
- `maxWidth: string | number`
- `minHeight: string | number`
- `maxHeight: string | number`
- `backgroundColor: string`
- `color: string`
- `fontSize: number`
- `fontWeight: number`
- `fontFamily: string`
- `lineHeight: number`
- `letterSpacing: number`
- `textAlign: TextAlign`
- `borderRadius: number`
- `borderWidth: number`
- `borderColor: string`
- `borderStyle: "solid"`
- `objectFit: ObjectFit`
- `opacity: number`

## Constants

### DEFAULT_CHART_HEIGHT

```ts
const DEFAULT_CHART_HEIGHT: 480
```

### DEFAULT_CHART_WIDTH

```ts
const DEFAULT_CHART_WIDTH: 800
```

### BUNDLED_FONT_FAMILY

```ts
const BUNDLED_FONT_FAMILY: "DejaVu Sans"
```

### BotIdSchema

```ts
const BotIdSchema: z.ZodBranded<z.ZodString, "BotId">
```

### CachedFileHitSchema

```ts
const CachedFileHitSchema: z.ZodObject<{ hit: z.ZodLiteral<true>; fileId: z.ZodBranded<z.ZodString, "TelegramFileId">; contentHash: z.ZodBranded<z.ZodString, "ContentHash">; }, "strip", z.ZodTypeAny, { hit?: true; fileId?: string & z.BRAND<"TelegramFileId">; contentHash?: string & z.BRAND<"ContentHash">; }, { hit?: true; fileId?: string; contentHash?: string; }>
```

### CardInputSchema

```ts
const CardInputSchema: z.ZodDiscriminatedUnion<"template", [z.ZodObject<{ template: z.ZodLiteral<"status">; agentName: z.ZodString; level: z.ZodEnum<["ok", "warn", "error"]>; headline: z.ZodString; detail: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind?: "none"; }, { kind?: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"text">; value: z.ZodString; }, "strip", z.ZodTypeAny, { kind?: "text"; value?: string; }, { kind?: "text"; value?: string; }>]>; timestampIso: z.ZodString; }, "strip", z.ZodTypeAny, { template?: "status"; agentName?: string; level?: "ok" | "warn" | "error"; headline?: string; detail?: { kind?: "none"; } | { kind?: "text"; value?: string; }; timestampIso?: string; }, { template?: "status"; agentName?: string; level?: "ok" | "warn" | "error"; headline?: string; detail?: { kind?: "none"; } | { kind?: "text"; value?: string; }; timestampIso?: string; }>, z.ZodObject<{ template: z.ZodLiteral<"fleet-overview">; title: z.ZodString; agents: z.ZodArray<z.ZodObject<{ name: z.ZodString; level: z.ZodEnum<["ok", "warn", "error"]>; note: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind?: "none"; }, { kind?: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"text">; value: z.ZodString; }, "strip", z.ZodTypeAny, { kind?: "text"; value?: string; }, { kind?: "text"; value?: string; }>]>; }, "strip", z.ZodTypeAny, { name?: string; level?: "ok" | "warn" | "error"; note?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }, { name?: string; level?: "ok" | "warn" | "error"; note?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }>, "many">; chart: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind?: "none"; }, { kind?: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"spec">; spec: z.ZodObject<{ kind: z.ZodEnum<["bar", "line"]>; title: z.ZodString; categories: z.ZodArray<z.ZodString, "many">; series: z.ZodArray<z.ZodObject<{ name: z.ZodString; values: z.ZodArray<z.ZodNumber, "many">; }, "strip", z.ZodTypeAny, { values?: number[]; name?: string; }, { values?: number[]; name?: string; }>, "many">; }, "strip", z.ZodTypeAny, { kind?: "bar" | "line"; title?: string; categories?: string[]; series?: { values?: number[]; name?: string; }[]; }, { kind?: "bar" | "line"; title?: string; categories?: string[]; series?: { values?: number[]; name?: string; }[]; }>; }, "strip", z.ZodTypeAny, { kind?: "spec"; spec?: { kind?: "bar" | "line"; title?: string; categories?: string[]; series?: { values?: number[]; name?: string; }[]; }; }, { kind?: "spec"; spec?: { kind?: "bar" | "line"; title?: string; categories?: string[]; series?: { values?: number[]; name?: string; }[]; }; }>]>; timestampIso: z.ZodString; }, "strip", z.ZodTypeAny, { title?: string; template?: "fleet-overview"; timestampIso?: string; agents?: { name?: string; level?: "ok" | "warn" | "error"; note?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }[]; chart?: { kind?: "none"; } | { kind?: "spec"; spec?: { kind?: "bar" | "line"; title?: string; categories?: string[]; series?: { values?: number[]; name?: string; }[]; }; }; }, { title?: string; template?: "fleet-overview"; timestampIso?: string; agents?: { name?: string; level?: "ok" | "warn" | "error"; note?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }[]; chart?: { kind?: "none"; } | { kind?: "spec"; spec?: { kind?: "bar" | "line"; title?: string; categories?: string[]; series?: { values?: number[]; name?: string; }[]; }; }; }>, z.ZodObject<{ template: z.ZodLiteral<"needs-input">; agentName: z.ZodString; question: z.ZodString; options: z.ZodArray<z.ZodObject<{ label: z.ZodString; hint: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind?: "none"; }, { kind?: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"text">; value: z.ZodString; }, "strip", z.ZodTypeAny, { kind?: "text"; value?: string; }, { kind?: "text"; value?: string; }>]>; }, "strip", z.ZodTypeAny, { label?: string; hint?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }, { label?: string; hint?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }>, "many">; timestampIso: z.ZodString; }, "strip", z.ZodTypeAny, { options?: { label?: string; hint?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }[]; template?: "needs-input"; agentName?: string; timestampIso?: string; question?: string; }, { options?: { label?: string; hint?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }[]; template?: "needs-input"; agentName?: string; timestampIso?: string; question?: string; }>, z.ZodObject<{ template: z.ZodLiteral<"completion">; agentName: z.ZodString; headline: z.ZodString; summary: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind?: "none"; }, { kind?: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"text">; value: z.ZodString; }, "strip", z.ZodTypeAny, { kind?: "text"; value?: string; }, { kind?: "text"; value?: string; }>]>; durationMs: z.ZodNumber; timestampIso: z.ZodString; }, "strip", z.ZodTypeAny, { template?: "completion"; agentName?: string; headline?: string; timestampIso?: string; summary?: { kind?: "none"; } | { kind?: "text"; value?: string; }; durationMs?: number; }, { template?: "completion"; agentName?: string; headline?: string; timestampIso?: string; summary?: { kind?: "none"; } | { kind?: "text"; value?: string; }; durationMs?: number; }>, z.ZodObject<{ template: z.ZodLiteral<"failure">; agentName: z.ZodString; headline: z.ZodString; detail: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind?: "none"; }, { kind?: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"text">; value: z.ZodString; }, "strip", z.ZodTypeAny, { kind?: "text"; value?: string; }, { kind?: "text"; value?: string; }>]>; timestampIso: z.ZodString; }, "strip", z.ZodTypeAny, { template?: "failure"; agentName?: string; headline?: string; detail?: { kind?: "none"; } | { kind?: "text"; value?: string; }; timestampIso?: string; }, { template?: "failure"; agentName?: string; headline?: string; detail?: { kind?: "none"; } | { kind?: "text"; value?: string; }; timestampIso?: string; }>, z.ZodObject<{ template: z.ZodLiteral<"chart">; spec: z.ZodObject<{ kind: z.ZodEnum<["bar", "line"]>; title: z.ZodString; categories: z.ZodArray<z.ZodString, "many">; series: z.ZodArray<z.ZodObject<{ name: z.ZodString; values: z.ZodArray<z.ZodNumber, "many">; }, "strip", z.ZodTypeAny, { values?: number[]; name?: string; }, { values?: number[]; name?: string; }>, "many">; }, "strip", z.ZodTypeAny, { kind?: "bar" | "line"; title?: string; categories?: string[]; series?: { values?: number[]; name?: string; }[]; }, { kind?: "bar" | "line"; title?: string; categories?: string[]; series?: { values?: number[]; name?: string; }[]; }>; caption: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind?: "none"; }, { kind?: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"text">; value: z.ZodString; }, "strip", z.ZodTypeAny, { kind?: "text"; value?: string; }, { kind?: "text"; value?: string; }>]>; }, "strip", z.ZodTypeAny, { template?: "chart"; spec?: { kind?: "bar" | "line"; title?: string; categories?: string[]; series?: { values?: number[]; name?: string; }[]; }; caption?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }, { template?: "chart"; spec?: { kind?: "bar" | "line"; title?: string; categories?: string[]; series?: { values?: number[]; name?: string; }[]; }; caption?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }>]>
```

### ChartCardInputSchema

```ts
const ChartCardInputSchema: z.ZodObject<{ template: z.ZodLiteral<"chart">; spec: z.ZodObject<{ kind: z.ZodEnum<["bar", "line"]>; title: z.ZodString; categories: z.ZodArray<z.ZodString, "many">; series: z.ZodArray<z.ZodObject<{ name: z.ZodString; values: z.ZodArray<z.ZodNumber, "many">; }, "strip", z.ZodTypeAny, { values?: number[]; name?: string; }, { values?: number[]; name?: string; }>, "many">; }, "strip", z.ZodTypeAny, { kind?: "bar" | "line"; title?: string; categories?: string[]; series?: { values?: number[]; name?: string; }[]; }, { kind?: "bar" | "line"; title?: string; categories?: string[]; series?: { values?: number[]; name?: string; }[]; }>; caption: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind?: "none"; }, { kind?: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"text">; value: z.ZodString; }, "strip", z.ZodTypeAny, { kind?: "text"; value?: string; }, { kind?: "text"; value?: string; }>]>; }, "strip", z.ZodTypeAny, { template?: "chart"; spec?: { kind?: "bar" | "line"; title?: string; categories?: string[]; series?: { values?: number[]; name?: string; }[]; }; caption?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }, { template?: "chart"; spec?: { kind?: "bar" | "line"; title?: string; categories?: string[]; series?: { values?: number[]; name?: string; }[]; }; caption?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }>
```

### ChartKindSchema

```ts
const ChartKindSchema: z.ZodEnum<["bar", "line"]>
```

### ChartSeriesSchema

```ts
const ChartSeriesSchema: z.ZodObject<{ name: z.ZodString; values: z.ZodArray<z.ZodNumber, "many">; }, "strip", z.ZodTypeAny, { values?: number[]; name?: string; }, { values?: number[]; name?: string; }>
```

### ChartSpecSchema

```ts
const ChartSpecSchema: z.ZodObject<{ kind: z.ZodEnum<["bar", "line"]>; title: z.ZodString; categories: z.ZodArray<z.ZodString, "many">; series: z.ZodArray<z.ZodObject<{ name: z.ZodString; values: z.ZodArray<z.ZodNumber, "many">; }, "strip", z.ZodTypeAny, { values?: number[]; name?: string; }, { values?: number[]; name?: string; }>, "many">; }, "strip", z.ZodTypeAny, { kind?: "bar" | "line"; title?: string; categories?: string[]; series?: { values?: number[]; name?: string; }[]; }, { kind?: "bar" | "line"; title?: string; categories?: string[]; series?: { values?: number[]; name?: string; }[]; }>
```

### CompletionCardInputSchema

```ts
const CompletionCardInputSchema: z.ZodObject<{ template: z.ZodLiteral<"completion">; agentName: z.ZodString; headline: z.ZodString; summary: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind?: "none"; }, { kind?: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"text">; value: z.ZodString; }, "strip", z.ZodTypeAny, { kind?: "text"; value?: string; }, { kind?: "text"; value?: string; }>]>; durationMs: z.ZodNumber; timestampIso: z.ZodString; }, "strip", z.ZodTypeAny, { template?: "completion"; agentName?: string; headline?: string; timestampIso?: string; summary?: { kind?: "none"; } | { kind?: "text"; value?: string; }; durationMs?: number; }, { template?: "completion"; agentName?: string; headline?: string; timestampIso?: string; summary?: { kind?: "none"; } | { kind?: "text"; value?: string; }; durationMs?: number; }>
```

### ContentHashSchema

```ts
const ContentHashSchema: z.ZodBranded<z.ZodString, "ContentHash">
```

### FailureCardInputSchema

```ts
const FailureCardInputSchema: z.ZodObject<{ template: z.ZodLiteral<"failure">; agentName: z.ZodString; headline: z.ZodString; detail: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind?: "none"; }, { kind?: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"text">; value: z.ZodString; }, "strip", z.ZodTypeAny, { kind?: "text"; value?: string; }, { kind?: "text"; value?: string; }>]>; timestampIso: z.ZodString; }, "strip", z.ZodTypeAny, { template?: "failure"; agentName?: string; headline?: string; detail?: { kind?: "none"; } | { kind?: "text"; value?: string; }; timestampIso?: string; }, { template?: "failure"; agentName?: string; headline?: string; detail?: { kind?: "none"; } | { kind?: "text"; value?: string; }; timestampIso?: string; }>
```

### FleetAgentSchema

```ts
const FleetAgentSchema: z.ZodObject<{ name: z.ZodString; level: z.ZodEnum<["ok", "warn", "error"]>; note: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind?: "none"; }, { kind?: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"text">; value: z.ZodString; }, "strip", z.ZodTypeAny, { kind?: "text"; value?: string; }, { kind?: "text"; value?: string; }>]>; }, "strip", z.ZodTypeAny, { name?: string; level?: "ok" | "warn" | "error"; note?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }, { name?: string; level?: "ok" | "warn" | "error"; note?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }>
```

### FleetOverviewCardInputSchema

```ts
const FleetOverviewCardInputSchema: z.ZodObject<{ template: z.ZodLiteral<"fleet-overview">; title: z.ZodString; agents: z.ZodArray<z.ZodObject<{ name: z.ZodString; level: z.ZodEnum<["ok", "warn", "error"]>; note: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind?: "none"; }, { kind?: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"text">; value: z.ZodString; }, "strip", z.ZodTypeAny, { kind?: "text"; value?: string; }, { kind?: "text"; value?: string; }>]>; }, "strip", z.ZodTypeAny, { name?: string; level?: "ok" | "warn" | "error"; note?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }, { name?: string; level?: "ok" | "warn" | "error"; note?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }>, "many">; chart: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind?: "none"; }, { kind?: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"spec">; spec: z.ZodObject<{ kind: z.ZodEnum<["bar", "line"]>; title: z.ZodString; categories: z.ZodArray<z.ZodString, "many">; series: z.ZodArray<z.ZodObject<{ name: z.ZodString; values: z.ZodArray<z.ZodNumber, "many">; }, "strip", z.ZodTypeAny, { values?: number[]; name?: string; }, { values?: number[]; name?: string; }>, "many">; }, "strip", z.ZodTypeAny, { kind?: "bar" | "line"; title?: string; categories?: string[]; series?: { values?: number[]; name?: string; }[]; }, { kind?: "bar" | "line"; title?: string; categories?: string[]; series?: { values?: number[]; name?: string; }[]; }>; }, "strip", z.ZodTypeAny, { kind?: "spec"; spec?: { kind?: "bar" | "line"; title?: string; categories?: string[]; series?: { values?: number[]; name?: string; }[]; }; }, { kind?: "spec"; spec?: { kind?: "bar" | "line"; title?: string; categories?: string[]; series?: { values?: number[]; name?: string; }[]; }; }>]>; timestampIso: z.ZodString; }, "strip", z.ZodTypeAny, { title?: string; template?: "fleet-overview"; timestampIso?: string; agents?: { name?: string; level?: "ok" | "warn" | "error"; note?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }[]; chart?: { kind?: "none"; } | { kind?: "spec"; spec?: { kind?: "bar" | "line"; title?: string; categories?: string[]; series?: { values?: number[]; name?: string; }[]; }; }; }, { title?: string; template?: "fleet-overview"; timestampIso?: string; agents?: { name?: string; level?: "ok" | "warn" | "error"; note?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }[]; chart?: { kind?: "none"; } | { kind?: "spec"; spec?: { kind?: "bar" | "line"; title?: string; categories?: string[]; series?: { values?: number[]; name?: string; }[]; }; }; }>
```

### NeedsInputCardInputSchema

```ts
const NeedsInputCardInputSchema: z.ZodObject<{ template: z.ZodLiteral<"needs-input">; agentName: z.ZodString; question: z.ZodString; options: z.ZodArray<z.ZodObject<{ label: z.ZodString; hint: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind?: "none"; }, { kind?: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"text">; value: z.ZodString; }, "strip", z.ZodTypeAny, { kind?: "text"; value?: string; }, { kind?: "text"; value?: string; }>]>; }, "strip", z.ZodTypeAny, { label?: string; hint?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }, { label?: string; hint?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }>, "many">; timestampIso: z.ZodString; }, "strip", z.ZodTypeAny, { options?: { label?: string; hint?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }[]; template?: "needs-input"; agentName?: string; timestampIso?: string; question?: string; }, { options?: { label?: string; hint?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }[]; template?: "needs-input"; agentName?: string; timestampIso?: string; question?: string; }>
```

### NeedsInputOptionSchema

```ts
const NeedsInputOptionSchema: z.ZodObject<{ label: z.ZodString; hint: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind?: "none"; }, { kind?: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"text">; value: z.ZodString; }, "strip", z.ZodTypeAny, { kind?: "text"; value?: string; }, { kind?: "text"; value?: string; }>]>; }, "strip", z.ZodTypeAny, { label?: string; hint?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }, { label?: string; hint?: { kind?: "none"; } | { kind?: "text"; value?: string; }; }>
```

### NetworkUsageSchema

```ts
const NetworkUsageSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"offline">; }, "strip", z.ZodTypeAny, { kind?: "offline"; }, { kind?: "offline"; }>, z.ZodObject<{ kind: z.ZodLiteral<"emoji-font-fetch">; codepoints: z.ZodArray<z.ZodString, "many">; }, "strip", z.ZodTypeAny, { kind?: "emoji-font-fetch"; codepoints?: string[]; }, { kind?: "emoji-font-fetch"; codepoints?: string[]; }>]>
```

### RendererBackendSchema

```ts
const RendererBackendSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"takumi">; }, "strip", z.ZodTypeAny, { kind?: "takumi"; }, { kind?: "takumi"; }>, z.ZodObject<{ kind: z.ZodLiteral<"satori-sharp">; reason: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"native-module-load-failed">; platform: z.ZodString; arch: z.ZodString; }, "strip", z.ZodTypeAny, { kind?: "native-module-load-failed"; platform?: string; arch?: string; }, { kind?: "native-module-load-failed"; platform?: string; arch?: string; }>, z.ZodObject<{ kind: z.ZodLiteral<"forced-fallback">; }, "strip", z.ZodTypeAny, { kind?: "forced-fallback"; }, { kind?: "forced-fallback"; }>]>; }, "strip", z.ZodTypeAny, { kind?: "satori-sharp"; reason?: { kind?: "native-module-load-failed"; platform?: string; arch?: string; } | { kind?: "forced-fallback"; }; }, { kind?: "satori-sharp"; reason?: { kind?: "native-module-load-failed"; platform?: string; arch?: string; } | { kind?: "forced-fallback"; }; }>]>
```

### RendererFallbackReasonSchema

```ts
const RendererFallbackReasonSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"native-module-load-failed">; platform: z.ZodString; arch: z.ZodString; }, "strip", z.ZodTypeAny, { kind?: "native-module-load-failed"; platform?: string; arch?: string; }, { kind?: "native-module-load-failed"; platform?: string; arch?: string; }>, z.ZodObject<{ kind: z.ZodLiteral<"forced-fallback">; }, "strip", z.ZodTypeAny, { kind?: "forced-fallback"; }, { kind?: "forced-fallback"; }>]>
```

### RenderFailureSchema

```ts
const RenderFailureSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"invalid-template-input">; issues: z.ZodArray<z.ZodString, "many">; }, "strip", z.ZodTypeAny, { kind?: "invalid-template-input"; issues?: string[]; }, { kind?: "invalid-template-input"; issues?: string[]; }>, z.ZodObject<{ kind: z.ZodLiteral<"renderer-unavailable">; attempted: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"takumi">; }, "strip", z.ZodTypeAny, { kind?: "takumi"; }, { kind?: "takumi"; }>, z.ZodObject<{ kind: z.ZodLiteral<"satori-sharp">; reason: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"native-module-load-failed">; platform: z.ZodString; arch: z.ZodString; }, "strip", z.ZodTypeAny, { kind?: "native-module-load-failed"; platform?: string; arch?: string; }, { kind?: "native-module-load-failed"; platform?: string; arch?: string; }>, z.ZodObject<{ kind: z.ZodLiteral<"forced-fallback">; }, "strip", z.ZodTypeAny, { kind?: "forced-fallback"; }, { kind?: "forced-fallback"; }>]>; }, "strip", z.ZodTypeAny, { kind?: "satori-sharp"; reason?: { kind?: "native-module-load-failed"; platform?: string; arch?: string; } | { kind?: "forced-fallback"; }; }, { kind?: "satori-sharp"; reason?: { kind?: "native-module-load-failed"; platform?: string; arch?: string; } | { kind?: "forced-fallback"; }; }>]>, "many">; }, "strip", z.ZodTypeAny, { kind?: "renderer-unavailable"; attempted?: ({ kind?: "takumi"; } | { kind?: "satori-sharp"; reason?: { kind?: "native-module-load-failed"; platform?: string; arch?: string; } | { kind?: "forced-fallback"; }; })[]; }, { kind?: "renderer-unavailable"; attempted?: ({ kind?: "takumi"; } | { kind?: "satori-sharp"; reason?: { kind?: "native-module-load-failed"; platform?: string; arch?: string; } | { kind?: "forced-fallback"; }; })[]; }>, z.ZodObject<{ kind: z.ZodLiteral<"rasterize-failed">; message: z.ZodString; }, "strip", z.ZodTypeAny, { kind?: "rasterize-failed"; message?: string; }, { kind?: "rasterize-failed"; message?: string; }>, z.ZodObject<{ kind: z.ZodLiteral<"chart-spec-invalid">; issues: z.ZodArray<z.ZodString, "many">; }, "strip", z.ZodTypeAny, { kind?: "chart-spec-invalid"; issues?: string[]; }, { kind?: "chart-spec-invalid"; issues?: string[]; }>]>
```

### RenderMetaSchema

```ts
const RenderMetaSchema: z.ZodObject<{ backend: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"takumi">; }, "strip", z.ZodTypeAny, { kind?: "takumi"; }, { kind?: "takumi"; }>, z.ZodObject<{ kind: z.ZodLiteral<"satori-sharp">; reason: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"native-module-load-failed">; platform: z.ZodString; arch: z.ZodString; }, "strip", z.ZodTypeAny, { kind?: "native-module-load-failed"; platform?: string; arch?: string; }, { kind?: "native-module-load-failed"; platform?: string; arch?: string; }>, z.ZodObject<{ kind: z.ZodLiteral<"forced-fallback">; }, "strip", z.ZodTypeAny, { kind?: "forced-fallback"; }, { kind?: "forced-fallback"; }>]>; }, "strip", z.ZodTypeAny, { kind?: "satori-sharp"; reason?: { kind?: "native-module-load-failed"; platform?: string; arch?: string; } | { kind?: "forced-fallback"; }; }, { kind?: "satori-sharp"; reason?: { kind?: "native-module-load-failed"; platform?: string; arch?: string; } | { kind?: "forced-fallback"; }; }>]>; contentHash: z.ZodBranded<z.ZodString, "ContentHash">; network: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"offline">; }, "strip", z.ZodTypeAny, { kind?: "offline"; }, { kind?: "offline"; }>, z.ZodObject<{ kind: z.ZodLiteral<"emoji-font-fetch">; codepoints: z.ZodArray<z.ZodString, "many">; }, "strip", z.ZodTypeAny, { kind?: "emoji-font-fetch"; codepoints?: string[]; }, { kind?: "emoji-font-fetch"; codepoints?: string[]; }>]>; renderMs: z.ZodNumber; widthPx: z.ZodNumber; heightPx: z.ZodNumber; }, "strip", z.ZodTypeAny, { contentHash?: string & z.BRAND<"ContentHash">; backend?: { kind?: "takumi"; } | { kind?: "satori-sharp"; reason?: { kind?: "native-module-load-failed"; platform?: string; arch?: string; } | { kind?: "forced-fallback"; }; }; network?: { kind?: "offline"; } | { kind?: "emoji-font-fetch"; codepoints?: string[]; }; renderMs?: number; widthPx?: number; heightPx?: number; }, { contentHash?: string; backend?: { kind?: "takumi"; } | { kind?: "satori-sharp"; reason?: { kind?: "native-module-load-failed"; platform?: string; arch?: string; } | { kind?: "forced-fallback"; }; }; network?: { kind?: "offline"; } | { kind?: "emoji-font-fetch"; codepoints?: string[]; }; renderMs?: number; widthPx?: number; heightPx?: number; }>
```

### StatusCardInputSchema

```ts
const StatusCardInputSchema: z.ZodObject<{ template: z.ZodLiteral<"status">; agentName: z.ZodString; level: z.ZodEnum<["ok", "warn", "error"]>; headline: z.ZodString; detail: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind?: "none"; }, { kind?: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"text">; value: z.ZodString; }, "strip", z.ZodTypeAny, { kind?: "text"; value?: string; }, { kind?: "text"; value?: string; }>]>; timestampIso: z.ZodString; }, "strip", z.ZodTypeAny, { template?: "status"; agentName?: string; level?: "ok" | "warn" | "error"; headline?: string; detail?: { kind?: "none"; } | { kind?: "text"; value?: string; }; timestampIso?: string; }, { template?: "status"; agentName?: string; level?: "ok" | "warn" | "error"; headline?: string; detail?: { kind?: "none"; } | { kind?: "text"; value?: string; }; timestampIso?: string; }>
```

### StatusLevelSchema

```ts
const StatusLevelSchema: z.ZodEnum<["ok", "warn", "error"]>
```

### TelegramFileIdSchema

```ts
const TelegramFileIdSchema: z.ZodBranded<z.ZodString, "TelegramFileId">
```