@astroapps/forms-core 1.0.1

package/TODO.txt

@@ -0,0 +1,3 @@
+* Support formData in jsonata
+* nuances with default value
+* Data grid group

package/lib/controlDefinition.d.ts

@@ -0,0 +1,436 @@
+import { SchemaValidator } from "./schemaValidator";
+import { SchemaField } from "./schemaField";
+import { EntityExpression } from "./entityExpression";
+import { SchemaDataNode } from "./schemaDataNode";
+import { SchemaNode } from "./schemaNode";
+/**
+ * Represents any control definition.
+ */
+export type AnyControlDefinition = DataControlDefinition | GroupedControlsDefinition | ActionControlDefinition | DisplayControlDefinition;
+/**
+ * Represents a control definition.
+ */
+export interface ControlDefinition {
+    type: string;
+    id?: string | null;
+    childRefId?: string | null;
+    title?: string | null;
+    hidden?: boolean | null;
+    styleClass?: string | null;
+    textClass?: string | null;
+    layoutClass?: string | null;
+    labelClass?: string | null;
+    labelTextClass?: string | null;
+    placement?: string | null;
+    dynamic?: DynamicProperty[] | null;
+    adornments?: ControlAdornment[] | null;
+    children?: ControlDefinition[] | null;
+}
+export declare enum ControlDefinitionType {
+    Data = "Data",
+    Group = "Group",
+    Display = "Display",
+    Action = "Action"
+}
+export interface DynamicProperty {
+    type: string;
+    expr: EntityExpression;
+}
+export declare enum DynamicPropertyType {
+    Visible = "Visible",
+    DefaultValue = "DefaultValue",
+    Readonly = "Readonly",
+    Disabled = "Disabled",
+    Display = "Display",
+    Style = "Style",
+    LayoutStyle = "LayoutStyle",
+    AllowedOptions = "AllowedOptions",
+    Label = "Label",
+    ActionData = "ActionData"
+}
+export interface ControlAdornment {
+    type: string;
+}
+export declare enum AdornmentPlacement {
+    ControlStart = "ControlStart",
+    ControlEnd = "ControlEnd",
+    LabelStart = "LabelStart",
+    LabelEnd = "LabelEnd"
+}
+export declare enum ControlAdornmentType {
+    Tooltip = "Tooltip",
+    Accordion = "Accordion",
+    HelpText = "HelpText",
+    Icon = "Icon",
+    SetField = "SetField",
+    Optional = "Optional"
+}
+export declare enum IconLibrary {
+    FontAwesome = "FontAwesome",
+    Material = "Material",
+    CssClass = "CssClass"
+}
+export interface IconReference {
+    library: string;
+    name: string;
+}
+export interface IconAdornment extends ControlAdornment {
+    type: ControlAdornmentType.Icon;
+    iconClass: string;
+    icon?: IconReference;
+    placement?: AdornmentPlacement | null;
+}
+export interface TooltipAdornment extends ControlAdornment {
+    type: ControlAdornmentType.Tooltip;
+    tooltip: string;
+}
+export interface AccordionAdornment extends ControlAdornment {
+    type: ControlAdornmentType.Accordion;
+    title: string;
+    defaultExpanded?: boolean | null;
+}
+export interface HelpTextAdornment extends ControlAdornment {
+    type: ControlAdornmentType.HelpText;
+    helpText: string;
+    placement?: AdornmentPlacement | null;
+}
+export interface SetFieldAdornment extends ControlAdornment {
+    type: ControlAdornmentType.SetField;
+    field: string;
+    defaultOnly?: boolean | null;
+    expression?: EntityExpression;
+}
+export interface OptionalAdornment extends ControlAdornment {
+    type: ControlAdornmentType.Optional;
+    placement?: AdornmentPlacement | null;
+    allowNull?: boolean;
+    editSelectable?: boolean;
+}
+export interface DataControlDefinition extends ControlDefinition {
+    type: ControlDefinitionType.Data;
+    field: string;
+    required?: boolean | null;
+    renderOptions?: RenderOptions | null;
+    defaultValue?: any;
+    readonly?: boolean | null;
+    disabled?: boolean | null;
+    validators?: SchemaValidator[] | null;
+    hideTitle?: boolean | null;
+    dontClearHidden?: boolean | null;
+}
+export interface RenderOptions {
+    type: string;
+}
+export declare enum DataRenderType {
+    Standard = "Standard",
+    Textfield = "Textfield",
+    Radio = "Radio",
+    HtmlEditor = "HtmlEditor",
+    IconList = "IconList",
+    CheckList = "CheckList",
+    UserSelection = "UserSelection",
+    Synchronised = "Synchronised",
+    IconSelector = "IconSelector",
+    DateTime = "DateTime",
+    Checkbox = "Checkbox",
+    Dropdown = "Dropdown",
+    DisplayOnly = "DisplayOnly",
+    Group = "Group",
+    NullToggle = "NullToggle",
+    Autocomplete = "Autocomplete",
+    Jsonata = "Jsonata",
+    Array = "Array",
+    ArrayElement = "ArrayElement",
+    ElementSelected = "ElementSelected"
+}
+export interface TextfieldRenderOptions extends RenderOptions {
+    type: DataRenderType.Textfield;
+    placeholder?: string | null;
+    multiline?: boolean | null;
+}
+export interface AutocompleteRenderOptions extends RenderOptions, AutocompleteClasses {
+    type: DataRenderType.Autocomplete;
+}
+export interface AutocompleteClasses {
+    listContainerClass?: string | null;
+    listEntryClass?: string | null;
+    chipContainerClass?: string | null;
+    chipCloseButtonClass?: string | null;
+    placeholder?: string | null;
+}
+export interface CheckEntryClasses {
+    entryWrapperClass?: string | null;
+    selectedClass?: string | null;
+    notSelectedClass?: string | null;
+}
+export interface RadioButtonRenderOptions extends RenderOptions, CheckEntryClasses {
+    type: DataRenderType.Radio;
+}
+export interface StandardRenderer extends RenderOptions {
+    type: DataRenderType.Standard;
+}
+export interface DataGroupRenderOptions extends RenderOptions {
+    type: DataRenderType.Group;
+    groupOptions?: GroupRenderOptions;
+}
+export interface HtmlEditorRenderOptions extends RenderOptions {
+    type: DataRenderType.HtmlEditor;
+    allowImages: boolean;
+}
+export interface DateTimeRenderOptions extends RenderOptions {
+    type: DataRenderType.DateTime;
+    format?: string | null;
+    forceMidnight?: boolean;
+    forceStandard?: boolean;
+}
+export interface IconListRenderOptions extends RenderOptions {
+    type: DataRenderType.IconList;
+    iconMappings: IconMapping[];
+}
+export interface DisplayOnlyRenderOptions extends RenderOptions {
+    type: DataRenderType.DisplayOnly;
+    emptyText?: string | null;
+    sampleText?: string | null;
+}
+export interface IconMapping {
+    value: string;
+    materialIcon?: string | null;
+}
+export interface JsonataRenderOptions extends RenderOptions {
+    type: DataRenderType.Jsonata;
+    expression: string;
+}
+export interface JsonataRenderOptions extends RenderOptions {
+    type: DataRenderType.Jsonata;
+    expression: string;
+}
+export interface ArrayRenderOptions extends RenderOptions {
+    type: DataRenderType.Array;
+    addText?: string | null;
+    addActionId?: string | null;
+    removeText?: string | null;
+    removeActionId?: string | null;
+    editText?: string | null;
+    editActionId?: string | null;
+    noAdd?: boolean | null;
+    noRemove?: boolean | null;
+    noReorder?: boolean | null;
+    editExternal?: boolean | null;
+}
+export interface ArrayElementRenderOptions extends RenderOptions {
+    type: DataRenderType.ArrayElement;
+    showInline?: boolean | null;
+}
+export interface ElementSelectedRenderOptions extends RenderOptions {
+    type: DataRenderType.ElementSelected;
+    elementExpression: EntityExpression;
+}
+export type ArrayActionOptions = Pick<ArrayRenderOptions, "addText" | "addActionId" | "removeText" | "removeActionId" | "noAdd" | "noRemove" | "noReorder" | "editExternal" | "editActionId" | "editText"> & {
+    readonly?: boolean;
+    disabled?: boolean;
+    designMode?: boolean;
+};
+export interface CheckListRenderOptions extends RenderOptions, CheckEntryClasses {
+    type: DataRenderType.CheckList;
+}
+export interface SynchronisedRenderOptions extends RenderOptions {
+    type: DataRenderType.Synchronised;
+    fieldToSync: string;
+    syncType: SyncTextType;
+}
+export declare enum SyncTextType {
+    Camel = "Camel",
+    Snake = "Snake",
+    Pascal = "Pascal"
+}
+export interface UserSelectionRenderOptions extends RenderOptions {
+    type: DataRenderType.UserSelection;
+    noGroups: boolean;
+    noUsers: boolean;
+}
+export interface IconSelectionRenderOptions extends RenderOptions {
+    type: DataRenderType.IconSelector;
+}
+export interface GroupedControlsDefinition extends ControlDefinition {
+    type: ControlDefinitionType.Group;
+    compoundField?: string | null;
+    groupOptions?: GroupRenderOptions;
+}
+export interface GroupRenderOptions {
+    type: string;
+    hideTitle?: boolean | null;
+    childStyleClass?: string | null;
+    childLayoutClass?: string | null;
+    childLabelClass?: string | null;
+    displayOnly?: boolean | null;
+}
+export interface ActionOptions {
+    actionId: string;
+    actionText?: string | null;
+    actionData?: string | null;
+    icon?: IconReference | null;
+    actionStyle?: ActionStyle | null;
+    iconPlacement?: IconPlacement | null;
+}
+export declare enum GroupRenderType {
+    Standard = "Standard",
+    Grid = "Grid",
+    Flex = "Flex",
+    Tabs = "Tabs",
+    GroupElement = "GroupElement",
+    SelectChild = "SelectChild",
+    Inline = "Inline",
+    Wizard = "Wizard",
+    Dialog = "Dialog",
+    Contents = "Contents"
+}
+export interface DialogRenderOptions extends GroupRenderOptions {
+    type: GroupRenderType.Dialog;
+    title?: string | null;
+}
+export interface StandardGroupRenderer extends GroupRenderOptions {
+    type: GroupRenderType.Standard;
+}
+export interface FlexRenderer extends GroupRenderOptions {
+    type: GroupRenderType.Flex;
+    direction?: string | null;
+    gap?: string | null;
+}
+export interface GroupElementRenderer extends GroupRenderOptions {
+    type: GroupRenderType.GroupElement;
+    value: any;
+}
+export interface GridRenderer extends GroupRenderOptions {
+    type: GroupRenderType.Grid;
+    columns?: number | null;
+    rowClass?: string | null;
+}
+export interface TabsRenderOptions extends GroupRenderOptions {
+    type: GroupRenderType.Tabs;
+    contentClass?: string;
+}
+export interface WizardRenderOptions extends GroupRenderOptions {
+    type: GroupRenderType.Wizard;
+}
+export interface SelectChildRenderer extends GroupRenderOptions {
+    type: GroupRenderType.SelectChild;
+    childIndexExpression?: EntityExpression | null;
+}
+export interface DisplayControlDefinition extends ControlDefinition {
+    type: ControlDefinitionType.Display;
+    displayData: DisplayData;
+}
+export interface DisplayData {
+    type: string;
+}
+export declare enum DisplayDataType {
+    Text = "Text",
+    Html = "Html",
+    Icon = "Icon",
+    Custom = "Custom"
+}
+export interface TextDisplay extends DisplayData {
+    type: DisplayDataType.Text;
+    text: string;
+}
+export interface IconDisplay extends DisplayData {
+    type: DisplayDataType.Icon;
+    iconClass: string;
+    icon?: IconReference | null;
+}
+export interface HtmlDisplay extends DisplayData {
+    type: DisplayDataType.Html;
+    html: string;
+}
+export interface CustomDisplay extends DisplayData {
+    type: DisplayDataType.Custom;
+    customId: string;
+}
+export interface ActionControlDefinition extends ControlDefinition {
+    type: ControlDefinitionType.Action;
+    actionId: string;
+    actionData?: string | null;
+    icon?: IconReference | null;
+    actionStyle?: ActionStyle | null;
+    iconPlacement?: IconPlacement | null;
+}
+export declare enum ActionStyle {
+    Button = "Button",
+    Secondary = "Secondary",
+    Link = "Link",
+    Group = "Group"
+}
+export declare enum IconPlacement {
+    BeforeText = "BeforeText",
+    AfterText = "AfterText",
+    ReplaceText = "ReplaceText"
+}
+export interface ControlVisitor<A> {
+    data(d: DataControlDefinition): A;
+    group(d: GroupedControlsDefinition): A;
+    display(d: DisplayControlDefinition): A;
+    action(d: ActionControlDefinition): A;
+}
+export declare function visitControlDefinition<A>(x: ControlDefinition, visitor: ControlVisitor<A>, defaultValue: (c: ControlDefinition) => A): A;
+export declare function isGridRenderer(options: GroupRenderOptions): options is GridRenderer;
+export declare function isWizardRenderer(options: GroupRenderOptions): options is WizardRenderOptions;
+export declare function isDialogRenderer(options: GroupRenderOptions): options is DialogRenderOptions;
+export declare function isInlineRenderer(options: GroupRenderOptions): options is GridRenderer;
+export declare function isSelectChildRenderer(options: GroupRenderOptions): options is SelectChildRenderer;
+export declare function isTabsRenderer(options: GroupRenderOptions): options is TabsRenderOptions;
+export declare function isFlexRenderer(options: GroupRenderOptions): options is FlexRenderer;
+export declare function isDisplayOnlyRenderer(options: RenderOptions): options is DisplayOnlyRenderOptions;
+export declare function isTextfieldRenderer(options: RenderOptions): options is TextfieldRenderOptions;
+export declare function isDateTimeRenderer(options: RenderOptions): options is DateTimeRenderOptions;
+export declare function isAutocompleteRenderer(options: RenderOptions): options is AutocompleteRenderOptions;
+export declare function isAutoCompleteClasses(options?: RenderOptions | null): options is AutocompleteClasses & RenderOptions;
+export declare function isDataGroupRenderer(options?: RenderOptions | null): options is DataGroupRenderOptions;
+export declare function isArrayRenderer(options: RenderOptions): options is ArrayRenderOptions;
+export declare function isDataControl(c: ControlDefinition): c is DataControlDefinition;
+export declare function isGroupControl(c: ControlDefinition): c is GroupedControlsDefinition;
+export declare function isActionControl(c: ControlDefinition): c is ActionControlDefinition;
+export declare function isDisplayControl(c: ControlDefinition): c is DisplayControlDefinition;
+export declare function isTextDisplay(d: DisplayData): d is TextDisplay;
+export declare function isHtmlDisplay(d: DisplayData): d is HtmlDisplay;
+export declare function isCheckEntryClasses(options?: RenderOptions | null): options is CheckEntryClasses & RenderOptions;
+export declare function traverseParents<A, B extends {
+    parent?: B | undefined;
+}>(current: B | undefined, get: (b: B) => A, until?: (b: B) => boolean): A[];
+export declare function getRootDataNode(dataNode: SchemaDataNode): SchemaDataNode;
+export declare function getJsonPath(dataNode: SchemaDataNode): (string | number)[];
+export declare function getSchemaPath(schemaNode: SchemaNode): SchemaField[];
+export declare function getSchemaFieldList(schema: SchemaNode): SchemaField[];
+export declare function fontAwesomeIcon(icon: string): {
+    library: IconLibrary;
+    name: string;
+};
+/**
+ * Checks if a control definition is readonly.
+ * @param c - The control definition to check.
+ * @returns True if the control definition is readonly, false otherwise.
+ */
+export declare function isControlReadonly(c: ControlDefinition): boolean;
+/**
+ * Checks if a control definition is disabled.
+ * @param c - The control definition to check.
+ * @returns True if the control definition is disabled, false otherwise.
+ */
+export declare function isControlDisabled(c: ControlDefinition): boolean;
+/**
+ * Returns the group renderer options for a control definition.
+ * @param {ControlDefinition} def - The control definition to get the group renderer options for.
+ * @returns {GroupRenderOptions | undefined} - The group renderer options, or undefined if not applicable.
+ */
+export declare function getGroupRendererOptions(def: ControlDefinition): GroupRenderOptions | undefined;
+/**
+ * Checks if a control definition is display-only.
+ * @param {ControlDefinition} def - The control definition to check.
+ * @returns {boolean} - True if the control definition is display-only, false otherwise.
+ */
+export declare function isControlDisplayOnly(def: ControlDefinition): boolean;
+/**
+ * Returns the display-only render options for a control definition.
+ * @param d - The control definition to get the display-only render options for.
+ * @returns The display-only render options, or undefined if not applicable.
+ */
+export declare function getDisplayOnlyOptions(d: ControlDefinition): DisplayOnlyRenderOptions | undefined;

