@veil-runtime/ui 0.0.0-stage → 0.3.0

package/dist/format-semantic-value.js

@@ -0,0 +1,15 @@
+export function formatSemanticValue(value, field) {
+    if (field?.semantic === "currency" && typeof value === "number" && field.currency) {
+        return new Intl.NumberFormat(undefined, {
+            style: "currency",
+            currency: field.currency,
+        }).format(value);
+    }
+    if (field?.semantic === "count" && typeof value === "number") {
+        return new Intl.NumberFormat(undefined, { maximumFractionDigits: 0 }).format(value);
+    }
+    if (field?.semantic === "ratio" && typeof value === "number") {
+        return new Intl.NumberFormat(undefined, { style: "percent", maximumFractionDigits: 1 }).format(value);
+    }
+    return value;
+}

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+export * from "./input-schema.js";
+export * from "./output-schema.js";
+export * from "./application.js";
+export * from "./capability-view.js";
+export * from "./composed-surface.js";
+export * from "./workflow.js";
+export * from "./relationship-interpretation.js";
+export * from "./validate-application.js";
+export * from "./registry.js";
+export * from "./derive-input-fields.js";
+export * from "./derive-output-view.js";
+export * from "./capability-view-derivation.js";
+export * from "./interaction-resolution.js";
+export * from "./experience-orchestration.js";
+export * from "./presentation-context.js";
+export * from "./presentation-composition.js";
+export * from "./execution-request.js";
+export * from "./format-semantic-value.js";
+export * from "./composition.js";
+export * from "./interface.js";

package/dist/index.js

@@ -0,0 +1,20 @@
+export * from "./input-schema.js";
+export * from "./output-schema.js";
+export * from "./application.js";
+export * from "./capability-view.js";
+export * from "./composed-surface.js";
+export * from "./workflow.js";
+export * from "./relationship-interpretation.js";
+export * from "./validate-application.js";
+export * from "./registry.js";
+export * from "./derive-input-fields.js";
+export * from "./derive-output-view.js";
+export * from "./capability-view-derivation.js";
+export * from "./interaction-resolution.js";
+export * from "./experience-orchestration.js";
+export * from "./presentation-context.js";
+export * from "./presentation-composition.js";
+export * from "./execution-request.js";
+export * from "./format-semantic-value.js";
+export * from "./composition.js";
+export * from "./interface.js";

package/dist/input-schema.d.ts

@@ -0,0 +1,25 @@
+export type RichStringFormat = "date" | "date-time" | "multiline";
+/** The shared field shape is structural so composition needs no Core installation. */
+export interface RichCapabilityInputField {
+    type: "string" | "number" | "integer" | "boolean" | "object" | "array";
+    required: boolean;
+    description: string;
+    enum?: Array<string | number | boolean>;
+    format?: RichStringFormat;
+    semantic?: "currency";
+    currency?: string;
+    fields?: RichCapabilityInputSchema;
+    items?: RichCapabilityInputField;
+    minLength?: number;
+    maxLength?: number;
+    minimum?: number;
+    maximum?: number;
+    minItems?: number;
+    maxItems?: number;
+}
+export type RichCapabilityInputSchema = Record<string, RichCapabilityInputField>;
+export declare function defineInputSchema<T extends RichCapabilityInputSchema>(schema: T): T;
+export declare function validateRichInputField(field: RichCapabilityInputField, path: string): void;
+export declare function validateRichInputSchema(schema: RichCapabilityInputSchema): void;
+export declare function validateRichInputValue(value: unknown, field: RichCapabilityInputField, path: string): void;
+export declare function validateRichCapabilityInput(schema: RichCapabilityInputSchema, input: unknown): asserts input is Record<string, unknown>;

package/dist/input-schema.js

