@sbb-esta/lyne-elements 0.0.0 → 0.52.0

package/development/radio-button/radio-button.js

@@ -0,0 +1,398 @@
+import { css, LitElement, html, nothing } from "lit";
+import { property, state, customElement } from "lit/decorators.js";
+import { SbbConnectedAbortController, SbbLanguageController, SbbSlotStateController } from "../core/controllers.js";
+import { hostAttributes } from "../core/decorators.js";
+import { setOrRemoveAttribute } from "../core/dom.js";
+import { EventEmitter, HandlerRepository, formElementHandlerAspect } from "../core/eventing.js";
+import { i18nExpanded, i18nCollapsed } from "../core/i18n.js";
+import { SbbUpdateSchedulerMixin } from "../core/mixins.js";
+const style = css`/**
+ * Better font rendering (on OS X)
+ * http://maximilianhoffmann.com/posts/better-font-rendering-on-osx
+ *
+ * Usage:
+ *
+ * .var_dark_on_light {
+ * 	@include font-smoothing;
+ * }
+ * .var_light_on_dark {
+ * 	@include font-smoothing-reset;
+ * }
+ */
+/** This mixin can be used to avoid spacing problems by inserting an invisible space as pseudo element. */
+*,
+::before,
+::after {
+  box-sizing: border-box;
+}
+
+:host {
+  --sbb-radio-button-label-color: var(--sbb-color-charcoal);
+  --sbb-radio-button-background-color: var(--sbb-color-white);
+  --sbb-radio-button-inner-circle-color: var(--sbb-color-white);
+  --sbb-radio-button-border-width: var(--sbb-border-width-1x);
+  --sbb-radio-button-border-style: solid;
+  --sbb-radio-button-border-color: var(--sbb-color-smoke);
+  --sbb-radio-button-dimension: var(--sbb-size-icon-ui-small);
+  --sbb-radio-button-inner-circle-dimension: 0.625rem;
+  --sbb-radio-button-suffix-color: var(--sbb-color-charcoal);
+  --sbb-radio-button-subtext-color: var(--sbb-color-granite);
+  --sbb-radio-button-cursor: pointer;
+  --sbb-radio-button-background-fake-border-width: calc(var(--sbb-radio-button-dimension) / 2);
+  --sbb-radio-button-icon-align: calc(
+    (1em * var(--sbb-typo-line-height-body-text) - var(--sbb-radio-button-dimension)) / 2
+  );
+  display: block;
+  outline: none !important;
+}
+@media (forced-colors: active) {
+  :host {
+    --sbb-radio-button-background-color: Canvas !important;
+    --sbb-radio-button-border-width: var(--sbb-border-width-2x);
+    --sbb-radio-button-border-color: ButtonBorder;
+  }
+}
+
+:host(:focus-visible[data-is-selection-panel-input]) {
+  outline: none !important;
+}
+:host(:focus-visible[data-is-selection-panel-input]) .sbb-radio-button::after {
+  content: "";
+  position: absolute;
+  display: block;
+  inset-block: calc(var(--sbb-spacing-responsive-xs) * -1 + var(--sbb-focus-outline-width) - var(--sbb-focus-outline-offset) * 2);
+  inset-inline: calc(var(--sbb-spacing-responsive-xxs) * -1 + var(--sbb-focus-outline-width) - var(--sbb-focus-outline-offset) * 2);
+  border: var(--sbb-focus-outline-color) solid var(--sbb-focus-outline-width);
+  border-radius: calc(var(--sbb-border-radius-4x) + var(--sbb-focus-outline-offset));
+}
+
+:host([checked]) {
+  --sbb-radio-button-inner-circle-color: var(--sbb-color-red);
+  --sbb-radio-button-background-fake-border-width: calc(
+    (var(--sbb-radio-button-dimension) - var(--sbb-radio-button-inner-circle-dimension)) / 2
+  );
+}
+@media (forced-colors: active) {
+  :host([checked]) {
+    --sbb-radio-button-inner-circle-color: Highlight;
+    --sbb-radio-button-border-color: Highlight;
+  }
+}
+
+:host([disabled]) {
+  --sbb-radio-button-label-color: var(--sbb-color-granite);
+  --sbb-radio-button-background-color: var(--sbb-color-milk);
+  --sbb-radio-button-border-style: dashed;
+  --sbb-radio-button-inner-circle-color: var(--sbb-color-charcoal);
+  --sbb-radio-button-cursor: default;
+}
+@media (forced-colors: active) {
+  :host([disabled]) {
+    --sbb-radio-button-inner-circle-color: GrayText;
+    --sbb-radio-button-border-color: GrayText;
+    --sbb-radio-button-border-style: solid;
+  }
+}
+
+.sbb-radio-button {
+  --sbb-text-font-size: var(--sbb-font-size-text-m);
+  font-family: var(--sbb-typo-font-family);
+  font-weight: normal;
+  line-height: var(--sbb-typo-line-height-body-text);
+  letter-spacing: var(--sbb-typo-letter-spacing-body-text);
+  font-size: var(--sbb-text-font-size);
+  display: block;
+  cursor: var(--sbb-radio-button-cursor);
+  user-select: none;
+  position: relative;
+  color: var(--sbb-radio-button-label-color);
+  -webkit-tap-highlight-color: transparent;
+}
+:host([size=s]) .sbb-radio-button {
+  --sbb-text-font-size: var(--sbb-font-size-text-s);
+  font-family: var(--sbb-typo-font-family);
+  font-weight: normal;
+  line-height: var(--sbb-typo-line-height-body-text);
+  letter-spacing: var(--sbb-typo-letter-spacing-body-text);
+  font-size: var(--sbb-text-font-size);
+}
+:host(:focus-visible:not([data-focus-origin=mouse],
+[data-focus-origin=touch],
+[data-is-selection-panel-input])) .sbb-radio-button {
+  outline-offset: var(--sbb-focus-outline-offset);
+  outline: var(--sbb-focus-outline-color) solid var(--sbb-focus-outline-width);
+  border-radius: calc(var(--sbb-border-radius-4x) - var(--sbb-focus-outline-offset));
+}
+
+slot[name=suffix] {
+  color: var(--sbb-radio-button-suffix-color);
+}
+
+slot[name=subtext] {
+  display: block;
+  color: var(--sbb-radio-button-subtext-color);
+  padding-inline-start: var(--sbb-spacing-fixed-8x);
+}
+:host(:not([data-slot-names~=subtext])) slot[name=subtext] {
+  display: none;
+}
+
+.sbb-radio-button__label-slot {
+  display: flex;
+  align-items: flex-start;
+  overflow: hidden;
+}
+.sbb-radio-button__label-slot::before, .sbb-radio-button__label-slot::after {
+  content: "";
+  flex-shrink: 0;
+  width: var(--sbb-radio-button-dimension);
+  height: var(--sbb-radio-button-dimension);
+  border-radius: 50%;
+  margin-block-start: var(--sbb-radio-button-icon-align);
+  transition-duration: var(--sbb-disable-animation-zero-time, var(--sbb-animation-duration-4x));
+  transition-timing-function: ease;
+  transition-property: background-color, border;
+}
+@media (forced-colors: active) {
+  .sbb-radio-button__label-slot::before, .sbb-radio-button__label-slot::after {
+    transition: none;
+  }
+}
+.sbb-radio-button__label-slot::before {
+  background: var(--sbb-radio-button-inner-circle-color);
+  border: var(--sbb-radio-button-background-fake-border-width) solid var(--sbb-radio-button-background-color);
+  margin-inline-end: var(--sbb-spacing-fixed-2x);
+}
+.sbb-radio-button__label-slot::after {
+  position: absolute;
+  border: var(--sbb-radio-button-border-width) var(--sbb-radio-button-border-style) var(--sbb-radio-button-border-color);
+}
+
+.sbb-screen-reader-only {
+  border: 0;
+  clip: rect(0 0 0 0);
+  height: 1px;
+  margin: -1px;
+  overflow: hidden;
+  padding: 0;
+  position: absolute;
+  white-space: nowrap;
+  width: 1px;
+}`;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+let SbbRadioButtonElement = class extends SbbUpdateSchedulerMixin(LitElement) {
+  constructor() {
+    super();
+    this._allowEmptySelection = false;
+    this._disabled = false;
+    this._required = false;
+    this._group = null;
+    this._checked = false;
+    this._size = "m";
+    this._isSelectionPanelInput = false;
+    this._selectionPanelElement = null;
+    this._abort = new SbbConnectedAbortController(this);
+    this._language = new SbbLanguageController(this);
+    this._stateChange = new EventEmitter(
+      this,
+      SbbRadioButtonElement.events.stateChange,
+      { bubbles: true }
+    );
+    this._radioButtonLoaded = new EventEmitter(
+      this,
+      SbbRadioButtonElement.events.radioButtonLoaded,
+      { bubbles: true }
+    );
+    this._handlerRepository = new HandlerRepository(this, formElementHandlerAspect);
+    new SbbSlotStateController(this);
+  }
+  set allowEmptySelection(value) {
+    this._allowEmptySelection = Boolean(value);
+  }
+  get allowEmptySelection() {
+    var _a;
+    return this._allowEmptySelection || (((_a = this.group) == null ? void 0 : _a.allowEmptySelection) ?? false);
+  }
+  set disabled(value) {
+    this._disabled = Boolean(value);
+  }
+  get disabled() {
+    var _a;
+    return this._disabled || (((_a = this.group) == null ? void 0 : _a.disabled) ?? false);
+  }
+  set required(value) {
+    this._required = Boolean(value);
+  }
+  get required() {
+    var _a;
+    return this._required || (((_a = this.group) == null ? void 0 : _a.required) ?? false);
+  }
+  /**
+   * Reference to the connected radio button group.
+   */
+  get group() {
+    return this._group;
+  }
+  set checked(value) {
+    this._checked = Boolean(value);
+  }
+  get checked() {
+    return this._checked;
+  }
+  set size(value) {
+    this._size = value;
+  }
+  get size() {
+    var _a;
+    return ((_a = this.group) == null ? void 0 : _a.size) ?? this._size;
+  }
+  /**
+   * Whether the input is the main input of a selection panel.
+   * @internal
+   */
+  get isSelectionPanelInput() {
+    return this._isSelectionPanelInput;
+  }
+  _handleClick(event) {
+    event.preventDefault();
+    this.select();
+  }
+  select() {
+    if (this.disabled) {
+      return;
+    }
+    if (this.allowEmptySelection) {
+      this.checked = !this.checked;
+    } else if (!this.checked) {
+      this.checked = true;
+    }
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this._group = this.closest("sbb-radio-button-group");
+    this._selectionPanelElement = this.closest("sbb-selection-panel");
+    this._isSelectionPanelInput = !!this._selectionPanelElement && !this.closest('sbb-selection-panel [slot="content"]');
+    this.toggleAttribute("data-is-selection-panel-input", this._isSelectionPanelInput);
+    const signal = this._abort.signal;
+    this.addEventListener("click", (e) => this._handleClick(e), { signal });
+    this.addEventListener("keydown", (e) => this._handleKeyDown(e), { signal });
+    this._handlerRepository.connect();
+    this._radioButtonLoaded.emit();
+    ["disabled", "required", "size"].forEach((p) => this.requestUpdate(p));
+  }
+  willUpdate(changedProperties) {
+    super.willUpdate(changedProperties);
+    if (changedProperties.has("checked")) {
+      this.setAttribute("aria-checked", `${this.checked}`);
+      if (this.checked !== changedProperties.get("checked")) {
+        this._stateChange.emit({ type: "checked", checked: this.checked });
+        this.isSelectionPanelInput && this._updateExpandedLabel();
+      }
+    }
+    if (changedProperties.has("disabled")) {
+      setOrRemoveAttribute(this, "aria-disabled", this.disabled ? "true" : null);
+      if (this.disabled !== changedProperties.get("disabled")) {
+        this._stateChange.emit({ type: "disabled", disabled: this.disabled });
+      }
+    }
+    if (changedProperties.has("required")) {
+      this.setAttribute("aria-required", `${this.required}`);
+    }
+  }
+  firstUpdated(changedProperties) {
+    super.firstUpdated(changedProperties);
+    this.startUpdate();
+    setTimeout(() => {
+      this.isSelectionPanelInput && this._updateExpandedLabel();
+      this.completeUpdate();
+    });
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this._handlerRepository.disconnect();
+  }
+  _handleKeyDown(evt) {
+    if (evt.code === "Space") {
+      this.select();
+    }
+  }
+  _updateExpandedLabel() {
+    var _a;
+    if (!((_a = this._selectionPanelElement) == null ? void 0 : _a.hasContent)) {
+      this._selectionPanelExpandedLabel = "";
+      return;
+    }
+    this._selectionPanelExpandedLabel = this.checked ? ", " + i18nExpanded[this._language.current] : ", " + i18nCollapsed[this._language.current];
+  }
+  render() {
+    return html`
+      <label class="sbb-radio-button">
+        <input
+          type="radio"
+          aria-hidden="true"
+          tabindex="-1"
+          ?disabled=${this.disabled}
+          ?required=${this.required}
+          ?checked=${this.checked}
+          value=${this.value || nothing}
+          class="sbb-screen-reader-only"
+        />
+        <span class="sbb-radio-button__label-slot">
+          <slot></slot>
+          ${this._selectionPanelElement ? html`<slot name="suffix"></slot>` : nothing}
+        </span>
+        ${this._selectionPanelElement ? html`<slot name="subtext"></slot>` : nothing}
+        ${this.isSelectionPanelInput && this._selectionPanelExpandedLabel ? html`<span class="sbb-screen-reader-only"> ${this._selectionPanelExpandedLabel} </span>` : nothing}
+      </label>
+    `;
+  }
+};
+SbbRadioButtonElement.styles = style;
+SbbRadioButtonElement.events = {
+  stateChange: "stateChange",
+  radioButtonLoaded: "radioButtonLoaded"
+};
+__decorateClass([
+  property({ attribute: "allow-empty-selection", type: Boolean })
+], SbbRadioButtonElement.prototype, "allowEmptySelection", 1);
+__decorateClass([
+  property()
+], SbbRadioButtonElement.prototype, "value", 2);
+__decorateClass([
+  property({ reflect: true, type: Boolean })
+], SbbRadioButtonElement.prototype, "disabled", 1);
+__decorateClass([
+  property({ reflect: true, type: Boolean })
+], SbbRadioButtonElement.prototype, "required", 1);
+__decorateClass([
+  property({ reflect: true, type: Boolean })
+], SbbRadioButtonElement.prototype, "checked", 1);
+__decorateClass([
+  property({ reflect: true })
+], SbbRadioButtonElement.prototype, "size", 1);
+__decorateClass([
+  state()
+], SbbRadioButtonElement.prototype, "_isSelectionPanelInput", 2);
+__decorateClass([
+  state()
+], SbbRadioButtonElement.prototype, "_selectionPanelExpandedLabel", 2);
+SbbRadioButtonElement = __decorateClass([
+  customElement("sbb-radio-button"),
+  hostAttributes({
+    role: "radio"
+  })
+], SbbRadioButtonElement);
+export {
+  SbbRadioButtonElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"radio-button.js","sources":["../../../../src/elements/radio-button/radio-button/radio-button.ts"],"sourcesContent":["import type { CSSResultGroup, PropertyValues, TemplateResult } from 'lit';\nimport { html, LitElement, nothing } from 'lit';\nimport { customElement, property, state } from 'lit/decorators.js';\n\nimport {\n  SbbConnectedAbortController,\n  SbbLanguageController,\n  SbbSlotStateController,\n} from '../../core/controllers.js';\nimport { hostAttributes } from '../../core/decorators.js';\nimport { setOrRemoveAttribute } from '../../core/dom.js';\nimport { EventEmitter, formElementHandlerAspect, HandlerRepository } from '../../core/eventing.js';\nimport { i18nCollapsed, i18nExpanded } from '../../core/i18n.js';\nimport type {\n  SbbCheckedStateChange,\n  SbbDisabledStateChange,\n  SbbStateChange,\n} from '../../core/interfaces.js';\nimport { SbbUpdateSchedulerMixin } from '../../core/mixins.js';\nimport type { SbbSelectionPanelElement } from '../../selection-panel.js';\nimport type { SbbRadioButtonGroupElement } from '../radio-button-group.js';\n\nimport style from './radio-button.scss?lit&inline';\n\nexport type SbbRadioButtonStateChange = Extract<\n  SbbStateChange,\n  SbbDisabledStateChange | SbbCheckedStateChange\n>;\n\nexport type SbbRadioButtonSize = 's' | 'm';\n\n/**\n * It displays a radio button enhanced with the SBB Design.\n *\n * @slot - Use the unnamed slot to add content to the radio label.\n * @slot subtext - Slot used to render a subtext under the label (only visible within a `sbb-selection-panel`).\n * @slot suffix - Slot used to render additional content after the label (only visible within a `sbb-selection-panel`).\n */\n@customElement('sbb-radio-button')\n@hostAttributes({\n  role: 'radio',\n})\nexport class SbbRadioButtonElement extends SbbUpdateSchedulerMixin(LitElement) {\n  public static override styles: CSSResultGroup = style;\n  public static readonly events = {\n    stateChange: 'stateChange',\n    radioButtonLoaded: 'radioButtonLoaded',\n  } as const;\n\n  /**\n   * Whether the radio can be deselected.\n   */\n  @property({ attribute: 'allow-empty-selection', type: Boolean })\n  public set allowEmptySelection(value: boolean) {\n    this._allowEmptySelection = Boolean(value);\n  }\n  public get allowEmptySelection(): boolean {\n    return this._allowEmptySelection || (this.group?.allowEmptySelection ?? false);\n  }\n  private _allowEmptySelection = false;\n\n  /**\n   * Value of radio button.\n   */\n  @property() public value?: string;\n\n  /**\n   * Whether the radio button is disabled.\n   */\n  @property({ reflect: true, type: Boolean })\n  public set disabled(value: boolean) {\n    this._disabled = Boolean(value);\n  }\n  public get disabled(): boolean {\n    return this._disabled || (this.group?.disabled ?? false);\n  }\n  private _disabled = false;\n\n  /**\n   * Whether the radio button is required.\n   */\n  @property({ reflect: true, type: Boolean })\n  public set required(value: boolean) {\n    this._required = Boolean(value);\n  }\n  public get required(): boolean {\n    return this._required || (this.group?.required ?? false);\n  }\n  private _required = false;\n\n  /**\n   * Reference to the connected radio button group.\n   */\n  public get group(): SbbRadioButtonGroupElement | null {\n    return this._group;\n  }\n  private _group: SbbRadioButtonGroupElement | null = null;\n\n  /**\n   * Whether the radio button is checked.\n   */\n  @property({ reflect: true, type: Boolean })\n  public set checked(value: boolean) {\n    this._checked = Boolean(value);\n  }\n  public get checked(): boolean {\n    return this._checked;\n  }\n  private _checked = false;\n\n  /**\n   * Label size variant, either m or s.\n   */\n  @property({ reflect: true })\n  public set size(value: SbbRadioButtonSize) {\n    this._size = value;\n  }\n  public get size(): SbbRadioButtonSize {\n    return this.group?.size ?? this._size;\n  }\n  private _size: SbbRadioButtonSize = 'm';\n\n  /**\n   * Whether the input is the main input of a selection panel.\n   * @internal\n   */\n  public get isSelectionPanelInput(): boolean {\n    return this._isSelectionPanelInput;\n  }\n  @state() private _isSelectionPanelInput = false;\n\n  /**\n   * The label describing whether the selection panel is expanded (for screen readers only).\n   */\n  @state() private _selectionPanelExpandedLabel?: string;\n\n  private _selectionPanelElement: SbbSelectionPanelElement | null = null;\n  private _abort = new SbbConnectedAbortController(this);\n  private _language = new SbbLanguageController(this);\n\n  /**\n   * @internal\n   * Internal event that emits whenever the state of the radio option\n   * in relation to the parent selection panel changes.\n   */\n  private _stateChange: EventEmitter<SbbRadioButtonStateChange> = new EventEmitter(\n    this,\n    SbbRadioButtonElement.events.stateChange,\n    { bubbles: true },\n  );\n\n  /**\n   * @internal\n   * Internal event that emits when the radio button is loaded.\n   */\n  private _radioButtonLoaded: EventEmitter<void> = new EventEmitter(\n    this,\n    SbbRadioButtonElement.events.radioButtonLoaded,\n    { bubbles: true },\n  );\n  private _handleClick(event: Event): void {\n    event.preventDefault();\n    this.select();\n  }\n\n  public select(): void {\n    if (this.disabled) {\n      return;\n    }\n\n    if (this.allowEmptySelection) {\n      this.checked = !this.checked;\n    } else if (!this.checked) {\n      this.checked = true;\n    }\n  }\n\n  private _handlerRepository = new HandlerRepository(this, formElementHandlerAspect);\n\n  public constructor() {\n    super();\n    new SbbSlotStateController(this);\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n    this._group = this.closest('sbb-radio-button-group') as SbbRadioButtonGroupElement;\n    // We can use closest here, as we expect the parent sbb-selection-panel to be in light DOM.\n    this._selectionPanelElement = this.closest('sbb-selection-panel');\n    this._isSelectionPanelInput =\n      !!this._selectionPanelElement && !this.closest('sbb-selection-panel [slot=\"content\"]');\n    this.toggleAttribute('data-is-selection-panel-input', this._isSelectionPanelInput);\n\n    const signal = this._abort.signal;\n    this.addEventListener('click', (e) => this._handleClick(e), { signal });\n    this.addEventListener('keydown', (e) => this._handleKeyDown(e), { signal });\n    this._handlerRepository.connect();\n    this._radioButtonLoaded.emit();\n\n    // We need to call requestUpdate to update the reflected attributes\n    ['disabled', 'required', 'size'].forEach((p) => this.requestUpdate(p));\n  }\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    if (changedProperties.has('checked')) {\n      this.setAttribute('aria-checked', `${this.checked}`);\n      if (this.checked !== changedProperties.get('checked')!) {\n        this._stateChange.emit({ type: 'checked', checked: this.checked });\n        this.isSelectionPanelInput && this._updateExpandedLabel();\n      }\n    }\n    if (changedProperties.has('disabled')) {\n      setOrRemoveAttribute(this, 'aria-disabled', this.disabled ? 'true' : null);\n      if (this.disabled !== changedProperties.get('disabled')!) {\n        this._stateChange.emit({ type: 'disabled', disabled: this.disabled });\n      }\n    }\n    if (changedProperties.has('required')) {\n      this.setAttribute('aria-required', `${this.required}`);\n    }\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n\n    // We need to wait for the selection-panel to be fully initialized\n    this.startUpdate();\n    setTimeout(() => {\n      this.isSelectionPanelInput && this._updateExpandedLabel();\n      this.completeUpdate();\n    });\n  }\n\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    this._handlerRepository.disconnect();\n  }\n\n  private _handleKeyDown(evt: KeyboardEvent): void {\n    if (evt.code === 'Space') {\n      this.select();\n    }\n  }\n\n  private _updateExpandedLabel(): void {\n    if (!this._selectionPanelElement?.hasContent) {\n      this._selectionPanelExpandedLabel = '';\n      return;\n    }\n\n    this._selectionPanelExpandedLabel = this.checked\n      ? ', ' + i18nExpanded[this._language.current]\n      : ', ' + i18nCollapsed[this._language.current];\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <label class=\"sbb-radio-button\">\n        <input\n          type=\"radio\"\n          aria-hidden=\"true\"\n          tabindex=\"-1\"\n          ?disabled=${this.disabled}\n          ?required=${this.required}\n          ?checked=${this.checked}\n          value=${this.value || nothing}\n          class=\"sbb-screen-reader-only\"\n        />\n        <span class=\"sbb-radio-button__label-slot\">\n          <slot></slot>\n          ${this._selectionPanelElement ? html`<slot name=\"suffix\"></slot>` : nothing}\n        </span>\n        ${this._selectionPanelElement ? html`<slot name=\"subtext\"></slot>` : nothing}\n        ${this.isSelectionPanelInput && this._selectionPanelExpandedLabel\n          ? html`<span class=\"sbb-screen-reader-only\"> ${this._selectionPanelExpandedLabel} </span>`\n          : nothing}\n      </label>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-radio-button': SbbRadioButtonElement;\n  }\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CO,IAAM,wBAAN,cAAoC,wBAAwB,UAAU,EAAE;AAAA,EAyItE,cAAc;AACb;AAzHR,SAAQ,uBAAuB;AAiB/B,SAAQ,YAAY;AAYpB,SAAQ,YAAY;AAQpB,SAAQ,SAA4C;AAYpD,SAAQ,WAAW;AAYnB,SAAQ,QAA4B;AAS3B,SAAQ,yBAAyB;AAO1C,SAAQ,yBAA0D;AAC1D,SAAA,SAAS,IAAI,4BAA4B,IAAI;AAC7C,SAAA,YAAY,IAAI,sBAAsB,IAAI;AAOlD,SAAQ,eAAwD,IAAI;AAAA,MAClE;AAAA,MACA,sBAAsB,OAAO;AAAA,MAC7B,EAAE,SAAS,KAAK;AAAA,IAAA;AAOlB,SAAQ,qBAAyC,IAAI;AAAA,MACnD;AAAA,MACA,sBAAsB,OAAO;AAAA,MAC7B,EAAE,SAAS,KAAK;AAAA,IAAA;AAmBlB,SAAQ,qBAAqB,IAAI,kBAAkB,MAAM,wBAAwB;AAI/E,QAAI,uBAAuB,IAAI;AAAA,EACjC;AAAA,EAjIA,IAAW,oBAAoB,OAAgB;AACxC,SAAA,uBAAuB,QAAQ,KAAK;AAAA,EAC3C;AAAA,EACA,IAAW,sBAA+B;;AACxC,WAAO,KAAK,2BAAyB,UAAK,UAAL,mBAAY,wBAAuB;AAAA,EAC1E;AAAA,EAYA,IAAW,SAAS,OAAgB;AAC7B,SAAA,YAAY,QAAQ,KAAK;AAAA,EAChC;AAAA,EACA,IAAW,WAAoB;;AAC7B,WAAO,KAAK,gBAAc,UAAK,UAAL,mBAAY,aAAY;AAAA,EACpD;AAAA,EAOA,IAAW,SAAS,OAAgB;AAC7B,SAAA,YAAY,QAAQ,KAAK;AAAA,EAChC;AAAA,EACA,IAAW,WAAoB;;AAC7B,WAAO,KAAK,gBAAc,UAAK,UAAL,mBAAY,aAAY;AAAA,EACpD;AAAA;AAAA;AAAA;AAAA,EAMA,IAAW,QAA2C;AACpD,WAAO,KAAK;AAAA,EACd;AAAA,EAOA,IAAW,QAAQ,OAAgB;AAC5B,SAAA,WAAW,QAAQ,KAAK;AAAA,EAC/B;AAAA,EACA,IAAW,UAAmB;AAC5B,WAAO,KAAK;AAAA,EACd;AAAA,EAOA,IAAW,KAAK,OAA2B;AACzC,SAAK,QAAQ;AAAA,EACf;AAAA,EACA,IAAW,OAA2B;;AAC7B,aAAA,UAAK,UAAL,mBAAY,SAAQ,KAAK;AAAA,EAClC;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,IAAW,wBAAiC;AAC1C,WAAO,KAAK;AAAA,EACd;AAAA,EAgCQ,aAAa,OAAoB;AACvC,UAAM,eAAe;AACrB,SAAK,OAAO;AAAA,EACd;AAAA,EAEO,SAAe;AACpB,QAAI,KAAK,UAAU;AACjB;AAAA,IACF;AAEA,QAAI,KAAK,qBAAqB;AACvB,WAAA,UAAU,CAAC,KAAK;AAAA,IAAA,WACZ,CAAC,KAAK,SAAS;AACxB,WAAK,UAAU;AAAA,IACjB;AAAA,EACF;AAAA,EASgB,oBAA0B;AACxC,UAAM,kBAAkB;AACnB,SAAA,SAAS,KAAK,QAAQ,wBAAwB;AAE9C,SAAA,yBAAyB,KAAK,QAAQ,qBAAqB;AAC3D,SAAA,yBACH,CAAC,CAAC,KAAK,0BAA0B,CAAC,KAAK,QAAQ,sCAAsC;AAClF,SAAA,gBAAgB,iCAAiC,KAAK,sBAAsB;AAE3E,UAAA,SAAS,KAAK,OAAO;AACtB,SAAA,iBAAiB,SAAS,CAAC,MAAM,KAAK,aAAa,CAAC,GAAG,EAAE,OAAA,CAAQ;AACjE,SAAA,iBAAiB,WAAW,CAAC,MAAM,KAAK,eAAe,CAAC,GAAG,EAAE,OAAA,CAAQ;AAC1E,SAAK,mBAAmB;AACxB,SAAK,mBAAmB;AAGvB,KAAA,YAAY,YAAY,MAAM,EAAE,QAAQ,CAAC,MAAM,KAAK,cAAc,CAAC,CAAC;AAAA,EACvE;AAAA,EAEmB,WAAW,mBAA+C;AAC3E,UAAM,WAAW,iBAAiB;AAE9B,QAAA,kBAAkB,IAAI,SAAS,GAAG;AACpC,WAAK,aAAa,gBAAgB,GAAG,KAAK,OAAO,EAAE;AACnD,UAAI,KAAK,YAAY,kBAAkB,IAAI,SAAS,GAAI;AACjD,aAAA,aAAa,KAAK,EAAE,MAAM,WAAW,SAAS,KAAK,SAAS;AAC5D,aAAA,yBAAyB,KAAK;MACrC;AAAA,IACF;AACI,QAAA,kBAAkB,IAAI,UAAU,GAAG;AACrC,2BAAqB,MAAM,iBAAiB,KAAK,WAAW,SAAS,IAAI;AACzE,UAAI,KAAK,aAAa,kBAAkB,IAAI,UAAU,GAAI;AACnD,aAAA,aAAa,KAAK,EAAE,MAAM,YAAY,UAAU,KAAK,UAAU;AAAA,MACtE;AAAA,IACF;AACI,QAAA,kBAAkB,IAAI,UAAU,GAAG;AACrC,WAAK,aAAa,iBAAiB,GAAG,KAAK,QAAQ,EAAE;AAAA,IACvD;AAAA,EACF;AAAA,EAEmB,aAAa,mBAA+C;AAC7E,UAAM,aAAa,iBAAiB;AAGpC,SAAK,YAAY;AACjB,eAAW,MAAM;AACV,WAAA,yBAAyB,KAAK;AACnC,WAAK,eAAe;AAAA,IAAA,CACrB;AAAA,EACH;AAAA,EAEgB,uBAA6B;AAC3C,UAAM,qBAAqB;AAC3B,SAAK,mBAAmB;EAC1B;AAAA,EAEQ,eAAe,KAA0B;AAC3C,QAAA,IAAI,SAAS,SAAS;AACxB,WAAK,OAAO;AAAA,IACd;AAAA,EACF;AAAA,EAEQ,uBAA6B;;AAC/B,QAAA,GAAC,UAAK,2BAAL,mBAA6B,aAAY;AAC5C,WAAK,+BAA+B;AACpC;AAAA,IACF;AAEA,SAAK,+BAA+B,KAAK,UACrC,OAAO,aAAa,KAAK,UAAU,OAAO,IAC1C,OAAO,cAAc,KAAK,UAAU,OAAO;AAAA,EACjD;AAAA,EAEmB,SAAyB;AACnC,WAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,sBAMW,KAAK,QAAQ;AAAA,sBACb,KAAK,QAAQ;AAAA,qBACd,KAAK,OAAO;AAAA,kBACf,KAAK,SAAS,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA,YAK3B,KAAK,yBAAyB,oCAAoC,OAAO;AAAA;AAAA,UAE3E,KAAK,yBAAyB,qCAAqC,OAAO;AAAA,UAC1E,KAAK,yBAAyB,KAAK,+BACjC,6CAA6C,KAAK,4BAA4B,aAC9E,OAAO;AAAA;AAAA;AAAA,EAGjB;AACF;AA/Oa,sBACY,SAAyB;AADrC,sBAEY,SAAS;AAAA,EAC9B,aAAa;AAAA,EACb,mBAAmB;AACrB;AAMW,gBAAA;AAAA,EADV,SAAS,EAAE,WAAW,yBAAyB,MAAM,SAAS;AAAA,GAVpD,sBAWA,WAAA,uBAAA,CAAA;AAWQ,gBAAA;AAAA,EAAlB,SAAS;AAAA,GAtBC,sBAsBQ,WAAA,SAAA,CAAA;AAMR,gBAAA;AAAA,EADV,SAAS,EAAE,SAAS,MAAM,MAAM,SAAS;AAAA,GA3B/B,sBA4BA,WAAA,YAAA,CAAA;AAYA,gBAAA;AAAA,EADV,SAAS,EAAE,SAAS,MAAM,MAAM,SAAS;AAAA,GAvC/B,sBAwCA,WAAA,YAAA,CAAA;AAoBA,gBAAA;AAAA,EADV,SAAS,EAAE,SAAS,MAAM,MAAM,SAAS;AAAA,GA3D/B,sBA4DA,WAAA,WAAA,CAAA;AAYA,gBAAA;AAAA,EADV,SAAS,EAAE,SAAS,MAAM;AAAA,GAvEhB,sBAwEA,WAAA,QAAA,CAAA;AAeM,gBAAA;AAAA,EAAhB,MAAM;AAAA,GAvFI,sBAuFM,WAAA,0BAAA,CAAA;AAKA,gBAAA;AAAA,EAAhB,MAAM;AAAA,GA5FI,sBA4FM,WAAA,gCAAA,CAAA;AA5FN,wBAAN,gBAAA;AAAA,EAJN,cAAc,kBAAkB;AAAA,EAChC,eAAe;AAAA,IACd,MAAM;AAAA,EAAA,CACP;AAAA,GACY,qBAAA;"}

package/development/radio-button.d.ts

@@ -0,0 +1,3 @@
+export * from './radio-button/radio-button.js';
+export * from './radio-button/radio-button-group.js';
+//# sourceMappingURL=radio-button.d.ts.map

package/development/radio-button.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"radio-button.d.ts","sourceRoot":"","sources":["../../../src/elements/radio-button.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC;AAC/C,cAAc,sCAAsC,CAAC"}

package/development/radio-button.js

@@ -0,0 +1,3 @@
+export * from "./radio-button/radio-button.js";
+export * from "./radio-button/radio-button-group.js";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmFkaW8tYnV0dG9uLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7In0=

package/development/screen-reader-only/screen-reader-only.d.ts

@@ -0,0 +1,17 @@
+import { CSSResultGroup, TemplateResult, LitElement } from 'lit';
+
+/**
+ * This component can be used to visually hide content but present it to screen readers.
+ *
+ * @slot - Use the unnamed slot to provide content.
+ */
+export declare class SbbScreenReaderOnlyElement extends LitElement {
+    static styles: CSSResultGroup;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sbb-screen-reader-only': SbbScreenReaderOnlyElement;
+    }
+}
+//# sourceMappingURL=screen-reader-only.d.ts.map

