@dynamicforms/vue-forms 1.1.0 → 2.0.3

package/dist/index.d.ts

@@ -15,6 +15,43 @@ import { TranslateStringsCallback } from '@dynamicforms/translatable';
 export declare class AbortEventHandlingException extends Error {
 }
 
+/**
+ * What a form element accepts and what it sends. The four values follow HTML: `'editable'` and `'readonly'` send
+ * the element's value the way an `<input>` and an `<input readonly>` are submitted, `'disabled'` sends nothing the
+ * way an `<input disabled>` is left out, and `'disabled-null'` sends `null` in the element's place.
+ *
+ * | access            | accepts input | contributes to its container's `value` |
+ * |-------------------|---------------|----------------------------------------|
+ * | `'editable'`      | yes           | its value                              |
+ * | `'readonly'`      | no            | its value                              |
+ * | `'disabled'`      | no            | nothing: the key or row is left out    |
+ * | `'disabled-null'` | no            | `null`                                 |
+ *
+ * An element that contributes no value of its own is not counted in its container's validity. `fullValue` carries
+ * every element whatever its access.
+ */
+export declare type Access = 'editable' | 'readonly' | 'disabled' | 'disabled-null';
+
+/** Told once an element's `access` has been written. */
+export declare class AccessChangedAction extends FieldActionBase {
+    constructor(executorFn: (field: FieldBase, supr: FieldActionExecute, newValue: Access, oldValue: Access) => void);
+    static get classIdentifier(): symbol;
+    execute(field: FieldBase, supr: FieldActionExecute, newValue: Access, oldValue: Access): void;
+}
+
+/**
+ * Asked before an element's `access` is written. A handler answers with the access to write instead, or throws
+ * `AbortEventHandlingException` to refuse the write.
+ */
+export declare class AccessChangingAction extends FieldActionBase {
+    constructor(executorFn: (field: FieldBase, supr: FieldActionExecute, newValue: Access, oldValue: Access) => Access);
+    static get classIdentifier(): symbol;
+    execute(field: FieldBase, supr: FieldActionExecute, newValue: Access, oldValue: Access): Access;
+}
+
+/** every access, in the order of the table above */
+export declare const accessValues: readonly Access[];
+
 export declare class Action<T extends ActionValue = ActionValue, X extends object = Omit<Extras, keyof ActionValue>> extends Field<T, X> {
     get [Symbol.toStringTag](): string;
     protected init(params?: IFieldParams<T, X>): void;
@@ -30,7 +67,7 @@ export declare class Action<T extends ActionValue = ActionValue, X extends objec
     get label(): T['label'];
     /**
      * The two setters hand the value setter a new object rather than writing into the one the action holds, so each
-     * is an ordinary value change: the handlers fire, isChanged answers over it, and a disabled action refuses it.
+     * is an ordinary value change: the handlers fire and isChanged answers over it.
      * The new object is built only for a member that differs from the one held - the value setter compares by
      * identity and every copy is a new object, so without the comparison here a write of the value already held
      * would announce a change and invalidate the value cache of every container above.
@@ -219,8 +256,12 @@ declare interface CompareToBindingState<T> extends ValidatorBindingState {
  */
 declare type CompareToTarget = FieldBase | string | ((field: FieldBase) => FieldBase | null | undefined);
 
-export declare class ConditionalEnabledAction extends ConditionalStatementAction {
-    constructor(statement: Statement);
+/**
+ * Sets the access of the elements it is registered on from the statement's result: `whenTrue` while the statement
+ * holds, `whenFalse` otherwise.
+ */
+export declare class ConditionalAccessAction extends ConditionalStatementAction {
+    constructor(statement: Statement, whenTrue?: Access, whenFalse?: Access);
 }
 
 declare type ConditionalExecutorFn = (field: FieldBase, currentResult: boolean, previousResult: boolean | undefined) => void;
@@ -270,8 +311,77 @@ export declare class ConditionalValueAction<T> extends ConditionalStatementActio
     constructor(statement: Statement, trueValue: T);
 }
 
+/**
+ * Sets the visibility of the elements it is registered on from the statement's result: `whenTrue` while the
+ * statement holds, `whenFalse` otherwise. Visibility is presentation alone, so what the elements send is left to
+ * their access.
+ */
 export declare class ConditionalVisibilityAction extends ConditionalStatementAction {
-    constructor(statement: Statement);
+    constructor(statement: Statement, whenTrue?: Visibility, whenFalse?: Visibility);
+}
+
+/**
+ * A form element that holds other elements and composes its state out of theirs: `Group`, which holds named
+ * members, and `List`, which holds rows. Every element's `parent` is a `Container`.
+ *
+ * What a container answers for over its children is the same whatever holds them: `valid` and `busy` are composed
+ * of theirs, `touched` is true where any child is touched and propagates an assignment down, `validate(true)`
+ * revalidates every child before the container forms its own verdict, and a child's change of value or verdict
+ * reaches the container through `notifyValueChanged()` and the tallies below. How the children are reached - by
+ * name or by position - is the subclass's.
+ */
+export declare abstract class Container<T = any, X extends object = Extras> extends FieldBase<T, X> {
+    get [Symbol.toStringTag](): string;
+    /**
+     * The children this container holds, read through the tracked view of its state: a verdict or a flag composed
+     * over them is formed again when a child is added or removed.
+     */
+    protected abstract get children(): readonly FieldBase[];
+    get touched(): boolean;
+    set touched(touched: boolean);
+    get valid(): boolean;
+    get busy(): boolean;
+    validate(revalidate?: boolean): void;
+    /**
+     * Records that a child changed its value, so that the transaction in progress works out at commit what this
+     * container's own value became and announces it once. The mutation methods call it themselves; you rarely need
+     * to.
+     */
+    notifyValueChanged(): void;
+    protected get composesValue(): boolean;
+    /**
+     * A container with nothing listening for what it holds does not compose it at all, so the copy it keeps is from
+     * before the changes nobody received. A registration that adds a listener brings it up to date here, and what
+     * the listener is then told about is the change that follows it.
+     */
+    protected refreshPreviousValue(): void;
+    /** A container holds every member's value whatever the member sends: its `fullValue`. */
+    protected get holding(): any;
+    /**
+     * The composed verdict `valid` answers with, memoised by Vue. The walk over the children is what makes an error
+     * pushed into one of them visible without a validate() call, and the computed keeps that walk from repeating
+     * while nothing it read has moved.
+     */
+    private get validRead();
+    /**
+     * The composed answer `busy` gives, memoised by Vue. An `Action` counts its executions in a counter of its own,
+     * which no container is told about, so the answer is composed over the children instead of tallied; the computed
+     * keeps the walk from repeating while nothing it read has moved, and a child that is itself a container answers
+     * from its own computed.
+     */
+    private get busyRead();
+    /**
+     * Records that a child started or stopped answering `validating` with true, and carries the transition further
+     * up where it changes this container's own answer.
+     */
+    protected childValidatingChanged(started: boolean): void;
+    /**
+     * Records a child's new verdict in this container's tally. The child reports it as it settles, and the commit
+     * settles the deepest element first, so the tally a container reads when its own turn comes is finished. The
+     * delta is applied here rather than recomputed by walking the children at commit, which would cost
+     * `O(children)` per container and turn a list fill back into the quadratic walk this tally exists to avoid.
+     */
+    protected childValidityChanged(nowValid: boolean): void;
 }
 
 /**
@@ -283,38 +393,28 @@ declare interface ContainerSlots<T = any> extends ElementSlots<T> {
     cachedValueVersion: number;
 }
 
-/** What a form element's visibility is when nothing sets it. It is a starting value, never a fallback for input. */
-export declare const defaultDisplayMode = DisplayMode.FULL;
-
 /**
- * DisplayMode enum provides an enumeration for supported ways of rendering a particular object in the DOM
+ * Told what an element contributes to its container's `value` once that changed over a transaction: the element's
+ * value where its access sends it, `null` for `'disabled-null'`, and `undefined` for `'disabled'`, whose key or row
+ * is left out. The pair carried is (contribution now, contribution at the last announcement).
+ *
+ * It answers a different question from `ValueChangedAction`, which reports what the element holds. A write into a
+ * `'disabled'` field changes what the field holds and not what it sends, so it fires `ValueChangedAction` alone;
+ * switching a field's access changes what it sends and not what it holds, so it fires this action alone. On a
+ * container, what it holds is its `fullValue` and what it sends is its `value`, so a change of a member's access
+ * reaches the containers above as a change of their contribution, never of their value.
  */
-export declare enum DisplayMode {
-    SUPPRESS = 1,// Field will be entirely suppressed. it will not render (not even to JSON) and will not parse for PUT
-    HIDDEN = 5,// Field will render as <input type="hidden"> or <tr data-field_name>
-    INVISIBLE = 8,// Field will render completely, but with display: none. Equal to setting its style = {display: none}
-    FULL = 10
+export declare class ContributionChangedAction<T = any> extends FieldActionBase {
+    constructor(executorFn: (field: FieldBase<T>, supr: FieldActionExecute<T>, newValue: unknown, oldValue: unknown) => void);
+    static get classIdentifier(): symbol;
+    execute(field: FieldBase<T>, supr: FieldActionExecute<T>, newValue: unknown, oldValue: unknown): void;
 }
 
-export declare namespace DisplayMode {
-    /**
-     * Resolves a constant's name, case insensitive, to the constant it names. Anything else - a misspelled name, a
-     * value that is not a string - throws an `Error` naming it. A mode nobody defined is an error at the point it
-     * arrives, not a field that renders as `FULL` and is never questioned.
-     */
-    export function fromString(mode: string): DisplayMode;
-    /**
-     * Resolves a DisplayMode number, or a constant's name (case insensitive), to a DisplayMode. A number that is
-     * none of the constants, a string that names none, and input that is neither a number nor a string all throw an
-     * `Error` naming the value. Ask `isDefined` where the answer is to be judged rather than raised.
-     */
-    export function fromAny(mode: any): DisplayMode;
-    /**
-     * Answers whether the input is a DisplayMode: a number that is one of the constants, or a string naming one,
-     * case insensitive. This is the way to ask that does not throw; it answers `false` where `fromAny` raises.
-     */
-    export function isDefined(mode: number | string): boolean;
-}
+/** What an element's access is when nothing sets it. */
+export declare const defaultAccess: Access;
+
+/** What an element's visibility is when nothing sets it. */
+export declare const defaultVisibility: Visibility;
 
 /**
  * The mutable state of one element, held in an object of its own beside the element rather than in the element's
@@ -340,11 +440,24 @@ export declare namespace DisplayMode {
 declare interface ElementSlots<T = any> {
     /** the value the element was given at construction; isChanged compares against it */
     originalValue: T;
-    /** the value the last ValueChangedAction reported; the next transaction measures its net change against it */
+    /**
+     * What the last ValueChangedAction reported the element as holding - its value, and a container's fullValue; the
+     * next transaction measures its net change against it
+     */
     announcedValue: T;
+    /**
+     * What the last ContributionChangedAction reported the element as contributing to its container: its value,
+     * `null`, or `undefined` for nothing
+     */
+    announcedContribution: unknown;
+    /**
+     * What a container's own validators last ran over - what it sends; the next transaction runs them where that
+     * moved. A leaf's validators run at the write and the access switch, and leave it untouched.
+     */
+    validatedValue: unknown;
     errors: ValidationError[];
-    visibility: DisplayMode;
-    enabled: boolean;
+    visibility: Visibility;
+    access: Access;
     /** counts the writes that changed the value of the element or of anything below it */
     valueVersion: number;
     /** how many asynchronous validation runs are in flight on this element */
@@ -352,7 +465,7 @@ declare interface ElementSlots<T = any> {
     /** how many direct children answer `validating` with true; a child that starts or stops running moves it */
     validatingChildren: number;
     /** the container that holds this element, absent while none does; takeChild writes it, releaseChild clears it */
-    parent: FieldBase | undefined;
+    parent: Container | undefined;
     /** the name the containing Group holds this element under; a List row carries none */
     fieldName: string | undefined;
     /** generation of the validators attached to the element; clearValidators() raises it */
@@ -375,18 +488,35 @@ declare interface ElementSlots<T = any> {
     invalidChildren: number;
 }
 
+/**
+ * Told once a write of `access` changed `enabled`: a switch into or out of `'editable'`. It fires after
+ * `AccessChangedAction`, and a switch between two accesses that are not `'editable'` does not fire it.
+ */
 export declare class EnabledChangedAction extends FieldActionBase {
     constructor(executorFn: (field: FieldBase, supr: FieldActionExecute, newValue: boolean, oldValue: boolean) => void);
     static get classIdentifier(): symbol;
     execute(field: FieldBase, supr: FieldActionExecute, newValue: boolean, oldValue: boolean): void;
 }
 
+/**
+ * Asked before a write of `access` that would change `enabled`: a switch into or out of `'editable'`. It is asked
+ * after `AccessChangingAction`, over the access that would be written. `enabled` is read from `access`, so the
+ * answer cannot set it: answering with the value `enabled` has now, or throwing `AbortEventHandlingException`,
+ * refuses the write of `access`, and answering with the new value, `null` or `undefined` lets it through.
+ */
 export declare class EnabledChangingAction extends FieldActionBase {
     constructor(executorFn: (field: FieldBase, supr: FieldActionExecute, newValue: boolean, oldValue: boolean) => boolean);
     static get classIdentifier(): symbol;
     execute(field: FieldBase, supr: FieldActionExecute, newValue: boolean, oldValue: boolean): boolean;
 }
 
+/**
+ * Where an error comes from. `'validator'` is an error a validator produced, `'server'` one the server returned and
+ * `'application'` one the application's own code computed and wrote into `errors`. Any other string is an origin of
+ * the application's own.
+ */
+export declare type ErrorOrigin = 'validator' | 'server' | 'application' | (string & {});
+
 export declare class ExecuteAction extends FieldActionBase {
     constructor(executorFn: (field: FieldBase, supr: FieldActionExecute, params: any) => any);
     static get classIdentifier(): symbol;
@@ -437,12 +567,6 @@ export declare class Field<T = any, X extends object = Extras> extends FieldBase
     protected init(params?: IFieldParams<T, X>): void;
     get value(): T;
     set value(newValue: T);
-    /**
-     * The container that holds this field. A `List` holds rows and a row is a `Group`, so a field is never a `List`'s
-     * child and the link is a `Group` wherever there is one: `field.parent?.fields.other` is the sibling lookup, and
-     * it is typed here.
-     */
-    get parent(): Group | undefined;
     get touched(): boolean;
     set touched(touched: boolean);
     bind(data?: T, overrides?: IBindParams<T, X>): this;
@@ -529,7 +653,7 @@ export declare abstract class FieldBase<T = any, X extends object = Extras> {
      * one answers `declaration` with.
      *
      * `data` of `undefined` is no data supplied and the new element carries what this one holds; an explicit `null`
-     * is data and clears. `overrides` states the rest: `originalValue` is read by key presence, `enabled` and
+     * is data and clears. `overrides` states the rest: `originalValue` is read by key presence, `access` and
      * `visibility` fall back to this element's, and extended properties it names are written over the ones carried
      * over. The new element is detached - no `parent`, no `fieldName` - so it is free to be taken by a container.
      */
@@ -574,7 +698,7 @@ export declare abstract class FieldBase<T = any, X extends object = Extras> {
     setExtendedValues(values: Partial<X>): void;
     /**
      * The extended properties a parameter object carries: every key the element does not answer for itself. A key
-     * the element answers for at the time the parameters are applied - `value`, `enabled`, an accessor a subclass
+     * the element answers for at the time the parameters are applied - `value`, `access`, an accessor a subclass
      * adds - is the element's own; a key that only Object.prototype answers for is nobody's declaration and counts
      * as extended, and `validators` and `actions` are neither, since they state what to register on the element.
      *
@@ -627,7 +751,8 @@ export declare abstract class FieldBase<T = any, X extends object = Extras> {
     endValidating(): void;
     /**
      * Records that a child started or stopped answering `validating` with true, and carries the transition further
-     * up where it changes this element's own answer.
+     * up where it changes this element's own answer. Only a `Container` has children, and it implements this; it is
+     * declared here because a child tells its container through it.
      */
     protected childValidatingChanged(started: boolean): void;
     /**
@@ -639,15 +764,6 @@ export declare abstract class FieldBase<T = any, X extends object = Extras> {
      * idle reads both.
      */
     get busy(): boolean;
-    /**
-     * The composed answer a container gives `busy`, memoised by Vue. An `Action` counts its executions in a counter
-     * of its own, which no container is told about, so the answer is composed over the members instead of tallied;
-     * the computed keeps the walk from repeating while nothing it read has moved, and a member that is itself a
-     * container answers from its own computed.
-     */
-    protected get busyRead(): boolean;
-    /** What busyRead computes. A container answers over its members; anything else executes nothing. */
-    protected composeBusy(): boolean;
     /**
      * Resolves once nothing at or below this element is running - no asynchronous validation, no `Action.execute()`
      * that has yet to settle. It is what a submit path awaits instead of polling `validating` and `busy`, and it
@@ -675,14 +791,14 @@ export declare abstract class FieldBase<T = any, X extends object = Extras> {
      * so an effect rendering off the link - `v-if="field.parent"` - re-runs when a container takes the element or
      * releases it.
      *
-     * A `List` holds rows and a row is a `Group`, so only a container can be a `List`'s child: `Field` narrows the
-     * type to `Group | undefined`, and the sibling lookup `field.parent?.fields.other` is typed on a field.
+     * The type is `Container`, which names no members: a sibling lookup states which container it expects, either
+     * with `field.parent instanceof Group` or with a cast where the structure guarantees it.
      */
-    get parent(): Group | List | undefined;
+    get parent(): Container | undefined;
     /**
-     * The same link at the type the internals reach through. The protected members a container is told things
-     * through - childValidatingChanged, childValidityChanged - are declared here, and a union of two subclasses is
-     * not an instance of this class, which is what a protected access needs.
+     * The same link at the type the internals reach through. The hooks a child tells its container things through -
+     * childValidatingChanged, childValidityChanged - are declared here, and a protected member is reachable only
+     * through the class that declares it; `Container` overrides them, so the link is read as a `FieldBase`.
      */
     private get container();
     /** when member of a Group, fieldName specifies the name of this field. Written by the group, read-only after */
@@ -776,9 +892,8 @@ export declare abstract class FieldBase<T = any, X extends object = Extras> {
      * construction rather than a change of it: the element announces no ValueChangedAction, and what the hook
      * leaves is what its eager actions and its validators run over, once. An element whose parameters named no
      * `originalValue` is baselined on the value the hook left and so starts unchanged; one that named a baseline is
-     * measured against it, as any element is. A `Field` writes
-     * `_value`, which reaches the slot on an element built `enabled: false` as well - the value setter, which a
-     * disabled field refuses, states a change, and this is not one.
+     * measured against it, as any element is. A `Field` writes `_value`: the value setter states a change, and
+     * this is not one.
      *
      * A container completes itself through its members, and a member carries a construction of its own: the write
      * reaches it as any later one would, so the member announces it and reports itself changed. A member that is to
@@ -788,9 +903,9 @@ export declare abstract class FieldBase<T = any, X extends object = Extras> {
      */
     protected constructed(params?: object): void;
     /**
-     * Re-reads the value that the next ValueChangedAction will report as the one it replaces. A leaf records what
-     * it announced at every announcement, so its copy is always current and there is nothing to re-read; a
-     * container that skipped composing a value nobody was listening for overrides this.
+     * Re-reads what the next announcements will report as replaced. A contribution is composed only where something
+     * listens for it, so the copy is re-read here; a leaf records what it holds at every announcement, so that copy
+     * is always current, and a container that skipped composing what nobody was listening for re-reads its own too.
      */
     protected refreshPreviousValue(): void;
     /**
@@ -827,40 +942,95 @@ export declare abstract class FieldBase<T = any, X extends object = Extras> {
     /** Resets a member. It is what lets a container reach the reset of a child whose class it does not know. */
     protected resetChild(child: FieldBase, source: FieldBase, value: any): void;
     /**
-     * Records a child's new verdict in this element's tally. The child reports it as it settles, and the commit
-     * settles the deepest element first, so the tally a container reads when its own turn comes is finished.
-     * The delta is applied here rather than recomputed by walking the members at commit, which would cost
-     * `O(members)` per container and turn a list fill back into the quadratic walk this tally exists to avoid.
+     * Records a child's new verdict in this element's tally. Only a `Container` has children, and it implements
+     * this; it is declared here for the reason `childValidatingChanged` is.
      */
     protected childValidityChanged(nowValid: boolean): void;
     /**
-     * The composed verdict a container answers `valid` with, memoised by Vue. The walk over the members is what
-     * makes an error pushed into one of them visible without a validate() call, and the computed keeps that walk
-     * from repeating while nothing it read has moved.
+     * How a rendering layer shows this element. It is presentation alone: what the element sends and whether it is
+     * validated are its `access`, and no visibility changes either.
      */
-    protected get validRead(): boolean;
-    /** What validRead computes. A leaf answers over its own errors; a container adds its members. */
-    protected composeValid(): boolean;
-    get visibility(): DisplayMode;
-    set visibility(newValue: DisplayMode);
-    get enabled(): boolean;
-    set enabled(newValue: boolean);
+    get visibility(): Visibility;
+    set visibility(newValue: Visibility);
     /**
-     * Whether this element and every container above it are enabled. A rendering layer binds one read instead of
-     * walking the parent chain: a disabled `Group` states that its section cannot be edited, and the inputs
-     * rendered from the members inside it read that here.
-     *
-     * It is a read and nothing else. `enabled` on each element stays exactly what was written to it, a write to a
-     * member of a disabled container is accepted the way it always was, and what a container serializes is decided
-     * by the members' own `enabled`. Where a whole subtree is to stop serializing, the members are disabled.
+     * What this element accepts and what it sends: `'editable'` and `'readonly'` send its value, `'disabled'` sends
+     * nothing and `'disabled-null'` sends `null`, and only `'editable'` accepts input. The validators run over what
+     * the element sends and only where it is sent at all, as `effectiveAccess` states, so a switch of access runs
+     * them again here and below.
+     */
+    get access(): Access;
+    set access(newValue: Access);
+    /**
+     * The access this element has once the containers above it are taken into account. A container that sends nothing
+     * or `null` in place of what it holds sends none of its members, so below a `'disabled'` or `'disabled-null'`
+     * container every element is `'disabled'`; below a `'readonly'` one an `'editable'` element is `'readonly'`.
+     * Anywhere else it is the element's own access.
      *
-     * `enabled` is the only member with a reading of this kind, and it is not a scheme the other members follow.
-     * `visibility` has none because `SUPPRESS` states that an element is absent from the value as well, so folding
-     * it down the tree would decide serialization rather than report it; `value` has none because a container
-     * composes its own from its members rather than passing one down. A rendering layer that needs a third thing
-     * folded down the tree has `provide`/`inject`, which is where the render tree's own context belongs.
+     * It is what decides whether the element's validators run: an element that is `'disabled'` here is sent nowhere,
+     * so its validators reach no verdict and it carries none of their errors. Anywhere else they run over what the
+     * element sends - its value, or `null`.
+     */
+    get effectiveAccess(): Access;
+    /**
+     * Whether `effectiveAccess` is `'disabled'`, read off the untracked state. A validator asks it on every run, where
+     * nothing renders off the answer and a tracked walk up the containers would cost every write a read per level.
+     */
+    [SentNowhere](): boolean;
+    /**
+     * True where `access` is `'editable'`: the element accepts input. It reads `access` and nothing else, and it is a
+     * statement about input rather than about data - `'readonly'` is not enabled and still sends its value. What an
+     * element sends is read from `access`.
+     */
+    get enabled(): boolean;
+    /**
+     * True where `effectiveAccess` is `'editable'`: this element and every container above it accept input. A
+     * rendering layer binds one read instead of walking the parent chain: a container that is not editable states
+     * that its section cannot be edited, and the inputs rendered from the members inside it read that here.
      */
     get effectiveEnabled(): boolean;
+    /** The effective access of this element and of every element below it, read before a change that may move it. */
+    private effectiveAccessFromHere;
+    /** The effective access of every element below this one, read before a change that may move it. */
+    private effectiveAccessBelow;
+    /**
+     * Runs the validators again on every element whose effective access moved since `before` was read: one that stops
+     * being sent drops their errors, and one that starts being sent is checked over what it now sends.
+     */
+    private revalidateWhereChanged;
+    /**
+     * What this element contributes to its container's `value` or `fullValue`: its own value, `null` in its place, or
+     * nothing. It is the one place the rule is stated - every container composes its values by asking it.
+     *
+     * `fullValue` states everything the form holds, so every element contributes its value there. `value` states
+     * what the form sends, and `access` decides it: `'disabled'` leaves the element out and `'disabled-null'` sends
+     * `null`, whatever a container holds below it.
+     */
+    protected serializesAs(purpose: 'value' | 'fullValue'): 'value' | 'null' | 'omit';
+    /** What `child` contributes to this container, asked the way `childComposesValue` asks what it is. */
+    protected childSerializesAs(child: FieldBase, purpose: 'value' | 'fullValue'): 'value' | 'null' | 'omit';
+    /**
+     * What this element sends to its container's `value`: its value where its access sends it, `null` for
+     * `'disabled-null'`, and `undefined` for `'disabled'`, whose key or row is left out. It is what the element's
+     * validators run over and what `ContributionChangedAction` reports.
+     */
+    get contribution(): unknown;
+    /**
+     * What `ValueChangedAction` reports this element as holding: its value. A container holds every member's value
+     * whatever the member sends, so it answers with its `fullValue`.
+     */
+    protected get holding(): any;
+    /**
+     * Whether the container holding this element counts its verdict: every element that sends something, `null`
+     * included. A `'disabled'` element sends nothing, so it is not counted - an error written into it by hand no more
+     * than one from a validator, which does not run there.
+     */
+    private get countsInContainer();
+    /**
+     * Carries a change of what this element sends: the element is enrolled so the commit measures its contribution
+     * and re-forms its verdict, the container's value is built again, and an element that is invalid enters or leaves
+     * the container's tally as it starts or stops being counted.
+     */
+    private contributionChanged;
     /**
      * True for an element whose value is composed of its members'. The commit builds such a value only where
      * something receives it, compares it by content rather than by identity, and runs the element's own validators
@@ -876,12 +1046,22 @@ export declare abstract class FieldBase<T = any, X extends object = Extras> {
      */
     protected childComposesValue(child: FieldBase): boolean;
     /**
-     * Announces what this element's value became over the transaction. The pair carried is (value now, value at the
-     * last announcement), so a value that went A -> B -> A within the transaction says nothing, and the events an
-     * operation states rather than an element's state - an item added, an item removed - are emitted first, in the
-     * order the operations happened.
+     * Announces what this element holds and what it sends, as they became over the transaction. Each pair carried is
+     * (now, at the last announcement), so a value that went A -> B -> A within the transaction says nothing, and the
+     * events an operation states rather than an element's state - an item added, an item removed - are emitted first,
+     * in the order the operations happened.
+     *
+     * A container's validators read what it sends, which is composed here and nowhere else, so they run first, where
+     * that moved; a leaf's have run at the write. `ValueChangedAction` reports what the element holds, and
+     * `ContributionChangedAction` what it sends to its container.
      */
     protected [TxAnnounceValue](tx: Transaction, dirty: boolean, force: boolean, structural?: TxStructuralEvent[]): void;
+    /**
+     * Records what this element holds and sends as what was last announced, so the commit that follows reports no
+     * change of either. A construction calls it over the state it ends on, and so does an element brought to the
+     * state a fresh binding would be in.
+     */
+    protected recordAnnounced(): void;
     /**
      * Forms the verdict this element ends the transaction with and announces a transition of it. The container is
      * told first, so a handler reads a tally that already includes this verdict, and it is enrolled in the same
@@ -949,25 +1129,41 @@ declare interface FieldSlots<T = any> extends ElementSlots<T> {
 
 /**
  * What Group.fullValue reads back. The indexed access reads each field's fullValue getter, so a nested group
- * contributes its own full structure rather than the partial one its `value` builds, and the recursion carries
- * the guarantee all the way down: every key is present and none of them is null.
+ * contributes its own full structure rather than the partial one its `value` builds. Every member is present
+ * whatever its access.
  */
 export declare type FieldsToFullValues<T extends GenericFieldsInterface> = {
     [K in keyof T]: T[K]['fullValue'];
 };
 
+/**
+ * Converts a field structure into the matching value structure. The indexed access reads each field's value
+ * getter, so a nested Group contributes its own value structure and a List contributes its row array; inferring
+ * from FieldBase<infer U> instead would pick up the value setter, which is deliberately wider than the getter on
+ * Group. Every member may be `null`, because a member whose access is `'disabled-null'` contributes `null` in place
+ * of its value.
+ */
 export declare type FieldsToValues<T extends GenericFieldsInterface> = {
-    [K in keyof T]: T[K]['value'];
+    [K in keyof T]: T[K]['value'] | null;
 };
 
 declare namespace Form {
     export {
-        DisplayMode,
-        defaultDisplayMode,
+        Access,
+        accessValues,
+        defaultAccess,
+        isAccess,
+        Visibility,
+        visibilityValues,
+        defaultVisibility,
+        isVisibility,
         transaction,
         TransactionControl,
         FieldActionBase,
         ActionsMap,
+        AccessChangedAction,
+        AccessChangingAction,
+        ContributionChangedAction,
         EnabledChangedAction,
         EnabledChangingAction,
         ExecuteAction,
@@ -980,7 +1176,7 @@ declare namespace Form {
         Operator,
         ConditionalStatementAction,
         ConditionalVisibilityAction,
-        ConditionalEnabledAction,
+        ConditionalAccessAction,
         ConditionalValueAction,
         OperandType,
         Statement,
@@ -988,6 +1184,7 @@ declare namespace Form {
         Action,
         NullableAction,
         MessagesWidget,
+        Container,
         Field,
         NullableField,
         IFieldConstructorActionsList,
@@ -1007,6 +1204,8 @@ declare namespace Form {
         NullableGroup,
         isEqual,
         ListValue,
+        ListValueInput,
+        ListFullValue,
         List,
         NullableList,
         Validators,
@@ -1024,10 +1223,13 @@ declare namespace Form {
         RenderContentCallable,
         RenderContent,
         RenderContentRef,
+        ErrorOrigin,
         ValidationError,
         ValidationErrorText,
         ValidationErrorRenderContent,
-        RenderableValue
+        RenderableValue,
+        view,
+        View
     }
 }
 export default Form;
@@ -1052,7 +1254,7 @@ export declare type GenericFieldsInterface = Record<string, FieldBase>;
 /** The current configuration. The object is the module's own record, and reading it again reports later writes. */
 export declare function getConfig(): FormsConfig;
 
-export declare class Group<T extends GenericFieldsInterface = GenericFieldsInterface, X extends object = Extras> extends FieldBase<GroupValue<T>, X> {
+export declare class Group<T extends GenericFieldsInterface = GenericFieldsInterface, X extends object = Extras> extends Container<GroupValue<T>, X> {
     get [Symbol.toStringTag](): string;
     protected get state(): GroupSlots<GroupValue<T>>;
     protected get raw(): GroupSlots<GroupValue<T>>;
@@ -1112,6 +1314,7 @@ export declare class Group<T extends GenericFieldsInterface = GenericFieldsInter
      */
     get fields(): T;
     protected get members(): FieldBase[];
+    protected get children(): readonly FieldBase[];
     get value(): GroupValue<T>;
     /**
      * Writes the members that the given value carries. The members are written one by one and the group says
@@ -1126,26 +1329,11 @@ export declare class Group<T extends GenericFieldsInterface = GenericFieldsInter
      * supplies that per member, so a group reset from the template it was bound from matches a fresh binding of it.
      */
     protected resetTo(source: FieldBase, value: any): void;
-    get touched(): boolean;
-    set touched(touched: boolean);
-    get fullValue(): FieldsToFullValues<T>;
     /**
-     * Records that a member changed its value, so that the transaction in progress works out at commit what this
-     * group's own value became and announces it once. A mutation method calls it itself; you rarely need to.
+     * Everything the group holds: every member's `fullValue`, whatever the member's access. Where `value` states what
+     * the group sends, this states what it holds, and it is what a binding of the group carries.
      */
-    notifyValueChanged(): void;
-    protected get composesValue(): boolean;
-    /**
-     * A group with nothing listening for its value does not compose one at all, so the copy it holds is from before
-     * the changes nobody received. A registration that adds a listener brings it up to date here, and what the
-     * listener is then told about is the change that follows it.
-     */
-    protected refreshPreviousValue(): void;
-    get valid(): boolean;
-    protected composeValid(): boolean;
-    get busy(): boolean;
-    protected composeBusy(): boolean;
-    validate(revalidate?: boolean): void;
+    get fullValue(): FieldsToFullValues<T>;
     /**
      * States that `res` was built from the members handed to it. A subclass whose constructor takes something other
      * than `(fields, params)` - one that composes its own members and passes them to super - never sees them, and
@@ -1161,6 +1349,13 @@ export declare class Group<T extends GenericFieldsInterface = GenericFieldsInter
     rebind(data: GroupValueInput<T>): this;
 }
 
+/** the data keys of a group's view */
+declare type GroupData<F extends GenericFieldsInterface> = {
+    readonly [K in keyof F as F[K] extends Container ? K : never]: Slot<F[K]>;
+} & {
+    -readonly [K in keyof F as F[K] extends Container ? never : K]: Slot<F[K]>;
+};
+
 /** what a Group holds beyond the container slots: the names of its members, in the order it took them */
 declare interface GroupSlots<T = any> extends ContainerSlots<T> {
     /**
@@ -1172,12 +1367,12 @@ declare interface GroupSlots<T = any> extends ContainerSlots<T> {
 }
 
 /**
- * What Group.value reads back: the values of the fields that serialize, or null when none does. Every key is
- * optional, because a field that is disabled is left out of the object the group builds.
+ * What Group.value reads back: the values of the members that serialize, and `{}` where none does. Every key is
+ * optional, because a member whose access is `'disabled'` is left out of the object the group builds.
  */
-export declare type GroupValue<T extends GenericFieldsInterface> = Partial<FieldsToValues<T>> | null;
+export declare type GroupValue<T extends GenericFieldsInterface> = Partial<FieldsToValues<T>>;
 
-/** what Group.value and the Group constructor accept: keys left out are simply not assigned */
+/** what Group.value and the Group constructor accept: keys left out are simply not assigned, and null clears */
 export declare type GroupValueInput<T extends GenericFieldsInterface> = Partial<FieldsToValues<T>> | null;
 
 /**
@@ -1186,7 +1381,7 @@ export declare type GroupValueInput<T extends GenericFieldsInterface> = Partial<
  * `validators` and `actions` are carried from the declaration rather than supplied, and `touched` and `errors`
  * are what the binding establishes for itself as it validates.
  */
-export declare type IBindParams<T = any, X extends object = Extras> = Partial<Pick<IFieldConstructorParams<T>, 'originalValue' | 'enabled' | 'visibility'>> & Partial<NoInfer<X>>;
+export declare type IBindParams<T = any, X extends object = Extras> = Partial<Pick<IFieldConstructorParams<T>, 'originalValue' | 'access' | 'visibility'>> & Partial<NoInfer<X>>;
 
 export declare interface IFieldConstructorActionsList {
     actions?: FieldActionBase[];
@@ -1196,15 +1391,15 @@ export declare interface IFieldConstructorActionsList {
 /**
  * Parameters accepted by field constructors and by bind overrides.
  *
- * Only writable members are listed. valid, validating, busy, fullValue and isChanged are getter-only, so assigning
- * them throws a TypeError. So are parent and fieldName: a container writes the slots behind them when it takes
- * an element, and nobody else can, which is why the type rejects them.
+ * Only writable members are listed. valid, validating, busy, fullValue, isChanged, enabled and effectiveEnabled are
+ * getter-only, so assigning them throws a TypeError. So are parent and fieldName: a container writes the slots
+ * behind them when it takes an element, and nobody else can, which is why the type rejects them.
  */
 export declare type IFieldConstructorParams<T = any> = {
     value: T;
     originalValue: T;
-    enabled: boolean;
-    visibility: DisplayMode;
+    access: Access;
+    visibility: Visibility;
     touched: boolean;
     errors: ValidationError[];
 } & IFieldConstructorActionsList;
@@ -1226,6 +1421,9 @@ declare class InAllowedValues<T = any> extends Validator {
     constructor(allowedValues: AllowedValues<T>, message?: RenderContentRef);
 }
 
+/** Answers whether `value` is one of the four accesses. */
+export declare function isAccess(value: unknown): value is Access;
+
 export declare function isCallableFunction(msg?: RenderContentRef): msg is RenderContentCallable;
 
 /**
@@ -1245,16 +1443,20 @@ export declare function isEqual(a: unknown, b: unknown): boolean;
  */
 export declare function isSimpleComponentDef(msg?: RenderContentRef): msg is SimpleComponentDef;
 
+/** Answers whether `value` is one of the four visibilities. */
+export declare function isVisibility(value: unknown): value is Visibility;
+
 declare class LengthInRange extends Validator {
     constructor(minLength: number, maxLength: number, message?: RenderContentRef);
 }
 
-export declare class List<T extends GenericFieldsInterface = GenericFieldsInterface, X extends object = Extras> extends FieldBase<ListValue, X> {
+export declare class List<R extends FieldBase = Group, X extends object = Extras> extends Container<ListValue<R>, X> {
     get [Symbol.toStringTag](): string;
-    protected get state(): ListSlots<T>;
-    protected get raw(): ListSlots<T>;
+    protected get state(): ListSlots<R>;
+    protected get raw(): ListSlots<R>;
     private _itemTemplate?;
-    constructor(itemTemplate?: Group<T>, params?: IFieldParams<ListValue, X>);
+    constructor(itemTemplate?: undefined, params?: IFieldParams<ListValueInput<R>, X>);
+    constructor(itemTemplate: R, params?: IFieldParams<ListValueInput<R>, X>);
     /** The row array is copied as well: a rollback puts back the set the list held, not the array it went on to hold. */
     protected [TxCapture](): TxSnapshot;
     /**
@@ -1263,9 +1465,14 @@ export declare class List<T extends GenericFieldsInterface = GenericFieldsInterf
      */
     private static baseline;
     private processSetValueItem;
+    /**
+     * The row a list without an item template builds from `item`: a `Group` of fields from a plain object, a `List`
+     * from an array, and a `Field` holding anything else.
+     */
+    private static elementFor;
     /**
      * Builds the item that fills a gap left by an insert beyond the end of the list: the item template bound to its
-     * own values, or an empty group when the list has no template.
+     * own values, or, where the list has no template, an empty element of the kind `item` is built into.
      */
     private createPaddingItem;
     /** Records that the set of rows changed, so `items` rebuilds the frozen array it hands out at the next read. */
@@ -1273,44 +1480,26 @@ export declare class List<T extends GenericFieldsInterface = GenericFieldsInterf
     /** True where `next` is a different set of rows than `previous`: another count, or another row at a position. */
     private static rowsDiffer;
     private setValueInternal;
-    get value(): ListValue;
-    set value(newValue: ListValue);
+    get value(): ListValue<R>;
+    set value(newValue: ListValueInput<R>);
     /**
      * The rows are taken from `source` where the caller supplied no value of its own, so a list nested in a row that
      * a whole-list assignment reuses ends up holding what the template gives it rather than what it held before.
      */
     protected resetTo(source: FieldBase, value: any): void;
-    get touched(): boolean;
-    set touched(touched: boolean);
-    bind(data?: ListValue, overrides?: IBindParams<ListValue, X>): List<T, X>;
+    bind(data?: ListValueInput<R>, overrides?: IBindParams<ListValueInput<R>, X>): List<R, X>;
+    protected get members(): FieldBase[];
+    protected get children(): readonly FieldBase[];
     /**
-     * Records that a row changed its value, so that the transaction in progress works out at commit what this
-     * list's own value became and announces it once. The mutation methods call it themselves; you rarely need to.
+     * The full value of every row. Where `value` states what the list sends, this states what the list holds: every
+     * row whatever its access, and a group row carrying every field of its own. It is what a binding or a reset
+     * carries.
      */
-    notifyValueChanged(): void;
-    protected get composesValue(): boolean;
-    /**
-     * A list with nothing listening for its value does not compose one at all, so the copy it holds is from before
-     * the changes nobody received. A registration that adds a listener brings it up to date here, and what the
-     * listener is then told about is the change that follows it.
-     */
-    protected refreshPreviousValue(): void;
-    get valid(): boolean;
-    protected composeValid(): boolean;
-    get busy(): boolean;
-    protected composeBusy(): boolean;
-    validate(revalidate?: boolean): void;
-    protected get members(): FieldBase[];
+    get fullValue(): ListFullValue<R>;
     /**
      * How many rows this list holds. The read is tracked, so a template rendering off it re-renders as rows come and
      * go.
      */
-    /**
-     * Every row of this list, each one built from all of its fields. Where `value` states what the list serializes -
-     * rows composed of the fields that are enabled, and null where the list is empty - this states what the list
-     * holds: the disabled fields are in it too, and an empty list reads back as an empty array rather than as null.
-     */
-    get fullValue(): FieldsToFullValues<T>[];
     get length(): number;
     /**
      * The rows this list holds, oldest position first. The array is a frozen copy: it states what the list held at
@@ -1321,17 +1510,27 @@ export declare class List<T extends GenericFieldsInterface = GenericFieldsInterf
      * row changes what the list serializes without changing which rows it holds, and the array a reader took stays
      * the same one across such a write.
      */
-    get items(): readonly Group<T>[];
-    get(index: number): Group<T> | undefined;
+    get items(): readonly R[];
+    get(index: number): R | undefined;
     push(item: any): number;
-    pop(): Group<T> | undefined;
-    remove(index: number): Group<T> | undefined;
+    pop(): R | undefined;
+    remove(index: number): R | undefined;
     insert(item: any, index: number): number;
     /** Drops every row this list holds out of its tally, so a row that changes its verdict later is not counted. */
     private releaseRows;
     clear(): void;
 }
 
+/** the array a list's view is: every read an array has, and the mutations taken as the list's own operations */
+declare type ListData<R extends FieldBase> = Omit<Slot<R>[], 'push' | 'unshift' | 'splice' | 'fill' | 'copyWithin'> & {
+    push(...items: RowInput<R>[]): number;
+    unshift(...items: RowInput<R>[]): number;
+    splice(start: number, deleteCount?: number, ...items: RowInput<R>[]): Slot<R>[];
+};
+
+/** what List.fullValue reads back: the full value of every row, whatever its access */
+export declare type ListFullValue<R extends FieldBase = Group> = R['fullValue'][];
+
 export declare class ListItemAddedAction extends FieldActionBase {
     constructor(executorFn: (field: FieldBase, supr: FieldActionExecute, item: any, index: number) => void);
     static get classIdentifier(): symbol;
@@ -1345,20 +1544,26 @@ export declare class ListItemRemovedAction extends FieldActionBase {
 }
 
 /** what a List holds beyond the container slots: the rows themselves */
-declare interface ListSlots<T extends GenericFieldsInterface = GenericFieldsInterface> extends ContainerSlots<ListValue> {
-    rows: Group<T>[] | null;
+declare interface ListSlots<R extends FieldBase = Group> extends ContainerSlots<ListValue<R>> {
+    rows: R[] | null;
     /**
      * Counts the changes to the set of rows. `items` rebuilds the frozen array it hands out when it moves, and
      * only then: a write inside a row changes what the list serializes without changing which rows it holds.
      */
     rowsVersion: number;
     /** the frozen array `items` last handed out, together with the rows version it was built from */
-    cachedItems: readonly Group<T>[] | null;
+    cachedItems: readonly R[] | null;
     cachedItemsVersion: number;
 }
 
-/** what List.value reads back: one plain object per item, or null when the list is empty */
-export declare type ListValue = Record<string, any>[] | null;
+/**
+ * What a List of R reads back: the value of each row it sends, `null` for a row whose access is `'disabled-null'`,
+ * and `[]` while it sends none
+ */
+export declare type ListValue<R extends FieldBase = Group> = (R['value'] | null)[];
+
+/** what List.value and the List constructor accept: an array of rows, or null, which empties the list */
+export declare type ListValueInput<R extends FieldBase = Group> = ListValue<R> | null;
 
 declare class MaxLength extends Validator {
     constructor(maxLength: number, message?: RenderContentRef);
@@ -1470,6 +1675,12 @@ declare interface RequiredOptions {
     trim?: boolean;
 }
 
+/** what a list's view takes as a row: the data a row is built from, an element, or the view of one */
+declare type RowInput<R extends FieldBase> = R['value'] | R | View<R>;
+
+/** asked by a validator before it runs: whether the element is sent nowhere, read without tracking */
+declare const SentNowhere: unique symbol;
+
 /** Writes the members `newConfig` names and leaves the rest as they stand. */
 export declare function setConfig(newConfig: Partial<FormsConfig>): void;
 
@@ -1482,6 +1693,9 @@ export declare interface SimpleComponentDef {
     componentVHtml?: string;
 }
 
+/** a member of the form in the shape a view hands it out: the view of a container, the value of anything else */
+declare type Slot<E> = E extends Container ? View<E> : E extends FieldBase ? E['value'] : never;
+
 export declare class Statement {
     private readonly operand1;
     private readonly operator;
@@ -1706,12 +1920,21 @@ declare interface TxStructuralEvent {
  */
 export declare class ValidationError {
     code?: string | undefined;
+    private readonly statedOrigin?;
     /**
-     * Machine-readable identifier of what failed, in kebab-case. Every validator this library ships states one, so
-     * code that reacts to a particular failure does not have to match the message text, which is translated and
-     * configurable. It is optional: an error built by hand carries whatever its author gives it, or nothing.
+     * @param code Machine-readable identifier of what failed, in kebab-case. Every validator this library ships states
+     * one, so code that reacts to a particular failure does not have to match the message text, which is translated
+     * and configurable. It is optional: an error built by hand carries whatever its author gives it, or nothing.
+     * @param statedOrigin Where the error comes from, where its author states it; see `origin`.
      */
-    constructor(code?: string | undefined);
+    constructor(code?: string | undefined, statedOrigin?: ErrorOrigin | undefined);
+    /**
+     * Where the error comes from: the origin its author stated, and otherwise `'validator'` for an error a validator
+     * produced - a validator stamps every error it hands a field - and `'application'` for one written into `errors`
+     * by any other code. It is what a rendering layer reads to decide when to show the error, and what code reads to
+     * withdraw the errors of one origin and leave the rest.
+     */
+    get origin(): ErrorOrigin;
     /**
      * True where `other` is an error of this class that renders exactly as this one does and reports the same code.
      * Two runs of one validator over an unchanged value produce two instances of one message, and this is what lets
@@ -1736,7 +1959,7 @@ export declare class ValidationErrorRenderContent extends ValidationError {
     classes: ClassTypes;
     private text;
     private textType;
-    constructor(text: RenderContentRef, classes?: ClassTypes, code?: string);
+    constructor(text: RenderContentRef, classes?: ClassTypes, code?: string, origin?: ErrorOrigin);
     get resolvedText(): RenderContentNonCallable;
     get getTextType(): "string" | "md" | "component";
     get componentName(): string;
@@ -1751,7 +1974,7 @@ export declare class ValidationErrorRenderContent extends ValidationError {
 export declare class ValidationErrorText extends ValidationError {
     text: string;
     classes: ClassTypes;
-    constructor(text: string, classes?: ClassTypes, code?: string);
+    constructor(text: string, classes?: ClassTypes, code?: string, origin?: ErrorOrigin);
     get componentName(): string;
     get componentBody(): string;
     get extraClasses(): ClassTypes;
@@ -1866,16 +2089,57 @@ declare class ValueInRange<T = any> extends Validator {
     constructor(minValue: T, maxValue: T, message?: RenderContentRef);
 }
 
+/**
+ * An element seen as its data: the members of a group, or the rows of a list, as plain properties, and the element
+ * itself as `$`. See `view()`.
+ */
+export declare type View<E extends FieldBase> = (E extends Group<infer F, any> ? GroupData<F> : E extends List<infer R, any> ? ListData<R> : unknown) & {
+    readonly $: E;
+};
+
+/**
+ * The element seen as its data. A group's members and a list's rows are plain properties of the view - a field as
+ * its value, a container as its own view - and `$` is the element itself: `view.$.valid`,
+ * `view.$.access = 'readonly'`, `view.$.registerAction(...)`.
+ *
+ * A member reads what the element holds, by the rule `fullValue` follows: every member is there whatever its access,
+ * so a disabled field reads and writes like any other. Every read goes
+ * through the element's tracked state, so an effect reading `view.address.city` re-runs when that field changes and
+ * not when another one does.
+ *
+ * A list's view is an array: it reads like one, and `push`, `pop`, `shift`, `unshift`, `splice`, `sort` and
+ * `reverse` are carried out as the list's own operations, so every row keeps its element and its state.
+ *
+ * One element has one view: `view(element) === view(element)`, and `view()` of a view hands it back.
+ */
+export declare function view<V extends View<any>>(of: V): V;
+
+export declare function view<E extends FieldBase>(element: E): View<E>;
+
+/**
+ * How a rendering layer shows a form element. It is presentation alone: what an element sends and whether it is
+ * validated are its `access`, and no visibility changes either.
+ *
+ * - `'full'`: rendered and shown
+ * - `'invisible'`: rendered and keeps its space in the layout, but is not painted (`visibility: hidden`)
+ * - `'hidden'`: rendered but not displayed, taking no space (`display: none`)
+ * - `'suppress'`: not rendered at all
+ */
+export declare type Visibility = 'full' | 'invisible' | 'hidden' | 'suppress';
+
 export declare class VisibilityChangedAction extends FieldActionBase {
-    constructor(executorFn: (field: FieldBase, supr: FieldActionExecute, newValue: DisplayMode, oldValue: DisplayMode) => void);
+    constructor(executorFn: (field: FieldBase, supr: FieldActionExecute, newValue: Visibility, oldValue: Visibility) => void);
     static get classIdentifier(): symbol;
-    execute(field: FieldBase, supr: FieldActionExecute, newValue: DisplayMode, oldValue: DisplayMode): void;
+    execute(field: FieldBase, supr: FieldActionExecute, newValue: Visibility, oldValue: Visibility): void;
 }
 
 export declare class VisibilityChangingAction extends FieldActionBase {
-    constructor(executorFn: (field: FieldBase, supr: FieldActionExecute, newValue: DisplayMode, oldValue: DisplayMode) => DisplayMode);
+    constructor(executorFn: (field: FieldBase, supr: FieldActionExecute, newValue: Visibility, oldValue: Visibility) => Visibility);
     static get classIdentifier(): symbol;
-    execute(field: FieldBase, supr: FieldActionExecute, newValue: DisplayMode, oldValue: DisplayMode): DisplayMode;
+    execute(field: FieldBase, supr: FieldActionExecute, newValue: Visibility, oldValue: Visibility): Visibility;
 }
 
+/** every visibility, from shown to not rendered */
+export declare const visibilityValues: readonly Visibility[];
+
 export { }