@xh/hoist 57.0.0 → 57.0.1

package/build/types/cmp/clock/Clock.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="react" />
+import { BoxProps, HoistProps } from '@xh/hoist/core';
+export interface ClockProps extends HoistProps, BoxProps {
+    /** String to display if the timezone is invalid or an offset cannot be fetched. */
+    errorString?: string;
+    /** A moment.js format string. @see {@link https://momentjs.com/docs/#/displaying/format/} */
+    format?: string;
+    /** Prefix prepended to the displayed time. */
+    prefix?: string;
+    /** Suffix appended to the displayed time. */
+    suffix?: string;
+    /**
+     * Timezone ID. The user's local system time will be used if omitted.
+     * @see {@link https://docs.oracle.com/middleware/12212/wcs/tag-ref/MISC/TimeZones.html}
+     */
+    timezone?: string;
+    /** Frequency (ms) for updating the displayed time. Defaults to once a second. */
+    updateInterval?: number;
+}
+/**
+ * A component to display the current time.
+ *
+ * Automatically updates on a regular interval to stay current. Supports displaying time in an
+ * alternate timezone (fetching the requested zone offset from the server as required).
+ */
+export declare const Clock: import("react").FC<ClockProps>, clock: import("@xh/hoist/core").ElementFactory<ClockProps>;

package/build/types/cmp/clock/index.d.ts

@@ -0,0 +1 @@
+export * from './Clock';

package/build/types/cmp/dataview/DataView.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="react" />
+import { BoxProps, HoistProps } from '@xh/hoist/core';
+import type { GridOptions } from '@xh/hoist/kit/ag-grid';
+import './DataView.scss';
+import { DataViewModel } from './DataViewModel';
+export interface DataViewProps extends HoistProps<DataViewModel>, BoxProps {
+    /**
+     * Options for ag-Grid's API.
+     *
+     * This constitutes an 'escape hatch' for applications that need to get to the underlying
+     * ag-Grid API. It should be used with care. Settings made here might be overwritten and/or
+     * interfere with the implementation of this component and its use of the ag-Grid API.
+     *
+     * Note that changes to these options after the component's initial render will be ignored.
+     */
+    agOptions?: GridOptions;
+}
+/**
+ * A DataView is a specialized version of the Grid component. It displays its data within a
+ * single column, using a configured component for rendering each item.
+ */
+export declare const DataView: import("react").FC<DataViewProps>, dataView: import("@xh/hoist/core").ElementFactory<DataViewProps>;

package/build/types/cmp/dataview/DataViewModel.d.ts

