@514sid/signagekit 0.0.0-stage → 0.0.1

package/dist/types/cycle-fit.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Sizes a cycle to its longest message, so the size never jumps between
+ * messages. One line suits a banner; a tall, narrow zone wraps instead,
+ * whichever lets the text be larger.
+ */
+export declare function fitMessages(el: HTMLElement, messages: string[]): void;

package/dist/types/data.d.ts

@@ -0,0 +1,19 @@
+import type { Data, Value } from './types';
+/** Reads "/menu/0/price" from the data. Missing paths give undefined. */
+export declare function getPath(data: unknown, path: string): unknown;
+export declare function isBind(v: unknown): v is {
+    bind: string;
+    fallback?: string | number;
+};
+/**
+ * Resolves a value to display text. A bind that is missing or empty in the
+ * data shows its `fallback`; without one it resolves to "" and the component
+ * shows its own empty state.
+ */
+export declare function text(v: Value | undefined, data: Data): string;
+/** Resolves a value that should be a list, literal or bound. */
+export declare function items<T>(v: T[] | {
+    bind: string;
+}, data: Data): unknown[];
+/** Deep merge: objects merge key by key, arrays and values are replaced. */
+export declare function merge(base: unknown, over: unknown): unknown;

package/dist/types/empty.d.ts

@@ -0,0 +1,6 @@
+/** Stands in for a missing single value: a stat, a meter, a table cell. */
+export declare const DASH = "\u2014";
+/** Shown instead of an empty list, table, chart or image. */
+export declare function Empty({ text }: {
+    text?: string;
+}): import("preact").JSX.Element;

package/dist/types/fit.d.ts

@@ -0,0 +1,3 @@
+import { fitMessages } from './cycle-fit';
+export { fitMessages };
+export declare function fitAll(root: ParentNode): void;

package/dist/types/flow.d.ts

@@ -0,0 +1,7 @@
+import type { FlowLayout, GridLayout, Layout } from './types';
+export declare const COLUMNS = 12;
+/** Reference canvas: 1080 px on the short side, the long side follows the screen. */
+export declare function canvasSize(viewW: number, viewH: number): [number, number];
+export declare const isFlow: (l: Layout) => l is FlowLayout;
+export declare function flowGrid(l: FlowLayout, width: number): GridLayout;
+export declare function toGrid(l: Layout, width: number): GridLayout;

package/dist/types/icon-paths.d.ts

@@ -0,0 +1,2 @@
+import type { IconName } from './icons';
+export declare const ICONS: Record<IconName, string>;

package/dist/types/icon.d.ts

@@ -0,0 +1,7 @@
+import type { IconName } from './icons';
+export declare function loadIcons(): Promise<Record<string, string>>;
+/** A named icon from the set in icons.ts, drawn in the current text color. */
+export declare function Icon({ name, cls }: {
+    name: IconName;
+    cls?: string;
+}): import("preact").JSX.Element;

package/dist/types/icons.d.ts

@@ -0,0 +1,3 @@
+export declare const ICON_NAMES: readonly ["info", "check", "warning", "danger", "fire", "evacuate", "assembly", "medical", "first-aid", "storm", "wind", "snow", "flood", "heat", "lockdown", "shelter", "security", "power", "water", "network", "closed", "delay", "maintenance", "announcement", "phone", "biohazard", "radiation", "chemical", "event", "location", "accessibility"];
+export type IconName = (typeof ICON_NAMES)[number];
+export declare const isIcon: (v: unknown) => v is IconName;

package/dist/types/index.d.ts

@@ -0,0 +1,20 @@
+import './style.css';
+export { mount } from './mount';
+export type { MountOptions, ScreenHandle, Update } from './mount';
+export { check } from './check';
+export type { CheckOptions, CheckResult, Source } from './check';
+export { validate } from './validate';
+export type { Result as ValidateResult } from './validate';
+export { canvasSize } from './flow';
+export { COLOR_KEYS, SCHEMES } from './colors';
+export type { ColorKey, Colors, Palette, Scheme } from './colors';
+export { ICON_NAMES } from './icons';
+export type { IconName } from './icons';
+export { LEVELS } from './alert';
+export type { Level } from './alert';
+export type * from './types';
+export { pack, previewUrl, unpack, PREVIEW_BASE } from './share';
+export type { PreviewOptions, Shared } from './share';
+export { FORMAT } from './version';
+export { DEFAULT_SIZES, parseSize, SIZES } from './sizes';
+export type { Size } from './sizes';

