@react-typed-forms/schemas 15.1.1 → 15.1.3

package/lib/controlBuilder.d.ts

@@ -1,8 +1,9 @@
 import { AccordionAdornment, ActionControlDefinition, AutocompleteRenderOptions, CheckListRenderOptions, ControlAdornmentType, ControlDefinition, DataControlDefinition, DataRenderType, DisplayControlDefinition, DisplayOnlyRenderOptions, DynamicProperty, GroupedControlsDefinition, JsonataRenderOptions, RadioButtonRenderOptions, RenderOptions, TextfieldRenderOptions } from "./controlDefinition";
 import { ActionRendererProps } from "./controlRender";
 import { DateValidator, JsonataValidator, LengthValidator, ValidatorType } from "./schemaValidator";
-import { SchemaField, SchemaMap, SchemaNode } from "./schemaField";
+import { SchemaField, SchemaMap } from "./schemaField";
 import { DataExpression, DataMatchExpression, EntityExpression, JsonataExpression } from "./entityExpression";
+import { SchemaNode } from "./schemaNode";
 export declare function dataControl(field: string, title?: string | null, options?: Partial<DataControlDefinition>): DataControlDefinition;
 export declare function validatorOptions<A extends {
     type: string;

package/lib/controlDefinition.d.ts

@@ -1,6 +1,9 @@
 import { SchemaValidator } from "./schemaValidator";
-import { FieldOption, SchemaDataNode, SchemaField, SchemaInterface, SchemaNode } from "./schemaField";
+import { FieldOption, SchemaField } from "./schemaField";
 import { EntityExpression } from "./entityExpression";
+import { SchemaInterface } from "./schemaInterface";
+import { SchemaDataNode } from "./schemaDataNode";
+import { SchemaNode } from "./schemaNode";
 /**
  * Interface representing the form context data.
  */
@@ -30,8 +33,10 @@ export interface ControlDefinition {
     childRefId?: string | null;
     title?: string | null;
     styleClass?: string | null;
+    textClass?: string | null;
     layoutClass?: string | null;
     labelClass?: string | null;
+    labelTextClass?: string | null;
     dynamic?: DynamicProperty[] | null;
     adornments?: ControlAdornment[] | null;
     children?: ControlDefinition[] | null;
@@ -75,9 +80,19 @@ export declare enum ControlAdornmentType {
     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 {
@@ -214,7 +229,6 @@ export interface ArrayRenderOptions extends RenderOptions {
     noAdd?: boolean | null;
     noRemove?: boolean | null;
     noReorder?: boolean | null;
-    childOptions?: RenderOptions | null;
     editExternal?: boolean | null;
 }
 export interface ArrayElementRenderOptions extends RenderOptions {
@@ -266,7 +280,8 @@ export declare enum GroupRenderType {
     Flex = "Flex",
     Tabs = "Tabs",
     GroupElement = "GroupElement",
-    SelectChild = "SelectChild"
+    SelectChild = "SelectChild",
+    Inline = "Inline"
 }
 export interface StandardGroupRenderer extends GroupRenderOptions {
     type: GroupRenderType.Standard;
@@ -283,6 +298,7 @@ export interface GroupElementRenderer extends GroupRenderOptions {
 export interface GridRenderer extends GroupRenderOptions {
     type: GroupRenderType.Grid;
     columns?: number | null;
+    rowClass?: string | null;
 }
 export interface TabsRenderOptions extends GroupRenderOptions {
     type: GroupRenderType.Tabs;
@@ -312,6 +328,7 @@ export interface TextDisplay extends DisplayData {
 export interface IconDisplay extends DisplayData {
     type: DisplayDataType.Icon;
     iconClass: string;
+    icon?: IconReference | null;
 }
 export interface HtmlDisplay extends DisplayData {
     type: DisplayDataType.Html;
@@ -325,6 +342,17 @@ 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",
+    Link = "Link"
+}
+export declare enum IconPlacement {
+    BeforeText = "BeforeText",
+    AfterText = "AfterText"
 }
 export interface ControlVisitor<A> {
     data(d: DataControlDefinition): A;
@@ -334,6 +362,7 @@ export interface ControlVisitor<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 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;
@@ -350,34 +379,6 @@ export declare function isActionControl(c: ControlDefinition): c is ActionContro
 export declare function isDisplayControl(c: ControlDefinition): c is DisplayControlDefinition;
 export type ControlActionHandler = (actionId: string, actionData: any, ctx: ControlDataContext) => (() => void) | undefined;
 export declare function isCheckEntryClasses(options?: RenderOptions | null): options is CheckEntryClasses & RenderOptions;
-export type ControlMap = {
-    [k: string]: ControlDefinition;
-};
-export interface FormNode {
-    id: string;
-    definition: ControlDefinition;
-    tree: FormTree;
-    parent?: FormNode;
-    getChildNodes(): FormNode[];
-}
-export interface FormTreeLookup {
-    getForm(formId: string): FormTree | undefined;
-}
-export declare abstract class FormTree implements FormTreeLookup {
-    abstract rootNode: FormNode;
-    abstract getByRefId(id: string): FormNode | undefined;
-    abstract addChild(parent: FormNode, control: ControlDefinition): FormNode;
-    abstract getForm(formId: string): FormTree | undefined;
-    createTempNode(id: string, definition: ControlDefinition, children?: FormNode[], parent?: FormNode): FormNode;
-    createChildNodes(parent: FormNode, definitions: ControlDefinition[] | undefined | null): FormNode[];
-}
-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;
 export declare function traverseParents<A, B extends {
     parent?: B | undefined;
 }>(current: B | undefined, get: (b: B) => A, until?: (b: B) => boolean): A[];
@@ -385,14 +386,7 @@ export declare function getRootDataNode(dataNode: SchemaDataNode): SchemaDataNod
 export declare function getJsonPath(dataNode: SchemaDataNode): (string | number)[];
 export declare function getSchemaPath(schemaNode: SchemaNode): SchemaField[];
 export declare function getSchemaFieldList(schema: SchemaNode): SchemaField[];
-/**
- * @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;
+export declare function fontAwesomeIcon(icon: string): {
+    library: IconLibrary;
+    name: string;
+};

package/lib/controlRender.d.ts

@@ -1,20 +1,72 @@
-import React, { ButtonHTMLAttributes, ElementType, FC, HTMLAttributes, InputHTMLAttributes, Key, LabelHTMLAttributes, ReactElement, ReactNode } from "react";
+import React, { ComponentType, ElementType, FC, HTMLAttributes, Key, ReactElement, ReactNode } from "react";
 import { Control } from "@react-typed-forms/core";
-import { AdornmentPlacement, ArrayActionOptions, ControlActionHandler, ControlAdornment, ControlDataContext, ControlDefinition, DataControlDefinition, DisplayData, FormContextData, FormNode, GroupRenderOptions, RenderOptions } from "./controlDefinition";
+import { ActionStyle, AdornmentPlacement, ArrayActionOptions, ControlActionHandler, ControlAdornment, ControlDataContext, ControlDefinition, DataControlDefinition, DisplayData, FormContextData, GroupRenderOptions, IconPlacement, IconReference, RenderOptions } from "./controlDefinition";
 import { ControlClasses, JsonPath } from "./util";
 import { EvalExpressionHook, UseEvalExpressionHook } from "./hooks";
 import { ValidationContext } from "./validators";
 import { SchemaValidator } from "./schemaValidator";
-import { FieldOption, SchemaDataNode, SchemaField, SchemaInterface } from "./schemaField";
+import { FieldOption, SchemaField } from "./schemaField";
+import { FormNode } from "./formNode";
+import { SchemaInterface } from "./schemaInterface";
+import { SchemaDataNode } from "./schemaDataNode";
+export interface HtmlIconProperties {
+    className?: string;
+    style?: React.CSSProperties;
+    iconLibrary?: string;
+    iconName?: string;
+}
+export interface HtmlLabelProperties {
+    htmlFor?: string;
+    className?: string;
+    textClass?: string;
+    children?: ReactNode;
+}
+export interface HtmlDivProperties {
+    id?: string;
+    className?: string;
+    textClass?: string;
+    style?: React.CSSProperties;
+    children?: ReactNode;
+    text?: string;
+    html?: string;
+    nativeRef?: (e: HTMLElement | null) => void;
+    inline?: boolean;
+}
+export interface HtmlInputProperties {
+    id?: string;
+    className?: string;
+    textClass?: string;
+    name?: string;
+    type?: string;
+    checked?: boolean;
+    style?: React.CSSProperties;
+    readOnly?: boolean;
+    placeholder?: string;
+    value?: string | number;
+    onBlur?: () => void;
+    disabled?: boolean;
+    inputRef?: (e: HTMLElement | null) => void;
+    onChangeValue?: (value: string) => void;
+    onChangeChecked?: (checked: boolean) => void;
+}
+export interface HtmlButtonProperties {
+    className?: string;
+    textClass?: string;
+    disabled?: boolean;
+    style?: React.CSSProperties;
+    onClick?: () => void;
+    inline?: boolean;
+    children?: ReactNode;
+}
 export interface HtmlComponents {
-    Div: ElementType<HTMLAttributes<HTMLDivElement>, "div">;
+    Div: ComponentType<HtmlDivProperties>;
     Span: ElementType<HTMLAttributes<HTMLSpanElement>>;
-    Button: ElementType<ButtonHTMLAttributes<HTMLButtonElement>>;
-    I: ElementType<HTMLAttributes<HTMLElement>>;
-    Label: ElementType<LabelHTMLAttributes<HTMLLabelElement>>;
+    Button: ComponentType<HtmlButtonProperties>;
+    I: ComponentType<HtmlIconProperties>;
+    Label: ComponentType<HtmlLabelProperties>;
     B: ElementType<HTMLAttributes<HTMLElement>>;
     H1: ElementType<HTMLAttributes<HTMLElement>>;
-    Input: ElementType<InputHTMLAttributes<HTMLInputElement>, "input">;
+    Input: ComponentType<HtmlInputProperties>;
 }
 /**
  * Interface for rendering different types of form controls.
@@ -82,7 +134,6 @@ export interface FormRenderer {
      * @returns A React node.
      */
     renderLabelText: (props: ReactNode) => ReactNode;
-    renderText: (props: ReactNode, className?: string) => ReactNode;
     html: HtmlComponents;
 }
 export interface AdornmentProps {
@@ -127,12 +178,14 @@ export interface RenderedLayout {
     className?: string;
     style?: React.CSSProperties;
     wrapLayout: (layout: ReactElement) => ReactElement;
+    inline?: boolean;
 }
 export interface RenderedControl {
     children: ReactNode;
     className?: string;
     style?: React.CSSProperties;
     divRef?: (cb: HTMLElement | null) => void;
+    inline?: boolean;
 }
 export interface VisibilityRendererProps extends RenderedControl {
     visibility: Control<Visibility | undefined>;
@@ -145,6 +198,7 @@ export interface ControlLayoutProps {
     processLayout?: (props: ControlLayoutProps) => ControlLayoutProps;
     className?: string | null;
     style?: React.CSSProperties;
+    inline?: boolean;
 }
 /**
  * Enum representing the types of labels that can be rendered.
@@ -192,6 +246,10 @@ export interface LabelRendererProps {
      * The CSS class name for the label.
      */
     className?: string;
+    /**
+     * The CSS class name for the label text.
+     */
+    textClass?: string;
 }
 /**
  * Properties for display renderers.
@@ -213,16 +271,19 @@ export interface DisplayRendererProps {
      * The CSS class name for the display renderer.
      */
     className?: string;
+    textClass?: string;
     /**
      * The CSS styles for the display renderer.
      */
     style?: React.CSSProperties;
+    inline?: boolean;
 }
 export type ChildVisibilityFunc = (child: ControlDefinition, parentNode?: SchemaDataNode, dontOverride?: boolean) => EvalExpressionHook<boolean>;
 export interface ParentRendererProps {
     formNode: FormNode;
     renderChild: ChildRenderer;
     className?: string;
+    textClass?: string;
     style?: React.CSSProperties;
     dataContext: ControlDataContext;
     useChildVisibility: ChildVisibilityFunc;
@@ -237,7 +298,6 @@ export interface DataRendererProps extends ParentRendererProps {
     renderOptions: RenderOptions;
     definition: DataControlDefinition;
     field: SchemaField;
-    elementIndex?: number;
     id: string;
     control: Control<any>;
     readonly: boolean;
@@ -246,15 +306,21 @@ export interface DataRendererProps extends ParentRendererProps {
     hidden: boolean;
     dataNode: SchemaDataNode;
     displayOnly: boolean;
+    inline: boolean;
 }
 export interface ActionRendererProps {
     actionId: string;
     actionText: string;
     actionData?: any;
+    actionStyle?: ActionStyle;
+    icon?: IconReference | null;
+    iconPlacement?: IconPlacement;
     onClick: () => void;
     className?: string | null;
+    textClass?: string | null;
     style?: React.CSSProperties;
     disabled?: boolean;
+    inline?: boolean;
 }
 export interface ControlRenderProps {
     control: Control<any>;
@@ -265,25 +331,9 @@ export interface FormContextOptions {
     hidden?: boolean | null;
     disabled?: boolean | null;
     displayOnly?: boolean;
+    inline?: boolean;
 }
-export interface DataControlProps {
-    formNode: FormNode;
-    definition: DataControlDefinition;
-    dataContext: ControlDataContext;
-    control: Control<any>;
-    formOptions: FormContextOptions;
-    style?: React.CSSProperties | undefined;
-    renderChild: ChildRenderer;
-    elementIndex?: number;
-    allowedOptions?: Control<any[] | undefined>;
-    useChildVisibility: ChildVisibilityFunc;
-    useEvalExpression: UseEvalExpressionHook;
-    schemaInterface?: SchemaInterface;
-    designMode?: boolean;
-    styleClass?: string;
-    layoutClass?: string;
-}
-export type CreateDataProps = (controlProps: DataControlProps) => DataRendererProps;
+export type CreateDataProps = (controlProps: RenderLayoutProps, definition: DataControlDefinition, control: Control<any>) => DataRendererProps;
 export interface ControlRenderOptions extends FormContextOptions, ControlClasses {
     useDataHook?: (c: ControlDefinition) => CreateDataProps;
     actionOnClick?: ControlActionHandler;
@@ -293,7 +343,6 @@ export interface ControlRenderOptions extends FormContextOptions, ControlClasses
     adjustLayout?: (context: ControlDataContext, layout: ControlLayoutProps) => ControlLayoutProps;
     clearHidden?: boolean;
     schemaInterface?: SchemaInterface;
-    elementIndex?: number;
     formData?: FormContextData;
 }
 export declare function useControlRenderer(definition: ControlDefinition, fields: SchemaField[], renderer: FormRenderer, options?: ControlRenderOptions): FC<ControlRenderProps>;
@@ -312,19 +361,18 @@ export declare function NewControlRenderer({ definition, renderer, options, pare
     options?: ControlRenderOptions;
     parentDataNode: SchemaDataNode;
 }): JSX.Element;
-export declare function defaultDataProps({ definition, control, formOptions, style, allowedOptions, schemaInterface, styleClass, ...props }: DataControlProps): DataRendererProps;
+export declare function defaultDataProps({ formOptions, style, allowedOptions, schemaInterface, styleClass, textClass: tc, ...props }: RenderLayoutProps, definition: DataControlDefinition, control: Control<any>): DataRendererProps;
 export interface ChildRendererOptions {
-    elementIndex?: number;
     parentDataNode?: SchemaDataNode;
     formData?: FormContextData;
+    inline?: boolean;
     displayOnly?: boolean;
     styleClass?: string;
     layoutClass?: string;
     labelClass?: string;
 }
 export type ChildRenderer = (k: Key, child: FormNode, options?: ChildRendererOptions) => ReactNode;
-export interface RenderControlProps {
-    definition: ControlDefinition;
+export interface RenderLayoutProps {
     formNode: FormNode;
     renderer: FormRenderer;
     renderChild: ChildRenderer;
@@ -333,7 +381,6 @@ export interface RenderControlProps {
     dataContext: ControlDataContext;
     control?: Control<any>;
     labelText?: Control<string | null | undefined>;
-    elementIndex?: number;
     displayControl?: Control<string | undefined>;
     style?: React.CSSProperties;
     allowedOptions?: Control<any[] | undefined>;
@@ -345,10 +392,12 @@ export interface RenderControlProps {
     designMode?: boolean;
     customDisplay?: (customId: string, displayProps: DisplayRendererProps) => ReactNode;
     labelClass?: string;
+    labelTextClass?: string;
     styleClass?: string;
+    textClass?: string;
 }
-export declare function renderControlLayout(props: RenderControlProps): ControlLayoutProps;
-type MarkupKeys = keyof Omit<RenderedLayout, "errorControl" | "style" | "className" | "wrapLayout" | "readonly" | "disabled">;
+export declare function renderControlLayout(props: RenderLayoutProps): ControlLayoutProps;
+type MarkupKeys = keyof Omit<RenderedLayout, "errorControl" | "style" | "className" | "wrapLayout" | "readonly" | "disabled" | "inline">;
 export declare function appendMarkup(k: MarkupKeys, markup: ReactNode): (layout: RenderedLayout) => void;
 export declare function wrapMarkup(k: MarkupKeys, wrap: (ex: ReactNode) => ReactNode): (layout: RenderedLayout) => void;
 export declare function layoutKeyForPlacement(pos: AdornmentPlacement): MarkupKeys;

package/lib/defaultSchemaInterface.d.ts

@@ -1,5 +1,8 @@
 import { Control, ControlSetup } from "@react-typed-forms/core";
-import { EqualityFunc, FieldOption, SchemaDataNode, SchemaField, SchemaInterface, SchemaNode, ValidationMessageType } from "./schemaField";
+import { EqualityFunc, FieldOption, SchemaField, ValidationMessageType } from "./schemaField";
+import { SchemaInterface } from "./schemaInterface";
+import { SchemaDataNode } from "./schemaDataNode";
+import { SchemaNode } from "./schemaNode";
 export declare class DefaultSchemaInterface implements SchemaInterface {
     protected boolStrings: [string, string];
     protected parseDateTime: (s: string) => number;
@@ -12,7 +15,8 @@ export declare class DefaultSchemaInterface implements SchemaInterface {
     getFilterOptions(array: SchemaDataNode, field: SchemaNode): FieldOption[] | undefined | null;
     isEmptyValue(f: SchemaField, value: any): boolean;
     searchText(field: SchemaField, value: any): string;
-    textValue(field: SchemaField, value: any, element?: boolean | undefined): string | undefined;
+    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;

package/lib/formNode.d.ts

@@ -0,0 +1,46 @@
+import { ControlDataContext, 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;
+export declare function lookupChildDataContext(dataContext: ControlDataContext, c: ControlDefinition): ControlDataContext;
+/**
+ * @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/hooks.d.ts

@@ -3,8 +3,9 @@ import React from "react";
 import { Control } from "@react-typed-forms/core";
 import { JsonPath } from "./util";
 import { DynamicHookGenerator } from "./dynamicHooks";
-import { SchemaDataNode, SchemaInterface } from "./schemaField";
 import { EntityExpression } from "./entityExpression";
+import { SchemaInterface } from "./schemaInterface";
+import { SchemaDataNode } from "./schemaDataNode";
 export type EvalExpressionHook<A = any> = DynamicHookGenerator<Control<A | undefined>, ControlDataContext>;
 export type UseEvalExpressionHook = (expr: EntityExpression | undefined | null, coerce: (v: any) => any) => DynamicHookGenerator<Control<any> | undefined, ControlDataContext>;
 export declare function optionalHook(expr: EntityExpression | undefined | null, useHook: UseEvalExpressionHook, coerce: (v: any) => any): DynamicHookGenerator<Control<any> | undefined, ControlDataContext> | undefined;