@dou-ui/form-builder 0.0.0-stage → 0.1.0-alpha.0

package/dist/types/core/values.d.ts

@@ -0,0 +1,22 @@
+import type { FormFunction } from './expression';
+import type { FormDocument, FormFieldNode, FormListNode, FormNode } from './types';
+import type { FormFieldType } from '../fields/define';
+/** The value a field starts with: its own default, else its type's empty value. */
+export declare function startValue(type: FormFieldType, node: FormFieldNode): unknown;
+/** A new item of a list, every field at its starting value. */
+export declare function emptyItem(list: FormListNode, types: Map<string, FormFieldType>): Record<string, unknown>;
+/**
+ * Give every field of `nodes` that `target` has no value for its starting
+ * value, the items of lists included. Values already there stay.
+ */
+export declare function fillValues(nodes: readonly FormNode[], target: Record<string, unknown>, types: Map<string, FormFieldType>): void;
+export interface VisibleValuesOptions {
+    /** Functions the expressions can call besides the built-in ones. */
+    functions?: Record<string, FormFunction>;
+}
+/**
+ * A copy of the values without the ones of hidden fields: a field, group,
+ * page or list whose `visibleWhen` is false leaves out everything it
+ * holds, item by item inside lists. This is what the renderer submits.
+ */
+export declare function visibleValues(document: FormDocument, model: Record<string, unknown>, options?: VisibleValuesOptions): Record<string, unknown>;

package/dist/types/fields/builtin.d.ts

@@ -0,0 +1,9 @@
+import type { FormFieldType } from './define';
+/**
+ * The field types every renderer and builder knows. Each one is named
+ * after the component it renders, in kebab case without the `Dou`
+ * prefix: `input-number` renders `DouInputNumber`.
+ */
+export declare const builtinFields: FormFieldType<any>[];
+/** The built-in types, then `extra` on top: a type of the same name replaces the built-in one. */
+export declare function resolveFields(extra?: readonly FormFieldType<any>[]): Map<string, FormFieldType<import("./define").FormFieldProps>>;

package/dist/types/fields/components.d.ts

