@superxd-studio/adptr 0.5.0

package/types/reusable/core/index.d.ts

@@ -0,0 +1,107 @@
+/** Public, platform-neutral contract. No browser, React or runtime-vendor types. */
+export { AttachmentController } from "./attachments.js";
+export type { AttachmentItem, AttachmentIssue, AttachmentSnapshot, UploadAdapter, UploadPolicy, UploadSource, } from "./attachments.js";
+export type ChatStatus = "idle" | "waiting" | "streaming" | "complete" | "cancelled" | "error" | "interrupted";
+export interface ChatMessage {
+    readonly id: string;
+    readonly role: "user" | "assistant";
+    readonly text: string;
+    readonly files?: readonly ChatFile[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface ChatCapabilities {
+    readonly send: boolean;
+    readonly cancel: boolean;
+    /** Restart a response, not continuation of an interrupted stream. */
+    readonly retry: boolean;
+    readonly attachments?: boolean;
+    /** Host explicitly permits replaying a question; this does not undo server work. */
+    readonly edit?: boolean;
+    readonly regenerate?: boolean;
+    readonly branches?: boolean;
+}
+export interface ChatBranch {
+    readonly index: number;
+    readonly count: number;
+}
+/** A verified reference from the consumer's upload service, never a browser File. */
+export interface ChatFile {
+    readonly id: string;
+    readonly name: string;
+    readonly mediaType: string;
+    readonly size: number;
+    readonly url: string;
+}
+export interface ChatSnapshot {
+    readonly messages: readonly ChatMessage[];
+    readonly status: ChatStatus;
+    readonly capabilities: ChatCapabilities;
+    readonly branches?: Readonly<Record<string, ChatBranch>>;
+}
+export interface ChatRequest {
+    readonly requestId: string;
+    readonly messages: readonly ChatMessage[];
+}
+export type ChatEvent = {
+    type: "text";
+    text: string;
+} | {
+    type: "replace-text";
+    text: string;
+} | {
+    type: "metadata";
+    metadata: Readonly<Record<string, unknown>>;
+} | {
+    type: "finish";
+} | {
+    type: "error";
+};
+export interface ChatAdapter {
+    readonly capabilities: ChatCapabilities;
+    run(request: ChatRequest, signal: AbortSignal): AsyncIterable<ChatEvent>;
+}
+export interface ChatActions {
+    send(text: string, files?: readonly ChatFile[]): boolean;
+    cancel(): void;
+    retry(): boolean;
+    edit?(messageId: string, text: string): boolean;
+    regenerate?(messageId: string): boolean;
+    selectBranch?(messageId: string, direction: "previous" | "next"): boolean;
+}
+export declare class ChatInterrupted extends Error {
+    constructor();
+}
+export declare function parseChatFile(value: unknown): ChatFile;
+/** Validates the small wire protocol. Provider/server errors never become UI copy. */
+export declare function parseChatEvent(value: unknown): ChatEvent;
+export declare function parseChatRequest(value: unknown): ChatRequest;
+/** One bounded, in-memory conversation tree. Snapshots contain only its selected path. */
+export declare class ChatController implements ChatActions {
+    private readonly adapter;
+    private readonly id;
+    private snapshot;
+    private readonly listeners;
+    private readonly nodes;
+    private readonly children;
+    private readonly selected;
+    private active;
+    private generation;
+    constructor(adapter: ChatAdapter, id: () => string);
+    getSnapshot: () => ChatSnapshot;
+    subscribe: (listener: () => void) => (() => void);
+    private path;
+    private publish;
+    private add;
+    private room;
+    send: (text: string, files?: readonly ChatFile[]) => boolean;
+    edit: (messageId: string, text: string) => boolean;
+    regenerate: (messageId: string) => boolean;
+    selectBranch: (messageId: string, direction: "previous" | "next") => boolean;
+    retry: () => boolean;
+    cancel: () => void;
+    dispose: () => void;
+    private begin;
+    private consume;
+}
+export * from "../review/types.js";
+export { ReviewController, reviewReducer } from "../review/controller.js";

package/types/reusable/custom/index.d.ts

@@ -0,0 +1,14 @@
+import { type ChatAdapter } from "../core/index.js";
+export interface HttpChatOptions {
+    endpoint: string;
+    /** Opt into editing, regeneration and versions. Restart is controlled separately by retry. */
+    conversationActions?: boolean;
+    /** Allow Restart as a new run. Defaults to true; disable for endpoints without replay safety. */
+    retry?: boolean;
+    /** Consumer-owned, evaluated each request so refreshed auth is used. */
+    headers?: () => HeadersInit | Promise<HeadersInit>;
+    credentials?: RequestCredentials;
+    fetch?: typeof globalThis.fetch;
+}
+/** Newline-delimited JSON over customer-owned HTTP. No hosted account required. */
+export declare function createHttpChatAdapter(options: HttpChatOptions): ChatAdapter;

package/types/reusable/generative/actions.d.ts

@@ -0,0 +1,45 @@
+import { type StructuredAction } from "./schema.js";
+export interface GenerativeRequest {
+    readonly key: string;
+    readonly action: StructuredAction;
+}
+export interface GenerativeReceipt {
+    key: string;
+    type: string;
+    state: "complete" | "not-applied";
+    message: string;
+}
+export interface GenerativeActionHandler {
+    /** Host-owned copy and intent. A model cannot mark an action safe or grant permission. */
+    label: string;
+    description: string;
+    kind: "inspect" | "mutate" | "dismiss";
+    /** Must enforce authorization and idempotency at the destination. The frozen request survives retries. */
+    execute: (request: GenerativeRequest, signal: AbortSignal) => Promise<GenerativeReceipt>;
+    /** Return null only if no receipt is available yet; this does not prove an action wasn't applied. */
+    lookup?: (request: GenerativeRequest, signal: AbortSignal) => Promise<GenerativeReceipt | null>;
+}
+export type GenerativeActions = Readonly<Record<string, GenerativeActionHandler>>;
+export type GenerativeStage = "ready" | "confirm" | "submitting" | "failed" | "uncertain" | "checking" | "complete" | "dismissed";
+export interface GenerativeActionSnapshot {
+    stage: GenerativeStage;
+    request?: GenerativeRequest;
+    label?: string;
+    description?: string;
+    message?: string;
+    noReceipt?: boolean;
+}
+/** One state owner. No execution before explicit confirmation of host-declared mutations. */
+export declare function createGenerativeActionController(actions: GenerativeActions, makeKey?: () => `${string}-${string}-${string}-${string}-${string}`): {
+    subscribe: (listener: () => void) => () => void;
+    getSnapshot: () => GenerativeActionSnapshot;
+    request: (input: unknown) => boolean;
+    confirm: () => boolean;
+    back: () => boolean;
+    retry: () => boolean;
+    check: () => boolean;
+    reset: () => boolean;
+    dispose: () => void;
+};
+export type GenerativeActionController = ReturnType<typeof createGenerativeActionController>;
+export declare const unavailableActionMessage: "This action isn’t available here.";

package/types/reusable/generative/copy.d.ts

@@ -0,0 +1,48 @@
+export declare const generativeCopy: {
+    readonly stepReady: "Ready";
+    readonly stepLoading: "Loading";
+    readonly stepReview: "Review";
+    readonly stepFailed: "Not applied";
+    readonly stepUncertain: "Unconfirmed";
+    readonly stepResult: "Result";
+    readonly stepPast: "Previous state";
+    readonly loading: "Preparing your response";
+    readonly streaming: "The response is arriving. Actions will be available when it’s complete.";
+    readonly empty: "There’s nothing to show yet.";
+    readonly invalid: "We couldn’t display this response.";
+    readonly invalidNote: "Your work is still here. Try requesting the response again.";
+    readonly retry: "Try again";
+    readonly back: "Back";
+    readonly confirm: "Confirm action";
+    readonly working: "Applying";
+    readonly checking: "Checking";
+    readonly review: "Review before continuing";
+    readonly input: "Your details";
+    readonly noHandler: "This action isn’t available here.";
+    readonly failed: "The action wasn’t applied.";
+    readonly failedNote: "Your details are saved here. You can try again.";
+    readonly uncertain: "We haven’t received confirmation.";
+    readonly uncertainNote: "Check the result before trying again. Your details are kept here.";
+    readonly check: "Check status";
+    readonly noReceipt: "There’s no confirmation yet. Check again or retry this same request.";
+    readonly complete: "Action complete";
+    readonly dismissed: "Dismissed";
+    readonly fieldRequired: "Enter a value to continue.";
+    readonly email: "Enter an email address like name@company.com.";
+    readonly date: "Enter a valid date.";
+    readonly imageMissing: "Image unavailable";
+    readonly data: "View data";
+    readonly point: "Point";
+    readonly series: "Value";
+    readonly mediaSelected: "Track selected";
+    readonly quoted: "Quoted amount";
+    readonly validation: "Check the highlighted fields.";
+    readonly updated: "A new response is available. Finish or dismiss this action before opening it.";
+    readonly next: "Open new response";
+    readonly quoteUnavailable: "We couldn’t confirm the amount. Try again before continuing.";
+    readonly actionInvalid: "We couldn’t prepare this action.";
+    readonly actionInvalidNote: "Your details are still here. Check the entries, shorten long text and try again.";
+};
+export type GenerativeCopy = {
+    [K in keyof typeof generativeCopy]: string;
+};

package/types/reusable/generative/data.d.ts

@@ -0,0 +1,4 @@
+import type { GenerativeChartProps, GenerativeTableProps } from "./schema.js";
+export declare function GenerativeTable({ label, columns, rows, sortable }: GenerativeTableProps): import("react").JSX.Element;
+/** Upstream chart geometry, host tokens, and the same values in a keyboard-accessible table. */
+export declare function GenerativeChart(props: GenerativeChartProps): import("react").JSX.Element;

package/types/reusable/generative/index.d.ts

@@ -0,0 +1,30 @@
+import { type ReactNode } from "react";
+import { type GenerativeCopy } from "./copy.js";
+import { type GenerativeLibraryOptions } from "./vocabulary.js";
+import { type GenerativeActions, type GenerativeActionController, type GenerativeRequest } from "./actions.js";
+export { createSuperxdGenerativeLibrary, GenerativeForm } from "./vocabulary.js";
+export type { GenerativeLibraryOptions, GenerativeFormProps, GenerativeFactResolver, } from "./vocabulary.js";
+export { GenerativeChart, GenerativeTable } from "./data.js";
+export { parseStructuredSpec, chartSchema, tableSchema, nodeSchemas } from "./schema.js";
+export type { StructuredSpec, StructuredAction, GenerativeChartProps, GenerativeTableProps, } from "./schema.js";
+export { createGenerativeActionController } from "./actions.js";
+export type { GenerativeActionController, GenerativeActions, GenerativeActionHandler, GenerativeActionSnapshot, GenerativeStage, GenerativeRequest, GenerativeReceipt, } from "./actions.js";
+export { generativeCopy } from "./copy.js";
+export type { GenerativeCopy } from "./copy.js";
+export interface StructuredResponseProps extends GenerativeLibraryOptions {
+    /** Stable identity of this response. A different response owns a different action session. */
+    responseId: string;
+    spec: unknown;
+    status?: "loading" | "streaming" | "done" | "error";
+    /** Host-authored allowlist; an omitted handler renders its action unavailable. Keep stable for this response. */
+    actions?: GenerativeActions;
+    controller?: GenerativeActionController;
+    onRetry?: () => void;
+    /** Host-owned destination shown only after a matching successful receipt. Return null for the default receipt. */
+    renderResult?: (request: GenerativeRequest) => ReactNode;
+    /** Keep action steps on the canvas; earlier steps become read-only previews. Off by default. */
+    retainSteps?: boolean;
+    copy?: GenerativeCopy;
+    className?: string;
+}
+export declare function StructuredResponse(props: StructuredResponseProps): import("react").JSX.Element;

package/types/reusable/generative/schema.d.ts

@@ -0,0 +1,303 @@
+import { z } from "zod";
+export declare const actionSchema: z.ZodIntersection<z.ZodRecord<z.ZodString, z.ZodJSONSchema>, z.ZodObject<{
+    type: z.ZodString;
+}, z.core.$strip>>;
+export type StructuredAction = z.infer<typeof actionSchema>;
+export declare const chartSchema: z.ZodObject<{
+    label: z.ZodString;
+    variant: z.ZodEnum<{
+        bar: "bar";
+        line: "line";
+        area: "area";
+        sparkline: "sparkline";
+    }>;
+    data: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodNumber;
+    }, z.core.$strict>>>;
+    series: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        data: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+    stacked: z.ZodOptional<z.ZodBoolean>;
+    showAxis: z.ZodOptional<z.ZodBoolean>;
+    showLegend: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type GenerativeChartProps = z.infer<typeof chartSchema>;
+export declare const tableSchema: z.ZodObject<{
+    label: z.ZodString;
+    columns: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        align: z.ZodOptional<z.ZodEnum<{
+            start: "start";
+            end: "end";
+        }>>;
+    }, z.core.$strict>>;
+    rows: z.ZodArray<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    sortable: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type GenerativeTableProps = z.infer<typeof tableSchema>;
+export declare const nodeSchemas: {
+    Card: z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        asForm: z.ZodOptional<z.ZodBoolean>;
+        confirm: z.ZodOptional<z.ZodObject<{
+            label: z.ZodString;
+            $action: z.ZodOptional<z.ZodIntersection<z.ZodRecord<z.ZodString, z.ZodJSONSchema>, z.ZodObject<{
+                type: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strict>>;
+        cancel: z.ZodOptional<z.ZodObject<{
+            label: z.ZodString;
+            $action: z.ZodOptional<z.ZodIntersection<z.ZodRecord<z.ZodString, z.ZodJSONSchema>, z.ZodObject<{
+                type: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    Form: z.ZodObject<{}, z.core.$strict>;
+    Row: z.ZodObject<{
+        justify: z.ZodOptional<z.ZodEnum<{
+            start: "start";
+            center: "center";
+            end: "end";
+            between: "between";
+        }>>;
+        gap: z.ZodOptional<z.ZodNumber>;
+        align: z.ZodOptional<z.ZodEnum<{
+            start: "start";
+            center: "center";
+            end: "end";
+        }>>;
+    }, z.core.$strict>;
+    Col: z.ZodObject<{
+        gap: z.ZodOptional<z.ZodNumber>;
+        align: z.ZodOptional<z.ZodEnum<{
+            start: "start";
+            center: "center";
+            end: "end";
+        }>>;
+    }, z.core.$strict>;
+    Text: z.ZodObject<{
+        value: z.ZodString;
+        size: z.ZodOptional<z.ZodEnum<{
+            sm: "sm";
+            md: "md";
+            lg: "lg";
+            xl: "xl";
+            "2xl": "2xl";
+            "3xl": "3xl";
+        }>>;
+        weight: z.ZodOptional<z.ZodEnum<{
+            bold: "bold";
+            normal: "normal";
+            medium: "medium";
+            semibold: "semibold";
+        }>>;
+        color: z.ZodOptional<z.ZodEnum<{
+            emphasis: "emphasis";
+            secondary: "secondary";
+        }>>;
+    }, z.core.$strict>;
+    Header: z.ZodObject<{
+        text: z.ZodString;
+        size: z.ZodOptional<z.ZodEnum<{
+            sm: "sm";
+            md: "md";
+            lg: "lg";
+            xl: "xl";
+            "2xl": "2xl";
+            "3xl": "3xl";
+        }>>;
+    }, z.core.$strict>;
+    Caption: z.ZodObject<{
+        value: z.ZodString;
+    }, z.core.$strict>;
+    Markdown: z.ZodObject<{
+        value: z.ZodString;
+    }, z.core.$strict>;
+    Badge: z.ZodObject<{
+        value: z.ZodString;
+        variant: z.ZodOptional<z.ZodEnum<{
+            success: "success";
+            info: "info";
+            warning: "warning";
+            neutral: "neutral";
+        }>>;
+    }, z.core.$strict>;
+    Fact: z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodString;
+        binding: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    Divider: z.ZodObject<{}, z.core.$strict>;
+    Spacer: z.ZodObject<{}, z.core.$strict>;
+    Accent: z.ZodObject<{}, z.core.$strict>;
+    Icon: z.ZodObject<{
+        name: z.ZodEnum<{
+            user: "user";
+            search: "search";
+            check: "check";
+            sun: "sun";
+            moon: "moon";
+            cloud: "cloud";
+            rain: "rain";
+            snow: "snow";
+            wind: "wind";
+            play: "play";
+            pause: "pause";
+            x: "x";
+            star: "star";
+            heart: "heart";
+            "arrow-right": "arrow-right";
+            "arrow-up-right": "arrow-up-right";
+            "chevron-right": "chevron-right";
+            calendar: "calendar";
+            clock: "clock";
+            "map-pin": "map-pin";
+            plane: "plane";
+            truck: "truck";
+            "credit-card": "credit-card";
+            bell: "bell";
+        }>;
+        size: z.ZodOptional<z.ZodEnum<{
+            sm: "sm";
+            md: "md";
+            lg: "lg";
+        }>>;
+    }, z.core.$strict>;
+    Image: z.ZodObject<{
+        src: z.ZodString;
+        alt: z.ZodString;
+        size: z.ZodOptional<z.ZodEnum<{
+            sm: "sm";
+            md: "md";
+            lg: "lg";
+        }>>;
+        round: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>;
+    Avatar: z.ZodObject<{
+        name: z.ZodString;
+    }, z.core.$strict>;
+    Alert: z.ZodObject<{
+        tone: z.ZodEnum<{
+            success: "success";
+            info: "info";
+            warning: "warning";
+            danger: "danger";
+        }>;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    ListView: z.ZodObject<{}, z.core.$strict>;
+    ListViewItem: z.ZodObject<{}, z.core.$strict>;
+    Input: z.ZodObject<{
+        placeholder: z.ZodOptional<z.ZodString>;
+        multiline: z.ZodOptional<z.ZodBoolean>;
+        inputType: z.ZodOptional<z.ZodEnum<{
+            text: "text";
+            email: "email";
+        }>>;
+        name: z.ZodString;
+        label: z.ZodString;
+        defaultValue: z.ZodOptional<z.ZodString>;
+        required: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>;
+    Select: z.ZodObject<{
+        options: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strict>>;
+        placeholder: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        label: z.ZodString;
+        defaultValue: z.ZodOptional<z.ZodString>;
+        required: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>;
+    DatePicker: z.ZodObject<{
+        name: z.ZodString;
+        label: z.ZodString;
+        defaultValue: z.ZodOptional<z.ZodString>;
+        required: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>;
+    RadioGroup: z.ZodObject<{
+        options: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strict>>;
+        name: z.ZodString;
+        label: z.ZodString;
+        defaultValue: z.ZodOptional<z.ZodString>;
+        required: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>;
+    Checkbox: z.ZodObject<{
+        name: z.ZodString;
+        label: z.ZodString;
+        defaultChecked: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>;
+    Button: z.ZodObject<{
+        label: z.ZodString;
+        buttonStyle: z.ZodOptional<z.ZodEnum<{
+            secondary: "secondary";
+            danger: "danger";
+            primary: "primary";
+            outline: "outline";
+            ghost: "ghost";
+        }>>;
+        block: z.ZodOptional<z.ZodBoolean>;
+        submit: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>;
+    Progress: z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodNumber;
+        max: z.ZodNumber;
+    }, z.core.$strict>;
+    Chart: z.ZodObject<{
+        label: z.ZodString;
+        variant: z.ZodEnum<{
+            bar: "bar";
+            line: "line";
+            area: "area";
+            sparkline: "sparkline";
+        }>;
+        data: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodNumber;
+        }, z.core.$strict>>>;
+        series: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            data: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                value: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+        stacked: z.ZodOptional<z.ZodBoolean>;
+        showAxis: z.ZodOptional<z.ZodBoolean>;
+        showLegend: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>;
+    Table: z.ZodObject<{
+        label: z.ZodString;
+        columns: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            align: z.ZodOptional<z.ZodEnum<{
+                start: "start";
+                end: "end";
+            }>>;
+        }, z.core.$strict>>;
+        rows: z.ZodArray<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+        sortable: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>;
+};
+export type StructuredSpec = {
+    readonly $type: string;
+    readonly $key?: string | number;
+    readonly $action?: StructuredAction;
+    readonly children?: StructuredSpec | readonly StructuredSpec[];
+    readonly [property: string]: unknown;
+};
+/** Bound the whole JSON tree before recursive schemas, including action payloads. */
+export declare function assertBoundedJson(input: unknown, maxBytes?: number): void;
+/** Validate BEFORE the upstream renderer; its property schemas describe tools, not input validation. */
+export declare function parseStructuredSpec(input: unknown): StructuredSpec;

package/types/reusable/generative/timeline.d.ts

@@ -0,0 +1,21 @@
+import { type ReactNode } from "react";
+import type { GenerativeActionController, GenerativeActionSnapshot, GenerativeActions } from "./actions.js";
+import type { GenerativeCopy } from "./copy.js";
+type ResponseStatus = "loading" | "streaming" | "done" | "error";
+interface Step {
+    snapshot: GenerativeActionSnapshot;
+    spec: unknown;
+    status: ResponseStatus;
+    input?: Readonly<Record<string, string | boolean>>;
+    result?: ReactNode;
+    label?: string;
+}
+export declare function ResponseTimeline({ controller, spec, status, actions, copy, children, }: {
+    controller: GenerativeActionController;
+    spec: unknown;
+    status: ResponseStatus;
+    actions: GenerativeActions;
+    copy: GenerativeCopy;
+    children: (step: Step, onRequest: (input: unknown) => void) => ReactNode;
+}): import("react").JSX.Element;
+export {};

package/types/reusable/generative/vocabulary.d.ts

@@ -0,0 +1,34 @@
+import { type ReactNode } from "react";
+import type { GenerativeUILibrary, GenerativeUIDispatch } from "@assistant-ui/react-generative-ui";
+import { buttonStyles } from "../../components/button.js";
+import { type StructuredAction } from "./schema.js";
+export declare const GenerativeRuntimeContext: import("react").Context<{
+    blocked: boolean;
+    available: ReadonlySet<string> | undefined;
+    captureInput: ((input: unknown) => void) | undefined;
+    initialValues: Readonly<Record<string, string | boolean>> | undefined;
+}>;
+export type GenerativeFactResolver = (binding: string, values: Readonly<Record<string, string | boolean>>) => string | undefined;
+export interface GenerativeFormProps {
+    children?: ReactNode;
+    action?: StructuredAction;
+    dispatch?: GenerativeUIDispatch;
+    title?: string;
+    confirm?: {
+        label: string;
+        $action?: StructuredAction;
+    };
+    cancel?: {
+        label: string;
+        $action?: StructuredAction;
+    };
+    resolveFact?: GenerativeFactResolver;
+}
+export declare function GenerativeForm({ children, action, dispatch, title, confirm, cancel, resolveFact, }: GenerativeFormProps): import("react").JSX.Element;
+export interface GenerativeLibraryOptions {
+    /** Only host-approved images may load. No arbitrary model-supplied network requests. */ resolveImage?: (src: string) => string | undefined;
+    /** Host-derived values, such as a quote. The destination must revalidate them. */ resolveFact?: GenerativeFactResolver;
+}
+/** Same wire vocabulary as upstream, with SuperXD controls and a closed token-only presentation. */
+export declare function createSuperxdGenerativeLibrary(options?: GenerativeLibraryOptions): GenerativeUILibrary;
+export { buttonStyles };