ngx-json-render 0.1.0

package/types/ngx-json-render.d.ts

@@ -0,0 +1,821 @@
+import * as _json_render_core from '@json-render/core';
+import { ResolvedAction, ActionHandler, ActionBinding, Catalog, InferCatalogActions, InferActionParams, StateModel, InferCatalogComponents, UIElement, Spec, StateStore, ValidationFunction, ComputedFunction, DirectiveDefinition, ActionConfirm, DirectiveRegistry, ValidationResult, ValidationConfig, JsonPatch, FlatElement } from '@json-render/core';
+export { ActionBinding, ActionHandler, JsonPatch, Spec, StateModel, StateStore, UIElement, VisibilityCondition, createStateStore, nestedToFlat } from '@json-render/core';
+import * as zod from 'zod';
+import * as zod_v4_core from 'zod/v4/core';
+import * as _angular_core from '@angular/core';
+import { Signal, Type, InjectionToken } from '@angular/core';
+
+interface PendingConfirmation {
+    action: ResolvedAction;
+    handler: ActionHandler;
+    resolve: () => void;
+    reject: () => void;
+}
+/**
+ * Action dispatcher of a `<json-render>` subtree.
+ *
+ * Executes {@link ActionBinding}s: built-in actions (`setState`, `pushState`,
+ * `removeState`, `push`, `pop`, `validateForm`) are handled internally;
+ * everything else is routed to the host-provided `handlers` (or the
+ * `onAction` catch-all), honoring `confirm`, `onSuccess`, and `onError`.
+ */
+declare class JsonRenderActionsService {
+    private readonly root;
+    private readonly state;
+    private readonly validation;
+    private readonly extraHandlers;
+    private readonly _loadingActions;
+    private readonly _pendingConfirmation;
+    /** Names of actions currently executing. */
+    readonly loadingActions: Signal<ReadonlySet<string>>;
+    /** The confirmation currently awaiting user input, if any. */
+    readonly pendingConfirmation: Signal<PendingConfirmation | null>;
+    /** All registered handlers (host handlers + runtime registrations). */
+    get handlers(): Record<string, ActionHandler>;
+    /** Register an additional action handler at runtime. */
+    registerHandler(name: string, handler: ActionHandler): void;
+    /** Execute an action binding. */
+    execute(binding: ActionBinding): Promise<void>;
+    /** Confirm the pending confirmation dialog. */
+    confirm(): void;
+    /** Cancel the pending confirmation dialog. */
+    cancel(): void;
+    private lookupHandler;
+    private runHandler;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<JsonRenderActionsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<JsonRenderActionsService>;
+}
+/** Inject the actions service of the nearest `<json-render>` renderer. */
+declare function injectActions(): JsonRenderActionsService;
+/**
+ * Convenience helper for executing a fixed action binding, mirroring
+ * `useAction` from the other renderers.
+ */
+declare function injectAction(binding: ActionBinding): {
+    execute: () => Promise<void>;
+    isLoading: Signal<boolean>;
+};
+
+/**
+ * State setter function for updating application state.
+ * Matches the `SetState` contract of the other json-render renderers
+ * (React/Vue/Solid): an updater receives the previous state object and
+ * returns the next one.
+ */
+type SetState = (updater: (prev: Record<string, unknown>) => Record<string, unknown>) => void;
+/** A single state change notification (JSON Pointer path + new value). */
+interface StateChange {
+    path: string;
+    value: unknown;
+}
+/**
+ * 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 = ctx.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;
+}
+/**
+ * Context available to catalog components via `injectRenderContext()`.
+ *
+ * This is the Angular equivalent of the render props that the React/Vue/Solid
+ * renderers pass to registered components: resolved props, event emitters,
+ * two-way binding paths, and the loading flag — exposed as signals so catalog
+ * components stay fine-grained reactive while the spec streams in.
+ */
+interface RenderContext<P = Record<string, unknown>> {
+    /** The element being rendered, with all prop expressions resolved. */
+    element: Signal<UIElement<string, P>>;
+    /** Resolved component props (shortcut for `element().props`). */
+    props: Signal<P>;
+    /**
+     * Emit a named event. The renderer resolves the event to action binding(s)
+     * from the element's `on` field.
+     */
+    emit: (event: string) => void;
+    /** Get an event handle with metadata (shouldPreventDefault, bound). */
+    on: (event: string) => EventHandle;
+    /**
+     * Two-way binding paths resolved from `$bindState` / `$bindItem`
+     * expressions. Maps prop name → absolute state path for write-back.
+     * `undefined` when no prop uses a binding expression.
+     */
+    bindings: Signal<Record<string, string> | undefined>;
+    /** Whether the spec is currently loading/streaming. */
+    loading: Signal<boolean>;
+    /**
+     * Write a value back to the state path bound to the given prop.
+     * No-op (with a dev warning) when the prop has no `$bindState`/`$bindItem`
+     * binding.
+     */
+    setBound: (prop: string, value: unknown) => void;
+}
+/**
+ * A registry entry: the Angular component to render for a catalog component
+ * type, plus optional slot metadata used for dev-mode warnings.
+ */
+interface RegistryEntry {
+    component: Type<unknown>;
+    /** Slot names this component supports (from the catalog definition). */
+    slots?: string[];
+}
+/**
+ * Registry of component renderers: catalog type name → Angular component
+ * (or a {@link RegistryEntry} carrying slot metadata).
+ */
+type ComponentRegistry = Record<string, Type<unknown> | RegistryEntry>;
+/**
+ * Registry of all Angular components for a catalog. Keys are checked against
+ * the catalog's component names.
+ */
+type Components<C extends Catalog> = {
+    [K in keyof InferCatalogComponents<C>]: Type<unknown>;
+};
+/**
+ * The repeat scope available to elements rendered inside a `repeat` block.
+ * Injected via {@link injectRepeatScope}.
+ */
+interface RepeatScope {
+    /** The current repeat item. */
+    item: Signal<unknown>;
+    /** The current repeat array index. */
+    index: Signal<number>;
+    /** Absolute state path of the current item (e.g. `/todos/0`). */
+    basePath: Signal<string>;
+}
+/**
+ * Action handler function type for {@link defineRegistry}.
+ *
+ * @example
+ * ```ts
+ * const viewCustomers: ActionFn<typeof catalog, 'viewCustomers'> = async (params, setState) => {
+ *   const data = await fetch('/api/customers').then((r) => r.json());
+ *   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. */
+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;
+
+/**
+ * The state store of a `<json-render>` subtree.
+ *
+ * Wraps a core {@link StateStore} (either the internal in-memory store in
+ * uncontrolled mode, or an external store passed via the `store` input) and
+ * exposes the current state model as a signal.
+ *
+ * Inject it from catalog components or action handlers via
+ * {@link injectStateStore}.
+ */
+declare class JsonRenderStateService {
+    private readonly root;
+    private readonly internalStore;
+    private readonly changeListeners;
+    private readonly _state;
+    /** The current state model as a signal. */
+    readonly state: Signal<StateModel>;
+    private readonly currentStore;
+    constructor();
+    /** Read a value by JSON Pointer path from the current state. */
+    get(path: string): unknown;
+    /** Write a value by JSON Pointer path and notify subscribers. */
+    set(path: string, value: unknown): void;
+    /** Write multiple values at once (single notification). */
+    update(updates: Record<string, unknown>): void;
+    /** Return the full state object (non-reactive read). */
+    getSnapshot(): StateModel;
+    /**
+     * Register a listener called with the list of changed paths whenever state
+     * is written through this service (element `watch` fields rely on this).
+     * Returns an unsubscribe function.
+     */
+    subscribeChanges(listener: (changes: StateChange[]) => void): () => void;
+    private notifyChanges;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<JsonRenderStateService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<JsonRenderStateService>;
+}
+/**
+ * Inject the state store of the nearest `<json-render>` renderer.
+ * Must be called from within the renderer's subtree (e.g. a catalog
+ * component) or a component that provides {@link JsonRenderStateService}.
+ */
+declare function injectStateStore(): JsonRenderStateService;
+/** Reactive read of a state value by JSON Pointer path. */
+declare function injectStateValue<T>(path: string | (() => string)): Signal<T | undefined>;
+/**
+ * Reactive two-way binding to a state path: a value signal plus a setter
+ * that writes back to the same path.
+ */
+declare function injectStateBinding<T>(path: string | (() => string)): {
+    value: Signal<T | undefined>;
+    set: (value: T) => void;
+};
+/**
+ * Two-way bound prop helper for catalog components, mirroring `useBoundProp`
+ * from the other renderers: the value comes from the already-resolved prop,
+ * and the setter writes back to the bound state path (no-op if not bound).
+ *
+ * @example
+ * ```ts
+ * const ctx = injectRenderContext<{ value?: string }>();
+ * const bound = injectBoundProp<string>(
+ *   () => ctx.props().value,
+ *   () => ctx.bindings()?.['value'],
+ * );
+ * // template: <input [value]="bound.value() ?? ''" (input)="bound.set($any($event.target).value)" />
+ * ```
+ */
+declare function injectBoundProp<T>(propValue: () => T | undefined, bindingPath: () => string | undefined): {
+    value: Signal<T | undefined>;
+    set: (value: T) => void;
+};
+
+/**
+ * Renders a json-render {@link Spec} using a registry of Angular components.
+ *
+ * The renderer owns the state store, action dispatcher, and validation state
+ * of its subtree (all injectable from catalog components). Pass an external
+ * {@link StateStore} via `store` for controlled mode or to share state across
+ * renderers.
+ *
+ * @example
+ * ```html
+ * <json-render
+ *   [spec]="spec()"
+ *   [registry]="registry"
+ *   [handlers]="handlers"
+ *   [loading]="isStreaming()"
+ *   (stateChange)="onStateChange($event)"
+ * />
+ * ```
+ */
+declare class JsonRenderer {
+    /** The UI spec to render (may be partial while streaming). */
+    readonly spec: _angular_core.InputSignal<Spec | null>;
+    /** Component registry mapping catalog type names to Angular components. */
+    readonly registry: _angular_core.InputSignal<ComponentRegistry>;
+    /** Whether the spec is currently loading/streaming. */
+    readonly loading: _angular_core.InputSignal<boolean>;
+    /** Fallback component for unknown types. */
+    readonly fallback: _angular_core.InputSignal<RegistryEntry | Type<unknown> | null>;
+    /**
+     * Initial state model (uncontrolled mode). Defaults to `spec.state`.
+     * Ignored when `store` is provided.
+     */
+    readonly state: _angular_core.InputSignal<StateModel | undefined>;
+    /** External state store (controlled mode). */
+    readonly store: _angular_core.InputSignal<StateStore | null>;
+    /** Action handlers by action name. */
+    readonly handlers: _angular_core.InputSignal<Record<string, ActionHandler> | undefined>;
+    /** Catch-all action handler for actions without a dedicated handler. */
+    readonly onAction: _angular_core.InputSignal<((name: string, params?: Record<string, unknown>) => unknown) | null>;
+    /** Navigation function used by `onSuccess: { navigate }` handlers. */
+    readonly navigate: _angular_core.InputSignal<((path: string) => void) | null>;
+    /** Custom validation functions. */
+    readonly validationFunctions: _angular_core.InputSignal<Record<string, ValidationFunction> | undefined>;
+    /** Named functions for `$computed` expressions in props. */
+    readonly functions: _angular_core.InputSignal<Record<string, ComputedFunction> | undefined>;
+    /** Custom directives for user-defined `$`-prefixed dynamic values. */
+    readonly directives: _angular_core.InputSignal<DirectiveDefinition<zod.ZodType<unknown, unknown, zod_v4_core.$ZodTypeInternals<unknown, unknown>>>[] | undefined>;
+    /** Emits state changes in uncontrolled mode. */
+    readonly stateChange: _angular_core.OutputEmitterRef<StateChange[]>;
+    /** The state store of this renderer (also injectable in the subtree). */
+    readonly stateStore: JsonRenderStateService;
+    /** The action dispatcher of this renderer. */
+    protected readonly actions: JsonRenderActionsService;
+    constructor();
+    protected readonly rootKey: _angular_core.Signal<string | null>;
+    protected readonly pendingConfirm: _angular_core.Signal<_json_render_core.ActionConfirm | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<JsonRenderer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<JsonRenderer, "json-render", never, { "spec": { "alias": "spec"; "required": true; "isSignal": true; }; "registry": { "alias": "registry"; "required": true; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "fallback": { "alias": "fallback"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "store": { "alias": "store"; "required": false; "isSignal": true; }; "handlers": { "alias": "handlers"; "required": false; "isSignal": true; }; "onAction": { "alias": "onAction"; "required": false; "isSignal": true; }; "navigate": { "alias": "navigate"; "required": false; "isSignal": true; }; "validationFunctions": { "alias": "validationFunctions"; "required": false; "isSignal": true; }; "functions": { "alias": "functions"; "required": false; "isSignal": true; }; "directives": { "alias": "directives"; "required": false; "isSignal": true; }; }, { "stateChange": "stateChange"; }, never, never, true, never>;
+}
+
+/**
+ * Renders the children of the current element. Place it inside a catalog
+ * component's template where nested content should appear — like a
+ * `<router-outlet>` for the spec tree.
+ *
+ * - Default (no `slot`): renders `element.children`, honoring the element's
+ *   `repeat` field (one pass per item of the referenced state array, with the
+ *   proper repeat scope for `$item` / `$index` / `$bindItem` expressions).
+ * - With `slot`: renders the element keys of `element.slots[slot]`.
+ *
+ * @example
+ * ```html
+ * <div class="card">
+ *   <h3>{{ ctx.props().title }}</h3>
+ *   <jr-children />
+ * </div>
+ * ```
+ */
+declare class JrChildren {
+    /** Named slot to render instead of the default children. */
+    readonly slot: _angular_core.InputSignal<string | null>;
+    private readonly ctx;
+    private readonly root;
+    private readonly state;
+    private readonly parentScope;
+    protected readonly childKeys: _angular_core.Signal<string[]>;
+    protected readonly repeat: _angular_core.Signal<{
+        statePath: _json_render_core.RepeatStatePath;
+        key?: string;
+    } | undefined>;
+    private readonly repeatBasePath;
+    protected readonly repeatItems: _angular_core.Signal<unknown[]>;
+    constructor();
+    protected itemPath(index: number): string;
+    protected trackItem(index: number, item: unknown): unknown;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<JrChildren, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<JrChildren, "jr-children", never, { "slot": { "alias": "slot"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Renders a single spec element: evaluates visibility, resolves prop
+ * expressions against the state model, wires event/watch bindings, and
+ * instantiates the catalog component with a {@link RenderContext} injector.
+ *
+ * @internal Used by `<json-render>` and `<jr-children>`.
+ */
+declare class JrElement {
+    readonly elementKey: _angular_core.InputSignal<string>;
+    private readonly root;
+    private readonly state;
+    private readonly actions;
+    private readonly repeatScope;
+    private readonly devtoolsActive;
+    /** The raw (unresolved) element from the spec. */
+    readonly rawElement: Signal<UIElement<string, Record<string, unknown>> | undefined>;
+    /** Prop/visibility resolution context (state + repeat scope + extensions). */
+    private readonly resolutionCtx;
+    protected readonly visible: Signal<boolean>;
+    /** The element with all prop expressions resolved. */
+    readonly resolvedElement: Signal<UIElement<string, Record<string, unknown>> | undefined>;
+    /** Two-way binding paths ($bindState / $bindItem) by prop name. */
+    readonly bindings: Signal<Record<string, string> | undefined>;
+    private readonly entry;
+    protected readonly component: Signal<_angular_core.Type<unknown> | null>;
+    protected readonly devtoolsKey: Signal<string | null>;
+    private readonly renderCtx;
+    protected readonly outletInjector: _angular_core.DestroyableInjector;
+    constructor();
+    /**
+     * Resolution context with a live state snapshot, so `$state` references in
+     * later actions of a chain see mutations from earlier ones.
+     */
+    private liveResolutionCtx;
+    private emitEvent;
+    private eventHandle;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<JrElement, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<JrElement, "jr-element", never, { "elementKey": { "alias": "elementKey"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Provides the repeat scope (item, index, absolute base path) to the elements
+ * rendered inside a `repeat` block.
+ *
+ * @internal Used by `<jr-children>`; not intended for direct use.
+ */
+declare class JrRepeatScope implements RepeatScope {
+    readonly item: _angular_core.InputSignal<unknown>;
+    readonly index: _angular_core.InputSignal<number>;
+    readonly basePath: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<JrRepeatScope, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<JrRepeatScope, "jr-repeat-scope", never, { "item": { "alias": "item"; "required": true; "isSignal": true; }; "index": { "alias": "index"; "required": true; "isSignal": true; }; "basePath": { "alias": "basePath"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Default confirmation dialog shown for action bindings with a `confirm`
+ * field. Rendered automatically by `<json-render>`; can also be used
+ * standalone with a custom action flow.
+ */
+declare class JrConfirmDialog {
+    readonly config: _angular_core.InputSignal<ActionConfirm>;
+    readonly confirmed: _angular_core.OutputEmitterRef<void>;
+    readonly cancelled: _angular_core.OutputEmitterRef<void>;
+    protected readonly isDanger: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<JrConfirmDialog, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<JrConfirmDialog, "jr-confirm-dialog", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "confirmed": "confirmed"; "cancelled": "cancelled"; }, never, never, true, never>;
+}
+
+/**
+ * The render context of the element currently being rendered.
+ * Provided by the renderer for every catalog component instance.
+ */
+declare const RENDER_CONTEXT: InjectionToken<RenderContext<Record<string, unknown>>>;
+/**
+ * The current repeat scope. Present only for elements rendered inside a
+ * `repeat` block.
+ */
+declare const REPEAT_SCOPE: InjectionToken<RepeatScope>;
+/**
+ * Inject the render context inside a catalog component.
+ *
+ * @example
+ * ```ts
+ * @Component({
+ *   selector: 'app-button',
+ *   template: `<button (click)="ctx.emit('press')">{{ ctx.props().label }}</button>`,
+ * })
+ * export class ButtonComponent {
+ *   readonly ctx = injectRenderContext<{ label: string }>();
+ * }
+ * ```
+ */
+declare function injectRenderContext<P = Record<string, unknown>>(): RenderContext<P>;
+/**
+ * Inject the current repeat scope, or `null` when the component is not
+ * rendered inside a `repeat` block.
+ */
+declare function injectRepeatScope(): RepeatScope | null;
+
+/**
+ * Internal bridge between the `<json-render>` component's inputs and the
+ * renderer services / element tree. The renderer component replaces these
+ * signal references with its own input signals at construction time.
+ *
+ * @internal
+ */
+declare class JsonRenderRootContext {
+    spec: Signal<Spec | null | undefined>;
+    registry: Signal<ComponentRegistry | undefined>;
+    loading: Signal<boolean>;
+    fallback: Signal<Type<unknown> | RegistryEntry | null | undefined>;
+    /** External store (controlled mode). */
+    store: Signal<StateStore | null | undefined>;
+    /** Initial state (uncontrolled mode); falls back to `spec.state`. */
+    initialState: Signal<StateModel>;
+    handlers: Signal<Record<string, ActionHandler> | undefined>;
+    onAction: Signal<((name: string, params?: Record<string, unknown>) => unknown) | null | undefined>;
+    navigate: Signal<((path: string) => void) | null | undefined>;
+    validationFunctions: Signal<Record<string, ValidationFunction> | undefined>;
+    functions: Signal<Record<string, ComputedFunction> | undefined>;
+    directiveRegistry: Signal<DirectiveRegistry | undefined>;
+    /** Emits uncontrolled-mode state changes to the renderer output. */
+    emitStateChange: (changes: StateChange[]) => void;
+    /** Resolve a registry entry (component + slot metadata) for a type. */
+    resolveEntry(type: string): RegistryEntry | undefined;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<JsonRenderRootContext, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<JsonRenderRootContext>;
+}
+
+interface FieldValidationState {
+    touched: boolean;
+    validated: boolean;
+    result: ValidationResult | null;
+}
+/**
+ * Form validation state of a `<json-render>` subtree. Fields register their
+ * {@link ValidationConfig}; the built-in `validateForm` action validates all
+ * registered fields and writes the result to state.
+ */
+declare class JsonRenderValidationService {
+    private readonly root;
+    private readonly state;
+    private readonly _fieldStates;
+    private readonly _fieldConfigs;
+    /** Validation state per registered field path. */
+    readonly fieldStates: Signal<Record<string, FieldValidationState>>;
+    get customFunctions(): Record<string, ValidationFunction>;
+    /** Register (or update) a field's validation config. */
+    registerField(path: string, config: ValidationConfig): void;
+    /** Validate a single field and record the result. */
+    validate(path: string, config: ValidationConfig): ValidationResult;
+    /** Mark a field as touched. */
+    touch(path: string): void;
+    /** Clear a field's validation state. */
+    clear(path: string): void;
+    /** Validate all registered fields. Returns whether all are valid. */
+    validateAll(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<JsonRenderValidationService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<JsonRenderValidationService>;
+}
+/** Inject the validation service of the nearest `<json-render>` renderer. */
+declare function injectValidation(): JsonRenderValidationService;
+/**
+ * Field-level validation helper for catalog input components: registers the
+ * config and exposes the field's validation state as signals.
+ */
+declare function injectFieldValidation(path: string | (() => string), config?: ValidationConfig | (() => ValidationConfig | undefined)): {
+    state: Signal<FieldValidationState>;
+    validate: () => ValidationResult;
+    touch: () => void;
+    clear: () => void;
+    errors: Signal<string[]>;
+    isValid: Signal<boolean>;
+};
+
+/**
+ * Result returned by {@link defineRegistry}.
+ */
+interface DefineRegistryResult {
+    /** Component registry for `<json-render [registry]="...">`. */
+    registry: ComponentRegistry;
+    /**
+     * Create renderer-compatible handlers from the catalog actions.
+     * Accepts getter functions so handlers always read the latest
+     * state/setState.
+     */
+    handlers: (getSetState: () => SetState | undefined, getState: () => StateModel) => Record<string, (params: Record<string, unknown>) => Promise<void>>;
+    /**
+     * Execute an action by name imperatively
+     * (for use outside the renderer tree, e.g. initial state loading).
+     */
+    executeAction: (actionName: string, params: Record<string, unknown> | undefined, setState: SetState, state?: StateModel) => Promise<void>;
+}
+/**
+ * Options for defineRegistry.
+ *
+ * When the catalog declares actions, the `actions` field is required.
+ * When the catalog has no actions (or `actions: {}`), the field is optional.
+ */
+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.
+ *
+ * Component keys are type-checked against the catalog, and slot metadata from
+ * the catalog is carried into the registry for dev-mode slot warnings.
+ *
+ * @example
+ * ```ts
+ * const { registry, handlers } = defineRegistry(catalog, {
+ *   components: { Card: CardComponent, Button: ButtonComponent },
+ *   actions: {
+ *     refresh: async (params, setState) => {
+ *       setState((prev) => ({ ...prev, refreshedAt: Date.now() }));
+ *     },
+ *   },
+ * });
+ * ```
+ */
+declare function defineRegistry<C extends Catalog>(catalog: C, options: DefineRegistryOptions<C>): DefineRegistryResult;
+/**
+ * Build a {@link SetState} (whole-state updater) on top of a path-based
+ * store. The updater's result is diffed against the previous state and only
+ * changed leaves are written, preserving fine-grained reactivity.
+ *
+ * Works with both a core {@link StateStore} and the renderer's injected
+ * `JsonRenderStateService`.
+ */
+declare function createStoreSetState(store: Pick<StateStore, 'getSnapshot' | 'update'>): SetState;
+
+/**
+ * Token usage metadata from AI generation.
+ */
+interface TokenUsage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+}
+/**
+ * Apply an RFC 6902 JSON patch to the current spec, returning a new spec
+ * object (structural sharing for untouched elements).
+ * Supports add, remove, replace, move, copy, and test operations.
+ */
+declare function applyPatch(spec: Spec, patch: JsonPatch): Spec;
+/**
+ * Options for {@link injectUIStream}.
+ */
+interface UIStreamOptions {
+    /** API endpoint */
+    api: string;
+    /** Callback when complete */
+    onComplete?: (spec: Spec) => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+}
+/**
+ * Return type for {@link injectUIStream}.
+ */
+interface UIStreamReturn {
+    /** Current UI spec */
+    readonly spec: Signal<Spec | null>;
+    /** Whether currently streaming */
+    readonly isStreaming: Signal<boolean>;
+    /** Error if any */
+    readonly error: Signal<Error | null>;
+    /** Token usage from the last generation */
+    readonly usage: Signal<TokenUsage | null>;
+    /** Raw JSONL lines received from the stream (JSON patch lines) */
+    readonly rawLines: Signal<string[]>;
+    /** Send a prompt to generate UI */
+    send: (prompt: string, context?: Record<string, unknown>) => Promise<void>;
+    /** Clear the current spec */
+    clear: () => void;
+}
+/**
+ * Streaming UI generation. POSTs `{ prompt, context, currentSpec }` to the
+ * endpoint and progressively applies the returned JSONL patch stream to the
+ * `spec` signal, so partial UIs render as they arrive.
+ *
+ * Must be called in an injection context (aborts in-flight requests on
+ * destroy).
+ *
+ * @example
+ * ```ts
+ * export class GeneratePage {
+ *   readonly ui = injectUIStream({ api: '/api/generate' });
+ * }
+ * // template:
+ * // <json-render [spec]="ui.spec()" [registry]="registry" [loading]="ui.isStreaming()" />
+ * ```
+ */
+declare function injectUIStream(options: UIStreamOptions): UIStreamReturn;
+/**
+ * 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;
+/**
+ * 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.
+ */
+interface DataPart {
+    type: string;
+    text?: string;
+    data?: unknown;
+}
+/**
+ * Build a `Spec` by replaying all spec data parts from a message's
+ * parts array (AI SDK `UIMessage.parts`). Returns `null` if no spec data
+ * parts are present.
+ */
+declare function buildSpecFromParts(parts: DataPart[]): Spec | null;
+/**
+ * Extract and join all text content from a message's parts array.
+ */
+declare function getTextFromParts(parts: DataPart[]): string;
+/**
+ * Extract both the json-render spec and the text content from a message's
+ * parts array, as memoized signals. Angular counterpart of
+ * `useJsonRenderMessage` from the other renderers.
+ *
+ * @example
+ * ```ts
+ * readonly msg = jsonRenderMessage(() => this.message().parts);
+ * // template: @if (msg.hasSpec()) { <json-render [spec]="msg.spec()" ... /> }
+ * ```
+ */
+declare function jsonRenderMessage(parts: Signal<DataPart[]> | (() => DataPart[])): {
+    spec: Signal<Spec | null>;
+    text: Signal<string>;
+    hasSpec: Signal<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 {@link injectChatUI}.
+ */
+interface ChatUIOptions {
+    /** 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 {@link injectChatUI}.
+ */
+interface ChatUIReturn {
+    /** All messages in the conversation */
+    readonly messages: Signal<ChatMessage[]>;
+    /** Whether currently streaming an assistant response */
+    readonly isStreaming: Signal<boolean>;
+    /** Error from the last request, if any */
+    readonly error: Signal<Error | null>;
+    /** Send a user message */
+    send: (text: string) => Promise<void>;
+    /** Clear all messages and reset the conversation */
+    clear: () => void;
+}
+/**
+ * Chat + GenUI: manages a multi-turn conversation where each assistant
+ * message can contain both conversational text and a json-render UI spec.
+ * The full message history is sent to the endpoint and the streamed response
+ * is split into text lines and JSONL patch lines.
+ *
+ * Must be called in an injection context.
+ */
+declare function injectChatUI(options: ChatUIOptions): ChatUIReturn;
+
+/**
+ * The schema for ngx-json-render.
+ *
+ * Defines:
+ * - Spec: A flat tree of elements with keys, types, props, and children references
+ * - Catalog: Components with props schemas, and optional actions
+ *
+ * This is the same spec grammar the other json-render renderers use, so
+ * catalogs and specs are portable across frameworks.
+ */
+declare const schema: _json_render_core.Schema<{
+    spec: _json_render_core.SchemaType<"object", {
+        /** Root element key */
+        root: _json_render_core.SchemaType<"string", unknown>;
+        /** Flat map of elements by key */
+        elements: _json_render_core.SchemaType<"record", _json_render_core.SchemaType<"object", {
+            /** Component type from catalog */
+            type: _json_render_core.SchemaType<"ref", string>;
+            /** Component props */
+            props: _json_render_core.SchemaType<"propsOf", string>;
+            /** Child element keys (flat reference) */
+            children: _json_render_core.SchemaType<"array", _json_render_core.SchemaType<"string", unknown>>;
+            /** Visibility condition */
+            visible: {
+                optional: true;
+                kind: "any";
+                inner?: unknown;
+            };
+            /** Repeat children from a state array */
+            repeat: {
+                optional: true;
+                kind: "any";
+                inner?: unknown;
+            };
+        }>>;
+    }>;
+    catalog: _json_render_core.SchemaType<"object", {
+        /** Component definitions */
+        components: _json_render_core.SchemaType<"map", {
+            /** Zod schema for component props */
+            props: _json_render_core.SchemaType<"zod", unknown>;
+            /** Slots for this component. Use ['default'] for children, or named slots like ['header', 'footer'] */
+            slots: _json_render_core.SchemaType<"array", _json_render_core.SchemaType<"string", unknown>>;
+            /** Description for AI generation hints */
+            description: _json_render_core.SchemaType<"string", unknown>;
+            /** Example prop values used in prompt examples (auto-generated from Zod schema if omitted) */
+            example: _json_render_core.SchemaType<"any", unknown>;
+        }>;
+        /** Action definitions (optional) */
+        actions: _json_render_core.SchemaType<"map", {
+            /** Zod schema for action params */
+            params: _json_render_core.SchemaType<"zod", unknown>;
+            /** Description for AI generation hints */
+            description: _json_render_core.SchemaType<"string", unknown>;
+        }>;
+    }>;
+}>;
+/**
+ * Type for the Angular schema
+ */
+type AngularSchema = typeof schema;
+/**
+ * Infer the spec type from a catalog
+ */
+type AngularSpec<TCatalog> = typeof schema extends {
+    createCatalog: (catalog: TCatalog) => {
+        _specType: infer S;
+    };
+} ? S : never;
+
+/**
+ * Reactive mirror of the json-render devtools-active flag. When active, the
+ * renderer wraps each element with a `data-jr-key` attribute for the picker.
+ */
+declare function injectDevtoolsActive(): Signal<boolean>;
+
+export { JrChildren, JrConfirmDialog, JrElement, JrRepeatScope, JsonRenderActionsService, JsonRenderRootContext, JsonRenderStateService, JsonRenderValidationService, JsonRenderer, RENDER_CONTEXT, REPEAT_SCOPE, applyPatch, buildSpecFromParts, createStoreSetState, defineRegistry, flatToTree, getTextFromParts, injectAction, injectActions, injectBoundProp, injectChatUI, injectDevtoolsActive, injectFieldValidation, injectRenderContext, injectRepeatScope, injectStateBinding, injectStateStore, injectStateValue, injectUIStream, injectValidation, jsonRenderMessage, schema };
+export type { ActionFn, Actions, AngularSchema, AngularSpec, CatalogHasActions, ChatMessage, ChatUIOptions, ChatUIReturn, ComponentRegistry, Components, DataPart, DefineRegistryResult, EventHandle, FieldValidationState, PendingConfirmation, RegistryEntry, RenderContext, RepeatScope, SetState, StateChange, TokenUsage, UIStreamOptions, UIStreamReturn };