@siemens/element-ng 47.9.0 → 48.0.0-next.2

package/application-header/index.d.ts

@@ -1,17 +1,361 @@
+import * as rxjs from 'rxjs';
+import { Subject } from 'rxjs';
+import * as _siemens_element_translate_ng_translate_types from '@siemens/element-translate-ng/translate-types';
+import * as _angular_core from '@angular/core';
+import { OnDestroy, TemplateRef, Injector, OnInit, OnChanges, SimpleChanges } from '@angular/core';
+import { HeaderWithDropdowns, SiHeaderDropdownTriggerDirective } from '@siemens/element-ng/header-dropdown';
+import * as _siemens_element_ng_application_header from '@siemens/element-ng/application-header';
+import { NavigationExtras, IsActiveMatchOptions, ActivatedRoute } from '@angular/router';
+import { TranslatableString } from '@siemens/element-translate-ng/translate';
+
+/** Root component for the application header. */
+declare class SiApplicationHeaderComponent implements HeaderWithDropdowns, OnDestroy {
+    private static idCounter;
+    /**
+     * Defines the minimum breakpoint which must be matched to expand the header / switch to desktop mode.
+     *
+     * @defaultValue 'sm'
+     */
+    readonly expandBreakpoint: _angular_core.InputSignal<"sm" | "md" | "lg" | "xl" | "xxl" | "never">;
+    readonly launchpad: _angular_core.InputSignal<TemplateRef<void> | undefined>;
+    /**
+     * @defaultValue
+     * ```
+     * t(() => $localize`:@@SI_APPLICATION_HEADER.LAUNCHPAD:Launchpad`)
+     * ```
+     */
+    readonly launchpadLabel: _angular_core.InputSignal<_siemens_element_translate_ng_translate_types.TranslatableString>;
+    /** @internal */
+    readonly closeMobileMenus: Subject<void>;
+    /** @internal */
+    readonly mobileNavigationExpanded: _angular_core.WritableSignal<boolean>;
+    /** @internal */
+    readonly hasNavigation: _angular_core.WritableSignal<boolean>;
+    protected readonly openDropdownCount: _angular_core.WritableSignal<number>;
+    protected readonly launchpadOpen: _angular_core.WritableSignal<boolean>;
+    protected readonly id: string;
+    protected toggleNavigation: _siemens_element_translate_ng_translate_types.TranslatableString;
+    protected injector: Injector;
+    protected readonly icons: Record<"elementThumbnails" | "elementMenu", string>;
+    private readonly navigationToggle;
+    private readonly focusTrap;
+    private breakpointObserver;
+    private openDropdown?;
+    private closeMobileSub;
+    /** @internal */
+    readonly inlineDropdown: rxjs.Observable<boolean>;
+    ngOnDestroy(): void;
+    /** @internal */
+    onDropdownItemTriggered(): void;
+    /** @internal */
+    dropdownClosed(trigger?: SiHeaderDropdownTriggerDirective): void;
+    /** @internal */
+    dropdownOpened(trigger?: SiHeaderDropdownTriggerDirective): void;
+    /** @internal */
+    closeLaunchpad(): void;
+    /** @internal */
+    openLaunchpad(): void;
+    protected toggleMobileNavigationExpanded(): void;
+    protected toggleLaunchpad(): void;
+    protected navigationEscapePressed(): void;
+    protected backdropClicked(): void;
+    private openMobileNavigation;
+    private closeMobileNavigation;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiApplicationHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SiApplicationHeaderComponent, "si-application-header", never, { "expandBreakpoint": { "alias": "expandBreakpoint"; "required": false; "isSignal": true; }; "launchpad": { "alias": "launchpad"; "required": false; "isSignal": true; }; "launchpadLabel": { "alias": "launchpadLabel"; "required": false; "isSignal": true; }; }, {}, never, ["si-header-brand, element-header-brand", "si-header-navigation, element-header-navigation", "si-header-actions, element-header-actions"], true, never>;
+}
+
+/** Adds a navigation item to the header. Should be located inside `.header-navigation`. */
+declare class SiHeaderNavigationItemComponent {
+    /** @internal */
+    dropdownTrigger: SiHeaderDropdownTriggerDirective | null;
+    protected readonly icons: Record<"elementDown2", string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiHeaderNavigationItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SiHeaderNavigationItemComponent, "button[si-header-navigation-item], a[si-header-navigation-item]", never, {}, {}, never, ["*"], true, never>;
+}
+
+/** Container for actions that should be collapsed in mobile mode. */
+declare class SiHeaderCollapsibleActionsComponent implements OnDestroy {
+    private static idCounter;
+    /**
+     * Accessible label of the toggle button if actions are collapsed.
+     *
+     * @defaultValue
+     * ```
+     * t(() => $localize`:@@SI_APPLICATION_HEADER.TOGGLE_ACTIONS:Toggle actions`)
+     * ```
+     */
+    readonly mobileToggleLabel: _angular_core.InputSignal<_siemens_element_translate_ng_translate_types.TranslatableString>;
+    /** @internal **/
+    readonly mobileExpanded: _angular_core.WritableSignal<boolean>;
+    /** @internal **/
+    readonly badgeCount: _angular_core.WritableSignal<number>;
+    protected readonly id: string;
+    protected readonly icons: Record<"elementOptionsVertical", string>;
+    private readonly toggle;
+    private readonly focusTrap;
+    private header;
+    private closeMobileSub;
+    private inlineChangeSubscription?;
+    ngOnDestroy(): void;
+    protected toggleMobileExpanded(): void;
+    protected escapePressed(): void;
+    private openMobile;
+    private closeMobile;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiHeaderCollapsibleActionsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SiHeaderCollapsibleActionsComponent, "si-header-collapsible-actions", never, { "mobileToggleLabel": { "alias": "mobileToggleLabel"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
 /**
  * Copyright (c) Siemens 2016 - 2025
  * SPDX-License-Identifier: MIT
  */
-export * from './si-application-header.component';
-export * from './si-header-navigation-item.component';
-export * from './si-header-collapsible-actions.component';
-export * from './si-header-action-item.component';
-export * from './si-header-account-item.component';
-export * from './si-header-selection-item.component';
-export * from './si-header-siemens-logo.component';
-export * from './si-header-logo.directive';
-export * from './si-header-actions.directive';
-export * from './si-header-brand.directive';
-export * from './si-header-navigation.component';
-export * from './launchpad/si-launchpad-factory.component';
-export * from './launchpad/si-launchpad.model';
+
+declare abstract class SiHeaderActionItemBase implements OnInit {
+    /** @internal */
+    dropdownTrigger: SiHeaderDropdownTriggerDirective | null;
+    protected collapsibleActions: SiHeaderCollapsibleActionsComponent | null;
+    protected readonly icons: Record<"elementDown2", string>;
+    private header;
+    ngOnInit(): void;
+    protected click(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiHeaderActionItemBase, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SiHeaderActionItemBase, never, never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Base for icon based actions.
+ * @internal
+ */
+declare abstract class SiHeaderActionIconItemBase extends SiHeaderActionItemBase implements OnChanges, OnInit {
+    /**
+     * Adds a badge to the header item.
+     * If type
+     * - =number, the number will be shown and automatically trimmed if \>99
+     * - =true, an empty red dot will be shown
+     */
+    readonly badge: _angular_core.InputSignal<number | boolean | null | undefined>;
+    protected readonly badgeDot: _angular_core.Signal<boolean>;
+    protected readonly badgeValue: _angular_core.Signal<string | undefined>;
+    ngOnChanges(changes: SimpleChanges): void;
+    protected get visuallyHideTitle(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiHeaderActionIconItemBase, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SiHeaderActionIconItemBase, never, never, { "badge": { "alias": "badge"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Adds an action item to the header. Should be located inside `.header-actions`. */
+declare class SiHeaderActionItemComponent extends SiHeaderActionIconItemBase {
+    /** The icon to be shown. */
+    readonly icon: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiHeaderActionItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SiHeaderActionItemComponent, "button[si-header-action-item], a[si-header-action-item]", never, { "icon": { "alias": "icon"; "required": true; "isSignal": true; }; }, {}, never, ["si-avatar", "*"], true, never>;
+}
+
+/** Adds an account item to the header. Should be located inside `.header-actions`. */
+declare class SiHeaderAccountItemComponent extends SiHeaderActionIconItemBase {
+    /** Name of the account. */
+    readonly name: _angular_core.InputSignal<string>;
+    /** Initials of the account. If not provided, they will be calculated. */
+    readonly initials: _angular_core.InputSignal<string | undefined>;
+    /** URL to an image which should be shown instead of the initials. */
+    readonly imageUrl: _angular_core.InputSignal<string | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiHeaderAccountItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SiHeaderAccountItemComponent, "button[si-header-account-item]", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "initials": { "alias": "initials"; "required": false; "isSignal": true; }; "imageUrl": { "alias": "imageUrl"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class SiHeaderSelectionItemComponent extends SiHeaderActionItemBase {
+    /**
+     * Sets the open state which will only affect the arrow. Only use this property when not using {@link SiHeaderDropdownTriggerDirective}.
+     *
+     * @defaultValue false
+     */
+    readonly open: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiHeaderSelectionItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SiHeaderSelectionItemComponent, "button[si-header-selection-item]", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/** The siemens logo. Should be located inside `.header-brand`. */
+declare class SiHeaderLogoDirective implements OnInit {
+    protected readonly logoText: _angular_core.WritableSignal<string | undefined>;
+    private elementRef;
+    private injector;
+    ngOnInit(): void;
+    protected updateLogoText(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiHeaderLogoDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SiHeaderLogoDirective, "si-header-logo, [siHeaderLogo]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * The siemens logo.
+ * Should be located inside `.header-brand`.
+ *
+ * @deprecated Use the {@link SiHeaderLogoDirective} instead.
+ * The new component will use the logo provided by the global theme instead
+ * of containing a hard coded siemens logo.
+ * ```html
+ * // previous
+ * <a si-header-siemens-logo routerLink="/" aria-label="Siemens" class="d-none d-md-flex"></a>
+ * // new
+ * <a siHeaderLogo routerLink="/" class="d-none d-md-flex"></a>
+ * ```
+ *
+ */
+declare class SiHeaderSiemensLogoComponent extends SiHeaderLogoDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiHeaderSiemensLogoComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SiHeaderSiemensLogoComponent, "si-header-siemens-logo, [si-header-siemens-logo]", never, {}, {}, never, never, true, never>;
+}
+
+declare class SiHeaderActionsDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiHeaderActionsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SiHeaderActionsDirective, "si-header-actions", never, {}, {}, never, never, true, never>;
+}
+
+declare class SiHeaderBrandDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiHeaderBrandDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SiHeaderBrandDirective, "si-header-brand", never, {}, {}, never, never, true, never>;
+}
+
+declare class SiHeaderNavigationComponent implements OnDestroy {
+    protected header: SiApplicationHeaderComponent;
+    protected readonly icons: Record<"elementThumbnails", string>;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiHeaderNavigationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SiHeaderNavigationComponent, "si-header-navigation", never, {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Copyright (c) Siemens 2016 - 2025
+ * SPDX-License-Identifier: MIT
+ */
+
+/** Represents an app to be shown in the launchpad. */
+interface AppLink extends AppBase {
+    /** The type of the app. can be either 'link' or 'router-link' */
+    type?: 'link';
+    /** URL destination of the app. */
+    href: string;
+    /** Value for the anchor target attribute. */
+    target?: string;
+    /** Whether the app is the currently running app. */
+    active?: boolean;
+}
+interface AppRouterLink extends AppBase {
+    type: 'router-link';
+    /** Link for the angular router. Accepts the same values as {@link https://angular.dev/api/router/RouterLink}. */
+    routerLink: string | any[];
+    /** Navigation extras that are passed to the {@link https://angular.dev/api/router/NavigationExtras}. */
+    extras?: NavigationExtras;
+    /** Active match options for routerLinkActive {@link https://angular.dev/api/router/IsActiveMatchOptions}.*/
+    activeMatchOptions?: {
+        exact: boolean;
+    } | IsActiveMatchOptions;
+}
+/** Represents a categories in the launchpad. */
+interface AppCategory {
+    /** The name of the app category. */
+    name?: TranslatableString;
+    /** The apps to show under this category.  */
+    apps: App[];
+}
+interface AppBase {
+    /** Name of the app */
+    name: TranslatableString;
+    /** Name of the related system. */
+    systemName?: TranslatableString;
+    /** Icon of the app. */
+    iconUrl?: string;
+    /** CSS class to apply, which should render the icon. Typically, "element-*". */
+    iconClass?: string;
+    /** Whether the app is marked as favorite.  */
+    favorite?: boolean;
+    /** Whether the app should be marked as external. */
+    external?: boolean;
+}
+type App = AppLink | AppRouterLink;
+
+interface FavoriteChangeEvent {
+    app: App;
+    favorite: boolean;
+}
+declare class SiLaunchpadFactoryComponent {
+    /**
+     * Text to close the launchpad. Needed for a11y.
+     *
+     * @defaultValue
+     * ```
+     * t(() => $localize`:@@SI_LAUNCHPAD.CLOSE:Close launchpad`)
+     * ```
+     */
+    readonly closeText: _angular_core.InputSignal<_siemens_element_translate_ng_translate_types.TranslatableString>;
+    /**
+     * Title of the launchpad.
+     *
+     * @defaultValue
+     * ```
+     * t(() => $localize`:@@SI_LAUNCHPAD.TITLE:Launchpad`)
+     * ```
+     */
+    readonly titleText: _angular_core.InputSignal<_siemens_element_translate_ng_translate_types.TranslatableString>;
+    /**
+     * Subtitle of the launchpad.
+     *
+     * @defaultValue
+     * ```
+     * t(() => $localize`:@@SI_LAUNCHPAD.SUBTITLE:Access all your apps`)
+     * ```
+     */
+    readonly subtitleText: _angular_core.InputSignal<_siemens_element_translate_ng_translate_types.TranslatableString>;
+    /** All app items shown in the launchpad. */
+    readonly apps: _angular_core.InputSignal<App[] | AppCategory[]>;
+    /**
+     * Allow the user to select favorite apps which will then be displayed at the top.
+     *
+     * @defaultValue false
+     */
+    readonly enableFavorites: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Title of the favorite apps section.
+     *
+     * @defaultValue
+     * ```
+     * t(() => $localize`:@@SI_LAUNCHPAD.FAVORITE_APPS:Favorite apps`)
+     * ```
+     */
+    readonly favoriteAppsText: _angular_core.InputSignal<_siemens_element_translate_ng_translate_types.TranslatableString>;
+    /**
+     * Title of the show more apps button.
+     *
+     * @defaultValue
+     * ```
+     * t(() => $localize`:@@SI_LAUNCHPAD.SHOW_MORE:Show more`)
+     * ```
+     */
+    readonly showMoreAppsText: _angular_core.InputSignal<_siemens_element_translate_ng_translate_types.TranslatableString>;
+    /**
+     * Title of the show less apps button.
+     *
+     * @defaultValue
+     * ```
+     * t(() => $localize`:@@SI_LAUNCHPAD.SHOW_LESS:Show less`)
+     * ```
+     */
+    readonly showLessAppsText: _angular_core.InputSignal<_siemens_element_translate_ng_translate_types.TranslatableString>;
+    readonly favoriteChange: _angular_core.OutputEmitterRef<FavoriteChangeEvent>;
+    protected showAllApps: boolean;
+    protected readonly categories: _angular_core.Signal<AppCategory[]>;
+    protected readonly favorites: _angular_core.Signal<(_siemens_element_ng_application_header.AppLink | _siemens_element_ng_application_header.AppRouterLink)[]>;
+    protected readonly hasFavorites: _angular_core.Signal<boolean>;
+    protected readonly icons: Record<"elementDown2" | "elementCancel", string>;
+    protected readonly activatedRoute: ActivatedRoute | null;
+    private header;
+    protected closeLaunchpad(): void;
+    protected toggleFavorite(app: App, favorite: boolean): void;
+    protected escape(): void;
+    protected isCategories(items: App[] | AppCategory[]): items is AppCategory[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiLaunchpadFactoryComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SiLaunchpadFactoryComponent, "si-launchpad-factory", never, { "closeText": { "alias": "closeText"; "required": false; "isSignal": true; }; "titleText": { "alias": "titleText"; "required": false; "isSignal": true; }; "subtitleText": { "alias": "subtitleText"; "required": false; "isSignal": true; }; "apps": { "alias": "apps"; "required": true; "isSignal": true; }; "enableFavorites": { "alias": "enableFavorites"; "required": false; "isSignal": true; }; "favoriteAppsText": { "alias": "favoriteAppsText"; "required": false; "isSignal": true; }; "showMoreAppsText": { "alias": "showMoreAppsText"; "required": false; "isSignal": true; }; "showLessAppsText": { "alias": "showLessAppsText"; "required": false; "isSignal": true; }; }, { "favoriteChange": "favoriteChange"; }, never, never, true, never>;
+}
+
+export { SiApplicationHeaderComponent, SiHeaderAccountItemComponent, SiHeaderActionItemComponent, SiHeaderActionsDirective, SiHeaderBrandDirective, SiHeaderCollapsibleActionsComponent, SiHeaderLogoDirective, SiHeaderNavigationComponent, SiHeaderNavigationItemComponent, SiHeaderSelectionItemComponent, SiHeaderSiemensLogoComponent, SiLaunchpadFactoryComponent };
+export type { App, AppBase, AppCategory, AppLink, AppRouterLink, FavoriteChangeEvent };

package/auto-collapsable-list/index.d.ts

@@ -1,10 +1,114 @@
-/**
- * Copyright (c) Siemens 2016 - 2025
- * SPDX-License-Identifier: MIT
- */
-export * from './si-auto-collapsable-list-item.directive';
-export * from './si-auto-collapsable-list.directive';
-export * from './si-auto-collapsable-list-overflow-item.directive';
-export * from './si-auto-collapsable-list-measurable.class';
-export * from './si-auto-collapsable-list-additional-content.directive';
-export * from './si-auto-collapsable-list.module';
+import * as i0 from '@angular/core';
+import { ElementRef, AfterViewInit, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
+import * as rxjs from 'rxjs';
+
+declare class SiAutoCollapsableListMeasurable {
+    protected readonly elementRef: ElementRef<any>;
+    private readonly resizeObserverService;
+    /**
+     * Emits on element width changes.
+     *
+     * @defaultValue
+     * ```
+     * this.resizeObserverService
+     *       .observe(this.elementRef.nativeElement, 0, true, true)
+     *       .pipe(
+     *         map(size => size.width),
+     *         distinctUntilChanged(),
+     *         shareReplay(1)
+     *       )
+     * ```
+     */
+    size$: rxjs.Observable<number>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiAutoCollapsableListMeasurable, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SiAutoCollapsableListMeasurable, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class SiAutoCollapsableListItemDirective extends SiAutoCollapsableListMeasurable implements AfterViewInit {
+    /**
+     * Hide this item even if enough space is available.
+     * When calculating the overall available size, this item is still considered when forceHide=true
+     *
+     * @defaultValue false
+     */
+    readonly forceHide: i0.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * True if enough space is available for this item.
+     *
+     * @defaultValue false
+     */
+    readonly canBeVisible: i0.WritableSignal<boolean>;
+    /**
+     * True if this item is actually visible to the user
+     */
+    readonly isVisible: i0.Signal<boolean>;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiAutoCollapsableListItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SiAutoCollapsableListItemDirective, "[siAutoCollapsableListItem]", ["siAutoCollapsableListItem"], { "forceHide": { "alias": "forceHide"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class SiAutoCollapsableListDirective implements AfterViewInit, OnChanges, OnDestroy {
+    /**
+     * The items which are displayed in the siAutoCollapsableList.
+     */
+    readonly items: i0.Signal<readonly SiAutoCollapsableListItemDirective[]>;
+    private readonly overflowItem;
+    private readonly additionalContent;
+    /** @defaultValue true */
+    readonly siAutoCollapsableList: i0.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * The (flex) gap in pixels, will automatically be set if a pixel value is used in CSS.
+     */
+    readonly gap: i0.InputSignal<number | undefined>;
+    /**
+     * The element which size is available for the content of the siAutoCollapsableList.
+     *
+     * @defaultValue undefined
+     */
+    readonly containerElement: i0.InputSignal<HTMLElement | null | undefined>;
+    private resizeSubscription?;
+    private disableInitSubscription?;
+    private readonly elementRef;
+    private readonly resizeObserverService;
+    private readonly changeDetectorRef;
+    private readonly containerElementSubject;
+    /**
+     * The same as {@link gap}, but automatically read from the computed styles.
+     * Used if not set by user.
+     */
+    private computedGap;
+    private injector;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    private setupResizeListener;
+    private updateItemVisibility;
+    private reset;
+    private readGapSize;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiAutoCollapsableListDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SiAutoCollapsableListDirective, "[siAutoCollapsableList]", ["siAutoCollapsableList"], { "siAutoCollapsableList": { "alias": "siAutoCollapsableList"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "containerElement": { "alias": "siAutoCollapsableListContainerElement"; "required": false; "isSignal": true; }; }, {}, ["items", "overflowItem", "additionalContent"], never, true, never>;
+}
+
+declare class SiAutoCollapsableListOverflowItemDirective extends SiAutoCollapsableListItemDirective {
+    /**
+     * Number of hidden items.
+     *
+     * @defaultValue 0
+     */
+    hiddenItemCount: number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiAutoCollapsableListOverflowItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SiAutoCollapsableListOverflowItemDirective, "[siAutoCollapsableListOverflowItem]", ["siAutoCollapsableListOverflowItem"], {}, {}, never, never, true, never>;
+}
+
+declare class SiAutoCollapsableListAdditionalContentDirective extends SiAutoCollapsableListMeasurable {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiAutoCollapsableListAdditionalContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SiAutoCollapsableListAdditionalContentDirective, "[siAutoCollapsableListAdditionalContent]", never, {}, {}, never, never, true, never>;
+}
+
+declare class SiAutoCollapsableListModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiAutoCollapsableListModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SiAutoCollapsableListModule, never, [typeof SiAutoCollapsableListAdditionalContentDirective, typeof SiAutoCollapsableListDirective, typeof SiAutoCollapsableListItemDirective, typeof SiAutoCollapsableListOverflowItemDirective], [typeof SiAutoCollapsableListAdditionalContentDirective, typeof SiAutoCollapsableListDirective, typeof SiAutoCollapsableListItemDirective, typeof SiAutoCollapsableListOverflowItemDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SiAutoCollapsableListModule>;
+}
+
+export { SiAutoCollapsableListAdditionalContentDirective, SiAutoCollapsableListDirective, SiAutoCollapsableListItemDirective, SiAutoCollapsableListMeasurable, SiAutoCollapsableListModule, SiAutoCollapsableListOverflowItemDirective };

package/autocomplete/index.d.ts

@@ -1,8 +1,77 @@
-/**
- * Copyright (c) Siemens 2016 - 2025
- * SPDX-License-Identifier: MIT
- */
-export * from './si-autocomplete-listbox.directive';
-export * from './si-autocomplete-option.directive';
-export * from './si-autocomplete.directive';
-export * from './si-autocomplete.module';
+import * as i0 from '@angular/core';
+import { OnInit } from '@angular/core';
+import { Highlightable } from '@angular/cdk/a11y';
+
+declare class SiAutocompleteOptionDirective<T = unknown> implements Highlightable {
+    private static idCounter;
+    private element;
+    private parent;
+    /**
+     * @defaultValue
+     * ```
+     * `__si-autocomplete-option-${SiAutocompleteOptionDirective.idCounter++}`
+     * ```
+     */
+    readonly id: i0.InputSignal<string>;
+    /** @defaultValue false */
+    readonly disabledInput: i0.InputSignalWithTransform<boolean, unknown>;
+    get disabled(): boolean;
+    /** @defaultValue undefined */
+    readonly value: i0.InputSignal<T | undefined>;
+    protected active?: boolean;
+    protected click(): void;
+    /** @internal */
+    setActiveStyles(): void;
+    /** @internal */
+    setInactiveStyles(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiAutocompleteOptionDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SiAutocompleteOptionDirective<any>, "[siAutocompleteOption]", ["siAutocompleteOption"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "value": { "alias": "siAutocompleteOption"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class SiAutocompleteDirective<T> {
+    /** @internal */
+    listbox?: SiAutocompleteListboxDirective<T>;
+    protected get activeDescendant(): string;
+    protected get ariaControls(): string | undefined;
+    protected get expanded(): boolean;
+    protected keydown(event: KeyboardEvent): void;
+    get active(): SiAutocompleteOptionDirective<T> | undefined | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiAutocompleteDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SiAutocompleteDirective<any>, "input[siAutocomplete]", ["siAutocomplete"], {}, {}, never, never, true, never>;
+}
+
+declare class SiAutocompleteListboxDirective<T> implements OnInit {
+    private static idCounter;
+    private readonly options;
+    /**
+     * @defaultValue
+     * ```
+     * `__si-autocomplete-listbox-${SiAutocompleteListboxDirective.idCounter++}`
+     * ```
+     */
+    readonly id: i0.InputSignal<string>;
+    readonly autocomplete: i0.InputSignal<SiAutocompleteDirective<T>>;
+    /** @defaultValue 0 */
+    readonly siAutocompleteDefaultIndex: i0.InputSignal<number>;
+    readonly siAutocompleteOptionSubmitted: i0.OutputEmitterRef<T | undefined>;
+    private injector;
+    private keyManager;
+    private changeDetectorRef;
+    private destroyRef;
+    constructor();
+    ngOnInit(): void;
+    private setActiveItem;
+    /** @internal */
+    onKeydown(event: KeyboardEvent): void;
+    get active(): SiAutocompleteOptionDirective<T> | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiAutocompleteListboxDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SiAutocompleteListboxDirective<any>, "[siAutocompleteListboxFor]", ["siAutocompleteListbox"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "siAutocompleteListboxFor"; "required": true; "isSignal": true; }; "siAutocompleteDefaultIndex": { "alias": "siAutocompleteDefaultIndex"; "required": false; "isSignal": true; }; }, { "siAutocompleteOptionSubmitted": "siAutocompleteOptionSubmitted"; }, ["options"], never, true, never>;
+}
+
+declare class SiAutocompleteModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiAutocompleteModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SiAutocompleteModule, never, [typeof SiAutocompleteDirective, typeof SiAutocompleteListboxDirective, typeof SiAutocompleteOptionDirective], [typeof SiAutocompleteDirective, typeof SiAutocompleteListboxDirective, typeof SiAutocompleteOptionDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SiAutocompleteModule>;
+}
+
+export { SiAutocompleteDirective, SiAutocompleteListboxDirective, SiAutocompleteModule, SiAutocompleteOptionDirective };