@@ -0,0 +1,103 @@
+import { ColumnRenderer, GridConfig, GridModel, GroupRowRenderer, RowClassFn, RowClassRuleFn, GridSorterLike, GridContextMenuSpec } from '@xh/hoist/cmp/grid';
+import { HoistModel, LoadSpec, PlainObject, Some } from '@xh/hoist/core';
+import { Store, StoreConfig, StoreRecord, StoreRecordOrId, StoreSelectionConfig, StoreSelectionModel, StoreTransaction } from '@xh/hoist/data';
+/**
+ * Configuration for a DataView.
+ *
+ *  Additional properties not specified here will be passed to the underlying
+ *  GridModel. Note this is for advanced usage - not all configs supported, and many will
+ *  override DataView defaults in ways that will break this component.
+ */
+export interface DataViewConfig extends GridConfig {
+    /** A Store instance, or a config to create one. */
+    store?: Store | StoreConfig;
+    /** Renderer to use for each data row. */
+    renderer?: ColumnRenderer;
+    /** Row height (in px) for each item displayed in the view, or a function which returns a number.*/
+    itemHeight?: number | ItemHeightFn;
+    /** Field(s) by which to do full-width row grouping. */
+    groupBy?: Some<string>;
+    /** Height (in px) of a group row. */
+    groupRowHeight?: number;
+    /** Function used to render group rows. */
+    groupRowRenderer?: GroupRowRenderer;
+    /** Sort specification. */
+    sortBy?: Some<GridSorterLike>;
+    /** Specification of selection behavior. Defaults to 'single' (desktop) and 'disabled' (mobile) */
+    selModel?: StoreSelectionModel | StoreSelectionConfig | 'single' | 'multiple' | 'disabled';
+    /** Text/HTML to display if view has no records.*/
+    emptyText?: string;
+    /** True to highlight the currently hovered row.*/
+    showHover?: boolean;
+    /** True to render row borders.*/
+    rowBorders?: boolean;
+    /** True to use alternating backgrounds for rows.*/
+    stripeRows?: boolean;
+    /**
+     * Array of RecordActions, dividers, or token strings with which to create a context menu.
+     * May also be specified as a function returning same.
+     */
+    contextMenu?: GridContextMenuSpec;
+    /**
+     * Closure to generate CSS class names for a row.
+     * NOTE that, once added, classes will *not* be removed if the data changes.
+     * Use `rowClassRules` instead if StoreRecord data can change across refreshes.
+     */
+    rowClassFn?: RowClassFn;
+    /**
+     * Object keying CSS class names to functions determining if they should be added or
+     * removed from the row. See Ag-Grid docs on "row styles" for details.
+     */
+    rowClassRules?: Record<string, RowClassRuleFn>;
+    /**
+     * Callback when a row is clicked - will receive an event with a data node containing
+     * the row's data. (Note that this may be null - e.g. for clicks on full-width group rows.)
+     */
+    onRowClicked?: (e: any) => void;
+    /**
+     * Callback when a row is double clicked - will receive an event with a data node containing
+     * the row's data. (Note that this may be null - e.g. for clicks on full-width group rows.)
+     */
+    onRowDoubleClicked?: (e: any) => void;
+}
+export type ItemHeightFn = (params: {
+    record: StoreRecord;
+    dataViewModel: DataViewModel;
+    agParams: PlainObject;
+}) => number;
+/**
+ * DataViewModel is a wrapper around GridModel, which shows sorted data in a single column,
+ * using a configured component for rendering each item.
+ *
+ * This is the primary app entry-point for specifying DataView component options and behavior.
+ */
+export declare class DataViewModel extends HoistModel {
+    gridModel: GridModel;
+    itemHeight: number | ItemHeightFn;
+    groupRowHeight: number;
+    constructor(config: DataViewConfig);
+    get store(): Store;
+    get empty(): boolean;
+    get selModel(): StoreSelectionModel;
+    get hasSelection(): boolean;
+    get selectedRecords(): StoreRecord[];
+    get selectedRecord(): StoreRecord;
+    get selectedId(): import("@xh/hoist/data").StoreRecordId;
+    get groupBy(): string[];
+    get sortBy(): import("@xh/hoist/cmp/grid").GridSorter[];
+    selectAsync(records: Some<StoreRecordOrId>, opts: {
+        ensureVisible?: boolean;
+        clearSelection?: boolean;
+    }): Promise<void>;
+    preSelectFirstAsync(): Promise<void>;
+    selectFirstAsync(opts?: {
+        ensureVisible?: boolean;
+    }): Promise<void>;
+    ensureSelectionVisibleAsync(): Promise<void>;
+    doLoadAsync(loadSpec: LoadSpec): Promise<any>;
+    loadData(rawData: any[], rawSummaryData?: PlainObject): void;
+    updateData(rawData: PlainObject[] | StoreTransaction): PlainObject;
+    clear(): void;
+    setGroupBy(colIds: Some<string>): void;
+    setSortBy(sorters: Some<GridSorterLike>): void;
+}

package/build/types/cmp/dataview/index.d.ts

@@ -0,0 +1,2 @@
+export * from './DataView';
+export * from './DataViewModel';

package/build/types/cmp/filter/FilterChooserFieldSpec.d.ts

