@siemens/ix 5.0.0 → 5.1.0

package/dist/types/components/menu-category/menu-category.d.ts

@@ -1,5 +1,6 @@
 import { EventEmitter } from '../../stencil-public-runtime';
 import type { IxMenuItemBase } from './../menu-item/menu-item.interface';
+import { InheritAriaAttributesMixinContract } from '../utils/internal/mixins/accessibility/inherit-aria-attributes.mixin';
 declare const MenuCategory_base: abstract new (...args: any[]) => {
     componentDidLoad(): void;
     disconnectedCallback(): void;
@@ -12,8 +13,23 @@ declare const MenuCategory_base: abstract new (...args: any[]) => {
     componentWillUpdate?(): Promise<void> | void;
     componentDidUpdate?(): void;
     render?(): any;
-} & import("../utils/internal/component").StencilLifecycle;
-export declare class MenuCategory extends MenuCategory_base implements IxMenuItemBase {
+} & 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;
+};
+export declare class MenuCategory extends MenuCategory_base implements IxMenuItemBase, InheritAriaAttributesMixinContract {
     hostElement: HTMLIxMenuCategoryElement;
     /**
      * Display name of the category
@@ -39,23 +55,33 @@ export declare class MenuCategory extends MenuCategory_base implements IxMenuIte
     showItems: boolean;
     showDropdown: boolean;
     nestedItems: HTMLIxMenuItemElement[];
+    /** @internal */
+    setTabIndex(value: number): Promise<void>;
     private observer?;
     private menuItemsContainer?;
     private ixMenu?;
     private readonly dropdownRef;
     private readonly categoryParentRef;
+    private readonly categoryId;
+    private focusFirstItemOnDropdownOpen;
     private isNestedItemActive;
     private getNestedItems;
     private getNestedItemsHeight;
+    private focusFirstItem;
     private onExpandCategory;
     private animateFadeOut;
     private animateFadeIn;
     private showMenuItemDropdown;
     private hideMenuItemDropdown;
     private handleCategoryVisibility;
+    private onDropdownShowChange;
+    private onDropdownShowChanged;
+    private onDropdownFocusOut;
+    private onNestedItemSelect;
     private onCategoryClick;
     private onKeyDown;
     private onMenuItemsKeyDown;
+    private suppressAnchorWrapperTabStops;
     private onNestedItemsChanged;
     private isCategoryItemListVisible;
     componentWillLoad(): void;

package/dist/types/components/menu-item/menu-item.d.ts

@@ -1,9 +1,38 @@
 import { AnchorTarget } from '../button/button.interface';
+import { InheritAriaAttributesMixinContract } from '../utils/internal/mixins/accessibility/inherit-aria-attributes.mixin';
 import { IxMenuItemBase } from './menu-item.interface';
+declare const MenuItem_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;
+};
 /**
  * @slot menu-item-label Custom label
  */
-export declare class MenuItem implements IxMenuItemBase {
+export declare class MenuItem extends MenuItem_base implements IxMenuItemBase, InheritAriaAttributesMixinContract {
     /**
      * Label of the menu item. Will also be used as tooltip text
      */
@@ -60,10 +89,15 @@ export declare class MenuItem implements IxMenuItemBase {
     rel?: string;
     /** @internal */
     isCategory: boolean;
+    /** @internal */
+    menuCategoryLabel?: string;
     hostElement: HTMLIxMenuItemElement;
     tooltip?: string;
-    ariaHiddenTooltip: boolean;
     menuExpanded: boolean;
+    private isInMenuContext;
+    private hostTabIndex;
+    /** @internal */
+    setTabIndex(value: number): Promise<void>;
     private readonly internalItemId;
     private readonly buttonRef;
     private isHostedInsideCategory;
@@ -76,6 +110,9 @@ export declare class MenuItem implements IxMenuItemBase {
     disconnectedCallback(): void;
     onIconChange(): void;
     private handleCategoryKeyDown;
+    private getAriaLabel;
+    private getEffectiveRole;
     private returnFocusToParentCategoryMenuItem;
     render(): any;
 }
+export {};

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

@@ -27,6 +27,13 @@ export declare class Pane {
      * Defaults to the borderless attribute of the pane layout. If used standalone it defaults to false.
      */
     borderless: boolean;
+    /**
+     * Remove the padding of the content area.
+     * If set to `true` the left, right and bottom padding of the content area is removed.
+     *
+     * @since 5.1.0
+     */
+    noPadding: boolean;
     /**
      * State of the pane
      */
@@ -95,12 +102,15 @@ export declare class Pane {
     private mutationObserver?;
     private resizeObserver?;
     private disposableWindowClick?;
+    private disposableKeydown?;
+    private focusTrap?;
+    private focusReturnElement?;
     get currentSlot(): string | null;
     get isBottomTopPane(): boolean;
     get isLeftRightPane(): boolean;
     get isMobileTop(): boolean;
     disconnectedCallback(): void;
-    onExpandedChange(): void;
+    onExpandedChange(): Promise<void>;
     componentWillLoad(): void;
     private setPosition;
     private getExpandPaneSize;
@@ -109,6 +119,7 @@ export declare class Pane {
     private getKey;
     private animateVerticalFadeIn;
     private animateHorizontalFadeIn;
+    private onAnimationComplete;
     private removePadding;
     private animateHorizontalPadding;
     private animateVerticalPadding;
@@ -118,6 +129,8 @@ export declare class Pane {
     onHideOnCollapseChange(value: boolean): void;
     onVariantChange(value: 'inline' | 'floating'): void;
     onBorderlessChange(value: boolean): void;
+    private focusFirstSlottedElement;
+    private registerEscapeListener;
     private dispatchExpandedChangedEvent;
     onParentSizeChange(): void;
     onSizeChange(): void;

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 - 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 - 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 - 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 - 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;
+}