package/lib/defaultSchemaInterface.d.ts

@@ -0,0 +1,28 @@
+import { EqualityFunc, FieldOption, SchemaField, ValidationMessageType } from "./schemaField";
+import { SchemaInterface } from "./schemaInterface";
+import { SchemaDataNode } from "./schemaDataNode";
+import { SchemaNode } from "./schemaNode";
+import { Control, ControlSetup } from "@astroapps/controls";
+export declare class DefaultSchemaInterface implements SchemaInterface {
+    protected boolStrings: [string, string];
+    protected parseDateTime: (s: string) => number;
+    constructor(boolStrings?: [string, string], parseDateTime?: (s: string) => number);
+    parseToMillis(field: SchemaField, v: string): number;
+    validationMessageText(field: SchemaField, messageType: ValidationMessageType, actual: any, expected: any): string;
+    getDataOptions(node: SchemaDataNode): FieldOption[] | null | undefined;
+    getNodeOptions(node: SchemaNode): FieldOption[] | null | undefined;
+    getOptions({ options }: SchemaField): FieldOption[] | null | undefined;
+    getFilterOptions(array: SchemaDataNode, field: SchemaNode): FieldOption[] | undefined | null;
+    isEmptyValue(f: SchemaField, value: any): boolean;
+    searchText(field: SchemaField, value: any): string;
+    textValueForData(dataNode: SchemaDataNode): string | undefined;
+    textValue(field: SchemaField, value: any, element?: boolean | undefined, options?: FieldOption[] | null): string | undefined;
+    controlLength(f: SchemaField, control: Control<any>): number;
+    valueLength(field: SchemaField, value: any): number;
+    compareValue(field: SchemaField, v1: unknown, v2: unknown): number;
+    compoundFieldSetup(f: SchemaNode): [string, ControlSetup<any>][];
+    compoundFieldEquality(f: SchemaNode): [string, EqualityFunc][];
+    makeEqualityFunc(field: SchemaNode, element?: boolean): EqualityFunc;
+    makeControlSetup(field: SchemaNode, element?: boolean): ControlSetup<any>;
+}
+export declare const defaultSchemaInterface: SchemaInterface;

