@json-render/vue 0.9.1

package/dist/index.d.ts

@@ -0,0 +1,885 @@
+import * as vue from 'vue';
+import { PropType, ShallowRef, ComputedRef, VNode, Ref, Component } from 'vue';
+import { StateStore, StateModel, VisibilityCondition, VisibilityContext, ActionHandler, ResolvedAction, ActionBinding, ActionConfirm, ValidationFunction, ValidationResult, ValidationConfig, Catalog, InferCatalogComponents, InferComponentProps, InferCatalogActions, InferActionParams, Spec, FlatElement, SchemaDefinition, ComputedFunction, UIElement } from '@json-render/core';
+export { ComputedFunction, Spec, StateModel, StateStore, createStateStore } from '@json-render/core';
+export { VueSchema, VueSpec, schema } from './schema.js';
+
+/**
+ * State context value
+ */
+interface StateContextValue {
+    /** Reactive state snapshot — use state.value in reactive contexts */
+    state: ShallowRef<StateModel>;
+    /** Get a value by path */
+    get: (path: string) => unknown;
+    /** Set a value by path */
+    set: (path: string, value: unknown) => void;
+    /** Update multiple values at once */
+    update: (updates: Record<string, unknown>) => void;
+    /** Return the live state snapshot from the underlying store (not through Vue reactivity). */
+    getSnapshot: () => StateModel;
+}
+/**
+ * Props for StateProvider
+ */
+interface StateProviderProps {
+    /**
+     * External store that owns the state. When provided, the provider operates
+     * in **controlled mode** — `initialState` and `onStateChange` are ignored
+     * and the store is the single source of truth.
+     */
+    store?: StateStore;
+    /** Initial state model (used only in uncontrolled mode) */
+    initialState?: StateModel;
+    /**
+     * Callback when state changes (used only in uncontrolled mode).
+     * Called once per `set` or `update` with all changed entries.
+     */
+    onStateChange?: (changes: Array<{
+        path: string;
+        value: unknown;
+    }>) => void;
+}
+/**
+ * Provider for state model context.
+ *
+ * Supports two modes:
+ * - **Controlled**: pass a `store` prop (e.g. backed by Redux / Zustand).
+ * - **Uncontrolled** (default): omit `store` and optionally pass
+ *   `initialState` / `onStateChange`.
+ */
+declare const StateProvider: vue.DefineComponent<vue.ExtractPropTypes<{
+    store: {
+        type: PropType<StateStore>;
+        default: undefined;
+    };
+    initialState: {
+        type: PropType<StateModel>;
+        default: undefined;
+    };
+    onStateChange: {
+        type: PropType<(changes: Array<{
+            path: string;
+            value: unknown;
+        }>) => void>;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    store: {
+        type: PropType<StateStore>;
+        default: undefined;
+    };
+    initialState: {
+        type: PropType<StateModel>;
+        default: undefined;
+    };
+    onStateChange: {
+        type: PropType<(changes: Array<{
+            path: string;
+            value: unknown;
+        }>) => void>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    store: StateStore;
+    initialState: StateModel;
+    onStateChange: (changes: Array<{
+        path: string;
+        value: unknown;
+    }>) => void;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+/**
+ * Composable to access the state context
+ */
+declare function useStateStore(): StateContextValue;
+/**
+ * Composable to get a value from the state model (reactive)
+ */
+declare function useStateValue<T>(path: string): ComputedRef<T | undefined>;
+/**
+ * Composable to get and set a value from the state model by path.
+ *
+ * This is the path-based variant for use in arbitrary composables. For
+ * registry components that receive `bindings` from the renderer, prefer
+ * `useBoundProp` which reads the already-resolved prop value and writes back
+ * to the bound path.
+ */
+declare function useStateBinding<T>(path: string): [ComputedRef<T | undefined>, (value: T) => void];
+
+/**
+ * Visibility context value
+ */
+interface VisibilityContextValue {
+    /** Evaluate a visibility condition */
+    isVisible: (condition: VisibilityCondition | undefined) => boolean;
+    /** The underlying visibility context (reactive) */
+    ctx: ComputedRef<VisibilityContext>;
+}
+/**
+ * Provider for visibility evaluation
+ */
+declare const VisibilityProvider: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+/**
+ * Composable to access visibility evaluation
+ */
+declare function useVisibility(): VisibilityContextValue;
+/**
+ * Composable to check if a condition is visible. Returns a reactive
+ * `ComputedRef<boolean>` so the result updates whenever state changes.
+ */
+declare function useIsVisible(condition: VisibilityCondition | undefined): ComputedRef<boolean>;
+
+/**
+ * Pending confirmation state
+ */
+interface PendingConfirmation {
+    action: ResolvedAction;
+    handler: ActionHandler;
+    resolve: () => void;
+    reject: () => void;
+}
+/**
+ * Action context value
+ */
+interface ActionContextValue {
+    handlers: Record<string, ActionHandler>;
+    loadingActions: Set<string>;
+    pendingConfirmation: PendingConfirmation | null;
+    execute: (binding: ActionBinding) => Promise<void>;
+    confirm: () => void;
+    cancel: () => void;
+    registerHandler: (name: string, handler: ActionHandler) => void;
+}
+interface ActionProviderProps {
+    handlers?: Record<string, ActionHandler>;
+    navigate?: (path: string) => void;
+}
+/**
+ * Provider for action execution
+ */
+declare const ActionProvider: vue.DefineComponent<vue.ExtractPropTypes<{
+    handlers: {
+        type: PropType<Record<string, ActionHandler>>;
+        default: () => {};
+    };
+    navigate: {
+        type: PropType<(path: string) => void>;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    handlers: {
+        type: PropType<Record<string, ActionHandler>>;
+        default: () => {};
+    };
+    navigate: {
+        type: PropType<(path: string) => void>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    handlers: Record<string, ActionHandler>;
+    navigate: (path: string) => void;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+/**
+ * Composable to access action context
+ */
+declare function useActions(): ActionContextValue;
+/**
+ * Composable to execute an action binding
+ */
+declare function useAction(binding: ActionBinding): {
+    execute: () => Promise<void>;
+    isLoading: ComputedRef<boolean>;
+};
+/**
+ * Props for ConfirmDialog component
+ */
+interface ConfirmDialogProps {
+    confirm: ActionConfirm;
+    onConfirm: () => void;
+    onCancel: () => void;
+}
+/**
+ * Default confirmation dialog component
+ */
+declare const ConfirmDialog: vue.DefineComponent<vue.ExtractPropTypes<{
+    confirm: {
+        type: PropType<ActionConfirm>;
+        required: true;
+    };
+    onConfirm: {
+        type: PropType<() => void>;
+        required: true;
+    };
+    onCancel: {
+        type: PropType<() => void>;
+        required: true;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    confirm: {
+        type: PropType<ActionConfirm>;
+        required: true;
+    };
+    onConfirm: {
+        type: PropType<() => void>;
+        required: true;
+    };
+    onCancel: {
+        type: PropType<() => void>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * Field validation state
+ */
+interface FieldValidationState {
+    touched: boolean;
+    validated: boolean;
+    result: ValidationResult | null;
+}
+/**
+ * Validation context value
+ */
+interface ValidationContextValue {
+    customFunctions: Record<string, ValidationFunction>;
+    fieldStates: Record<string, FieldValidationState>;
+    validate: (path: string, config: ValidationConfig) => ValidationResult;
+    touch: (path: string) => void;
+    clear: (path: string) => void;
+    validateAll: () => boolean;
+    registerField: (path: string, config: ValidationConfig) => void;
+}
+interface ValidationProviderProps {
+    customFunctions?: Record<string, ValidationFunction>;
+}
+/**
+ * Provider for validation
+ */
+declare const ValidationProvider: vue.DefineComponent<vue.ExtractPropTypes<{
+    customFunctions: {
+        type: PropType<Record<string, ValidationFunction>>;
+        default: () => {};
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    customFunctions: {
+        type: PropType<Record<string, ValidationFunction>>;
+        default: () => {};
+    };
+}>> & Readonly<{}>, {
+    customFunctions: Record<string, ValidationFunction>;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+/**
+ * Composable to access validation context (or null if not inside a ValidationProvider).
+ * Useful for components that optionally participate in form validation.
+ */
+declare function useOptionalValidation(): ValidationContextValue | null;
+/**
+ * Composable to access validation context
+ */
+declare function useValidation(): ValidationContextValue;
+/**
+ * Composable to get validation state for a field
+ */
+declare function useFieldValidation(path: string, config?: ValidationConfig): {
+    state: ComputedRef<FieldValidationState>;
+    validate: () => ValidationResult;
+    touch: () => void;
+    clear: () => void;
+    errors: ComputedRef<string[]>;
+    isValid: ComputedRef<boolean>;
+};
+
+/**
+ * Repeat scope value provided to child elements inside a repeated element.
+ */
+interface RepeatScopeValue {
+    /** The current array item object */
+    item: unknown;
+    /** Index of the current item in the array */
+    index: number;
+    /** Absolute state path to the current array item (e.g. "/todos/0") — used for statePath two-way binding */
+    basePath: string;
+}
+/**
+ * Provides repeat scope to child elements so $item and $index expressions resolve correctly.
+ */
+declare const RepeatScopeProvider: vue.DefineComponent<vue.ExtractPropTypes<{
+    item: {
+        required: true;
+    };
+    index: {
+        type: NumberConstructor;
+        required: true;
+    };
+    basePath: {
+        type: PropType<string>;
+        required: true;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    item: {
+        required: true;
+    };
+    index: {
+        type: NumberConstructor;
+        required: true;
+    };
+    basePath: {
+        type: PropType<string>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+/**
+ * Read the current repeat scope (or null if not inside a repeated element).
+ */
+declare function useRepeatScope(): RepeatScopeValue | null;
+
+/**
+ * State setter function for updating application state
+ */
+type SetState = (updater: (prev: Record<string, unknown>) => Record<string, unknown>) => void;
+/**
+ * Handle returned by the `on()` function for a specific event.
+ * Provides metadata about the event binding and a method to fire it.
+ *
+ * @example
+ * ```ts
+ * const press = on("press");
+ * if (press.shouldPreventDefault) e.preventDefault();
+ * press.emit();
+ * ```
+ */
+interface EventHandle {
+    /** Fire the event (resolve action bindings) */
+    emit: () => void;
+    /** Whether any binding requested preventDefault */
+    shouldPreventDefault: boolean;
+    /** Whether any handler is bound to this event */
+    bound: boolean;
+}
+/**
+ * Catalog-agnostic base type for component render function arguments.
+ * Use this when building reusable component libraries that are not tied to a specific catalog.
+ *
+ * @example
+ * ```ts
+ * const Card = ({ props, children }: BaseComponentProps<{ title?: string }>) =>
+ *   h('div', null, [props.title, children])
+ * ```
+ */
+interface BaseComponentProps<P = Record<string, unknown>> {
+    props: P;
+    /** Rendered children (from the default slot) */
+    children?: VNode | VNode[];
+    /** Simple event emitter (shorthand). Fires the event and returns void. */
+    emit: (event: string) => void;
+    /** Get an event handle with metadata. Use when you need shouldPreventDefault or bound checks. */
+    on: (event: string) => EventHandle;
+    /**
+     * Two-way binding paths resolved from `$bindState` / `$bindItem` expressions.
+     * Maps prop name → absolute state path for write-back.
+     */
+    bindings?: Record<string, string>;
+    loading?: boolean;
+}
+/**
+ * Context passed to component render functions
+ * @example
+ * const Button: ComponentFn<typeof catalog, 'Button'> = (ctx) => {
+ *   return h('button', { onClick: () => ctx.emit("press") }, ctx.props.label)
+ * }
+ */
+interface ComponentContext<C extends Catalog, K extends keyof InferCatalogComponents<C>> extends BaseComponentProps<InferComponentProps<C, K>> {
+}
+/**
+ * Component render function type for Vue
+ * @example
+ * const Button: ComponentFn<typeof catalog, 'Button'> = ({ props, emit }) =>
+ *   h('button', { onClick: () => emit("press") }, props.label)
+ */
+type ComponentFn<C extends Catalog, K extends keyof InferCatalogComponents<C>> = (ctx: ComponentContext<C, K>) => VNode | VNode[] | null | string;
+/**
+ * Registry of all component render functions for a catalog
+ * @example
+ * const components: Components<typeof myCatalog> = {
+ *   Button: ({ props }) => h('button', null, props.label),
+ *   Input: ({ props }) => h('input', { placeholder: props.placeholder }),
+ * };
+ */
+type Components<C extends Catalog> = {
+    [K in keyof InferCatalogComponents<C>]: ComponentFn<C, K>;
+};
+/**
+ * Action handler function type
+ * @example
+ * const viewCustomers: ActionFn<typeof catalog, 'viewCustomers'> = async (params, setState) => {
+ *   const data = await fetch('/api/customers');
+ *   setState(prev => ({ ...prev, customers: data }));
+ * };
+ */
+type ActionFn<C extends Catalog, K extends keyof InferCatalogActions<C>> = (params: InferActionParams<C, K> | undefined, setState: SetState, state: StateModel) => Promise<void>;
+/**
+ * Registry of all action handlers for a catalog
+ * @example
+ * const actions: Actions<typeof myCatalog> = {
+ *   viewCustomers: async (params, setState) => { ... },
+ *   createCustomer: async (params, setState) => { ... },
+ * };
+ */
+type Actions<C extends Catalog> = {
+    [K in keyof InferCatalogActions<C>]: ActionFn<C, K>;
+};
+/**
+ * True when the catalog declares at least one action, false otherwise.
+ * Used by defineRegistry to conditionally require the `actions` field.
+ */
+type CatalogHasActions<C extends Catalog> = [
+    InferCatalogActions<C>
+] extends [never] ? false : [keyof InferCatalogActions<C>] extends [never] ? false : true;
+
+/**
+ * Token usage metadata from AI generation
+ */
+interface TokenUsage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+}
+/**
+ * Options for useUIStream
+ */
+interface UseUIStreamOptions {
+    /** API endpoint */
+    api: string;
+    /** Callback when complete */
+    onComplete?: (spec: Spec) => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+}
+/**
+ * Return type for useUIStream
+ */
+interface UseUIStreamReturn {
+    /** Current UI spec */
+    spec: Ref<Spec | null>;
+    /** Whether currently streaming */
+    isStreaming: Ref<boolean>;
+    /** Error if any */
+    error: Ref<Error | null>;
+    /** Token usage from the last generation */
+    usage: Ref<TokenUsage | null>;
+    /** Raw JSONL lines received from the stream (JSON patch lines) */
+    rawLines: Ref<string[]>;
+    /** Send a prompt to generate UI */
+    send: (prompt: string, context?: Record<string, unknown>) => Promise<void>;
+    /** Clear the current spec */
+    clear: () => void;
+}
+/**
+ * Composable for streaming UI generation
+ */
+declare function useUIStream({ api, onComplete, onError, }: UseUIStreamOptions): UseUIStreamReturn;
+/**
+ * Convert a flat element list to a Spec.
+ * Input elements use key/parentKey to establish identity and relationships.
+ * Output spec uses the map-based format where key is the map entry key
+ * and parent-child relationships are expressed through children arrays.
+ */
+declare function flatToTree(elements: FlatElement[]): Spec;
+/**
+ * Composable for two-way bound props. Returns `[value, setValue]` where:
+ *
+ * - `value` is the already-resolved prop value (passed through from render props)
+ * - `setValue` writes back to the bound state path (no-op if not bound)
+ *
+ * Designed to work with the `bindings` map that the renderer provides when
+ * a prop uses `{ $bindState: "/path" }` or `{ $bindItem: "field" }`.
+ *
+ * @example
+ * ```ts
+ * import { useBoundProp } from "@json-render/vue";
+ *
+ * const Input: ComponentFn<AppCatalog, "Input"> = ({ props, bindings }) => {
+ *   const [value, setValue] = useBoundProp<string>(props.value as string, bindings?.value);
+ *   return h("input", { value: value ?? "", onInput: (e) => setValue(e.target.value) });
+ * };
+ * ```
+ */
+declare function useBoundProp<T>(propValue: T | undefined, bindingPath: string | undefined): [T | undefined, (value: T) => void];
+/**
+ * A single part from the AI SDK's `message.parts` array. This is a minimal
+ * structural type so that library helpers do not depend on the AI SDK.
+ * Fields are optional because different part types carry different data:
+ * - Text parts have `text`
+ * - Data parts have `data`
+ */
+interface DataPart {
+    type: string;
+    text?: string;
+    data?: unknown;
+}
+/**
+ * Build a `Spec` by replaying all spec data parts from a message's
+ * parts array. Returns `null` if no spec data parts are present.
+ *
+ * Works with the AI SDK's `UIMessage.parts` array. Picks out parts whose
+ * `type` is `SPEC_DATA_PART_TYPE` and processes them based on the payload's
+ * `type` discriminator: `"patch"`, `"flat"`, or `"nested"`.
+ */
+declare function buildSpecFromParts(parts: DataPart[]): Spec | null;
+/**
+ * Extract and join all text content from a message's parts array.
+ *
+ * Filters for parts with `type === "text"`, trims each one, and joins them
+ * with double newlines so that text from separate agent steps renders as
+ * distinct paragraphs in markdown.
+ */
+declare function getTextFromParts(parts: DataPart[]): string;
+/**
+ * Composable that extracts both the json-render spec and text content from a
+ * message's parts array. Accepts a plain `DataPart[]` or a `Ref<DataPart[]>`
+ * for reactive use in streaming scenarios.
+ *
+ * Returns `ComputedRef`s that recompute whenever `parts` changes.
+ *
+ * @example
+ * ```ts
+ * import { useJsonRenderMessage } from "@json-render/vue";
+ *
+ * const { spec, text, hasSpec } = useJsonRenderMessage(message.parts);
+ * ```
+ */
+declare function useJsonRenderMessage(parts: DataPart[] | Ref<DataPart[]>): {
+    spec: ComputedRef<Spec | null>;
+    text: ComputedRef<string>;
+    hasSpec: ComputedRef<boolean>;
+};
+/**
+ * A single message in the chat, which may contain text, a rendered UI spec, or both.
+ */
+interface ChatMessage {
+    /** Unique message ID */
+    id: string;
+    /** Who sent this message */
+    role: "user" | "assistant";
+    /** Text content (conversational prose) */
+    text: string;
+    /** json-render Spec built from JSONL patches (null if no UI was generated) */
+    spec: Spec | null;
+}
+/**
+ * Options for useChatUI
+ */
+interface UseChatUIOptions {
+    /** API endpoint that accepts `{ messages: Array<{ role, content }> }` and returns a text stream */
+    api: string;
+    /** Callback when streaming completes for a message */
+    onComplete?: (message: ChatMessage) => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+}
+/**
+ * Return type for useChatUI
+ */
+interface UseChatUIReturn {
+    /** All messages in the conversation */
+    messages: Ref<ChatMessage[]>;
+    /** Whether currently streaming an assistant response */
+    isStreaming: Ref<boolean>;
+    /** Error from the last request, if any */
+    error: Ref<Error | null>;
+    /** Send a user message */
+    send: (text: string) => Promise<void>;
+    /** Clear all messages and reset the conversation */
+    clear: () => void;
+}
+/**
+ * Composable for chat + GenUI experiences.
+ *
+ * Manages a multi-turn conversation where each assistant message can contain
+ * both conversational text and a json-render UI spec. Sends the full message
+ * history to the API endpoint, reads the streamed response, and separates
+ * text lines from JSONL patch lines using `createMixedStreamParser`.
+ *
+ * @example
+ * ```ts
+ * const { messages, isStreaming, send, clear } = useChatUI({ api: "/api/chat" });
+ *
+ * await send("Compare weather in NYC and Tokyo");
+ * ```
+ */
+declare function useChatUI({ api, onComplete, onError, }: UseChatUIOptions): UseChatUIReturn;
+
+/**
+ * Props passed to component renderers
+ */
+interface ComponentRenderProps<P = Record<string, unknown>> {
+    /** The element being rendered */
+    element: UIElement<string, P>;
+    /** Emit a named event */
+    emit: (event: string) => void;
+    /** Get an event handle with metadata */
+    on: (event: string) => EventHandle;
+    /**
+     * Two-way binding paths resolved from `$bindState` / `$bindItem` expressions.
+     * Maps prop name → absolute state path for write-back.
+     */
+    bindings?: Record<string, string>;
+    /** Whether the parent is loading */
+    loading?: boolean;
+}
+/**
+ * Registry of component renderers (Vue component definitions)
+ */
+type ComponentRegistry = Record<string, Component>;
+/**
+ * Props for the Renderer component
+ */
+interface RendererProps {
+    spec: Spec | null;
+    registry: ComponentRegistry;
+    loading?: boolean;
+    fallback?: Component;
+}
+/**
+ * Main renderer component
+ */
+declare const Renderer: vue.DefineComponent<vue.ExtractPropTypes<{
+    spec: {
+        type: PropType<Spec | null>;
+        default: null;
+    };
+    registry: {
+        type: PropType<ComponentRegistry>;
+        required: true;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    fallback: {
+        type: PropType<Component>;
+        default: undefined;
+    };
+}>, () => VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    spec: {
+        type: PropType<Spec | null>;
+        default: null;
+    };
+    registry: {
+        type: PropType<ComponentRegistry>;
+        required: true;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    fallback: {
+        type: PropType<Component>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    spec: Spec | null;
+    loading: boolean;
+    fallback: Component;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+/**
+ * Props for JSONUIProvider
+ */
+interface JSONUIProviderProps {
+    registry: ComponentRegistry;
+    store?: StateStore;
+    initialState?: Record<string, unknown>;
+    handlers?: Record<string, (params: Record<string, unknown>) => Promise<unknown> | unknown>;
+    navigate?: (path: string) => void;
+    validationFunctions?: Record<string, (value: unknown, args?: Record<string, unknown>) => boolean>;
+    /** Named functions for `$computed` expressions in props */
+    functions?: Record<string, ComputedFunction>;
+    onStateChange?: (changes: Array<{
+        path: string;
+        value: unknown;
+    }>) => void;
+}
+/**
+ * Combined provider for all JSONUI contexts
+ */
+declare const JSONUIProvider: vue.DefineComponent<vue.ExtractPropTypes<{
+    registry: {
+        type: PropType<ComponentRegistry>;
+        required: true;
+    };
+    store: {
+        type: PropType<StateStore>;
+        default: undefined;
+    };
+    initialState: {
+        type: PropType<Record<string, unknown>>;
+        default: undefined;
+    };
+    handlers: {
+        type: PropType<Record<string, (params: Record<string, unknown>) => Promise<unknown> | unknown>>;
+        default: undefined;
+    };
+    navigate: {
+        type: PropType<(path: string) => void>;
+        default: undefined;
+    };
+    validationFunctions: {
+        type: PropType<Record<string, (value: unknown, args?: Record<string, unknown>) => boolean>>;
+        default: undefined;
+    };
+    functions: {
+        type: PropType<Record<string, ComputedFunction>>;
+        default: undefined;
+    };
+    onStateChange: {
+        type: PropType<(changes: Array<{
+            path: string;
+            value: unknown;
+        }>) => void>;
+        default: undefined;
+    };
+}>, () => VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    registry: {
+        type: PropType<ComponentRegistry>;
+        required: true;
+    };
+    store: {
+        type: PropType<StateStore>;
+        default: undefined;
+    };
+    initialState: {
+        type: PropType<Record<string, unknown>>;
+        default: undefined;
+    };
+    handlers: {
+        type: PropType<Record<string, (params: Record<string, unknown>) => Promise<unknown> | unknown>>;
+        default: undefined;
+    };
+    navigate: {
+        type: PropType<(path: string) => void>;
+        default: undefined;
+    };
+    validationFunctions: {
+        type: PropType<Record<string, (value: unknown, args?: Record<string, unknown>) => boolean>>;
+        default: undefined;
+    };
+    functions: {
+        type: PropType<Record<string, ComputedFunction>>;
+        default: undefined;
+    };
+    onStateChange: {
+        type: PropType<(changes: Array<{
+            path: string;
+            value: unknown;
+        }>) => void>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    store: StateStore;
+    initialState: Record<string, unknown>;
+    onStateChange: (changes: Array<{
+        path: string;
+        value: unknown;
+    }>) => void;
+    handlers: Record<string, (params: Record<string, unknown>) => Promise<unknown> | unknown>;
+    navigate: (path: string) => void;
+    functions: Record<string, ComputedFunction>;
+    validationFunctions: Record<string, (value: unknown, args?: Record<string, unknown>) => boolean>;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+/**
+ * Result returned by defineRegistry
+ */
+interface DefineRegistryResult {
+    registry: ComponentRegistry;
+    handlers: (getSetState: () => SetState | undefined, getState: () => StateModel) => Record<string, (params: Record<string, unknown>) => Promise<void>>;
+    executeAction: (actionName: string, params: Record<string, unknown> | undefined, setState: SetState, state?: StateModel) => Promise<void>;
+}
+type DefineRegistryOptions<C extends Catalog> = {
+    components?: Components<C>;
+} & (CatalogHasActions<C> extends true ? {
+    actions: Actions<C>;
+} : {
+    actions?: Actions<C>;
+});
+/**
+ * Create a registry from a catalog with components and/or actions.
+ *
+ * @example
+ * ```ts
+ * // Components only
+ * const { registry } = defineRegistry(catalog, {
+ *   components: {
+ *     Card: ({ props, children }) => h('div', { class: 'card' }, [props.title, children]),
+ *   },
+ * });
+ *
+ * // Both
+ * const { registry, handlers, executeAction } = defineRegistry(catalog, {
+ *   components: { ... },
+ *   actions: { ... },
+ * });
+ * ```
+ */
+declare function defineRegistry<C extends Catalog>(_catalog: C, options: DefineRegistryOptions<C>): DefineRegistryResult;
+/**
+ * Props for renderers created with createRenderer
+ */
+interface CreateRendererProps {
+    spec: Spec | null;
+    store?: StateStore;
+    state?: Record<string, unknown>;
+    onAction?: (actionName: string, params?: Record<string, unknown>) => void;
+    onStateChange?: (changes: Array<{
+        path: string;
+        value: unknown;
+    }>) => void;
+    /** Named functions for `$computed` expressions in props */
+    functions?: Record<string, ComputedFunction>;
+    loading?: boolean;
+    fallback?: Component;
+}
+/**
+ * Component map type — maps component names to Vue components
+ */
+type ComponentMap<TComponents extends Record<string, {
+    props: unknown;
+}>> = {
+    [K in keyof TComponents]: Component;
+};
+/**
+ * Create a renderer from a catalog
+ *
+ * @example
+ * ```typescript
+ * const DashboardRenderer = createRenderer(dashboardCatalog, {
+ *   Card: ({ props, children }) => h('div', { class: 'card' }, children),
+ *   Metric: ({ props }) => h('span', null, props.value),
+ * });
+ *
+ * // Usage in template
+ * <DashboardRenderer :spec="aiGeneratedSpec" :state="state" />
+ * ```
+ */
+declare function createRenderer<TDef extends SchemaDefinition, TCatalog extends {
+    components: Record<string, {
+        props: unknown;
+    }>;
+}>(catalog: Catalog<TDef, TCatalog>, components: ComponentMap<TCatalog["components"]>): Component;
+
+export { type ActionContextValue, type ActionFn, ActionProvider, type ActionProviderProps, type Actions, type BaseComponentProps, type ChatMessage, type ComponentContext, type ComponentFn, type ComponentMap, type ComponentRegistry, type ComponentRenderProps, type Components, ConfirmDialog, type ConfirmDialogProps, type CreateRendererProps, type DataPart, type DefineRegistryResult, type EventHandle, type FieldValidationState, JSONUIProvider, type JSONUIProviderProps, type PendingConfirmation, Renderer, type RendererProps, RepeatScopeProvider, type RepeatScopeValue, type SetState, type StateContextValue, StateProvider, type StateProviderProps, type TokenUsage, type UseChatUIOptions, type UseChatUIReturn, type UseUIStreamOptions, type UseUIStreamReturn, type ValidationContextValue, ValidationProvider, type ValidationProviderProps, type VisibilityContextValue, VisibilityProvider, buildSpecFromParts, createRenderer, defineRegistry, flatToTree, getTextFromParts, useAction, useActions, useBoundProp, useChatUI, useFieldValidation, useIsVisible, useJsonRenderMessage, useOptionalValidation, useRepeatScope, useStateBinding, useStateStore, useStateValue, useUIStream, useValidation, useVisibility };