package/dist/types/lists.d.ts

@@ -0,0 +1,28 @@
+import type { Clocks, Data, Queue, Schedule, Status } from './types';
+export declare function StatusView({ c, data }: {
+    c: Status;
+    data: Data;
+}): import("preact").JSX.Element;
+export interface Entry {
+    start: string;
+    title: string;
+    detail: string;
+    tag: 'now' | 'next' | '';
+}
+/**
+ * Entries from the current one onward. An entry ends at its `end`, else when
+ * the next one starts, else an hour after it starts.
+ */
+export declare function upcoming(raw: unknown[], data: Data, now: Date, limit: number): Entry[];
+export declare function ScheduleView({ c, data }: {
+    c: Schedule;
+    data: Data;
+}): import("preact").JSX.Element;
+export declare function QueueView({ c, data }: {
+    c: Queue;
+    data: Data;
+}): import("preact").JSX.Element;
+export declare function ClocksView({ c, data }: {
+    c: Clocks;
+    data: Data;
+}): import("preact").JSX.Element;

package/dist/types/measure.d.ts

@@ -0,0 +1,4 @@
+/** Font size, in px, that components are measured at before scaling. */
+export declare const PROBE = 100;
+/** The box a component fills: its parent, without padding. */
+export declare function contentBox(box: HTMLElement): [number, number];

package/dist/types/measures.d.ts

@@ -0,0 +1,22 @@
+import type { Bars, Data, Meter, Meters, Split } from './types';
+export declare function MeterView({ c, data }: {
+    c: Meter;
+    data: Data;
+}): import("preact").JSX.Element;
+export declare function MetersView({ c, data }: {
+    c: Meters;
+    data: Data;
+}): import("preact").JSX.Element;
+/** Ranked bars, largest first, all against the largest value. */
+export declare function BarsView({ c, data }: {
+    c: Bars;
+    data: Data;
+}): import("preact").JSX.Element;
+/**
+ * One whole split into parts. Each block prints its share when it is wide
+ * enough; the legend repeats name and share, so no value is lost.
+ */
+export declare function SplitView({ c, data }: {
+    c: Split;
+    data: Data;
+}): import("preact").JSX.Element;

package/dist/types/media.d.ts

@@ -0,0 +1,15 @@
+import type { Data, Qr, Slideshow } from './types';
+/** Swaps images instantly on a timer and preloads the next one. */
+export declare function SlideshowView({ c, data }: {
+    c: Slideshow;
+    data: Data;
+}): import("preact").JSX.Element;
+/**
+ * One SVG path for all dark modules, with a four-module quiet zone. Always
+ * black on white: many phone scanners fail on inverted codes.
+ */
+export declare function qrPath(grid: boolean[][]): string;
+export declare function QrView({ c, data }: {
+    c: Qr;
+    data: Data;
+}): import("preact").JSX.Element;

package/dist/types/mount.d.ts

@@ -0,0 +1,45 @@
+import { type Source } from './check';
+import { type Colors, type Scheme } from './colors';
+export interface MountOptions {
+    /** The screen document: JSON or YAML text, or a parsed object. */
+    layout: Source;
+    /** Values that binds read: JSON or YAML text, or an object. */
+    data?: Source;
+    /** Scheme used when the document doesn't set one. Default dark. */
+    scheme?: Scheme;
+    /** Accent used when the document doesn't set one. Default #2563eb. */
+    accent?: string;
+    /**
+     * Colors that win over the document's own, like `{ scheme: 'light' }` to
+     * see a screen in the other scheme.
+     */
+    colors?: Colors;
+    /** IANA time zone for clocks and schedules. Default the device's. */
+    timeZone?: string;
+    /** BCP 47 locale for dates and times. Default the device's. */
+    locale?: string;
+    /** Show errors and warnings over the screen. Default false. */
+    showProblems?: boolean;
+    /** Freezes the clock at this time, for screenshots and tests. */
+    now?: Date;
+}
+export interface Update {
+    layout?: Source;
+    data?: Source;
+}
+export interface ScreenHandle {
+    /** Errors from the last check, plus any reported with report(). */
+    readonly errors: string[];
+    readonly warnings: string[];
+    /** Replaces the layout, the data or both, and renders again. */
+    update(changes: Update): Promise<void>;
+    /** Adds an error, shown over the screen when showProblems is on. */
+    report(message: string): void;
+    /** Stops watching the element's size and removes the screen. */
+    destroy(): void;
+}
+/**
+ * Renders a screen document into `container` and resolves once it is drawn,
+ * charts included. The container sets the size; the screen fills it.
+ */
+export declare function mount(container: HTMLElement, options: MountOptions): Promise<ScreenHandle>;

