@koobiq/components 19.8.3 → 20.1.0

package/navbar/index.d.ts

@@ -1 +1,305 @@
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { AfterContentInit, AfterViewInit, OnDestroy, ChangeDetectorRef, ElementRef, QueryList, InjectionToken } from '@angular/core';
+import * as i2 from '@koobiq/components/tooltip';
+import { KbqTooltipTrigger } from '@koobiq/components/tooltip';
+import * as i1 from '@angular/cdk/a11y';
+import { FocusOrigin, FocusMonitor } from '@angular/cdk/a11y';
+import { KbqButtonCssStyler, KbqButton } from '@koobiq/components/button';
+import * as _koobiq_components_core from '@koobiq/components/core';
+import { IFocusableOption, FocusKeyManager } from '@koobiq/components/core';
+import { KbqFormField } from '@koobiq/components/form-field';
+import * as i3 from '@koobiq/components/icon';
+import { KbqIcon } from '@koobiq/components/icon';
+import { Subject, Observable } from 'rxjs';
+import * as i2$1 from '@angular/cdk/platform';
+
+interface KbqNavbarFocusableItemEvent {
+    item: KbqNavbarFocusableItem;
+}
+declare class KbqNavbarLogo {
+    readonly hovered: Subject<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqNavbarLogo, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqNavbarLogo, "kbq-navbar-logo, [kbq-navbar-logo]", never, {}, {}, never, never, true, never>;
+}
+declare class KbqNavbarBento {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqNavbarBento, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqNavbarBento, "kbq-navbar-item[bento], [kbq-navbar-item][bento]", never, {}, {}, never, never, true, never>;
+}
+declare class KbqNavbarTitle implements AfterViewInit {
+    protected readonly isBrowser: boolean;
+    protected readonly nativeElement: HTMLElement;
+    private readonly window;
+    readonly hovered: Subject<boolean>;
+    outerElementWidth: number;
+    isTextOverflown: boolean;
+    get text(): string;
+    get isOverflown(): boolean;
+    getOuterElementWidth(): number;
+    checkTextOverflown(): void;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqNavbarTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqNavbarTitle, "kbq-navbar-title, [kbq-navbar-title]", never, {}, {}, never, never, true, never>;
+}
+declare class KbqNavbarDivider {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqNavbarDivider, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqNavbarDivider, "kbq-navbar-divider", never, {}, {}, never, never, true, never>;
+}
+declare class KbqNavbarFocusableItem implements AfterContentInit, AfterViewInit, OnDestroy, IFocusableOption {
+    private elementRef;
+    private changeDetector;
+    private focusMonitor;
+    private ngZone;
+    readonly title: i0.Signal<KbqNavbarTitle | undefined>;
+    readonly button: i0.Signal<KbqButton | undefined>;
+    readonly formField: i0.Signal<KbqFormField | undefined>;
+    get nestedElement(): KbqButton | KbqFormField | undefined;
+    get tooltip(): KbqTooltipTrigger;
+    private _tooltip;
+    readonly onFocus: Subject<KbqNavbarFocusableItemEvent>;
+    readonly onBlur: Subject<KbqNavbarFocusableItemEvent>;
+    get hasFocus(): boolean;
+    set hasFocus(value: boolean);
+    private _hasFocus;
+    /** Whether the item is disabled. */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _disabled;
+    get tabIndex(): number;
+    ngAfterViewInit(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    setTooltip(value: KbqTooltipTrigger): void;
+    onFocusHandler(): void;
+    focus(origin?: FocusOrigin): void;
+    blur(): void;
+    getLabel(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqNavbarFocusableItem, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqNavbarFocusableItem, "kbq-navbar-item, [kbq-navbar-item], kbq-navbar-brand, [kbq-navbar-brand], kbq-navbar-toggle", never, { "disabled": { "alias": "disabled"; "required": false; }; }, {}, ["title", "button", "formField"], never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+declare class KbqNavbarRectangleElement {
+    protected readonly isBrowser: boolean;
+    protected readonly nativeElement: HTMLElement;
+    private readonly window;
+    private readonly changeDetectorRef;
+    readonly state: Subject<void>;
+    get horizontal(): boolean;
+    set horizontal(value: boolean);
+    private _horizontal;
+    get vertical(): boolean;
+    set vertical(value: boolean);
+    private _vertical;
+    get collapsed(): boolean;
+    set collapsed(value: boolean);
+    private _collapsed;
+    readonly button: i0.Signal<KbqButtonCssStyler | undefined>;
+    getOuterElementWidth(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqNavbarRectangleElement, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqNavbarRectangleElement, "kbq-navbar-item, [kbq-navbar-item], kbq-navbar-divider, kbq-navbar-brand, [kbq-navbar-brand]", never, {}, {}, ["button"], never, true, never>;
+}
+declare class KbqNavbarItem extends KbqTooltipTrigger implements AfterContentInit {
+    rectangleElement: KbqNavbarRectangleElement;
+    navbarFocusableItem: KbqNavbarFocusableItem;
+    private changeDetectorRef;
+    private dropdownTrigger;
+    private bento;
+    readonly title: i0.Signal<KbqNavbarTitle | undefined>;
+    readonly icon: i0.Signal<KbqIcon | undefined>;
+    get collapsedText(): string;
+    set collapsedText(value: string);
+    private _collapsedText;
+    get trigger(): string;
+    set trigger(value: string);
+    set collapsed(value: boolean);
+    get isCollapsed(): boolean;
+    private _collapsed;
+    get croppedText(): string;
+    get collapsable(): boolean;
+    set collapsable(value: boolean);
+    private _collapsable;
+    get titleText(): string | null;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    get hasDropDownTrigger(): boolean;
+    get showVerticalDropDownAngle(): boolean;
+    get showHorizontalDropDownAngle(): boolean;
+    get hasCroppedText(): boolean;
+    constructor();
+    ngAfterContentInit(): void;
+    updateDropdown(): void;
+    updateTooltip(): void;
+    getTitleWidth(): number;
+    onKeyDown($event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqNavbarItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqNavbarItem, "kbq-navbar-item, [kbq-navbar-item]", ["kbqNavbarItem"], { "collapsedText": { "alias": "collapsedText"; "required": false; }; "trigger": { "alias": "kbqTrigger"; "required": false; }; "collapsable": { "alias": "collapsable"; "required": false; }; }, {}, ["title", "icon"], ["[kbq-icon]", "kbq-navbar-title, [kbq-navbar-title]", "*"], true, never>;
+}
+
+declare class KbqNavbarBrand extends KbqTooltipTrigger implements AfterContentInit {
+    /** @docs-private */
+    protected readonly nativeElement: HTMLElement;
+    /** @docs-private */
+    protected readonly changeDetectorRef: ChangeDetectorRef;
+    /** @docs-private */
+    protected readonly rectangleElement: KbqNavbarRectangleElement;
+    /** @docs-private */
+    protected readonly navbarFocusableItem: KbqNavbarFocusableItem;
+    /** @docs-private */
+    readonly title: i0.Signal<KbqNavbarTitle | undefined>;
+    /** alternative display of the brand name in two lines */
+    readonly longTitle: i0.InputSignal<boolean>;
+    /** text that will be displayed in the tooltip. By default, the text is taken from kbq-navbar-title. */
+    get collapsedText(): string;
+    set collapsedText(value: string);
+    private _collapsedText;
+    get isLink(): boolean;
+    /** @docs-private */
+    get croppedText(): string;
+    /** @docs-private */
+    get hasCroppedText(): boolean;
+    /** @docs-private */
+    get titleText(): string | null;
+    /** @docs-private */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    /** @docs-private */
+    get collapsed(): boolean;
+    set collapsed(value: boolean);
+    private _collapsed;
+    constructor();
+    ngAfterContentInit(): void;
+    private updateTooltip;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqNavbarBrand, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqNavbarBrand, "kbq-navbar-brand, [kbq-navbar-brand]", ["kbqNavbarBrand"], { "longTitle": { "alias": "longTitle"; "required": false; "isSignal": true; }; "collapsedText": { "alias": "collapsedText"; "required": false; }; }, {}, ["title"], ["*"], true, never>;
+}
+
+type KbqNavbarContainerPositionType = 'left' | 'right';
+declare class KbqFocusableComponent implements AfterContentInit, AfterViewInit, OnDestroy {
+    protected readonly changeDetectorRef: ChangeDetectorRef;
+    protected readonly elementRef: ElementRef<HTMLElement>;
+    protected readonly focusMonitor: FocusMonitor;
+    focusableItems: QueryList<KbqNavbarFocusableItem>;
+    keyManager: FocusKeyManager<KbqNavbarFocusableItem>;
+    get tabIndex(): any;
+    set tabIndex(value: any);
+    private _tabIndex;
+    private lastFocusOrigin;
+    get optionFocusChanges(): Observable<KbqNavbarFocusableItemEvent>;
+    get optionBlurChanges(): Observable<KbqNavbarFocusableItemEvent>;
+    private readonly destroyRef;
+    private optionFocusSubscription;
+    private optionBlurSubscription;
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    focus(): void;
+    blur(): void;
+    protected resetOptions(): void;
+    protected dropSubscriptions(): void;
+    private listenToOptionsFocus;
+    private updateTabIndex;
+    private isValidIndex;
+    private hasFocusedItem;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqFocusableComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqFocusableComponent, never, never, { "tabIndex": { "alias": "tabIndex"; "required": false; }; }, {}, ["focusableItems"], never, true, never>;
+}
+declare class KbqNavbarContainer {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqNavbarContainer, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqNavbarContainer, "kbq-navbar-container", never, {}, {}, never, never, true, never>;
+}
+declare class KbqNavbar extends KbqFocusableComponent implements AfterViewInit, AfterContentInit, OnDestroy {
+    protected readonly elementRef: ElementRef<HTMLElement>;
+    protected readonly changeDetectorRef: ChangeDetectorRef;
+    protected readonly focusMonitor: FocusMonitor;
+    private readonly platform;
+    readonly rectangleElements: i0.Signal<readonly any[]>;
+    readonly navbarItems: i0.Signal<readonly any[]>;
+    readonly resizeStream: Subject<Event>;
+    private readonly resizeDebounceInterval;
+    private get width();
+    private get totalItemsWidth();
+    private get collapsableItems();
+    private resizeSubscription;
+    constructor();
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    onKeyDown(event: KeyboardEvent): void;
+    updateExpandedStateForItems: () => void;
+    private eventFromInput;
+    private cursorOnFirstPosition;
+    private cursorOnLastPosition;
+    private collapseItems;
+    private expandItems;
+    private setItemsState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqNavbar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqNavbar, "kbq-navbar", never, {}, {}, ["rectangleElements", "navbarItems"], ["[kbq-navbar-container], kbq-navbar-container"], true, never>;
+}
+
+/** default configuration of navbar */
+/** @docs-private */
+declare const KBQ_VERTICAL_NAVBAR_DEFAULT_CONFIGURATION: {
+    toggle: {
+        expand: string;
+        collapse: string;
+    };
+};
+/** Injection Token for providing configuration of navbar */
+/** @docs-private */
+declare const KBQ_VERTICAL_NAVBAR_CONFIGURATION: InjectionToken<unknown>;
+declare class KbqVerticalNavbar extends KbqFocusableComponent implements AfterContentInit {
+    protected elementRef: ElementRef<HTMLElement>;
+    /** @docs-private */
+    protected readonly localeService: _koobiq_components_core.KbqLocaleService | null;
+    readonly externalConfiguration: unknown;
+    configuration: any;
+    rectangleElements: i0.Signal<readonly any[]>;
+    readonly items: i0.Signal<readonly any[]>;
+    readonly bento: i0.Signal<any>;
+    readonly animationDone: Subject<void>;
+    readonly openOver: i0.InputSignal<boolean>;
+    get expanded(): boolean;
+    set expanded(value: boolean);
+    private _expanded;
+    constructor();
+    ngAfterContentInit(): void;
+    toggle(): void;
+    onKeyDown(event: KeyboardEvent): void;
+    private updateExpandedStateForItems;
+    private updateTooltipForItems;
+    private setItemsVerticalStateAndUpdateExpandedState;
+    private setItemVerticalStateAndUpdateExpandedState;
+    private setItemVerticalState;
+    private updateItemExpandedState;
+    private updateLocaleParams;
+    private initDefaultParams;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqVerticalNavbar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqVerticalNavbar, "kbq-vertical-navbar", ["KbqVerticalNavbar"], { "openOver": { "alias": "openOver"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; }; }, {}, ["rectangleElements", "items", "bento"], ["[kbq-navbar-container], kbq-navbar-container", "[kbq-navbar-toggle], kbq-navbar-toggle"], true, [{ directive: typeof i1.CdkMonitorFocus; inputs: {}; outputs: {}; }]>;
+}
+
+declare class KbqNavbarToggle implements OnDestroy {
+    private readonly window;
+    private readonly ngZone;
+    private readonly changeDetectorRef;
+    private readonly tooltip;
+    /** @docs-private */
+    protected readonly navbar: KbqVerticalNavbar;
+    constructor();
+    ngOnDestroy(): void;
+    /** @docs-private */
+    keydownHandler($event: KeyboardEvent): void;
+    /** toggles the state of the navbar */
+    toggle(): void;
+    private updateTooltipContent;
+    private windowToggleHandler;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqNavbarToggle, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqNavbarToggle, "kbq-navbar-toggle, [kbq-navbar-toggle]", never, {}, {}, never, ["[kbq-icon]"], true, [{ directive: typeof i1.CdkMonitorFocus; inputs: {}; outputs: {}; }, { directive: typeof i2.KbqTooltipTrigger; inputs: {}; outputs: {}; }]>;
+}
+
+declare class KbqNavbarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqNavbarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqNavbarModule, never, [typeof i1.A11yModule, typeof i2$1.PlatformModule, typeof i3.KbqIconModule, typeof i2.KbqToolTipModule, typeof KbqNavbar, typeof KbqNavbarContainer, typeof KbqNavbarTitle, typeof KbqNavbarItem, typeof KbqNavbarBrand, typeof KbqNavbarLogo, typeof KbqNavbarToggle, typeof KbqVerticalNavbar, typeof KbqNavbarDivider, typeof KbqNavbarFocusableItem, typeof KbqNavbarRectangleElement, typeof KbqNavbarBento], [typeof KbqNavbar, typeof KbqNavbarContainer, typeof KbqNavbarTitle, typeof KbqNavbarItem, typeof KbqNavbarBrand, typeof KbqNavbarLogo, typeof KbqNavbarToggle, typeof KbqVerticalNavbar, typeof KbqNavbarDivider, typeof KbqNavbarFocusableItem, typeof KbqNavbarRectangleElement, typeof KbqNavbarBento]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KbqNavbarModule>;
+}
+
+export { KBQ_VERTICAL_NAVBAR_CONFIGURATION, KBQ_VERTICAL_NAVBAR_DEFAULT_CONFIGURATION, KbqFocusableComponent, KbqNavbar, KbqNavbarBento, KbqNavbarBrand, KbqNavbarContainer, KbqNavbarDivider, KbqNavbarFocusableItem, KbqNavbarItem, KbqNavbarLogo, KbqNavbarModule, KbqNavbarRectangleElement, KbqNavbarTitle, KbqNavbarToggle, KbqVerticalNavbar };
+export type { KbqNavbarContainerPositionType, KbqNavbarFocusableItemEvent };

package/navbar/navbar.scss

@@ -4,8 +4,7 @@
 @use './navbar-theme' as *;
 
 .kbq-navbar {
-    // TODO: Disabled, need fix in DS-5288
-    //z-index: overlay.$overlay-z-index;
+    z-index: overlay.$overlay-z-index;
 
     display: flex;
     flex-direction: row;

package/notification-center/index.d.ts

@@ -1 +1,322 @@
-export * from './public-api';
+import * as _angular_cdk_scrolling_module_d from '@angular/cdk/scrolling-module.d';
+import * as rxjs from 'rxjs';
+import { BehaviorSubject, Observable, Subscription } from 'rxjs';
+import * as i0 from '@angular/core';
+import { TemplateRef, EventEmitter, InjectionToken, AfterViewInit, ChangeDetectorRef, AfterContentInit, Type } from '@angular/core';
+import * as _koobiq_components_core from '@koobiq/components/core';
+import { KbqPopUp, DateAdapter, KbqPopUpTrigger, KbqPopUpPlacementValues, KbqStickToWindowPlacementValues, KbqPopUpSizeValues } from '@koobiq/components/core';
+import { ScrollStrategy, Overlay, OverlayConfig } from '@angular/cdk/overlay';
+import { KbqButton } from '@koobiq/components/button';
+import { KbqToastData, KbqToastStyle } from '@koobiq/components/toast';
+import { AnimationTriggerMetadata } from '@angular/animations';
+
+interface KbqNotificationItem extends Omit<KbqToastData, 'closeButton'> {
+    id?: string;
+    /** Numeric id of the shown toast, set by `push()` and consumed by `hideToast()`. */
+    toastId?: number;
+    title?: string | TemplateRef<unknown>;
+    style?: string | KbqToastStyle;
+    icon?: boolean | TemplateRef<unknown>;
+    iconClass?: string;
+    caption?: string | TemplateRef<unknown>;
+    content?: string | TemplateRef<unknown>;
+    actions?: TemplateRef<unknown>;
+    date: string;
+    read?: boolean;
+}
+declare const maxUnreadItemsLength = 99;
+type KbqNotificationsGroup = {
+    title: string;
+    items: KbqNotificationItem[];
+};
+/** Payload emitted by `KbqNotificationCenterService.onDelete`. */
+type KbqNotificationDeleteEvent = {
+    /** What was removed: a single item, a whole date group, or all notifications. */
+    type: 'item' | 'group' | 'all';
+    /** The notification items that were removed. */
+    items: KbqNotificationItem[];
+};
+declare class KbqNotificationCenterService {
+    /** @docs-private */
+    private readonly adapter;
+    /** @docs-private */
+    private readonly formatter;
+    /** @docs-private */
+    private readonly toastService;
+    /** @docs-private */
+    readonly silentMode: BehaviorSubject<boolean>;
+    /** @docs-private */
+    readonly loadingMode: BehaviorSubject<boolean>;
+    /** @docs-private */
+    readonly errorMode: BehaviorSubject<boolean>;
+    /**
+     * Whether the bottom "load more" spinner is shown while the next page is being loaded.
+     * Note: this is the infinite-scroll indicator and is distinct from `loadingMode`,
+     * which renders the full-screen loader instead of the list.
+     */
+    readonly loadingMore: BehaviorSubject<boolean>;
+    /**
+     * Whether the bottom "load more" error row (with a retry button) is shown.
+     * Distinct from `errorMode`, which replaces the whole list with the full-screen error state.
+     */
+    readonly loadMoreErrorMode: BehaviorSubject<boolean>;
+    /**
+     * Whether there are more notifications to load. While `true`, scrolling to the bottom
+     * emits `onNextPage`; set it to `false` to stop further infinite-scroll requests.
+     */
+    readonly hasMore: BehaviorSubject<boolean>;
+    /** @docs-private */
+    readonly onRead: BehaviorSubject<KbqNotificationItem | null>;
+    /** Triggers an event when the user presses the reload button. */
+    readonly onReload: EventEmitter<void>;
+    /** Triggers an event when the list is scrolled to the bottom and the next page should be loaded. */
+    readonly onNextPage: EventEmitter<void>;
+    /** Triggers an event when an item, a group, or all notifications are removed. */
+    readonly onDelete: EventEmitter<KbqNotificationDeleteEvent>;
+    private originalItems;
+    /**
+     * Grouped notifications, always ordered from newest to oldest: day groups are sorted by date
+     * descending, and notifications within each day are sorted by date descending.
+     * @docs-private
+     */
+    readonly groupedItems: Observable<KbqNotificationsGroup[]>;
+    /** Emits an event whenever the changes. */
+    readonly changes: Observable<boolean | KbqNotificationItem | KbqNotificationItem[] | null>;
+    /** Notification items */
+    get items(): KbqNotificationItem[];
+    set items(values: KbqNotificationItem[]);
+    /** Number of unread notifications */
+    get unreadItemsCounter(): Observable<string>;
+    /** true if there are no notifications. */
+    get isEmpty(): boolean;
+    constructor();
+    /** Set silent mode */
+    setSilentMode(value: boolean): void;
+    /** Set loading mode */
+    setLoadingMode(value: boolean): void;
+    /** Set error mode */
+    setErrorMode(value: boolean): void;
+    /** Set the bottom "load more" spinner visibility. */
+    setLoadingMore(value: boolean): void;
+    /** Set the bottom "load more" error state visibility. */
+    setLoadMoreErrorMode(value: boolean): void;
+    /** Set whether there are more notifications to load via infinite scroll. */
+    setHasMore(value: boolean): void;
+    /** Push new notification item in center */
+    push(item: KbqNotificationItem): void;
+    /** Hides the toast that corresponds to the given notification item. */
+    hideToast(item: KbqNotificationItem): void;
+    /** Remove notification item */
+    remove(removedItem: KbqNotificationItem): void;
+    /** Remove group of notification items */
+    removeGroup(group: KbqNotificationsGroup): void;
+    /** Remove all notification items */
+    removeAll(): void;
+    private makeGroup;
+    /** Compares two notifications by date so the newest comes first. */
+    private compareByDateDesc;
+    private setIds;
+    private setReadState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqNotificationCenterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KbqNotificationCenterService>;
+}
+
+/**default configuration of notification-center */
+declare const KBQ_NOTIFICATION_CENTER_DEFAULT_CONFIGURATION: {
+    notifications: string;
+    remove: string;
+    doNotDisturb: string;
+    showPopUpNotifications: string;
+    noNotifications: string;
+    failedToLoadNotifications: string;
+    repeat: string;
+    loadingMore: string;
+};
+/** Injection Token for providing configuration of notification-center */
+declare const KBQ_NOTIFICATION_CENTER_CONFIGURATION: InjectionToken<unknown>;
+/** @docs-private */
+declare const KBQ_NOTIFICATION_CENTER_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
+/** @docs-private */
+declare function kbqNotificationCenterScrollStrategyFactory(overlay: Overlay): () => ScrollStrategy;
+/** @docs-private */
+declare const KBQ_NOTIFICATION_CENTER_SCROLL_STRATEGY_FACTORY_PROVIDER: {
+    provide: InjectionToken<() => ScrollStrategy>;
+    deps: (typeof Overlay)[];
+    useFactory: typeof kbqNotificationCenterScrollStrategyFactory;
+};
+/** @docs-private */
+declare class KbqNotificationCenterComponent extends KbqPopUp implements AfterViewInit {
+    /** @docs-private */
+    protected readonly changeDetectorRef: ChangeDetectorRef;
+    /** @docs-private */
+    protected readonly localeService: _koobiq_components_core.KbqLocaleService | null;
+    /** @docs-private */
+    protected readonly dateAdapter: DateAdapter<any>;
+    /** @docs-private */
+    protected readonly service: KbqNotificationCenterService;
+    readonly externalConfiguration: unknown;
+    configuration: any;
+    /** @docs-private */
+    protected popoverMode: boolean;
+    /** Distance in pixels from the bottom of the list at which the next page is requested.
+     * @docs-private */
+    protected scrolledToBottomOffset: number;
+    /** Emits on every scroll of the list container; drives the scroll-to-bottom check. */
+    private readonly scroll$;
+    /** localized data
+     * @docs-private */
+    get localeData(): any;
+    /** @docs-private */
+    prefix: string;
+    /** @docs-private */
+    trigger: KbqNotificationCenterTrigger;
+    /** @docs-private */
+    isTrapFocus: boolean;
+    readonly switcher: i0.Signal<KbqButton>;
+    /** Scrollable list container; used to measure scroll position for infinite scroll. */
+    private readonly scrollContainer;
+    get popoverHeight(): string;
+    set popoverHeight(value: string);
+    private _popoverHeight;
+    constructor();
+    ngAfterViewInit(): void;
+    /** Handles the list container scroll: feeds the scroll-to-bottom check that drives infinite scroll.
+     * Overflow shadows are handled declaratively by the `kbqOverflowShadow*` directives.
+     * @docs-private */
+    protected onContainerScroll(): void;
+    /** Retries loading the next page from the bottom error row.
+     * @docs-private */
+    protected retryLoadMore(): void;
+    /**
+     * Requests the next page (via `service.onNextPage`) once the list is scrolled to within
+     * `scrolledToBottomOffset` pixels of the bottom. Two triggers feed it: the user scrolling, and a
+     * page finishing loading. The latter keeps paging when a freshly loaded page is too short to
+     * overflow the viewport — otherwise no further scroll event would fire and pagination would
+     * stall. Suppressed while a load is in flight, errored, or when there is nothing more to load.
+     */
+    private subscribeToScrolledToBottom;
+    /** Whether the list is scrolled to within `scrolledToBottomOffset` pixels of the bottom. */
+    private isScrolledToBottom;
+    /** Emits `onNextPage` unless a load is already in flight, errored, or there is nothing more to load. */
+    private requestNextPage;
+    /**
+     * Reveals the bottom "load more" spinner / error row when it first appears. Both rows are appended
+     * below the last item and can land outside the viewport (the next page is requested while the user
+     * is up to `scrolledToBottomOffset` px above the true bottom). Only a genuine false->true transition
+     * reveals the row: the BehaviorSubject's replayed current value is ignored (`pairwise` needs two
+     * emissions), so the panel always opens scrolled to the top — reopening it while a load-more error
+     * is still set never jumps to the bottom.
+     */
+    private subscribeToRevealLoadMoreRow;
+    /** Scrolls the list container to its bottom so a freshly-appended bottom row becomes visible. */
+    private scrollToBottom;
+    private focusScrollContainer;
+    /** @docs-private */
+    updateClassMap(placement: string, customClass: string, size: KbqPopUpSizeValues): void;
+    /** @docs-private */
+    updateTrapFocus(isTrapFocus: boolean): void;
+    /** @docs-private */
+    escapeHandler(): void;
+    private updateLocaleParams;
+    private initDefaultParams;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqNotificationCenterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqNotificationCenterComponent, "kbq-notification-center", never, {}, {}, never, never, true, never>;
+}
+declare class KbqNotificationCenterTrigger extends KbqPopUpTrigger<KbqNotificationCenterComponent> implements AfterContentInit {
+    /** @docs-private */
+    protected scrollStrategy: () => ScrollStrategy;
+    /** @docs-private */
+    protected readonly service: KbqNotificationCenterService;
+    /** @docs-private */
+    arrow: boolean;
+    /** @docs-private */
+    customClass: string;
+    /** @docs-private */
+    private hasBackdrop;
+    /** @docs-private */
+    private size;
+    /** @docs-private */
+    content: string | TemplateRef<any>;
+    /** @docs-private */
+    header: string | TemplateRef<any>;
+    /** @docs-private */
+    footer: string | TemplateRef<any>;
+    /** Number of unread notifications */
+    get unreadItemsCounter(): rxjs.Observable<string>;
+    /** Placement of popUp */
+    placement: KbqPopUpPlacementValues;
+    /** Class that will be used in the background */
+    backdropClass: string;
+    /** Class that will be used in the panel */
+    panelClass: string;
+    /** Offset of popUp */
+    offset: number | null;
+    /** Distance in pixels from the bottom of the list at which the next page is requested via `onNextPage`. */
+    scrolledToBottomOffset: number;
+    /** Use popover or not */
+    get popoverMode(): boolean;
+    set popoverMode(value: boolean);
+    private _popoverMode;
+    /** Set height of popover. Default is calc(100vh - 48px). 48px - height of navbar */
+    get popoverHeight(): string;
+    set popoverHeight(value: string);
+    private _popoverHeight;
+    /** Whether the trigger is disabled. */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    /**
+     * Additionally positions the element relative to the window side (Top, Right, Bottom and Left).
+     * If container is specified, the positioning will be relative to it.
+     * */
+    stickToWindow: KbqStickToWindowPlacementValues;
+    /** Container for additional positioning, used with stickToWindow */
+    container: HTMLElement;
+    /** @docs-private */
+    get hasClickTrigger(): boolean;
+    /** Emits a change event whenever the placement state changes. */
+    readonly placementChange: EventEmitter<any>;
+    /** Emits a change event whenever the visible state changes. */
+    readonly visibleChange: EventEmitter<boolean>;
+    /** @docs-private */
+    trigger: string;
+    /** @docs-private */
+    protected originSelector: string;
+    /** @docs-private */
+    protected get overlayConfig(): OverlayConfig;
+    /** @docs-private */
+    protected preventClosingByInnerScrollSubscription: Subscription;
+    constructor();
+    ngAfterContentInit(): void;
+    /** @docs-private */
+    updateData(): void;
+    /** Updates the current position.
+     *
+     * @docs-private */
+    updatePosition(reapplyPosition?: boolean): void;
+    /** @docs-private */
+    getOverlayHandleComponentType(): Type<KbqNotificationCenterComponent>;
+    /** @docs-private */
+    updateClassMap(newPlacement?: string): void;
+    /** @docs-private */
+    closingActions(): rxjs.Observable<void | _angular_cdk_scrolling_module_d.CdkScrollable | MouseEvent>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqNotificationCenterTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqNotificationCenterTrigger, "[kbqNotificationCenterTrigger]", ["kbqNotificationCenterTrigger"], { "placement": { "alias": "kbqNotificationCenterPlacement"; "required": false; }; "backdropClass": { "alias": "backdropClass"; "required": false; }; "panelClass": { "alias": "kbqNotificationCenterPanelClass"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "scrolledToBottomOffset": { "alias": "scrolledToBottomOffset"; "required": false; }; "popoverMode": { "alias": "popoverMode"; "required": false; }; "popoverHeight": { "alias": "popoverHeight"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "stickToWindow": { "alias": "stickToWindow"; "required": false; }; "container": { "alias": "container"; "required": false; }; }, { "placementChange": "kbqPlacementChange"; "visibleChange": "kbqVisibleChange"; }, never, never, true, never>;
+    static ngAcceptInputType_offset: unknown;
+    static ngAcceptInputType_scrolledToBottomOffset: unknown;
+    static ngAcceptInputType_popoverMode: unknown;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+/** @docs-private */
+declare const KbqNotificationCenterAnimations: {
+    readonly state: AnimationTriggerMetadata;
+};
+
+declare class KbqNotificationCenterModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqNotificationCenterModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqNotificationCenterModule, never, [typeof KbqNotificationCenterComponent, typeof KbqNotificationCenterTrigger], [typeof KbqNotificationCenterComponent, typeof KbqNotificationCenterTrigger]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KbqNotificationCenterModule>;
+}
+
+export { KBQ_NOTIFICATION_CENTER_CONFIGURATION, KBQ_NOTIFICATION_CENTER_DEFAULT_CONFIGURATION, KBQ_NOTIFICATION_CENTER_SCROLL_STRATEGY, KBQ_NOTIFICATION_CENTER_SCROLL_STRATEGY_FACTORY_PROVIDER, KbqNotificationCenterAnimations, KbqNotificationCenterComponent, KbqNotificationCenterModule, KbqNotificationCenterService, KbqNotificationCenterTrigger, kbqNotificationCenterScrollStrategyFactory, maxUnreadItemsLength };
+export type { KbqNotificationDeleteEvent, KbqNotificationItem };