@lion/ui 0.7.3 → 0.7.5

package/docs/components/combobox/overview.md

@@ -34,7 +34,7 @@ export const main = () => html`
 `;
 ```
 
-[...show more](https://github.com/ing-bank/lion/blob/3829e2dce5fce180672f666257d10513da30e1d5/docs/components/combobox/extensions.md)
+[...show more](https://github.com/ing-bank/lion/blob/b15d2aae1a8d40d3551822279e1a650633dba428/docs/components/combobox/extensions.md)
 
 ## Features
 

package/docs/components/combobox/use-cases.md

@@ -458,4 +458,4 @@ export const complexObjectChoiceValue = () =>
 ## Listbox compatibility
 
 All configurations that can be applied to `lion-listbox`, can be applied to `lion-combobox` as well.
-See the [listbox documentation](https://github.com/ing-bank/lion/blob/3829e2dce5fce180672f666257d10513da30e1d5/docs/components/listbox/overview.md) for more information.
+See the [listbox documentation](https://github.com/ing-bank/lion/blob/b15d2aae1a8d40d3551822279e1a650633dba428/docs/components/listbox/overview.md) for more information.

package/docs/components/dialog/api-table.md

@@ -0,0 +1,45 @@
+# Dialog >> API Table ||90 
+
+## class: `LionDialog`, `lion-dialog`
+
+### Fields
+
+| Name                         | Privacy   | Type                     | Default | Description                                                                                                                                                           | Inherited From |
+| ---------------------------- | --------- | ------------------------ | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------- |
+| `config`                     | public    | `Partial<OverlayConfig>` | `{}`    | Configure the many options of the \`OverlayController\`                                                                                                               | OverlayMixin   |
+| `_overlayInvokerNode`        | protected |                          |         |                                                                                                                                                                       | OverlayMixin   |
+| `_overlayReferenceNode`      | protected |                          |         |                                                                                                                                                                       | OverlayMixin   |
+| `_overlayBackdropNode`       | protected |                          |         |                                                                                                                                                                       | OverlayMixin   |
+| `_overlayContentNode`        | protected |                          |         |                                                                                                                                                                       | OverlayMixin   |
+| `_overlayContentWrapperNode` | protected |                          |         |                                                                                                                                                                       | OverlayMixin   |
+| `opened`                     | public    | `boolean`                | `false` | If you add the opened attribute a dialog will be opened on page load. The invoker can be left out&#xA;in case the user does not need to be able to reopen the dialog. | OverlayMixin   |
+
+### Methods
+
+| Name                               | Privacy   | Description                                                                                                                                                                                                                                                                                                                | Parameters                                                                                                   | Return              | Inherited From |
+| ---------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------ | ------------------- | -------------- |
+| `_defineOverlayConfig`             | protected |                                                                                                                                                                                                                                                                                                                            |                                                                                                              | `OverlayConfig`     | OverlayMixin   |
+| `_defineOverlay`                   | protected |                                                                                                                                                                                                                                                                                                                            | `{ contentNode, invokerNode, referenceNode, backdropNode, contentWrapperNode }, config: DefineOverlayConfig` | `OverlayController` | OverlayMixin   |
+| `_setupOpenCloseListeners`         | protected |                                                                                                                                                                                                                                                                                                                            |                                                                                                              |                     | OverlayMixin   |
+| `_teardownOpenCloseListeners`      | protected |                                                                                                                                                                                                                                                                                                                            |                                                                                                              |                     | OverlayMixin   |
+| `_setupOverlayCtrl`                | protected |                                                                                                                                                                                                                                                                                                                            |                                                                                                              |                     | OverlayMixin   |
+| `_teardownOverlayCtrl`             | protected |                                                                                                                                                                                                                                                                                                                            |                                                                                                              |                     | OverlayMixin   |
+| `_setOpenedWithoutPropertyEffects` | protected | When the opened state is changed by an Application Developer,cthe OverlayController is&#xA;requested to show/hide. It might happen that this request is not honoured&#xA;(intercepted in before-hide for instance), so that we need to sync the controller state&#xA;to this webcomponent again, preventing eternal loops. | `newOpened: boolean`                                                                                         |                     | OverlayMixin   |
+| `toggle`                           | public    | Toggles the overlay                                                                                                                                                                                                                                                                                                        |                                                                                                              |                     | OverlayMixin   |
+| `open`                             | public    | Shows the overlay                                                                                                                                                                                                                                                                                                          |                                                                                                              |                     | OverlayMixin   |
+| `close`                            | public    | Hides the overlay                                                                                                                                                                                                                                                                                                          |                                                                                                              |                     | OverlayMixin   |
+| `repositionOverlay`                | public    | Sometimes it's needed to recompute Popper position of an overlay, for instance when we have&#xA;an opened combobox and the surrounding context changes (the space consumed by the textbox&#xA;increases vertically)                                                                                                        |                                                                                                              |                     | OverlayMixin   |
+
+### Events
+
+| Name             | Type    | Description | Inherited From |
+| ---------------- | ------- | ----------- | -------------- |
+| `opened-changed` | `Event` |             | OverlayMixin   |
+
+### Attributes
+
+| Name     | Field  | Inherited From |
+| -------- | ------ | -------------- |
+| `opened` | opened | OverlayMixin   |
+
+<hr/>

package/docs/components/dialog/overview.md

@@ -54,6 +54,6 @@ import '@lion/ui/define/lion-dialog.js';
 ## Changing the configuration
 
 You can use the `.config` property on the dialog to change the configuration.
-The documentation of the full config object can be found in the `overlays` folder or here in [Overlay System - Configuration](https://github.com/ing-bank/lion/blob/3829e2dce5fce180672f666257d10513da30e1d5/docs/fundamentals/systems/overlays/configuration.md).
+The documentation of the full config object can be found in the `overlays` folder or here in [Overlay System - Configuration](https://github.com/ing-bank/lion/blob/b15d2aae1a8d40d3551822279e1a650633dba428/docs/fundamentals/systems/overlays/configuration.md).
 
 The `config` property uses a setter to merge the passed configuration with the current, so you only **overwrite what you pass** when updating `config`.

package/docs/components/drawer/api-table.md

@@ -0,0 +1,45 @@
+# Drawer >> API Table ||90 
+
+## class: `LionDrawer`, `lion-drawer`
+
+### Fields
+
+| Name             | Privacy   | Type      | Default | Description                                                                  | Inherited From  |
+| ---------------- | --------- | --------- | ------- | ---------------------------------------------------------------------------- | --------------- |
+| `position`       | public    | `string`  |         | Setter for position property, available values are 'top', 'left' and 'right' |                 |
+| `_contentWidth`  | protected |           |         |                                                                              |                 |
+| `_contentHeight` | protected |           |         |                                                                              | LionCollapsible |
+| `transitioning`  | public    | `boolean` |         |                                                                              |                 |
+| `opened`         | public    | `boolean` | `false` |                                                                              | LionCollapsible |
+| `_invokerNode`   | protected |           |         |                                                                              | LionCollapsible |
+| `_contentNode`   | protected |           |         |                                                                              | LionCollapsible |
+
+### Methods
+
+| Name                 | Privacy   | Description                                                    | Parameters                                                                 | Return          | Inherited From  |
+| -------------------- | --------- | -------------------------------------------------------------- | -------------------------------------------------------------------------- | --------------- | --------------- |
+| `__setBoundaries`    | protected |                                                                |                                                                            |                 |                 |
+| `_showAnimation`     | protected | Trigger show animation and wait for transition to be finished. | `{ contentNode }, options: @param {HTMLElement} options.contentNode    * ` |                 | LionCollapsible |
+| `_hideAnimation`     | protected | Trigger hide animation and wait for transition to be finished. | `{ contentNode }, options: @param {HTMLElement} options.contentNode    * ` |                 | LionCollapsible |
+| `_waitForTransition` | protected | Wait until the transition event is finished.                   | `{ contentNode }, options: @param {HTMLElement} options.contentNode    * ` | `Promise<void>` |                 |
+| `_openedChanged`     | protected |                                                                |                                                                            |                 |                 |
+| `_updateContentSize` | protected |                                                                |                                                                            |                 |                 |
+| `show`               | public    | Show extra content.                                            |                                                                            |                 | LionCollapsible |
+| `hide`               | public    | Hide extra content.                                            |                                                                            |                 | LionCollapsible |
+| `toggle`             | public    | Toggle the current(opened/closed) state.                       |                                                                            |                 | LionCollapsible |
+
+### Events
+
+| Name             | Type          | Description | Inherited From  |
+| ---------------- | ------------- | ----------- | --------------- |
+| `opened-changed` | `CustomEvent` |             | LionCollapsible |
+
+### Attributes
+
+| Name            | Field         | Inherited From  |
+| --------------- | ------------- | --------------- |
+| `transitioning` | transitioning |                 |
+| `opened`        | opened        | LionCollapsible |
+| `position`      | position      |                 |
+
+<hr/>

package/docs/components/fieldset/api-table.md

@@ -0,0 +1,163 @@
+# Fieldset >> API Table ||90 
+
+## class: `LionFieldset`, `lion-fieldset`
+
+### Fields
+
+| Name                                 | Privacy   | Type                                                                      | Default                                                                                                                                                 | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | Inherited From     |
+| ------------------------------------ | --------- | ------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------ |
+| `_isFormOrFieldset`                  | protected | `boolean`                                                                 | `true`                                                                                                                                                  | Flag that determines how ".formElements" should behave.
For a regular fieldset (see LionFieldset) we expect ".formElements"
to be accessible as an object.
In case of a radio-group, a checkbox-group or a select/listbox,
it should act like an array (see ChoiceGroupMixin).
Usually, when false, we deal with a choice-group (radio-group, checkbox-group,
(multi)select)                                                                                                                                                 | FormRegistrarMixin |
+| `_repropagationRole`                 | public    | `'child'\|'choice-group'\|'fieldset'`                                     | `'fieldset'`                                                                                                                                            | Based on the role, details of handling model-value-changed repropagation differ.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | FormControlMixin   |
+| `_inputNode`                         | protected |                                                                           |                                                                                                                                                         | The host element with role group (or radio-group or form) containing necessary aria attributes                                                                                                                                                                                                                                                                                                                                                                                                                                                       | FormControlMixin   |
+| `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     |
+| `prefilled`                          | public    | `boolean`                                                                 |                                                                                                                                                         | True when all of the children are prefilled (see InteractionStateMixin for more details.)                                                                                                                                                                                                                                                                                                                                                                                                                                                            | FormGroupMixin     |
+| `_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      |
+| `submitted`                          | public    | `boolean`                                                                 | `false`                                                                                                                                                 | True when parent form is submitted                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | FormGroupMixin     |
+| `dirty`                              | public    | `boolean`                                                                 | `false`                                                                                                                                                 | True when any of the children is dirty (see InteractionStateMixin for more details.)                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | FormGroupMixin     |
+| `touched`                            | public    | `boolean`                                                                 | `false`                                                                                                                                                 | True when the group as a whole is blurred (see InteractionStateMixin for more details.)                                                                                                                                                                                                                                                                                                                                                                                                                                                              | FormGroupMixin     |
+| `focused`                            | public    | `boolean`                                                                 | `false`                                                                                                                                                 | True when any of the children is focused.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | FormGroupMixin     |
+| `defaultValidators`                  | public    | `Validator[]`                                                             | `[new FormElementsHaveNoError()]`                                                                                                                       | Used by Subclassers to add default Validators to a particular FormControl.
A date input for instance, always needs the isDate validator.                                                                                                                                                                                                                                                                                                                                                                                                         | ValidateMixin      |
+| `__descriptionElementsInParentChain` | protected |                                                                           | `new Set()`                                                                                                                                             |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | FormGroupMixin     |
+| `__pendingValues`                    | protected | `{modelValue?:{[key:string]: any}, serializedValue?:{[key:string]: any}}` | `{ modelValue: {}, serializedValue: {} }`                                                                                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | FormGroupMixin     |
+| `formElements`                       | public    | `FormControlsCollection`                                                  | `new FormControlsCollection()`                                                                                                                          | Closely mimics the natively supported HTMLFormControlsCollection. It can be accessed
both like an array and an object (based on control/element names).                                                                                                                                                                                                                                                                                                                                                                                          | 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 |
+| `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   |
+| `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      |
+| `_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      |
+| `_visibleMessagesAmount`             | protected | `number`                                                                  | `1`                                                                                                                                                     | The amount of feedback messages that will visible in LionValidationFeedback                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | ValidateMixin      |
+| `_requestedToBeDisabled`             | protected | `boolean`                                                                 | `false`                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | DisabledMixin      |
+
+### Methods
+
+| Name                                         | Privacy   | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | Parameters                                                                                                     | Return                      | Inherited From     |
+| -------------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- | --------------------------- | ------------------ |
+| `__initInteractionStates`                    | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | FormGroupMixin     |
+| `_triggerInitialModelValueChangedEvent`      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | FormControlMixin   |
+| `__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     |
+| `resetInteractionState`                      | public    | Resets all interaction states for all formElements                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |                                                                                                                |                             | 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     |
+| `_getFromAllFormElements`                    | protected | Gets a keyed be name object for requested property (like modelValue/serializedValue)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `property: string, filterFn: (el: FormControl, property?: string) => boolean`                                  | `{[name:string]: any}`      | 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     |
+| `addFormElement`                             | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `child: FormControl & {serializedValue:string\|object}, indexToInsertAt: number`                               |                             | FormRegistrarMixin |
+| `removeFormElement`                          | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `el: FormRegisteringHost & FormControl`                                                                        |                             | FormRegistrarMixin |
+| `_isEmpty`                                   | protected | Used for Required validation and computation of interaction states                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `modelValue: any`                                                                                              | `boolean`                   | FormControlMixin   |
+| `_completeRegistration`                      | protected | Resolves the registrationComplete promise. Subclassers can delay if needed                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |                                                                                                                |                             | FormRegistrarMixin |
+| `isRegisteredFormElement`                    | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `el: ElementWithParentFormGroup`                                                                               |                             | 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 |
+| `_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   |
+| `_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   |
+| `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      |
+| `makeRequestToBeDisabled`                    | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | DisabledMixin      |
+| `retractRequestToBeDisabled`                 | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | DisabledMixin      |
+
+### Events
+
+| Name                           | Type          | Description                                              | Inherited From   |
+| ------------------------------ | ------------- | -------------------------------------------------------- | ---------------- |
+| `form-element-name-changed`    | `CustomEvent` |                                                          | FormControlMixin |
+| `model-value-changed`          | `CustomEvent` |                                                          | FormControlMixin |
+| `showsFeedbackForChanged`      | `Event`       |                                                          | ValidateMixin    |
+|                                | `Event`       |                                                          | ValidateMixin    |
+| `shouldShowFeedbackForChanged` | `Event`       |                                                          | ValidateMixin    |
+| `validate-performed`           | `Event`       | private event that should be listened to by LionFieldSet | ValidateMixin    |
+
+### Attributes
+
+| Name                 | Field              | Inherited From     |
+| -------------------- | ------------------ | ------------------ |
+| `submitted`          | submitted          | FormGroupMixin     |
+| `focused`            | focused            | FormGroupMixin     |
+| `dirty`              | dirty              | FormGroupMixin     |
+| `touched`            | touched            | FormGroupMixin     |
+| `prefilled`          | prefilled          | FormGroupMixin     |
+| `_isFormOrFieldset`  | \_isFormOrFieldset | FormRegistrarMixin |
+| `readonly`           | readOnly           | FormControlMixin   |
+| `label`              | label              | FormControlMixin   |
+| `label-sr-only`      | labelSrOnly        | FormControlMixin   |
+| `help-text`          | helpText           | FormControlMixin   |
+| `shows-feedback-for` | showsFeedbackFor   | ValidateMixin      |
+| `is-pending`         | isPending          | ValidateMixin      |
+| `disabled`           | disabled           | DisabledMixin      |
+
+<hr/>