package/lib/entityExpression.d.ts

@@ -0,0 +1,33 @@
+export interface EntityExpression {
+    type: string;
+}
+export declare enum ExpressionType {
+    Jsonata = "Jsonata",
+    Data = "Data",
+    DataMatch = "FieldValue",
+    UserMatch = "UserMatch",
+    NotEmpty = "NotEmpty",
+    UUID = "UUID"
+}
+export interface JsonataExpression extends EntityExpression {
+    type: ExpressionType.Jsonata;
+    expression: string;
+}
+export interface DataExpression extends EntityExpression {
+    type: ExpressionType.Data;
+    field: string;
+}
+export interface DataMatchExpression extends EntityExpression {
+    type: ExpressionType.DataMatch;
+    field: string;
+    value: any;
+}
+export interface NotEmptyExpression extends EntityExpression {
+    type: ExpressionType.NotEmpty;
+    field: string;
+    empty?: boolean | null;
+}
+export interface UserMatchExpression extends EntityExpression {
+    type: ExpressionType.UserMatch;
+    userMatch: string;
+}

package/lib/evalExpression.d.ts

@@ -0,0 +1,15 @@
+import { EntityExpression, JsonataExpression } from "./entityExpression";
+import { CleanupScope, Value } from "@astroapps/controls";
+import { SchemaDataNode } from "./schemaDataNode";
+import { SchemaInterface } from "./schemaInterface";
+export interface ExpressionEvalContext {
+    scope: CleanupScope;
+    returnResult: (k: unknown) => void;
+    dataNode: SchemaDataNode;
+    schemaInterface: SchemaInterface;
+    variables?: Value<Record<string, any> | undefined>;
+}
+export type ExpressionEval<T extends EntityExpression> = (expr: T, context: ExpressionEvalContext) => void;
+export declare const jsonataEval: ExpressionEval<JsonataExpression>;
+export declare const uuidEval: ExpressionEval<EntityExpression>;
+export declare const defaultEvaluators: Record<string, ExpressionEval<any>>;

