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

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

@@ -16,234 +16,101 @@ eleventyNavigation:
 
 ### Fields
 
-| Name                           | Privacy   | Type                                  | Default                                                                                                                           | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | Inherited From         |
-| ------------------------------ | --------- | ------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------- |
-| `activeIndex`                  | public    |                                       |                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ListboxMixin           |
-| `allowCustomChoice`            | public    | `boolean`                             | `false`                                                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | CustomChoiceGroupMixin |
-| `autocomplete`                 | public    | `'none'\|'list'\|'inline'\|'both'`    | `'both'`                                                                                                                          | When "list", will filter listbox suggestions based on textbox value.
When "both", an inline completion string will be added to the textbox as well.                                                                                                                                                                                                                                                                                                                                                                                              |                        |
-| `autofocus`                    | public    | `boolean`                             | `false`                                                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | FocusMixin             |
-| `checkedIndex`                 | public    | `number \| number[]`                  |                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ListboxMixin           |
-| `customChoices`                | public    |                                       |                                                                                                                                   | Custom elements are all missing elements that have no corresponding element, independent if enabled or not.                                                                                                                                                                                                                                                                                                                                                                                                                                          | CustomChoiceGroupMixin |
-| `defaultValidators`            | public    | `Validator[]`                         | `[]`                                                                                                                              | Used by Subclassers to add default Validators to a particular FormControl.
A date input for instance, always needs the isDate validator.                                                                                                                                                                                                                                                                                                                                                                                                         | ValidateMixin          |
-| `dirty`                        | public    | `boolean`                             | `false`                                                                                                                           | True when user has changed the value of the field.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | InteractionStateMixin  |
-| `disabled`                     | public    | `boolean`                             | `false`                                                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | DisabledMixin          |
-| `done`                         | public    | `boolean`                             | `false`                                                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | FormRegistrarMixin     |
-| `fieldName`                    | public    | `string`                              |                                                                                                                                   | Will be used in validation messages to refer to the current field                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | FormControlMixin       |
-| `filled`                       | public    | `boolean`                             | `false`                                                                                                                           | True when the modelValue is non-empty (see \_isEmpty in FormControlMixin)                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | InteractionStateMixin  |
-| `focused`                      | public    | `boolean`                             | `false`                                                                                                                           | Whether the focusable element within (\`.\_focusableNode\`) is focused.
Reflects to attribute '\[focused]' as a styling hook                                                                                                                                                                                                                                                                                                                                                                                                                     | FocusMixin             |
-| `focusedVisible`               | public    | `boolean`                             | `false`                                                                                                                           | Whether the focusable element within (\`.\_focusableNode\`) matches ':focus-visible'
Reflects to attribute '\[focused-visible]' as a styling hook
See: https\://developer.mozilla.org/en-US/docs/Web/CSS/:focus-visible                                                                                                                                                                                                                                                                                                                      | FocusMixin             |
-| `formattedValue`               | public    |                                       |                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ChoiceGroupMixin       |
-| `formElements`                 | public    | `FormControlsCollection`              | `new FormControlsCollection()`                                                                                                    | Closely mimics the natively supported HTMLFormControlsCollection. It can be accessed
both like an array and an object (based on control/element names).                                                                                                                                                                                                                                                                                                                                                                                          | FormRegistrarMixin     |
-| `hasFeedbackFor`               | public    | `ValidationType[]`                    | `[]`                                                                                                                              | As soon as validation happens (after modelValue/validators/validator param change), this
array is updated with the active ValidationTypes ('error'\|'warning'\|'success'\|'info' etc.).
Notice the difference with \`.showsFeedbackFor\`, which filters \`.hasFeedbackFor\` based on
\`.feedbackCondition()\`.

For styling purposes, will be reflected to \[has-feedback-for="error warning"]. This can
be useful for subtle visual feedback on keyup, like a red/green border around an input.                             | ValidateMixin          |
-| `hasNoDefaultSelected`         | public    | `boolean`                             | `false`                                                                                                                           | When setting this to true, on initial render, no option will be selected.
It is advisable to override \`\_noSelectionTemplate\` method in the select-invoker
to render some kind of placeholder initially                                                                                                                                                                                                                                                                                                                                    | ListboxMixin           |
-| `helpText`                     | public    | `string`                              |                                                                                                                                   | The helpt text for the input node.
When no light dom defined via \[slot=help-text], this value will be used                                                                                                                                                                                                                                                                                                                                                                                                                                      | FormControlMixin       |
-| `initComplete`                 | public    | `Promise<any>`                        | `new Promise((resolve, reject) => { this.__resolveInitComplete = resolve; this.__rejectInitComplete = reject; })`                 | initComplete resolves after all pending initialization logic&#xA;(for instance \`\<form-group .serializedValue=${{ child1: 'a', child2: 'b' }}>\`)&#xA;is executed                                                                                                                                                                                                                                                                                                                                                                                   | FormRegistrarMixin     |
-| `isPending`                    | public    | `boolean`                             | `false`                                                                                                                           | Flag indicating whether async validation is pending.&#xA;Creates attribute \[is-pending] as a styling hook                                                                                                                                                                                                                                                                                                                                                                                                                                           | ValidateMixin          |
-| `label`                        | public    | `string`                              |                                                                                                                                   | The label text for the input node.&#xA;When no light dom defined via \[slot=label], this value will be used.                                                                                                                                                                                                                                                                                                                                                                                                                                         | FormControlMixin       |
-| `labelSrOnly`                  | public    | `boolean`                             | `false`                                                                                                                           | The label will only be visible for srceen readers when true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | FormControlMixin       |
-| `matchMode`                    | public    | `'begin'\|'all'`                      | `'all'`                                                                                                                           | When typing in the textbox, will by default be set on 'begin',&#xA;only matching the beginning part in suggestion list.&#xA;=> 'a' will match 'apple' from \['apple', 'pear', 'citrus'].&#xA;When set to 'all', will match middle of the word as well&#xA;=> 'a' will match 'apple' and 'pear'                                                                                                                                                                                                                                                       |                        |
-| `modelValue`                   | public    | `object`                              |                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | FormControlMixin       |
-| `multipleChoice`               | public    | `boolean`                             | `false`                                                                                                                           | When false (default), modelValue and serializedValue will reflect the&#xA;currently selected choice (usually a string). When true, modelValue will and&#xA;serializedValue will be an array of strings.                                                                                                                                                                                                                                                                                                                                              | ChoiceGroupMixin       |
-| `operationMode`                | public    | `OperationMode`                       |                                                                                                                                   | Types of input interaction of the FormControl (for instance 'enter'\|'select'\|'upload')                                                                                                                                                                                                                                                                                                                                                                                                                                                             | ValidateMixin          |
-| `orientation`                  | public    | `string`                              | `'vertical'`                                                                                                                      | Informs screen reader and affects keyboard navigation.&#xA;By default 'vertical'                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | ListboxMixin           |
-| `prefilled`                    | public    | `boolean`                             | `false`                                                                                                                           | True when user has left non-empty field or input is prefilled.&#xA;The name must be seen from the point of view of the input field:&#xA;once the user enters the input field, the value is non-empty.                                                                                                                                                                                                                                                                                                                                                | InteractionStateMixin  |
-| `readOnly`                     | public    | `boolean`                             | `false`                                                                                                                           | A Boolean attribute which, if present, indicates that the user should not be able to edit&#xA;the value of the input. The difference between disabled and readonly is that read-only&#xA;controls can still function, whereas disabled controls generally do not function as&#xA;controls until they are enabled.&#xA;(From: https\://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#attr-readonly)                                                                                                                                         | FormControlMixin       |
-| `registrationComplete`         | public    | `Promise<any> & {done?:boolean}`      | `new Promise((resolve, reject) => { this.__resolveRegistrationComplete = resolve; this.__rejectRegistrationComplete = reject; })` | registrationComplete waits for all children formElements to have registered                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | FormRegistrarMixin     |
-| `requireOptionMatch`           | public    | `boolean`                             | `true`                                                                                                                            | If set to false, the value is allowed to not match any of the options.&#xA;We set the default to true for backwards compatibility                                                                                                                                                                                                                                                                                                                                                                                                                    |                        |
-| `rotateKeyboardNavigation`     | public    | `boolean`                             | `true`                                                                                                                            | Will give first option active state when navigated to the next option from&#xA;last option.                                                                                                                                                                                                                                                                                                                                                                                                                                                          | ListboxMixin           |
-| `selectionFollowsFocus`        | public    | `boolean`                             | `true`                                                                                                                            | When true, will synchronize activedescendant and selected element on&#xA;arrow key navigation.&#xA;This behavior can usually be seen on \<select> on the Windows platform.&#xA;Note that this behavior cannot be used when multiple-choice is true.&#xA;See: https\://www\.w3.org/TR/wai-aria-practices/#kbd\_selection\_follows\_focus                                                                                                                                                                                                              | ListboxMixin           |
-| `serializedValue`              | public    |                                       |                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ChoiceGroupMixin       |
-| `showAllOnEmpty`               | public    | `boolean`                             | `false`                                                                                                                           | When true, the listbox is open and textbox goes from a value to empty, all options are shown.&#xA;By default, the listbox closes on empty, similar to wai-aria example and \<datalist>                                                                                                                                                                                                                                                                                                                                                               |                        |
-| `showsFeedbackFor`             | public    | `ValidationType[]`                    | `[]`                                                                                                                              | Based on outcome of feedbackCondition, this array decides what ValidationTypes should be&#xA;shown in validationFeedback, based on meta data like interaction states.&#xA;&#xA;For styling purposes, it reflects it \`\[shows-feedback-for="error warning"]\`                                                                                                                                                                                                                                                                                        | ValidateMixin          |
-| `submitted`                    | public    |                                       |                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | InteractionStateMixin  |
-| `touched`                      | public    | `boolean`                             | `false`                                                                                                                           | True when user has focused and left(blurred) the field.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | InteractionStateMixin  |
-| `validationStates`             | public    | `ValidationStates`                    | `{}`                                                                                                                              | The outcome of a validation 'round'. Keyed by ValidationType and Validator name                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ValidateMixin          |
-| `validators`                   | public    | `Validator[]`                         | `[]`                                                                                                                              | Used by Application Developers to add Validators to a FormControl.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | ValidateMixin          |
-| `value`                        | public    |                                       |                                                                                                                                   | We define the value getter/setter below as also defined in LionField (via FormatMixin).&#xA;Since FormatMixin is meant for Formgroups/ChoiceGroup it's not applied on Combobox;&#xA;Combobox is somewhat of a hybrid between a ChoiceGroup and LionField, therefore we copy over&#xA;some of the LionField members to align with its interface.&#xA;&#xA;The view value. Will be delegated to \`.\_inputNode.value\`                                                                                                                                 |                        |
-| `_activeDescendantOwnerNode`   | protected | `HTMLElement`                         |                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ListboxMixin           |
-| `_allValidators`               | protected | `(Validator \| MetaValidator)[]`      |                                                                                                                                   | Combination of validators provided by Application Developer and the default validators                                                                                                                                                                                                                                                                                                                                                                                                                                                               | ValidateMixin          |
-| `_ariaDescribedNodes`          | public    | `HTMLElement[]`                       | `[]`                                                                                                                              | Contains all elements that should end up in aria-describedby of \`.\_inputNode\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | FormControlMixin       |
-| `_ariaLabelledNodes`           | public    | `HTMLElement[]`                       | `[]`                                                                                                                              | Contains all elements that should end up in aria-labelledby of \`.\_inputNode\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | FormControlMixin       |
-| `_ariaVersion`                 | protected | `'1.1'\|'1.0'`                        |                                                                                                                                   | For optimal support, we allow aria v1.1 on newer browsers                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |                        |
-| `_comboboxNode`                | protected | `HTMLElement`                         |                                                                                                                                   | Wrapper with combobox role for the text input that the end user controls the listbox with.                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                        |
-| `_customChoices`               | protected | `Set<unknown>`                        | `new Set()`                                                                                                                       |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | CustomChoiceGroupMixin |
-| `_feedbackConditionMeta`       | protected |                                       |                                                                                                                                   | Allows Subclassers to add meta info for feedbackCondition                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | LionListbox            |
-| `_feedbackNode`                | protected |                                       |                                                                                                                                   | Element where validation feedback will be rendered to                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | FormControlMixin       |
-| `_focusableNode`               | protected | `HTMLElement`                         |                                                                                                                                   | The focusable element:&#xA;could be an input, textarea, select, button or any other element with tabindex > -1                                                                                                                                                                                                                                                                                                                                                                                                                                       | LionListbox            |
-| `_helpTextNode`                | protected |                                       |                                                                                                                                   | Element where help text will be rendered to                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | FormControlMixin       |
-| `_inputId`                     | protected | `string`                              |                                                                                                                                   | Unique id that can be used in all light dom                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | FormControlMixin       |
-| `_inputNode`                   | protected |                                       |                                                                                                                                   | The interactive (form) element. Can be a native element like input/textarea/select or&#xA;an element with tabindex > -1                                                                                                                                                                                                                                                                                                                                                                                                                              | FormControlMixin       |
-| `_isFormOrFieldset`            | protected | `boolean`                             | `false`                                                                                                                           | Flag that determines how ".formElements" should behave.&#xA;For a regular fieldset (see LionFieldset) we expect ".formElements"&#xA;to be accessible as an object.&#xA;In case of a radio-group, a checkbox-group or a select/listbox,&#xA;it should act like an array (see ChoiceGroupMixin).&#xA;Usually, when false, we deal with a choice-group (radio-group, checkbox-group,&#xA;(multi)select)                                                                                                                                                 | FormRegistrarMixin     |
-| `_isRepropagationEndpoint`     | public    | `boolean`                             | `false`                                                                                                                           | By default, a field with \_repropagationRole 'choice-group' will act as an&#xA;'endpoint'. This means it will be considered as an individual field: for&#xA;a select, individual options will not be part of the formPath. They&#xA;will.&#xA;Similarly, components that (a11y wise) need to be fieldsets, but 'interaction wise'&#xA;(from Application Developer perspective) need to be more like fields&#xA;(think of an amount-input with a currency select box next to it), can set this&#xA;to true to hide private internals in the formPath. | FormControlMixin       |
-| `_labelNode`                   | protected |                                       |                                                                                                                                   | Element where label will be rendered to                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | FormControlMixin       |
-| `_leaveEvent`                  | protected | `string`                              | `'blur'`                                                                                                                          | The event that triggers the touched state                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | InteractionStateMixin  |
-| `_listboxActiveDescendant`     | protected | `number \| null`                      | `null`                                                                                                                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ListboxMixin           |
-| `_listboxActiveDescendantNode` | protected | `HTMLElement`                         |                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ListboxMixin           |
-| `_listboxNode`                 | protected |                                       |                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ListboxMixin           |
-| `_listboxReceivesNoFocus`      | protected | `boolean`                             | `true`                                                                                                                            | When listbox is coupled to a textbox (in case we are dealing with a combobox),&#xA;spaces should not select an element (they need to be put in the textbox)                                                                                                                                                                                                                                                                                                                                                                                          | ListboxMixin           |
-| `_listboxSlot`                 | protected | `HTMLElement`                         |                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ListboxMixin           |
-| `_noTypeAhead`                 | public    | `boolean`                             | `true`                                                                                                                            | When false, a user can type on which the focus will jump to the matching option                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ListboxMixin           |
-| `_oldModelValue`               | protected | `string \| string[] \| undefined`     | `undefined`                                                                                                                       |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ListboxMixin           |
-| `_overlayContentNode`          | protected |                                       |                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |                        |
-| `_overlayInvokerNode`          | protected |                                       |                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |                        |
-| `_overlayReferenceNode`        | protected |                                       |                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |                        |
-| `_repropagationRole`           | public    | `'child'\|'choice-group'\|'fieldset'` | `'choice-group'`                                                                                                                  | Based on the role, details of handling model-value-changed repropagation differ.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | FormControlMixin       |
-| `_requestedToBeDisabled`       | protected | `boolean`                             | `false`                                                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | DisabledMixin          |
-| `_scrollTargetNode`            | protected | `HTMLElement`                         |                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ListboxMixin           |
-| `_selectionDisplayNode`        | protected | `SelectionDisplay \| null`            |                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |                        |
-| `_typeAheadTimeout`            | protected | `number`                              | `1000`                                                                                                                            | The pending char sequence that will set active list item                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | ListboxMixin           |
-| `_valueChangedEvent`           | protected | `string`                              | `'model-value-changed'`                                                                                                           | The event that triggers the dirty state                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | InteractionStateMixin  |
-| `_visibleMessagesAmount`       | protected | `number`                              | `1`                                                                                                                               | The amount of feedback messages that will visible in LionValidationFeedback                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | ValidateMixin          |
+| Name                         | Privacy   | Type                               | Default  | Description                                                                                                                                                                                                                                                                                                                                                                                                          | Inherited From |
+| ---------------------------- | --------- | ---------------------------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------- |
+| `allowCustomChoice`          | public    | `boolean`                          |          |                                                                                                                                                                                                                                                                                                                                                                                                                      |                |
+| `autocomplete`               | public    | `'none'\|'list'\|'inline'\|'both'` | `'both'` | When "list", will filter listbox suggestions based on textbox value.&#xA;When "both", an inline completion string will be added to the textbox as well.                                                                                                                                                                                                                                                              |                |
+| `config`                     | public    | `Partial<OverlayConfig>`           | `{}`     | Configure the many options of the \`OverlayController\`                                                                                                                                                                                                                                                                                                                                                              | OverlayMixin   |
+| `matchMode`                  | public    | `'begin'\|'all'`                   | `'all'`  | When typing in the textbox, will by default be set on 'begin',&#xA;only matching the beginning part in suggestion list.&#xA;=> 'a' will match 'apple' from \['apple', 'pear', 'citrus'].&#xA;When set to 'all', will match middle of the word as well&#xA;=> 'a' will match 'apple' and 'pear'                                                                                                                       |                |
+| `modelValue`                 | public    |                                    |          |                                                                                                                                                                                                                                                                                                                                                                                                                      |                |
+| `opened`                     | public    | `boolean`                          | `false`  | If you add the opened attribute a dialog will be opened on page load. The invoker can be left out&#xA;in case the user does not need to be able to reopen the dialog.                                                                                                                                                                                                                                                | OverlayMixin   |
+| `requireOptionMatch`         | public    | `boolean`                          | `true`   | If set to false, the value is allowed to not match any of the options.&#xA;We set the default to true for backwards compatibility                                                                                                                                                                                                                                                                                    |                |
+| `rotateKeyboardNavigation`   | public    | `boolean`                          | `true`   |                                                                                                                                                                                                                                                                                                                                                                                                                      |                |
+| `selectionFollowsFocus`      | public    | `boolean`                          | `true`   |                                                                                                                                                                                                                                                                                                                                                                                                                      |                |
+| `showAllOnEmpty`             | public    | `boolean`                          | `false`  | When true, the listbox is open and textbox goes from a value to empty, all options are shown.&#xA;By default, the listbox closes on empty, similar to wai-aria example and \<datalist>                                                                                                                                                                                                                               |                |
+| `slots`                      | public    | `SlotsMap`                         |          |                                                                                                                                                                                                                                                                                                                                                                                                                      |                |
+| `value`                      | public    |                                    |          | We define the value getter/setter below as also defined in LionField (via FormatMixin).&#xA;Since FormatMixin is meant for Formgroups/ChoiceGroup it's not applied on Combobox;&#xA;Combobox is somewhat of a hybrid between a ChoiceGroup and LionField, therefore we copy over&#xA;some of the LionField members to align with its interface.&#xA;&#xA;The view value. Will be delegated to \`.\_inputNode.value\` |                |
+| `_activeDescendantOwnerNode` | protected |                                    |          |                                                                                                                                                                                                                                                                                                                                                                                                                      |                |
+| `_ariaVersion`               | protected | `'1.1'\|'1.0'`                     |          | For optimal support, we allow aria v1.1 on newer browsers                                                                                                                                                                                                                                                                                                                                                            |                |
+| `_comboboxNode`              | protected | `HTMLElement`                      |          | Wrapper with combobox role for the text input that the end user controls the listbox with.                                                                                                                                                                                                                                                                                                                           |                |
+| `_feedbackConditionMeta`     | protected |                                    |          |                                                                                                                                                                                                                                                                                                                                                                                                                      | LionListbox    |
+| `_focusableNode`             | protected |                                    |          |                                                                                                                                                                                                                                                                                                                                                                                                                      | LionListbox    |
+| `_inputNode`                 | protected |                                    |          |                                                                                                                                                                                                                                                                                                                                                                                                                      |                |
+| `_listboxNode`               | protected |                                    |          |                                                                                                                                                                                                                                                                                                                                                                                                                      |                |
+| `_listboxReceivesNoFocus`    | protected | `boolean`                          | `true`   |                                                                                                                                                                                                                                                                                                                                                                                                                      |                |
+| `_noTypeAhead`               | protected | `boolean`                          | `true`   |                                                                                                                                                                                                                                                                                                                                                                                                                      |                |
+| `_overlayBackdropNode`       | protected |                                    |          |                                                                                                                                                                                                                                                                                                                                                                                                                      | OverlayMixin   |
+| `_overlayContentNode`        | protected |                                    |          |                                                                                                                                                                                                                                                                                                                                                                                                                      | OverlayMixin   |
+| `_overlayContentWrapperNode` | protected |                                    |          |                                                                                                                                                                                                                                                                                                                                                                                                                      | OverlayMixin   |
+| `_overlayInvokerNode`        | protected |                                    |          | The node that opens/closes this overlay.&#xA;&#xA;Resolved in a stable, declarative way (independent of the exact DOM order)&#xA;by looking, in order, for:&#xA;1\. a child with \`\[slot="invoker"]\`&#xA;2\. any element in the same root that opts in via \`\[data-invoker]\` and&#xA;   references this host by id (\`for="\<id>"\`)&#xA;3\. a preceding sibling that opts in via \`\[data-invoker]\`            | OverlayMixin   |
+| `_overlayReferenceNode`      | protected |                                    |          |                                                                                                                                                                                                                                                                                                                                                                                                                      | OverlayMixin   |
+| `_selectionDisplayNode`      | protected | `SelectionDisplay \| null`         |          |                                                                                                                                                                                                                                                                                                                                                                                                                      |                |
 
 ### Methods
 
-| Name                                     | Privacy   | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | Parameters                                                                                                     | Return                      | Inherited From         |
-| ---------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- | --------------------------- | ---------------------- |
-| `addFormElement`                         | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `child: FormControl, indexToInsertAt: number`                                                                  |                             | FormRegistrarMixin     |
-| `addToAriaDescribedBy`                   | public    | Allows to add element references to aria-describedby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `element: HTMLElement, { idPrefix = '', reorder = true }, customConfig: {idPrefix?:string; reorder?: boolean}` |                             | FormControlMixin       |
-| `addToAriaLabelledBy`                    | public    | Allows to add extra element references to aria-labelledby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `element: HTMLElement, { idPrefix = '', reorder = true }, customConfig: {idPrefix?:string; reorder?: boolean}` |                             | FormControlMixin       |
-| `blur`                                   | public    | Calls \`blur()\` on focusable element within                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |                                                                                                                |                             | FocusMixin             |
-| `clear`                                  | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | ChoiceGroupMixin       |
-| `click`                                  | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | DisabledMixin          |
-| `feedbackCondition`                      | public    | Allows the Application Developer to specify when a feedback message should be shown                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `type: string, meta: object, currentCondition: ((type: string, meta: object) => boolean)`                      | `boolean`                   | ValidateMixin          |
-| `focus`                                  | public    | Calls \`focus()\` on focusable element within                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |                                                                                                                |                             | FocusMixin             |
-| `initInteractionState`                   | public    | Evaluations performed on connectedCallback.&#xA;This method is public, so it can be called at a later moment (when we need to wait for&#xA;registering children for instance) as well.&#xA;Since this method will be called twice in last mentioned scenario, it must stay idempotent.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                |                             | InteractionStateMixin  |
-| `isRegisteredFormElement`                | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `el: ElementWithParentFormGroup`                                                                               |                             | FormRegistrarMixin     |
-| `makeRequestToBeDisabled`                | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | DisabledMixin          |
-| `matchCondition`                         | public    | When the preconfigurable \`match-mode\` conditions are not sufficient,&#xA;one can define a custom matching function.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `option: LionOption, textboxValue: string`                                                                     |                             |                        |
-| `parser`                                 | public    | Converts viewValue to modelValue                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `value: string\|string[]`                                                                                      | `*`                         | CustomChoiceGroupMixin |
-| `removeFormElement`                      | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `child: FormControlHost`                                                                                       |                             | FormRegistrarMixin     |
-| `removeFromAriaDescribedBy`              | public    | Allows to remove element references from aria-describedby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `element: HTMLElement`                                                                                         |                             | FormControlMixin       |
-| `removeFromAriaLabelledBy`               | public    | Allows to remove element references from aria-labelledby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `element: HTMLElement`                                                                                         |                             | FormControlMixin       |
-| `reset`                                  | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | ListboxMixin           |
-| `resetInteractionState`                  | public    | Resets touched and dirty, and recomputes prefilled                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |                                                                                                                |                             | InteractionStateMixin  |
-| `retractRequestToBeDisabled`             | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | DisabledMixin          |
-| `setCheckedIndex`                        | public    | If an array is passed for multiple-choice, it will check the indexes in array, and uncheck the rest&#xA;If a number is passed, the item with the passed index is checked without unchecking others&#xA;For single choice, \_\_onChildCheckedChanged we ensure that we uncheck siblings                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `index: number\|number[]`                                                                                      |                             | ListboxMixin           |
-| `validate`                               | public    | Triggered by:&#xA; \- modelValue change&#xA; \- change in the 'validators' array&#xA; \- change in the config of an individual Validator&#xA;&#xA;Three situations are handled:&#xA;- a1) the FormControl is empty: further execution is halted. When the Required Validator&#xA;(being mutually exclusive to the other Validators) is applied, it will end up in the&#xA;validation result (as the only Validator, since further execution was halted).&#xA;- a2) there are synchronous Validators: this is the most common flow. When modelValue hasn't&#xA;changed since last async results were generated, 'sync results' are merged with the&#xA;'async results'.&#xA;- a3) there are asynchronous Validators: for instance when server side evaluation is needed.&#xA;Executions are scheduled and awaited and the 'async results' are merged with the&#xA;'sync results'.&#xA;&#xA;- b) there are MetaValidators. After steps a1, a2, or a3 are finished, the holistic&#xA;MetaValidators (evaluating the total result of the 'regular' (a1, a2 and a3) validators)&#xA;will be run...&#xA;&#xA;Situations a2 and a3 are not mutually exclusive and can be triggered within one \`validate()\`&#xA;call. Situation b will occur after every call. | `{ clearCurrentResult = false }, opts: { clearCurrentResult?: boolean }`                                       |                             | ValidateMixin          |
-| `_autoSelectCondition`                   | protected | When this condition is false, an end user will have to manually select a suggested&#xA;option from the list (by default when autocomplete is 'none' or 'list').&#xA;For autocomplete 'both' or 'inline', it will automatically select on a match.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |                                                                                                                |                             |                        |
-| `_checkSingleChoiceElements`             | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: CustomEvent & {target:FormControl}`                                                                       |                             | ChoiceGroupMixin       |
-| `_completeRegistration`                  | protected | Resolves the registrationComplete promise. Subclassers can delay if needed                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |                                                                                                                |                             | FormRegistrarMixin     |
-| `_defineOverlayConfig`                   | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             |                        |
-| `_dispatchInitialModelValueChangedEvent` | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | FormControlMixin       |
-| `_enhanceLightDomA11y`                   | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | FormControlMixin       |
-| `_enhanceLightDomA11yForAdditionalSlots` | protected | Enhances additional slots(prefix, suffix, before, after) defined by developer.&#xA;&#xA;When boolean attribute data-label or data-description is found,&#xA;the slot element will be connected to the input via aria-labelledby or aria-describedby                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `additionalSlots: string[]`                                                                                    |                             | FormControlMixin       |
-| `_enhanceLightDomClasses`                | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | FormControlMixin       |
-| `_feedbackTemplate`                      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`            | FormControlMixin       |
-| `_getAriaDescriptionElements`            | protected | This function exposes descripion elements that a FormGroup should expose to its&#xA;children. See FormGroupMixin.\_\_getAllDescriptionElementsInParentChain()                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |                                                                                                                | `Array.<HTMLElement>`       | FormControlMixin       |
-| `_getCheckedElements`                    | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | ChoiceGroupMixin       |
-| `_getFromAllFormElements`                | protected | Implicit :(                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `property: string, filterFn: (el: FormControl, property?: string) => boolean`                                  | `{[name:string]: any}`      | ChoiceGroupMixin       |
-| `_getFromAllFormElementsFilter`          | protected | A filter function which will exclude a form field when returning false&#xA;By default, exclude form fields which are disabled&#xA;&#xA;The type is be passed as well for more fine grained control, e.g.&#xA;distinguish the filter when fetching modelValue versus serializedValue                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `el: FormControl, type: string`                                                                                | `boolean`                   | ChoiceGroupMixin       |
-| `_getNextEnabledOption`                  | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `currentIndex: number, offset: number`                                                                         |                             | ListboxMixin           |
-| `_getPreviousEnabledOption`              | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `currentIndex: number, offset: number`                                                                         |                             | ListboxMixin           |
-| `_getTextboxValueFromOption`             | protected | Return the value to be used for the input value                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `option: LionOption`                                                                                           | `string`                    |                        |
-| `_groupOneTemplate`                      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`            | FormControlMixin       |
-| `_groupTwoTemplate`                      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`            | FormControlMixin       |
-| `_handleAutocompletion`                  | protected | Handles autocompletion. This entails:&#xA;- list: shows a list on keydown character press&#xA;- filter: filters list of potential matches according to matchmode or provided matchCondition&#xA;- focus: automatically focuses closest match (makes it the activedescendant)&#xA;- check: automatically checks/selects closest match when selection-follows-focus is enabled&#xA;(this is the default configuration)&#xA;- complete: completes the textbox value inline (the 'missing characters' will be added as&#xA;selected text)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |                                                                                                                |                             |                        |
-| `_handleTypeAhead`                       | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: KeyboardEvent, { setAsChecked }, options: {setAsChecked:boolean}`                                         |                             | ListboxMixin           |
-| `_hasFeedbackVisibleFor`                 | protected | Used to translate \`.hasFeedbackFor\` and \`.shouldShowFeedbackFor\` to \`.showsFeedbackFor\`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `type: string`                                                                                                 |                             | ValidateMixin          |
-| `_helpTextTemplate`                      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`            | FormControlMixin       |
-| `_highlightMatchedOption`                | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `option: Element, matchingString: string`                                                                      |                             |                        |
-| `_inputGroupAfterTemplate`               | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`            | FormControlMixin       |
-| `_inputGroupBeforeTemplate`              | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`            | FormControlMixin       |
-| `_inputGroupInputTemplate`               | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`            | FormControlMixin       |
-| `_inputGroupPrefixTemplate`              | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult \| nothing` | FormControlMixin       |
-| `_inputGroupSuffixTemplate`              | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult \| nothing` | FormControlMixin       |
-| `_inputGroupTemplate`                    | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`            | FormControlMixin       |
-| `_isEmpty`                               | protected | Used for Required validation and computation of interaction states                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `modelValue: any`                                                                                              | `boolean`                   | FormControlMixin       |
-| `_iStateOnLeave`                         | protected | Sets touched value to true and reevaluates prefilled state.&#xA;When false, on next interaction, user will start with a clean state.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |                                                                                                                |                             | InteractionStateMixin  |
-| `_iStateOnValueChange`                   | protected | Sets dirty value and validates when already touched or invalid                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                                                                                                                |                             | InteractionStateMixin  |
-| `_labelTemplate`                         | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                | `TemplateResult`            | FormControlMixin       |
-| `_listboxOnClick`                        | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: MouseEvent`                                                                                               |                             | ListboxMixin           |
-| `_listboxOnKeyDown`                      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: KeyboardEvent`                                                                                            |                             | ListboxMixin           |
-| `_listboxOnKeyUp`                        | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: KeyboardEvent`                                                                                            |                             | ListboxMixin           |
-| `_onBeforeRepropagateChildrenValues`     | protected | Hook for Subclassers to add logic before repropagation                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `ev: CustomEvent`                                                                                              |                             | FormControlMixin       |
-| `_onChildActiveChanged`                  | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `{ target }, ev: Event & { target: LionOption }`                                                               |                             | ListboxMixin           |
-| `_onDirtyChanged`                        | protected | Dispatches event on touched state change                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |                                                                                                                |                             | InteractionStateMixin  |
-| `_onFilterMatch`                         | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `option: LionOption & {__originalInnerHTML?:string}, matchingString: string`                                   |                             |                        |
-| `_onFilterUnmatch`                       | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `option: LionOption & {__originalInnerHTML?:string}, curValue: string, prevValue: string`                      |                             |                        |
-| `_onKeyUp`                               | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: KeyboardEvent`                                                                                            |                             |                        |
-| `_onLabelClick`                          | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | FormControlMixin       |
-| `_onListboxContentChanged`               | protected | A Subclasser can perform additional logic whenever the elements inside the listbox are&#xA;updated. For instance, when a combobox does server side autocomplete, we want to&#xA;match highlighted parts client side.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |                                                                                                                |                             | ListboxMixin           |
-| `_onRequestToAddFormElement`             | protected | Hook for Subclassers to perform logic before an element is added                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `ev: CustomEvent`                                                                                              |                             | FormRegistrarMixin     |
-| `_onRequestToChangeFormElementName`      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: CustomEvent`                                                                                              |                             | FormRegistrarMixin     |
-| `_onRequestToRemoveFormElement`          | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: CustomEvent`                                                                                              |                             | FormRegistrarMixin     |
-| `_onTouchedChanged`                      | protected | Dispatches event on touched state change                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |                                                                                                                |                             | InteractionStateMixin  |
-| `_onValidatorUpdated`                    | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `e: Event\|CustomEvent`                                                                                        |                             | ValidateMixin          |
-| `_overlayListboxTemplate`                | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             |                        |
-| `_prioritizeAndFilterFeedback`           | protected | Orders all active validators in this.\_\_validationResult.&#xA;Can also filter out occurrences (based on interaction states)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `{ validationResult }, opts: { validationResult: Validator[] }`                                                | `Validator[]`               | ValidateMixin          |
-| `_repropagationCondition`                | protected | Based on provided target, this condition determines whether received model-value-changed&#xA;event should be repropagated                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `target: FormControlHost`                                                                                      |                             | FormControlMixin       |
-| `_resetListboxOptions`                   | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             |                        |
-| `_scrollIntoView`                        | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `el: HTMLElement, scrollTargetEl: HTMLElement`                                                                 |                             | ListboxMixin           |
-| `_setCheckedElements`                    | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `value: string \| any[], check: Function`                                                                      |                             | ChoiceGroupMixin       |
-| `_setTextboxValue`                       | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `v: string`                                                                                                    |                             |                        |
-| `_setupListboxNode`                      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | ListboxMixin           |
-| `_setupOpenCloseListeners`               | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             |                        |
-| `_setupOverlayCtrl`                      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             |                        |
-| `_showFeedbackConditionFor`              | protected | Default feedbackCondition condition, used by Subclassers, that will be used when&#xA;\`feedbackCondition()\` is not overridden by Application Developer.&#xA;Show the validity feedback when returning true, don't show when false                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `type: string, meta: InteractionStates`                                                                        |                             | ValidateMixin          |
-| `_showOverlayCondition`                  | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `{ lastKey }, options: { currentValue?: string, lastKey?: string }`                                            | `boolean`                   |                        |
-| `_syncToTextboxCondition`                | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `modelValue: string\|string[], oldModelValue: string\|string[], { phase }, config: {phase?:string}`            |                             |                        |
-| `_syncToTextboxMultiple`                 | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `modelValue: string[], oldModelValue: string[]`                                                                |                             |                        |
-| `_teardownListboxNode`                   | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | ListboxMixin           |
-| `_teardownOpenCloseListeners`            | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             |                        |
-| `_teardownOverlayCtrl`                   | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             |                        |
-| `_textboxOnClick`                        | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: FocusEvent`                                                                                               |                             |                        |
-| `_textboxOnInput`                        | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: Event`                                                                                                    |                             |                        |
-| `_textboxOnKeydown`                      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `ev: KeyboardEvent`                                                                                            |                             |                        |
-| `_throwWhenInvalidChildModelValue`       | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `child: FormControl`                                                                                           |                             | ChoiceGroupMixin       |
-| `_triggerInitialModelValueChangedEvent`  | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | FormControlMixin       |
-| `_uncheckChildren`                       | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `exclude: LionOption\|LionOption[]`                                                                            |                             | ListboxMixin           |
-| `_unhighlightMatchedOption`              | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `option: Element`                                                                                              |                             |                        |
-| `_updateFeedbackComponent`               | protected | Responsible for retrieving messages from Validators and&#xA;(delegation of) rendering them.&#xA;&#xA;For \`.\_feedbackNode\` (extension of LionValidationFeedback):&#xA;- retrieve messages from highest prio Validators&#xA;- provide the result to custom feedback node and let the&#xA;custom node decide on their renderings&#xA;&#xA;In both cases:&#xA;- we compute the 'show' flag (like 'hasErrorVisible') for all types&#xA;- we set the customValidity message of the highest prio Validator&#xA;- we set aria-invalid="true" in case hasErrorVisible is true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |                                                                                                                |                             | ValidateMixin          |
-| `_updateShouldShowFeedbackFor`           | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                             | ValidateMixin          |
+| Name                               | Privacy   | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | Parameters                                                                                                   | Return              | Inherited From |
+| ---------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------ | ------------------- | -------------- |
+| `clear`                            | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |                                                                                                              |                     |                |
+| `close`                            | public    | Hides the overlay                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |                                                                                                              |                     | OverlayMixin   |
+| `matchCondition`                   | public    | When the preconfigurable \`match-mode\` conditions are not sufficient,&#xA;one can define a custom matching function.                                                                                                                                                                                                                                                                                                                                                                                                                 | `option: LionOption, textboxValue: string`                                                                   |                     |                |
+| `open`                             | public    | Shows the overlay                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |                                                                                                              |                     | OverlayMixin   |
+| `parser`                           | public    | Converts viewValue to modelValue                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `value: string\|string[]`                                                                                    | `*`                 |                |
+| `repositionOverlay`                | public    | Sometimes it's needed to recompute Popper position of an overlay, for instance when we have&#xA;an opened combobox and the surrounding context changes (the space consumed by the textbox&#xA;increases vertically)                                                                                                                                                                                                                                                                                                                   |                                                                                                              |                     | OverlayMixin   |
+| `reset`                            | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |                                                                                                              |                     |                |
+| `toggle`                           | public    | Toggles the overlay                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                              |                     | OverlayMixin   |
+| `_autoSelectCondition`             | protected | When this condition is false, an end user will have to manually select a suggested&#xA;option from the list (by default when autocomplete is 'none' or 'list').&#xA;For autocomplete 'both' or 'inline', it will automatically select on a match.                                                                                                                                                                                                                                                                                     |                                                                                                              |                     |                |
+| `_defineOverlay`                   | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `{ contentNode, invokerNode, referenceNode, backdropNode, contentWrapperNode }, config: DefineOverlayConfig` | `OverlayController` | OverlayMixin   |
+| `_defineOverlayConfig`             | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |                                                                                                              | `OverlayConfig`     | OverlayMixin   |
+| `_enhanceLightDomClasses`          | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |                                                                                                              |                     |                |
+| `_getInvokerNode`                  | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |                                                                                                              | `Element\|null`     | OverlayMixin   |
+| `_getTextboxValueFromOption`       | protected | Return the value to be used for the input value                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `option: LionOption`                                                                                         | `string`            |                |
+| `_groupTwoTemplate`                | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |                                                                                                              |                     |                |
+| `_handleAutocompletion`            | protected | Handles autocompletion. This entails:&#xA;- list: shows a list on keydown character press&#xA;- filter: filters list of potential matches according to matchmode or provided matchCondition&#xA;- focus: automatically focuses closest match (makes it the activedescendant)&#xA;- check: automatically checks/selects closest match when selection-follows-focus is enabled&#xA;(this is the default configuration)&#xA;- complete: completes the textbox value inline (the 'missing characters' will be added as&#xA;selected text) |                                                                                                              |                     |                |
+| `_highlightMatchedOption`          | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `option: Element, matchingString: string`                                                                    |                     |                |
+| `_inputGroupInputTemplate`         | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |                                                                                                              |                     |                |
+| `_isPermanentlyDisconnected`       | protected | When we're moving around in dom, disconnectedCallback gets called.&#xA;Before we decide to teardown, let's wait to see if we were not just moving nodes around.                                                                                                                                                                                                                                                                                                                                                                       |                                                                                                              | `Promise<boolean>`  | OverlayMixin   |
+| `_listboxOnClick`                  | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `ev: MouseEvent`                                                                                             |                     |                |
+| `_listboxOnKeyDown`                | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `ev: KeyboardEvent`                                                                                          |                     |                |
+| `_onFilterMatch`                   | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `option: LionOption & {__originalInnerHTML?:string}, matchingString: string`                                 |                     |                |
+| `_onFilterUnmatch`                 | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `option: LionOption & {__originalInnerHTML?:string}, curValue: string, prevValue: string`                    |                     |                |
+| `_onKeyUp`                         | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `ev: KeyboardEvent`                                                                                          |                     |                |
+| `_onListboxContentChanged`         | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |                                                                                                              |                     |                |
+| `_overlayListboxTemplate`          | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |                                                                                                              |                     |                |
+| `_repropagationCondition`          | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `target: FormControlHost`                                                                                    |                     |                |
+| `_resetListboxOptions`             | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |                                                                                                              |                     |                |
+| `_setOpenedWithoutPropertyEffects` | protected | When the opened state is changed by an Application Developer,cthe OverlayController is&#xA;requested to show/hide. It might happen that this request is not honoured&#xA;(intercepted in before-hide for instance), so that we need to sync the controller state&#xA;to this webcomponent again, preventing eternal loops.                                                                                                                                                                                                            | `newOpened: boolean`                                                                                         |                     | OverlayMixin   |
+| `_setTextboxValue`                 | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `v: string`                                                                                                  |                     |                |
+| `_setupListboxNode`                | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |                                                                                                              |                     |                |
+| `_setupOpenCloseListeners`         | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |                                                                                                              |                     | OverlayMixin   |
+| `_setupOverlayCtrl`                | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |                                                                                                              |                     | OverlayMixin   |
+| `_showOverlayCondition`            | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `{ lastKey }, options: { currentValue?: string, lastKey?: string }`                                          | `boolean`           |                |
+| `_syncToTextboxCondition`          | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `modelValue: string\|string[], oldModelValue: string\|string[], { phase }, config: {phase?:string}`          |                     |                |
+| `_syncToTextboxMultiple`           | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `modelValue: string[], oldModelValue: string[]`                                                              |                     |                |
+| `_teardownOpenCloseListeners`      | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |                                                                                                              |                     | OverlayMixin   |
+| `_teardownOverlayCtrl`             | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |                                                                                                              |                     | OverlayMixin   |
+| `_textboxOnClick`                  | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `ev: FocusEvent`                                                                                             |                     |                |
+| `_textboxOnInput`                  | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `ev: Event`                                                                                                  |                     |                |
+| `_textboxOnKeydown`                | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `ev: KeyboardEvent`                                                                                          |                     |                |
+| `_unhighlightMatchedOption`        | protected |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `option: Element`                                                                                            |                     |                |
 
 ### Events
 
-| Name                           | Type          | Description                                              | Inherited From        |
-| ------------------------------ | ------------- | -------------------------------------------------------- | --------------------- |
-| `model-value-changed`          | `CustomEvent` |                                                          | FormControlMixin      |
-| `form-element-name-changed`    | `CustomEvent` |                                                          | FormControlMixin      |
-| `focus`                        | `Event`       |                                                          | FocusMixin            |
-| `blur`                         | `Event`       |                                                          | FocusMixin            |
-| `focusin`                      | `Event`       |                                                          | FocusMixin            |
-| `focusout`                     | `Event`       |                                                          | FocusMixin            |
-| `touched-changed`              | `Event`       |                                                          | InteractionStateMixin |
-| `dirty-changed`                | `Event`       |                                                          | InteractionStateMixin |
-| `showsFeedbackForChanged`      | `Event`       |                                                          | ValidateMixin         |
-|                                | `Event`       |                                                          | ValidateMixin         |
-| `shouldShowFeedbackForChanged` | `Event`       |                                                          | ValidateMixin         |
-| `validate-performed`           | `Event`       | private event that should be listened to by LionFieldSet | ValidateMixin         |
+| Name                  | Type          | Description | Inherited From |
+| --------------------- | ------------- | ----------- | -------------- |
+| `model-value-changed` | `CustomEvent` |             |                |
+| `opened-changed`      | `CustomEvent` |             | OverlayMixin   |
 
 ### Attributes
 
-| Name                             | Field                            | Inherited From         |
-| -------------------------------- | -------------------------------- | ---------------------- |
-| `autocomplete`                   | autocomplete                     |                        |
-| `match-mode`                     | matchMode                        |                        |
-| `show-all-on-empty`              | showAllOnEmpty                   |                        |
-| `requireOptionMatch`             | requireOptionMatch               |                        |
-| `allow-custom-choice`            | allowCustomChoice                | CustomChoiceGroupMixin |
-| `__shouldAutocompleteNextUpdate` | \_\_shouldAutocompleteNextUpdate |                        |
-| `modelValue`                     | modelValue                       | CustomChoiceGroupMixin |
-| `multiple-choice`                | multipleChoice                   | ChoiceGroupMixin       |
-| `orientation`                    | orientation                      | ListboxMixin           |
-| `selection-follows-focus`        | selectionFollowsFocus            | ListboxMixin           |
-| `rotate-keyboard-navigation`     | rotateKeyboardNavigation         | ListboxMixin           |
-| `has-no-default-selected`        | hasNoDefaultSelected             | ListboxMixin           |
-| `_noTypeAhead`                   | \_noTypeAhead                    | ListboxMixin           |
-| `readonly`                       | readOnly                         | FormControlMixin       |
-| `label`                          | label                            | FormControlMixin       |
-| `label-sr-only`                  | labelSrOnly                      | FormControlMixin       |
-| `help-text`                      | helpText                         | FormControlMixin       |
-| `_isFormOrFieldset`              | \_isFormOrFieldset               | FormRegistrarMixin     |
-| `focused`                        | focused                          | FocusMixin             |
-| `focused-visible`                | focusedVisible                   | FocusMixin             |
-| `autofocus`                      | autofocus                        | FocusMixin             |
-| `touched`                        | touched                          | InteractionStateMixin  |
-| `dirty`                          | dirty                            | InteractionStateMixin  |
-| `filled`                         | filled                           | InteractionStateMixin  |
-| `shows-feedback-for`             | showsFeedbackFor                 | ValidateMixin          |
-| `is-pending`                     | isPending                        | ValidateMixin          |
-| `disabled`                       | disabled                         | DisabledMixin          |
+| Name                             | Field                            | Inherited From |
+| -------------------------------- | -------------------------------- | -------------- |
+| `autocomplete`                   | autocomplete                     |                |
+| `match-mode`                     | matchMode                        |                |
+| `show-all-on-empty`              | showAllOnEmpty                   |                |
+| `requireOptionMatch`             | requireOptionMatch               |                |
+| `allow-custom-choice`            | allowCustomChoice                |                |
+| `__shouldAutocompleteNextUpdate` | \_\_shouldAutocompleteNextUpdate |                |
+| `opened`                         | opened                           | OverlayMixin   |
 
 ### Slots