@siemens/ix 5.0.0 → 5.1.1

package/dist/types/components/pane-layout/pane-layout.d.ts

@@ -1,3 +1,11 @@
+/**
+ * @slot left - Pane displayed to the left of the content.
+ * @slot top - Pane displayed above the content.
+ * @slot content - Main layout content.
+ * @slot default - Additional main layout content.
+ * @slot bottom - Pane displayed below the content.
+ * @slot right - Pane displayed to the right of the content.
+ */
 export declare class Panes {
     hostElement: HTMLIxPaneLayoutElement;
     /**

package/dist/types/components/pill/pill.d.ts

@@ -12,6 +12,9 @@ declare const Pill_base: abstract new (...args: any[]) => {
     componentDidUpdate?(): void;
     render?(): any;
 } & import("../utils/internal/component").StencilLifecycle;
+/**
+ * @slot default - Pill label.
+ */
 export declare class Pill extends Pill_base implements IxComponentInterface {
     hostElement: HTMLIxPillElement;
     /**

package/dist/types/components/popover/popover-controller.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Focus management strategy when an interactive popover closes.
+ *
+ * - `restore-trigger`: Move focus back to the trigger element (default, WCAG-compliant).
+ * - `release`: Blur the active element without restoring focus (hover mode pointer dismiss).
+ */
+export type PopoverCloseFocus = 'restore-trigger' | 'release';
+export interface PopoverInterface {
+    hostElement: HTMLElement;
+    closeOnClickOutside: boolean;
+    getNestedPopoverIds(): string[];
+    getId(): string;
+    isPresent(): boolean;
+    willPresent?(): boolean;
+    willDismiss?(): boolean;
+    present(): Promise<void>;
+    /**
+     * @param closeFocus How to handle focus when the popover has focusable content.
+     */
+    dismiss(closeFocus?: PopoverCloseFocus): void;
+}
+declare class PopoverController {
+    private readonly stack;
+    /** LIFO order of popovers opened through {@link presentAndWait}. */
+    private readonly presentationOrder;
+    private isWindowListenerActive;
+    connected(popover: PopoverInterface): void;
+    disconnected(popover: PopoverInterface): void;
+    removeFromNestedPopoverIds(id: string): void;
+    /** Keeps stack parent→child links aligned with host {@link PopoverInterface.getNestedPopoverIds}. */
+    syncNestedPopoverIds(popover: PopoverInterface): void;
+    present(popover: PopoverInterface): void;
+    presentAndWait(popover: PopoverInterface): Promise<void>;
+    dismissChildren(uid: string): void;
+    dismiss(popover: PopoverInterface, closeFocus?: PopoverCloseFocus): void;
+    private dismissChildrenWithFocus;
+    dismissAll(ignoreCloseOnClickOutside?: boolean): void;
+    dismissTopmost(): void;
+    dismissOthers(uid: string): void;
+    pathIncludesTrigger(eventTargets: EventTarget[]): HTMLElement | undefined;
+    private recordPresented;
+    private removeFromPresentationOrder;
+    /** Whether this host is the active (topmost) popover for keyboard focus. */
+    isTopmostPresentedHost(host: HTMLElement): boolean;
+    private getTopmostForEscape;
+    private getPopoverDialog;
+    private pathIncludesPopover;
+    private dismissAllFromOutsideClick;
+    private addOverlayListeners;
+}
+export { PopoverController };
+export declare const popoverController: PopoverController;

package/dist/types/components/popover/popover.d.ts

@@ -0,0 +1,190 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { ElementReference } from '../utils/element-reference';
+import { InheritAriaAttributesMixinContract } from '../utils/internal/mixins/accessibility/inherit-aria-attributes.mixin';
+import { ComponentIdMixinContract } from '../utils/internal/mixins/id.mixin';
+import { PopoverCloseFocus, PopoverInterface } from './popover-controller';
+declare const Popover_base: abstract new (...args: any[]) => {
+    componentDidLoad(): void;
+    disconnectedCallback(): void;
+    hostElement?: import("@stencil/core/internal").HTMLStencilElement;
+    connectedCallback?(): void;
+    componentWillRender?(): Promise<void> | void;
+    componentDidRender?(): void;
+    componentWillLoad?(): Promise<void> | void;
+    componentShouldUpdate?(newVal: any, oldVal: any, propName: string): boolean | void;
+    componentWillUpdate?(): Promise<void> | void;
+    componentDidUpdate?(): void;
+    render?(): any;
+} & import("../utils/internal/component").StencilLifecycle & {
+    inheritAriaAttributes: import("../utils/a11y").A11yAttributes;
+    getIgnoredAriaAttributes(): import("../utils/a11y").A11yAttributeName[];
+    componentWillLoad(): Promise<void> | void;
+    ariaAttributeChanged(newValue: string | null, _: string | null, propName: string): void;
+    hostElement?: import("@stencil/core/internal").HTMLStencilElement;
+    connectedCallback?(): void;
+    disconnectedCallback?(): void;
+    componentWillRender?(): Promise<void> | void;
+    componentDidRender?(): void;
+    componentDidLoad?(): void;
+    componentShouldUpdate?(newVal: any, oldVal: any, propName: string): boolean | void;
+    componentWillUpdate?(): Promise<void> | void;
+    componentDidUpdate?(): void;
+    render?(): any;
+} & {
+    $internal_id: number;
+    getHostElementId(): string;
+    hostElement?: import("@stencil/core/internal").HTMLStencilElement;
+    connectedCallback?(): void;
+    disconnectedCallback?(): void;
+    componentWillRender?(): Promise<void> | void;
+    componentDidRender?(): void;
+    componentWillLoad?(): Promise<void> | void;
+    componentDidLoad?(): void;
+    componentShouldUpdate?(newVal: any, oldVal: any, propName: string): boolean | void;
+    componentWillUpdate?(): Promise<void> | void;
+    componentDidUpdate?(): void;
+    render?(): any;
+};
+/**
+ * Floating panel anchored to a trigger element.
+ *
+ * @slot default - Child sections in order: `ix-popover-header`, `ix-popover-image`, `ix-popover-content`, and `ix-popover-footer`.
+ *
+ * @since 5.1.0
+ */
+export declare class Popover extends Popover_base implements PopoverInterface, InheritAriaAttributesMixinContract, ComponentIdMixinContract {
+    hostElement: HTMLIxPopoverElement;
+    /**
+     * Element that toggles the popover.
+     * String values are resolved as the trigger element `id`, not as CSS selectors.
+     * Also accepts a DOM element reference.
+     *
+     * @since 5.1.0
+     */
+    trigger?: ElementReference;
+    /**
+     * Show/hide state
+     *
+     * @since 5.1.0
+     */
+    show: boolean;
+    /**
+     * Preferred placement relative to trigger
+     *
+     * @since 5.1.0
+     */
+    placement: 'top' | 'bottom' | 'left' | 'right';
+    /**
+     * Show the spike pointing at the trigger
+     *
+     * @since 5.1.0
+     */
+    hasSpike: boolean;
+    /**
+     * Interaction that opens the popover
+     *
+     * @since 5.1.0
+     */
+    triggerMode: 'click' | 'hover';
+    /**
+     * Dismiss when clicking outside the popover and trigger
+     *
+     * @since 5.1.0
+     */
+    closeOnClickOutside: boolean;
+    /**
+     * Fires before visibility changes. Cancel to prevent.
+     *
+     * @since 5.1.0
+     */
+    showChange: EventEmitter<boolean>;
+    /**
+     * Fires after visibility has changed
+     *
+     * @since 5.1.0
+     */
+    showChanged: EventEmitter<boolean>;
+    private readonly dialogRef;
+    private triggerElement?;
+    private disposeAutoUpdate?;
+    private disposeTriggerListener?;
+    private disposeDialogListener?;
+    private focusTrap?;
+    private hideTimeout?;
+    private readonly assignedNestedPopoverIds;
+    private hasFocusableContent;
+    private suppressShowWatch;
+    private isOpeningPopover;
+    private closeFocus;
+    private hasDisconnected;
+    private triggerRegistryId;
+    /**
+     * Hover mode: skip `present()` on the trigger `focus` handler while
+     * `schedulePostCloseFocus()` refocuses the trigger (e.g. after Escape).
+     */
+    private suppressFocusPresent;
+    private get spikeElement();
+    private getFocusTrapOptions;
+    /** Top-layer dialog id; kept separate from host `id` when the host has a custom id. */
+    private get popoverPanelId();
+    getId(): string;
+    getNestedPopoverIds(): string[];
+    cacheNestedPopoverId(event: CustomEvent<string>): void;
+    isPresent(): boolean;
+    willPresent(): boolean;
+    willDismiss(): boolean;
+    present(): Promise<void>;
+    dismiss(closeFocus?: PopoverCloseFocus): void;
+    /**
+     * Open the popover programmatically
+     *
+     * @since 5.1.0
+     */
+    showPopover(): Promise<void>;
+    /**
+     * Close the popover programmatically
+     *
+     * @since 5.1.0
+     */
+    hidePopover(): Promise<void>;
+    onTriggerChange(newTrigger: ElementReference | undefined, oldTrigger: ElementReference | undefined): void;
+    onTriggerModeChange(): void;
+    onShowChange(newValue: boolean): void;
+    connectedCallback(): void;
+    componentDidLoad(): void;
+    private initializePopover;
+    componentDidRender(): void;
+    disconnectedCallback(): void;
+    private openPopover;
+    private closePopover;
+    private detectFocusableContent;
+    private focusFirstElement;
+    private applyCloseFocus;
+    /**
+     * Run after `hidePopover()` so browser popover focus restoration can be
+     * corrected (pointer dismiss) or overridden (keyboard dismiss).
+     */
+    private schedulePostCloseFocus;
+    /** Pointer-driven dismiss: avoid a focus ring on the trigger. */
+    private releasePopoverFocus;
+    private blurTriggerElement;
+    private registerTriggerListener;
+    private discoverNestedPopover;
+    private togglePopover;
+    private containsPopoverTarget;
+    private scheduleHideFromTrigger;
+    private scheduleHide;
+    private clearHideTimeout;
+    private getTriggerAriaTarget;
+    private clearTriggerAriaAttributes;
+    private updateTriggerAria;
+    private clearTriggerAria;
+    private computeSpikePosition;
+    private computePopoverPosition;
+    private applyPopoverPosition;
+    private registerHoverDialogListener;
+    private onDialogMouseEnter;
+    private onDialogMouseLeave;
+    render(): any;
+}
+export {};

package/dist/types/components/popover/test/popover.constants.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Hover hide delay in milliseconds (matches implementation)
+ */
+export declare const HOVER_HIDE_MS = 150;
+/**
+ * Mouse coordinates for testing click/hover interactions
+ */
+export declare const OUTSIDE_CLICK_X = 5;
+export declare const OUTSIDE_CLICK_Y = 5;
+export declare const FAR_CORNER_X = 800;
+export declare const FAR_CORNER_Y = 600;

package/dist/types/components/popover/test/popover.fixtures.d.ts

@@ -0,0 +1,29 @@
+export interface PopoverMarkupOptions {
+    id?: string;
+    triggerId?: string;
+    triggerLabel?: string;
+    placement?: string;
+    closeOnClickOutside?: boolean;
+    triggerMode?: string;
+    hasSpike?: boolean;
+    ariaLabel?: string;
+    hideClose?: boolean;
+    showFooterDismiss?: boolean;
+    show?: boolean;
+}
+/**
+ * Generate markup for an interactive popover with header, content, and footer
+ */
+export declare function interactivePopoverMarkup(options?: PopoverMarkupOptions): string;
+/**
+ * Generate markup for placement tests with centered layout
+ */
+export declare function placementTestMarkup(placement: 'top' | 'bottom' | 'left' | 'right'): string;
+/**
+ * Outer popover only; nested child is injected at runtime (see {@link injectLateNestedPopover}).
+ */
+export declare function outerPopoverWithNestedMountMarkup(): string;
+/**
+ * Nested popovers with a third unrelated popover for controller tests
+ */
+export declare function nestedPopoverMarkup(): string;

package/dist/types/components/popover/test/popover.page.d.ts

@@ -0,0 +1,118 @@
+import AxeBuilder from '@axe-core/playwright';
+import { Locator, Page } from '@playwright/test';
+/**
+ * Page Object Model for ix-popover component testing
+ *
+ * Usage:
+ * ```ts
+ * const popover = new PopoverPage(page);
+ * await popover.open();
+ * await popover.expectOpen();
+ * ```
+ */
+export declare class PopoverPage {
+    readonly page: Page;
+    readonly triggerId: string;
+    constructor(page: Page, triggerId?: string);
+    /**
+     * Get the trigger button locator
+     */
+    get trigger(): Locator;
+    /** Native button inside the trigger host (pierces open shadow root). */
+    get triggerButton(): Locator;
+    /** First popover on the page (single-popover fixtures). */
+    get host(): Locator;
+    private getTriggerAriaAttribute;
+    /**
+     * Resolves the popover host via the trigger's `aria-controls` id.
+     * That id is assigned when the trigger registers (typically before the first open).
+     *
+     * `expectOpen()` and `expectClosed()` call this when no locator is passed; Playwright
+     * retries the `aria-controls` assertion until the link exists. Prefer those helpers
+     * after open/close actions unless you need the locator for further queries.
+     */
+    getPopover(): Promise<Locator>;
+    /**
+     * Same as {@link getPopover}; use after mount when the trigger is registered but the
+     * popover is still closed (e.g. hover/focus tests).
+     */
+    linkedPopover(): Promise<Locator>;
+    /**
+     * Get the popover locator directly by page (for closed state checks)
+     */
+    get popoverElement(): Locator;
+    /**
+     * Get the dialog element for a popover host.
+     * Uses the dialog `id` (same as `data-ix-popover`) so nested popovers are not matched.
+     */
+    dialog(popover: Locator): Promise<Locator>;
+    /**
+     * Open popover by clicking the trigger
+     */
+    open(): Promise<void>;
+    /**
+     * Assert that popover is visible
+     */
+    expectOpen(popover?: Locator): Promise<void>;
+    /**
+     * Assert that popover is closed
+     */
+    expectClosed(popover?: Locator): Promise<void>;
+    /**
+     * Check if popover has spike element in shadow DOM
+     */
+    hasSpike(popover: Locator): Promise<boolean>;
+    /**
+     * Close button on this popover's header only (avoids nested header matches)
+     */
+    scopedHeaderCloseButton(popover: Locator): Locator;
+    /**
+     * Get the close button in popover header
+     */
+    getCloseButton(popover: Locator): Locator;
+    openWithKeyboard(): Promise<void>;
+    /** Keyboard open can lag behind aria-controls / visible state; poll until stable. */
+    openWithKeyboardAndExpectOpen(popover?: Locator): Promise<Locator>;
+    closeWithEscape(): Promise<void>;
+    /**
+     * Assert focus stayed on the trigger (host or shadow-DOM button inside ix-button).
+     */
+    expectTriggerFocused(timeout?: number): Promise<void>;
+    expectTriggerButtonNotFocused(): Promise<void>;
+    callShowPopover(popover?: Locator): Promise<void>;
+    callHidePopover(popover?: Locator): Promise<void>;
+    setShowProperty(show: boolean, popover?: Locator): Promise<void>;
+    callShowPopoverConcurrently(times: number, popover?: Locator): Promise<void>;
+    /**
+     * Blocks open via cancelable `showChange` (same pattern as other IX CTs:
+     * `locator.evaluate` + `addEventListener`, not `document.querySelector`).
+     */
+    preventShowChangeOnOpen(popover?: Locator): Promise<void>;
+    preventShowChangeOnClose(popover?: Locator): Promise<void>;
+    preventHeaderCloseClick(popover: Locator): Promise<void>;
+    private isTriggerFocused;
+    clickOutside(x?: number, y?: number): Promise<void>;
+    pointerDismissFarCorner(): Promise<void>;
+    expectAriaExpanded(expanded: 'true' | 'false'): Promise<void>;
+    expectAriaControlsMatch(popover: Locator): Promise<void>;
+    static installShowChangedTracker(page: Page): Promise<void>;
+    expectShowChangedEvents(expected: boolean[]): Promise<void>;
+    runAxe(makeAxeBuilder: () => AxeBuilder): Promise<void>;
+}
+/**
+ * Assert popover placement relative to trigger
+ */
+export declare function expectPlacement(page: Page, triggerSelector: string, popover: Locator, placement: 'top' | 'bottom' | 'left' | 'right'): Promise<void>;
+/** Poll until the locator's focused element does not match `:focus-visible`. */
+export declare function expectLocatorNotFocusVisible(locator: Locator, options?: {
+    timeout?: number;
+}): Promise<void>;
+/**
+ * Mount popover component and wait for hydration
+ */
+export declare function mountPopover(mount: (markup: string) => Promise<unknown>, page: Page, markup: string): Promise<void>;
+/**
+ * Inject nested popover markup after the parent is already open.
+ * Waits for the inner trigger to register with the controller.
+ */
+export declare function injectLateNestedPopover(page: Page): Promise<void>;

package/dist/types/components/popover-content/popover-content.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Main body section of the popover.
+ *
+ * @slot default - Popover body content.
+ *
+ * @since 5.1.0
+ */
+export declare class PopoverContent {
+    /**
+     * Remove default inner padding.
+     *
+     * @since 5.1.0
+     */
+    noPadding: boolean;
+    render(): any;
+}

package/dist/types/components/popover-footer/popover-footer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Footer section for actions and optional leading metadata.
+ *
+ * @slot default - Footer actions (typically buttons), aligned to the end.
+ * @slot start - Optional leading content (for example version text or step indicators).
+ *
+ * @since 5.1.0
+ */
+export declare class PopoverFooter {
+    /**
+     * Button layout direction
+     *
+     * @since 5.1.0
+     */
+    alignment: 'horizontal' | 'vertical';
+    render(): any;
+}

package/dist/types/components/popover-header/popover-header.d.ts

@@ -0,0 +1,49 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+/**
+ * Header section with optional icon, title, additional items, and close button.
+ *
+ * @slot default - Popover title (rendered as heading text).
+ * @slot additional-items - Optional content beside the title (for example `ix-pill`).
+ *
+ * @since 5.1.0
+ */
+export declare class PopoverHeader {
+    hostElement: HTMLIxPopoverHeaderElement;
+    /**
+     * Icon name displayed before the title.
+     * The icon is decorative; provide context in the default slot heading.
+     *
+     * @since 5.1.0
+     */
+    icon?: string;
+    /**
+     * Icon color
+     *
+     * @since 5.1.0
+     */
+    iconColor?: string;
+    /**
+     * Hide the close (X) button
+     *
+     * @since 5.1.0
+     */
+    hideClose: boolean;
+    /**
+     * ARIA label for the close icon button.
+     * Will be set as aria-label on the nested HTML button element.
+     *
+     * @since 5.1.0
+     */
+    ariaLabelCloseIconButton?: string;
+    /**
+     * Fires when close button is clicked.
+     * Cancel to prevent closing.
+     *
+     * @since 5.1.0
+     */
+    closeClick: EventEmitter<MouseEvent>;
+    private parentPopover?;
+    componentDidLoad(): void;
+    private onCloseClick;
+    render(): any;
+}

package/dist/types/components/popover-image/popover-image.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Optional image section for the popover.
+ *
+ * @since 5.1.0
+ */
+export declare class PopoverImage {
+    /**
+     * Image source URL
+     *
+     * @since 5.1.0
+     */
+    image?: string;
+    /**
+     * Alt text for the image.
+     * Use an empty string for decorative images; provide descriptive text for content images.
+     *
+     * @since 5.1.0
+     */
+    imageAlt: string;
+    render(): any;
+}

package/dist/types/components/progress-indicator/progress-indicator.d.ts

@@ -1,6 +1,8 @@
 import type { ProgressIndicatorSize, ProgressIndicatorStatus } from './progress-indicator.types';
 /**
  * @since 3.2.0
+ * @slot helper-text - Custom helper text content.
+ * @slot default - Content displayed with the progress indicator.
  */
 export declare class ProgressIndicator {
     hostElement: HTMLIxProgressIndicatorElement;

package/dist/types/components/push-card/push-card.d.ts

@@ -1,4 +1,8 @@
 import type { PushCardVariant } from './push-card.types';
+/**
+ * @slot title-action - Action displayed next to the card title.
+ * @slot default - Expandable card content.
+ */
 export declare class PushCard {
     /**
      * Card icon

package/dist/types/components/radio/radio.d.ts

@@ -2,6 +2,7 @@ import { EventEmitter } from '../../stencil-public-runtime';
 import { IxFormComponent } from '../utils/input';
 /**
  * @form-ready
+ * @slot default - Radio button label.
  */
 export declare class Radio implements IxFormComponent<string> {
     hostElement: HTMLIxRadioElement;

package/dist/types/components/radio-group/radio-group.d.ts

@@ -2,6 +2,7 @@ import { EventEmitter } from '../../stencil-public-runtime';
 import { ValidationResults, FieldWrapperInterface, IxFormValidationState } from '../utils/input';
 /**
  * @form-ready
+ * @slot default - Radio buttons displayed in the group.
  */
 export declare class RadiobuttonGroup implements FieldWrapperInterface, IxFormValidationState {
     hostElement: HTMLIxRadioGroupElement;

package/dist/types/components/range-field/range-field.d.ts

@@ -11,6 +11,9 @@ declare const RangeField_base: abstract new (...args: any[]) => {
     componentDidUpdate?(): void;
     render?(): any;
 } & import("../utils/internal/component").StencilLifecycle;
+/**
+ * @slot default - Range field controls.
+ */
 export declare class RangeField extends RangeField_base {
     hostElement: HTMLIxRangeFieldElement;
     /**

package/dist/types/components/row/row.d.ts

@@ -1,3 +1,6 @@
+/**
+ * @slot default - Row content.
+ */
 export declare class Row {
     render(): any;
 }

package/dist/types/components/select/select.d.ts

@@ -50,6 +50,7 @@ declare const Select_base: abstract new (...args: any[]) => {
 };
 /**
  * @form-ready
+ * @slot default - Select items.
  */
 export declare class Select extends Select_base implements IxInputFieldComponent<string | string[]>, AriaActiveDescendantMixinContract, ComponentIdMixinContract {
     hostElement: HTMLIxSelectElement;
@@ -80,6 +81,14 @@ export declare class Select extends Select_base implements IxInputFieldComponent
      * @since TODO: Define
      */
     ariaLabelAddItem: string;
+    /**
+     * Accessible label template for the overflow indicator chip shown in multiple
+     * mode when not all selected chips fit on a single row. The `{count}`
+     * placeholder is replaced with the number of hidden items (e.g. "3 more").
+     *
+     * @since 5.1.0
+     */
+    i18nMoreItems: string;
     /**
      * Warning text for the select component
      **/
@@ -201,6 +210,9 @@ export declare class Select extends Select_base implements IxInputFieldComponent
     isDropdownEmpty: boolean;
     inputFilterText: string;
     inputValue: string;
+    visibleChipValues: string[] | null;
+    hiddenChipValues: string[];
+    overflowDropdownShow: boolean;
     hasInputFocus: boolean;
     dropdownItemsVisualFocused: boolean;
     isInvalid: boolean;
@@ -212,6 +224,17 @@ export declare class Select extends Select_base implements IxInputFieldComponent
     private readonly dropdownAnchorRef;
     private readonly inputRef;
     private readonly dropdownRef;
+    private readonly chipElementRefs;
+    private readonly chipWidths;
+    private readonly overflowChipRef;
+    private readonly chipsContainerRef;
+    private readonly clearButtonRef;
+    private readonly chipHorizontalMargin;
+    private readonly triggerMinWidth;
+    private readonly overflowChipFallbackWidth;
+    private overflowChipWidth;
+    private chipsResizeObserver?;
+    private overflowDropdownOpenedByKeyboard;
     private proxyListObserver;
     private inputElement?;
     private touched;
@@ -226,6 +249,7 @@ export declare class Select extends Select_base implements IxInputFieldComponent
     get isMultipleMode(): boolean;
     get isEveryDropdownItemHidden(): boolean;
     watchValue(value: string | string[]): void;
+    watchDisabledReadonly(): void;
     updateFormInternalValue(value: string | string[]): void;
     /** @internal */
     hasValidValue(): Promise<boolean>;
@@ -256,6 +280,32 @@ export declare class Select extends Select_base implements IxInputFieldComponent
     private getRemoveChipAriaLabel;
     private renderAllChip;
     private renderChip;
+    private renderHiddenChip;
+    private renderOverflowChip;
+    private renderMultipleModeChips;
+    private renderOverflowDropdown;
+    private toggleOverflowDropdown;
+    private getOverflowRemoveButtons;
+    private focusOverflowRemoveButton;
+    onOverflowRemoveButtonKeyDown(event: KeyboardEvent): void;
+    private focusOverflowChip;
+    private pruneChipWidthCache;
+    private sameChipValues;
+    private applyOverflowState;
+    private getChipWidthWithMargin;
+    private getOverflowChipWidthWithMargin;
+    private canShowAllChips;
+    private getOverflowChipValues;
+    private hasUnmeasuredSelectedChips;
+    private getChipOverflowContext;
+    private handleChipsContainerResize;
+    private calculateChipOverflow;
+    private waitForComponentReady;
+    private waitForNextFrame;
+    private waitForChipLayout;
+    private measureSelectedChipWidths;
+    private measureOverflowChipWidth;
+    componentDidRender(): Promise<void>;
     onValidationChange({ isInvalid, isInvalidByRequired, isValid, isInfo, isWarning, }: ValidationResults): void;
     /** @internal */
     getAssociatedFormElement(): Promise<HTMLFormElement | null>;