@@ -0,0 +1,39 @@
+import { BaseFilterFieldSpec, BaseFilterFieldSpecConfig } from '@xh/hoist/data/filter/BaseFilterFieldSpec';
+import { FieldFilterOperator } from '@xh/hoist/data/filter/Types';
+import { ReactNode } from 'react';
+export interface FilterChooserFieldSpecConfig extends BaseFilterFieldSpecConfig {
+    /**
+     * Function to produce a suitably formatted string for display to the user
+     * for any given field value.
+     */
+    valueRenderer?: FilterChooserValueRenderer;
+    /**
+     * Function to parse user's input from a FilterChooser control into a typed data value for
+     * use in filtering comparisons.
+     */
+    valueParser?: FilterChooserValueParser;
+    /** Sample / representative value displayed by `FilterChooser` components to aid usability. */
+    example?: string;
+}
+/**
+ * Filter field specification class for the typeahead `FilterChooser` component. Manages additional
+ * configuration related to data values available for suggestion.
+ *
+ * Apps should NOT instantiate this class directly. Instead see {@link FilterChooserModel.fieldSpecs}
+ * for the relevant config to set these options.
+ */
+export declare class FilterChooserFieldSpec extends BaseFilterFieldSpec {
+    valueRenderer: FilterChooserValueRenderer;
+    valueParser: FilterChooserValueParser;
+    example: string;
+    /** @internal */
+    constructor({ valueRenderer, valueParser, example, ...rest }: FilterChooserFieldSpecConfig);
+    renderValue(value: any, op: FieldFilterOperator): string;
+    parseValue(value: any, op: FieldFilterOperator): any;
+    parseExample(example: any): any;
+    parseValueParser(valueParser: any): any;
+    loadValuesFromSource(): void;
+}
+type FilterChooserValueRenderer = (value: any, op: FieldFilterOperator) => ReactNode;
+type FilterChooserValueParser = (input: string, op: FieldFilterOperator) => any;
+export {};

package/build/types/cmp/filter/FilterChooserModel.d.ts

