@lion/ui 0.11.0 → 0.11.2

package/docs/components/checkbox-group/api-table.md

@@ -1,4 +1,16 @@
-# Checkbox Group >> API Table ||90 
+---
+parts:
+  - API Table
+  - Checkbox Group
+title: 'Checkbox Group: API Table'
+eleventyNavigation:
+  key: API Table >> Checkbox Group
+  title: API Table
+  order: 90
+  parent: Checkbox Group
+---
+# Checkbox Group: API Table
+ 
 
 ## class: `LionCheckbox`, `lion-checkbox`
 
@@ -6,137 +18,132 @@
 
 | Name                         | Privacy   | Type                                      | Default                         | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | Inherited From        |
 | ---------------------------- | --------- | ----------------------------------------- | ------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------- |
+| `allowCrossRootRegistration` | public    | `boolean`                                 | `false`                         | To encourage accessibility best practices, \`form-element-register\` events
do not pierce through shadow roots. This forces the developer to create form groups and fieldsets that automatically allow the creation of accessible relationships in the same dom tree.
Use this option if you know what you're doing. It will then be possible to nest FormControls
inside shadow dom. See https\://lion.js.org/fundamentals/rationales/accessibility/#shadow-roots-and-accessibility                                                                                                          | FormRegisteringMixin  |
+| `autocomplete`               | public    | `string \| undefined`                     | `undefined`                     | Delegates this property to input/textarea/select.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | NativeTextFieldMixin  |
+| `autofocus`                  | public    | `boolean`                                 | `false`                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | FocusMixin            |
+| `checked`                    | public    | `boolean`                                 |                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | ChoiceInputMixin      |
 | `choiceValue`                | public    | `string\|any`                             |                                 | The value that will be registered to the modelValue of the parent ChoiceGroup. Recommended
to be a string                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | ChoiceInputMixin      |
-| `modelValue`                 | public    | `{value:string\|any,checked:boolean}`     | `{ value: '', checked: false }` | Whereas 'normal' \`.modelValue\`s usually store a complex/typed version
of a view value, choice inputs have a slightly different approach.
In order to remain their Single Source of Truth characteristic, choice inputs
store both the value and 'checkedness', in the format { value: 'x', checked: true }
Different from the platform, this also allows to serialize the 'non checkedness',
allowing to restore form state easily and inform the server about unchecked options.                                                                                                   | FormControlMixin      |
+| `defaultValidators`          | public    | `Validator[]`                             | `[]`                            | Used by Subclassers to add default Validators to a particular FormControl.
A date input for instance, always needs the isDate validator.                                                                                                                                                                                                                                                                                                                                                                                                                                                              | ValidateMixin         |
+| `dirty`                      | public    | `boolean`                                 | `false`                         | True when user has changed the value of the field.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | InteractionStateMixin |
 | `disabled`                   | public    | `boolean`                                 | `false`                         | Boolean indicating whether or not this element is disabled.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | DisabledMixin         |
-| `checked`                    | public    | `boolean`                                 |                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | ChoiceInputMixin      |
-| `value`                      | public    |                                           |                                 | The view value. Will be delegated to \`.\_inputNode.value\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | FormatMixin           |
+| `fieldName`                  | public    | `string`                                  |                                 | Will be used in validation messages to refer to the current field                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | FormControlMixin      |
+| `filled`                     | public    | `boolean`                                 | `false`                         | True when the modelValue is non-empty (see \_isEmpty in FormControlMixin)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | InteractionStateMixin |
+| `focused`                    | public    | `boolean`                                 | `false`                         | Whether the focusable element within (\`.\_focusableNode\`) is focused.
Reflects to attribute '\[focused]' as a styling hook                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | FocusMixin            |
+| `focusedVisible`             | public    | `boolean`                                 | `false`                         | Whether the focusable element within (\`.\_focusableNode\`) matches ':focus-visible'
Reflects to attribute '\[focused-visible]' as a styling hook
See: https\://developer.mozilla.org/en-US/docs/Web/CSS/:focus-visible                                                                                                                                                                                                                                                                                                                                                                           | FocusMixin            |
 | `formatOn`                   | protected | `string`                                  | `'change'`                      | Event that will trigger formatting (more precise, visual update of the view, so the
user sees the formatted value)
Default: 'change'                                                                                                                                                                                                                                                                                                                                                                                                                                                              | FormatMixin           |
 | `formatOptions`              | public    |                                           | `({ mode: 'auto' })`            | Configuration object that will be available inside the formatter function                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | FormatMixin           |
 | `formattedValue`             | public    | `string\|undefined`                       | `undefined`                     | The view value is the result of the formatter function (when available).
The result will be stored in the native \_inputNode (usually an input\[type=text]).

Examples:
- For a date input, this would be '20/01/1999' (dependent on locale).
- For a number input, this could be '1,234.56' (a String representation of modelValue
1234.56)                                                                                                                                                                                                                                      | FormatMixin           |
-| `serializedValue`            | public    | `string\|undefined`                       | `undefined`                     | The serialized version of the model value.
This value exists for maximal compatibility with the platform API.
The serialized value can be an interface in context where data binding is not
supported and a serialized string needs to be set.

Examples:
- For a date input, this would be the iso format of a date, e.g. '1999-01-20'.
- For a number input this would be the String representation of a float ('1234.56'
  instead of 1234.56)

When no parser is available, the value is usually the same as the formattedValue
(being \_inputNode.value) | FormatMixin           |
-| `_isPasting`                 | protected | `boolean`                                 | `false`                         | Whether the user is pasting content. Allows Subclassers to do this in their subclass:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | FormatMixin           |
-| `_isHandlingUserInput`       | protected | `boolean`                                 | `false`                         | Flag that will be set when user interaction takes place (for instance after an 'input'
event). Will be added as meta info to the \`model-value-changed\` event. Depending on
whether a user is interacting, formatting logic will be handled differently.                                                                                                                                                                                                                                                                                                                                         | FormatMixin           |
-| `_inputNode`                 | protected | `HTMLInputElement \| HTMLTextAreaElement` |                                 | The interactive (form) element. Can be a native element like input/textarea/select or
an element with tabindex > -1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | FormControlMixin      |
-| `selectionStart`             | public    | `number`                                  |                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | NativeTextFieldMixin  |
+| `hasFeedbackFor`             | public    | `ValidationType[]`                        | `[]`                            | As soon as validation happens (after modelValue/validators/validator param change), this
array is updated with the active ValidationTypes ('error'\|'warning'\|'success'\|'info' etc.).
Notice the difference with \`.showsFeedbackFor\`, which filters \`.hasFeedbackFor\` based on
\`.feedbackCondition()\`.

For styling purposes, will be reflected to \[has-feedback-for="error warning"]. This can
be useful for subtle visual feedback on keyup, like a red/green border around an input.                                                                                  | ValidateMixin         |
+| `helpText`                   | public    | `string`                                  | `''`                            | The helpt text for the input node.
When no value is defined, textContent of \[slot=help-text] will be used                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | FormControlMixin      |
+| `isPending`                  | public    | `boolean`                                 | `false`                         | Flag indicating whether async validation is pending.
Creates attribute \[is-pending] as a styling hook                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | ValidateMixin         |
+| `label`                      | public    | `string`                                  | `''`                            | The label text for the input node.
When no value is defined, textContent of \[slot=label] will be used                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | FormControlMixin      |
+| `labelSrOnly`                | public    | `boolean`                                 | `false`                         | The label will only be visible for srceen readers when true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | FormControlMixin      |
+| `modelValue`                 | public    | `{value:string\|any,checked:boolean}`     | `{ value: '', checked: false }` | Whereas 'normal' \`.modelValue\`s usually store a complex/typed version
of a view value, choice inputs have a slightly different approach.
In order to remain their Single Source of Truth characteristic, choice inputs
store both the value and 'checkedness', in the format { value: 'x', checked: true }
Different from the platform, this also allows to serialize the 'non checkedness',
allowing to restore form state easily and inform the server about unchecked options.                                                                                                   | FormControlMixin      |
+| `name`                       | public    | `string`                                  | `''`                            | The name the element will be registered with to the .formElements collection
of the parent. Also, it serves as the key of key/value pairs in
 modelValue/serializedValue objects                                                                                                                                                                                                                                                                                                                                                                                                                  | FormRegisteringMixin  |
+| `operationMode`              | public    | `OperationMode`                           |                                 | Types of input interaction of the FormControl (for instance 'enter'\|'select'\|'upload')                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | ValidateMixin         |
+| `placeholder`                | public    | `string`                                  | `''`                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | LionInput             |
+| `prefilled`                  | public    | `boolean`                                 | `false`                         | True when user has left non-empty field or input is prefilled.
The name must be seen from the point of view of the input field:
once the user enters the input field, the value is non-empty.                                                                                                                                                                                                                                                                                                                                                                                                     | InteractionStateMixin |
+| `readOnly`                   | public    | `boolean`                                 | `false`                         | A Boolean attribute which, if present, indicates that the user should not be able to edit
the value of the input. The difference between disabled and readonly is that read-only
controls can still function, whereas disabled controls generally do not function as
controls until they are enabled.
(From: https\://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#attr-readonly)                                                                                                                                                                                              | FormControlMixin      |
 | `selectionEnd`               | public    | `number`                                  |                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | NativeTextFieldMixin  |
+| `selectionStart`             | public    | `number`                                  |                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | NativeTextFieldMixin  |
+| `serializedValue`            | public    | `string\|undefined`                       | `undefined`                     | The serialized version of the model value.
This value exists for maximal compatibility with the platform API.
The serialized value can be an interface in context where data binding is not
supported and a serialized string needs to be set.

Examples:
- For a date input, this would be the iso format of a date, e.g. '1999-01-20'.
- For a number input this would be the String representation of a float ('1234.56'
  instead of 1234.56)

When no parser is available, the value is usually the same as the formattedValue
(being \_inputNode.value) | FormatMixin           |
+| `showsFeedbackFor`           | public    | `ValidationType[]`                        | `[]`                            | Based on outcome of feedbackCondition, this array decides what ValidationTypes should be
shown in validationFeedback, based on meta data like interaction states.

For styling purposes, it reflects it \`\[shows-feedback-for="error warning"]\`                                                                                                                                                                                                                                                                                                                                             | ValidateMixin         |
+| `submitted`                  | public    |                                           |                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | InteractionStateMixin |
+| `touched`                    | public    | `boolean`                                 | `false`                         | True when user has focused and left(blurred) the field.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | InteractionStateMixin |
+| `type`                       | public    | `string`                                  | `'text'`                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | LionInput             |
+| `validationStates`           | public    | `ValidationStates`                        | `{}`                            | The outcome of a validation 'round'. Keyed by ValidationType and Validator name                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | ValidateMixin         |
+| `validators`                 | public    | `Validator[]`                             | `[]`                            | Used by Application Developers to add Validators to a FormControl.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ValidateMixin         |
+| `value`                      | public    |                                           |                                 | The view value. Will be delegated to \`.\_inputNode.value\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | FormatMixin           |
+| `_allValidators`             | protected | `Validator[]`                             |                                 | Combination of validators provided by Application Developer and the default validators                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | ValidateMixin         |
+| `_ariaDescribedNodes`        | public    | `HTMLElement[]`                           | `[]`                            | Contains all elements that should end up in aria-describedby of \`.\_inputNode\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | FormControlMixin      |
+| `_ariaLabelledNodes`         | public    | `HTMLElement[]`                           | `[]`                            | Contains all elements that should end up in aria-labelledby of \`.\_inputNode\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | FormControlMixin      |
+| `_feedbackConditionMeta`     | protected |                                           |                                 | Allows Subclassers to add meta info for feedbackCondition                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | LionField             |
+| `_feedbackNode`              | protected |                                           |                                 | Element where validation feedback will be rendered to                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | FormControlMixin      |
 | `_focusableNode`             | protected | `HTMLElement`                             |                                 | The focusable element:
could be an input, textarea, select, button or any other element with tabindex > -1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | LionField             |
-| `autocomplete`               | public    | `string \| undefined`                     | `undefined`                     | Delegates this property to input/textarea/select.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | NativeTextFieldMixin  |
-| `focused`                    | public    | `boolean`                                 | `false`                         | Whether the focusable element within (\`.\_focusableNode\`) is focused.
Reflects to attribute '\[focused]' as a styling hook                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | FocusMixin            |
-| `focusedVisible`             | public    | `boolean`                                 | `false`                         | Whether the focusable element within (\`.\_focusableNode\`) matches ':focus-visible'
Reflects to attribute '\[focused-visible]' as a styling hook
See: https\://developer.mozilla.org/en-US/docs/Web/CSS/:focus-visible                                                                                                                                                                                                                                                                                                                                                                           | FocusMixin            |
-| `autofocus`                  | public    | `boolean`                                 | `false`                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | FocusMixin            |
-| `label`                      | public    | `string`                                  | `''`                            | The label text for the input node.
When no value is defined, textContent of \[slot=label] will be used                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | FormControlMixin      |
-| `helpText`                   | public    | `string`                                  | `''`                            | The helpt text for the input node.
When no value is defined, textContent of \[slot=help-text] will be used                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | FormControlMixin      |
-| `fieldName`                  | public    | `string`                                  |                                 | Will be used in validation messages to refer to the current field                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | FormControlMixin      |
-| `_labelNode`                 | protected |                                           |                                 | Element where label will be rendered to                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | FormControlMixin      |
 | `_helpTextNode`              | protected |                                           |                                 | Element where help text will be rendered to                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | FormControlMixin      |
-| `_feedbackNode`              | protected |                                           |                                 | Element where validation feedback will be rendered to                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | FormControlMixin      |
-| `readOnly`                   | public    | `boolean`                                 | `false`                         | A Boolean attribute which, if present, indicates that the user should not be able to edit
the value of the input. The difference between disabled and readonly is that read-only
controls can still function, whereas disabled controls generally do not function as
controls until they are enabled.
(From: https\://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#attr-readonly)                                                                                                                                                                                              | FormControlMixin      |
-| `labelSrOnly`                | public    | `boolean`                                 | `false`                         | The label will only be visible for srceen readers when true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | FormControlMixin      |
 | `_inputId`                   | protected | `string`                                  |                                 | Unique id that can be used in all light dom                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | FormControlMixin      |
-| `_ariaLabelledNodes`         | public    | `HTMLElement[]`                           | `[]`                            | Contains all elements that should end up in aria-labelledby of \`.\_inputNode\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | FormControlMixin      |
-| `_ariaDescribedNodes`        | public    | `HTMLElement[]`                           | `[]`                            | Contains all elements that should end up in aria-describedby of \`.\_inputNode\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | FormControlMixin      |
-| `_repropagationRole`         | public    | `'child'\|'choice-group'\|'fieldset'`     | `'child'`                       | Based on the role, details of handling model-value-changed repropagation differ.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | FormControlMixin      |
+| `_inputNode`                 | protected | `HTMLInputElement \| HTMLTextAreaElement` |                                 | The interactive (form) element. Can be a native element like input/textarea/select or
an element with tabindex > -1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | FormControlMixin      |
+| `_isHandlingUserInput`       | protected | `boolean`                                 | `false`                         | Flag that will be set when user interaction takes place (for instance after an 'input'
event). Will be added as meta info to the \`model-value-changed\` event. Depending on
whether a user is interacting, formatting logic will be handled differently.                                                                                                                                                                                                                                                                                                                                         | FormatMixin           |
+| `_isPasting`                 | protected | `boolean`                                 | `false`                         | Whether the user is pasting content. Allows Subclassers to do this in their subclass:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | FormatMixin           |
 | `_isRepropagationEndpoint`   | public    | `boolean`                                 | `false`                         | By default, a field with \_repropagationRole 'choice-group' will act as an
'endpoint'. This means it will be considered as an individual field: for
a select, individual options will not be part of the formPath. They
will.
Similarly, components that (a11y wise) need to be fieldsets, but 'interaction wise'
(from Application Developer perspective) need to be more like fields
(think of an amount-input with a currency select box next to it), can set this
to true to hide private internals in the formPath.                                                      | FormControlMixin      |
-| `type`                       | public    | `string`                                  | `'text'`                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | LionInput             |
-| `placeholder`                | public    | `string`                                  | `''`                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | LionInput             |
-| `name`                       | public    | `string`                                  | `''`                            | The name the element will be registered with to the .formElements collection
of the parent. Also, it serves as the key of key/value pairs in
 modelValue/serializedValue objects                                                                                                                                                                                                                                                                                                                                                                                                                  | FormRegisteringMixin  |
+| `_labelNode`                 | protected |                                           |                                 | Element where label will be rendered to                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | FormControlMixin      |
+| `_leaveEvent`                | protected | `string`                                  | `'blur'`                        | The event that triggers the touched state                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | InteractionStateMixin |
 | `_parentFormGroup`           | protected | `FormRegistrarHost \| undefined`          | `undefined`                     | The registrar this FormControl registers to, Usually a descendant of FormGroup or
ChoiceGroup                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | FormRegisteringMixin  |
-| `allowCrossRootRegistration` | public    | `boolean`                                 | `false`                         | To encourage accessibility best practices, \`form-element-register\` events
do not pierce through shadow roots. This forces the developer to create form groups and fieldsets that automatically allow the creation of accessible relationships in the same dom tree.
Use this option if you know what you're doing. It will then be possible to nest FormControls
inside shadow dom. See https\://lion.js.org/fundamentals/rationales/accessibility/#shadow-roots-and-accessibility                                                                                                          | FormRegisteringMixin  |
+| `_repropagationRole`         | public    | `'child'\|'choice-group'\|'fieldset'`     | `'child'`                       | Based on the role, details of handling model-value-changed repropagation differ.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | FormControlMixin      |
 | `_requestedToBeDisabled`     | protected | `boolean`                                 | `false`                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | DisabledMixin         |
-| `_feedbackConditionMeta`     | protected |                                           |                                 | Allows Subclassers to add meta info for feedbackCondition                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | LionField             |
-| `touched`                    | public    | `boolean`                                 | `false`                         | True when user has focused and left(blurred) the field.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | InteractionStateMixin |
-| `dirty`                      | public    | `boolean`                                 | `false`                         | True when user has changed the value of the field.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | InteractionStateMixin |
-| `prefilled`                  | public    | `boolean`                                 | `false`                         | True when user has left non-empty field or input is prefilled.
The name must be seen from the point of view of the input field:
once the user enters the input field, the value is non-empty.                                                                                                                                                                                                                                                                                                                                                                                                     | InteractionStateMixin |
-| `filled`                     | public    | `boolean`                                 | `false`                         | True when the modelValue is non-empty (see \_isEmpty in FormControlMixin)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | InteractionStateMixin |
-| `_leaveEvent`                | protected | `string`                                  | `'blur'`                        | The event that triggers the touched state                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | InteractionStateMixin |
 | `_valueChangedEvent`         | protected | `string`                                  | `'model-value-changed'`         | The event that triggers the dirty state                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | InteractionStateMixin |
-| `submitted`                  | public    |                                           |                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | InteractionStateMixin |
-| `operationMode`              | public    | `OperationMode`                           |                                 | Types of input interaction of the FormControl (for instance 'enter'\|'select'\|'upload')                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | ValidateMixin         |
-| `_allValidators`             | protected | `Validator[]`                             |                                 | Combination of validators provided by Application Developer and the default validators                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | ValidateMixin         |
-| `hasFeedbackFor`             | public    | `ValidationType[]`                        | `[]`                            | As soon as validation happens (after modelValue/validators/validator param change), this
array is updated with the active ValidationTypes ('error'\|'warning'\|'success'\|'info' etc.).
Notice the difference with \`.showsFeedbackFor\`, which filters \`.hasFeedbackFor\` based on
\`.feedbackCondition()\`.

For styling purposes, will be reflected to \[has-feedback-for="error warning"]. This can
be useful for subtle visual feedback on keyup, like a red/green border around an input.                                                                                  | ValidateMixin         |
-| `showsFeedbackFor`           | public    | `ValidationType[]`                        | `[]`                            | Based on outcome of feedbackCondition, this array decides what ValidationTypes should be
shown in validationFeedback, based on meta data like interaction states.

For styling purposes, it reflects it \`\[shows-feedback-for="error warning"]\`                                                                                                                                                                                                                                                                                                                                             | ValidateMixin         |
-| `validationStates`           | public    | `ValidationStates`                        | `{}`                            | The outcome of a validation 'round'. Keyed by ValidationType and Validator name                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | ValidateMixin         |
-| `isPending`                  | public    | `boolean`                                 | `false`                         | Flag indicating whether async validation is pending.
Creates attribute \[is-pending] as a styling hook                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | ValidateMixin         |
-| `validators`                 | public    | `Validator[]`                             | `[]`                            | Used by Application Developers to add Validators to a FormControl.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ValidateMixin         |
-| `defaultValidators`          | public    | `Validator[]`                             | `[]`                            | Used by Subclassers to add default Validators to a particular FormControl.
A date input for instance, always needs the isDate validator.                                                                                                                                                                                                                                                                                                                                                                                                                                                              | ValidateMixin         |
 | `_visibleMessagesAmount`     | protected | `number`                                  | `1`                             | The amount of feedback messages that will visible in LionValidationFeedback                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | ValidateMixin         |
 
 ### Methods
 
 | Name                                     | Privacy   | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | Parameters                                                                                                     | Return                                                        | Inherited From        |
 | ---------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------- | --------------------- |
-| `_choiceGraphicTemplate`                 | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | ChoiceInputMixin      |
-| `_afterTemplate`                         | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | ChoiceInputMixin      |
-| `_preventDuplicateLabelClick`            | protected | The native platform fires an event for both the click on the label, and also
the redispatched click on the native input element.
This results in two click events arriving at the host, but we only want one.
This method prevents the duplicate click and ensures the correct isTrusted event
with the correct event.target arrives at the host.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `ev: Event`                                                                                                    |                                                               | ChoiceInputMixin      |
-| `_toggleChecked`                         | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: Event`                                                                                                    |                                                               | ChoiceInputMixin      |
-| `_syncNameToParentFormGroup`             | protected | Override this in case of extending ChoiceInputMixin and requiring
to sync differently with parent form group name
Right now it checks tag name match where the parent form group tagname
should include the child field tagname ('checkbox' is included in 'checkbox-group')                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |                                                                                                                |                                                               | ChoiceInputMixin      |
-| `_proxyInputEvent`                       | protected | This can be called whenever the view value should be updated. Dependent on component type&#xA;("input" for \<input> or "change" for \<select>(mainly for IE)) a different event should be&#xA;used  as source for the "user-input-changed" event (which can be seen as an abstraction&#xA;layer on top of other events (input, change, whatever))                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |                                                                                                                |                                                               | FormatMixin           |
-| `_onModelValueChanged`                   | protected | Responds to modelValue changes in the synchronous cycle (most subclassers should listen to&#xA;the asynchronous cycle ('modelValue' in the .updated lifecycle))                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `{ modelValue }, old: { modelValue:unknown }, newV: { modelValue:unknown }`                                    |                                                               | FormatMixin           |
-| `parser`                                 | public    | Converts viewValue to modelValue&#xA;For instance, a localized date to a Date Object                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `v: string, opts: FormatOptions`                                                                               | `*`                                                           | FormatMixin           |
-| `formatter`                              | public    | Converts modelValue to formattedValue (formattedValue will be synced with&#xA;\`.\_inputNode.value\`)&#xA;For instance, a Date object to a localized date.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `modelValue: ChoiceInputModelValue`                                                                            | `string`                                                      | FormatMixin           |
+| `addToAriaDescribedBy`                   | public    | Allows to add element references to aria-describedby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `element: HTMLElement, { idPrefix = '', reorder = true }, customConfig: {idPrefix?:string; reorder?: boolean}` |                                                               | FormControlMixin      |
+| `addToAriaLabelledBy`                    | public    | Allows to add extra element references to aria-labelledby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `element: HTMLElement, { idPrefix = '', reorder = true }, customConfig: {idPrefix?:string; reorder?: boolean}` |                                                               | FormControlMixin      |
+| `blur`                                   | public    | Calls \`blur()\` on focusable element within                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |                                                                                                                |                                                               | FocusMixin            |
 | `clear`                                  | public    | Clears modelValue.&#xA;Interaction states are not cleared (use resetInteractionState for this)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                                                                                                                |                                                               | LionField             |
-| `_isEmpty`                               | protected | Used for required validator.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `modelValue: any`                                                                                              | `boolean`                                                     | FormControlMixin      |
-| `_syncValueUpwards`                      | protected | Synchronization from \`.\_inputNode.value\` to \`LionField\` (flow \[2])&#xA;Downwards syncing should only happen for \`LionField\`.value changes from 'above'.&#xA;This triggers \_onModelValueChanged and connects user input&#xA;to the parsing/formatting/serializing loop.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | FormatMixin           |
+| `click`                                  | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | DisabledMixin         |
+| `deserializer`                           | public    | Converts \`.serializedValue\` to \`.modelValue\`&#xA;For instance, an iso formatted date string to a Date object                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `v: ?`                                                                                                         | `?`                                                           | FormatMixin           |
+| `feedbackCondition`                      | public    | Allows the Application Developer to specify when a feedback message should be shown                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `type: string, meta: object, currentCondition: ((type: string, meta: object) => boolean)`                      | `boolean`                                                     | ValidateMixin         |
+| `focus`                                  | public    | Calls \`focus()\` on focusable element within                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |                                                                                                                |                                                               | FocusMixin            |
+| `formatter`                              | public    | Converts modelValue to formattedValue (formattedValue will be synced with&#xA;\`.\_inputNode.value\`)&#xA;For instance, a Date object to a localized date.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `modelValue: ChoiceInputModelValue`                                                                            | `string`                                                      | FormatMixin           |
+| `initInteractionState`                   | public    | Evaluations performed on connectedCallback.&#xA;This method is public, so it can be called at a later moment (when we need to wait for&#xA;registering children for instance) as well.&#xA;Since this method will be called twice in last mentioned scenario, it must stay idempotent.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                |                                                               | InteractionStateMixin |
+| `makeRequestToBeDisabled`                | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | DisabledMixin         |
+| `parser`                                 | public    | Converts viewValue to modelValue&#xA;For instance, a localized date to a Date Object                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `v: string, opts: FormatOptions`                                                                               | `*`                                                           | FormatMixin           |
 | `preprocessor`                           | public    | Preprocessors could be considered 'live formatters'. Their result is shown to the user&#xA;on keyup instead of after blurring the field. The biggest difference between preprocessors&#xA;and formatters is their moment of execution: preprocessors are run before modelValue is&#xA;computed (and work based on view value), whereas formatters are run after the parser (and&#xA;are based on modelValue)&#xA;Automatically formats code while typing. It depends on a preprocessro that smartly&#xA;updates the viewValue and caret position for best UX.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `v: string, opts: FormatOptions & { prevViewValue: string; currentCaretIndex: number }`                        | `{ viewValue:string; caretIndex:number; }\|string\|undefined` | FormatMixin           |
+| `removeFromAriaDescribedBy`              | public    | Allows to remove element references from aria-describedby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `element: HTMLElement`                                                                                         |                                                               | FormControlMixin      |
+| `removeFromAriaLabelledBy`               | public    | Allows to remove element references from aria-labelledby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `element: HTMLElement`                                                                                         |                                                               | FormControlMixin      |
+| `reset`                                  | public    | Resets modelValue to initial value.&#xA;Interaction states are cleared                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                |                                                               | LionField             |
+| `resetInteractionState`                  | public    | Resets touched and dirty, and recomputes prefilled                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |                                                                                                                |                                                               | LionField             |
+| `retractRequestToBeDisabled`             | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | DisabledMixin         |
 | `serializer`                             | public    | Converts \`.modelValue\` to \`.serializedValue\`&#xA;For instance, a Date object to an iso formatted date string                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `v: ?`                                                                                                         | `string`                                                      | FormatMixin           |
-| `deserializer`                           | public    | Converts \`.serializedValue\` to \`.modelValue\`&#xA;For instance, an iso formatted date string to a Date object                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `v: ?`                                                                                                         | `?`                                                           | FormatMixin           |
+| `validate`                               | public    | Triggered by:&#xA; \- modelValue change&#xA; \- change in the 'validators' array&#xA; \- change in the config of an individual Validator&#xA;&#xA;Three situations are handled:&#xA;- a1) the FormControl is empty: further execution is halted. When the Required Validator&#xA;(being mutually exclusive to the other Validators) is applied, it will end up in the&#xA;validation result (as the only Validator, since further execution was halted).&#xA;- a2) there are synchronous Validators: this is the most common flow. When modelValue hasn't&#xA;changed since last async results were generated, 'sync results' are merged with the&#xA;'async results'.&#xA;- a3) there are asynchronous Validators: for instance when server side evaluation is needed.&#xA;Executions are scheduled and awaited and the 'async results' are merged with the&#xA;'sync results'.&#xA;&#xA;- b) there are MetaValidators. After steps a1, a2, or a3 are finished, the holistic&#xA;MetaValidators (evaluating the total result of the 'regular' (a1, a2 and a3) validators)&#xA;will be run...&#xA;&#xA;Situations a2 and a3 are not mutually exclusive and can be triggered within one \`validate()\`&#xA;call. Situation b will occur after every call. | `{ clearCurrentResult = false }, opts: { clearCurrentResult?: boolean }`                                       |                                                               | ValidateMixin         |
+| `_afterTemplate`                         | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | ChoiceInputMixin      |
 | `_calculateValues`                       | protected | Responsible for storing all representations(modelValue, serializedValue, formattedValue&#xA;and value) of the input value. Prevents infinite loops, so all value observers can be&#xA;treated like they will only be called once, without indirectly calling other observers.&#xA;(in fact, some are called twice, but the \_\_preventRecursiveTrigger lock prevents the&#xA;second call from having effect).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `{ source }, config: {source:'model'\|'serialized'\|'formatted'\|null}`                                        |                                                               | FormatMixin           |
+| `_choiceGraphicTemplate`                 | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | ChoiceInputMixin      |
+| `_dispatchInitialModelValueChangedEvent` | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | FormControlMixin      |
 | `_dispatchModelValueChangedEvent`        | protected | This is wrapped in a distinct method, so that parents can control when the changed event&#xA;is fired. For objects, a deep comparison might be needed.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `args: { modelValue: unknown; }[]`                                                                             |                                                               | FormatMixin           |
-| `_reflectBackFormattedValueToUser`       | protected | Synchronization from \`LionField.value\` to \`.\_inputNode.value\`&#xA;- flow \[1] will always be reflected back&#xA;- flow \[2] will not be reflected back when this flow was triggered via&#xA;  \`@user-input-changed\` (this will happen later, when \`formatOn\` condition is met)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |                                                                                                                |                                                               | FormatMixin           |
-| `_reflectBackOn`                         | protected | Every time .formattedValue is attempted to sync to the view value (on change/blur and on&#xA;modelValue change), this condition is checked. When enhancing it, it's recommended to&#xA;call via \`return this.\_myExtraCondition && super.\_reflectBackOn()\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |                                                                                                                | `boolean`                                                     | FormatMixin           |
-| `_onUserInputChanged`                    | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | FormatMixin           |
-| `__onCompositionEvent`                   | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `{ type }, event: Event`                                                                                       |                                                               | FormatMixin           |
-| `_setValueAndPreserveCaret`              | protected | Restores the cursor to its original position after updating the value.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `newValue: string`                                                                                             |                                                               | NativeTextFieldMixin  |
-| `focus`                                  | public    | Calls \`focus()\` on focusable element within                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |                                                                                                                |                                                               | FocusMixin            |
-| `blur`                                   | public    | Calls \`blur()\` on focusable element within                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |                                                                                                                |                                                               | FocusMixin            |
-| `_triggerInitialModelValueChangedEvent`  | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | FormControlMixin      |
-| `_enhanceLightDomClasses`                | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | FormControlMixin      |
 | `_enhanceLightDomA11y`                   | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | FormControlMixin      |
 | `_enhanceLightDomA11yForAdditionalSlots` | protected | Enhances additional slots(prefix, suffix, before, after) defined by developer.&#xA;&#xA;When boolean attribute data-label or data-description is found,&#xA;the slot element will be connected to the input via aria-labelledby or aria-describedby                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `additionalSlots: string[]`                                                                                    |                                                               | FormControlMixin      |
-| `__reflectAriaAttr`                      | protected | Will handle help text, validation feedback and character counter,&#xA;prefix/suffix/before/after (if they contain data-description flag attr).&#xA;Also, contents of id references that will be put in the \<lion-field>.\_ariaDescribedby property&#xA;from an external context, will be read by a screen reader.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `attrName: string, nodes: Element[], reorder: boolean\|undefined`                                              |                                                               | FormControlMixin      |
+| `_enhanceLightDomClasses`                | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | FormControlMixin      |
+| `_feedbackTemplate`                      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | FormControlMixin      |
+| `_getAriaDescriptionElements`            | protected | This function exposes descripion elements that a FormGroup should expose to its&#xA;children. See FormGroupMixin.\_\_getAllDescriptionElementsInParentChain()                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |                                                                                                                | `Array.<HTMLElement>`                                         | FormControlMixin      |
 | `_groupOneTemplate`                      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | FormControlMixin      |
 | `_groupTwoTemplate`                      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | FormControlMixin      |
-| `_labelTemplate`                         | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | FormControlMixin      |
+| `_hasFeedbackVisibleFor`                 | protected | Used to translate \`.hasFeedbackFor\` and \`.shouldShowFeedbackFor\` to \`.showsFeedbackFor\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `type: string`                                                                                                 |                                                               | ValidateMixin         |
 | `_helpTextTemplate`                      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | FormControlMixin      |
-| `_inputGroupTemplate`                    | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | FormControlMixin      |
+| `_inputGroupAfterTemplate`               | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | FormControlMixin      |
 | `_inputGroupBeforeTemplate`              | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | FormControlMixin      |
-| `_inputGroupPrefixTemplate`              | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult \| nothing`                                   | FormControlMixin      |
 | `_inputGroupInputTemplate`               | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | FormControlMixin      |
+| `_inputGroupPrefixTemplate`              | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult \| nothing`                                   | FormControlMixin      |
 | `_inputGroupSuffixTemplate`              | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult \| nothing`                                   | FormControlMixin      |
-| `_inputGroupAfterTemplate`               | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | FormControlMixin      |
-| `_feedbackTemplate`                      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | FormControlMixin      |
-| `_getAriaDescriptionElements`            | protected | This function exposes descripion elements that a FormGroup should expose to its&#xA;children. See FormGroupMixin.\_\_getAllDescriptionElementsInParentChain()                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |                                                                                                                | `Array.<HTMLElement>`                                         | FormControlMixin      |
-| `addToAriaLabelledBy`                    | public    | Allows to add extra element references to aria-labelledby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `element: HTMLElement, { idPrefix = '', reorder = true }, customConfig: {idPrefix?:string; reorder?: boolean}` |                                                               | FormControlMixin      |
-| `removeFromAriaLabelledBy`               | public    | Allows to remove element references from aria-labelledby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `element: HTMLElement`                                                                                         |                                                               | FormControlMixin      |
-| `addToAriaDescribedBy`                   | public    | Allows to add element references to aria-describedby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `element: HTMLElement, { idPrefix = '', reorder = true }, customConfig: {idPrefix?:string; reorder?: boolean}` |                                                               | FormControlMixin      |
-| `removeFromAriaDescribedBy`              | public    | Allows to remove element references from aria-describedby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `element: HTMLElement`                                                                                         |                                                               | FormControlMixin      |
-| `__getDirectSlotChild`                   | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `slotName: string`                                                                                             | `HTMLElement \| undefined`                                    | FormControlMixin      |
-| `_dispatchInitialModelValueChangedEvent` | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | FormControlMixin      |
-| `_onBeforeRepropagateChildrenValues`     | protected | Hook for Subclassers to add logic before repropagation                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `ev: CustomEvent`                                                                                              |                                                               | FormControlMixin      |
-| `__repropagateChildrenValues`            | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: CustomEvent`                                                                                              |                                                               | FormControlMixin      |
-| `_repropagationCondition`                | protected | Based on provided target, this condition determines whether received model-value-changed&#xA;event should be repropagated                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `target: FormControlHost`                                                                                      |                                                               | FormControlMixin      |
-| `_onLabelClick`                          | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | FormControlMixin      |
-| `makeRequestToBeDisabled`                | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | DisabledMixin         |
-| `retractRequestToBeDisabled`             | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | DisabledMixin         |
-| `click`                                  | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | DisabledMixin         |
-| `initInteractionState`                   | public    | Evaluations performed on connectedCallback.&#xA;This method is public, so it can be called at a later moment (when we need to wait for&#xA;registering children for instance) as well.&#xA;Since this method will be called twice in last mentioned scenario, it must stay idempotent.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                |                                                               | InteractionStateMixin |
+| `_inputGroupTemplate`                    | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | FormControlMixin      |
+| `_isEmpty`                               | protected | Used for required validator.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `modelValue: any`                                                                                              | `boolean`                                                     | FormControlMixin      |
 | `_iStateOnLeave`                         | protected | Sets touched value to true and reevaluates prefilled state.&#xA;When false, on next interaction, user will start with a clean state.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |                                                                                                                |                                                               | InteractionStateMixin |
 | `_iStateOnValueChange`                   | protected | Sets dirty value and validates when already touched or invalid                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                                                                                                                |                                                               | InteractionStateMixin |
-| `resetInteractionState`                  | public    | Resets touched and dirty, and recomputes prefilled                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |                                                                                                                |                                                               | LionField             |
-| `_onTouchedChanged`                      | protected | Dispatches event on touched state change                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |                                                                                                                |                                                               | InteractionStateMixin |
+| `_labelTemplate`                         | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | FormControlMixin      |
+| `_onBeforeRepropagateChildrenValues`     | protected | Hook for Subclassers to add logic before repropagation                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `ev: CustomEvent`                                                                                              |                                                               | FormControlMixin      |
+| `_onChange`                              | protected | Dispatches custom bubble event                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `ev: Event=`                                                                                                   |                                                               | LionField             |
 | `_onDirtyChanged`                        | protected | Dispatches event on touched state change                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |                                                                                                                |                                                               | InteractionStateMixin |
-| `_showFeedbackConditionFor`              | protected | Default feedbackCondition condition, used by Subclassers, that will be used when&#xA;\`feedbackCondition()\` is not overridden by Application Developer.&#xA;Show the validity feedback when returning true, don't show when false                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `type: string, meta: InteractionStates`                                                                        |                                                               | ValidateMixin         |
-| `validate`                               | public    | Triggered by:&#xA; \- modelValue change&#xA; \- change in the 'validators' array&#xA; \- change in the config of an individual Validator&#xA;&#xA;Three situations are handled:&#xA;- a1) the FormControl is empty: further execution is halted. When the Required Validator&#xA;(being mutually exclusive to the other Validators) is applied, it will end up in the&#xA;validation result (as the only Validator, since further execution was halted).&#xA;- a2) there are synchronous Validators: this is the most common flow. When modelValue hasn't&#xA;changed since last async results were generated, 'sync results' are merged with the&#xA;'async results'.&#xA;- a3) there are asynchronous Validators: for instance when server side evaluation is needed.&#xA;Executions are scheduled and awaited and the 'async results' are merged with the&#xA;'sync results'.&#xA;&#xA;- b) there are MetaValidators. After steps a1, a2, or a3 are finished, the holistic&#xA;MetaValidators (evaluating the total result of the 'regular' (a1, a2 and a3) validators)&#xA;will be run...&#xA;&#xA;Situations a2 and a3 are not mutually exclusive and can be triggered within one \`validate()\`&#xA;call. Situation b will occur after every call. | `{ clearCurrentResult = false }, opts: { clearCurrentResult?: boolean }`                                       |                                                               | ValidateMixin         |
-| `__executeValidators`                    | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | ValidateMixin         |
+| `_onLabelClick`                          | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | FormControlMixin      |
+| `_onModelValueChanged`                   | protected | Responds to modelValue changes in the synchronous cycle (most subclassers should listen to&#xA;the asynchronous cycle ('modelValue' in the .updated lifecycle))                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `{ modelValue }, old: { modelValue:unknown }, newV: { modelValue:unknown }`                                    |                                                               | FormatMixin           |
+| `_onTouchedChanged`                      | protected | Dispatches event on touched state change                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |                                                                                                                |                                                               | InteractionStateMixin |
+| `_onUserInputChanged`                    | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | FormatMixin           |
 | `_onValidatorUpdated`                    | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `e: Event\|CustomEvent`                                                                                        |                                                               | ValidateMixin         |
+| `_preventDuplicateLabelClick`            | protected | The native platform fires an event for both the click on the label, and also&#xA;the redispatched click on the native input element.&#xA;This results in two click events arriving at the host, but we only want one.&#xA;This method prevents the duplicate click and ensures the correct isTrusted event&#xA;with the correct event.target arrives at the host.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `ev: Event`                                                                                                    |                                                               | ChoiceInputMixin      |
+| `_prioritizeAndFilterFeedback`           | protected | Orders all active validators in this.\_\_validationResult.&#xA;Can also filter out occurrences (based on interaction states)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `{ validationResult }, opts: { validationResult: Validator[] }`                                                | `Validator[]`                                                 | ValidateMixin         |
+| `_proxyInputEvent`                       | protected | This can be called whenever the view value should be updated. Dependent on component type&#xA;("input" for \<input> or "change" for \<select>(mainly for IE)) a different event should be&#xA;used  as source for the "user-input-changed" event (which can be seen as an abstraction&#xA;layer on top of other events (input, change, whatever))                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |                                                                                                                |                                                               | FormatMixin           |
+| `_reflectBackFormattedValueToUser`       | protected | Synchronization from \`LionField.value\` to \`.\_inputNode.value\`&#xA;- flow \[1] will always be reflected back&#xA;- flow \[2] will not be reflected back when this flow was triggered via&#xA;  \`@user-input-changed\` (this will happen later, when \`formatOn\` condition is met)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |                                                                                                                |                                                               | FormatMixin           |
+| `_reflectBackOn`                         | protected | Every time .formattedValue is attempted to sync to the view value (on change/blur and on&#xA;modelValue change), this condition is checked. When enhancing it, it's recommended to&#xA;call via \`return this.\_myExtraCondition && super.\_reflectBackOn()\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |                                                                                                                | `boolean`                                                     | FormatMixin           |
+| `_repropagationCondition`                | protected | Based on provided target, this condition determines whether received model-value-changed&#xA;event should be repropagated                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `target: FormControlHost`                                                                                      |                                                               | FormControlMixin      |
+| `_setValueAndPreserveCaret`              | protected | Restores the cursor to its original position after updating the value.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `newValue: string`                                                                                             |                                                               | NativeTextFieldMixin  |
+| `_showFeedbackConditionFor`              | protected | Default feedbackCondition condition, used by Subclassers, that will be used when&#xA;\`feedbackCondition()\` is not overridden by Application Developer.&#xA;Show the validity feedback when returning true, don't show when false                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `type: string, meta: InteractionStates`                                                                        |                                                               | ValidateMixin         |
+| `_syncNameToParentFormGroup`             | protected | Override this in case of extending ChoiceInputMixin and requiring&#xA;to sync differently with parent form group name&#xA;Right now it checks tag name match where the parent form group tagname&#xA;should include the child field tagname ('checkbox' is included in 'checkbox-group')                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |                                                                                                                |                                                               | ChoiceInputMixin      |
+| `_syncValueUpwards`                      | protected | Synchronization from \`.\_inputNode.value\` to \`LionField\` (flow \[2])&#xA;Downwards syncing should only happen for \`LionField\`.value changes from 'above'.&#xA;This triggers \_onModelValueChanged and connects user input&#xA;to the parsing/formatting/serializing loop.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | FormatMixin           |
+| `_toggleChecked`                         | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: Event`                                                                                                    |                                                               | ChoiceInputMixin      |
+| `_triggerInitialModelValueChangedEvent`  | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | FormControlMixin      |
 | `_updateFeedbackComponent`               | protected | Responsible for retrieving messages from Validators and&#xA;(delegation of) rendering them.&#xA;&#xA;For \`.\_feedbackNode\` (extension of LionValidationFeedback):&#xA;- retrieve messages from highest prio Validators&#xA;- provide the result to custom feedback node and let the&#xA;custom node decide on their renderings&#xA;&#xA;In both cases:&#xA;- we compute the 'show' flag (like 'hasErrorVisible') for all types&#xA;- we set the customValidity message of the highest prio Validator&#xA;- we set aria-invalid="true" in case hasErrorVisible is true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |                                                                                                                |                                                               | ValidateMixin         |
-| `feedbackCondition`                      | public    | Allows the Application Developer to specify when a feedback message should be shown                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `type: string, meta: object, currentCondition: ((type: string, meta: object) => boolean)`                      | `boolean`                                                     | ValidateMixin         |
-| `_hasFeedbackVisibleFor`                 | protected | Used to translate \`.hasFeedbackFor\` and \`.shouldShowFeedbackFor\` to \`.showsFeedbackFor\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `type: string`                                                                                                 |                                                               | ValidateMixin         |
 | `_updateShouldShowFeedbackFor`           | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | ValidateMixin         |
-| `_prioritizeAndFilterFeedback`           | protected | Orders all active validators in this.\_\_validationResult.&#xA;Can also filter out occurrences (based on interaction states)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `{ validationResult }, opts: { validationResult: Validator[] }`                                                | `Validator[]`                                                 | ValidateMixin         |
-| `reset`                                  | public    | Resets modelValue to initial value.&#xA;Interaction states are cleared                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                |                                                               | LionField             |
-| `_onChange`                              | protected | Dispatches custom bubble event                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `ev: Event=`                                                                                                   |                                                               | LionField             |
 
 ### Events
 
@@ -190,141 +197,127 @@
 
 ### Fields
 
-| Name                                 | Privacy   | Type                                                                      | Default                                                                                                                           | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | Inherited From        |
-| ------------------------------------ | --------- | ------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------- |
-| `multipleChoice`                     | public    | `boolean`                                                                 | `true`                                                                                                                            | When false (default), modelValue and serializedValue will reflect the&#xA;currently selected choice (usually a string). When true, modelValue will and&#xA;serializedValue will be an array of strings.                                                                                                                                                                                                                                                                                                                                              | ChoiceGroupMixin      |
-| `modelValue`                         | public    |                                                                           |                                                                                                                                   | Object keyed by formElements names, containing formElements' modelValues                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | FormControlMixin      |
-| `serializedValue`                    | public    |                                                                           |                                                                                                                                   | Object keyed by formElements names, containing formElements' serializedValues                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | FormGroupMixin        |
-| `formattedValue`                     | public    |                                                                           |                                                                                                                                   | Object keyed by formElements names, containing formElements' formattedValues                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | FormGroupMixin        |
-| `operationMode`                      | public    | `OperationMode`                                                           |                                                                                                                                   | Types of input interaction of the FormControl (for instance 'enter'\|'select'\|'upload')                                                                                                                                                                                                                                                                                                                                                                                                                                                             | ValidateMixin         |
-| `_repropagationRole`                 | public    | `'child'\|'choice-group'\|'fieldset'`                                     | `'choice-group'`                                                                                                                  | Based on the role, details of handling model-value-changed repropagation differ.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | FormControlMixin      |
-| `formElements`                       | public    | `FormControlsCollection`                                                  | `new FormControlsCollection()`                                                                                                    | Closely mimics the natively supported HTMLFormControlsCollection. It can be accessed&#xA;both like an array and an object (based on control/element names).                                                                                                                                                                                                                                                                                                                                                                                          | FormRegistrarMixin    |
-| `_isFormOrFieldset`                  | protected | `boolean`                                                                 | `false`                                                                                                                           | Flag that determines how ".formElements" should behave.&#xA;For a regular fieldset (see LionFieldset) we expect ".formElements"&#xA;to be accessible as an object.&#xA;In case of a radio-group, a checkbox-group or a select/listbox,&#xA;it should act like an array (see ChoiceGroupMixin).&#xA;Usually, when false, we deal with a choice-group (radio-group, checkbox-group,&#xA;(multi)select)                                                                                                                                                 | FormRegistrarMixin    |
-| `initComplete`                       | public    | `Promise<any>`                                                            | `new Promise((resolve, reject) => { this.__resolveInitComplete = resolve; this.__rejectInitComplete = reject; })`                 | initComplete resolves after all pending initialization logic&#xA;(for instance \`\<form-group .serializedValue=${{ child1: 'a', child2: 'b' }}>\`)&#xA;is executed                                                                                                                                                                                                                                                                                                                                                                                   | FormRegistrarMixin    |
-| `registrationComplete`               | public    | `Promise<any> & {done?:boolean}`                                          | `new Promise((resolve, reject) => { this.__resolveRegistrationComplete = resolve; this.__rejectRegistrationComplete = reject; })` | registrationComplete waits for all children formElements to have registered                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | FormRegistrarMixin    |
-| `done`                               | public    | `boolean`                                                                 | `false`                                                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | FormRegistrarMixin    |
-| `_allValidators`                     | protected | `Validator[]`                                                             |                                                                                                                                   | Combination of validators provided by Application Developer and the default validators                                                                                                                                                                                                                                                                                                                                                                                                                                                               | ValidateMixin         |
-| `_feedbackConditionMeta`             | protected |                                                                           |                                                                                                                                   | Allows Subclassers to add meta info for feedbackCondition                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | ValidateMixin         |
-| `hasFeedbackFor`                     | public    | `ValidationType[]`                                                        | `[]`                                                                                                                              | As soon as validation happens (after modelValue/validators/validator param change), this&#xA;array is updated with the active ValidationTypes ('error'\|'warning'\|'success'\|'info' etc.).&#xA;Notice the difference with \`.showsFeedbackFor\`, which filters \`.hasFeedbackFor\` based on&#xA;\`.feedbackCondition()\`.&#xA;&#xA;For styling purposes, will be reflected to \[has-feedback-for="error warning"]. This can&#xA;be useful for subtle visual feedback on keyup, like a red/green border around an input.                             | ValidateMixin         |
-| `showsFeedbackFor`                   | public    | `ValidationType[]`                                                        | `[]`                                                                                                                              | Based on outcome of feedbackCondition, this array decides what ValidationTypes should be&#xA;shown in validationFeedback, based on meta data like interaction states.&#xA;&#xA;For styling purposes, it reflects it \`\[shows-feedback-for="error warning"]\`                                                                                                                                                                                                                                                                                        | ValidateMixin         |
-| `validationStates`                   | public    | `ValidationStates`                                                        | `{}`                                                                                                                              | The outcome of a validation 'round'. Keyed by ValidationType and Validator name                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ValidateMixin         |
-| `isPending`                          | public    | `boolean`                                                                 | `false`                                                                                                                           | Flag indicating whether async validation is pending.&#xA;Creates attribute \[is-pending] as a styling hook                                                                                                                                                                                                                                                                                                                                                                                                                                           | ValidateMixin         |
-| `validators`                         | public    | `Validator[]`                                                             | `[]`                                                                                                                              | Used by Application Developers to add Validators to a FormControl.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | ValidateMixin         |
-| `defaultValidators`                  | public    | `Validator[]`                                                             | `[]`                                                                                                                              | Used by Subclassers to add default Validators to a particular FormControl.&#xA;A date input for instance, always needs the isDate validator.                                                                                                                                                                                                                                                                                                                                                                                                         | ValidateMixin         |
-| `_visibleMessagesAmount`             | protected | `number`                                                                  | `1`                                                                                                                               | The amount of feedback messages that will visible in LionValidationFeedback                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | ValidateMixin         |
-| `touched`                            | public    | `boolean`                                                                 | `false`                                                                                                                           | True when user has focused and left(blurred) the field.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | FormGroupMixin        |
-| `dirty`                              | public    | `boolean`                                                                 | `false`                                                                                                                           | True when user has changed the value of the field.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | FormGroupMixin        |
-| `prefilled`                          | public    | `boolean`                                                                 | `false`                                                                                                                           | True when user has left non-empty field or input is prefilled.&#xA;The name must be seen from the point of view of the input field:&#xA;once the user enters the input field, the value is non-empty.                                                                                                                                                                                                                                                                                                                                                | FormGroupMixin        |
-| `filled`                             | public    | `boolean`                                                                 | `false`                                                                                                                           | True when the modelValue is non-empty (see \_isEmpty in FormControlMixin)                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | InteractionStateMixin |
-| `_leaveEvent`                        | protected | `string`                                                                  | `'blur'`                                                                                                                          | The event that triggers the touched state                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | InteractionStateMixin |
-| `_valueChangedEvent`                 | protected | `string`                                                                  | `'model-value-changed'`                                                                                                           | The event that triggers the dirty state                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | InteractionStateMixin |
-| `submitted`                          | public    | `boolean`                                                                 | `false`                                                                                                                           | True when parent form is submitted                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | FormGroupMixin        |
-| `_inputNode`                         | protected |                                                                           |                                                                                                                                   | The host element with role group (or radio-group or form) containing necessary aria attributes                                                                                                                                                                                                                                                                                                                                                                                                                                                       | FormControlMixin      |
-| `_initialModelValue`                 | protected |                                                                           |                                                                                                                                   | Gathers initial model values of all children. Used when resetGroup() is called.                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | FormGroupMixin        |
-| `value`                              | public    | `string`                                                                  | `''`                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | FormGroupMixin        |
-| `disabled`                           | public    | `boolean`                                                                 | `false`                                                                                                                           | Disables all formElements in group                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | DisabledMixin         |
-| `focused`                            | public    | `boolean`                                                                 | `false`                                                                                                                           | True when any of the children is focused.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | FormGroupMixin        |
-| `__descriptionElementsInParentChain` | protected |                                                                           | `new Set()`                                                                                                                       |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | FormGroupMixin        |
-| `__pendingValues`                    | protected | `{modelValue?:{[key:string]: any}, serializedValue?:{[key:string]: any}}` | `{ modelValue: {}, serializedValue: {} }`                                                                                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | FormGroupMixin        |
-| `label`                              | public    | `string`                                                                  | `''`                                                                                                                              | The label text for the input node.&#xA;When no value is defined, textContent of \[slot=label] will be used                                                                                                                                                                                                                                                                                                                                                                                                                                           | FormControlMixin      |
-| `helpText`                           | public    | `string`                                                                  | `''`                                                                                                                              | The helpt text for the input node.&#xA;When no value is defined, textContent of \[slot=help-text] will be used                                                                                                                                                                                                                                                                                                                                                                                                                                       | FormControlMixin      |
-| `fieldName`                          | public    | `string`                                                                  |                                                                                                                                   | Will be used in validation messages to refer to the current field                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | FormControlMixin      |
-| `_labelNode`                         | protected |                                                                           |                                                                                                                                   | Element where label will be rendered to                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | FormControlMixin      |
-| `_helpTextNode`                      | protected |                                                                           |                                                                                                                                   | Element where help text will be rendered to                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | FormControlMixin      |
-| `_feedbackNode`                      | protected |                                                                           |                                                                                                                                   | Element where validation feedback will be rendered to                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | FormControlMixin      |
-| `readOnly`                           | public    | `boolean`                                                                 | `false`                                                                                                                           | A Boolean attribute which, if present, indicates that the user should not be able to edit&#xA;the value of the input. The difference between disabled and readonly is that read-only&#xA;controls can still function, whereas disabled controls generally do not function as&#xA;controls until they are enabled.&#xA;(From: https\://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#attr-readonly)                                                                                                                                         | FormControlMixin      |
-| `labelSrOnly`                        | public    | `boolean`                                                                 | `false`                                                                                                                           | The label will only be visible for srceen readers when true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | FormControlMixin      |
-| `_inputId`                           | protected | `string`                                                                  |                                                                                                                                   | Unique id that can be used in all light dom                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | FormControlMixin      |
-| `_ariaLabelledNodes`                 | public    | `HTMLElement[]`                                                           | `[]`                                                                                                                              | Contains all elements that should end up in aria-labelledby of \`.\_inputNode\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | FormControlMixin      |
-| `_ariaDescribedNodes`                | public    | `HTMLElement[]`                                                           | `[]`                                                                                                                              | Contains all elements that should end up in aria-describedby of \`.\_inputNode\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | FormControlMixin      |
-| `_isRepropagationEndpoint`           | public    | `boolean`                                                                 | `false`                                                                                                                           | By default, a field with \_repropagationRole 'choice-group' will act as an&#xA;'endpoint'. This means it will be considered as an individual field: for&#xA;a select, individual options will not be part of the formPath. They&#xA;will.&#xA;Similarly, components that (a11y wise) need to be fieldsets, but 'interaction wise'&#xA;(from Application Developer perspective) need to be more like fields&#xA;(think of an amount-input with a currency select box next to it), can set this&#xA;to true to hide private internals in the formPath. | FormControlMixin      |
-| `_requestedToBeDisabled`             | protected | `boolean`                                                                 | `false`                                                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | DisabledMixin         |
+| Name                       | Privacy   | Type                                  | Default                                                                                                                           | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | Inherited From        |
+| -------------------------- | --------- | ------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------- |
+| `defaultValidators`        | public    | `Validator[]`                         | `[]`                                                                                                                              | Used by Subclassers to add default Validators to a particular FormControl.&#xA;A date input for instance, always needs the isDate validator.                                                                                                                                                                                                                                                                                                                                                                                                         | ValidateMixin         |
+| `dirty`                    | public    | `boolean`                             | `false`                                                                                                                           | True when user has changed the value of the field.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | FormGroupMixin        |
+| `disabled`                 | public    | `boolean`                             | `false`                                                                                                                           | Disables all formElements in group                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | DisabledMixin         |
+| `done`                     | public    | `boolean`                             | `false`                                                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | FormRegistrarMixin    |
+| `fieldName`                | public    | `string`                              |                                                                                                                                   | Will be used in validation messages to refer to the current field                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | FormControlMixin      |
+| `filled`                   | public    | `boolean`                             | `false`                                                                                                                           | True when the modelValue is non-empty (see \_isEmpty in FormControlMixin)                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | InteractionStateMixin |
+| `focused`                  | public    | `boolean`                             | `false`                                                                                                                           | True when any of the children is focused.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | FormGroupMixin        |
+| `formattedValue`           | public    |                                       |                                                                                                                                   | Object keyed by formElements names, containing formElements' formattedValues                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | FormGroupMixin        |
+| `formElements`             | public    | `FormControlsCollection`              | `new FormControlsCollection()`                                                                                                    | Closely mimics the natively supported HTMLFormControlsCollection. It can be accessed&#xA;both like an array and an object (based on control/element names).                                                                                                                                                                                                                                                                                                                                                                                          | FormRegistrarMixin    |
+| `hasFeedbackFor`           | public    | `ValidationType[]`                    | `[]`                                                                                                                              | As soon as validation happens (after modelValue/validators/validator param change), this&#xA;array is updated with the active ValidationTypes ('error'\|'warning'\|'success'\|'info' etc.).&#xA;Notice the difference with \`.showsFeedbackFor\`, which filters \`.hasFeedbackFor\` based on&#xA;\`.feedbackCondition()\`.&#xA;&#xA;For styling purposes, will be reflected to \[has-feedback-for="error warning"]. This can&#xA;be useful for subtle visual feedback on keyup, like a red/green border around an input.                             | ValidateMixin         |
+| `helpText`                 | public    | `string`                              | `''`                                                                                                                              | The helpt text for the input node.&#xA;When no value is defined, textContent of \[slot=help-text] will be used                                                                                                                                                                                                                                                                                                                                                                                                                                       | FormControlMixin      |
+| `initComplete`             | public    | `Promise<any>`                        | `new Promise((resolve, reject) => { this.__resolveInitComplete = resolve; this.__rejectInitComplete = reject; })`                 | initComplete resolves after all pending initialization logic&#xA;(for instance \`\<form-group .serializedValue=${{ child1: 'a', child2: 'b' }}>\`)&#xA;is executed                                                                                                                                                                                                                                                                                                                                                                                   | FormRegistrarMixin    |
+| `isPending`                | public    | `boolean`                             | `false`                                                                                                                           | Flag indicating whether async validation is pending.&#xA;Creates attribute \[is-pending] as a styling hook                                                                                                                                                                                                                                                                                                                                                                                                                                           | ValidateMixin         |
+| `label`                    | public    | `string`                              | `''`                                                                                                                              | The label text for the input node.&#xA;When no value is defined, textContent of \[slot=label] will be used                                                                                                                                                                                                                                                                                                                                                                                                                                           | FormControlMixin      |
+| `labelSrOnly`              | public    | `boolean`                             | `false`                                                                                                                           | The label will only be visible for srceen readers when true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | FormControlMixin      |
+| `modelValue`               | public    |                                       |                                                                                                                                   | Object keyed by formElements names, containing formElements' modelValues                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | FormControlMixin      |
+| `multipleChoice`           | public    | `boolean`                             | `true`                                                                                                                            | When false (default), modelValue and serializedValue will reflect the&#xA;currently selected choice (usually a string). When true, modelValue will and&#xA;serializedValue will be an array of strings.                                                                                                                                                                                                                                                                                                                                              | ChoiceGroupMixin      |
+| `operationMode`            | public    | `OperationMode`                       |                                                                                                                                   | Types of input interaction of the FormControl (for instance 'enter'\|'select'\|'upload')                                                                                                                                                                                                                                                                                                                                                                                                                                                             | ValidateMixin         |
+| `prefilled`                | public    | `boolean`                             | `false`                                                                                                                           | True when user has left non-empty field or input is prefilled.&#xA;The name must be seen from the point of view of the input field:&#xA;once the user enters the input field, the value is non-empty.                                                                                                                                                                                                                                                                                                                                                | FormGroupMixin        |
+| `readOnly`                 | public    | `boolean`                             | `false`                                                                                                                           | A Boolean attribute which, if present, indicates that the user should not be able to edit&#xA;the value of the input. The difference between disabled and readonly is that read-only&#xA;controls can still function, whereas disabled controls generally do not function as&#xA;controls until they are enabled.&#xA;(From: https\://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#attr-readonly)                                                                                                                                         | FormControlMixin      |
+| `registrationComplete`     | public    | `Promise<any> & {done?:boolean}`      | `new Promise((resolve, reject) => { this.__resolveRegistrationComplete = resolve; this.__rejectRegistrationComplete = reject; })` | registrationComplete waits for all children formElements to have registered                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | FormRegistrarMixin    |
+| `serializedValue`          | public    |                                       |                                                                                                                                   | Object keyed by formElements names, containing formElements' serializedValues                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | FormGroupMixin        |
+| `showsFeedbackFor`         | public    | `ValidationType[]`                    | `[]`                                                                                                                              | Based on outcome of feedbackCondition, this array decides what ValidationTypes should be&#xA;shown in validationFeedback, based on meta data like interaction states.&#xA;&#xA;For styling purposes, it reflects it \`\[shows-feedback-for="error warning"]\`                                                                                                                                                                                                                                                                                        | ValidateMixin         |
+| `submitted`                | public    | `boolean`                             | `false`                                                                                                                           | True when parent form is submitted                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | FormGroupMixin        |
+| `touched`                  | public    | `boolean`                             | `false`                                                                                                                           | True when user has focused and left(blurred) the field.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | FormGroupMixin        |
+| `validationStates`         | public    | `ValidationStates`                    | `{}`                                                                                                                              | The outcome of a validation 'round'. Keyed by ValidationType and Validator name                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ValidateMixin         |
+| `validators`               | public    | `Validator[]`                         | `[]`                                                                                                                              | Used by Application Developers to add Validators to a FormControl.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | ValidateMixin         |
+| `value`                    | public    | `string`                              | `''`                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | FormGroupMixin        |
+| `_allValidators`           | protected | `Validator[]`                         |                                                                                                                                   | Combination of validators provided by Application Developer and the default validators                                                                                                                                                                                                                                                                                                                                                                                                                                                               | ValidateMixin         |
+| `_ariaDescribedNodes`      | public    | `HTMLElement[]`                       | `[]`                                                                                                                              | Contains all elements that should end up in aria-describedby of \`.\_inputNode\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | FormControlMixin      |
+| `_ariaLabelledNodes`       | public    | `HTMLElement[]`                       | `[]`                                                                                                                              | Contains all elements that should end up in aria-labelledby of \`.\_inputNode\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | FormControlMixin      |
+| `_feedbackConditionMeta`   | protected |                                       |                                                                                                                                   | Allows Subclassers to add meta info for feedbackCondition                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | ValidateMixin         |
+| `_feedbackNode`            | protected |                                       |                                                                                                                                   | Element where validation feedback will be rendered to                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | FormControlMixin      |
+| `_helpTextNode`            | protected |                                       |                                                                                                                                   | Element where help text will be rendered to                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | FormControlMixin      |
+| `_initialModelValue`       | protected |                                       |                                                                                                                                   | Gathers initial model values of all children. Used when resetGroup() is called.                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | FormGroupMixin        |
+| `_inputId`                 | protected | `string`                              |                                                                                                                                   | Unique id that can be used in all light dom                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | FormControlMixin      |
+| `_inputNode`               | protected |                                       |                                                                                                                                   | The host element with role group (or radio-group or form) containing necessary aria attributes                                                                                                                                                                                                                                                                                                                                                                                                                                                       | FormControlMixin      |
+| `_isFormOrFieldset`        | protected | `boolean`                             | `false`                                                                                                                           | Flag that determines how ".formElements" should behave.&#xA;For a regular fieldset (see LionFieldset) we expect ".formElements"&#xA;to be accessible as an object.&#xA;In case of a radio-group, a checkbox-group or a select/listbox,&#xA;it should act like an array (see ChoiceGroupMixin).&#xA;Usually, when false, we deal with a choice-group (radio-group, checkbox-group,&#xA;(multi)select)                                                                                                                                                 | FormRegistrarMixin    |
+| `_isRepropagationEndpoint` | public    | `boolean`                             | `false`                                                                                                                           | By default, a field with \_repropagationRole 'choice-group' will act as an&#xA;'endpoint'. This means it will be considered as an individual field: for&#xA;a select, individual options will not be part of the formPath. They&#xA;will.&#xA;Similarly, components that (a11y wise) need to be fieldsets, but 'interaction wise'&#xA;(from Application Developer perspective) need to be more like fields&#xA;(think of an amount-input with a currency select box next to it), can set this&#xA;to true to hide private internals in the formPath. | FormControlMixin      |
+| `_labelNode`               | protected |                                       |                                                                                                                                   | Element where label will be rendered to                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | FormControlMixin      |
+| `_leaveEvent`              | protected | `string`                              | `'blur'`                                                                                                                          | The event that triggers the touched state                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | InteractionStateMixin |
+| `_repropagationRole`       | public    | `'child'\|'choice-group'\|'fieldset'` | `'choice-group'`                                                                                                                  | Based on the role, details of handling model-value-changed repropagation differ.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | FormControlMixin      |
+| `_requestedToBeDisabled`   | protected | `boolean`                             | `false`                                                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | DisabledMixin         |
+| `_valueChangedEvent`       | protected | `string`                              | `'model-value-changed'`                                                                                                           | The event that triggers the dirty state                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | InteractionStateMixin |
+| `_visibleMessagesAmount`   | protected | `number`                              | `1`                                                                                                                               | The amount of feedback messages that will visible in LionValidationFeedback                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | ValidateMixin         |
 
 ### Methods
 
-| Name                                         | Privacy   | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | Parameters                                                                                                     | Return                      | Inherited From        |
-| -------------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- | --------------------------- | --------------------- |
-| `_completeRegistration`                      | protected | Resolves the registrationComplete promise. Subclassers can delay if needed                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |                                                                                                                |                             | FormRegistrarMixin    |
-| `addFormElement`                             | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `child: FormControl, indexToInsertAt: number`                                                                  |                             | FormRegistrarMixin    |
-| `clear`                                      | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | ChoiceGroupMixin      |
-| `_triggerInitialModelValueChangedEvent`      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | FormControlMixin      |
-| `_getFromAllFormElementsFilter`              | protected | A filter function which will exclude a form field when returning false&#xA;By default, exclude form fields which are disabled&#xA;&#xA;The type is be passed as well for more fine grained control, e.g.&#xA;distinguish the filter when fetching modelValue versus serializedValue                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `el: FormControl, type: string`                                                                                | `boolean`                   | FormGroupMixin        |
-| `_getFromAllFormElements`                    | protected | Implicit :(                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `property: string, filterFn: (el: FormControl, property?: string) => boolean`                                  | `{[name:string]: any}`      | FormGroupMixin        |
-| `_throwWhenInvalidChildModelValue`           | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `child: FormControl`                                                                                           |                             | ChoiceGroupMixin      |
-| `_isEmpty`                                   | protected | Used for Required validation and computation of interaction states                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `modelValue: any`                                                                                              | `boolean`                   | FormControlMixin      |
-| `_checkSingleChoiceElements`                 | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: CustomEvent & {target:FormControl}`                                                                       |                             | ChoiceGroupMixin      |
-| `_getCheckedElements`                        | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | ChoiceGroupMixin      |
-| `_setCheckedElements`                        | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `value: string \| any[], check: Function`                                                                      |                             | ChoiceGroupMixin      |
-| `_onBeforeRepropagateChildrenValues`         | protected | Hook for Subclassers to add logic before repropagation                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `ev: CustomEvent`                                                                                              |                             | FormControlMixin      |
-| `_repropagationCondition`                    | protected | Based on provided target, this condition determines whether received model-value-changed&#xA;event should be repropagated                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `target: FormControlHost & ChoiceInputHost`                                                                    |                             | FormControlMixin      |
-| `isRegisteredFormElement`                    | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `el: ElementWithParentFormGroup`                                                                               |                             | FormRegistrarMixin    |
-| `removeFormElement`                          | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `child: FormControlHost`                                                                                       |                             | FormRegistrarMixin    |
-| `_onRequestToAddFormElement`                 | protected | Hook for Subclassers to perform logic before an element is added                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `ev: CustomEvent`                                                                                              |                             | FormRegistrarMixin    |
-| `_onRequestToChangeFormElementName`          | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: CustomEvent`                                                                                              |                             | FormRegistrarMixin    |
-| `_onRequestToRemoveFormElement`              | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: CustomEvent`                                                                                              |                             | FormRegistrarMixin    |
-| `updateSync`                                 | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `name: string, oldValue: ?`                                                                                    |                             | ValidateMixin         |
-| `validate`                                   | public    | Triggered by:&#xA; \- modelValue change&#xA; \- change in the 'validators' array&#xA; \- change in the config of an individual Validator&#xA;&#xA;Three situations are handled:&#xA;- a1) the FormControl is empty: further execution is halted. When the Required Validator&#xA;(being mutually exclusive to the other Validators) is applied, it will end up in the&#xA;validation result (as the only Validator, since further execution was halted).&#xA;- a2) there are synchronous Validators: this is the most common flow. When modelValue hasn't&#xA;changed since last async results were generated, 'sync results' are merged with the&#xA;'async results'.&#xA;- a3) there are asynchronous Validators: for instance when server side evaluation is needed.&#xA;Executions are scheduled and awaited and the 'async results' are merged with the&#xA;'sync results'.&#xA;&#xA;- b) there are MetaValidators. After steps a1, a2, or a3 are finished, the holistic&#xA;MetaValidators (evaluating the total result of the 'regular' (a1, a2 and a3) validators)&#xA;will be run...&#xA;&#xA;Situations a2 and a3 are not mutually exclusive and can be triggered within one \`validate()\`&#xA;call. Situation b will occur after every call. | `{ clearCurrentResult = false }, opts: { clearCurrentResult?: boolean }`                                       |                             | ValidateMixin         |
-| `__executeValidators`                        | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | ValidateMixin         |
-| `_onValidatorUpdated`                        | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `e: Event\|CustomEvent`                                                                                        |                             | ValidateMixin         |
-| `_updateFeedbackComponent`                   | protected | Responsible for retrieving messages from Validators and&#xA;(delegation of) rendering them.&#xA;&#xA;For \`.\_feedbackNode\` (extension of LionValidationFeedback):&#xA;- retrieve messages from highest prio Validators&#xA;- provide the result to custom feedback node and let the&#xA;custom node decide on their renderings&#xA;&#xA;In both cases:&#xA;- we compute the 'show' flag (like 'hasErrorVisible') for all types&#xA;- we set the customValidity message of the highest prio Validator&#xA;- we set aria-invalid="true" in case hasErrorVisible is true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |                                                                                                                |                             | ValidateMixin         |
-| `_showFeedbackConditionFor`                  | protected | Default feedbackCondition condition, used by Subclassers, that will be used when&#xA;\`feedbackCondition()\` is not overridden by Application Developer.&#xA;Show the validity feedback when returning true, don't show when false                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `type: string, meta: object`                                                                                   |                             | ValidateMixin         |
-| `feedbackCondition`                          | public    | Allows the Application Developer to specify when a feedback message should be shown                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `type: string, meta: object, currentCondition: ((type: string, meta: object) => boolean)`                      | `boolean`                   | ValidateMixin         |
-| `_hasFeedbackVisibleFor`                     | protected | Used to translate \`.hasFeedbackFor\` and \`.shouldShowFeedbackFor\` to \`.showsFeedbackFor\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `type: string`                                                                                                 |                             | ValidateMixin         |
-| `_updateShouldShowFeedbackFor`               | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | ValidateMixin         |
-| `_prioritizeAndFilterFeedback`               | protected | Orders all active validators in this.\_\_validationResult.&#xA;Can also filter out occurrences (based on interaction states)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `{ validationResult }, opts: { validationResult: Validator[] }`                                                | `Validator[]`               | ValidateMixin         |
-| `initInteractionState`                       | public    | Evaluations performed on connectedCallback.&#xA;This method is public, so it can be called at a later moment (when we need to wait for&#xA;registering children for instance) as well.&#xA;Since this method will be called twice in last mentioned scenario, it must stay idempotent.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                |                             | InteractionStateMixin |
-| `_iStateOnLeave`                             | protected | Sets touched value to true and reevaluates prefilled state.&#xA;When false, on next interaction, user will start with a clean state.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |                                                                                                                |                             | InteractionStateMixin |
-| `_iStateOnValueChange`                       | protected | Sets dirty value and validates when already touched or invalid                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                                                                                                                |                             | InteractionStateMixin |
-| `resetInteractionState`                      | public    | Resets touched and dirty, and recomputes prefilled                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |                                                                                                                |                             | FormGroupMixin        |
-| `_onTouchedChanged`                          | protected | Dispatches event on touched state change                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |                                                                                                                |                             | InteractionStateMixin |
-| `_onDirtyChanged`                            | protected | Dispatches event on touched state change                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |                                                                                                                |                             | InteractionStateMixin |
-| `__initInteractionStates`                    | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | FormGroupMixin        |
-| `__setupOutsideClickHandling`                | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | FormGroupMixin        |
-| `_checkForOutsideClick`                      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `event: Event`                                                                                                 |                             | FormGroupMixin        |
-| `__requestChildrenToBeDisabled`              | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | FormGroupMixin        |
-| `__retractRequestChildrenToBeDisabled`       | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | FormGroupMixin        |
-| `_inputGroupTemplate`                        | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`            | FormControlMixin      |
-| `submitGroup`                                | public    | Handles interaction state 'submitted'.&#xA;This allows children to enable visibility of validation feedback                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |                                                                                                                |                             | FormGroupMixin        |
-| `resetGroup`                                 | public    | Resets to initial/prefilled values and interaction states of all FormControls in group,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |                                                                                                                |                             | FormGroupMixin        |
-| `clearGroup`                                 | public    | Clears all values and resets all interaction states of all FormControls in group,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |                                                                                                                |                             | FormGroupMixin        |
-| `_setValueForAllFormElements`                | protected | Sets the same value for requested property in all formElements                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `property: string \| number, value: any`                                                                       |                             | FormGroupMixin        |
-| `_setValueMapForAllFormElements`             | protected | Allows to set formElements values via a keyed object structure                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `property: string, values: { [x: string]: any; }`                                                              |                             | FormGroupMixin        |
-| `_anyFormElementHas`                         | protected | Returns true when one of the formElements has requested                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | `property: string`                                                                                             |                             | FormGroupMixin        |
-| `_anyFormElementHasFeedbackFor`              | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `state: string`                                                                                                |                             | FormGroupMixin        |
-| `_everyFormElementHas`                       | protected | Returns true when all of the formElements have requested property                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `property: string`                                                                                             |                             | FormGroupMixin        |
-| `__onChildValidatePerformed`                 | protected | Gets triggered by event 'validate-performed' which enabled us to handle 2 different situations&#xA; \- react on modelValue change, which says something about the validity as a whole&#xA; (at least two checkboxes for instance) and nothing about the children's values&#xA; \- children validity states have changed, so fieldset needs to update itself based on that                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `ev: Event`                                                                                                    |                             | FormGroupMixin        |
-| `_syncFocused`                               | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | FormGroupMixin        |
-| `_onFocusOut`                                | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: Event`                                                                                                    |                             | FormGroupMixin        |
-| `_syncDirty`                                 | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | FormGroupMixin        |
-| `__storeAllDescriptionElementsInParentChain` | protected | Traverses the \_parentFormGroup tree, and gathers all aria description elements&#xA;(feedback) that should be provided to children.&#xA;&#xA;In the example below, when the input for 'street' has focus, a screenreader user&#xA;would hear the #group-error.&#xA;In case one of the inputs was in error state as well, the SR user would&#xA;first hear the local error, followed by #group-error                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |                                                                                                                |                             | FormGroupMixin        |
-| `__linkParentMessages`                       | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `child: FormControl`                                                                                           |                             | FormGroupMixin        |
-| `__unlinkParentMessages`                     | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `child: FormControl`                                                                                           |                             | FormGroupMixin        |
-| `_enhanceLightDomClasses`                    | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | FormControlMixin      |
-| `_enhanceLightDomA11y`                       | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | FormControlMixin      |
-| `_enhanceLightDomA11yForAdditionalSlots`     | protected | Enhances additional slots(prefix, suffix, before, after) defined by developer.&#xA;&#xA;When boolean attribute data-label or data-description is found,&#xA;the slot element will be connected to the input via aria-labelledby or aria-describedby                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `additionalSlots: string[]`                                                                                    |                             | FormControlMixin      |
-| `__reflectAriaAttr`                          | protected | Will handle help text, validation feedback and character counter,&#xA;prefix/suffix/before/after (if they contain data-description flag attr).&#xA;Also, contents of id references that will be put in the \<lion-field>.\_ariaDescribedby property&#xA;from an external context, will be read by a screen reader.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `attrName: string, nodes: Element[], reorder: boolean\|undefined`                                              |                             | FormControlMixin      |
-| `_groupOneTemplate`                          | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`            | FormControlMixin      |
-| `_groupTwoTemplate`                          | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`            | FormControlMixin      |
-| `_labelTemplate`                             | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`            | FormControlMixin      |
-| `_helpTextTemplate`                          | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`            | FormControlMixin      |
-| `_inputGroupBeforeTemplate`                  | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`            | FormControlMixin      |
-| `_inputGroupPrefixTemplate`                  | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult \| nothing` | FormControlMixin      |
-| `_inputGroupInputTemplate`                   | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`            | FormControlMixin      |
-| `_inputGroupSuffixTemplate`                  | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult \| nothing` | FormControlMixin      |
-| `_inputGroupAfterTemplate`                   | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`            | FormControlMixin      |
-| `_feedbackTemplate`                          | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`            | FormControlMixin      |
-| `_getAriaDescriptionElements`                | protected | This function exposes descripion elements that a FormGroup should expose to its&#xA;children. See FormGroupMixin.\_\_getAllDescriptionElementsInParentChain()                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |                                                                                                                | `Array.<HTMLElement>`       | FormControlMixin      |
-| `addToAriaLabelledBy`                        | public    | Allows to add extra element references to aria-labelledby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `element: HTMLElement, { idPrefix = '', reorder = true }, customConfig: {idPrefix?:string; reorder?: boolean}` |                             | FormControlMixin      |
-| `removeFromAriaLabelledBy`                   | public    | Allows to remove element references from aria-labelledby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `element: HTMLElement`                                                                                         |                             | FormControlMixin      |
-| `addToAriaDescribedBy`                       | public    | Allows to add element references to aria-describedby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `element: HTMLElement, { idPrefix = '', reorder = true }, customConfig: {idPrefix?:string; reorder?: boolean}` |                             | FormControlMixin      |
-| `removeFromAriaDescribedBy`                  | public    | Allows to remove element references from aria-describedby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `element: HTMLElement`                                                                                         |                             | FormControlMixin      |
-| `__getDirectSlotChild`                       | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `slotName: string`                                                                                             | `HTMLElement \| undefined`  | FormControlMixin      |
-| `_dispatchInitialModelValueChangedEvent`     | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | FormControlMixin      |
-| `__repropagateChildrenValues`                | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: CustomEvent`                                                                                              |                             | FormControlMixin      |
-| `_onLabelClick`                              | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | FormControlMixin      |
-| `makeRequestToBeDisabled`                    | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | DisabledMixin         |
-| `retractRequestToBeDisabled`                 | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | DisabledMixin         |
-| `click`                                      | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | DisabledMixin         |
+| Name                                     | Privacy   | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | Parameters                                                                                                     | Return                      | Inherited From        |
+| ---------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- | --------------------------- | --------------------- |
+| `addFormElement`                         | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `child: FormControl, indexToInsertAt: number`                                                                  |                             | FormRegistrarMixin    |
+| `addToAriaDescribedBy`                   | public    | Allows to add element references to aria-describedby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `element: HTMLElement, { idPrefix = '', reorder = true }, customConfig: {idPrefix?:string; reorder?: boolean}` |                             | FormControlMixin      |
+| `addToAriaLabelledBy`                    | public    | Allows to add extra element references to aria-labelledby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `element: HTMLElement, { idPrefix = '', reorder = true }, customConfig: {idPrefix?:string; reorder?: boolean}` |                             | FormControlMixin      |
+| `clear`                                  | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | ChoiceGroupMixin      |
+| `clearGroup`                             | public    | Clears all values and resets all interaction states of all FormControls in group,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |                                                                                                                |                             | FormGroupMixin        |
+| `click`                                  | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | DisabledMixin         |
+| `feedbackCondition`                      | public    | Allows the Application Developer to specify when a feedback message should be shown                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `type: string, meta: object, currentCondition: ((type: string, meta: object) => boolean)`                      | `boolean`                   | ValidateMixin         |
+| `initInteractionState`                   | public    | Evaluations performed on connectedCallback.&#xA;This method is public, so it can be called at a later moment (when we need to wait for&#xA;registering children for instance) as well.&#xA;Since this method will be called twice in last mentioned scenario, it must stay idempotent.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                |                             | InteractionStateMixin |
+| `isRegisteredFormElement`                | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `el: ElementWithParentFormGroup`                                                                               |                             | FormRegistrarMixin    |
+| `makeRequestToBeDisabled`                | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | DisabledMixin         |
+| `removeFormElement`                      | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `child: FormControlHost`                                                                                       |                             | FormRegistrarMixin    |
+| `removeFromAriaDescribedBy`              | public    | Allows to remove element references from aria-describedby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `element: HTMLElement`                                                                                         |                             | FormControlMixin      |
+| `removeFromAriaLabelledBy`               | public    | Allows to remove element references from aria-labelledby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `element: HTMLElement`                                                                                         |                             | FormControlMixin      |
+| `resetGroup`                             | public    | Resets to initial/prefilled values and interaction states of all FormControls in group,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |                                                                                                                |                             | FormGroupMixin        |
+| `resetInteractionState`                  | public    | Resets touched and dirty, and recomputes prefilled                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |                                                                                                                |                             | FormGroupMixin        |
+| `retractRequestToBeDisabled`             | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | DisabledMixin         |
+| `submitGroup`                            | public    | Handles interaction state 'submitted'.&#xA;This allows children to enable visibility of validation feedback                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |                                                                                                                |                             | FormGroupMixin        |
+| `updateSync`                             | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `name: string, oldValue: ?`                                                                                    |                             | ValidateMixin         |
+| `validate`                               | public    | Triggered by:&#xA; \- modelValue change&#xA; \- change in the 'validators' array&#xA; \- change in the config of an individual Validator&#xA;&#xA;Three situations are handled:&#xA;- a1) the FormControl is empty: further execution is halted. When the Required Validator&#xA;(being mutually exclusive to the other Validators) is applied, it will end up in the&#xA;validation result (as the only Validator, since further execution was halted).&#xA;- a2) there are synchronous Validators: this is the most common flow. When modelValue hasn't&#xA;changed since last async results were generated, 'sync results' are merged with the&#xA;'async results'.&#xA;- a3) there are asynchronous Validators: for instance when server side evaluation is needed.&#xA;Executions are scheduled and awaited and the 'async results' are merged with the&#xA;'sync results'.&#xA;&#xA;- b) there are MetaValidators. After steps a1, a2, or a3 are finished, the holistic&#xA;MetaValidators (evaluating the total result of the 'regular' (a1, a2 and a3) validators)&#xA;will be run...&#xA;&#xA;Situations a2 and a3 are not mutually exclusive and can be triggered within one \`validate()\`&#xA;call. Situation b will occur after every call. | `{ clearCurrentResult = false }, opts: { clearCurrentResult?: boolean }`                                       |                             | ValidateMixin         |
+| `_anyFormElementHas`                     | protected | Returns true when one of the formElements has requested                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | `property: string`                                                                                             |                             | FormGroupMixin        |
+| `_anyFormElementHasFeedbackFor`          | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `state: string`                                                                                                |                             | FormGroupMixin        |
+| `_checkForOutsideClick`                  | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `event: Event`                                                                                                 |                             | FormGroupMixin        |
+| `_checkSingleChoiceElements`             | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: CustomEvent & {target:FormControl}`                                                                       |                             | ChoiceGroupMixin      |
+| `_completeRegistration`                  | protected | Resolves the registrationComplete promise. Subclassers can delay if needed                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |                                                                                                                |                             | FormRegistrarMixin    |
+| `_dispatchInitialModelValueChangedEvent` | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | FormControlMixin      |
+| `_enhanceLightDomA11y`                   | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | FormControlMixin      |
+| `_enhanceLightDomA11yForAdditionalSlots` | protected | Enhances additional slots(prefix, suffix, before, after) defined by developer.&#xA;&#xA;When boolean attribute data-label or data-description is found,&#xA;the slot element will be connected to the input via aria-labelledby or aria-describedby                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `additionalSlots: string[]`                                                                                    |                             | FormControlMixin      |
+| `_enhanceLightDomClasses`                | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | FormControlMixin      |
+| `_everyFormElementHas`                   | protected | Returns true when all of the formElements have requested property                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `property: string`                                                                                             |                             | FormGroupMixin        |
+| `_feedbackTemplate`                      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`            | FormControlMixin      |
+| `_getAriaDescriptionElements`            | protected | This function exposes descripion elements that a FormGroup should expose to its&#xA;children. See FormGroupMixin.\_\_getAllDescriptionElementsInParentChain()                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |                                                                                                                | `Array.<HTMLElement>`       | FormControlMixin      |
+| `_getCheckedElements`                    | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | ChoiceGroupMixin      |
+| `_getFromAllFormElements`                | protected | Implicit :(                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `property: string, filterFn: (el: FormControl, property?: string) => boolean`                                  | `{[name:string]: any}`      | FormGroupMixin        |
+| `_getFromAllFormElementsFilter`          | protected | A filter function which will exclude a form field when returning false&#xA;By default, exclude form fields which are disabled&#xA;&#xA;The type is be passed as well for more fine grained control, e.g.&#xA;distinguish the filter when fetching modelValue versus serializedValue                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `el: FormControl, type: string`                                                                                | `boolean`                   | FormGroupMixin        |
+| `_groupOneTemplate`                      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`            | FormControlMixin      |
+| `_groupTwoTemplate`                      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`            | FormControlMixin      |
+| `_hasFeedbackVisibleFor`                 | protected | Used to translate \`.hasFeedbackFor\` and \`.shouldShowFeedbackFor\` to \`.showsFeedbackFor\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `type: string`                                                                                                 |                             | ValidateMixin         |
+| `_helpTextTemplate`                      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`            | FormControlMixin      |
+| `_inputGroupAfterTemplate`               | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`            | FormControlMixin      |
+| `_inputGroupBeforeTemplate`              | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`            | FormControlMixin      |
+| `_inputGroupInputTemplate`               | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`            | FormControlMixin      |
+| `_inputGroupPrefixTemplate`              | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult \| nothing` | FormControlMixin      |
+| `_inputGroupSuffixTemplate`              | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult \| nothing` | FormControlMixin      |
+| `_inputGroupTemplate`                    | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`            | FormControlMixin      |
+| `_isEmpty`                               | protected | Used for Required validation and computation of interaction states                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `modelValue: any`                                                                                              | `boolean`                   | FormControlMixin      |
+| `_iStateOnLeave`                         | protected | Sets touched value to true and reevaluates prefilled state.&#xA;When false, on next interaction, user will start with a clean state.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |                                                                                                                |                             | InteractionStateMixin |
+| `_iStateOnValueChange`                   | protected | Sets dirty value and validates when already touched or invalid                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                                                                                                                |                             | InteractionStateMixin |
+| `_labelTemplate`                         | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`            | FormControlMixin      |
+| `_onBeforeRepropagateChildrenValues`     | protected | Hook for Subclassers to add logic before repropagation                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `ev: CustomEvent`                                                                                              |                             | FormControlMixin      |
+| `_onDirtyChanged`                        | protected | Dispatches event on touched state change                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |                                                                                                                |                             | InteractionStateMixin |
+| `_onFocusOut`                            | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: Event`                                                                                                    |                             | FormGroupMixin        |
+| `_onLabelClick`                          | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | FormControlMixin      |
+| `_onRequestToAddFormElement`             | protected | Hook for Subclassers to perform logic before an element is added                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `ev: CustomEvent`                                                                                              |                             | FormRegistrarMixin    |
+| `_onRequestToChangeFormElementName`      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: CustomEvent`                                                                                              |                             | FormRegistrarMixin    |
+| `_onRequestToRemoveFormElement`          | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: CustomEvent`                                                                                              |                             | FormRegistrarMixin    |
+| `_onTouchedChanged`                      | protected | Dispatches event on touched state change                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |                                                                                                                |                             | InteractionStateMixin |
+| `_onValidatorUpdated`                    | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `e: Event\|CustomEvent`                                                                                        |                             | ValidateMixin         |
+| `_prioritizeAndFilterFeedback`           | protected | Orders all active validators in this.\_\_validationResult.&#xA;Can also filter out occurrences (based on interaction states)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `{ validationResult }, opts: { validationResult: Validator[] }`                                                | `Validator[]`               | ValidateMixin         |
+| `_repropagationCondition`                | protected | Based on provided target, this condition determines whether received model-value-changed&#xA;event should be repropagated                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `target: FormControlHost & ChoiceInputHost`                                                                    |                             | FormControlMixin      |
+| `_setCheckedElements`                    | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `value: string \| any[], check: Function`                                                                      |                             | ChoiceGroupMixin      |
+| `_setValueForAllFormElements`            | protected | Sets the same value for requested property in all formElements                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `property: string \| number, value: any`                                                                       |                             | FormGroupMixin        |
+| `_setValueMapForAllFormElements`         | protected | Allows to set formElements values via a keyed object structure                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `property: string, values: { [x: string]: any; }`                                                              |                             | FormGroupMixin        |
+| `_showFeedbackConditionFor`              | protected | Default feedbackCondition condition, used by Subclassers, that will be used when&#xA;\`feedbackCondition()\` is not overridden by Application Developer.&#xA;Show the validity feedback when returning true, don't show when false                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `type: string, meta: object`                                                                                   |                             | ValidateMixin         |
+| `_syncDirty`                             | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | FormGroupMixin        |
+| `_syncFocused`                           | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | FormGroupMixin        |
+| `_throwWhenInvalidChildModelValue`       | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `child: FormControl`                                                                                           |                             | ChoiceGroupMixin      |
+| `_triggerInitialModelValueChangedEvent`  | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | FormControlMixin      |
+| `_updateFeedbackComponent`               | protected | Responsible for retrieving messages from Validators and&#xA;(delegation of) rendering them.&#xA;&#xA;For \`.\_feedbackNode\` (extension of LionValidationFeedback):&#xA;- retrieve messages from highest prio Validators&#xA;- provide the result to custom feedback node and let the&#xA;custom node decide on their renderings&#xA;&#xA;In both cases:&#xA;- we compute the 'show' flag (like 'hasErrorVisible') for all types&#xA;- we set the customValidity message of the highest prio Validator&#xA;- we set aria-invalid="true" in case hasErrorVisible is true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |                                                                                                                |                             | ValidateMixin         |
+| `_updateShouldShowFeedbackFor`           | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | ValidateMixin         |
 
 ### Events
 
@@ -368,148 +361,143 @@
 
 | Name                         | Privacy   | Type                                      | Default                         | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | Inherited From        |
 | ---------------------------- | --------- | ----------------------------------------- | ------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------- |
-| `_checkboxGroupNode`         | protected |                                           |                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                       |
-| `_subCheckboxes`             | protected |                                           |                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                       |
-| `indeterminate`              | public    | `boolean`                                 | `false`                         | Indeterminate state of the checkbox                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |                       |
-| `_indeterminateSubStates`    | protected | `boolean[]`                               | `[]`                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                       |
-| `mixedState`                 | public    | `boolean`                                 | `false`                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                       |
+| `allowCrossRootRegistration` | public    | `boolean`                                 | `false`                         | To encourage accessibility best practices, \`form-element-register\` events&#xA;do not pierce through shadow roots. This forces the developer to create form groups and fieldsets that automatically allow the creation of accessible relationships in the same dom tree.&#xA;Use this option if you know what you're doing. It will then be possible to nest FormControls&#xA;inside shadow dom. See https\://lion.js.org/fundamentals/rationales/accessibility/#shadow-roots-and-accessibility                                                                                                          | FormRegisteringMixin  |
+| `autocomplete`               | public    | `string \| undefined`                     | `undefined`                     | Delegates this property to input/textarea/select.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | NativeTextFieldMixin  |
+| `autofocus`                  | public    | `boolean`                                 | `false`                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | FocusMixin            |
+| `checked`                    | public    | `boolean`                                 |                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | ChoiceInputMixin      |
 | `choiceValue`                | public    | `string\|any`                             |                                 | The value that will be registered to the modelValue of the parent ChoiceGroup. Recommended&#xA;to be a string                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | ChoiceInputMixin      |
-| `modelValue`                 | public    | `{value:string\|any,checked:boolean}`     | `{ value: '', checked: false }` | Whereas 'normal' \`.modelValue\`s usually store a complex/typed version&#xA;of a view value, choice inputs have a slightly different approach.&#xA;In order to remain their Single Source of Truth characteristic, choice inputs&#xA;store both the value and 'checkedness', in the format { value: 'x', checked: true }&#xA;Different from the platform, this also allows to serialize the 'non checkedness',&#xA;allowing to restore form state easily and inform the server about unchecked options.                                                                                                   | FormControlMixin      |
+| `defaultValidators`          | public    | `Validator[]`                             | `[]`                            | Used by Subclassers to add default Validators to a particular FormControl.&#xA;A date input for instance, always needs the isDate validator.                                                                                                                                                                                                                                                                                                                                                                                                                                                              | ValidateMixin         |
+| `dirty`                      | public    | `boolean`                                 | `false`                         | True when user has changed the value of the field.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | InteractionStateMixin |
 | `disabled`                   | public    | `boolean`                                 | `false`                         | Boolean indicating whether or not this element is disabled.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | DisabledMixin         |
-| `checked`                    | public    | `boolean`                                 |                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | ChoiceInputMixin      |
-| `value`                      | public    |                                           |                                 | The view value. Will be delegated to \`.\_inputNode.value\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | FormatMixin           |
+| `fieldName`                  | public    | `string`                                  |                                 | Will be used in validation messages to refer to the current field                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | FormControlMixin      |
+| `filled`                     | public    | `boolean`                                 | `false`                         | True when the modelValue is non-empty (see \_isEmpty in FormControlMixin)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | InteractionStateMixin |
+| `focused`                    | public    | `boolean`                                 | `false`                         | Whether the focusable element within (\`.\_focusableNode\`) is focused.&#xA;Reflects to attribute '\[focused]' as a styling hook                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | FocusMixin            |
+| `focusedVisible`             | public    | `boolean`                                 | `false`                         | Whether the focusable element within (\`.\_focusableNode\`) matches ':focus-visible'&#xA;Reflects to attribute '\[focused-visible]' as a styling hook&#xA;See: https\://developer.mozilla.org/en-US/docs/Web/CSS/:focus-visible                                                                                                                                                                                                                                                                                                                                                                           | FocusMixin            |
 | `formatOn`                   | protected | `string`                                  | `'change'`                      | Event that will trigger formatting (more precise, visual update of the view, so the&#xA;user sees the formatted value)&#xA;Default: 'change'                                                                                                                                                                                                                                                                                                                                                                                                                                                              | FormatMixin           |
 | `formatOptions`              | public    |                                           | `({ mode: 'auto' })`            | Configuration object that will be available inside the formatter function                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | FormatMixin           |
 | `formattedValue`             | public    | `string\|undefined`                       | `undefined`                     | The view value is the result of the formatter function (when available).&#xA;The result will be stored in the native \_inputNode (usually an input\[type=text]).&#xA;&#xA;Examples:&#xA;- For a date input, this would be '20/01/1999' (dependent on locale).&#xA;- For a number input, this could be '1,234.56' (a String representation of modelValue&#xA;1234.56)                                                                                                                                                                                                                                      | FormatMixin           |
-| `serializedValue`            | public    | `string\|undefined`                       | `undefined`                     | The serialized version of the model value.&#xA;This value exists for maximal compatibility with the platform API.&#xA;The serialized value can be an interface in context where data binding is not&#xA;supported and a serialized string needs to be set.&#xA;&#xA;Examples:&#xA;- For a date input, this would be the iso format of a date, e.g. '1999-01-20'.&#xA;- For a number input this would be the String representation of a float ('1234.56'&#xA;  instead of 1234.56)&#xA;&#xA;When no parser is available, the value is usually the same as the formattedValue&#xA;(being \_inputNode.value) | FormatMixin           |
-| `_isPasting`                 | protected | `boolean`                                 | `false`                         | Whether the user is pasting content. Allows Subclassers to do this in their subclass:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | FormatMixin           |
-| `_isHandlingUserInput`       | protected | `boolean`                                 | `false`                         | Flag that will be set when user interaction takes place (for instance after an 'input'&#xA;event). Will be added as meta info to the \`model-value-changed\` event. Depending on&#xA;whether a user is interacting, formatting logic will be handled differently.                                                                                                                                                                                                                                                                                                                                         | FormatMixin           |
-| `_inputNode`                 | protected | `HTMLInputElement \| HTMLTextAreaElement` |                                 | The interactive (form) element. Can be a native element like input/textarea/select or&#xA;an element with tabindex > -1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | FormControlMixin      |
-| `selectionStart`             | public    | `number`                                  |                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | NativeTextFieldMixin  |
+| `hasFeedbackFor`             | public    | `ValidationType[]`                        | `[]`                            | As soon as validation happens (after modelValue/validators/validator param change), this&#xA;array is updated with the active ValidationTypes ('error'\|'warning'\|'success'\|'info' etc.).&#xA;Notice the difference with \`.showsFeedbackFor\`, which filters \`.hasFeedbackFor\` based on&#xA;\`.feedbackCondition()\`.&#xA;&#xA;For styling purposes, will be reflected to \[has-feedback-for="error warning"]. This can&#xA;be useful for subtle visual feedback on keyup, like a red/green border around an input.                                                                                  | ValidateMixin         |
+| `helpText`                   | public    | `string`                                  | `''`                            | The helpt text for the input node.&#xA;When no value is defined, textContent of \[slot=help-text] will be used                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | FormControlMixin      |
+| `indeterminate`              | public    | `boolean`                                 | `false`                         | Indeterminate state of the checkbox                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |                       |
+| `isPending`                  | public    | `boolean`                                 | `false`                         | Flag indicating whether async validation is pending.&#xA;Creates attribute \[is-pending] as a styling hook                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | ValidateMixin         |
+| `label`                      | public    | `string`                                  | `''`                            | The label text for the input node.&#xA;When no value is defined, textContent of \[slot=label] will be used                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | FormControlMixin      |
+| `labelSrOnly`                | public    | `boolean`                                 | `false`                         | The label will only be visible for srceen readers when true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | FormControlMixin      |
+| `mixedState`                 | public    | `boolean`                                 | `false`                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                       |
+| `modelValue`                 | public    | `{value:string\|any,checked:boolean}`     | `{ value: '', checked: false }` | Whereas 'normal' \`.modelValue\`s usually store a complex/typed version&#xA;of a view value, choice inputs have a slightly different approach.&#xA;In order to remain their Single Source of Truth characteristic, choice inputs&#xA;store both the value and 'checkedness', in the format { value: 'x', checked: true }&#xA;Different from the platform, this also allows to serialize the 'non checkedness',&#xA;allowing to restore form state easily and inform the server about unchecked options.                                                                                                   | FormControlMixin      |
+| `name`                       | public    | `string`                                  | `''`                            | The name the element will be registered with to the .formElements collection&#xA;of the parent. Also, it serves as the key of key/value pairs in&#xA; modelValue/serializedValue objects                                                                                                                                                                                                                                                                                                                                                                                                                  | FormRegisteringMixin  |
+| `operationMode`              | public    | `OperationMode`                           |                                 | Types of input interaction of the FormControl (for instance 'enter'\|'select'\|'upload')                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | ValidateMixin         |
+| `placeholder`                | public    | `string`                                  | `''`                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | LionInput             |
+| `prefilled`                  | public    | `boolean`                                 | `false`                         | True when user has left non-empty field or input is prefilled.&#xA;The name must be seen from the point of view of the input field:&#xA;once the user enters the input field, the value is non-empty.                                                                                                                                                                                                                                                                                                                                                                                                     | InteractionStateMixin |
+| `readOnly`                   | public    | `boolean`                                 | `false`                         | A Boolean attribute which, if present, indicates that the user should not be able to edit&#xA;the value of the input. The difference between disabled and readonly is that read-only&#xA;controls can still function, whereas disabled controls generally do not function as&#xA;controls until they are enabled.&#xA;(From: https\://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#attr-readonly)                                                                                                                                                                                              | FormControlMixin      |
 | `selectionEnd`               | public    | `number`                                  |                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | NativeTextFieldMixin  |
+| `selectionStart`             | public    | `number`                                  |                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | NativeTextFieldMixin  |
+| `serializedValue`            | public    | `string\|undefined`                       | `undefined`                     | The serialized version of the model value.&#xA;This value exists for maximal compatibility with the platform API.&#xA;The serialized value can be an interface in context where data binding is not&#xA;supported and a serialized string needs to be set.&#xA;&#xA;Examples:&#xA;- For a date input, this would be the iso format of a date, e.g. '1999-01-20'.&#xA;- For a number input this would be the String representation of a float ('1234.56'&#xA;  instead of 1234.56)&#xA;&#xA;When no parser is available, the value is usually the same as the formattedValue&#xA;(being \_inputNode.value) | FormatMixin           |
+| `showsFeedbackFor`           | public    | `ValidationType[]`                        | `[]`                            | Based on outcome of feedbackCondition, this array decides what ValidationTypes should be&#xA;shown in validationFeedback, based on meta data like interaction states.&#xA;&#xA;For styling purposes, it reflects it \`\[shows-feedback-for="error warning"]\`                                                                                                                                                                                                                                                                                                                                             | ValidateMixin         |
+| `submitted`                  | public    |                                           |                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | InteractionStateMixin |
+| `touched`                    | public    | `boolean`                                 | `false`                         | True when user has focused and left(blurred) the field.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | InteractionStateMixin |
+| `type`                       | public    | `string`                                  | `'text'`                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | LionInput             |
+| `validationStates`           | public    | `ValidationStates`                        | `{}`                            | The outcome of a validation 'round'. Keyed by ValidationType and Validator name                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | ValidateMixin         |
+| `validators`                 | public    | `Validator[]`                             | `[]`                            | Used by Application Developers to add Validators to a FormControl.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ValidateMixin         |
+| `value`                      | public    |                                           |                                 | The view value. Will be delegated to \`.\_inputNode.value\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | FormatMixin           |
+| `_allValidators`             | protected | `Validator[]`                             |                                 | Combination of validators provided by Application Developer and the default validators                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | ValidateMixin         |
+| `_ariaDescribedNodes`        | public    | `HTMLElement[]`                           | `[]`                            | Contains all elements that should end up in aria-describedby of \`.\_inputNode\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | FormControlMixin      |
+| `_ariaLabelledNodes`         | public    | `HTMLElement[]`                           | `[]`                            | Contains all elements that should end up in aria-labelledby of \`.\_inputNode\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | FormControlMixin      |
+| `_checkboxGroupNode`         | protected |                                           |                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                       |
+| `_feedbackConditionMeta`     | protected |                                           |                                 | Allows Subclassers to add meta info for feedbackCondition                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | LionField             |
+| `_feedbackNode`              | protected |                                           |                                 | Element where validation feedback will be rendered to                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | FormControlMixin      |
 | `_focusableNode`             | protected | `HTMLElement`                             |                                 | The focusable element:&#xA;could be an input, textarea, select, button or any other element with tabindex > -1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | LionField             |
-| `autocomplete`               | public    | `string \| undefined`                     | `undefined`                     | Delegates this property to input/textarea/select.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | NativeTextFieldMixin  |
-| `focused`                    | public    | `boolean`                                 | `false`                         | Whether the focusable element within (\`.\_focusableNode\`) is focused.&#xA;Reflects to attribute '\[focused]' as a styling hook                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | FocusMixin            |
-| `focusedVisible`             | public    | `boolean`                                 | `false`                         | Whether the focusable element within (\`.\_focusableNode\`) matches ':focus-visible'&#xA;Reflects to attribute '\[focused-visible]' as a styling hook&#xA;See: https\://developer.mozilla.org/en-US/docs/Web/CSS/:focus-visible                                                                                                                                                                                                                                                                                                                                                                           | FocusMixin            |
-| `autofocus`                  | public    | `boolean`                                 | `false`                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | FocusMixin            |
-| `label`                      | public    | `string`                                  | `''`                            | The label text for the input node.&#xA;When no value is defined, textContent of \[slot=label] will be used                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | FormControlMixin      |
-| `helpText`                   | public    | `string`                                  | `''`                            | The helpt text for the input node.&#xA;When no value is defined, textContent of \[slot=help-text] will be used                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | FormControlMixin      |
-| `fieldName`                  | public    | `string`                                  |                                 | Will be used in validation messages to refer to the current field                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | FormControlMixin      |
-| `_labelNode`                 | protected |                                           |                                 | Element where label will be rendered to                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | FormControlMixin      |
 | `_helpTextNode`              | protected |                                           |                                 | Element where help text will be rendered to                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | FormControlMixin      |
-| `_feedbackNode`              | protected |                                           |                                 | Element where validation feedback will be rendered to                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | FormControlMixin      |
-| `readOnly`                   | public    | `boolean`                                 | `false`                         | A Boolean attribute which, if present, indicates that the user should not be able to edit&#xA;the value of the input. The difference between disabled and readonly is that read-only&#xA;controls can still function, whereas disabled controls generally do not function as&#xA;controls until they are enabled.&#xA;(From: https\://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#attr-readonly)                                                                                                                                                                                              | FormControlMixin      |
-| `labelSrOnly`                | public    | `boolean`                                 | `false`                         | The label will only be visible for srceen readers when true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | FormControlMixin      |
+| `_indeterminateSubStates`    | protected | `boolean[]`                               | `[]`                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                       |
 | `_inputId`                   | protected | `string`                                  |                                 | Unique id that can be used in all light dom                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | FormControlMixin      |
-| `_ariaLabelledNodes`         | public    | `HTMLElement[]`                           | `[]`                            | Contains all elements that should end up in aria-labelledby of \`.\_inputNode\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | FormControlMixin      |
-| `_ariaDescribedNodes`        | public    | `HTMLElement[]`                           | `[]`                            | Contains all elements that should end up in aria-describedby of \`.\_inputNode\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | FormControlMixin      |
-| `_repropagationRole`         | public    | `'child'\|'choice-group'\|'fieldset'`     | `'child'`                       | Based on the role, details of handling model-value-changed repropagation differ.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | FormControlMixin      |
+| `_inputNode`                 | protected | `HTMLInputElement \| HTMLTextAreaElement` |                                 | The interactive (form) element. Can be a native element like input/textarea/select or&#xA;an element with tabindex > -1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | FormControlMixin      |
+| `_isHandlingUserInput`       | protected | `boolean`                                 | `false`                         | Flag that will be set when user interaction takes place (for instance after an 'input'&#xA;event). Will be added as meta info to the \`model-value-changed\` event. Depending on&#xA;whether a user is interacting, formatting logic will be handled differently.                                                                                                                                                                                                                                                                                                                                         | FormatMixin           |
+| `_isPasting`                 | protected | `boolean`                                 | `false`                         | Whether the user is pasting content. Allows Subclassers to do this in their subclass:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | FormatMixin           |
 | `_isRepropagationEndpoint`   | public    | `boolean`                                 | `false`                         | By default, a field with \_repropagationRole 'choice-group' will act as an&#xA;'endpoint'. This means it will be considered as an individual field: for&#xA;a select, individual options will not be part of the formPath. They&#xA;will.&#xA;Similarly, components that (a11y wise) need to be fieldsets, but 'interaction wise'&#xA;(from Application Developer perspective) need to be more like fields&#xA;(think of an amount-input with a currency select box next to it), can set this&#xA;to true to hide private internals in the formPath.                                                      | FormControlMixin      |
-| `type`                       | public    | `string`                                  | `'text'`                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | LionInput             |
-| `placeholder`                | public    | `string`                                  | `''`                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | LionInput             |
-| `name`                       | public    | `string`                                  | `''`                            | The name the element will be registered with to the .formElements collection&#xA;of the parent. Also, it serves as the key of key/value pairs in&#xA; modelValue/serializedValue objects                                                                                                                                                                                                                                                                                                                                                                                                                  | FormRegisteringMixin  |
+| `_labelNode`                 | protected |                                           |                                 | Element where label will be rendered to                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | FormControlMixin      |
+| `_leaveEvent`                | protected | `string`                                  | `'blur'`                        | The event that triggers the touched state                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | InteractionStateMixin |
 | `_parentFormGroup`           | protected | `FormRegistrarHost \| undefined`          | `undefined`                     | The registrar this FormControl registers to, Usually a descendant of FormGroup or&#xA;ChoiceGroup                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | FormRegisteringMixin  |
-| `allowCrossRootRegistration` | public    | `boolean`                                 | `false`                         | To encourage accessibility best practices, \`form-element-register\` events&#xA;do not pierce through shadow roots. This forces the developer to create form groups and fieldsets that automatically allow the creation of accessible relationships in the same dom tree.&#xA;Use this option if you know what you're doing. It will then be possible to nest FormControls&#xA;inside shadow dom. See https\://lion.js.org/fundamentals/rationales/accessibility/#shadow-roots-and-accessibility                                                                                                          | FormRegisteringMixin  |
+| `_repropagationRole`         | public    | `'child'\|'choice-group'\|'fieldset'`     | `'child'`                       | Based on the role, details of handling model-value-changed repropagation differ.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | FormControlMixin      |
 | `_requestedToBeDisabled`     | protected | `boolean`                                 | `false`                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | DisabledMixin         |
-| `_feedbackConditionMeta`     | protected |                                           |                                 | Allows Subclassers to add meta info for feedbackCondition                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | LionField             |
-| `touched`                    | public    | `boolean`                                 | `false`                         | True when user has focused and left(blurred) the field.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | InteractionStateMixin |
-| `dirty`                      | public    | `boolean`                                 | `false`                         | True when user has changed the value of the field.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | InteractionStateMixin |
-| `prefilled`                  | public    | `boolean`                                 | `false`                         | True when user has left non-empty field or input is prefilled.&#xA;The name must be seen from the point of view of the input field:&#xA;once the user enters the input field, the value is non-empty.                                                                                                                                                                                                                                                                                                                                                                                                     | InteractionStateMixin |
-| `filled`                     | public    | `boolean`                                 | `false`                         | True when the modelValue is non-empty (see \_isEmpty in FormControlMixin)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | InteractionStateMixin |
-| `_leaveEvent`                | protected | `string`                                  | `'blur'`                        | The event that triggers the touched state                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | InteractionStateMixin |
+| `_subCheckboxes`             | protected |                                           |                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                       |
 | `_valueChangedEvent`         | protected | `string`                                  | `'model-value-changed'`         | The event that triggers the dirty state                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | InteractionStateMixin |
-| `submitted`                  | public    |                                           |                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | InteractionStateMixin |
-| `operationMode`              | public    | `OperationMode`                           |                                 | Types of input interaction of the FormControl (for instance 'enter'\|'select'\|'upload')                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | ValidateMixin         |
-| `_allValidators`             | protected | `Validator[]`                             |                                 | Combination of validators provided by Application Developer and the default validators                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | ValidateMixin         |
-| `hasFeedbackFor`             | public    | `ValidationType[]`                        | `[]`                            | As soon as validation happens (after modelValue/validators/validator param change), this&#xA;array is updated with the active ValidationTypes ('error'\|'warning'\|'success'\|'info' etc.).&#xA;Notice the difference with \`.showsFeedbackFor\`, which filters \`.hasFeedbackFor\` based on&#xA;\`.feedbackCondition()\`.&#xA;&#xA;For styling purposes, will be reflected to \[has-feedback-for="error warning"]. This can&#xA;be useful for subtle visual feedback on keyup, like a red/green border around an input.                                                                                  | ValidateMixin         |
-| `showsFeedbackFor`           | public    | `ValidationType[]`                        | `[]`                            | Based on outcome of feedbackCondition, this array decides what ValidationTypes should be&#xA;shown in validationFeedback, based on meta data like interaction states.&#xA;&#xA;For styling purposes, it reflects it \`\[shows-feedback-for="error warning"]\`                                                                                                                                                                                                                                                                                                                                             | ValidateMixin         |
-| `validationStates`           | public    | `ValidationStates`                        | `{}`                            | The outcome of a validation 'round'. Keyed by ValidationType and Validator name                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | ValidateMixin         |
-| `isPending`                  | public    | `boolean`                                 | `false`                         | Flag indicating whether async validation is pending.&#xA;Creates attribute \[is-pending] as a styling hook                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | ValidateMixin         |
-| `validators`                 | public    | `Validator[]`                             | `[]`                            | Used by Application Developers to add Validators to a FormControl.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ValidateMixin         |
-| `defaultValidators`          | public    | `Validator[]`                             | `[]`                            | Used by Subclassers to add default Validators to a particular FormControl.&#xA;A date input for instance, always needs the isDate validator.                                                                                                                                                                                                                                                                                                                                                                                                                                                              | ValidateMixin         |
 | `_visibleMessagesAmount`     | protected | `number`                                  | `1`                             | The amount of feedback messages that will visible in LionValidationFeedback                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | ValidateMixin         |
 
 ### Methods
 
 | Name                                     | Privacy   | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | Parameters                                                                                                     | Return                                                        | Inherited From        |
 | ---------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------- | --------------------- |
-| `_storeIndeterminateState`               | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               |                       |
-| `_setOldState`                           | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               |                       |
-| `_setOwnCheckedState`                    | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               |                       |
-| `_setBasedOnMixedState`                  | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               |                       |
-| `_afterTemplate`                         | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | ChoiceInputMixin      |
-| `_onRequestToAddFormElement`             | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: Event`                                                                                                    |                                                               |                       |
-| `_onRequestToRemoveFormElement`          | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: Event`                                                                                                    |                                                               |                       |
-| `_choiceGraphicTemplate`                 | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | ChoiceInputMixin      |
-| `_preventDuplicateLabelClick`            | protected | The native platform fires an event for both the click on the label, and also&#xA;the redispatched click on the native input element.&#xA;This results in two click events arriving at the host, but we only want one.&#xA;This method prevents the duplicate click and ensures the correct isTrusted event&#xA;with the correct event.target arrives at the host.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `ev: Event`                                                                                                    |                                                               | ChoiceInputMixin      |
-| `_toggleChecked`                         | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: Event`                                                                                                    |                                                               | ChoiceInputMixin      |
-| `_syncNameToParentFormGroup`             | protected | Override this in case of extending ChoiceInputMixin and requiring&#xA;to sync differently with parent form group name&#xA;Right now it checks tag name match where the parent form group tagname&#xA;should include the child field tagname ('checkbox' is included in 'checkbox-group')                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |                                                                                                                |                                                               | ChoiceInputMixin      |
-| `_proxyInputEvent`                       | protected | This can be called whenever the view value should be updated. Dependent on component type&#xA;("input" for \<input> or "change" for \<select>(mainly for IE)) a different event should be&#xA;used  as source for the "user-input-changed" event (which can be seen as an abstraction&#xA;layer on top of other events (input, change, whatever))                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |                                                                                                                |                                                               | FormatMixin           |
-| `_onModelValueChanged`                   | protected | Responds to modelValue changes in the synchronous cycle (most subclassers should listen to&#xA;the asynchronous cycle ('modelValue' in the .updated lifecycle))                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `{ modelValue }, old: { modelValue:unknown }, newV: { modelValue:unknown }`                                    |                                                               | FormatMixin           |
-| `parser`                                 | public    | Converts viewValue to modelValue&#xA;For instance, a localized date to a Date Object                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `v: string, opts: FormatOptions`                                                                               | `*`                                                           | FormatMixin           |
-| `formatter`                              | public    | Converts modelValue to formattedValue (formattedValue will be synced with&#xA;\`.\_inputNode.value\`)&#xA;For instance, a Date object to a localized date.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `modelValue: ChoiceInputModelValue`                                                                            | `string`                                                      | FormatMixin           |
+| `addToAriaDescribedBy`                   | public    | Allows to add element references to aria-describedby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `element: HTMLElement, { idPrefix = '', reorder = true }, customConfig: {idPrefix?:string; reorder?: boolean}` |                                                               | FormControlMixin      |
+| `addToAriaLabelledBy`                    | public    | Allows to add extra element references to aria-labelledby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `element: HTMLElement, { idPrefix = '', reorder = true }, customConfig: {idPrefix?:string; reorder?: boolean}` |                                                               | FormControlMixin      |
+| `blur`                                   | public    | Calls \`blur()\` on focusable element within                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |                                                                                                                |                                                               | FocusMixin            |
 | `clear`                                  | public    | Clears modelValue.&#xA;Interaction states are not cleared (use resetInteractionState for this)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                                                                                                                |                                                               | LionField             |
-| `_isEmpty`                               | protected | Used for required validator.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `modelValue: any`                                                                                              | `boolean`                                                     | FormControlMixin      |
-| `_syncValueUpwards`                      | protected | Synchronization from \`.\_inputNode.value\` to \`LionField\` (flow \[2])&#xA;Downwards syncing should only happen for \`LionField\`.value changes from 'above'.&#xA;This triggers \_onModelValueChanged and connects user input&#xA;to the parsing/formatting/serializing loop.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | FormatMixin           |
+| `click`                                  | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | DisabledMixin         |
+| `deserializer`                           | public    | Converts \`.serializedValue\` to \`.modelValue\`&#xA;For instance, an iso formatted date string to a Date object                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `v: ?`                                                                                                         | `?`                                                           | FormatMixin           |
+| `feedbackCondition`                      | public    | Allows the Application Developer to specify when a feedback message should be shown                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `type: string, meta: object, currentCondition: ((type: string, meta: object) => boolean)`                      | `boolean`                                                     | ValidateMixin         |
+| `focus`                                  | public    | Calls \`focus()\` on focusable element within                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |                                                                                                                |                                                               | FocusMixin            |
+| `formatter`                              | public    | Converts modelValue to formattedValue (formattedValue will be synced with&#xA;\`.\_inputNode.value\`)&#xA;For instance, a Date object to a localized date.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `modelValue: ChoiceInputModelValue`                                                                            | `string`                                                      | FormatMixin           |
+| `initInteractionState`                   | public    | Evaluations performed on connectedCallback.&#xA;This method is public, so it can be called at a later moment (when we need to wait for&#xA;registering children for instance) as well.&#xA;Since this method will be called twice in last mentioned scenario, it must stay idempotent.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                |                                                               | InteractionStateMixin |
+| `makeRequestToBeDisabled`                | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | DisabledMixin         |
+| `parser`                                 | public    | Converts viewValue to modelValue&#xA;For instance, a localized date to a Date Object                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `v: string, opts: FormatOptions`                                                                               | `*`                                                           | FormatMixin           |
 | `preprocessor`                           | public    | Preprocessors could be considered 'live formatters'. Their result is shown to the user&#xA;on keyup instead of after blurring the field. The biggest difference between preprocessors&#xA;and formatters is their moment of execution: preprocessors are run before modelValue is&#xA;computed (and work based on view value), whereas formatters are run after the parser (and&#xA;are based on modelValue)&#xA;Automatically formats code while typing. It depends on a preprocessro that smartly&#xA;updates the viewValue and caret position for best UX.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `v: string, opts: FormatOptions & { prevViewValue: string; currentCaretIndex: number }`                        | `{ viewValue:string; caretIndex:number; }\|string\|undefined` | FormatMixin           |
+| `removeFromAriaDescribedBy`              | public    | Allows to remove element references from aria-describedby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `element: HTMLElement`                                                                                         |                                                               | FormControlMixin      |
+| `removeFromAriaLabelledBy`               | public    | Allows to remove element references from aria-labelledby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `element: HTMLElement`                                                                                         |                                                               | FormControlMixin      |
+| `reset`                                  | public    | Resets modelValue to initial value.&#xA;Interaction states are cleared                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                |                                                               | LionField             |
+| `resetInteractionState`                  | public    | Resets touched and dirty, and recomputes prefilled                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |                                                                                                                |                                                               | LionField             |
+| `retractRequestToBeDisabled`             | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | DisabledMixin         |
 | `serializer`                             | public    | Converts \`.modelValue\` to \`.serializedValue\`&#xA;For instance, a Date object to an iso formatted date string                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `v: ?`                                                                                                         | `string`                                                      | FormatMixin           |
-| `deserializer`                           | public    | Converts \`.serializedValue\` to \`.modelValue\`&#xA;For instance, an iso formatted date string to a Date object                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `v: ?`                                                                                                         | `?`                                                           | FormatMixin           |
+| `validate`                               | public    | Triggered by:&#xA; \- modelValue change&#xA; \- change in the 'validators' array&#xA; \- change in the config of an individual Validator&#xA;&#xA;Three situations are handled:&#xA;- a1) the FormControl is empty: further execution is halted. When the Required Validator&#xA;(being mutually exclusive to the other Validators) is applied, it will end up in the&#xA;validation result (as the only Validator, since further execution was halted).&#xA;- a2) there are synchronous Validators: this is the most common flow. When modelValue hasn't&#xA;changed since last async results were generated, 'sync results' are merged with the&#xA;'async results'.&#xA;- a3) there are asynchronous Validators: for instance when server side evaluation is needed.&#xA;Executions are scheduled and awaited and the 'async results' are merged with the&#xA;'sync results'.&#xA;&#xA;- b) there are MetaValidators. After steps a1, a2, or a3 are finished, the holistic&#xA;MetaValidators (evaluating the total result of the 'regular' (a1, a2 and a3) validators)&#xA;will be run...&#xA;&#xA;Situations a2 and a3 are not mutually exclusive and can be triggered within one \`validate()\`&#xA;call. Situation b will occur after every call. | `{ clearCurrentResult = false }, opts: { clearCurrentResult?: boolean }`                                       |                                                               | ValidateMixin         |
+| `_afterTemplate`                         | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | ChoiceInputMixin      |
 | `_calculateValues`                       | protected | Responsible for storing all representations(modelValue, serializedValue, formattedValue&#xA;and value) of the input value. Prevents infinite loops, so all value observers can be&#xA;treated like they will only be called once, without indirectly calling other observers.&#xA;(in fact, some are called twice, but the \_\_preventRecursiveTrigger lock prevents the&#xA;second call from having effect).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `{ source }, config: {source:'model'\|'serialized'\|'formatted'\|null}`                                        |                                                               | FormatMixin           |
+| `_choiceGraphicTemplate`                 | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | ChoiceInputMixin      |
+| `_dispatchInitialModelValueChangedEvent` | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | FormControlMixin      |
 | `_dispatchModelValueChangedEvent`        | protected | This is wrapped in a distinct method, so that parents can control when the changed event&#xA;is fired. For objects, a deep comparison might be needed.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `args: { modelValue: unknown; }[]`                                                                             |                                                               | FormatMixin           |
-| `_reflectBackFormattedValueToUser`       | protected | Synchronization from \`LionField.value\` to \`.\_inputNode.value\`&#xA;- flow \[1] will always be reflected back&#xA;- flow \[2] will not be reflected back when this flow was triggered via&#xA;  \`@user-input-changed\` (this will happen later, when \`formatOn\` condition is met)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |                                                                                                                |                                                               | FormatMixin           |
-| `_reflectBackOn`                         | protected | Every time .formattedValue is attempted to sync to the view value (on change/blur and on&#xA;modelValue change), this condition is checked. When enhancing it, it's recommended to&#xA;call via \`return this.\_myExtraCondition && super.\_reflectBackOn()\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |                                                                                                                | `boolean`                                                     | FormatMixin           |
-| `_onUserInputChanged`                    | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | FormatMixin           |
-| `__onCompositionEvent`                   | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `{ type }, event: Event`                                                                                       |                                                               | FormatMixin           |
-| `_setValueAndPreserveCaret`              | protected | Restores the cursor to its original position after updating the value.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `newValue: string`                                                                                             |                                                               | NativeTextFieldMixin  |
-| `focus`                                  | public    | Calls \`focus()\` on focusable element within                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |                                                                                                                |                                                               | FocusMixin            |
-| `blur`                                   | public    | Calls \`blur()\` on focusable element within                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |                                                                                                                |                                                               | FocusMixin            |
-| `_triggerInitialModelValueChangedEvent`  | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | FormControlMixin      |
-| `_enhanceLightDomClasses`                | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | FormControlMixin      |
 | `_enhanceLightDomA11y`                   | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | FormControlMixin      |
 | `_enhanceLightDomA11yForAdditionalSlots` | protected | Enhances additional slots(prefix, suffix, before, after) defined by developer.&#xA;&#xA;When boolean attribute data-label or data-description is found,&#xA;the slot element will be connected to the input via aria-labelledby or aria-describedby                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `additionalSlots: string[]`                                                                                    |                                                               | FormControlMixin      |
-| `__reflectAriaAttr`                      | protected | Will handle help text, validation feedback and character counter,&#xA;prefix/suffix/before/after (if they contain data-description flag attr).&#xA;Also, contents of id references that will be put in the \<lion-field>.\_ariaDescribedby property&#xA;from an external context, will be read by a screen reader.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `attrName: string, nodes: Element[], reorder: boolean\|undefined`                                              |                                                               | FormControlMixin      |
+| `_enhanceLightDomClasses`                | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | FormControlMixin      |
+| `_feedbackTemplate`                      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | FormControlMixin      |
+| `_getAriaDescriptionElements`            | protected | This function exposes descripion elements that a FormGroup should expose to its&#xA;children. See FormGroupMixin.\_\_getAllDescriptionElementsInParentChain()                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |                                                                                                                | `Array.<HTMLElement>`                                         | FormControlMixin      |
 | `_groupOneTemplate`                      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | FormControlMixin      |
 | `_groupTwoTemplate`                      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | FormControlMixin      |
-| `_labelTemplate`                         | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | FormControlMixin      |
+| `_hasFeedbackVisibleFor`                 | protected | Used to translate \`.hasFeedbackFor\` and \`.shouldShowFeedbackFor\` to \`.showsFeedbackFor\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `type: string`                                                                                                 |                                                               | ValidateMixin         |
 | `_helpTextTemplate`                      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | FormControlMixin      |
-| `_inputGroupTemplate`                    | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | FormControlMixin      |
+| `_inputGroupAfterTemplate`               | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | FormControlMixin      |
 | `_inputGroupBeforeTemplate`              | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | FormControlMixin      |
-| `_inputGroupPrefixTemplate`              | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult \| nothing`                                   | FormControlMixin      |
 | `_inputGroupInputTemplate`               | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | FormControlMixin      |
+| `_inputGroupPrefixTemplate`              | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult \| nothing`                                   | FormControlMixin      |
 | `_inputGroupSuffixTemplate`              | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult \| nothing`                                   | FormControlMixin      |
-| `_inputGroupAfterTemplate`               | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | FormControlMixin      |
-| `_feedbackTemplate`                      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | FormControlMixin      |
-| `_getAriaDescriptionElements`            | protected | This function exposes descripion elements that a FormGroup should expose to its&#xA;children. See FormGroupMixin.\_\_getAllDescriptionElementsInParentChain()                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |                                                                                                                | `Array.<HTMLElement>`                                         | FormControlMixin      |
-| `addToAriaLabelledBy`                    | public    | Allows to add extra element references to aria-labelledby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `element: HTMLElement, { idPrefix = '', reorder = true }, customConfig: {idPrefix?:string; reorder?: boolean}` |                                                               | FormControlMixin      |
-| `removeFromAriaLabelledBy`               | public    | Allows to remove element references from aria-labelledby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `element: HTMLElement`                                                                                         |                                                               | FormControlMixin      |
-| `addToAriaDescribedBy`                   | public    | Allows to add element references to aria-describedby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `element: HTMLElement, { idPrefix = '', reorder = true }, customConfig: {idPrefix?:string; reorder?: boolean}` |                                                               | FormControlMixin      |
-| `removeFromAriaDescribedBy`              | public    | Allows to remove element references from aria-describedby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `element: HTMLElement`                                                                                         |                                                               | FormControlMixin      |
-| `__getDirectSlotChild`                   | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `slotName: string`                                                                                             | `HTMLElement \| undefined`                                    | FormControlMixin      |
-| `_dispatchInitialModelValueChangedEvent` | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | FormControlMixin      |
-| `_onBeforeRepropagateChildrenValues`     | protected | Hook for Subclassers to add logic before repropagation                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `ev: CustomEvent`                                                                                              |                                                               | FormControlMixin      |
-| `__repropagateChildrenValues`            | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: CustomEvent`                                                                                              |                                                               | FormControlMixin      |
-| `_repropagationCondition`                | protected | Based on provided target, this condition determines whether received model-value-changed&#xA;event should be repropagated                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `target: FormControlHost`                                                                                      |                                                               | FormControlMixin      |
-| `_onLabelClick`                          | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | FormControlMixin      |
-| `makeRequestToBeDisabled`                | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | DisabledMixin         |
-| `retractRequestToBeDisabled`             | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | DisabledMixin         |
-| `click`                                  | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | DisabledMixin         |
-| `initInteractionState`                   | public    | Evaluations performed on connectedCallback.&#xA;This method is public, so it can be called at a later moment (when we need to wait for&#xA;registering children for instance) as well.&#xA;Since this method will be called twice in last mentioned scenario, it must stay idempotent.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                |                                                               | InteractionStateMixin |
+| `_inputGroupTemplate`                    | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | FormControlMixin      |
+| `_isEmpty`                               | protected | Used for required validator.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `modelValue: any`                                                                                              | `boolean`                                                     | FormControlMixin      |
 | `_iStateOnLeave`                         | protected | Sets touched value to true and reevaluates prefilled state.&#xA;When false, on next interaction, user will start with a clean state.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |                                                                                                                |                                                               | InteractionStateMixin |
 | `_iStateOnValueChange`                   | protected | Sets dirty value and validates when already touched or invalid                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                                                                                                                |                                                               | InteractionStateMixin |
-| `resetInteractionState`                  | public    | Resets touched and dirty, and recomputes prefilled                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |                                                                                                                |                                                               | LionField             |
-| `_onTouchedChanged`                      | protected | Dispatches event on touched state change                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |                                                                                                                |                                                               | InteractionStateMixin |
+| `_labelTemplate`                         | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | FormControlMixin      |
+| `_onBeforeRepropagateChildrenValues`     | protected | Hook for Subclassers to add logic before repropagation                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `ev: CustomEvent`                                                                                              |                                                               | FormControlMixin      |
+| `_onChange`                              | protected | Dispatches custom bubble event                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `ev: Event=`                                                                                                   |                                                               | LionField             |
 | `_onDirtyChanged`                        | protected | Dispatches event on touched state change                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |                                                                                                                |                                                               | InteractionStateMixin |
-| `_showFeedbackConditionFor`              | protected | Default feedbackCondition condition, used by Subclassers, that will be used when&#xA;\`feedbackCondition()\` is not overridden by Application Developer.&#xA;Show the validity feedback when returning true, don't show when false                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `type: string, meta: InteractionStates`                                                                        |                                                               | ValidateMixin         |
-| `validate`                               | public    | Triggered by:&#xA; \- modelValue change&#xA; \- change in the 'validators' array&#xA; \- change in the config of an individual Validator&#xA;&#xA;Three situations are handled:&#xA;- a1) the FormControl is empty: further execution is halted. When the Required Validator&#xA;(being mutually exclusive to the other Validators) is applied, it will end up in the&#xA;validation result (as the only Validator, since further execution was halted).&#xA;- a2) there are synchronous Validators: this is the most common flow. When modelValue hasn't&#xA;changed since last async results were generated, 'sync results' are merged with the&#xA;'async results'.&#xA;- a3) there are asynchronous Validators: for instance when server side evaluation is needed.&#xA;Executions are scheduled and awaited and the 'async results' are merged with the&#xA;'sync results'.&#xA;&#xA;- b) there are MetaValidators. After steps a1, a2, or a3 are finished, the holistic&#xA;MetaValidators (evaluating the total result of the 'regular' (a1, a2 and a3) validators)&#xA;will be run...&#xA;&#xA;Situations a2 and a3 are not mutually exclusive and can be triggered within one \`validate()\`&#xA;call. Situation b will occur after every call. | `{ clearCurrentResult = false }, opts: { clearCurrentResult?: boolean }`                                       |                                                               | ValidateMixin         |
-| `__executeValidators`                    | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | ValidateMixin         |
+| `_onLabelClick`                          | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | FormControlMixin      |
+| `_onModelValueChanged`                   | protected | Responds to modelValue changes in the synchronous cycle (most subclassers should listen to&#xA;the asynchronous cycle ('modelValue' in the .updated lifecycle))                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `{ modelValue }, old: { modelValue:unknown }, newV: { modelValue:unknown }`                                    |                                                               | FormatMixin           |
+| `_onRequestToAddFormElement`             | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: Event`                                                                                                    |                                                               |                       |
+| `_onRequestToRemoveFormElement`          | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: Event`                                                                                                    |                                                               |                       |
+| `_onTouchedChanged`                      | protected | Dispatches event on touched state change                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |                                                                                                                |                                                               | InteractionStateMixin |
+| `_onUserInputChanged`                    | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | FormatMixin           |
 | `_onValidatorUpdated`                    | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `e: Event\|CustomEvent`                                                                                        |                                                               | ValidateMixin         |
+| `_preventDuplicateLabelClick`            | protected | The native platform fires an event for both the click on the label, and also&#xA;the redispatched click on the native input element.&#xA;This results in two click events arriving at the host, but we only want one.&#xA;This method prevents the duplicate click and ensures the correct isTrusted event&#xA;with the correct event.target arrives at the host.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `ev: Event`                                                                                                    |                                                               | ChoiceInputMixin      |
+| `_prioritizeAndFilterFeedback`           | protected | Orders all active validators in this.\_\_validationResult.&#xA;Can also filter out occurrences (based on interaction states)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `{ validationResult }, opts: { validationResult: Validator[] }`                                                | `Validator[]`                                                 | ValidateMixin         |
+| `_proxyInputEvent`                       | protected | This can be called whenever the view value should be updated. Dependent on component type&#xA;("input" for \<input> or "change" for \<select>(mainly for IE)) a different event should be&#xA;used  as source for the "user-input-changed" event (which can be seen as an abstraction&#xA;layer on top of other events (input, change, whatever))                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |                                                                                                                |                                                               | FormatMixin           |
+| `_reflectBackFormattedValueToUser`       | protected | Synchronization from \`LionField.value\` to \`.\_inputNode.value\`&#xA;- flow \[1] will always be reflected back&#xA;- flow \[2] will not be reflected back when this flow was triggered via&#xA;  \`@user-input-changed\` (this will happen later, when \`formatOn\` condition is met)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |                                                                                                                |                                                               | FormatMixin           |
+| `_reflectBackOn`                         | protected | Every time .formattedValue is attempted to sync to the view value (on change/blur and on&#xA;modelValue change), this condition is checked. When enhancing it, it's recommended to&#xA;call via \`return this.\_myExtraCondition && super.\_reflectBackOn()\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |                                                                                                                | `boolean`                                                     | FormatMixin           |
+| `_repropagationCondition`                | protected | Based on provided target, this condition determines whether received model-value-changed&#xA;event should be repropagated                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `target: FormControlHost`                                                                                      |                                                               | FormControlMixin      |
+| `_setBasedOnMixedState`                  | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               |                       |
+| `_setOldState`                           | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               |                       |
+| `_setOwnCheckedState`                    | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               |                       |
+| `_setValueAndPreserveCaret`              | protected | Restores the cursor to its original position after updating the value.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `newValue: string`                                                                                             |                                                               | NativeTextFieldMixin  |
+| `_showFeedbackConditionFor`              | protected | Default feedbackCondition condition, used by Subclassers, that will be used when&#xA;\`feedbackCondition()\` is not overridden by Application Developer.&#xA;Show the validity feedback when returning true, don't show when false                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `type: string, meta: InteractionStates`                                                                        |                                                               | ValidateMixin         |
+| `_storeIndeterminateState`               | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               |                       |
+| `_syncNameToParentFormGroup`             | protected | Override this in case of extending ChoiceInputMixin and requiring&#xA;to sync differently with parent form group name&#xA;Right now it checks tag name match where the parent form group tagname&#xA;should include the child field tagname ('checkbox' is included in 'checkbox-group')                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |                                                                                                                |                                                               | ChoiceInputMixin      |
+| `_syncValueUpwards`                      | protected | Synchronization from \`.\_inputNode.value\` to \`LionField\` (flow \[2])&#xA;Downwards syncing should only happen for \`LionField\`.value changes from 'above'.&#xA;This triggers \_onModelValueChanged and connects user input&#xA;to the parsing/formatting/serializing loop.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | FormatMixin           |
+| `_toggleChecked`                         | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: Event`                                                                                                    |                                                               | ChoiceInputMixin      |
+| `_triggerInitialModelValueChangedEvent`  | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | FormControlMixin      |
 | `_updateFeedbackComponent`               | protected | Responsible for retrieving messages from Validators and&#xA;(delegation of) rendering them.&#xA;&#xA;For \`.\_feedbackNode\` (extension of LionValidationFeedback):&#xA;- retrieve messages from highest prio Validators&#xA;- provide the result to custom feedback node and let the&#xA;custom node decide on their renderings&#xA;&#xA;In both cases:&#xA;- we compute the 'show' flag (like 'hasErrorVisible') for all types&#xA;- we set the customValidity message of the highest prio Validator&#xA;- we set aria-invalid="true" in case hasErrorVisible is true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |                                                                                                                |                                                               | ValidateMixin         |
-| `feedbackCondition`                      | public    | Allows the Application Developer to specify when a feedback message should be shown                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `type: string, meta: object, currentCondition: ((type: string, meta: object) => boolean)`                      | `boolean`                                                     | ValidateMixin         |
-| `_hasFeedbackVisibleFor`                 | protected | Used to translate \`.hasFeedbackFor\` and \`.shouldShowFeedbackFor\` to \`.showsFeedbackFor\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `type: string`                                                                                                 |                                                               | ValidateMixin         |
 | `_updateShouldShowFeedbackFor`           | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | ValidateMixin         |
-| `_prioritizeAndFilterFeedback`           | protected | Orders all active validators in this.\_\_validationResult.&#xA;Can also filter out occurrences (based on interaction states)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `{ validationResult }, opts: { validationResult: Validator[] }`                                                | `Validator[]`                                                 | ValidateMixin         |
-| `reset`                                  | public    | Resets modelValue to initial value.&#xA;Interaction states are cleared                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                |                                                               | LionField             |
-| `_onChange`                              | protected | Dispatches custom bubble event                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `ev: Event=`                                                                                                   |                                                               | LionField             |
 
 ### Events