import * as i0 from '@angular/core';
import { ElementRef, QueryList, DestroyRef, OnInit, AfterViewInit, OnDestroy, ViewContainerRef, TemplateRef, Type, ComponentRef, EmbeddedViewRef, InjectionToken } from '@angular/core';
import { ButtonComponent } from '@fundamental-ngx/core/button';
import { Direction } from '@angular/cdk/bidi';
import { AbstractFdNgxClass, Nullable, DynamicComponentService, RtlService } from '@fundamental-ngx/cdk/utils';
import { Observable, Subject } from 'rxjs';

declare class NotificationFooterContentDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationFooterContentDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NotificationFooterContentDirective, "[fdNotificationFooterContent], [fd-notification-footer-content]", never, {}, {}, never, never, true, never>;
}

declare class NotificationGroupGrowingItemTitleDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationGroupGrowingItemTitleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NotificationGroupGrowingItemTitleDirective, "[fdNotificationGroupGrowingItemTitle], [fd-notification-group-growing-item-title]", never, {}, {}, never, never, true, never>;
}

declare class NotificationGroupHeaderTitleDirective {
    /**
     * aria-level for the title
     * a numeric value from 1 to 6
     * default value is 3
     */
    ariaLevel: i0.InputSignal<1 | 2 | 3 | 4 | 5 | 6>;
    /**
     * id for the notification group header title
     * if not set, a default value is provided
     */
    id: i0.InputSignal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationGroupHeaderTitleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NotificationGroupHeaderTitleDirective, "[fdNotificationGroupHeaderTitle], [fd-notification-group-header-title]", never, { "ariaLevel": { "alias": "ariaLevel"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class NotificationListDirective {
    /**
     * aria-label attribute for the element
     * Default is set to 'Notifications'
     */
    ariaLabel: i0.InputSignal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationListDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NotificationListDirective, "[fdNotificationList], [fd-notification-list]", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class NotificationMessageStripContainerDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationMessageStripContainerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NotificationMessageStripContainerDirective, "[fdNotificationMessageStripContainer], [fd-notification-message-strip-container]", never, {}, {}, never, never, true, never>;
}

declare class NotificationMessageStripDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationMessageStripDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NotificationMessageStripDirective, "[fdNotificationMessageStrip], [fd-notification-message-strip]", never, {}, {}, never, never, true, never>;
}

declare class NotificationParagraphDirective {
    /**
     * id for the notification paragraph
     * if not set, a default value is provided
     */
    id: i0.InputSignal<string>;
    /** @hidden */
    elementRef: ElementRef<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationParagraphDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NotificationParagraphDirective, "[fdNotificationParagraph], [fd-notification-paragraph]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class NotificationPopoverDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationPopoverDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NotificationPopoverDirective, "[fdNotificationPopover], [fd-notification-popover]", never, {}, {}, never, never, true, never>;
}

declare class NotificationSeparatorDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationSeparatorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NotificationSeparatorDirective, "[fdNotificationSeparator], [fd-notification-separator]", never, {}, {}, never, never, true, never>;
}

declare class NotificationTitleDirective {
    /**
     * Whether the notification title is unread.
     * default is false
     */
    unread: i0.InputSignal<boolean>;
    /**
     * id for the notification title
     * if not set, a default value is provided
     */
    id: i0.InputSignal<string>;
    /** @hidden */
    elementRef: ElementRef<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationTitleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NotificationTitleDirective, "[fdNotificationTitle], [fd-notification-title]", never, { "unread": { "alias": "unread"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class NotificationActionsComponent {
    /** @hidden */
    buttons: QueryList<ButtonComponent>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationActionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationActionsComponent, "fd-notification-actions", never, {}, {}, ["buttons"], ["*"], true, never>;
}

declare class NotificationHeaderComponent {
    /**
     * Unique id for the notification header
     * if not set, a default value is provided
     */
    uniqueId: i0.InputSignal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationHeaderComponent, "fd-notification-header", never, { "uniqueId": { "alias": "uniqueId"; "required": false; "isSignal": true; }; }, {}, never, ["fd-icon", "[fd-notification-title]"], true, never>;
}

/**
 * @hidden
 * Base directive for notification components that need to set aria-describedby
 * on action buttons linking them to notification headers.
 */
declare abstract class NotificationGroupBaseDirective {
    /** @hidden */
    readonly notificationHeader: i0.Signal<readonly NotificationHeaderComponent[]>;
    /** @hidden */
    readonly notificationActions: i0.Signal<readonly NotificationActionsComponent[]>;
    /** @hidden */
    protected readonly _destroyRef: DestroyRef;
    /** @hidden */
    private readonly _renderer;
    /** @hidden */
    private readonly _injector;
    constructor();
    /**
     * Sets up reactive subscription to update aria-describedby on action buttons.
     * @hidden
     */
    private _setupAriaDescribedBy;
    /**
     * Creates an observable that emits when notification headers change.
     * @hidden
     */
    private _createHeadersObservable;
    /**
     * Creates an observable that emits when notification actions or their buttons change.
     * @hidden
     */
    private _createActionsObservable;
    /**
     * Checks if required content (headers and buttons) exists.
     * @hidden
     */
    private _hasRequiredContent;
    /**
     * Applies aria-describedby attribute to action buttons that don't already have it.
     * Uses the first header's uniqueId as the reference.
     * @hidden
     */
    private _applyAriaDescribedBy;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationGroupBaseDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NotificationGroupBaseDirective, never, never, {}, {}, ["notificationHeader", "notificationActions"], never, true, never>;
}

declare class NotificationBodyComponent extends NotificationGroupBaseDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationBodyComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationBodyComponent, "fd-notification-body", never, {}, {}, never, ["*"], true, never>;
}

declare class NotificationContentComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationContentComponent, "fd-notification-content", never, {}, {}, never, ["*"], true, never>;
}

declare class NotificationFooterComponent {
    /**
     * Manual control: Override to show/hide the expand/collapse button.
     * When set, takes precedence over automatic truncation detection.
     * Use this for dynamically created notifications where automatic detection doesn't work.
     */
    readonly manualShowTrigger: i0.InputSignal<boolean | undefined>;
    /**
     * Manual control: Set expanded state externally.
     * When set, takes precedence over internal expanded state.
     * Use this for dynamically created notifications.
     * Supports two-way binding with [(manualExpanded)].
     */
    readonly manualExpanded: i0.ModelSignal<boolean | undefined>;
    /**
     * Custom label for the expand button.
     * Defaults to `'More'`.
     */
    readonly moreLabel: i0.InputSignal<string | undefined>;
    /**
     * Custom label for the collapse button.
     * Defaults to `'Less'`.
     */
    readonly lessLabel: i0.InputSignal<string | undefined>;
    /**
     * Internal signal for automatic truncation detection.
     * Used when manual controls are not provided.
     * @internal
     */
    readonly _autoShowTrigger: i0.WritableSignal<boolean>;
    /**
     * Internal signal for automatic expanded state.
     * Used when manual controls are not provided.
     * @internal
     */
    readonly _autoExpanded: i0.WritableSignal<boolean>;
    /**
     * Computed signal for expanded state.
     * Uses manual control if provided, otherwise uses automatic state.
     */
    readonly expanded: i0.Signal<boolean>;
    /**
     * Computed signal that determines if trigger should be shown.
     * Uses manual control if provided, otherwise uses automatic detection.
     */
    protected readonly showTrigger: i0.Signal<boolean>;
    private readonly _defaultMoreLabel;
    private readonly _defaultLessLabel;
    /** @hidden */
    protected onTriggerClick(): void;
    /**
     * Label for the trigger button
     * @hidden
     **/
    protected get triggerLabel(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationFooterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationFooterComponent, "fd-notification-footer", never, { "manualShowTrigger": { "alias": "manualShowTrigger"; "required": false; "isSignal": true; }; "manualExpanded": { "alias": "manualExpanded"; "required": false; "isSignal": true; }; "moreLabel": { "alias": "moreLabel"; "required": false; "isSignal": true; }; "lessLabel": { "alias": "lessLabel"; "required": false; "isSignal": true; }; }, { "manualExpanded": "manualExpandedChange"; }, never, ["*"], true, never>;
}

declare class NotificationGroupGrowingItemComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationGroupGrowingItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationGroupGrowingItemComponent, "fd-notification-group-growing-item", never, {}, {}, never, ["[fd-notification-group-growing-item-title]", "*"], true, never>;
}

declare class NotificationGroupHeaderComponent extends NotificationGroupBaseDirective {
    /**
     * Title for the group header.
     * Default value is set from i18n translations ("Expand/Collapse").
     */
    readonly title: i0.WritableSignal<string | null>;
    /**
     * ID of the list element that the group header controls.
     */
    readonly ariaControls: i0.WritableSignal<string | null>;
    /** @hidden */
    readonly expanded: i0.WritableSignal<boolean>;
    /** @hidden */
    protected readonly _buttonIcon: i0.Signal<"slim-arrow-down" | "slim-arrow-left" | "slim-arrow-right">;
    /** @hidden */
    private readonly _rtlService;
    /** @hidden */
    private readonly _langSignal;
    /** @hidden */
    private readonly _translationResolver;
    constructor();
    /** Method that toggles the Notification list content */
    toggleExpand(): void;
    /** @hidden */
    protected _onKeydown(event: KeyboardEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationGroupHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationGroupHeaderComponent, "fd-notification-group-header", never, {}, {}, never, ["fd-notification-group-header-title", "*"], true, never>;
}

declare class NotificationComponent extends AbstractFdNgxClass implements OnInit, AfterViewInit, OnDestroy {
    /** @hidden */
    containerRef: i0.Signal<ViewContainerRef | undefined>;
    /** User defined width for the notification */
    width: i0.InputSignal<Nullable<string>>;
    /** Whether the notificatioon is in mobile mode */
    mobile: i0.InputSignal<boolean>;
    /** @hidden */
    _dir: i0.Signal<Direction>;
    /** ID of the notification */
    id: string;
    /**
     * aria-level of the Notificaion
     * should be set to 2 in Notification Group
     * default value is undefined
     */
    ariaLevel: i0.WritableSignal<Nullable<number>>;
    /**
     * role of the Notificaion
     * should be set to 'listitem' in Notification Group
     * default value is undefined
     */
    role: i0.WritableSignal<Nullable<string>>;
    /**
     * whether the Notificaion is selected
     * default is set to false
     */
    selected: i0.InputSignal<boolean>;
    /** Whether the notification is dismissed with the ESC key */
    escKeyCloseable: boolean;
    /** Whether the notification should close with router change */
    closeOnNavigation: boolean;
    /** aria-labelledby attribute for the notification component element. */
    ariaLabelledBy: i0.WritableSignal<Nullable<string>>;
    /** aria-label attribute for the notification component element. */
    ariaLabel: Nullable<string>;
    /** aria-describedby attribute for the notification component element. */
    ariaDescribedBy: Nullable<string>;
    /** Reference to the child content */
    childContent: TemplateRef<any> | Type<any> | undefined;
    /** Reference to the component or the embedded view */
    componentRef: ComponentRef<any> | EmbeddedViewRef<any> | undefined;
    /** @hidden */
    private _notificationTitle;
    /** @hidden */
    private _notificationParagraph;
    /** @hidden */
    private _notificationFooter;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    private readonly _afterViewInit$;
    /** @hidden The class that traps and manages focus within the notification. */
    private _focusTrap;
    /** @hidden */
    private _cdRef;
    /** @hidden */
    private _componentFactoryResolver;
    /** @hidden */
    private _router;
    /** @hidden */
    private _focusTrapFactory;
    /** @hidden */
    private _notificationConfig;
    /** @hidden */
    private _notificationRef;
    /** @hidden */
    private _rtlService;
    /** @hidden */
    private _isTitleTruncated;
    /** @hidden */
    private _isParagraphTruncated;
    /** @hidden */
    private _hasTruncation;
    /** @hidden */
    private _expanded;
    /** @hidden */
    private _observer;
    /** @hidden */
    constructor();
    /** @hidden Listen and close notification on Escape key */
    _closeNotificationEsc(event: KeyboardEvent): void;
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /**
     * Moves the focus inside the focus trap.
     * @returns
     * Returns a promise that resolves with a boolean, depending on whether focus was moved successfully.
     */
    trapFocus(): Promise<boolean>;
    /** @hidden */
    _setProperties(): void;
    /** @hidden */
    private _observeNotificationResize;
    /** @hidden */
    private _updateExpandedClass;
    /** @hidden */
    private _checkTruncation;
    /** @hidden */
    private _attachResizeListener;
    /** @hidden */
    private _onWindowResize;
    /** @hidden Listen on NavigationStart event and dismiss the dialog */
    private _listenAndCloseOnNavigation;
    /** @hidden */
    private _loadFromComponent;
    /** @hidden */
    private _loadFromTemplate;
    /** @hidden */
    private _setNotificationConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationComponent, "fd-notification", never, { "width": { "alias": "width"; "required": false; "isSignal": true; }; "mobile": { "alias": "mobile"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; }, {}, ["_notificationTitle", "_notificationParagraph", "_notificationFooter"], ["*"], true, never>;
}

declare class NotificationGroupListComponent implements AfterViewInit {
    /**
     * id of the element labelling the group list
     */
    ariaLabelledBy: i0.InputSignal<string | undefined>;
    /**
     * id for the notification group list
     * if not set, a default value is provided
     */
    id: i0.InputSignal<string>;
    /**
     * @hidden
     */
    notifications: i0.Signal<readonly NotificationComponent[]>;
    /**
     * @hidden
     */
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationGroupListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationGroupListComponent, "fd-notification-group-list", never, { "ariaLabelledBy": { "alias": "ariaLabelledBy"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, ["notifications"], ["*"], true, never>;
}

declare class NotificationGroupComponent implements AfterViewInit {
    /**
     * Whether the group is expanded
     * default value is false
     */
    expanded: i0.InputSignal<boolean>;
    /**
     * input property to set aria-label
     * accepts a string value
     */
    ariaLabel: i0.InputSignal<string | undefined>;
    /** @hidden */
    readonly ariaLabelledBy: i0.Signal<string | undefined>;
    /** @hidden */
    readonly ariaDescription: i0.Signal<string>;
    /** @hidden */
    readonly isExpanded: i0.Signal<boolean | undefined>;
    /** @hidden */
    readonly groupHeader: i0.Signal<NotificationGroupHeaderComponent | undefined>;
    /** @hidden */
    readonly groupTitle: i0.Signal<NotificationGroupHeaderTitleDirective | undefined>;
    /** @hidden */
    readonly groupList: i0.Signal<NotificationGroupListComponent | undefined>;
    /** @hidden */
    private _descriptionString;
    /** @hidden */
    private _expandedString;
    /** @hidden */
    private _collapsedString;
    /** @hidden */
    private readonly _langSignal;
    /** @hidden */
    private _translationResolver;
    /** @hidden */
    constructor();
    /** @hidden */
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationGroupComponent, "fd-notification-group", never, { "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, ["groupHeader", "groupTitle", "groupList"], ["fd-notification-group-header", "fd-notification-group-list", "fd-notification-group-growing-item"], true, never>;
}

declare class NotificationLinkComponent {
    /**
     * signal to control the show more/less
     * default value is false
     */
    showMore: i0.WritableSignal<boolean>;
    /**
     * Method to toggle show more functionality
     */
    toggleShowMore(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationLinkComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationLinkComponent, "fd-notification-link", never, {}, {}, never, never, true, never>;
}

/**
 * Configuration for opening a notification with the NotificationService.
 */
declare class NotificationConfig<T = any> {
    /** Id for the notification component. If omitted, a unique one is generated. */
    id?: string;
    /** aria-label attribute for the notification component element. */
    ariaLabel?: Nullable<string>;
    /** aria-labelledby attribute for the notification component element. */
    ariaLabelledBy?: Nullable<string>;
    /** aria-describedby attribute for the notification component element. */
    ariaDescribedBy?: Nullable<string>;
    /** The container that the notification is appended to. By default, it is appended to the body. */
    container?: HTMLElement | 'body';
    /** Data to pass along to the content through the NotificationRef. */
    data?: T;
    /** Custom width of the notification. */
    width?: string;
    /**
     * Whether the notification should trap focus within itself.
     * @default true
     */
    shouldTrapFocus?: boolean;
    /** Whether to dismiss the notification on router navigation start. */
    closeOnNavigation?: boolean;
}

declare class NotificationContainer {
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationContainer, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationContainer, "fd-notification-container", never, {}, {}, never, never, true, never>;
}

/**
 * Reference to a notification component generated via the NotificationService.
 * It can be injected into the content component through the constructor.
 * For a template, it is declared as part of the implicit context, see examples.
 */
declare class NotificationRef<T = any, P = any> {
    /**
     * Observable that is triggered when the notification is closed.
     * On close a *result* is passed back. On dismiss, an *error* is returned instead.
     */
    afterClosed: Observable<P | undefined>;
    /** Data passed from the calling component to the content.*/
    data: T;
    /** @hidden */
    protected readonly _afterClosed: Subject<P | undefined>;
    /** @hidden */
    constructor();
    /**
     * Closes the notification and passes the argument to the afterClosed observable.
     * @param result Value passed back to the observable as a result.
     */
    close(result?: P): void;
    /**
     * Dismisses the notification and passes the argument to the afterClosed observable as an error.
     * @param reason Value passed back to the observable as an error.
     */
    dismiss(reason?: P): void;
}

declare class NotificationService {
    private _dynamicComponentService;
    private _document;
    private _rtlService;
    /** @hidden */
    notifications: {
        notificationComponent: ComponentRef<NotificationComponent>;
        notificationConfig: Readonly<NotificationConfig>;
    }[];
    /** @hidden */
    containerRef: ComponentRef<NotificationContainer> | null;
    /**
     * @hidden
     * Element that was focused before the notification was opened. Being used to restore focus upon close.
     */
    private _elementFocusedBeforeNotificationWasOpened?;
    /**
     * @hidden
     */
    constructor(_dynamicComponentService: DynamicComponentService, _document: Document, _rtlService: RtlService);
    /**
     * Opens a notification component with a content of type TemplateRef or Component Type
     * @param content Content of the notification component.
     * @param notificationConfig Configuration of the notification component.
     */
    open(content: TemplateRef<any> | Type<any>, notificationConfig?: NotificationConfig): NotificationRef;
    /** Method to remove all of notifications from this service instance */
    destroyAll(): void;
    /** Method that informs if there is any notification opened in this service instance */
    isAnyOpened(): boolean;
    /** @hidden Method that destroys the Notification component */
    private _destroyNotificationComponent;
    /** @hidden attempts to focus previously selected element */
    private _restoreFocus;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationService, [null, null, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationService>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class NotificationModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NotificationModule, never, [typeof NotificationComponent, typeof NotificationContainer, typeof NotificationLinkComponent, typeof NotificationBodyComponent, typeof NotificationGroupComponent, typeof NotificationHeaderComponent, typeof NotificationFooterComponent, typeof NotificationActionsComponent, typeof NotificationContentComponent, typeof NotificationGroupListComponent, typeof NotificationGroupHeaderComponent, typeof NotificationGroupGrowingItemComponent, typeof NotificationListDirective, typeof NotificationTitleDirective, typeof NotificationPopoverDirective, typeof NotificationSeparatorDirective, typeof NotificationParagraphDirective, typeof NotificationMessageStripDirective, typeof NotificationFooterContentDirective, typeof NotificationGroupHeaderTitleDirective, typeof NotificationMessageStripContainerDirective, typeof NotificationGroupGrowingItemTitleDirective], [typeof NotificationComponent, typeof NotificationContainer, typeof NotificationLinkComponent, typeof NotificationBodyComponent, typeof NotificationGroupComponent, typeof NotificationHeaderComponent, typeof NotificationFooterComponent, typeof NotificationActionsComponent, typeof NotificationContentComponent, typeof NotificationGroupListComponent, typeof NotificationGroupHeaderComponent, typeof NotificationGroupGrowingItemComponent, typeof NotificationListDirective, typeof NotificationTitleDirective, typeof NotificationPopoverDirective, typeof NotificationSeparatorDirective, typeof NotificationParagraphDirective, typeof NotificationMessageStripDirective, typeof NotificationFooterContentDirective, typeof NotificationGroupHeaderTitleDirective, typeof NotificationMessageStripContainerDirective, typeof NotificationGroupGrowingItemTitleDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NotificationModule>;
}

declare const FD_NOTIFICATION: InjectionToken<unknown>;
declare const FD_NOTIFICATION_TITLE: InjectionToken<unknown>;
declare const FD_NOTIFICATION_PARAGRAPH: InjectionToken<unknown>;
declare const FD_NOTIFICATION_GROUP_HEADER: InjectionToken<unknown>;
declare const FD_NOTIFICATION_GROUP_HEADER_TITLE: InjectionToken<unknown>;
declare const FD_NOTIFICATION_GROUP_LIST: InjectionToken<unknown>;
declare const FD_NOTIFICATION_FOOTER: InjectionToken<unknown>;

export { FD_NOTIFICATION, FD_NOTIFICATION_FOOTER, FD_NOTIFICATION_GROUP_HEADER, FD_NOTIFICATION_GROUP_HEADER_TITLE, FD_NOTIFICATION_GROUP_LIST, FD_NOTIFICATION_PARAGRAPH, FD_NOTIFICATION_TITLE, NotificationActionsComponent, NotificationBodyComponent, NotificationComponent, NotificationConfig, NotificationContainer, NotificationContentComponent, NotificationFooterComponent, NotificationFooterContentDirective, NotificationGroupBaseDirective, NotificationGroupComponent, NotificationGroupGrowingItemComponent, NotificationGroupGrowingItemTitleDirective, NotificationGroupHeaderComponent, NotificationGroupHeaderTitleDirective, NotificationGroupListComponent, NotificationHeaderComponent, NotificationLinkComponent, NotificationListDirective, NotificationMessageStripContainerDirective, NotificationMessageStripDirective, NotificationModule, NotificationParagraphDirective, NotificationPopoverDirective, NotificationRef, NotificationSeparatorDirective, NotificationService, NotificationTitleDirective };