package/dist/types/parse.d.ts

@@ -0,0 +1,11 @@
+export interface Parsed {
+    value: unknown;
+    error?: string;
+}
+/**
+ * `layout` uses the YAML core schema, so `fit: true` and `gap: 24` keep their
+ * types. `data` uses the failsafe schema, which reads every scalar as a
+ * string: a price written as 4.50 stays "4.50" instead of becoming 4.5.
+ */
+export type Mode = 'layout' | 'data';
+export declare function parseText(src: string, mode: Mode): Promise<Parsed>;

package/dist/types/qr-size.d.ts

@@ -0,0 +1,2 @@
+/** QR codes: the largest square that fits beside their caption. */
+export declare function sizeQr(root: ParentNode): void;

package/dist/types/ready.d.ts

@@ -0,0 +1,3 @@
+export declare function track(p: Promise<unknown>): void;
+/** Resolves when tracked work is done, or after `timeout` ms at the latest. */
+export declare function settled(timeout?: number): Promise<void>;

package/dist/types/share.d.ts

@@ -0,0 +1,33 @@
+export declare const PREVIEW_BASE = "https://signagekit.514sid.com/preview/";
+export interface PreviewOptions {
+    /** `screen` (default), `sizes`, `schemes` or `edit`. */
+    mode?: 'screen' | 'sizes' | 'schemes' | 'edit';
+    /**
+     * Resolution: a name like `fullhd` or `portrait`, or `WIDTHxHEIGHT`. One
+     * for `screen` and `schemes`, a list for `sizes`.
+     */
+    size?: string | string[];
+    scheme?: 'dark' | 'light';
+    accent?: string;
+    timeZone?: string;
+    locale?: string;
+    /** Show errors and warnings over the screen. */
+    problems?: boolean;
+    /** Freeze the clock at this ISO time, like 2026-11-14T09:30. */
+    now?: string;
+    /** Preview page to link to. Default the public site. */
+    base?: string;
+}
+export interface Shared {
+    layout: string;
+    data?: string;
+}
+/** Packs layout and data text into the `s` value of a preview link. */
+export declare function pack(shared: Shared): Promise<string>;
+/** Reverses pack(). Throws on a damaged value. */
+export declare function unpack(s: string): Promise<Shared>;
+/**
+ * A link to the preview page showing this layout and data. Pass the text as
+ * written, JSON or YAML, or objects, which are sent as JSON.
+ */
+export declare function previewUrl(layout: string | object, data?: string | object, options?: PreviewOptions): Promise<string>;

package/dist/types/sizes.d.ts

@@ -0,0 +1,15 @@
+export interface Size {
+    name: string;
+    width: number;
+    height: number;
+    label: string;
+}
+/** Every named resolution, keyed by name. */
+export declare const SIZES: Record<string, Size>;
+/** The sizes the preview compares when none are given. */
+export declare const DEFAULT_SIZES: string[];
+/**
+ * Reads `fullhd`, `1080p` or `1366x768` (also `1366×768`). Returns null for
+ * anything else, or for sizes under 64 or over 16384 px.
+ */
+export declare function parseSize(text: string): Size | null;

package/dist/types/specs.d.ts

@@ -0,0 +1,7 @@
+import { type Check } from './checks';
+import type { ComponentType } from './types';
+export interface Spec {
+    required: Record<string, Check>;
+    optional: Record<string, Check>;
+}
+export declare const SPECS: Record<ComponentType, Spec>;

package/dist/types/stat.d.ts

