optikos 0.0.0-stage → 0.2.0

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

@@ -0,0 +1,32 @@
+import { TextField, type TextFieldConfig } from '../textfield/textfield.js';
+import { type DateRange } from '../../dates/calendar/calendar.js';
+export interface DateRangeFieldConfig extends TextFieldConfig<DateRange | null> {
+    min?: string;
+    max?: string;
+    firstDay?: number;
+}
+/**
+ * Value is `{ start, end }` (ISO dates) or null. The text reads `01/03/2025 – 15/03/2025` (typed or picked); the calendar
+ * takes two clicks, and the popup closes on the second.
+ */
+export declare class DateRangeField extends TextField<DateRange | null, DateRangeFieldConfig> {
+    protected baseCls: string;
+    private cal;
+    private dd;
+    private garbage;
+    protected emptyValue(): null;
+    protected isEmpty(v: DateRange | null): boolean;
+    protected parse(text: string): DateRange | null;
+    protected display(v: DateRange | null): string;
+    protected createControl(): HTMLDivElement;
+    protected onKey(e: KeyboardEvent): void;
+    protected onInput(): void;
+    protected applyValue(v: DateRange | null): void;
+    protected onDisabled(disabled: boolean): void;
+    protected check(): string;
+    open(): void;
+    close(): void;
+    toggle(): void;
+    setMin(min: string | undefined): void;
+    setMax(max: string | undefined): void;
+}

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

@@ -0,0 +1,84 @@
+import { Field, type FieldConfig } from '../../../core/field.js';
+export type DialValue = number | string;
+export interface DialOption {
+    value: DialValue;
+    label?: string;
+}
+export interface DialConfig extends FieldConfig<DialValue> {
+    min?: number;
+    max?: number;
+    step?: number;
+    /** A list instead of a range: the value is the item's value. */
+    options?: (DialValue | DialOption)[];
+    /** Snap points: every multiple of N (a range, default 10), every N items (a list, default 1), explicit values, or none. */
+    snap?: number | DialValue[] | false;
+    shape?: 'linear' | 'circle';
+    format?: (v: DialValue) => string;
+    /** Which ticks get a label. Default `snap`. */
+    labels?: 'snap' | 'all' | 'none';
+}
+/** A flat ruler (or a clock face) to pick one value from a range or a list, with a rolling readout. */
+export declare class Dial extends Field<DialValue, DialConfig> {
+    protected baseCls: string;
+    private face;
+    private tape;
+    private needle;
+    private readout;
+    private cache?;
+    /** Where the ruler sits, as an item index (fractional while dragging). */
+    private pos;
+    /** The hand's angle in circle mode, kept continuous so it always turns the short way. */
+    private angle;
+    private shown;
+    private stopGlide?;
+    constructor(config?: DialConfig);
+    private get isCircle();
+    private get items();
+    private fmt;
+    private buildItems;
+    protected emptyValue(): DialValue;
+    protected isEmpty(): boolean;
+    private indexOf;
+    private normalize;
+    private get index();
+    protected createControl(): HTMLDivElement;
+    protected onRender(): void;
+    private paintTicks;
+    protected build(): HTMLElement;
+    /** Distance in px between two ticks on the ruler, for drags (12 when there is no layout, as in tests). */
+    private spacing;
+    private place;
+    /** Turns the hand to item `i` the short way round. */
+    private aim;
+    protected applyValue(v: DialValue): void;
+    /** ARIA, the current tick and the readout for item `i`. */
+    private paintState;
+    /** Digits roll like an odometer when the text keeps its shape; any other change slides the new text in. */
+    private paintReadout;
+    /** The user picked item `i`: animate there and tell everyone. */
+    private choose;
+    private get locked();
+    private onKey;
+    /** The next snap point after item `i` in direction `dir` (or the limit when there is none). */
+    private snapFrom;
+    private angleAt;
+    private onDown;
+    /** Comes to rest on item `i`; a glide (after a flick) takes longer the further it goes. */
+    private rest;
+    /** Moves `n` steps (negative goes back). */
+    next(n?: number): void;
+    prev(n?: number): void;
+    nextSnap(): void;
+    prevSnap(): void;
+    getDisplayText(): string;
+    private rebuild;
+    setMin(min: number): void;
+    setMax(max: number): void;
+    setStep(step: number): void;
+    setOptions(options: DialConfig['options']): void;
+    setSnap(snap: DialConfig['snap']): void;
+    setShape(shape: 'linear' | 'circle'): void;
+    setFormat(format: DialConfig['format']): void;
+    protected onDisabled(disabled: boolean): void;
+    protected onReadonly(readonly: boolean): void;
+}

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