package/lib/formNode.d.ts

@@ -0,0 +1,45 @@
+import { ControlDefinition, DataControlDefinition } from "./controlDefinition";
+import { SchemaDataNode } from "./schemaDataNode";
+export type ControlMap = {
+    [k: string]: ControlDefinition;
+};
+export declare class FormNode {
+    id: string;
+    definition: ControlDefinition;
+    tree: FormTree;
+    parent?: FormNode | undefined;
+    constructor(id: string, definition: ControlDefinition, tree: FormTree, parent?: FormNode | undefined);
+    visit<A>(visitFn: (n: FormNode) => A | undefined): A | undefined;
+    getResolvedChildren(): ControlDefinition[];
+    createChildNode(childId: string, childDef: ControlDefinition): FormNode;
+    getChildNodes(): FormNode[];
+    getUnresolvedChildNodes(): FormNode[];
+}
+export interface FormTreeLookup {
+    getForm(formId: string): FormTree | undefined;
+}
+export declare abstract class FormTree implements FormTreeLookup {
+    abstract rootNode: FormNode;
+    abstract getByRefId(id: string): ControlDefinition | undefined;
+    abstract getForm(formId: string): FormTree | undefined;
+    getChildId(parentId: string, childId: string, control: ControlDefinition): string;
+}
+export declare function createControlMap(control: ControlDefinition): ControlMap;
+export declare function legacyFormNode(definition: ControlDefinition): FormNode;
+export declare function createFormTree(controls: ControlDefinition[], getForm?: FormTreeLookup): FormTree;
+export declare function createFormLookup<A extends Record<string, ControlDefinition[]>>(formMap: A): {
+    getForm(formId: keyof A): FormTree;
+};
+export declare function fieldPathForDefinition(c: ControlDefinition): string[] | undefined;
+export declare function lookupDataNode(c: ControlDefinition, parentNode: SchemaDataNode): SchemaDataNode | undefined;
+/**
+ * @deprecated use visitFormNodeData instead
+ */
+export declare function visitControlDataArray<A>(controls: ControlDefinition[] | undefined | null, context: SchemaDataNode, cb: (definition: DataControlDefinition, node: SchemaDataNode) => A | undefined): A | undefined;
+/**
+ * @deprecated use visitFormDataInContext instead
+ */
+export declare function visitControlData<A>(definition: ControlDefinition, ctx: SchemaDataNode, cb: (definition: DataControlDefinition, field: SchemaDataNode) => A | undefined): A | undefined;
+export type ControlDataVisitor<A> = (dataNode: SchemaDataNode, definition: DataControlDefinition) => A | undefined;
+export declare function visitFormData<A>(node: FormNode, dataNode: SchemaDataNode, cb: ControlDataVisitor<A>, notSelf?: boolean): A | undefined;
+export declare function visitFormDataInContext<A>(parentContext: SchemaDataNode, node: FormNode, cb: ControlDataVisitor<A>): A | undefined;