@@ -0,0 +1,130 @@
+import { HoistModel, PersistenceProvider, PersistOptions, PlainObject, TaskObserver } from '@xh/hoist/core';
+import { Filter, Store, View } from '@xh/hoist/data';
+import { CompoundFilterSpec, FieldFilterSpec, FilterLike } from '@xh/hoist/data/filter/Types';
+import { ReactNode } from 'react';
+import { FilterChooserFieldSpec, FilterChooserFieldSpecConfig } from './FilterChooserFieldSpec';
+import { FilterChooserOption } from './impl/Option';
+import { QueryEngine } from './impl/QueryEngine';
+export interface FilterChooserConfig {
+    /**
+     * Specifies the fields this model supports for filtering and customizes how their available values
+     * will be parsed and displayed. If a `valueSource` is provided, these may be specified as field
+     * names in that source or omitted entirely, indicating that all fields should be filter-enabled.
+     */
+    fieldSpecs?: Array<FilterChooserFieldSpecConfig | string>;
+    /** Default properties to be assigned to all FilterChooserFieldSpecs created by this model. */
+    fieldSpecDefaults?: Partial<FilterChooserFieldSpecConfig>;
+    /**
+     * Store or cube View that should actually be filtered as this model's value changes.
+     * This may be the same as `valueSource`. Leave undefined if you wish to combine this model's values
+     * with other filters, send it to the server, or otherwise observe and handle value changes manually.
+     */
+    bind?: Store | View;
+    /**
+     * Store or cube View to be used to lookup matching Field-level defaults for `fieldSpecs` and to
+     * provide suggested data values (if so configured) from user input. Defaults to `bind` if provided.
+     */
+    valueSource?: Store | View;
+    /**
+     * Configuration for a filter appropriate to be rendered and managed by FilterChooser, or a function
+     * to produce the same. Note that FilterChooser currently can only edit and create a flat collection
+     * of FieldFilters, to be 'AND'ed together.
+     */
+    initialValue?: FilterChooserFilterLike | (() => FilterChooserFilterLike);
+    /**
+     * Initial favorites as an array of filter configurations, or a function to produce such an array.
+     */
+    initialFavorites?: FilterChooserFilterLike[] | (() => FilterChooserFilterLike[]);
+    /**
+     * true to offer all field suggestions when the control is focused with an empty query,
+     * to aid discoverability.
+     */
+    suggestFieldsWhenEmpty?: boolean;
+    /**
+     * true (default) to sort field suggestions by displayed label. Set to false to preserve
+     * the order provided to `fieldSpecs`.
+     */
+    sortFieldSuggestions?: boolean;
+    /**
+     * Maximum number of filter tags to render before disabling the control.
+     * Limits the performance impact of rendering large filters.
+     */
+    maxTags?: number;
+    /** Maximum number of dropdown options to show before truncating. */
+    maxResults?: number;
+    /**
+     * Blurb displayed above field suggestions when the control is focused but user has yet
+     * to enter a query, or null to suppress default. */
+    introHelpText?: ReactNode;
+    /** Options governing persistence. */
+    persistWith?: FilterChooserPersistOptions;
+}
+export declare class FilterChooserModel extends HoistModel {
+    value: Filter;
+    favorites: Filter[];
+    bind: Store | View;
+    valueSource: Store | View;
+    fieldSpecs: FilterChooserFieldSpec[];
+    suggestFieldsWhenEmpty: boolean;
+    sortFieldSuggestions: boolean;
+    maxTags: number;
+    maxResults: number;
+    introHelpText: ReactNode;
+    provider: PersistenceProvider;
+    persistValue: boolean;
+    persistFavorites: boolean;
+    /** Tracks execution of filtering operation on bound object.*/
+    filterTask: TaskObserver;
+    queryEngine: QueryEngine;
+    selectOptions: FilterChooserOption[];
+    selectValue: string[];
+    favoritesIsOpen: boolean;
+    unsupportedFilter: boolean;
+    inputRef: import("react").RefObject<HTMLElement> & ((instance: HTMLElement) => void);
+    constructor({ fieldSpecs, fieldSpecDefaults, bind, valueSource, initialValue, initialFavorites, suggestFieldsWhenEmpty, sortFieldSuggestions, maxTags, maxResults, persistWith, introHelpText }?: FilterChooserConfig);
+    /**
+     * Set the value displayed by this control.
+     *
+     * Supports one or more FieldFilters to be 'AND'ed together, or
+     * an 'AND' CompoundFilter containing such a collection of FieldFilters.
+     *
+     * 'OR' CompoundFilters or nested CompoundFilters are partially supported -
+     * they will be displayed as tags and can be removed, but not created using
+     * the control.
+     *
+     * Any other Filter is unsupported and will cause the control to show a placeholder error.
+     */
+    setValue(rawValue: FilterLike): void;
+    setSelectValue(selectValue: string[]): void;
+    toDisplayFilters(filter: Filter): any[];
+    queryAsync(query: string): Promise<FilterChooserOption[]>;
+    autoComplete(value: any): void;
+    createFilterOption(filter: Filter): FilterChooserOption;
+    get favoritesOptions(): {
+        value: Filter;
+        filterOptions: FilterChooserOption[];
+    }[];
+    openFavoritesMenu(): void;
+    closeFavoritesMenu(): void;
+    setFavorites(favorites: Filter[]): void;
+    addFavorite(filter: Filter): void;
+    removeFavorite(filter: Filter): void;
+    findFavorite(filter: Filter): Filter;
+    isFavorite(filter: Filter): boolean;
+    get persistState(): PlainObject;
+    parseFieldSpecs(specs: Array<FilterChooserFieldSpecConfig | string>, fieldSpecDefaults: Partial<FilterChooserFieldSpecConfig>): Array<FilterChooserFieldSpec>;
+    getFieldSpec(fieldName: string): FilterChooserFieldSpec;
+    validateFilter(f: Filter): boolean;
+    getDefaultIntroHelpText(): string;
+}
+interface FilterChooserPersistOptions extends PersistOptions {
+    /** True (default) to save value to state. */
+    persistValue?: boolean;
+    /** True (default) to include favorites. */
+    persistFavorites?: boolean;
+}
+/**
+ * A variant of FilterLike, that excludes FunctionFilters and FilterTestFn.
+ */
+export type FilterChooserFilterLike = Filter | CompoundFilterSpec | FieldFilterSpec | FilterChooserFilterLike[];
+export {};