@@ -0,0 +1,54 @@
+import { Component, type ComponentConfig } from '../../../core/component.js';
+export interface ListItem {
+    value: unknown;
+    label: string;
+    disabled?: boolean;
+    /** Secondary text at the end of the row (e.g. the record id). */
+    hint?: string;
+    /** The original option/record this item was built from. */
+    raw?: unknown;
+}
+export interface ListBoxConfig extends ComponentConfig {
+    items?: ListItem[];
+    selected?: unknown;
+    emptyText?: string;
+    maxHeight?: number | string;
+    /** Custom cell content; default is the label (with `highlight` applied). */
+    renderer?: (item: ListItem) => string | Node;
+    /** Text to mark inside labels (the search term). */
+    highlight?: string;
+}
+/**
+ * Virtualized list of options. It never takes focus: the owner keeps it (a combobox input) and points
+ * `aria-activedescendant` at `getActiveId()`.
+ */
+export declare class ListBox extends Component<ListBoxConfig> {
+    protected baseCls: string;
+    private items;
+    private active;
+    private v?;
+    private emptyEl;
+    constructor(config?: ListBoxConfig);
+    protected build(): HTMLDivElement;
+    protected onRender(): void;
+    private indexOf;
+    private renderRow;
+    private isSelected;
+    private updateEmpty;
+    getItems(): ListItem[];
+    setItems(items: ListItem[]): void;
+    setSelected(value: unknown): void;
+    setHighlight(text: string): void;
+    setEmptyText(text: string): void;
+    /** Re-measures the row height and redraws (call after the list becomes visible). */
+    refresh(): void;
+    setActive(index: number, scroll?: boolean): void;
+    /** Moves the active item by `delta`, skipping disabled ones and wrapping around. */
+    moveActive(delta: number): void;
+    getActive(): ListItem | undefined;
+    getActiveIndex(): number;
+    getActiveId(): string;
+    /** Picks the item at `index` (default: the active one) and emits `select`. */
+    activate(index?: number): void;
+    scrollTo(index: number): void;
+}

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

@@ -0,0 +1,25 @@
+import { SuggestField, type SuggestConfig } from '../suggestfield/suggestfield.js';
+import { type LookupDef } from '../../data/searchgrid/searchgrid.js';
+export interface LookupFieldConfig<V = unknown> extends SuggestConfig<V> {
+    /** A definition or the name given to `registerLookup`. */
+    lookup: LookupDef | string;
+}
+/**
+ * Pick a record from a big set: type to get suggestions, or press the magnifier (or F4) to open a search window
+ * with filters and a grid. The value is the record's `valueField`; the text is its `displayField`.
+ */
+export declare class LookupField<V = unknown> extends SuggestField<V> {
+    protected baseCls: string;
+    private def;
+    private suggestStore?;
+    private win?;
+    constructor(config: LookupFieldConfig<V>);
+    /** Typing: filter a private store by the quick-search field and offer its page of records. */
+    private suggest;
+    protected createControl(): HTMLDivElement;
+    protected onKey(e: KeyboardEvent): void;
+    protected onDisabled(disabled: boolean): void;
+    /** Opens the search window; the text typed so far pre-fills the quick-search field. */
+    openDialog(): void;
+    private pickRecord;
+}

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

@@ -0,0 +1,31 @@
+import { TextField, type TextFieldConfig } from '../textfield/textfield.js';
+export interface NumberFieldConfig extends TextFieldConfig<number | null> {
+    min?: number;
+    max?: number;
+    step?: number;
+    /** Fixed decimals shown (and applied when the user leaves the field). */
+    decimals?: number;
+}
+export declare class NumberField extends TextField<number | null, NumberFieldConfig> {
+    protected baseCls: string;
+    /** Text that is not a number: reported as an error instead of silently dropped. */
+    private garbage;
+    protected emptyValue(): null;
+    protected isEmpty(v: number | null): v is null;
+    private get decimalSep();
+    protected parse(text: string): number | null;
+    protected display(v: number | null): string;
+    protected createControl(): HTMLDivElement;
+    private syncAria;
+    protected onInput(): void;
+    protected applyValue(v: number | null): void;
+    protected check(): string;
+    protected onKey(e: KeyboardEvent): void;
+    private bump;
+    increment(): void;
+    decrement(): void;
+    setMin(min: number | undefined): void;
+    setMax(max: number | undefined): void;
+    setStep(step: number): void;
+    setDecimals(decimals: number | undefined): void;
+}

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