@@ -0,0 +1,38 @@
+import type { Component, Data, Stat as StatSpec, Thresholds, Value } from './types';
+type Props = {
+    c: StatSpec;
+    data: Data;
+};
+export declare const STATE_WORDS: Record<string, string>;
+/** good, warning or danger; anything else, unknown included, is neutral. */
+export declare function stateText(v: Value | undefined, data: Data): string;
+/**
+ * A state from thresholds: past danger is danger, past warning is warning,
+ * anything else neutral. With danger below warning, lower values are worse.
+ */
+export declare function thresholdState(n: number, t: Thresholds | undefined): string;
+/**
+ * The state that marks a whole zone. Only stats and meters set one: an
+ * explicit `state` wins, else `thresholds` decide from the value.
+ */
+export declare function stateOf(c: Component, data: Data): string;
+export declare function StateIcon({ state }: {
+    state: string;
+}): import("preact").JSX.Element;
+/**
+ * up, down or flat, or none. With good_when set, a move that way is good
+ * (green) and the opposite is bad (red); without it the arrow stays neutral,
+ * since a rising number is not always good news.
+ */
+export declare function trendOf(c: StatSpec, data: Data): {
+    dir: string;
+    tone: string;
+} | null;
+/**
+ * Numbers of 10,000 and up are shortened (1M, 12.9K) unless format is full,
+ * so a big value doesn't shrink every stat in its row. Smaller numbers get
+ * thousands separators; text that isn't a number is shown as written.
+ */
+export declare function formatValue(raw: string, format?: 'compact' | 'full'): string;
+export declare function Stat({ c, data }: Props): import("preact").JSX.Element;
+export {};

package/dist/types/table-fit.d.ts

@@ -0,0 +1,8 @@
+export declare function tableOverflow(el: HTMLElement): void;
+/**
+ * Shows every row a table could show at once, all of them or the first
+ * page_rows, and hides its pager, so fitting and paging measure the same
+ * content on every pass. Returns a function that hands rows back to the
+ * table's own paging.
+ */
+export declare function showAllRows(root: ParentNode): () => void;

package/dist/types/table.d.ts

@@ -0,0 +1,11 @@
+import type { Data, Table as TableSpec } from './types';
+/**
+ * A table that sizes its text to fit. Rows that don't fit at a readable size
+ * are shown a page at a time, flipping instantly; page_rows caps the page
+ * size by hand. Rows off the page are collapsed, not removed, so column widths
+ * stay the same on every page and nothing jumps.
+ */
+export declare function Table({ c, data }: {
+    c: TableSpec;
+    data: Data;
+}): import("preact").JSX.Element;

package/dist/types/time.d.ts

@@ -0,0 +1,15 @@
+type Listener = (now: Date) => void;
+export declare function setFixedTime(d: Date | undefined): void;
+export declare const currentTime: () => Date;
+export declare function onMinute(fn: Listener): () => void;
+export declare function useMinute(): Date;
+export declare function setTimeContext(tz: string | undefined, loc: string | undefined): void;
+/** The time in another zone, for world clocks. */
+export declare function formatClockIn(now: Date, zone: string, hour12: boolean | undefined): string;
+/** Minutes since midnight on the screen's clock, for "HH:MM" schedules. */
+export declare function minutesOfDay(now: Date): number;
+export declare function formatClock(now: Date, hour12: boolean | undefined): string;
+export declare function formatDate(now: Date): string;
+/** "3 d 4 h", "4 h 12 min", "12 min", or "" once the time has passed. */
+export declare function formatCountdown(to: Date, now: Date): string;
+export {};

package/dist/types/trend-fit.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Fits a stat in each arrangement it can take, using `fitLine`, which returns
+ * the size the element fits at as it stands, or less than `floor` by how far
+ * it is from fitting at all. Leaves the best one in place
+ * and remembers every size for the row pass. Returns false when there is
+ * nothing to choose, so the caller fits the stat normally.
+ */
+export declare function fitTrend(el: HTMLElement, fitLine: () => number, floor: number): boolean;
+/**
+ * Picks one arrangement for a row of figures: the one whose smallest size is
+ * largest. A stat that can't take an arrangement keeps its own nearest one.
+ * Returns the size the row shares.
+ */
+export declare function alignTrends(group: HTMLElement[], sizeOf: (el: HTMLElement) => number, floor?: number): number;

package/dist/types/type-scale.d.ts

@@ -0,0 +1,10 @@
+export declare const RANGES: Record<string, [number, number]>;
+/** The type scale every fitted size snaps down to. */
+export declare const STEPS: number[];
+/** Components made of rows; they share one body size across the screen. */
+export declare const BODY: string[];
+/** Display text kept within this many times the body size. */
+export declare const DISPLAY: string[];
+export declare const DISPLAY_RATIO = 3.5;
+/** List-like components may grow this much past the shared body size. */
+export declare const BODY_SPREAD = 1.4;

