@siemens/element-ng 47.7.0 → 48.0.0-next.1

package/column-selection-dialog/index.d.ts

@@ -1,6 +1,93 @@
+import { TranslatableString } from '@siemens/element-translate-ng/translate';
+import { ModalDependencyInjectionOptions } from '@siemens/element-ng/modal';
+import { Observable } from 'rxjs';
+import * as i0 from '@angular/core';
+
 /**
  * Copyright (c) Siemens 2016 - 2025
  * SPDX-License-Identifier: MIT
  */
-export * from './si-column-selection-dialog.types';
-export * from './si-column-selection-dialog.service';
+
+interface Column {
+    /**
+     * Unique id
+     */
+    id: string;
+    /**
+     * Title of the column.
+     */
+    title: string;
+    /**
+     * Decides if the column is visible to the user.
+     */
+    visible: boolean;
+    /**
+     * If true, the order of the column can be changed by dragging it to another position.
+     */
+    draggable: boolean;
+    /**
+     * If true, the column is disabled and cannot be interacted with.
+     * This means, the user cannot change any of the column options
+     * like the visibility etc.
+     */
+    disabled: boolean;
+    /**
+     * If true, the {@link title} can be renamed.
+     */
+    editable?: boolean;
+}
+interface SiColumnSelectionDialogConfig {
+    heading: TranslatableString;
+    bodyTitle: TranslatableString;
+    submitBtnName?: TranslatableString;
+    cancelBtnName?: TranslatableString;
+    restoreToDefaultBtnName?: TranslatableString;
+    hiddenText?: TranslatableString;
+    visibleText?: TranslatableString;
+    columnVisibilityConfigurable?: boolean;
+    restoreEnabled?: boolean;
+    columns: Column[];
+    translationParams?: {
+        [key: string]: any;
+    };
+    listAriaLabel?: TranslatableString;
+    renameInputAriaLabel?: TranslatableString;
+    a11yItemMovedMessage?: TranslatableString;
+    a11yItemNotMovedMessage?: TranslatableString;
+}
+interface ColumnSelectionDialogResult {
+    type: ColumnSelectionDialogResultType;
+    columns: Column[];
+    /** when `type === 'restoreDefault'`, this function is set and allows to provide the columns */
+    updateColumns?: (columns: Column[]) => void;
+}
+/**
+ * Emit type of dialog actions.
+ *
+ * `ok` : Emitted when user submits.
+ * `cancel` : Emitted when user clicks cancel.
+ * `instant` : Emitted when visibility or place of a row changes.
+ *
+ * `instant` type is used to reflect the ui changes real time even before closing the dialog.
+ */
+type ColumnSelectionDialogResultType = 'ok' | 'cancel' | 'instant' | 'restoreDefault';
+
+declare class SiColumnSelectionDialogService {
+    private modalService;
+    /**
+     * Opens a column selection dialog.
+     *
+     * Despite other dialogs,
+     * this dialog informs the consumer not ONLY with clicking `submit` or `cancel`,
+     * but also with changing the place or visibility of a dialog row
+     * thanks to the `instant` type of emitted event.
+     *
+     * {@label WITH_OBJECT}
+     */
+    showColumnSelectionDialog(dialogConfig: SiColumnSelectionDialogConfig, diOptions?: ModalDependencyInjectionOptions): Observable<ColumnSelectionDialogResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiColumnSelectionDialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SiColumnSelectionDialogService>;
+}
+
+export { SiColumnSelectionDialogService };
+export type { Column, ColumnSelectionDialogResult, ColumnSelectionDialogResultType, SiColumnSelectionDialogConfig };

package/common/index.d.ts