@@ -0,0 +1,77 @@
+import { TextField, type TextFieldConfig } from '../textfield/textfield.js';
+import { Dropdown } from '../../overlays/dropdown/dropdown.js';
+import { ListBox, type ListItem } from '../listbox/listbox.js';
+import type { Store } from '../../../data/store.js';
+export type { ListItem };
+export type Option = string | number | Record<string, any>;
+export interface PickerConfig<V = unknown> extends TextFieldConfig<V> {
+    options?: Option[];
+    store?: Store<any>;
+    valueField?: string;
+    displayField?: string;
+    /** Text that does not match an item is discarded on blur. Default true. */
+    forceSelection?: boolean;
+    emptyText?: string;
+    openOnFocus?: boolean;
+    maxHeight?: number | string;
+    /** Show the record's value (its id) as a badge inside the field and as a hint in every list row. Default false. */
+    showValue?: boolean;
+}
+/**
+ * Shared base of Select, ComboBox and SuggestField: an input that owns a Dropdown with a ListBox,
+ * the ARIA combobox wiring and the keyboard model. Subclasses decide what typing does (`onType`)
+ * and whether the input is editable.
+ */
+export declare abstract class PickerField<V = unknown, C extends PickerConfig<V> = PickerConfig<V>> extends TextField<V, C> {
+    protected baseCls: string;
+    protected items: ListItem[];
+    protected selection?: ListItem;
+    /** The user typed since the last selection/blur; the input text is a search term, not the value's label. */
+    protected typed: boolean;
+    protected list: ListBox;
+    protected dd: Dropdown;
+    private triggerEl?;
+    private idEl?;
+    private wrapEl?;
+    private buffer;
+    private bufferTimer?;
+    protected editable(): boolean;
+    protected hasTrigger(): boolean;
+    /** Called when the user types in an editable picker. */
+    protected onType(_text: string): void;
+    protected toItem(o: Option): ListItem;
+    protected loadItems(): void;
+    setOptions(options: Option[]): void;
+    setStore(store: Store<any>): void;
+    private offStore?;
+    private bindStore;
+    protected findItem(value: unknown): ListItem | undefined;
+    getSelection(): ListItem | undefined;
+    /** Selects an item object directly (needed when the list does not contain it, e.g. a remote value). */
+    setSelection(item: ListItem | undefined, silent?: boolean): void;
+    /** The items to display for the current search state. Default: all. */
+    protected visibleItems(): ListItem[];
+    protected refreshList(): void;
+    private syncActive;
+    protected createControl(): HTMLDivElement;
+    protected onRender(): void;
+    protected onReadonly(readonly: boolean): void;
+    protected onDisabled(disabled: boolean): void;
+    protected applyValue(v: V): void;
+    /** The id badge (`showValue`): visible while a record is selected, and the input makes room for it. */
+    protected paintId(): void;
+    getDisplayText(): string;
+    open(): void;
+    close(): void;
+    toggle(): void;
+    expand(): void;
+    collapse(): void;
+    protected pick(item: ListItem): void;
+    /** Called on blur: commits free text or reverts to the selected label. */
+    protected settle(): void;
+    protected onInput(): void;
+    protected onKey(e: KeyboardEvent): void;
+    /** Select-style type-ahead: letters jump to the next label that starts with them. */
+    private typeahead;
+    setEmptyText(text: string): void;
+}

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

@@ -0,0 +1,26 @@
+import { Field, type FieldConfig } from '../../../core/field.js';
+export type RadioOption = string | {
+    value: string | number;
+    label: string;
+    disabled?: boolean;
+};
+export interface RadioGroupConfig extends FieldConfig<string | number | null> {
+    options?: RadioOption[];
+    direction?: 'vertical' | 'horizontal';
+}
+export declare class RadioGroup extends Field<string | number | null, RadioGroupConfig> {
+    protected baseCls: string;
+    private group;
+    private inputs;
+    protected emptyValue(): null;
+    protected createControl(): HTMLElement;
+    private opts;
+    private buildOptions;
+    protected onRender(): void;
+    protected applyValue(v: string | number | null): void;
+    /** The `is-checked` class (what the styled dot reads) mirrors the native `checked` of each option. */
+    private paintChecked;
+    getDisplayText(): string;
+    protected onDisabled(disabled: boolean): void;
+    setOptions(options: RadioOption[]): void;
+}

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