package/build/types/cmp/filter/impl/Option.d.ts

@@ -0,0 +1,47 @@
+export interface FilterChooserOption {
+    /**
+     * Indicates if option allows user to select a fully-formed filter, or a field to use for
+     * filtering, or if option is an unselectable informational message.
+     */
+    type: 'filter' | 'field' | 'msg' | 'minimalField';
+    /** Unique value for the underlying Select. */
+    value: string;
+    /** Unique display for the underlying Select. */
+    label: string;
+    /** If based on a matching process, was this an exact match? */
+    isExact: boolean;
+    /** Additional properties specific to the option type */
+    [key: string]: any;
+}
+/**
+ * Create an option representing a detailed field suggestion.
+ */
+export declare function fieldOption({ fieldSpec, isExact }: {
+    fieldSpec: any;
+    isExact?: boolean;
+}): FilterChooserOption;
+/**
+ * Create an option representing a minimal field suggestion.
+ */
+export declare function minimalFieldOption({ fieldSpec }: {
+    fieldSpec: any;
+}): FilterChooserOption;
+/**
+ * Create an option representing an existing or suggested FieldFilter.
+ */
+export declare function fieldFilterOption({ filter, fieldSpec, isExact }: {
+    filter: any;
+    fieldSpec: any;
+    isExact?: boolean;
+}): FilterChooserOption;
+/**
+ * Create an option representing a compound filter. For display purposes only.
+ */
+export declare function compoundFilterOption({ filter, fieldNames }: {
+    filter: any;
+    fieldNames: any;
+}): FilterChooserOption;
+/**
+ * Create an option representing an [unselectable] message
+ */
+export declare function msgOption(msg: string): FilterChooserOption;

package/build/types/cmp/filter/impl/QueryEngine.d.ts

@@ -0,0 +1,29 @@
+import { Some } from '@xh/hoist/core';
+import { FilterChooserOption } from './Option';
+import { FilterChooserModel } from '../FilterChooserModel';
+import { FilterChooserFieldSpec } from '../FilterChooserFieldSpec';
+/**
+ * Provide the querying support for FilterChooserModel.
+ *
+ * @internal
+ *
+ * Process the user typed query, FieldSpecs, and FilterChooserModel to come up with a sorted list
+ * of auto-complete options to be displayed to the user.
+ */
+export declare class QueryEngine {
+    model: FilterChooserModel;
+    constructor(model: FilterChooserModel);
+    queryAsync(query: string): Promise<FilterChooserOption[]>;
+    whenNoQuery(): FilterChooserOption[];
+    openSearching(q: any): Some<FilterChooserOption>;
+    withIsSearchingOnField(q: any): Some<FilterChooserOption>;
+    valueSearchingOnField(q: any): Some<FilterChooserOption>;
+    valueSearchingOnAll(q: any): Some<FilterChooserOption>;
+    getFieldOpts(queryStr: any): FilterChooserOption[];
+    getMinimalFieldOpts(): FilterChooserOption[];
+    getValueMatchesForField(op: any, queryStr: any, spec: any): FilterChooserOption[];
+    get fieldSpecs(): FilterChooserFieldSpec[];
+    getDecomposedQuery(raw: string): any;
+    sortAndTruncate(results: FilterChooserOption[]): FilterChooserOption[];
+    sort(results: FilterChooserOption[]): FilterChooserOption[];
+}

package/build/types/cmp/filter/index.d.ts

@@ -0,0 +1 @@
+export * from './FilterChooserModel';

package/build/types/cmp/form/BaseFormFieldProps.d.ts