@@ -1,8 +1,425 @@
+import * as rxjs from 'rxjs';
+import * as i0 from '@angular/core';
+import { InjectionToken, Type, Provider, TrackByFunction, ElementRef } from '@angular/core';
+import { Link } from '@siemens/element-ng/link';
+import { TranslatableString } from '@siemens/element-translate-ng/translate';
+import { ConnectionPositionPair, Overlay, PositionStrategy, OverlayRef, FlexibleConnectedPositionStrategy, ConnectedOverlayPositionChange } from '@angular/cdk/overlay';
+
+/**
+ * A global blink pulse generator for synchronized blinking patterns across an entire application.
+ * Use to trigger any blinking by subscribing to `pulse$`.
+ */
+declare class BlinkService {
+    private pause$;
+    private off$;
+    private on$;
+    /**
+     * Blink pulse. Subscribe to it to toggle `on` CSS class when true, `off` CSS class when `false`.
+     * Do animations using CSS transitions
+     *
+     * @defaultValue
+     * ```
+     * timer(0, 1400).pipe(
+     *     map(count => count % 2 === 0),
+     *     distinctUntilChanged(),
+     *     takeUntil(this.off$),
+     *     endWith(false),
+     *     repeat({ delay: () => this.on$ }),
+     *     share()
+     *   )
+     * ```
+     */
+    readonly pulse$: rxjs.Observable<boolean>;
+    /**
+     * Pause the blinking.
+     */
+    pause(): void;
+    /**
+     * Resume the blinking.
+     */
+    resume(): void;
+    /**
+     * Whether the blinking is paused or not.
+     */
+    isPaused(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BlinkService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BlinkService>;
+}
+
+/**
+ * Interface that defines a UIStateStore.
+ * It must be provided via {@link provideSiUiState}.
+ */
+interface UIStateStorage {
+    /**
+     * Saves data under a specific stateId.
+     * Already existing data for that stateId should be overridden.
+     * Asynchronous implementations must return a {@link Promise} and resolve it once saving was completed.
+     *
+     * Errors should be handled by the implementation.
+     * The `SiUIStateService` does not handle errors.
+     */
+    save(stateId: string, data: string): void | Promise<void>;
+    /**
+     * Loads data for a specific stateId.
+     * Can be asynchronous.
+     *
+     * Errors should be handled by the implementation.
+     * The `SiUIStateService` does not handle errors.
+     *
+     * @returns The data or undefined if the data does not exist.
+     * Asynchronous implementations must return a {@link Promise} containing the data.
+     */
+    load(stateId: string): string | undefined | null | Promise<string | undefined | null>;
+}
+/** @internal */
+declare const SI_UI_STATE_SERVICE: InjectionToken<SiUIStateService>;
+/**
+ * Service to save and load UI states.
+ * @internal
+ */
+declare class SiUIStateService {
+    private storage;
+    /**
+     * Saves the provided state in the storage.
+     * @param stateId - The unique id or key under which the state shall be saved.
+     * @param state - The state to be saved.
+     * @param version - The version of the state object.
+     * This can be used to migrate state objects.
+     */
+    save<TState>(stateId: string, state: TState, version?: number): Promise<void>;
+    /**
+     * Loads and returns the state for the given stateId and version.
+     * @param stateId - The unique id or key for which the state shall be loaded.
+     * @param version - The version of the state object.
+     * This can be used to migrate state objects.
+     * @returns A Promise containing the state or undefined if the state does not exist or the version did not match.
+     */
+    load<TState = unknown>(stateId: string, version?: number): PromiseLike<TState | undefined>;
+    private readData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiUIStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SiUIStateService>;
+}
+
+/** Enables the automatic storage of UI state for enabled components. */
+declare const provideSiUiState: (config?: {
+    store?: Type<UIStateStorage>;
+}) => Provider[];
+
+interface FontStyleOverride {
+    fontStyle?: string;
+    fontVariant?: string;
+    fontWeight?: string;
+    fontSize?: string;
+    fontFamily?: string;
+}
+declare class TextMeasureService {
+    private measureCanvas?;
+    private defaultFont?;
+    private document;
+    /** Measure text width in pixel. */
+    measureText(text: string, fontRef?: HTMLElement | string, overrides?: FontStyleOverride): number;
+    /** Get font styles for `font` CSS short-hand property. */
+    getFontStyle(element: HTMLElement, overrides?: FontStyleOverride): string;
+    private ensureCanvas;
+    private setFontStyle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextMeasureService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TextMeasureService>;
+}
+
+/**
+ * Gets the width of the scrollbar.  Nesc for windows
+ * http://stackoverflow.com/a/13382873/888165
+ */
+declare class ScrollbarHelper {
+    private document;
+    /**
+     * The width of the scrollbar.
+     *
+     * @defaultValue this.getWidth()
+     */
+    readonly width: number;
+    private getWidth;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollbarHelper, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScrollbarHelper>;
+}
+
+/**
+ * Copyright (c) Siemens 2016 - 2025
+ * SPDX-License-Identifier: MIT
+ */
+/**
+ * Use this type with filter components `colorVariant` to render component variants based on background of container
+ */
+type BackgroundColorVariant = 'base-1' | 'base-0';
+
+/**
+ * Copyright (c) Siemens 2016 - 2025
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * The MenuItem is used to configure clickable items in menus.
+ * They support a name, link, icons and sub-menu items.
+ *
+ * @deprecated This interface should no longer be used.
+ * Use a corresponding alternative based on your use case:
+ * - for {@link SiMenuFactoryComponent} use {@link @siemens/element-ng/menu#MenuItem}
+ * - for {@link SiContentActionBarComponent} use {@link @siemens/element-ng/menu#MenuItem} and {@link ContentActionBarMainItem}
+ * - for {@link SiNavbarVerticalComponent} use {@link NavbarVerticalItem}
+ * - for {@link @siemens/dashboards-ng#SiFlexibleDashboardComponent}
+ *   use {@link @siemens/dashboards-ng#DashboardToolbarItem}
+ */
+interface MenuItem extends Link {
+    /**
+     * An optional id to uniquely identify the menu item.
+     */
+    id?: string;
+    /**
+     * The web font icon class name (e.g. element-settings-outline).
+     */
+    icon?: string;
+    /**
+     * The value for an image src tag. Maybe a relative or absolute link to an
+     * jpg or gif image.
+     */
+    image?: string;
+    /**
+     * A navigation bar item can have a sub-menu, if these items are set. They
+     * define the sub-menu content.
+     */
+    items?: MenuItem[];
+    /**
+     * If the menu item has children you can specify
+     * if they are visible or not.
+     */
+    expanded?: boolean;
+    /**
+     * Defines if only the icon is shown in the default navigation bar.
+     */
+    iconOnly?: boolean;
+    /**
+     * Defines if custom content is chosen in account dropdown
+     * (otherwise accountItems are used)
+     */
+    customContent?: boolean;
+    /**
+     * Defines the content of the optional badge. Should be a number or something like "100+".
+     * if undefined or empty string, no badge is displayed
+     */
+    badge?: string | number;
+    /**
+     * Defines the background color of the badge. Default is specific to Element flavour.
+     */
+    badgeColor?: string;
+    /**
+     * Defines the badge style
+     */
+    badgeStyle?: 'inline' | 'dot' | '';
+    /**
+     * Show a dot badge without content?
+     */
+    badgeDot?: boolean;
+    /**
+     * For single/multi choice items: the kind of icon to show.
+     */
+    selectionState?: 'check' | 'radio' | '';
+    /**
+     * Type to distinguish between check and radio menu items. Needs to be set for correct interaction and used for a11y.
+     */
+    type?: 'check' | 'radio';
+    /**
+     * Whether the menu item should be displayed as a heading/title, will also disable links and actions.
+     */
+    isHeading?: boolean;
+    /**
+     * Whether the menu items sub-menu should open upwards instead of downwards.
+     */
+    dropUpwards?: boolean;
+}
+type NavbarItem = MenuItem;
+
+/**
+ * Copyright (c) Siemens 2016 - 2025
+ * SPDX-License-Identifier: MIT
+ */
+
+type StatusType = 'success' | 'info' | 'warning' | 'danger' | 'caution' | 'critical';
+type ExtendedStatusType = StatusType | 'unknown';
+type EntityStatusType = ExtendedStatusType | 'pending' | 'progress';
+type AccentLineType = StatusType | 'caution' | 'primary' | 'inactive';
+interface StatusIcon {
+    icon: string;
+    color: string;
+    stacked: string;
+    stackedColor: string;
+    background: string;
+    severity: number;
+    ariaLabel?: TranslatableString;
+}
+declare const STATUS_ICON: {
+    [key in EntityStatusType]: StatusIcon;
+};
+
+/**
+ * Copyright (c) Siemens 2016 - 2025
+ * SPDX-License-Identifier: MIT
+ */
+
+declare const positionTopCenter: ConnectionPositionPair;
+declare const positionTopStart: ConnectionPositionPair;
+declare const positionTopEnd: ConnectionPositionPair;
+declare const positionBottomCenter: ConnectionPositionPair;
+declare const positionBottomStart: ConnectionPositionPair;
+declare const positionBottomEnd: ConnectionPositionPair;
+declare const positions: {
+    top: ConnectionPositionPair[];
+    end: ConnectionPositionPair[];
+    bottom: ConnectionPositionPair[];
+    start: ConnectionPositionPair[];
+    auto: ConnectionPositionPair[];
+};
+
+/**
+ * Copyright (c) Siemens 2016 - 2025
+ * SPDX-License-Identifier: MIT
+ */
+/**
+ * @returns Returns whether animations are disabled via the CSS var. This is either set by
+ * an application on low-end devices or in case the device is configured for reduced motion
+ * (i.e. `@media (prefers-reduced-motion)` matches)
+ */
+declare const areAnimationsDisabled: () => boolean;
+
+type Direction = 'down' | 'up' | 'start' | 'end';
+type PlacementBasicVertical = 'top' | 'bottom';
+type PlacementBasic = 'start' | 'end' | PlacementBasicVertical;
+type Placement = '' | PlacementBasic | `${PlacementBasic} ${PlacementBasic}`;
+type Align = 'start' | 'center' | 'end';
+declare const AXIS_X: {
+    readonly axis: "X";
+    readonly directionRegular: "end";
+    readonly directionReverse: "start";
+    readonly upperBound: "left";
+    readonly lowerBound: "right";
+    readonly size: "width";
+    readonly windowSize: "innerWidth";
+};
+declare const AXIS_Y: {
+    readonly axis: "Y";
+    readonly directionRegular: "down";
+    readonly directionReverse: "up";
+    readonly upperBound: "top";
+    readonly lowerBound: "bottom";
+    readonly size: "height";
+    readonly windowSize: "innerHeight";
+};
+declare const BOUNDING_RECT_WINDOW: {
+    getBoundingClientRect: () => {
+        top: number;
+        left: number;
+        bottom: number;
+        right: number;
+    };
+};
+declare const resolveReference: (hostElement: HTMLElement, reference: string) => HTMLElement | null;
+declare const getContentPositionString: (params: {
+    contentElement: HTMLElement;
+    direction: Direction;
+    placement: Placement;
+    placementReferenceElement: HTMLElement;
+    align: Align;
+    rtl?: boolean;
+}) => string;
+declare const responsivelyCheckDirection: (params: {
+    isScrolling?: boolean;
+    currentDirection: Direction;
+    contentElements: HTMLElement[];
+    hostElement: HTMLElement | null;
+    placement: Placement;
+    placementReferenceElement: HTMLElement;
+    align: Align;
+    responsiveDirectionToPlacement: boolean;
+    closeOnPlacementReferenceScrollOut: boolean;
+    closeOnContentScrollOut: boolean;
+    minSpaceThresholdFactor?: number;
+    placementReverse?: Placement;
+    rtl?: boolean;
+}) => {
+    responsiveDirection?: Direction;
+    close: boolean;
+};
+
+/**
+ * Copyright (c) Siemens 2016 - 2025
+ * SPDX-License-Identifier: MIT
+ */
+declare const isRTL: (elem?: HTMLElement) => boolean;
+declare const correctKeyRTL: (key: string) => string;
+
+/**
+ * Copyright (c) Siemens 2016 - 2025
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * Creates a trackByFunction for ngFor, that tracks an Item by its identity.
+ * It should be used with a generic parameter, to generate a proper type:
+ *
+ * @example
+ * ```ts
+ * @Input() trackByFunction = buildTrackByIdentity<ItemType>()
+ * ```
+ * @deprecated use the new control-flow syntax
+ */
+declare const buildTrackByIdentity: <T>() => TrackByFunction<T>;
+/**
+ * Creates a trackByFunction for ngFor, that tracks an Item by its index.
+ * It should be used with a generic parameter, to generate a proper type:
+ *
+ * @example
+ * ```
+ * @Input() trackByFunction = buildTrackByIdentity<ItemType>()
+ * ```
+ * @deprecated use the new control-flow syntax
+ */
+declare const buildTrackByIndex: <T>() => TrackByFunction<T>;
+
+/**
+ * Copyright (c) Siemens 2016 - 2025
+ * SPDX-License-Identifier: MIT
+ */
+declare const listenGlobal: (eventName: string, handler: (e: any) => void, active?: boolean) => (() => void);
+
+/**
+ * Copyright (c) Siemens 2016 - 2025
+ * SPDX-License-Identifier: MIT
+ */
+
+declare function makePositionStrategy(elementRef: ElementRef<any> | undefined, overlay: Overlay, placement: keyof typeof positions | ConnectionPositionPair[], constrain?: boolean, center?: boolean): PositionStrategy;
+declare function makeOverlay(positionStrategy: PositionStrategy, overlay: Overlay, hasBackdrop: boolean): OverlayRef;
+declare function getOverlay(elementRef: ElementRef<any>, overlay: Overlay, hasBackdrop: boolean, placement: keyof typeof positions | ConnectionPositionPair[], constrain?: boolean, center?: boolean): OverlayRef;
+declare function getPositionStrategy(overlayref: OverlayRef): FlexibleConnectedPositionStrategy | undefined;
+declare function getOverlayPositions(elementRef: ElementRef<any>, placement: keyof typeof positions | ConnectionPositionPair[], center?: boolean): ConnectionPositionPair[];
+declare function hasTrigger(trigger: string, triggers?: string): boolean;
+interface OverlayArrowPosition {
+    left?: number;
+    right?: number;
+}
+/**
+ * calculates the arrow position from left/right for tooltips, popovers, etc
+ * @param change - the event from the position strategy
+ * @param overlay - ElementRef for the overlay content, i.e. the popover/tooltip component
+ * @param anchor - ElementRef for the anchoring element, i.e. the trigger of the popover/tooltip
+ */
+declare function calculateOverlayArrowPosition(change: ConnectedOverlayPositionChange, overlay: ElementRef, anchor?: ElementRef): OverlayArrowPosition;
+
 /**
  * Copyright (c) Siemens 2016 - 2025
  * SPDX-License-Identifier: MIT
  */
-export * from './services';
-export * from './models';
-export * from './helpers';
-export * from './decorators';
+
+declare function WebComponentContentChildren<T>(host: Type<T>): (...args: any) => void;
+
+export { AXIS_X, AXIS_Y, BOUNDING_RECT_WINDOW, BlinkService, SI_UI_STATE_SERVICE, STATUS_ICON, ScrollbarHelper, SiUIStateService, TextMeasureService, WebComponentContentChildren, areAnimationsDisabled, buildTrackByIdentity, buildTrackByIndex, calculateOverlayArrowPosition, correctKeyRTL, getContentPositionString, getOverlay, getOverlayPositions, getPositionStrategy, hasTrigger, isRTL, listenGlobal, makeOverlay, makePositionStrategy, positionBottomCenter, positionBottomEnd, positionBottomStart, positionTopCenter, positionTopEnd, positionTopStart, positions, provideSiUiState, resolveReference, responsivelyCheckDirection };
+export type { AccentLineType, Align, BackgroundColorVariant, Direction, EntityStatusType, ExtendedStatusType, FontStyleOverride, MenuItem, NavbarItem, OverlayArrowPosition, Placement, PlacementBasic, PlacementBasicVertical, StatusIcon, StatusType, UIStateStorage };

package/connection-strength/index.d.ts

@@ -1,6 +1,29 @@
-/**
- * Copyright (c) Siemens 2016 - 2025
- * SPDX-License-Identifier: MIT
- */
-export * from './si-connection-strength.component';
-export * from './si-connection-strength.module';
+import * as i0 from '@angular/core';
+
+type ConnectionStrength = 'none' | 'low' | 'medium' | 'strong';
+declare class SiConnectionStrengthComponent {
+    /**
+     * Shows the signal representation in an alternative *WLAN* format
+     *
+     * @defaultValue false
+     */
+    readonly wlan: i0.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Main value representing the current connection strength.
+     *
+     * @defaultValue 'none'
+     */
+    readonly value: i0.InputSignal<ConnectionStrength>;
+    protected readonly numberValue: i0.Signal<number>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiConnectionStrengthComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SiConnectionStrengthComponent, "si-connection-strength", never, { "wlan": { "alias": "wlan"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class SiConnectionStrengthModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiConnectionStrengthModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SiConnectionStrengthModule, never, [typeof SiConnectionStrengthComponent], [typeof SiConnectionStrengthComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SiConnectionStrengthModule>;
+}
+
+export { SiConnectionStrengthComponent, SiConnectionStrengthModule };
+export type { ConnectionStrength };

package/content-action-bar/index.d.ts

@@ -1,7 +1,92 @@
+import * as _siemens_element_translate_ng_translate_types from '@siemens/element-translate-ng/translate-types';
+import * as _angular_core from '@angular/core';
+import { OnChanges, AfterViewInit, SimpleChanges } from '@angular/core';
+import { MenuItem } from '@siemens/element-ng/common';
+import { MenuItemAction, MenuItemCheckbox, MenuItemLink, MenuItemRouterLink, MenuItemGroup, MenuItem as MenuItem$1, MenuItemRadio } from '@siemens/element-ng/menu';
+
 /**
  * Copyright (c) Siemens 2016 - 2025
  * SPDX-License-Identifier: MIT
  */
-export * from './si-content-action-bar.component';
-export * from './si-content-action-bar.module';
-export * from './si-content-action-bar.model';
+
+type ViewType = 'collapsible' | 'expanded' | 'mobile';
+type ContentActionBarMainItem = (MenuItemAction | MenuItemCheckbox | MenuItemLink | MenuItemRouterLink | MenuItemGroup) & {
+    iconOnly?: boolean;
+};
+
+declare class SiContentActionBarComponent implements OnChanges, AfterViewInit {
+    /**
+     * List of primary actions. Supports up to **4** actions and omits additional ones.
+     */
+    readonly primaryActions: _angular_core.InputSignal<readonly (ContentActionBarMainItem | MenuItem)[] | undefined>;
+    /**
+     * List of secondary actions.
+     */
+    readonly secondaryActions: _angular_core.InputSignal<readonly (MenuItem | MenuItem$1)[] | undefined>;
+    /**
+     * A param that will be passed to the `action` in the primary/secondary actions.
+     * This allows to re-use the same primary/secondary action arrays across rows
+     * in a table.
+     */
+    readonly actionParam: _angular_core.InputSignal<any>;
+    /**
+     * Selection of view type as 'collapsible', 'expanded' or 'mobile'.
+     *
+     * @defaultValue 'expanded'
+     */
+    readonly viewType: _angular_core.InputSignal<ViewType>;
+    /**
+     * Toggle icon aria-label, required for a11y
+     *
+     * @defaultValue
+     * ```
+     * t(() => $localize`:@@SI_CONTENT_ACTION_BAR.TOGGLE:Toggle`)
+     * ```
+     */
+    readonly toggleItemLabel: _angular_core.InputSignal<_siemens_element_translate_ng_translate_types.TranslatableString>;
+    /**
+     * Option to remove all icons from dropdown menus of the content action bar.
+     *
+     * Some apps provide only few actions with icons, located in the set of primary actions.
+     * The icons are visible in the `collapsible` and `expanded` view type. On reduced space,
+     * primary actions are relocated in the same dropdown menu as the secondary actions. The
+     * dropdown menu can look unbalanced, if a large number of secondary actions without
+     * icons are presented with few actions with icons. This option balances the look and feel
+     * by removing all icons from actions in the dropdown menu.
+     *
+     * @defaultValue false
+     */
+    readonly preventIconsInDropdownMenus: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Disables the whole content-action-bar.
+     *
+     * @defaultValue false
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly expandElement;
+    private readonly menuBarElement;
+    protected readonly mobileActions: _angular_core.Signal<readonly (MenuItem | MenuItem$1)[]>;
+    protected readonly secondaryActionsInternal: _angular_core.Signal<readonly (MenuItem | MenuItem$1)[] | undefined>;
+    protected readonly icons: Record<"elementCancel" | "elementOptionsVertical", string>;
+    protected expanded: boolean;
+    protected parentElement?: HTMLElement | null;
+    private elementRef;
+    private menuActionService;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    protected expand(): void;
+    protected collapse(): void;
+    protected isNewItemStyle(item: MenuItem | ContentActionBarMainItem): item is ContentActionBarMainItem;
+    protected runAction(item: MenuItemAction | MenuItemRadio | MenuItemCheckbox): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiContentActionBarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SiContentActionBarComponent, "si-content-action-bar", never, { "primaryActions": { "alias": "primaryActions"; "required": false; "isSignal": true; }; "secondaryActions": { "alias": "secondaryActions"; "required": false; "isSignal": true; }; "actionParam": { "alias": "actionParam"; "required": false; "isSignal": true; }; "viewType": { "alias": "viewType"; "required": false; "isSignal": true; }; "toggleItemLabel": { "alias": "toggleItemLabel"; "required": false; "isSignal": true; }; "preventIconsInDropdownMenus": { "alias": "preventIconsInDropdownMenus"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class SiContentActionBarModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiContentActionBarModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<SiContentActionBarModule, never, [typeof SiContentActionBarComponent], [typeof SiContentActionBarComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<SiContentActionBarModule>;
+}
+
+export { SiContentActionBarComponent, SiContentActionBarModule };
+export type { ContentActionBarMainItem, ViewType };