@@ -0,0 +1,52 @@
+import { TextField, type TextFieldConfig } from '../textfield/textfield.js';
+export interface SecretFieldConfig extends TextFieldConfig<string | null> {
+    /** A secret is already saved. It can never be shown; it can only be replaced. `form.load({ key: true })` sets it too. */
+    stored?: boolean;
+    /** Ask before replacing a saved secret. Default true. */
+    confirmReplace?: boolean;
+    replaceTitle?: string;
+    replaceText?: string;
+    /** The eye hides the value again when the field loses focus. Default true. */
+    autoHide?: boolean;
+}
+/**
+ * A field for secrets. While you type you can peek at what you typed (the eye); once a secret is saved it is shown only as a
+ * mask and can never be read back: to change it you replace it, after a warning. `getValue()` is `null` while untouched
+ * (keep what is saved), the new text once typed, `''` when replaced and left empty.
+ */
+export declare class SecretField extends TextField<string | null, SecretFieldConfig> {
+    protected baseCls: string;
+    private stored;
+    private initialStored;
+    private replacing;
+    private revealed;
+    private eyeBtn;
+    private replaceBtn;
+    private keepBtn;
+    private hint;
+    constructor(config?: SecretFieldConfig);
+    protected emptyValue(): string | null;
+    /** A saved secret that was not touched counts as filled in (so `required` is satisfied). */
+    protected isEmpty(v: string | null): boolean;
+    protected createControl(): HTMLDivElement;
+    protected onRender(): void;
+    isStored(): boolean;
+    /** The user chose to replace a saved secret and has not finished. */
+    isReplacing(): boolean;
+    isRevealed(): boolean;
+    /** Says whether a secret is saved (a saved secret is never given to the field, only the fact that it exists). */
+    setStored(stored: boolean): void;
+    /** `true` (what `form.load` passes for "a secret exists") means saved; a string is a new value typed or set by code. */
+    setValue(v: string | boolean | null, silent?: boolean): void;
+    markClean(): void;
+    /** Back to what was loaded: the saved secret, untouched. */
+    reset(): void;
+    /** Warns, then turns a saved secret into an empty field to type the new value in. Resolves to whether it was replaced. */
+    replace(): Promise<boolean>;
+    /** Gives up replacing: the saved secret stays as it was. */
+    keep(): void;
+    setRevealed(on: boolean): void;
+    /** Never reveals: a mask when there is something, nothing otherwise. */
+    getDisplayText(): string;
+    private paint;
+}

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

@@ -0,0 +1,10 @@
+import { PickerField, type PickerConfig } from '../pickerfield/pickerfield.js';
+export interface SelectConfig<V = unknown> extends PickerConfig<V> {
+}
+/** Pick one option from a closed list. The input is read-only; letters jump to matching labels. */
+export declare class Select<V = unknown> extends PickerField<V, SelectConfig<V>> {
+    protected baseCls: string;
+    protected editable(): boolean;
+    protected emptyValue(): V;
+    protected isEmpty(v: V): boolean;
+}

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

@@ -0,0 +1,62 @@
+import { Field, type FieldConfig } from '../../../core/field.js';
+export interface SliderMark {
+    value: number;
+    label?: string;
+}
+export interface SliderConfig extends FieldConfig<number | [number, number]> {
+    min?: number;
+    max?: number;
+    step?: number;
+    /** Two knobs: the value is `[low, high]`. */
+    range?: boolean;
+    marks?: boolean | SliderMark[];
+    /** When the bubble with the value shows. Default `drag` (while dragging or focused). */
+    showValue?: 'drag' | 'always' | 'never';
+    format?: (v: number) => string;
+    showScale?: boolean;
+}
+type V = number | [number, number];
+/** A bar with a ball to drag: a number, or a range with two balls. */
+export declare class Slider extends Field<V, SliderConfig> {
+    protected baseCls: string;
+    private track;
+    private fill;
+    private knobs;
+    private bubbles;
+    private marksEl;
+    private get min();
+    private get max();
+    private get step();
+    private get isRange();
+    protected emptyValue(): V;
+    protected isEmpty(): boolean;
+    private fmt;
+    private vals;
+    /** Snaps to a multiple of `step` inside [min, max] (without float noise). */
+    private snap;
+    protected createControl(): HTMLDivElement;
+    private buildKnobs;
+    protected onRender(): void;
+    private pct;
+    protected applyValue(v: V): void;
+    private paintMarks;
+    private valueAt;
+    private nearest;
+    private onTrackDown;
+    private onKnobDown;
+    /** The user moved knob `i` to `v`: update the value (knobs of a range never cross) and tell everyone. */
+    private setAt;
+    private onKey;
+    /** Where the (first) knob is, 0–100. */
+    getPercent(): number;
+    private refresh;
+    setMin(min: number): void;
+    setMax(max: number): void;
+    setStep(step: number): void;
+    private clampAll;
+    /** Switches between one knob and two; the value is converted. */
+    setRange(range: boolean): void;
+    protected onDisabled(disabled: boolean): void;
+    protected onReadonly(readonly: boolean): void;
+}
+export {};

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