@@ -0,0 +1,131 @@
+import { assertBoundedData, isCalendarDate, isUTCInstant } from "./validation-safety.js";
+export function defineInputSchema(schema) {
+    return schema;
+}
+function assertConstraintPair(minimum, maximum, path) {
+    if (minimum !== undefined && maximum !== undefined && minimum > maximum) {
+        throw new Error(`Invalid input schema at "${path}": minimum exceeds maximum`);
+    }
+}
+export function validateRichInputField(field, path) {
+    assertBoundedData(field);
+    const supported = ["string", "number", "integer", "boolean", "object", "array"];
+    if (!supported.includes(field.type)) {
+        throw new Error(`Unsupported input type "${field.type}" at "${path}"`);
+    }
+    if (field.enum) {
+        if (field.enum.length === 0)
+            throw new Error(`Empty enum at "${path}"`);
+        const primitive = field.type === "integer" ? "number" : field.type;
+        if (field.enum.some((value) => typeof value !== primitive)) {
+            throw new Error(`Enum value is incompatible with "${field.type}" at "${path}"`);
+        }
+    }
+    if (field.format && field.type !== "string") {
+        throw new Error(`Format requires a string field at "${path}"`);
+    }
+    if (field.semantic === "currency") {
+        if (!["number", "integer"].includes(field.type) || !field.currency) {
+            throw new Error(`Currency semantics require a numeric type and currency code at "${path}"`);
+        }
+    }
+    assertConstraintPair(field.minLength, field.maxLength, path);
+    assertConstraintPair(field.minimum, field.maximum, path);
+    assertConstraintPair(field.minItems, field.maxItems, path);
+    if (field.type === "object") {
+        if (!field.fields)
+            throw new Error(`Object field lacks nested fields at "${path}"`);
+        for (const [name, nested] of Object.entries(field.fields)) {
+            validateRichInputField(nested, `${path}.${name}`);
+        }
+    }
+    if (field.type === "array") {
+        if (!field.items)
+            throw new Error(`Array field lacks an item schema at "${path}"`);
+        validateRichInputField(field.items, `${path}[]`);
+    }
+}
+export function validateRichInputSchema(schema) {
+    assertBoundedData(schema);
+    for (const [name, field] of Object.entries(schema)) {
+        validateRichInputField(field, name);
+    }
+}
+function missing(value) {
+    return value === undefined || value === null || value === "";
+}
+export function validateRichInputValue(value, field, path) {
+    assertBoundedData(value);
+    assertBoundedData(field);
+    if (missing(value)) {
+        if (field.required)
+            throw new Error(`Required input omitted: ${path}`);
+        return;
+    }
+    if (field.enum && !field.enum.includes(value))
+        throw new Error(`Input "${path}" is not an allowed enum value`);
+    if (field.type === "string") {
+        if (typeof value !== "string")
+            throw new Error(`Input "${path}" must be a string`);
+        if (field.minLength !== undefined && value.length < field.minLength)
+            throw new Error(`Input "${path}" is shorter than minLength`);
+        if (field.maxLength !== undefined && value.length > field.maxLength)
+            throw new Error(`Input "${path}" exceeds maxLength`);
+        if (field.format === "date" && !isCalendarDate(value))
+            throw new Error(`Input "${path}" must use YYYY-MM-DD`);
+        if (field.format === "date-time" && !isUTCInstant(value))
+            throw new Error(`Input "${path}" must be an ISO-8601 UTC instant`);
+        return;
+    }
+    if (field.type === "number" || field.type === "integer") {
+        if (typeof value !== "number" || !Number.isFinite(value))
+            throw new Error(`Input "${path}" must be numeric`);
+        if (field.type === "integer" && !Number.isInteger(value))
+            throw new Error(`Input "${path}" must be an integer`);
+        if (field.minimum !== undefined && value < field.minimum)
+            throw new Error(`Input "${path}" is below minimum`);
+        if (field.maximum !== undefined && value > field.maximum)
+            throw new Error(`Input "${path}" exceeds maximum`);
+        return;
+    }
+    if (field.type === "boolean") {
+        if (typeof value !== "boolean")
+            throw new Error(`Input "${path}" must be boolean`);
+        return;
+    }
+    if (field.type === "object") {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            throw new Error(`Input "${path}" must be an object`);
+        const record = value;
+        const fields = field.fields ?? {};
+        for (const key of Object.keys(record))
+            if (!Object.hasOwn(fields, key))
+                throw new Error(`Unexpected nested field: ${path}.${key}`);
+        for (const [key, child] of Object.entries(fields))
+            validateRichInputValue(Object.hasOwn(record, key) ? record[key] : undefined, child, `${path}.${key}`);
+        return;
+    }
+    if (field.type === "array") {
+        if (!Array.isArray(value))
+            throw new Error(`Input "${path}" must be an array`);
+        if (field.minItems !== undefined && value.length < field.minItems)
+            throw new Error(`Input "${path}" is below minItems`);
+        if (field.maxItems !== undefined && value.length > field.maxItems)
+            throw new Error(`Input "${path}" exceeds maxItems`);
+        if (!field.items)
+            throw new Error(`Input "${path}" lacks an item schema`);
+        value.forEach((item, index) => validateRichInputValue(item, field.items, `${path}[${index}]`));
+    }
+}
+export function validateRichCapabilityInput(schema, input) {
+    assertBoundedData(schema);
+    assertBoundedData(input);
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        throw new Error("Capability input must be an object");
+    const record = input;
+    for (const key of Object.keys(record))
+        if (!Object.hasOwn(schema, key))
+            throw new Error(`Unexpected supplied input: ${key}`);
+    for (const [key, field] of Object.entries(schema))
+        validateRichInputValue(Object.hasOwn(record, key) ? record[key] : undefined, field, key);
+}