package/dist/types/types.d.ts

@@ -0,0 +1,271 @@
+import type { Colors } from './colors';
+/** A literal, or a pointer into the data, like { "bind": "/menu/0/price" }. */
+export type Bind = {
+    bind: string;
+    /** Shown when the path is missing or empty in the data. */
+    fallback?: string | number;
+};
+export type Value = string | number | Bind;
+export type Surface = 'base' | 'raised' | 'accent';
+export type Align = 'start' | 'center' | 'end';
+export type TextSize = 's' | 'm' | 'l' | 'xl';
+interface Base {
+    surface?: Surface;
+    /** Short label shown above the component, like "Menu" or "Wait time". */
+    title?: Value;
+    /** Pins the text size in px on the reference canvas, skipping fitting. */
+    size?: number | TextSize;
+    /** Share of a stack's space, relative to its siblings. Default 1. */
+    weight?: number;
+    /** A named icon shown before the title, in place of the square marker. */
+    icon?: string;
+}
+export interface Heading extends Base {
+    type: 'heading';
+    text: Value;
+    align?: Align;
+}
+export interface Text extends Base {
+    type: 'text';
+    text: Value;
+    size?: TextSize;
+    align?: Align;
+    fit?: boolean;
+}
+export type State = 'neutral' | 'good' | 'warning' | 'danger';
+/**
+ * Sets the state from the value, so data only has to carry numbers. With
+ * danger above warning, higher is worse; with danger below, lower is worse.
+ */
+export interface Thresholds {
+    warning?: number;
+    danger?: number;
+}
+export interface Stat extends Base {
+    type: 'stat';
+    value: Value;
+    label?: Value;
+    unit?: Value;
+    /** Bound or literal; anything but good, warning or danger is neutral. */
+    state?: Value;
+    /** up, down or flat; bound or literal. Anything else shows no arrow. */
+    trend?: Value;
+    /** Change shown next to the arrow, like "+4.2%". */
+    delta?: Value;
+    /** Which direction is good news; colors the arrow green or red. */
+    good_when?: 'up' | 'down';
+    /** compact (default) shortens numbers from 10,000 up; full never does. */
+    format?: 'compact' | 'full';
+    /** false keeps this stat's own size instead of matching its row. */
+    match_row?: boolean;
+    /** Recent values drawn as a sparkline under the number. */
+    spark?: Value[] | Bind;
+    thresholds?: Thresholds;
+}
+export interface Table extends Base {
+    type: 'table';
+    columns: string[];
+    rows: Value[][] | Bind;
+    align?: Align[];
+    /** Rows per page; pages flip instantly every `seconds`. */
+    page_rows?: number;
+    /** Relative column widths, like [3, 1, 1]. Long cells end in an ellipsis. */
+    widths?: number[];
+    seconds?: number;
+}
+export interface List extends Base {
+    type: 'list';
+    items: Value[] | Bind;
+}
+export interface Image extends Base {
+    type: 'image';
+    src: Value;
+    fit?: 'cover' | 'contain';
+    alt?: string;
+}
+export interface Clock extends Base {
+    type: 'clock';
+    hour12?: boolean;
+    show_date?: boolean;
+}
+export interface Countdown extends Base {
+    type: 'countdown';
+    to: Value;
+    label?: Value;
+    /** Shown once the time has passed. Default "Now". */
+    done?: Value;
+}
+export interface ChartSeries {
+    name: Value;
+    values: Value[] | Bind;
+}
+/** Line, area or column chart, drawn by uPlot. */
+export interface Chart extends Base {
+    type: 'chart';
+    kind: 'line' | 'area' | 'column';
+    labels: Value[] | Bind;
+    series: ChartSeries[];
+    /** A horizontal target line, like an SLO or a production goal. */
+    target?: Value;
+    target_label?: Value;
+    /** Fixed y-axis range; either end can be left out. */
+    y_min?: number;
+    y_max?: number;
+}
+/** Shows one message at a time and swaps to the next instantly. */
+export interface Cycle extends Base {
+    type: 'cycle';
+    items: Value[] | Bind;
+    seconds?: number;
+    align?: Align;
+}
+export interface Stack extends Base {
+    type: 'stack';
+    direction?: 'row' | 'column';
+    items: Component[];
+}
+export type Component = Heading | Text | Stat | Table | List | Image | Clock | Countdown | Cycle | Chart | Stack | Meter | Meters | Bars | Split | Status | Schedule | Queue | Clocks | Slideshow | Qr;
+/** A labelled amount, used by meters, bars and split. */
+export interface Part {
+    label: Value;
+    value: Value;
+    max?: Value;
+    state?: Value;
+}
+export type Parts = Part[] | Bind;
+/** One value against a limit. */
+export interface Meter extends Base {
+    type: 'meter';
+    value: Value;
+    max?: Value;
+    label?: Value;
+    unit?: Value;
+    state?: Value;
+    thresholds?: Thresholds;
+}
+/** Several meters, one row each, bars aligned. */
+export interface Meters extends Base {
+    type: 'meters';
+    items: Parts;
+    max?: Value;
+    unit?: Value;
+    /** Applied to each row without its own state. */
+    thresholds?: Thresholds;
+}
+/** Ranked horizontal bars, largest first. */
+export interface Bars extends Base {
+    type: 'bars';
+    items: Parts;
+    unit?: Value;
+    limit?: number;
+}
+/** One whole split into up to six parts. */
+export interface Split extends Base {
+    type: 'split';
+    items: Parts;
+}
+/** Rows with a state icon each, like service health. */
+export interface Status extends Base {
+    type: 'status';
+    items: {
+        label: Value;
+        state: Value;
+        note?: Value;
+    }[] | Bind;
+}
+/** Time-ordered entries; the current and next ones are marked. */
+export interface Schedule extends Base {
+    type: 'schedule';
+    items: {
+        start: Value;
+        end?: Value;
+        title: Value;
+        detail?: Value;
+    }[] | Bind;
+    rows?: number;
+}
+/** "Now serving" number with the recently called ones. */
+export interface Queue extends Base {
+    type: 'queue';
+    current: Value;
+    recent?: Value[] | Bind;
+    label?: Value;
+}
+/** Several clocks, one per time zone. */
+export interface Clocks extends Base {
+    type: 'clocks';
+    /** `zone` is the older name for `timezone` and still works. */
+    zones: {
+        label: Value;
+        timezone?: string;
+        zone?: string;
+    }[];
+    hour12?: boolean;
+}
+/** Images that swap instantly on a timer. */
+export interface Slideshow extends Base {
+    type: 'slideshow';
+    images: Value[] | Bind;
+    seconds?: number;
+    fit?: 'cover' | 'contain';
+}
+/** QR code, black on white for scanners, with an optional caption. */
+export interface Qr extends Base {
+    type: 'qr';
+    value: Value;
+    label?: Value;
+}
+export type ComponentType = Component['type'];
+/** A fixed grid: named areas, like CSS grid-template-areas. */
+export interface GridLayout {
+    areas: string[];
+    columns?: string;
+    rows?: string;
+    gap?: number;
+}
+/** One zone in a flow layout. */
+export interface FlowItem {
+    zone: string;
+    /** Columns out of 12 in the design orientation. Default 12. */
+    span?: number;
+    /** A number is a share of the free height (like fr); "150px" is fixed. */
+    height?: number | string;
+}
+/** Zones in reading order, packed into rows to suit the screen's shape. */
+export interface FlowLayout {
+    flow: (string | FlowItem)[];
+    design?: 'landscape' | 'portrait';
+    gap?: number;
+}
+export type Layout = GridLayout | FlowLayout;
+/**
+ * A screen-wide message: full screen (takeover) or a strip across the top
+ * (banner). It shows while its title or message is set and until `until`.
+ * The whole alert can also be a bind to an object in the data.
+ */
+export interface AlertFields {
+    level?: 'info' | 'good' | 'warning' | 'danger' | Bind;
+    icon?: string | Bind;
+    title?: Value;
+    message?: Value;
+    /** Older name for `message`. */
+    text?: Value;
+    steps?: Value[] | Bind;
+    footer?: Value;
+    mode?: 'takeover' | 'banner';
+    /** ISO date and time after which the alert no longer shows. */
+    until?: Value;
+    /** Older name for `level`. */
+    state?: 'warning' | 'danger';
+}
+export type Alert = AlertFields | Bind;
+export interface ScreenDoc {
+    /** Format version, default 1. See src/version.ts. */
+    version?: number;
+    colors?: Colors;
+    alert?: Alert;
+    layout: Layout;
+    zones: Record<string, Component>;
+}
+export type Data = Record<string, unknown>;
+export {};