@@ -0,0 +1,34 @@
+import { PickerField, type PickerConfig, type ListItem, type Option } from '../pickerfield/pickerfield.js';
+export interface SuggestConfig<V = unknown> extends PickerConfig<V> {
+    /** Async search. Receives the text and an AbortSignal that fires when a newer search starts. */
+    query?: (text: string, ctx: {
+        signal: AbortSignal;
+    }) => Promise<Option[]> | Option[];
+    minChars?: number;
+    /** Debounce in ms. */
+    delay?: number;
+    highlight?: boolean;
+    /** Leading icon name; `false` hides it. Default: the magnifier (`search`). */
+    icon?: string | false;
+}
+/** Search-as-you-type field: results come from `query` (or a Store with a proxy), not from a fixed list. */
+export declare class SuggestField<V = unknown> extends PickerField<V, SuggestConfig<V>> {
+    protected baseCls: string;
+    private seq;
+    private abort?;
+    private cancelWait?;
+    private live;
+    protected hasTrigger(): boolean;
+    protected emptyValue(): V;
+    protected isEmpty(v: V): boolean;
+    protected createControl(): HTMLDivElement;
+    protected onRender(): void;
+    protected onType(text: string): void;
+    /** Runs a search now (skips the debounce). */
+    search(text: string): Promise<void>;
+    private showResults;
+    private setSearching;
+    setQuery(query: NonNullable<SuggestConfig['query']>): void;
+    clearSuggestions(): void;
+    protected pick(item: ListItem): void;
+}

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

@@ -0,0 +1,16 @@
+import { TextField, type TextFieldConfig } from '../textfield/textfield.js';
+export interface TextAreaConfig extends TextFieldConfig {
+    rows?: number;
+    autoGrow?: boolean;
+    maxRows?: number;
+}
+export declare class TextArea extends TextField<string, TextAreaConfig> {
+    protected baseCls: string;
+    protected createInput(): HTMLTextAreaElement;
+    protected onKey(e: KeyboardEvent): void;
+    protected onInput(): void;
+    protected applyValue(v: string): void;
+    notifyMount(): void;
+    private grow;
+    setRows(rows: number): void;
+}

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

@@ -0,0 +1,38 @@
+import { Field, type FieldConfig } from '../../../core/field.js';
+export interface TextFieldConfig<V = string> extends FieldConfig<V> {
+    inputType?: 'text' | 'email' | 'tel' | 'url' | 'search' | 'password';
+    placeholder?: string;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    autocomplete?: string;
+    selectOnFocus?: boolean;
+    clearable?: boolean;
+}
+type Input = HTMLInputElement | HTMLTextAreaElement;
+export declare class TextField<V = string, C extends TextFieldConfig<V> = TextFieldConfig<V>> extends Field<V, C> {
+    protected baseCls: string;
+    protected clearBtn?: HTMLButtonElement;
+    /** Subclasses (TextArea, ...) replace the native control. */
+    protected createInput(): Input;
+    protected get input(): Input;
+    protected createControl(): HTMLDivElement;
+    /** The text the user typed becomes the value on every edit. */
+    protected onInput(): void;
+    /** Text → value. Subclasses with non-string values (NumberField) override. */
+    protected parse(text: string): V;
+    /** Value → text shown in the input. */
+    protected display(v: V): string;
+    protected onKey(e: KeyboardEvent): void;
+    getDisplayText(): string;
+    protected applyValue(v: V): void;
+    protected onReadonly(readonly: boolean): void;
+    protected onDisabled(disabled: boolean): void;
+    protected check(): string;
+    setPlaceholder(text: string): void;
+    setMaxLength(n: number): void;
+    setInputType(type: NonNullable<TextFieldConfig['inputType']>): void;
+    select(): void;
+    getInput(): Input;
+}
+export {};

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

