import * as rxjs from 'rxjs';
import * as i0 from '@angular/core';
import { InjectionToken, Type, Provider, ElementRef } from '@angular/core';
import { Link } from '@siemens/element-ng/link';
import { TranslatableString } from '@siemens/element-translate-ng/translate';
import { ConnectionPositionPair, ConnectedOverlayPositionChange, Overlay, OverlayRef, FlexibleConnectedPositionStrategy, PositionStrategy } 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 - 2026
 * 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 - 2026
 * 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 - 2026
 * 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 - 2026
 * 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 - 2026
 * 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;

/** @deprecated Use the CDK Overlay instead. */
type Direction = 'down' | 'up' | 'start' | 'end';
/** @deprecated Use the CDK Overlay instead. */
type PlacementBasicVertical = 'top' | 'bottom';
/** @deprecated Use the CDK Overlay instead. */
type PlacementBasic = 'start' | 'end' | PlacementBasicVertical;
/** @deprecated Use the CDK Overlay instead. */
type Placement = '' | PlacementBasic | `${PlacementBasic} ${PlacementBasic}`;
/** @deprecated Use the CDK Overlay instead. */
type Align = 'start' | 'center' | 'end';
/** @deprecated Use the CDK Overlay instead. */
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";
};
/** @deprecated Use the CDK Overlay instead. */
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";
};
/** @deprecated Use the CDK Overlay instead. */
declare const BOUNDING_RECT_WINDOW: {
    getBoundingClientRect: () => {
        top: number;
        left: number;
        bottom: number;
        right: number;
    };
};
/** @deprecated Use the CDK Overlay instead. */
declare const resolveReference: (hostElement: HTMLElement, reference: string) => HTMLElement | null;
/** @deprecated Use the CDK Overlay instead. */
declare const getContentPositionString: (params: {
    contentElement: HTMLElement;
    direction: Direction;
    placement: Placement;
    placementReferenceElement: HTMLElement;
    align: Align;
    rtl?: boolean;
}) => string;
/** @deprecated Use the CDK Overlay instead. */
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 - 2026
 * SPDX-License-Identifier: MIT
 */
/** */
declare const isRTL: (elem?: HTMLElement) => boolean;
declare const correctKeyRTL: (key: string) => string;

/**
 * Copyright (c) Siemens 2016 - 2026
 * SPDX-License-Identifier: MIT
 */
declare const listenGlobal: (eventName: string, handler: (e: any) => void, active?: boolean) => (() => void);

/**
 * Copyright (c) Siemens 2016 - 2026
 * 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 - 2026
 * SPDX-License-Identifier: MIT
 */

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