package/dist/interaction-resolution.d.ts

@@ -0,0 +1,27 @@
+import type { CapabilityView, UIField } from "./capability-view.js";
+export interface AuthoritativeInputBinding {
+    sourceField: string;
+    value: unknown;
+}
+export type AuthoritativeInputBindings = Record<string, AuthoritativeInputBinding>;
+export type CapabilityInteractionMode = "form" | "action" | "confirmation" | "read";
+export interface ResolvedCapabilityInput {
+    name: string;
+    source: "human" | "binding";
+    value?: unknown;
+    sourceField?: string;
+    field: UIField;
+}
+export interface CapabilityInteractionResolution {
+    mode: CapabilityInteractionMode;
+    suppliedInputs: Record<string, unknown>;
+    boundInputNames: string[];
+    humanFields: UIField[];
+    inputs: ResolvedCapabilityInput[];
+    unresolvedRequiredInputs: string[];
+    reason: string;
+}
+export declare function serializeDateTimeLocal(value: string): string;
+export declare function validateFieldValue(value: unknown, field: UIField, path: string): void;
+export declare function resolveCapabilityInteraction(view: CapabilityView, bindings?: AuthoritativeInputBindings): CapabilityInteractionResolution;
+export declare function buildCapabilityExecutionPayload(resolution: CapabilityInteractionResolution, humanValues: Record<string, unknown>): Record<string, unknown>;

package/dist/interaction-resolution.js