package/development/screen-reader-only/screen-reader-only.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screen-reader-only.d.ts","sourceRoot":"","sources":["../../../../src/elements/screen-reader-only/screen-reader-only.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,KAAK,CAAC;AAC1D,OAAO,EAAQ,UAAU,EAAE,MAAM,KAAK,CAAC;AAKvC;;;;GAIG;AACH,qBACa,0BAA2B,SAAQ,UAAU;IACxD,OAAuB,MAAM,EAAE,cAAc,CAAS;cAEnC,MAAM,IAAI,cAAc;CAG5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,wBAAwB,EAAE,0BAA0B,CAAC;KACtD;CACF"}

package/development/screen-reader-only.d.ts

@@ -0,0 +1,2 @@
+export * from './screen-reader-only/screen-reader-only.js';
+//# sourceMappingURL=screen-reader-only.d.ts.map

package/development/screen-reader-only.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screen-reader-only.d.ts","sourceRoot":"","sources":["../../../src/elements/screen-reader-only.ts"],"names":[],"mappings":"AAAA,cAAc,4CAA4C,CAAC"}

package/development/screen-reader-only.js

@@ -0,0 +1,51 @@
+import { css, LitElement, html } from "lit";
+import { customElement } from "lit/decorators.js";
+const style = css`/**
+ * Better font rendering (on OS X)
+ * http://maximilianhoffmann.com/posts/better-font-rendering-on-osx
+ *
+ * Usage:
+ *
+ * .var_dark_on_light {
+ * 	@include font-smoothing;
+ * }
+ * .var_light_on_dark {
+ * 	@include font-smoothing-reset;
+ * }
+ */
+/** This mixin can be used to avoid spacing problems by inserting an invisible space as pseudo element. */
+:host {
+  border: 0;
+  clip: rect(0 0 0 0);
+  height: 1px;
+  margin: -1px;
+  overflow: hidden;
+  padding: 0;
+  position: absolute;
+  white-space: nowrap;
+  width: 1px;
+}`;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+let SbbScreenReaderOnlyElement = class extends LitElement {
+  render() {
+    return html`<slot></slot>`;
+  }
+};
+SbbScreenReaderOnlyElement.styles = style;
+SbbScreenReaderOnlyElement = __decorateClass([
+  customElement("sbb-screen-reader-only")
+], SbbScreenReaderOnlyElement);
+export {
+  SbbScreenReaderOnlyElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NyZWVuLXJlYWRlci1vbmx5LmpzIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZWxlbWVudHMvc2NyZWVuLXJlYWRlci1vbmx5L3NjcmVlbi1yZWFkZXItb25seS50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IENTU1Jlc3VsdEdyb3VwLCBUZW1wbGF0ZVJlc3VsdCB9IGZyb20gJ2xpdCc7XG5pbXBvcnQgeyBodG1sLCBMaXRFbGVtZW50IH0gZnJvbSAnbGl0JztcbmltcG9ydCB7IGN1c3RvbUVsZW1lbnQgfSBmcm9tICdsaXQvZGVjb3JhdG9ycy5qcyc7XG5cbmltcG9ydCBzdHlsZSBmcm9tICcuL3NjcmVlbi1yZWFkZXItb25seS5zY3NzP2xpdCZpbmxpbmUnO1xuXG4vKipcbiAqIFRoaXMgY29tcG9uZW50IGNhbiBiZSB1c2VkIHRvIHZpc3VhbGx5IGhpZGUgY29udGVudCBidXQgcHJlc2VudCBpdCB0byBzY3JlZW4gcmVhZGVycy5cbiAqXG4gKiBAc2xvdCAtIFVzZSB0aGUgdW5uYW1lZCBzbG90IHRvIHByb3ZpZGUgY29udGVudC5cbiAqL1xuQGN1c3RvbUVsZW1lbnQoJ3NiYi1zY3JlZW4tcmVhZGVyLW9ubHknKVxuZXhwb3J0IGNsYXNzIFNiYlNjcmVlblJlYWRlck9ubHlFbGVtZW50IGV4dGVuZHMgTGl0RWxlbWVudCB7XG4gIHB1YmxpYyBzdGF0aWMgb3ZlcnJpZGUgc3R5bGVzOiBDU1NSZXN1bHRHcm91cCA9IHN0eWxlO1xuXG4gIHByb3RlY3RlZCBvdmVycmlkZSByZW5kZXIoKTogVGVtcGxhdGVSZXN1bHQge1xuICAgIHJldHVybiBodG1sYDxzbG90Pjwvc2xvdD5gO1xuICB9XG59XG5cbmRlY2xhcmUgZ2xvYmFsIHtcbiAgaW50ZXJmYWNlIEhUTUxFbGVtZW50VGFnTmFtZU1hcCB7XG4gICAgLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEB0eXBlc2NyaXB0LWVzbGludC9uYW1pbmctY29udmVudGlvblxuICAgICdzYmItc2NyZWVuLXJlYWRlci1vbmx5JzogU2JiU2NyZWVuUmVhZGVyT25seUVsZW1lbnQ7XG4gIH1cbn1cbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQVlhLElBQUEsNkJBQU4sY0FBeUMsV0FBVztBQUFBLEVBR3RDLFNBQXlCO0FBQ25DLFdBQUE7QUFBQSxFQUNUO0FBQ0Y7QUFOYSwyQkFDWSxTQUF5QjtBQURyQyw2QkFBTixnQkFBQTtBQUFBLEVBRE4sY0FBYyx3QkFBd0I7QUFBQSxHQUMxQiwwQkFBQTsifQ==

package/development/select/select.d.ts

@@ -0,0 +1,140 @@
+import { CSSResultGroup, PropertyValues, TemplateResult } from 'lit';
+import { SbbOpenCloseBaseElement } from '../core/base-elements.js';
+
+export interface SelectChange {
+    type: 'value';
+    value: string | string[];
+}
+declare const SbbSelectElement_base: import('../core/mixins.js').AbstractConstructor<import('../core/mixins.js').SbbUpdateSchedulerMixinType> & import('../core/mixins.js').AbstractConstructor<import('../core/mixins.js').SbbDisabledMixinType> & import('../core/mixins.js').AbstractConstructor<import('../core/mixins.js').SbbNegativeMixinType> & typeof SbbOpenCloseBaseElement;
+/**
+ * It displays a panel with selectable options.
+ *
+ * @slot - Use the unnamed slot to add options.
+ * @event {CustomEvent<void>} didChange - Deprecated. used for React. Will probably be removed once React 19 is available.
+ * @event {CustomEvent<void>} change - Notifies that the component's value has changed.
+ * @event {CustomEvent<void>} input - Notifies that an option value has been selected.
+ * @event {CustomEvent<void>} willOpen - Emits whenever the `sbb-select` starts the opening transition. Can be canceled.
+ * @event {CustomEvent<void>} didOpen - Emits whenever the `sbb-select` is opened.
+ * @event {CustomEvent<void>} willClose - Emits whenever the `sbb-select` begins the closing transition. Can be canceled.
+ * @event {CustomEvent<void>} didClose - Emits whenever the `sbb-select` is closed.
+ * @cssprop [--sbb-select-z-index=var(--sbb-overlay-default-z-index)] - To specify a custom stack order,
+ * the `z-index` can be overridden by defining this CSS variable. The default `z-index` of the
+ * component is set to `var(--sbb-overlay-default-z-index)` with a value of `1000`.
+ */
+export declare class SbbSelectElement extends SbbSelectElement_base {
+    static styles: CSSResultGroup;
+    static readonly events: {
+        readonly didChange: "didChange";
+        readonly change: "change";
+        readonly input: "input";
+        readonly stateChange: "stateChange";
+        readonly willOpen: "willOpen";
+        readonly didOpen: "didOpen";
+        readonly willClose: "willClose";
+        readonly didClose: "didClose";
+    };
+    /** The value of the select component. If `multiple` is true, it's an array. */
+    value?: string | string[];
+    /** The placeholder used if no value has been selected. */
+    placeholder?: string;
+    /** Whether the select allows for multiple selection. */
+    multiple: boolean;
+    /** Whether the select is required. */
+    required: boolean;
+    /** Whether the select is readonly. */
+    readonly: boolean;
+    /** The value displayed by the component. */
+    private _displayValue;
+    /**
+     * @deprecated only used for React. Will probably be removed once React 19 is available.
+     */
+    private _didChange;
+    /** Notifies that the component's value has changed. */
+    private _change;
+    /** Notifies that an option value has been selected. */
+    private _input;
+    /** @internal */
+    private _stateChange;
+    private _overlay;
+    private _optionContainer;
+    private _originElement;
+    private _triggerElement;
+    private _openPanelEventsController;
+    private _overlayId;
+    private _activeItemIndex;
+    private _searchTimeout?;
+    private _searchString;
+    private _didLoad;
+    private _isPointerDownEventOnMenu;
+    private _abort;
+    /**
+     * The 'combobox' input element
+     * @internal
+     */
+    get inputElement(): HTMLElement;
+    /** Gets all the SbbOptionElement projected in the select. */
+    private get _options();
+    private get _filteredOptions();
+    /** Opens the selection panel. */
+    open(): void;
+    /** Closes the selection panel. */
+    close(): void;
+    /** Gets the current displayed value. */
+    getDisplayValue(): string;
+    /** Listens to option changes. */
+    private _onOptionChanged;
+    private _onOptionClick;
+    /** Sets the _displayValue by checking the internal sbb-options and setting the correct `selected` value on them. */
+    private _onValueChanged;
+    protected firstUpdated(changedProperties: PropertyValues<this>): void;
+    /**
+     * Removes element's first attribute whose qualified name is qualifiedName.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/removeAttribute)
+     * @internal We need to override this due to a hydration issue with Next.js.
+     */
+    removeAttribute(qualifiedName: string): void;
+    connectedCallback(): void;
+    protected willUpdate(changedProperties: PropertyValues<this>): void;
+    disconnectedCallback(): void;
+    private _syncProperties;
+    private _setupSelect;
+    /** Sets the originElement; if the component is used in a sbb-form-field uses it, otherwise uses the parentElement. */
+    private _setupOrigin;
+    /**
+     * To assess screen-readers problems caused by the interaction between aria patterns and shadow DOM,
+     * we are forced to move the 'combobox' trigger element to the light DOM
+     */
+    private _setupTrigger;
+    private _setOverlayPosition;
+    private _onAnimationEnd;
+    private _onOpenAnimationEnd;
+    private _onCloseAnimationEnd;
+    /** When an option is selected, updates the displayValue; it also closes the select if not `multiple`. */
+    private _onOptionSelected;
+    /** When an option is unselected in `multiple`, removes it from value and updates displayValue. */
+    private _onOptionDeselected;
+    private _attachOpenPanelEvents;
+    private _onKeyDown;
+    private _closedPanelKeyboardInteraction;
+    private _openedPanelKeyboardInteraction;
+    private _checkForLetterSelection;
+    private _setNextActiveOptionByText;
+    private _selectByKeyboard;
+    private _setNextActiveOption;
+    private _setActiveElement;
+    private _setSelectedElement;
+    private _resetActiveElement;
+    private _pointerDownListener;
+    private _closeOnBackdropClick;
+    private _setValueFromSelectedOption;
+    private _toggleOpening;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sbb-select': SbbSelectElement;
+    }
+}
+export {};
+//# sourceMappingURL=select.d.ts.map