@@ -0,0 +1,177 @@
+import type { PropType } from 'vue';
+import type { CheckboxValue, RadioValue, Tone } from 'dou-ui';
+/** A choice as written in a document: a plain value is both value and label. */
+export type FormOption = string | number | {
+    value: string | number | boolean;
+    label?: string;
+    disabled?: boolean;
+};
+export declare function normalizeOptions(options: readonly FormOption[] | undefined): {
+    value: string | number | boolean;
+    label: string;
+    disabled: boolean | undefined;
+}[];
+/** One choice out of a few, all in view. */
+export declare const RadioField: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: PropType<RadioValue>;
+        default: undefined;
+    };
+    options: {
+        type: PropType<FormOption[]>;
+        default: () => never[];
+    };
+    direction: {
+        type: PropType<"horizontal" | "vertical">;
+        default: string;
+    };
+    disabled: BooleanConstructor;
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    'update:modelValue': (_value: RadioValue) => true;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: PropType<RadioValue>;
+        default: undefined;
+    };
+    options: {
+        type: PropType<FormOption[]>;
+        default: () => never[];
+    };
+    direction: {
+        type: PropType<"horizontal" | "vertical">;
+        default: string;
+    };
+    disabled: BooleanConstructor;
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((_value: RadioValue) => any) | undefined;
+}>, {
+    modelValue: RadioValue;
+    options: FormOption[];
+    direction: "vertical" | "horizontal";
+    disabled: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+/** Any number of choices out of a few, all in view. */
+export declare const CheckboxGroupField: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: PropType<CheckboxValue[]>;
+        default: undefined;
+    };
+    options: {
+        type: PropType<FormOption[]>;
+        default: () => never[];
+    };
+    direction: {
+        type: PropType<"horizontal" | "vertical">;
+        default: string;
+    };
+    disabled: BooleanConstructor;
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    'update:modelValue': (_value: CheckboxValue[]) => true;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: PropType<CheckboxValue[]>;
+        default: undefined;
+    };
+    options: {
+        type: PropType<FormOption[]>;
+        default: () => never[];
+    };
+    direction: {
+        type: PropType<"horizontal" | "vertical">;
+        default: string;
+    };
+    disabled: BooleanConstructor;
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((_value: CheckboxValue[]) => any) | undefined;
+}>, {
+    modelValue: CheckboxValue[];
+    options: FormOption[];
+    direction: "vertical" | "horizontal";
+    disabled: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+/** A single box, e.g. to agree to terms; its text sits beside it. */
+export declare const CheckboxField: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    text: StringConstructor;
+    disabled: BooleanConstructor;
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    'update:modelValue': (_value: boolean) => true;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    text: StringConstructor;
+    disabled: BooleanConstructor;
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((_value: boolean) => any) | undefined;
+}>, {
+    modelValue: boolean;
+    disabled: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+/** A heading or a paragraph between fields. */
+export declare const TextField: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    content: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** `title` for a heading, `body` for a paragraph, `caption` for small print. */
+    variant: {
+        type: PropType<"title" | "body" | "caption">;
+        default: string;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    content: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** `title` for a heading, `body` for a paragraph, `caption` for small print. */
+    variant: {
+        type: PropType<"title" | "body" | "caption">;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    content: string;
+    variant: "body" | "caption" | "title";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const DividerField: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    text: StringConstructor;
+    dashed: BooleanConstructor;
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    text: StringConstructor;
+    dashed: BooleanConstructor;
+}>> & Readonly<{}>, {
+    dashed: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const AlertField: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    tone: {
+        type: PropType<Tone>;
+        default: string;
+    };
+    title: StringConstructor;
+    content: StringConstructor;
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    tone: {
+        type: PropType<Tone>;
+        default: string;
+    };
+    title: StringConstructor;
+    content: StringConstructor;
+}>> & Readonly<{}>, {
+    tone: Tone;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/types/fields/define.d.ts

@@ -0,0 +1,93 @@
+import type { Component, InjectionKey } from 'vue';
+import type { FormFieldNode, FormNode } from '../core/types';
+import type { FormFormatContext } from './format';
+export type FormFieldProps = Record<string, unknown>;
+/**
+ * What a field type is: how it renders, what it starts with, and which
+ * settings it takes. The renderer and the builder share the same list.
+ */
+export interface FormFieldType<P extends FormFieldProps = FormFieldProps> {
+    /** The name nodes refer to it by in `type`. A type of the same name as a built-in one replaces it. */
+    type: string;
+    /** Shown to people building the form. */
+    label?: string;
+    /**
+     * - `value`: holds a value at the node's `name`, wrapped in a form item
+     *   with its label, help and checks.
+     * - `display`: only shows something, such as text or a divider.
+     */
+    kind?: 'value' | 'display';
+    /** Settings a node starts with, below its own `props`. */
+    defaultProps?: Partial<P>;
+    /**
+     * The type's empty value, which a field starts with when its node sets
+     * no `default`, e.g. `[]` for a list of choices. Defaults to `null`.
+     */
+    empty?: (props: P) => unknown;
+    /**
+     * Renders the field. A `value` field gets `modelValue`, listens to
+     * `update:modelValue`, and receives the settings as props (after
+     * `toProps`). Call `useFormField()` inside it for the node itself.
+     */
+    component: Component;
+    /**
+     * The prop that takes the list of options, for a type whose options can
+     * come from a source (a node's `source`), e.g. `options` or `data`.
+     */
+    optionsProp?: string;
+    /**
+     * Narrows a value to what new options offer, e.g. drops a city once the
+     * province changes. Called when a source loads different options; the
+     * value stays as it is when the type has none.
+     */
+    fitValue?: (value: unknown, options: readonly unknown[]) => unknown;
+    /**
+     * The value as text, for a renderer that is `readonly`. Gets the
+     * settings (with options loaded from a source). Not called for an empty
+     * value, which shows as the renderer's `noValue` text. Defaults to the
+     * labels of the chosen options for a type with `optionsProp`, else to
+     * the value as plain text: lists joined, booleans as yes and no.
+     */
+    format?: (value: unknown, props: P, context: FormFormatContext) => string;
+    /**
+     * Shows the value in a `readonly` renderer instead of `format`'s text,
+     * e.g. a swatch for a color. Gets `modelValue` and the same props as
+     * `component`, and `readonly` when it takes one.
+     */
+    readonlyComponent?: Component;
+    /** Turns the settings into the component's props, when they differ. */
+    toProps?: (props: P, node: FormFieldNode) => Record<string, unknown>;
+    /** The builder's palette: the type's icon, e.g. one of `@dou-ui/icons`. */
+    icon?: Component;
+    /**
+     * The palette group the type is listed in: `input`, `choice`, `more`
+     * (the default), `display`, or a name of your own, shown as it is.
+     */
+    group?: string;
+    /**
+     * The settings the builder's inspector shows for the type, as nodes of
+     * a form whose values are the node's `props`: a field named
+     * `placeholder` edits `props.placeholder`, and expressions read the
+     * other settings as `values`. A setting left at its `default` is not
+     * written to the node.
+     */
+    settings?: FormNode[];
+}
+/** Declare a field type. Gives the spec its types and leaves it as is otherwise. */
+export declare function defineFormField<P extends FormFieldProps = FormFieldProps>(spec: FormFieldType<P>): FormFieldType<P>;
+/** Settings of a node: its type's `defaultProps` with its own `props` on top. */
+export declare function fieldProps(type: FormFieldType | undefined, node: FormFieldNode): FormFieldProps;
+export interface FormFieldContext {
+    /** The node being rendered. */
+    node: FormFieldNode;
+    /** Its type. */
+    type: FormFieldType;
+    /** Its settings, with the type's `defaultProps` filled in. */
+    props: FormFieldProps;
+}
+export declare const formFieldKey: InjectionKey<() => FormFieldContext>;
+/**
+ * Inside a field type's component: the node it renders, its type and
+ * settings. The properties stay current when the node changes.
+ */
+export declare function useFormField(): Readonly<FormFieldContext>;

package/dist/types/fields/format.d.ts

@@ -0,0 +1,76 @@
+import type { PropType } from 'vue';
+import type { Locale } from 'dou-ui';
+import type { FormFieldNode } from '../core/types';
+import type { FormRendererMessages } from '../locale';
+/** What a field type's `format` gets besides the value and the settings. */
+export interface FormFormatContext {
+    /** The node being shown. */
+    node: FormFieldNode;
+    /** The renderer's texts, e.g. `yes` and `no`. */
+    messages: FormRendererMessages;
+    /** DouUI's current locale, e.g. for its date patterns. */
+    locale: Locale;
+}
+/** Plain text of any value: lists joined, `true` and `false` as yes and no. */
+export declare function formatValue(value: unknown, context: FormFormatContext): string;
+/** The labels of the chosen options, from the setting that holds them (`options` by default). */
+export declare const formatOptions: (prop?: string) => (value: unknown, props: Record<string, unknown>, context: FormFormatContext) => string;
+/**
+ * A path through levels of options as their labels, or a list of such
+ * paths; only the last label with `showLastOnly`, as the cascader shows it.
+ */
+export declare function formatPath(value: unknown, props: Record<string, unknown>, context: FormFormatContext): string;
+/** A switch or a single box: yes or no, by its `checkedValue` when it has one. */
+export declare function formatToggle(value: unknown, props: Record<string, unknown>, context: FormFormatContext): string;
+/** Text typed into an input, hidden for a password. */
+export declare function formatText(value: unknown, props: Record<string, unknown>): string;
+/** A number, with `precision` decimals when it sets them. */
+export declare function formatNumber(value: unknown, props: Record<string, unknown>): string;
+/** One number or time, or both ends of a range. */
+export declare function formatRange(value: unknown, _props: Record<string, unknown>, context: FormFormatContext): string;
+/** A date written the way the date picker writes it (`displayFormat`, else the locale's); a range as both ends. */
+export declare function formatDate(value: unknown, props: Record<string, unknown>, context: FormFormatContext): string;
+/** A color, with a swatch before its text. */
+export declare const ColorValue: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: PropType<string | null>;
+        default: null;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: PropType<string | null>;
+        default: null;
+    };
+}>> & Readonly<{}>, {
+    modelValue: string | null;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+/** Uploaded files, each a link when it has a `url`. */
+export declare const FilesValue: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: PropType<{
+            uid?: string;
+            name: string;
+            url?: string;
+        }[]>;
+        default: () => never[];
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: PropType<{
+            uid?: string;
+            name: string;
+            url?: string;
+        }[]>;
+        default: () => never[];
+    };
+}>> & Readonly<{}>, {
+    modelValue: {
+        uid?: string;
+        name: string;
+        url?: string;
+    }[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/types/fields/options.d.ts

@@ -0,0 +1,11 @@
+/**
+ * A value narrowed to what the options offer: a single value the options
+ * lack becomes `null`, and a list keeps only the items they have. The
+ * same value comes back when nothing is lost.
+ */
+export declare function fitToOptions(value: unknown, options: readonly unknown[]): unknown;
+/**
+ * Like `fitToOptions`, for a value that is a path through levels of
+ * options, or a list of such paths.
+ */
+export declare function fitPathToOptions(value: unknown, options: readonly unknown[]): unknown;

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './renderer';
+export * from './builder';
+export { default } from './renderer';

package/dist/types/locale.d.ts

@@ -0,0 +1,45 @@
+import type { MaybeRefOrGetter } from 'vue';
+import type { ExpressionProblem } from './core/expression';
+import type { DocumentProblem } from './core/check';
+export interface FormRendererMessages {
+    /** Buttons of `steps`. */
+    prev: string;
+    next: string;
+    /** Names the page of `steps` that shows, read out when Back or Next goes to it: `{index}`, `{count}`, `{title}`. */
+    step: string;
+    /** The add button of a list, unless the list sets `addText`. */
+    add: string;
+    /** The remove button of a list item, read out: `{index}` counts from 1. */
+    remove: string;
+    /** The drag handle of a list item, read out: `{index}`. */
+    move: string;
+    /** Names a list item: `{index}`. */
+    item: string;
+    /** Shown in a list without items. */
+    empty: string;
+    /** Read out after the title of a tab whose fields have errors. */
+    invalid: string;
+    /** What a `readonly` renderer shows for a field without a value. */
+    noValue: string;
+    /** A `readonly` renderer's text for `true`, e.g. a switch that is on. */
+    yes: string;
+    /** A `readonly` renderer's text for `false`. */
+    no: string;
+    /** Between the items of a list of values in a `readonly` renderer. */
+    separator: string;
+    /** Between both ends of a range of dates, times or numbers in a `readonly` renderer. */
+    rangeSeparator: string;
+    /** What an editor shows for each problem of an expression; `{text}` is the source at fault. */
+    expression: Record<ExpressionProblem['code'], string>;
+    /** What an editor shows for each problem of a document; `{text}` is the id, name or type at fault. */
+    document: Record<DocumentProblem['code'], string>;
+}
+export declare const formRendererLocales: Record<string, FormRendererMessages>;
+/** Texts to change; the `expression` and `document` groups are merged, so only the ones given are replaced. */
+export type FormRendererMessagesOverride = {
+    [K in keyof FormRendererMessages]?: FormRendererMessages[K] extends string ? string : Partial<FormRendererMessages[K]>;
+};
+/** The form builder's texts, picked by the name of DouUI's current locale. */
+export declare function useFormRendererMessages(override?: MaybeRefOrGetter<FormRendererMessagesOverride | undefined>): import("vue").ComputedRef<FormRendererMessages>;
+/** Fills `{name}` placeholders. */
+export declare const formatMessage: (text: string, params: Record<string, string | number>) => string;

package/dist/types/renderer/containers.d.ts

@@ -0,0 +1,20 @@
+import type { FormNode } from '../core/types';
+import type { NodeScope, RendererContext } from './context';
+import type { Condition, NodeKit, NodeProps } from './context';
+type Flag = {
+    readonly value: boolean;
+};
+/** Whether a field at `path` sits among `nodes`, inside a list item included. */
+export declare function holdsPath(nodes: readonly FormNode[], path: string, prefix?: string): boolean;
+/** The paths of every field among `nodes`, the fields of each list item included. */
+export declare function valuePaths(nodes: readonly FormNode[], model: unknown, prefix?: string): string[];
+export declare function tabsView(kit: NodeKit, props: NodeProps, renderer: RendererContext, scope: NodeScope, disabled: Flag, condition: Condition): () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+export declare function stepsView(kit: NodeKit, props: NodeProps, renderer: RendererContext, scope: NodeScope, disabled: Flag, condition: Condition): () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+export declare function listView(kit: NodeKit, props: NodeProps, renderer: RendererContext, scope: NodeScope, disabled: Flag): () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+export {};

package/dist/types/renderer/context.d.ts

@@ -0,0 +1,186 @@
+import type { Component, InjectionKey, VNode } from 'vue';
+import type { FormErrors, FormModel, FormRules, FormValidateResult } from 'dou-ui';
+import type { FormRendererMessages, FormRendererMessagesOverride } from '../locale';
+import type { FormFieldType } from '../fields/define';
+import type { FormDocument, FormNode, FormValidator } from '../core/types';
+import type { FormFunction } from '../core/expression';
+export interface FormRendererProps {
+    /** The form to render: its fields, groups and layout, as plain data. */
+    form: FormDocument;
+    /**
+     * The object the fields write to, changed in place. Pass a reactive
+     * object to read the values as they change; fields missing from it are
+     * filled with their defaults. Defaults to an object of the renderer's own.
+     */
+    model?: FormModel;
+    /** Field types besides the built-in ones; one of the same name replaces the built-in type. */
+    fields?: FormFieldType<any>[];
+    /** More rules by field name, e.g. checks that need code. Added to the document's own. */
+    rules?: FormRules;
+    /** Disable every field. */
+    disabled?: boolean;
+    /**
+     * Show the values as text instead of fields, e.g. on a detail page or an
+     * approval. Lists show their items without the buttons, steps show every
+     * page one after another, and the model is never written to.
+     */
+    readonly?: boolean;
+    /**
+     * Functions the document's expressions can call besides the built-in
+     * ones, e.g. `{ tax: (price) => price * 0.06 }`. They get plain values
+     * and should not change them; one of the same name replaces a built-in function.
+     */
+    functions?: Record<string, FormFunction>;
+    /**
+     * Where options come from, by the name a node's `source` gives. A source
+     * gets the result of the node's `arg` expression and returns the
+     * options, or a promise of them. Results are kept for each name and
+     * `arg`, so fields asking the same thing share one call. `reloadSource`
+     * forgets them, e.g. after the options changed on the server.
+     */
+    sources?: Record<string, FormOptionsLoader>;
+    /**
+     * Checks that need code, by the name a rule's `validator` gives, e.g. one
+     * asking the server whether a user name is taken. A validator may return
+     * a promise; only the result of the latest check of a field is shown.
+     */
+    validators?: Record<string, FormValidator>;
+    /**
+     * Submit the values of hidden fields too. By default `submit` hands over
+     * a copy of the values without them (see `visibleValues`), so a field
+     * that was filled in and then hidden is not sent.
+     */
+    keepHidden?: boolean;
+    /** Replaces texts of the locale, e.g. the step buttons. */
+    messages?: FormRendererMessagesOverride;
+}
+/** Loads the options of a field, given the result of its `source.arg`. */
+export type FormOptionsLoader = (arg: any) => unknown[] | Promise<unknown[]>;
+export interface FormRendererEmits {
+    /** A field changed its value: its `name`, and the value it now holds. */
+    change: [name: string, value: unknown];
+    /**
+     * The form was submitted and every field passed: a copy of the values,
+     * without the ones of hidden fields unless `keepHidden` is set.
+     */
+    submit: [values: FormModel];
+    /** The form was submitted and some fields failed. */
+    invalid: [errors: Record<string, string>];
+    /** The form was reset to its starting values. */
+    reset: [];
+}
+export interface FormRendererSlots {
+    /**
+     * After the fields, e.g. the submit and reset buttons. In a form that is
+     * a series of steps, on the last step beside the back button.
+     */
+    default?: () => unknown;
+}
+export interface FormRendererExpose {
+    /** The object the fields write to. */
+    readonly model: FormModel;
+    /** Check the given fields, or every field. Never rejects. */
+    validate: (names?: string | string[]) => Promise<FormValidateResult>;
+    /**
+     * Restore the given fields, or every field, to their starting values and
+     * clear their errors. Resetting every field also goes back to the first step.
+     */
+    resetFields: (names?: string | string[]) => void;
+    /** Clear the errors of the given fields, or every field. */
+    clearValidate: (names?: string | string[]) => void;
+    /**
+     * Show errors by field path, e.g. ones a server returned after submit.
+     * Each stays until the field's value changes or it is checked again; an
+     * empty or `undefined` message clears the field's error. Tabs and steps
+     * mark the pages with errors. Returns the paths with a message that no
+     * field shows, e.g. a hidden field's, to list them above the form.
+     */
+    setErrors: (errors: Partial<FormErrors>) => string[];
+    /** Scroll a field into view and focus it. */
+    scrollToField: (name: string) => void;
+    /** Forget the options loaded from a source, or from every source, and load them again. */
+    reloadSource: (name?: string) => void;
+    /** A copy of the values as `submit` hands them over, without hidden fields unless `keepHidden` is set. */
+    getValues: () => FormModel;
+}
+/** What every node of a renderer reads. */
+export interface RendererContext {
+    model: () => FormModel;
+    fields: () => Map<string, FormFieldType>;
+    /** Pixel width of the label column in the horizontal layout, else `undefined`. */
+    labelWidth: () => number | undefined;
+    /** Tell the renderer a field wrote a value. */
+    changed: (name: string, value: unknown) => void;
+    /** The functions expressions can call besides the built-in ones. */
+    functions: () => Record<string, FormFunction> | undefined;
+    /** The validators rules can name. */
+    validators: () => Record<string, FormValidator> | undefined;
+    /** Whether values show as text. */
+    readonly: () => boolean;
+    /** The ids of the formula fields on a circle, which are not worked out. */
+    blockedFormulas: () => ReadonlySet<string>;
+    /**
+     * In a read-only form, a copy of the values with every formula worked
+     * out, which formula fields show; nothing writes the model itself.
+     */
+    settled: () => FormModel;
+    /** Whether the controls are read-only, as in a read-only builder's settings. */
+    controlsReadonly: () => boolean;
+    /** The options from a source, shared by every field asking the same thing. */
+    load: (name: string, arg: unknown) => Promise<unknown[]>;
+    /** Bumped by `reloadSource`, so fields reading it load again. */
+    sourceVersion: (name: string) => number;
+    messages: () => FormRendererMessages;
+    validate: (names: string[]) => Promise<FormValidateResult>;
+    scrollToField: (name: string) => void;
+    /**
+     * Add something that can bring a field into view, e.g. tabs selecting
+     * the page it is on. It says whether it holds the field.
+     */
+    addRevealer: (reveal: (path: string) => boolean) => () => void;
+    /** Follow the error a form item shows, so tabs can mark the pages with errors. */
+    trackError: (path: () => string | undefined, error: () => string | undefined) => () => void;
+    /** The paths of the fields that show an error now. */
+    errorPaths: () => string[];
+    /** The default slot, for the steps that show it on their last step. */
+    footer: () => unknown;
+    /** The id of the steps that show the default slot, if the form is a series of steps. */
+    footerOwner: () => string | undefined;
+    /** Counts the times the whole form was reset, so steps go back to the first one. */
+    resets: () => number;
+}
+/** Where a node sits: inside a list item, its fields' paths start with the item's. */
+export interface NodeScope {
+    /** Put before the names of fields, e.g. `guests.2.`. */
+    prefix: () => string;
+    /** The item, read as `item` by expressions. */
+    item: () => unknown;
+}
+export declare const scopeKey: InjectionKey<NodeScope>;
+export declare const rendererKey: InjectionKey<RendererContext>;
+/**
+ * Internal: renderers inside make their controls read-only (the form's
+ * own `readonly`) instead of showing values as text, e.g. the settings of
+ * a read-only builder.
+ */
+export declare const controlsReadonlyKey: InjectionKey<() => boolean>;
+/** Whether the groups around a node are disabled. */
+export declare const disabledKey: InjectionKey<() => boolean>;
+/** The scope of nodes outside lists. */
+export declare const rootScope: NodeScope;
+/** The full path of a name in a scope. */
+export declare const pathIn: (scope: NodeScope, name: string) => string;
+/** The props of a node's view. */
+export type NodeProps = {
+    node: FormNode;
+    columns: number;
+    inset: number;
+    asPage: boolean;
+};
+/** Runs an expression of a node (the viewed one by default); `fallback` when it is unset or does not parse. */
+export type Condition = (source: string | undefined, fallback: boolean, node?: FormNode) => boolean;
+/** What container views draw their children with, handed in to keep the modules apart. */
+export interface NodeKit {
+    view: Component;
+    renderNodes: (nodes: readonly FormNode[], columns: number, inset?: number) => VNode[];
+}