@@ -0,0 +1,33 @@
+import { BoxProps, HoistProps } from '@xh/hoist/core';
+import { ReactNode } from 'react';
+import { FieldModel } from './field/FieldModel';
+export interface BaseFormFieldProps extends HoistProps<FieldModel>, BoxProps {
+    /**
+     * CommitOnChange property for underlying HoistInput (for inputs that support).
+     * Defaulted from containing Form.
+     */
+    commitOnChange?: boolean;
+    /** True to disable user interaction. Defaulted from backing FieldModel. */
+    disabled?: boolean;
+    /** Property name on bound FormModel from which to read/write data. */
+    field: string;
+    /** Additional description or info to be displayed alongside the input control. */
+    info?: ReactNode;
+    /**
+     * Label for form field. Defaults to Field displayName. Set to null to hide.
+     * Can be defaulted from contained Form (specifically, to null to hide all labels).
+     */
+    label?: ReactNode;
+    /**
+     * Apply minimal styling - validation errors are only displayed with a red outline.
+     * Defaulted from containing Form, or false.
+     */
+    minimal?: boolean;
+    /**
+     * Optional function for use in readonly mode. Called with the Field's current value and should
+     * return an element suitable for presentation to the end-user. Defaulted from containing Form.
+     */
+    readonlyRenderer?: (v: any) => ReactNode;
+    /** The indicator to display next to a required field. Defaults to `*`. */
+    requiredIndicator?: string;
+}

package/build/types/cmp/form/Form.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="react" />
+import { DefaultHoistProps, HoistProps } from '@xh/hoist/core';
+import { FormModel } from './FormModel';
+import { BaseFormFieldProps } from './BaseFormFieldProps';
+/** @internal */
+export interface FormContextType {
+    /** Defaults props to be applied to contained fields. */
+    fieldDefaults?: Partial<BaseFormFieldProps> & DefaultHoistProps;
+    /** Reference to associated FormModel. */
+    model?: FormModel;
+}
+/** @internal */
+export declare const FormContext: import("react").Context<FormContextType>;
+export interface FormProps extends HoistProps<FormModel> {
+    /**
+     * Defaults for certain props on child/nested FormFields.
+     * @see FormField (note there are both desktop and mobile implementations).
+     */
+    fieldDefaults?: Partial<BaseFormFieldProps> & DefaultHoistProps;
+}
+/**
+ * Wrapper component for a data-input form. This is the top-level entry point (along with its model
+ * class, FormModel) for building a form of arbitrary complexity with support for data binding,
+ * default / initial values, client-side validation rules, and nested sub-forms.
+ *
+ * This container accepts any manner of child components for layout or other purposes, but is
+ * primarily designed to apply defaults to and manage data binding for FormField components, which
+ * can be nested at any level below this parent component.
+ *
+ * @see FormModel - top-level model for Hoist form support, which holds a collection of...
+ * @see FieldModel - field-level model, which manages field-level specs/data to be rendered by a...
+ * @see FormField - field-level wrapper component, which labels and displays info for a...
+ * @see HoistInput - superclass for the data entry components themselves.
+ */
+export declare const Form: import("react").FC<FormProps>, form: import("@xh/hoist/core").ElementFactory<FormProps>;

package/build/types/cmp/form/FormModel.d.ts