@@ -0,0 +1,179 @@
+import { assertBoundedData, isCalendarDate, isUTCInstant } from "./validation-safety.js";
+function valueMatchesField(value, field) {
+    try {
+        validateFieldValue(value, field, field.name);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function serializeDateTimeLocal(value) {
+    return new Date(value).toISOString();
+}
+export function validateFieldValue(value, field, path) {
+    assertBoundedData(value);
+    assertBoundedData(field);
+    if (value === undefined || value === null || value === "") {
+        if (field.required)
+            throw new Error(`Required input omitted: ${path}`);
+        return;
+    }
+    if (field.options && !field.options.includes(value)) {
+        throw new Error(`Input "${path}" is not an allowed enum value`);
+    }
+    if (field.authoritativeType === "string") {
+        if (typeof value !== "string")
+            throw new Error(`Input "${path}" must be a string`);
+        if (field.minLength !== undefined && value.length < field.minLength)
+            throw new Error(`Input "${path}" is shorter than minLength`);
+        if (field.maxLength !== undefined && value.length > field.maxLength)
+            throw new Error(`Input "${path}" exceeds maxLength`);
+        if (field.format === "date" && !isCalendarDate(value))
+            throw new Error(`Input "${path}" must use YYYY-MM-DD`);
+        if (field.format === "date-time" && !isUTCInstant(value)) {
+            throw new Error(`Input "${path}" must be an ISO-8601 UTC instant`);
+        }
+        return;
+    }
+    if (field.authoritativeType === "number" || field.authoritativeType === "integer") {
+        if (typeof value !== "number" || !Number.isFinite(value))
+            throw new Error(`Input "${path}" must be numeric`);
+        if (field.authoritativeType === "integer" && !Number.isInteger(value))
+            throw new Error(`Input "${path}" must be an integer`);
+        if (field.minimum !== undefined && value < field.minimum)
+            throw new Error(`Input "${path}" is below minimum`);
+        if (field.maximum !== undefined && value > field.maximum)
+            throw new Error(`Input "${path}" exceeds maximum`);
+        return;
+    }
+    if (field.authoritativeType === "boolean") {
+        if (typeof value !== "boolean")
+            throw new Error(`Input "${path}" must be boolean`);
+        return;
+    }
+    if (field.authoritativeType === "object") {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            throw new Error(`Input "${path}" must be an object`);
+        const record = value;
+        const children = field.fields ?? [];
+        const names = new Set(children.map((child) => child.name));
+        for (const key of Object.keys(record))
+            if (!names.has(key))
+                throw new Error(`Unexpected nested field: ${path}.${key}`);
+        for (const child of children)
+            validateFieldValue(Object.hasOwn(record, child.name) ? record[child.name] : undefined, child, `${path}.${child.name}`);
+        return;
+    }
+    if (field.authoritativeType === "array") {
+        if (!Array.isArray(value))
+            throw new Error(`Input "${path}" must be an array`);
+        if (field.minItems !== undefined && value.length < field.minItems)
+            throw new Error(`Input "${path}" is below minItems`);
+        if (field.maxItems !== undefined && value.length > field.maxItems)
+            throw new Error(`Input "${path}" exceeds maxItems`);
+        if (!field.item)
+            throw new Error(`Input "${path}" lacks an item schema`);
+        value.forEach((item, index) => validateFieldValue(item, field.item, `${path}[${index}]`));
+    }
+}
+export function resolveCapabilityInteraction(view, bindings = {}) {
+    assertBoundedData(view);
+    assertBoundedData(bindings);
+    const fieldsByName = new Map(view.fields.map((field) => [field.name, field]));
+    const suppliedInputs = {};
+    const boundInputNames = Object.keys(bindings);
+    const inputs = [];
+    for (const [name, binding] of Object.entries(bindings)) {
+        const field = fieldsByName.get(name);
+        if (!field) {
+            throw new Error(`Authoritative binding references unknown input: ${name}`);
+        }
+        if (binding.value === undefined || binding.value === null || binding.value === "") {
+            if (field.required) {
+                throw new Error(`Required bound input "${name}" has no runtime value`);
+            }
+            inputs.push({
+                name, source: "binding", value: binding.value,
+                sourceField: binding.sourceField, field,
+            });
+            continue;
+        }
+        if (!valueMatchesField(binding.value, field)) {
+            throw new Error(`Bound input "${name}" does not match declared type "${field.type}"`);
+        }
+        suppliedInputs[name] = binding.value;
+        inputs.push({
+            name,
+            source: "binding",
+            value: binding.value,
+            sourceField: binding.sourceField,
+            field,
+        });
+    }
+    const boundNames = new Set(boundInputNames);
+    const humanFields = view.fields.filter((field) => !boundNames.has(field.name));
+    for (const field of humanFields) {
+        inputs.push({ name: field.name, source: "human", field });
+    }
+    const unresolvedRequiredInputs = humanFields
+        .filter((field) => field.required)
+        .map((field) => field.name);
+    const mode = humanFields.length > 0
+        ? "form"
+        : view.risk === "destructive"
+            ? "confirmation"
+            : view.risk === "read"
+                ? "read"
+                : "action";
+    if (mode === "confirmation" && !view.confirmation?.required) {
+        throw new Error("Destructive zero-input interaction is missing confirmation metadata");
+    }
+    const reason = humanFields.length > 0
+        ? `${humanFields.length} input${humanFields.length === 1 ? "" : "s"} remain for the human`
+        : mode === "confirmation"
+            ? 'all inputs are supplied and authoritative risk is "destructive"'
+            : mode === "read"
+                ? "all inputs are supplied and the capability is read-only"
+                : "all inputs are supplied and the capability is a write";
+    return {
+        mode,
+        suppliedInputs,
+        boundInputNames,
+        humanFields,
+        inputs,
+        unresolvedRequiredInputs,
+        reason,
+    };
+}
+export function buildCapabilityExecutionPayload(resolution, humanValues) {
+    assertBoundedData(resolution);
+    assertBoundedData(humanValues);
+    const humanNames = new Set(resolution.humanFields.map((field) => field.name));
+    const boundNames = new Set(resolution.boundInputNames);
+    for (const name of Object.keys(humanValues)) {
+        if (boundNames.has(name)) {
+            throw new Error(`Human input cannot overwrite authoritative bound input: ${name}`);
+        }
+        if (!humanNames.has(name)) {
+            throw new Error(`Unexpected supplied input: ${name}`);
+        }
+    }
+    const payload = {};
+    for (const field of resolution.humanFields) {
+        const value = Object.hasOwn(humanValues, field.name) ? humanValues[field.name] : undefined;
+        if (field.required && (value === undefined || value === null || value === "")) {
+            throw new Error(`Required human input omitted: ${field.name}`);
+        }
+        if (value !== undefined && value !== "") {
+            validateFieldValue(value, field, field.name);
+            payload[field.name] = value;
+        }
+    }
+    for (const name of resolution.unresolvedRequiredInputs) {
+        if (!Object.prototype.hasOwnProperty.call(payload, name)) {
+            throw new Error(`Resolved execution payload is missing required input: ${name}`);
+        }
+    }
+    return payload;
+}

package/dist/interface-transaction.d.ts

@@ -0,0 +1,9 @@
+/** Internal bridge between a neutral controller and any mounted renderers. */
+export interface PreparedInterfaceRender {
+    commit(): void;
+    discard(): void;
+}
+export type InterfaceRenderParticipant<T> = (candidate: T) => PreparedInterfaceRender;
+export declare function attachInterfaceRenderers<T>(controller: object, participants: Set<InterfaceRenderParticipant<T>>): void;
+export declare function detachInterfaceRenderers(controller: object): void;
+export declare function registerInterfaceRenderer<T>(controller: object, renderer: InterfaceRenderParticipant<T>): () => void;

package/dist/interface-transaction.js

@@ -0,0 +1,14 @@
+const renderers = new WeakMap();
+export function attachInterfaceRenderers(controller, participants) {
+    renderers.set(controller, participants);
+}
+export function detachInterfaceRenderers(controller) {
+    renderers.delete(controller);
+}
+export function registerInterfaceRenderer(controller, renderer) {
+    const participants = renderers.get(controller);
+    if (!participants)
+        throw new Error("Interface controller is disposed or unsupported");
+    participants.add(renderer);
+    return () => { participants.delete(renderer); };
+}

package/dist/interface.d.ts

@@ -0,0 +1,196 @@
+export type InterfaceValue = string | number | boolean | null;
+export interface InterfaceBinding {
+    source: "data" | "state";
+    path: string;
+}
+export interface InterfaceCondition {
+    binding: InterfaceBinding;
+    equals: InterfaceValue;
+}
+export interface InterfaceColumn {
+    key: string;
+    label: string;
+}
+export interface InterfaceNode {
+    key: string;
+    component: string;
+    children?: InterfaceNode[];
+    text?: string | InterfaceBinding;
+    binding?: InterfaceBinding;
+    visible?: InterfaceCondition;
+    action?: string;
+    label?: string;
+    inputType?: "text" | "number" | "checkbox";
+    columns?: InterfaceColumn[];
+    ariaLabel?: string;
+}
+export interface InterfaceDefinition {
+    id: string;
+    screen: InterfaceNode;
+    actions?: string[];
+    data?: Record<string, unknown>;
+    state?: Record<string, unknown>;
+}
+/** Use `satisfies BuiltinInterfaceDefinition` for compile-time checks on JSON-only built-in screens. */
+type BuiltinBase = Pick<InterfaceNode, "key" | "visible" | "ariaLabel">;
+export type BuiltinInterfaceNode = (BuiltinBase & {
+    component: "Stack" | "Row";
+    children?: BuiltinInterfaceNode[];
+}) | (BuiltinBase & {
+    component: "Text" | "Status";
+    text?: string | InterfaceBinding;
+}) | (BuiltinBase & {
+    component: "Heading";
+    text: string | InterfaceBinding;
+}) | (BuiltinBase & {
+    component: "Input";
+    label: string;
+    binding: InterfaceBinding & {
+        source: "state";
+    };
+    inputType?: "text" | "number" | "checkbox";
+}) | (BuiltinBase & {
+    component: "Button";
+    text: string | InterfaceBinding;
+    action: string;
+}) | (BuiltinBase & {
+    component: "Table";
+    binding: InterfaceBinding;
+    columns: InterfaceColumn[];
+}) | (BuiltinBase & {
+    component: "List";
+    binding: InterfaceBinding;
+});
+export type BuiltinInterfaceDefinition = Omit<InterfaceDefinition, "screen"> & {
+    screen: BuiltinInterfaceNode;
+};
+export interface InterfaceEvent {
+    action: string;
+    source: string;
+    state: Record<string, unknown>;
+    revision: number;
+}
+export interface InterfaceSnapshot {
+    definition: InterfaceDefinition;
+    data: Record<string, unknown>;
+    state: Record<string, unknown>;
+    revision: number;
+}
+export interface InterfaceController {
+    snapshot(): InterfaceSnapshot;
+    updateData(data: Record<string, unknown>, expectedRevision?: number): boolean;
+    updateDefinition(definition: InterfaceDefinition, expectedRevision?: number): boolean;
+    setState(path: string, value: InterfaceValue): void;
+    dispatch(action: string, source: string): void;
+    subscribe(listener: (snapshot: InterfaceSnapshot) => void): () => void;
+    dispose(): void;
+}
+/** JSON-safe description of the built-in vocabulary. Host extensions are trusted code and are never advertised here. */
+export declare function getInterfaceCapabilities(): {
+    version: number;
+    components: {
+        readonly Stack: {
+            readonly properties: readonly ["key", "component", "visible", "ariaLabel", "children"];
+            readonly required: readonly [];
+            readonly children: true;
+            readonly event: null;
+        };
+        readonly Row: {
+            readonly properties: readonly ["key", "component", "visible", "ariaLabel", "children"];
+            readonly required: readonly [];
+            readonly children: true;
+            readonly event: null;
+        };
+        readonly Text: {
+            readonly properties: readonly ["key", "component", "visible", "ariaLabel", "text"];
+            readonly required: readonly [];
+            readonly children: false;
+            readonly event: null;
+        };
+        readonly Heading: {
+            readonly properties: readonly ["key", "component", "visible", "ariaLabel", "text"];
+            readonly required: readonly ["text"];
+            readonly children: false;
+            readonly event: null;
+        };
+        readonly Status: {
+            readonly properties: readonly ["key", "component", "visible", "ariaLabel", "text"];
+            readonly required: readonly [];
+            readonly children: false;
+            readonly event: null;
+        };
+        readonly Input: {
+            readonly properties: readonly ["key", "component", "visible", "ariaLabel", "label", "binding", "inputType"];
+            readonly required: readonly ["label", "binding"];
+            readonly children: false;
+            readonly event: "state change";
+        };
+        readonly Button: {
+            readonly properties: readonly ["key", "component", "visible", "ariaLabel", "text", "action"];
+            readonly required: readonly ["text", "action"];
+            readonly children: false;
+            readonly event: "action";
+        };
+        readonly Table: {
+            readonly properties: readonly ["key", "component", "visible", "ariaLabel", "binding", "columns"];
+            readonly required: readonly ["binding", "columns"];
+            readonly children: false;
+            readonly event: null;
+        };
+        readonly List: {
+            readonly properties: readonly ["key", "component", "visible", "ariaLabel", "binding"];
+            readonly required: readonly ["binding"];
+            readonly children: false;
+            readonly event: null;
+        };
+    };
+    bindings: {
+        sources: string[];
+        path: string;
+        missing: string;
+        visibility: string;
+    };
+    propertyTypes: {
+        key: string;
+        component: string;
+        children: string;
+        text: string;
+        binding: string;
+        visible: string;
+        action: string;
+        label: string;
+        inputType: string[];
+        columns: string;
+        ariaLabel: string;
+    };
+    events: {
+        action: {
+            fields: string[];
+            declaration: string;
+        };
+        state: {
+            type: string;
+            source: string;
+        };
+    };
+    limits: {
+        treeDepth: number;
+        nodes: number;
+        textLength: number;
+        tableRows: number;
+        tableColumns: number;
+        listItems: number;
+        transportBytes: number;
+    };
+};
+export declare function defineInterface<const T extends InterfaceDefinition>(definition: T): T;
+/** Validate untrusted structured data before creating a controller or mounting it. */
+export declare function validateInterfaceDefinition(value: unknown, components?: readonly string[]): asserts value is InterfaceDefinition;
+export declare function createInterfaceController(definition: InterfaceDefinition, options?: {
+    components?: readonly string[];
+    allowedActions?: readonly string[];
+    onEvent?: (event: InterfaceEvent) => void | Promise<void>;
+    onError?: (error: unknown) => void;
+}): InterfaceController;
+export declare function resolveInterfaceBinding(snapshot: InterfaceSnapshot, bindingValue: InterfaceBinding): unknown;
+export {};