@lion/ui 0.21.0 → 0.21.1-menu-system.0

package/docs/components/input-file/api-table.md

@@ -37,204 +37,78 @@ eleventyNavigation:
 
 ### Fields
 
-| Name                         | Privacy   | Type                                  | Default                 | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | Inherited From |
-| ---------------------------- | --------- | ------------------------------------- | ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------- |
-| `accept`                     | public    | `string`                              | `''`                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                |
-| `allowCrossRootRegistration` | public    | `boolean`                             | `false`                 | To encourage accessibility best practices, \`form-element-register\` events
do not pierce through shadow roots. This forces the developer to create form groups and fieldsets that automatically allow the creation of accessible relationships in the same dom tree.
Use this option if you know what you're doing. It will then be possible to nest FormControls
inside shadow dom. See https\://lion.js.org/fundamentals/rationales/accessibility/#shadow-roots-and-accessibility                                                                                                          | LionField      |
-| `autofocus`                  | public    | `boolean`                             | `false`                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | LionField      |
-| `buttonLabel`                | public    | `string`                              | `''`                    | The label of the button                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                |
-| `defaultValidators`          | public    | `Validator[]`                         | `[]`                    | Used by Subclassers to add default Validators to a particular FormControl.
A date input for instance, always needs the isDate validator.                                                                                                                                                                                                                                                                                                                                                                                                                                                              | LionField      |
-| `dirty`                      | public    | `boolean`                             | `false`                 | True when user has changed the value of the field.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | LionField      |
-| `disabled`                   | public    | `boolean`                             | `false`                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | LionField      |
-| `enableDropZone`             | public    | `boolean`                             | `false`                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                |
-| `fieldName`                  | public    | `string`                              |                         | Will be used in validation messages to refer to the current field                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | LionField      |
-| `filled`                     | public    | `boolean`                             | `false`                 | True when the modelValue is non-empty (see \_isEmpty in FormControlMixin)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | LionField      |
-| `focused`                    | public    | `boolean`                             | `false`                 | Whether the focusable element within (\`.\_focusableNode\`) is focused.
Reflects to attribute '\[focused]' as a styling hook                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | LionField      |
-| `focusedVisible`             | public    | `boolean`                             | `false`                 | Whether the focusable element within (\`.\_focusableNode\`) matches ':focus-visible'
Reflects to attribute '\[focused-visible]' as a styling hook
See: https\://developer.mozilla.org/en-US/docs/Web/CSS/:focus-visible                                                                                                                                                                                                                                                                                                                                                                           | LionField      |
-| `formatOn`                   | protected | `string`                              | `'change'`              | Event that will trigger formatting (more precise, visual update of the view, so the
user sees the formatted value)
Default: 'change'                                                                                                                                                                                                                                                                                                                                                                                                                                                              | LionField      |
-| `formatOptions`              | public    |                                       | `({ mode: 'auto' })`    | Configuration object that will be available inside the formatter function                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | LionField      |
-| `formattedValue`             | public    | `string\|undefined`                   | `undefined`             | The view value is the result of the formatter function (when available).
The result will be stored in the native \_inputNode (usually an input\[type=text]).

Examples:
- For a date input, this would be '20/01/1999' (dependent on locale).
- For a number input, this could be '1,234.56' (a String representation of modelValue
1234.56)                                                                                                                                                                                                                                      | LionField      |
-| `hasFeedbackFor`             | public    | `ValidationType[]`                    | `[]`                    | As soon as validation happens (after modelValue/validators/validator param change), this
array is updated with the active ValidationTypes ('error'\|'warning'\|'success'\|'info' etc.).
Notice the difference with \`.showsFeedbackFor\`, which filters \`.hasFeedbackFor\` based on
\`.feedbackCondition()\`.

For styling purposes, will be reflected to \[has-feedback-for="error warning"]. This can
be useful for subtle visual feedback on keyup, like a red/green border around an input.                                                                                  | LionField      |
-| `helpText`                   | public    | `string`                              |                         | The helpt text for the input node.
When no light dom defined via \[slot=help-text], this value will be used                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | LionField      |
-| `isDragging`                 | public    | `boolean`                             |                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                |
-| `isPending`                  | public    | `boolean`                             | `false`                 | Flag indicating whether async validation is pending.
Creates attribute \[is-pending] as a styling hook                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | LionField      |
-| `label`                      | public    | `string`                              |                         | The label text for the input node.
When no light dom defined via \[slot=label], this value will be used.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | LionField      |
-| `labelSrOnly`                | public    | `boolean`                             | `false`                 | The label will only be visible for srceen readers when true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | LionField      |
-| `maxFileSize`                | public    | `number`                              | `MAX_FILE_SIZE`         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                |
-| `modelValue`                 | public    | `InputFile[]`                         | `[]`                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | LionField      |
-| `multiple`                   | public    | `boolean`                             | `false`                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                |
-| `name`                       | public    | `string`                              | `''`                    | The name the element will be registered with to the .formElements collection
of the parent. Also, it serves as the key of key/value pairs in
 modelValue/serializedValue objects                                                                                                                                                                                                                                                                                                                                                                                                                  | LionField      |
-| `operationMode`              | public    | `OperationMode`                       |                         | Types of input interaction of the FormControl (for instance 'enter'\|'select'\|'upload')                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | LionField      |
-| `prefilled`                  | public    | `boolean`                             | `false`                 | True when user has left non-empty field or input is prefilled.
The name must be seen from the point of view of the input field:
once the user enters the input field, the value is non-empty.                                                                                                                                                                                                                                                                                                                                                                                                     | LionField      |
-| `readOnly`                   | public    | `boolean`                             | `false`                 | A Boolean attribute which, if present, indicates that the user should not be able to edit
the value of the input. The difference between disabled and readonly is that read-only
controls can still function, whereas disabled controls generally do not function as
controls until they are enabled.
(From: https\://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#attr-readonly)                                                                                                                                                                                              | LionField      |
-| `serializedValue`            | public    | `string\|undefined`                   | `undefined`             | The serialized version of the model value.
This value exists for maximal compatibility with the platform API.
The serialized value can be an interface in context where data binding is not
supported and a serialized string needs to be set.

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

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

For styling purposes, it reflects it \`\[shows-feedback-for="error warning"]\`                                                                                                                                                                                                                                                                                                                                             | LionField      |
-| `slots`                      | public    |                                       |                         | Adds ".\_feedbackNode" as described below                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | LionField      |
-| `submitted`                  | public    |                                       |                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | LionField      |
-| `touched`                    | public    | `boolean`                             | `false`                 | True when user has focused and left(blurred) the field.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | LionField      |
-| `type`                       | public    | `string`                              | `'file'`                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                |
-| `uploadOnSelect`             | public    | `boolean`                             | `false`                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                |
-| `uploadResponse`             | public    | `UploadResponse[]`                    | `[]`                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                |
-| `validationStates`           | public    | `ValidationStates`                    | `{}`                    | The outcome of a validation 'round'. Keyed by ValidationType and Validator name                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | LionField      |
-| `validators`                 | public    | `Validator[]`                         | `[]`                    | Used by Application Developers to add Validators to a FormControl.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | LionField      |
-| `value`                      | public    |                                       |                         | The view value. Will be delegated to \`.\_inputNode.value\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | LionField      |
-| `_acceptCriteria`            | protected |                                       |                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                |
-| `_allValidators`             | protected | `(Validator \| MetaValidator)[]`      |                         | Combination of validators provided by Application Developer and the default validators                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | LionField      |
-| `_ariaDescribedNodes`        | public    | `HTMLElement[]`                       | `[]`                    | Contains all elements that should end up in aria-describedby of \`.\_inputNode\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | LionField      |
-| `_ariaLabelledNodes`         | public    | `HTMLElement[]`                       | `[]`                    | Contains all elements that should end up in aria-labelledby of \`.\_inputNode\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | LionField      |
-| `_buttonNode`                | protected |                                       |                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                |
-| `_feedbackConditionMeta`     | protected |                                       |                         | Allows Subclassers to add meta info for feedbackCondition                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | LionField      |
-| `_feedbackNode`              | protected |                                       |                         | Element where validation feedback will be rendered to                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | LionField      |
-| `_fileListNode`              | protected | `LionSelectedFileList`                |                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                |
-| `_focusableNode`             | protected | `HTMLElement`                         |                         | The focusable element:
could be an input, textarea, select, button or any other element with tabindex > -1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | LionField      |
-| `_helpTextNode`              | protected |                                       |                         | Element where help text will be rendered to                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | LionField      |
-| `_initialButtonLabel`        | protected | `string`                              | `''`                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                |
-| `_inputId`                   | protected | `string`                              |                         | Unique id that can be used in all light dom                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | LionField      |
-| `_inputNode`                 | protected | `HTMLInputElement`                    |                         | The interactive (form) element. Can be a native element like input/textarea/select or
an element with tabindex > -1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | LionField      |
-| `_isDragAndDropSupported`    | protected |                                       |                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                |
-| `_isEditingTextField`        | protected |                                       |                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | LionField      |
-| `_isHandlingUserInput`       | protected | `boolean`                             | `false`                 | Flag that will be set when user interaction takes place (for instance after an 'input'
event). Will be added as meta info to the \`model-value-changed\` event. Depending on
whether a user is interacting, formatting logic will be handled differently.                                                                                                                                                                                                                                                                                                                                         | LionField      |
-| `_isPasting`                 | protected | `boolean`                             | `false`                 | Whether the user is pasting content. Allows Subclassers to do this in their subclass:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | LionField      |
-| `_isRepropagationEndpoint`   | public    | `boolean`                             | `false`                 | By default, a field with \_repropagationRole 'choice-group' will act as an
'endpoint'. This means it will be considered as an individual field: for
a select, individual options will not be part of the formPath. They
will.
Similarly, components that (a11y wise) need to be fieldsets, but 'interaction wise'
(from Application Developer perspective) need to be more like fields
(think of an amount-input with a currency select box next to it), can set this
to true to hide private internals in the formPath.                                                      | LionField      |
-| `_labelNode`                 | protected |                                       |                         | Element where label will be rendered to                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | LionField      |
-| `_leaveEvent`                | protected | `string`                              | `'blur'`                | The event that triggers the touched state                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | LionField      |
-| `_parentFormGroup`           | protected | `FormRegistrarHost \| undefined`      | `undefined`             | The registrar this FormControl registers to, Usually a descendant of FormGroup or
ChoiceGroup                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | LionField      |
-| `_repropagationRole`         | public    | `'child'\|'choice-group'\|'fieldset'` | `'child'`               | Based on the role, details of handling model-value-changed repropagation differ.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | LionField      |
-| `_requestedToBeDisabled`     | protected | `boolean`                             | `false`                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | LionField      |
-| `_selectedFilesMetaData`     | protected | `InputFile[]`                         | `[]`                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                |
-| `_valueChangedEvent`         | protected | `string`                              | `'model-value-changed'` | The event that triggers the dirty state                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | LionField      |
-| `_visibleMessagesAmount`     | protected | `number`                              | `1`                     | The amount of feedback messages that will visible in LionValidationFeedback                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | LionField      |
+| Name                      | Privacy   | Type                   | Default         | Description                                                                                                                                                                                                                                                                                                                                                            | Inherited From |
+| ------------------------- | --------- | ---------------------- | --------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------- |
+| `accept`                  | public    | `string`               | `''`            |                                                                                                                                                                                                                                                                                                                                                                        |                |
+| `buttonLabel`             | public    | `string`               | `''`            | The label of the button                                                                                                                                                                                                                                                                                                                                                |                |
+| `enableDropZone`          | public    | `boolean`              | `false`         |                                                                                                                                                                                                                                                                                                                                                                        |                |
+| `isDragging`              | public    | `boolean`              |                 |                                                                                                                                                                                                                                                                                                                                                                        |                |
+| `maxFileSize`             | public    | `number`               | `MAX_FILE_SIZE` |                                                                                                                                                                                                                                                                                                                                                                        |                |
+| `modelValue`              | public    | `array`                | `[]`            | Overrides the inherited accessor with a typed pair instead of a class field: a field would be
emitted as a property and every consumer that type-checks the declarations reports
"TS2610: 'modelValue' is defined as an accessor ... but is overridden here as an instance
property". Keeps the published InputFile\[] type and adds no runtime behaviour. |                |
+| `multiple`                | public    | `boolean`              | `false`         |                                                                                                                                                                                                                                                                                                                                                                        |                |
+| `operationMode`           | public    |                        |                 |                                                                                                                                                                                                                                                                                                                                                                        |                |
+| `slots`                   | public    |                        |                 |                                                                                                                                                                                                                                                                                                                                                                        |                |
+| `type`                    | public    | `string`               | `'file'`        |                                                                                                                                                                                                                                                                                                                                                                        |                |
+| `uploadOnSelect`          | public    | `boolean`              | `false`         |                                                                                                                                                                                                                                                                                                                                                                        |                |
+| `uploadResponse`          | public    | `UploadResponse[]`     | `[]`            |                                                                                                                                                                                                                                                                                                                                                                        |                |
+| `_acceptCriteria`         | protected |                        |                 |                                                                                                                                                                                                                                                                                                                                                                        |                |
+| `_buttonNode`             | protected |                        |                 |                                                                                                                                                                                                                                                                                                                                                                        |                |
+| `_feedbackConditionMeta`  | protected |                        |                 |                                                                                                                                                                                                                                                                                                                                                                        | LionField      |
+| `_fileListNode`           | protected | `LionSelectedFileList` |                 |                                                                                                                                                                                                                                                                                                                                                                        |                |
+| `_focusableNode`          | protected |                        |                 |                                                                                                                                                                                                                                                                                                                                                                        | LionField      |
+| `_initialButtonLabel`     | protected | `string`               | `''`            |                                                                                                                                                                                                                                                                                                                                                                        |                |
+| `_inputNode`              | protected | `HTMLInputElement`     |                 |                                                                                                                                                                                                                                                                                                                                                                        |                |
+| `_isDragAndDropSupported` | protected |                        |                 |                                                                                                                                                                                                                                                                                                                                                                        |                |
+| `_selectedFilesMetaData`  | protected | `InputFile[]`          | `[]`            |                                                                                                                                                                                                                                                                                                                                                                        |                |
 
 ### Methods
 
-| Name                                     | Privacy   | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | Parameters                                                                                                     | Return                                                        | Inherited From |
-| ---------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------- | -------------- |
-| `addToAriaDescribedBy`                   | public    | Allows to add element references to aria-describedby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `element: HTMLElement, { idPrefix = '', reorder = true }, customConfig: {idPrefix?:string; reorder?: boolean}` |                                                               | LionField      |
-| `addToAriaLabelledBy`                    | public    | Allows to add extra element references to aria-labelledby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `element: HTMLElement, { idPrefix = '', reorder = true }, customConfig: {idPrefix?:string; reorder?: boolean}` |                                                               | LionField      |
-| `attachShadow`                           | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `options: ShadowRootInit`                                                                                      | `ShadowRoot`                                                  | LionField      |
-| `blur`                                   | public    | Calls \`blur()\` on focusable element within                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |                                                                                                                |                                                               | LionField      |
-| `clear`                                  | public    | Clears modelValue.
Interaction states are not cleared (use resetInteractionState for this)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                                                                                                                |                                                               | LionField      |
-| `click`                                  | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | LionField      |
-| `createScopedElement`                    | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `tagName`                                                                                                      |                                                               | LionField      |
-| `defineScopedElement`                    | public    | Defines a scoped element.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `tagName: string, classToBeRegistered: typeof HTMLElement`                                                     |                                                               | LionField      |
-| `deserializer`                           | public    | Converts \`.serializedValue\` to \`.modelValue\`
For instance, an iso formatted date string to a Date object                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `v: ?`                                                                                                         | `?`                                                           | LionField      |
-| `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`                                                     | LionField      |
-| `focus`                                  | public    | Calls \`focus()\` on focusable element within                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |                                                                                                                |                                                               | LionField      |
-| `formatter`                              | public    | Converts modelValue to formattedValue (formattedValue will be synced with
\`.\_inputNode.value\`)
For instance, a Date object to a localized date.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `v: InputFile[]`                                                                                               | `string`                                                      | LionField      |
-| `initInteractionState`                   | public    | Evaluations performed on connectedCallback.
This method is public, so it can be called at a later moment (when we need to wait for
registering children for instance) as well.
Since this method will be called twice in last mentioned scenario, it must stay idempotent.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                |                                                               | LionField      |
-| `makeRequestToBeDisabled`                | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | LionField      |
-| `parser`                                 | public    | Converts viewValue to modelValue
For instance, a localized date to a Date Object                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `v: string, opts: FormatOptions`                                                                               | `InputFile[]`                                                 | LionField      |
-| `preprocessor`                           | public    | Preprocessors could be considered 'live formatters'. Their result is shown to the user
on keyup instead of after blurring the field. The biggest difference between preprocessors
and formatters is their moment of execution: preprocessors are run before modelValue is
computed (and work based on view value), whereas formatters are run after the parser (and
are based on modelValue)
Automatically formats code while typing. It depends on a preprocessor that smartly
updates the viewValue and caret position for best UX.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `v: string, opts: FormatOptions & { prevViewValue: string; currentCaretIndex: number }`                        | `{ viewValue:string; caretIndex:number; }\|string\|undefined` | LionField      |
-| `removeFromAriaDescribedBy`              | public    | Allows to remove element references from aria-describedby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `element: HTMLElement`                                                                                         |                                                               | LionField      |
-| `removeFromAriaLabelledBy`               | public    | Allows to remove element references from aria-labelledby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `element: HTMLElement`                                                                                         |                                                               | LionField      |
-| `reset`                                  | public    | Resets modelValue to initial value.
Interaction states are cleared                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                |                                                               | LionField      |
-| `resetInteractionState`                  | public    | Resets touched and dirty, and recomputes prefilled                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |                                                                                                                |                                                               | LionField      |
-| `retractRequestToBeDisabled`             | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | LionField      |
-| `serializer`                             | public    | Converts \`.modelValue\` to \`.serializedValue\`
For instance, a Date object to an iso formatted date string                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `v: ?`                                                                                                         | `string`                                                      | LionField      |
-| `updateSync`                             | public    | An abstraction that has the exact same api as \`requestUpdate\`, but taking
into account:
- \[member order independence]\(https\://github.com/webcomponents/gold-standard/wiki/Member-Order-Independence)
- property effects start when all (light) dom has initialized (on firstUpdated)
- property effects don't interrupt the first meaningful paint
- compatible with propertyAccessor.\`hasChanged\`: no manual checks needed or accidentally
run property effects / events when no change happened
effects when values didn't change
All code previously present in requestUpdate can be placed in this method.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `name: string, oldValue: ?`                                                                                    |                                                               | LionField      |
-| `validate`                               | public    | Triggered by:
 \- modelValue change
 \- change in the 'validators' array
 \- change in the config of an individual Validator

Three situations are handled:
- a1) the FormControl is empty: further execution is halted. When the Required Validator
(being mutually exclusive to the other Validators) is applied, it will end up in the
validation result (as the only Validator, since further execution was halted).
- a2) there are synchronous Validators: this is the most common flow. When modelValue hasn't
changed since last async results were generated, 'sync results' are merged with the
'async results'.
- a3) there are asynchronous Validators: for instance when server side evaluation is needed.
Executions are scheduled and awaited and the 'async results' are merged with the
'sync results'.

- b) there are MetaValidators. After steps a1, a2, or a3 are finished, the holistic
MetaValidators (evaluating the total result of the 'regular' (a1, a2 and a3) validators)
will be run...

Situations a2 and a3 are not mutually exclusive and can be triggered within one \`validate()\`
call. Situation b will occur after every call. | `{ clearCurrentResult = false }, opts: { clearCurrentResult?: boolean }`                                       |                                                               | LionField      |
-| `_calculateValues`                       | protected | Responsible for storing all representations(modelValue, serializedValue, formattedValue
and value) of the input value. Prevents infinite loops, so all value observers can be
treated like they will only be called once, without indirectly calling other observers.
(in fact, some are called twice, but the \_\_preventRecursiveTrigger lock prevents the
second call from having effect).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `{ source }, config: {source:'model'\|'serialized'\|'formatted'\|null}`                                        |                                                               | LionField      |
-| `_connectSlotMixin`                      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | LionField      |
-| `_dispatchFileListChangeEvent`           | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `newFiles: InputFile[]`                                                                                        |                                                               |                |
-| `_dispatchInitialModelValueChangedEvent` | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | LionField      |
-| `_dispatchModelValueChangedEvent`        | protected | This is wrapped in a distinct method, so that parents can control when the changed event
is fired. For objects, a deep comparison might be needed.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `args: { modelValue: unknown; }[]`                                                                             |                                                               | LionField      |
-| `_dropZoneTemplate`                      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              |                |
-| `_enhanceLightDomA11y`                   | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | LionField      |
-| `_enhanceLightDomA11yForAdditionalSlots` | protected | Enhances additional slots(prefix, suffix, before, after) defined by developer.

When boolean attribute data-label or data-description is found,
the slot element will be connected to the input via aria-labelledby or aria-describedby                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `additionalSlots: string[]`                                                                                    |                                                               | LionField      |
-| `_enhanceLightDomClasses`                | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | LionField      |
-| `_feedbackTemplate`                      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | LionField      |
-| `_getAriaDescriptionElements`            | protected | This function exposes descripion elements that a FormGroup should expose to its&#xA;children. See FormGroupMixin.\_\_getAllDescriptionElementsInParentChain()                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |                                                                                                                | `Array.<HTMLElement>`                                         | LionField      |
-| `_groupOneTemplate`                      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | LionField      |
-| `_groupTwoTemplate`                      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | LionField      |
-| `_handleErroredFiles`                    | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `fileObj: InputFile`                                                                                           |                                                               |                |
-| `_handleErrors`                          | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               |                |
-| `_hasFeedbackVisibleFor`                 | protected | Used to translate \`.hasFeedbackFor\` and \`.shouldShowFeedbackFor\` to \`.showsFeedbackFor\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `type: string`                                                                                                 |                                                               | LionField      |
-| `_helpTextTemplate`                      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | LionField      |
-| `_inputGroupAfterTemplate`               | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | LionField      |
-| `_inputGroupBeforeTemplate`              | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | LionField      |
-| `_inputGroupInputTemplate`               | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | LionField      |
-| `_inputGroupPrefixTemplate`              | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult \| nothing`                                   | LionField      |
-| `_inputGroupSuffixTemplate`              | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult \| nothing`                                   | LionField      |
-| `_inputGroupTemplate`                    | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | LionField      |
-| `_isEmpty`                               | protected | Helper method for the mutually exclusive Required Validator                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `modelValue: any`                                                                                              | `boolean`                                                     | LionField      |
-| `_isPrivateSlot`                         | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `slotName: string`                                                                                             | `boolean`                                                     | LionField      |
-| `_iStateOnLeave`                         | protected | Sets touched value to true and reevaluates prefilled state.&#xA;When false, on next interaction, user will start with a clean state.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |                                                                                                                |                                                               | LionField      |
-| `_iStateOnValueChange`                   | protected | Sets dirty value and validates when already touched or invalid                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                                                                                                                |                                                               | LionField      |
-| `_labelTemplate`                         | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`                                              | LionField      |
-| `_onBeforeRepropagateChildrenValues`     | protected | Hook for Subclassers to add logic before repropagation                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `ev: CustomEvent`                                                                                              |                                                               | LionField      |
-| `_onChange`                              | protected | Dispatches custom bubble event                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `ev: Event=`                                                                                                   |                                                               | LionField      |
-| `_onClick`                               | protected | Clear \_inputNode.value to make sure onChange is called even for duplicate files                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `ev: Event`                                                                                                    |                                                               |                |
-| `_onDirtyChanged`                        | protected | Dispatches event on touched state change                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |                                                                                                                |                                                               | LionField      |
-| `_onLabelClick`                          | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | LionField      |
-| `_onModelValueChanged`                   | protected | Responds to modelValue changes in the synchronous cycle (most subclassers should listen to&#xA;the asynchronous cycle ('modelValue' in the .updated lifecycle))                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `args: { modelValue: unknown; }[]`                                                                             |                                                               | LionField      |
-| `_onRemoveFile`                          | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: CustomEvent`                                                                                              |                                                               |                |
-| `_onTouchedChanged`                      | protected | Dispatches event on touched state change                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |                                                                                                                |                                                               | LionField      |
-| `_onUserInputChanged`                    | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | LionField      |
-| `_onValidatorUpdated`                    | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `e: Event\|CustomEvent`                                                                                        |                                                               | LionField      |
-| `_prioritizeAndFilterFeedback`           | protected | Orders all active validators in this.\_\_validationResult.&#xA;Can also filter out occurrences (based on interaction states)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `{ validationResult }, opts: { validationResult: Validator[] }`                                                | `Validator[]`                                                 | LionField      |
-| `_processDroppedFiles`                   | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: DragEvent`                                                                                                |                                                               |                |
-| `_processFiles`                          | protected | Runs on drag or change event                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `selectedFiles: InputFile[]`                                                                                   |                                                               |                |
-| `_proxyInputEvent`                       | protected | This can be called whenever the view value should be updated. Dependent on component type&#xA;("input" for \<input> or "change" for \<select>(mainly for IE)) a different event should be&#xA;used  as source for the "user-input-changed" event (which can be seen as an abstraction&#xA;layer on top of other events (input, change, whatever))                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |                                                                                                                |                                                               | LionField      |
-| `_reflectBackFormattedValueToUser`       | protected | Synchronization from \`LionField.value\` to \`.\_inputNode.value\`&#xA;- flow \[1] will always be reflected back&#xA;- flow \[2] will not be reflected back when this flow was triggered via&#xA;  \`@user-input-changed\` (this will happen later, when \`formatOn\` condition is met)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |                                                                                                                |                                                               | LionField      |
-| `_reflectBackOn`                         | protected | Every time .formattedValue is attempted to sync to the view value (on change/blur and on&#xA;modelValue change), this condition is checked. In case of the input-file we don't want&#xA;this sync to happen, since the view value is already correct.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |                                                                                                                | `boolean`                                                     | LionField      |
-| `_removeFile`                            | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `removedFile: InputFile`                                                                                       |                                                               |                |
-| `_repropagationCondition`                | protected | Based on provided target, this condition determines whether received model-value-changed&#xA;event should be repropagated                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `target: FormControlHost`                                                                                      |                                                               | LionField      |
-| `_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`                                                                                   |                                                               | LionField      |
-| `_syncValueUpwards`                      | protected | Synchronization from \`.\_inputNode.value\` to \`LionField\` (flow \[2])&#xA;Downwards syncing should only happen for \`LionField\`.value changes from 'above'.&#xA;This triggers \_onModelValueChanged and connects user input&#xA;to the parsing/formatting/serializing loop.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | LionField      |
-| `_triggerInitialModelValueChangedEvent`  | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | LionField      |
-| `_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                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |                                                                                                                |                                                               | LionField      |
-| `_updateShouldShowFeedbackFor`           | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | LionField      |
-| `_updateUploadButtonDescription`         | protected | Description for screen readers connected to the button about how many files have been updated                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |                                                                                                                |                                                               |                |
+| Name                             | Privacy   | Description                                                                                                                                                                                                                                           | Parameters                   | Return           | Inherited From |
+| -------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ---------------- | -------------- |
+| `clear`                          | public    | Clears modelValue.&#xA;Interaction states are not cleared (use resetInteractionState for this)                                                                                                                                                        |                              |                  | LionField      |
+| `formatter`                      | public    |                                                                                                                                                                                                                                                       | `v: InputFile[]`             | `string`         |                |
+| `onLocaleUpdated`                | public    |                                                                                                                                                                                                                                                       |                              |                  |                |
+| `parser`                         | public    |                                                                                                                                                                                                                                                       |                              | `InputFile[]`    |                |
+| `reset`                          | public    | Resets modelValue to initial value.&#xA;Interaction states are cleared                                                                                                                                                                                |                              |                  | LionField      |
+| `resetInteractionState`          | public    |                                                                                                                                                                                                                                                       |                              |                  | LionField      |
+| `_dispatchFileListChangeEvent`   | protected |                                                                                                                                                                                                                                                       | `newFiles: InputFile[]`      |                  |                |
+| `_dropZoneTemplate`              | protected |                                                                                                                                                                                                                                                       |                              | `TemplateResult` |                |
+| `_handleErroredFiles`            | protected |                                                                                                                                                                                                                                                       | `fileObj: InputFile`         |                  |                |
+| `_handleErrors`                  | protected |                                                                                                                                                                                                                                                       |                              |                  |                |
+| `_inputGroupAfterTemplate`       | protected |                                                                                                                                                                                                                                                       |                              | `TemplateResult` |                |
+| `_inputGroupInputTemplate`       | protected |                                                                                                                                                                                                                                                       |                              | `TemplateResult` |                |
+| `_isEmpty`                       | protected | Helper method for the mutually exclusive Required Validator                                                                                                                                                                                           |                              |                  |                |
+| `_onChange`                      | protected | Dispatches custom bubble event                                                                                                                                                                                                                        | `ev: Event=`                 |                  | LionField      |
+| `_onClick`                       | protected | Clear \_inputNode.value to make sure onChange is called even for duplicate files                                                                                                                                                                      | `ev: Event`                  |                  |                |
+| `_onRemoveFile`                  | protected |                                                                                                                                                                                                                                                       | `ev: CustomEvent`            |                  |                |
+| `_processDroppedFiles`           | protected |                                                                                                                                                                                                                                                       | `ev: DragEvent`              |                  |                |
+| `_processFiles`                  | protected | Runs on drag or change event                                                                                                                                                                                                                          | `selectedFiles: InputFile[]` |                  |                |
+| `_reflectBackOn`                 | protected | Every time .formattedValue is attempted to sync to the view value (on change/blur and on&#xA;modelValue change), this condition is checked. In case of the input-file we don't want&#xA;this sync to happen, since the view value is already correct. |                              | `boolean`        |                |
+| `_removeFile`                    | protected |                                                                                                                                                                                                                                                       | `removedFile: InputFile`     |                  |                |
+| `_showFeedbackConditionFor`      | protected |                                                                                                                                                                                                                                                       | `type: string, meta: object` |                  |                |
+| `_updateUploadButtonDescription` | protected | Description for screen readers connected to the button about how many files have been updated                                                                                                                                                         |                              |                  |                |
 
 ### Events
 
-| Name                           | Type          | Description                                              | Inherited From |
-| ------------------------------ | ------------- | -------------------------------------------------------- | -------------- |
-| `file-list-changed`            | `CustomEvent` |                                                          |                |
-| `file-removed`                 | `CustomEvent` |                                                          |                |
-| `form-element-name-changed`    | `CustomEvent` |                                                          | LionField      |
-| `model-value-changed`          | `CustomEvent` |                                                          | LionField      |
-| `form-element-register`        | `CustomEvent` |                                                          | LionField      |
-| `touched-changed`              | `Event`       |                                                          | LionField      |
-| `dirty-changed`                | `Event`       |                                                          | LionField      |
-| `focus`                        | `Event`       |                                                          | LionField      |
-| `blur`                         | `Event`       |                                                          | LionField      |
-| `focusin`                      | `Event`       |                                                          | LionField      |
-| `focusout`                     | `Event`       |                                                          | LionField      |
-| `user-input-changed`           | `Event`       |                                                          | LionField      |
-| `showsFeedbackForChanged`      | `Event`       |                                                          | LionField      |
-|                                | `Event`       |                                                          | LionField      |
-| `shouldShowFeedbackForChanged` | `Event`       |                                                          | LionField      |
-| `validate-performed`           | `Event`       | private event that should be listened to by LionFieldSet | LionField      |
+| Name                 | Type          | Description | Inherited From |
+| -------------------- | ------------- | ----------- | -------------- |
+| `file-list-changed`  | `CustomEvent` |             |                |
+| `file-removed`       | `CustomEvent` |             |                |
+| `user-input-changed` | `Event`       |             | LionField      |
 
 ### Attributes
 
-| Name                            | Field                      | Inherited From |
-| ------------------------------- | -------------------------- | -------------- |
-| `accept`                        | accept                     |                |
-| `multiple`                      | multiple                   |                |
-| `button-label`                  | buttonLabel                |                |
-| `max-file-size`                 | maxFileSize                |                |
-| `enable-drop-zone`              | enableDropZone             |                |
-| `upload-on-select`              | uploadOnSelect             |                |
-| `is-dragging`                   | isDragging                 |                |
-| `uploadResponse`                | uploadResponse             |                |
-| `_selectedFilesMetaData`        | \_selectedFilesMetaData    |                |
-| `readonly`                      | readOnly                   | LionField      |
-| `label`                         | label                      | LionField      |
-| `label-sr-only`                 | labelSrOnly                | LionField      |
-| `help-text`                     | helpText                   | LionField      |
-| `name`                          | name                       | LionField      |
-| `allow-cross-root-registration` | allowCrossRootRegistration | LionField      |
-| `disabled`                      | disabled                   | LionField      |
-| `touched`                       | touched                    | LionField      |
-| `dirty`                         | dirty                      | LionField      |
-| `filled`                        | filled                     | LionField      |
-| `focused`                       | focused                    | LionField      |
-| `focused-visible`               | focusedVisible             | LionField      |
-| `autofocus`                     | autofocus                  | LionField      |
-| `shows-feedback-for`            | showsFeedbackFor           | LionField      |
-| `is-pending`                    | isPending                  | LionField      |
+| Name                     | Field                   | Inherited From |
+| ------------------------ | ----------------------- | -------------- |
+| `accept`                 | accept                  |                |
+| `multiple`               | multiple                |                |
+| `button-label`           | buttonLabel             |                |
+| `max-file-size`          | maxFileSize             |                |
+| `enable-drop-zone`       | enableDropZone          |                |
+| `upload-on-select`       | uploadOnSelect          |                |
+| `is-dragging`            | isDragging              |                |
+| `uploadResponse`         | uploadResponse          |                |
+| `_selectedFilesMetaData` | \_selectedFilesMetaData |                |
 
 ### Slots
 
@@ -257,15 +131,15 @@ eleventyNavigation:
 
 ### Methods
 
-| Name                           | Privacy   | Description | Parameters                                                     | Return                    | Inherited From |
-| ------------------------------ | --------- | ----------- | -------------------------------------------------------------- | ------------------------- | -------------- |
-| `_enhanceLightDomA11y`         | protected |             |                                                                |                           |                |
-| `_listItemAfterTemplate`       | protected |             | `file: InputFile, fileUuid: string`                            | `TemplateResult`          |                |
-| `_listItemBeforeTemplate`      | protected |             | `file: InputFile`                                              | `TemplateResult\|nothing` |                |
-| `_removeButtonContentTemplate` | protected |             |                                                                | `TemplateResult`          |                |
-| `_removeFile`                  | protected |             | `removedFile: InputFile`                                       |                           |                |
-| `_selectedListItemTemplate`    | protected |             | `file: InputFile`                                              | `TemplateResult`          |                |
-| `_validationFeedbackTemplate`  | protected |             | `validationFeedback: Array<FeedbackMessage>, fileUuid: string` | `TemplateResult`          |                |
+| Name                           | Privacy   | Description | Parameters                                                     | Return                           | Inherited From |
+| ------------------------------ | --------- | ----------- | -------------------------------------------------------------- | -------------------------------- | -------------- |
+| `_enhanceLightDomA11y`         | protected |             |                                                                |                                  |                |
+| `_listItemAfterTemplate`       | protected |             | `file: InputFile, fileUuid: string`                            | `TemplateResult`                 |                |
+| `_listItemBeforeTemplate`      | protected |             | `file: InputFile`                                              | `TemplateResult\|typeof nothing` |                |
+| `_removeButtonContentTemplate` | protected |             |                                                                | `TemplateResult`                 |                |
+| `_removeFile`                  | protected |             | `removedFile: InputFile`                                       |                                  |                |
+| `_selectedListItemTemplate`    | protected |             | `file: InputFile`                                              | `TemplateResult`                 |                |
+| `_validationFeedbackTemplate`  | protected |             | `validationFeedback: Array<FeedbackMessage>, fileUuid: string` | `TemplateResult`                 |                |
 
 ### Events