@@ -0,0 +1,130 @@
+import { HoistModel, PlainObject } from '@xh/hoist/core';
+import { ValidationState } from '@xh/hoist/data';
+import { BaseFieldConfig, BaseFieldModel } from './field/BaseFieldModel';
+import { SubformsFieldConfig, SubformsFieldModel } from './field/SubformsFieldModel';
+export interface FormConfig {
+    /**
+     * FieldModels, or configurations to create them, for all data fields managed by this FormModel.
+     */
+    fields?: Array<BaseFieldModel | BaseFieldConfig | SubformsFieldConfig | SubformsFieldModel>;
+    /** Map of initial values for fields in this model. */
+    initialValues?: PlainObject;
+    disabled?: boolean;
+    readonly?: boolean;
+    /** @internal */
+    xhImpl?: boolean;
+}
+/**
+ * FormModel is the main entry point for Form specification. This Model's `fields` collection holds
+ * multiple FieldModel instances, which in turn hold the state of user edited data and the
+ * validation rules around editing that data.
+ *
+ * A complete representation of all fields and data within a Form can be produced via this model's
+ * `getData()` method, making it easy to harvest all values for e.g. submission to a server.
+ *
+ * Individual field values are also available as observables via this model's `values` proxy. An
+ * application model can setup a reaction to track changes to any value and execute app-specific
+ * logic such as disabling one field based on the state of another, or setting up cascading options.
+ *
+ * This Model provides an overall validation state, determined by the current validation state of
+ * its fields as per their configured rules and constraints.
+ *
+ * FormModels can be nested via SubformsFieldModels, a specialized type of FieldModel that itself
+ * manages a collection of child FormModels. This allows use cases where Forms support editing of
+ * dynamic collections of complex objects with their own internal validation rules (e.g. a FormModel
+ * representing a market order might have multiple nested FormModels to represent execution splits,
+ * where each split has its own internal fields for broker, quantity, and time).
+ *
+ * @see FieldModel for details on state and validation maintained at the individual field level.
+ */
+export declare class FormModel extends HoistModel {
+    /** Container object for FieldModel instances, keyed by field name.*/
+    fields: Record<string, BaseFieldModel>;
+    /** All FieldModel instances. */
+    get fieldList(): BaseFieldModel[];
+    parent: FormModel;
+    disabled: boolean;
+    readonly: boolean;
+    private valuesProxy;
+    /**
+     * @returns proxy for access to observable field values, keyed by field name.
+     *
+     * Read field value(s) off of this object within a reaction's track or component render function
+     * to react to changes to those specific values - e.g. to disable one field based on the value
+     * of another. This proxy is also passed to validation rules to facilitate reactive cross-field
+     * validation - e.g. marking a field as invalid due to a change in another.
+     *
+     * See {@link getData} instead if you need to get or react to the values of *any/all* fields.
+     */
+    get values(): PlainObject;
+    constructor({ fields, initialValues, disabled, readonly, xhImpl }?: FormConfig);
+    getField(fieldName: string): BaseFieldModel;
+    /**
+     * Snapshot of current field values, keyed by field name.
+     *
+     * Call within a reaction's track or component render function to react to *any* field change.
+     * See {@link values} instead if you need to get or react to the value of a *single* field.
+     *
+     * @param dirtyOnly - true to include only dirty field values in the return
+     */
+    getData(dirtyOnly?: boolean): PlainObject;
+    /**
+     * Reset fields to initial values and reset validation.
+     *
+     * This is typically used by interfaces to restore a 'dirty' user-modified form to a state
+     * where all field values are at their initial values.
+     */
+    reset(): void;
+    /**
+     * Set the initial value of all fields and reset the form.
+     *
+     * This is the main programmatic entry point for loading new data (or an empty new record)
+     * into the form for editing. If initial values are undefined for any field, the original
+     * initial values specified during model construction will be used.
+     *
+     * @param initialValues - map of field name to value.
+     */
+    init(initialValues?: PlainObject): void;
+    /**
+     * Set the value of one or more fields on this form.
+     *
+     * @param values - map of field name to value.
+     */
+    setValues(values: PlainObject): void;
+    /** True if any fields have been changed since last reset/init. */
+    get isDirty(): boolean;
+    /**
+     * The Field that is currently focused on this form.
+     *
+     * @see FieldModel.focus() for important information on this method
+     * and its limitations.
+     */
+    get focusedField(): BaseFieldModel;
+    /**
+     * Focus a field on this form.
+     *
+     * @see FieldModel.focus() for important information on this method
+     * and its limitations.
+     */
+    focusField(name: string): void;
+    get validationState(): ValidationState;
+    /** True if any fields are currently recomputing their validation state. */
+    get isValidationPending(): boolean;
+    /** True if all fields are valid. */
+    get isValid(): boolean;
+    /** List of all validation errors for this form. */
+    get allErrors(): string[];
+    /**
+     * Recompute all validations and return true if the form is valid.
+     *
+     * @param opts - set 'display' to true to trigger the display of
+     *  validation errors (if any) by bound FormField components after validation
+     *  is complete.
+     */
+    validateAsync(opts?: {
+        display?: boolean;
+    }): Promise<boolean>;
+    /** Trigger the display of validation errors (if any) by bound FormField components. */
+    displayValidation(): void;
+    private createValuesProxy;
+}