package/lib/formState.d.ts

@@ -0,0 +1,44 @@
+import { FormNode } from "./formNode";
+import { SchemaDataNode } from "./schemaDataNode";
+import { ControlDefinition } from "./controlDefinition";
+import { SchemaInterface } from "./schemaInterface";
+import { FieldOption } from "./schemaField";
+import { Control } from "@astroapps/controls";
+import { ExpressionEval, ExpressionEvalContext } from "./evalExpression";
+import { EntityExpression } from "./entityExpression";
+export interface ControlState {
+    definition: ControlDefinition;
+    schemaInterface: SchemaInterface;
+    dataNode?: SchemaDataNode | undefined;
+    stateId?: string;
+    style?: object;
+    layoutStyle?: object;
+    allowedOptions?: any[];
+    readonly: boolean;
+    hidden: boolean;
+    disabled: boolean;
+    clearHidden: boolean;
+    variables: Record<string, any>;
+}
+export interface FormContextOptions {
+    readonly?: boolean | null;
+    hidden?: boolean | null;
+    disabled?: boolean | null;
+    clearHidden?: boolean;
+    stateKey?: string;
+    variables?: Record<string, any>;
+}
+/**
+ * Interface representing the form context data.
+ */
+export interface FormContextData {
+    option?: FieldOption;
+    optionSelected?: boolean;
+}
+export interface FormState {
+    getControlState(parent: SchemaDataNode, formNode: FormNode, context: FormContextOptions): ControlState;
+    cleanup(): void;
+    evalExpression(expr: EntityExpression, context: ExpressionEvalContext): void;
+}
+export declare function createFormState(schemaInterface: SchemaInterface, evaluators?: Record<string, ExpressionEval<any>>): FormState;
+export declare function createOverrideProxy<A extends object, B extends Record<string, any>>(proxyFor: A, handlers: Control<B>): A;