@@ -0,0 +1,9 @@
+import { Checkbox, type CheckboxConfig } from '../checkbox/checkbox.js';
+export type ToggleConfig = Omit<CheckboxConfig, 'indeterminate'>;
+/** An on/off switch: a Checkbox with `role="switch"` and a track-and-knob look. Same value (`boolean`), events and API. */
+export declare class Toggle extends Checkbox {
+    protected baseCls: string;
+    protected onRender(): void;
+    /** A switch has no third state. */
+    setIndeterminate(): void;
+}

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

@@ -0,0 +1 @@
+export * from '../components/layout/fieldset/fieldset.js';

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

@@ -0,0 +1 @@
+export * from '../components/data/filterbuilder/filterbuilder.js';

package/dist/types/components/form/fieldgroup/fieldgroup.d.ts

@@ -0,0 +1,33 @@
+import { Container, type ContainerConfig } from '../../../core/container.js';
+import { Field } from '../../../core/field.js';
+export interface FieldGroupConfig extends ContainerConfig {
+    label?: string;
+    help?: string;
+    /** The `*` marker (also shown when any field inside is required). */
+    required?: boolean;
+    /** Default: the form's `labelPos`. */
+    labelPos?: 'top' | 'left';
+    /** Under this width (px) the row becomes a column. */
+    stackBelow?: number;
+}
+/** Several inputs read as one field: one label, one help line and one error line over a row of fields. */
+export declare class FieldGroup extends Container<FieldGroupConfig> {
+    protected baseCls: string;
+    private labelEl;
+    private bodyEl;
+    private helpEl;
+    private errorEl;
+    private error;
+    constructor(config?: FieldGroupConfig);
+    getBody(): HTMLElement;
+    /** The fields inside (also inside nested containers). */
+    getFields(): Field<any>[];
+    getError(): string;
+    protected build(): HTMLElement;
+    protected onRender(): void;
+    /** The group shows the first error of its fields, in one line. */
+    private paintError;
+    private describe;
+    setLabel(label: string): void;
+    setHelp(help: string): void;
+}

package/dist/types/components/form/fieldlist/fieldlist.d.ts

@@ -0,0 +1,58 @@
+import { Field, type FieldConfig } from '../../../core/field.js';
+import { Container } from '../../../core/container.js';
+import { type AnyConfig } from '../../../core/registry.js';
+import type { LayoutSpec } from '../../../layout/layout.js';
+import { Component } from '../../../core/component.js';
+type Row = Record<string, any>;
+export interface FieldListConfig extends FieldConfig<Row[]> {
+    /** The fields of one row (configs or instances such as `ui.text(...)`). Names are relative to the row (nested allowed). */
+    items?: Array<AnyConfig | Component>;
+    min?: number;
+    max?: number;
+    addText?: string;
+    reorderable?: boolean;
+    /** Values for a new row, or a function that returns them. */
+    newRow?: Row | (() => Row);
+    /** Layout of a row. Default `hbox` (the fields share the row). */
+    rowLayout?: LayoutSpec;
+}
+/** A repeating block of fields: add, remove and reorder rows; the value is an array of row objects. */
+export declare class FieldList extends Field<Row[], FieldListConfig> {
+    protected baseCls: string;
+    private rowsEl;
+    private addBtn;
+    private emptyEl;
+    private rows;
+    private syncing;
+    protected emptyValue(): Row[];
+    protected isEmpty(v: Row[]): boolean;
+    protected createControl(): HTMLDivElement;
+    protected onRender(): void;
+    private label;
+    private makeRow;
+    private rowFields;
+    private collect;
+    private commitRows;
+    /** Puts every row in place: its group name, tools, and which tools are allowed. */
+    private paintRows;
+    protected applyValue(value: Row[]): void;
+    /** Adds a row (at the end) and focuses its first field. */
+    addRow(values?: Row): void;
+    removeRow(index: number): void;
+    moveRow(from: number, to: number): void;
+    getRows(): Container[];
+    getRowFields(index: number): Field<any>[];
+    setAddText(text: string): void;
+    setMin(min: number): void;
+    setMax(max: number): void;
+    protected check(): string;
+    /** Validates every row too; the list is valid when its own rules and every field inside pass. */
+    validate(): boolean;
+    isValid(): boolean;
+    /** The first invalid field inside, or the add button. */
+    focus(): void;
+    protected onDisabled(disabled: boolean): void;
+    protected onReadonly(readonly: boolean): void;
+    protected onDestroy(): void;
+}
+export {};