import { Nullable, ColorAccent } from '@fundamental-ngx/cdk/utils';
import { MenuComponent } from '@fundamental-ngx/core/menu';
import { Placement, PopoverFillMode, SearchComponent } from '@fundamental-ngx/core/shared';
import * as i0 from '@angular/core';
import { ElementRef, AfterContentChecked, QueryList, EventEmitter, OnInit, OnDestroy, AfterViewInit, AfterContentInit, TemplateRef, InjectionToken } from '@angular/core';
import { ButtonType } from '@fundamental-ngx/core/button';
import { IconFont } from '@fundamental-ngx/core/icon';
import { ComboboxInterface } from '@fundamental-ngx/core/combobox';
import { ProductSwitchComponent } from '@fundamental-ngx/core/product-switch';
import { CdkPortalOutlet, DomPortal } from '@angular/cdk/portal';
import { UserMenuComponent } from '@fundamental-ngx/core/user-menu';
import { SideNavigationInterface } from '@fundamental-ngx/core/side-navigation';
import * as i16 from '@fundamental-ngx/core/content-density';

type ShellbarSizes = 's' | 'm' | 'l' | 'xl';
type Breakpoints = Record<ShellbarSizes, number>;
type ShellbarGroup = 'product' | 'search' | 'actions';
interface NormalizedBreakpoint {
    size: ShellbarSizes;
    min: number;
    max: number;
}
type ShellbarGroupFlexOptions = Partial<{
    [key in ShellbarGroup]: {
        /**
         * Whether to shrink group.
         */
        shrink?: boolean;
        /**
         * Whether to apply flex-basis: auto style.
         */
        flexBasisAuto?: boolean;
    };
}>;

interface Shellbar {
    groupFlex: Nullable<ShellbarGroupFlexOptions>;
    _searchToggledFromActions: () => void;
    _actionsExceedShellbarWidth: () => boolean;
}

interface ShellbarMenuItem {
    /** Text written in dropdown option */
    name: string;
    /**
     *  Callback function that will be called on selecting this shellbar menu item from dropdown
     */
    callback?: (event: MouseEvent) => void;
    /**
     * The link, that user will be redirected to, after clicking item. When this value is set, element will become
     * anchor with href, otherwise it's basic text
     */
    link?: string;
    /**
    /* The icon to include in shellbar menu item See the icon page for the list of icons.
    */
    glyph?: string;
    /**
    /* If true open the link in a new tab.
    */
    newTab?: boolean;
}

interface ShellbarUser {
    /** Initials of user name */
    initials?: string;
    /** Url of user image (optional) */
    image?: string;
    /** User full name used only on aria-label*/
    fullName?: string;
    /**
     * Color Accent of user (optional), for more information about colors accent,
     * please visit: https://sap.github.io/fundamental-styles/components/identifier.html
     */
    colorAccent?: ColorAccent;
}

interface ShellbarUserMenu {
    /** Text written in dropdown option */
    text: string;
    /**
     *  Callback function that will be called on selecting this shellbar menu item from dropdown
     */
    callback?: (event: MouseEvent) => void;
}

/**
 * The component that represents a product menu.
 * Product menu is used for navigating to applications within the product.
 * ```html
 * <fd-product-menu [control]="productMenuControl"
 *                  [items]="productMenuItems">
 * </fd-product-menu>
 * ```
 */
declare class ProductMenuComponent {
    /** Whether the popover should close when the escape key is pressed. */
    closeOnEscapeKey: boolean;
    /** Whether the popover should close when a click is made outside its boundaries. */
    closeOnOutsideClick: boolean;
    /** The trigger events that will open/close the popover.
     *  Accepts any [HTML DOM Events](https://www.w3schools.com/jsref/dom_obj_event.asp). */
    triggers: string[];
    /** The placement of the popover. It can be one of: top, top-start, top-end, bottom,
     *  bottom-start, bottom-end, right, right-start, right-end, left, left-start, left-end. */
    placement: Placement;
    /** Whether the popover is disabled. */
    disabled: boolean;
    /**
     * Preset options for the popover body width.
     * * `at-least` will apply a minimum width to the body equivalent to the width of the control.
     * * `equal` will apply a width to the body equivalent to the width of the control.
     * * Leave blank for no effect.
     */
    fillControlMode: PopoverFillMode | null;
    /**
     * The control element to toggle the product menu,
     * represented by the name of the current application.
     */
    control: string;
    /**
     *  The items in the product menu. If the value is not passed or there is empty array,
     * the template changes and shows only control
     */
    items: ShellbarMenuItem[];
    /** When set to true, popover list will be closed after selecting the option */
    closePopoverOnSelect: boolean;
    /** @hidden */
    menu: MenuComponent;
    /** @hidden */
    itemClicked(item: ShellbarMenuItem, event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProductMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ProductMenuComponent, "fd-product-menu", never, { "closeOnEscapeKey": { "alias": "closeOnEscapeKey"; "required": false; }; "closeOnOutsideClick": { "alias": "closeOnOutsideClick"; "required": false; }; "triggers": { "alias": "triggers"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "fillControlMode": { "alias": "fillControlMode"; "required": false; }; "control": { "alias": "control"; "required": false; }; "items": { "alias": "items"; "required": false; }; "closePopoverOnSelect": { "alias": "closePopoverOnSelect"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * The component that represents a shellbar action.
 * ```html
 *  <fd-shellbar-action *ngFor="let action of actions"
 *                      [glyph]="action.glyph"
 *                      [callback]="action.callback"
 *                      [label]="action.label"
 *                      [ariaLabel]="action.ariaLabel"
 *                      [title]="action.title"
 *                      [notificationCount]="action.notificationCount"
 *                      [notificationLabel]="action.notificationLabel">
 *  </fd-shellbar-action>
 * ```
 */
declare class ShellbarActionComponent {
    /** Icon name for the button. */
    readonly glyph: i0.InputSignal<string | undefined>;
    /** Icon font family. */
    readonly glyphFont: i0.InputSignal<IconFont>;
    /** Function to call when the action is clicked. */
    readonly callback: i0.InputSignal<Nullable<(event: MouseEvent) => void>>;
    /** Accessible label for the action. */
    readonly label: i0.InputSignal<string>;
    /** ARIA label for screen readers. */
    readonly ariaLabel: i0.InputSignal<string>;
    /** Tooltip text shown on hover. */
    readonly title: i0.InputSignal<string>;
    /** ARIA label for the notification badge. */
    readonly notificationLabel: i0.InputSignal<string | undefined>;
    /** Number of notifications to display in badge. */
    readonly notificationCount: i0.InputSignal<number | undefined>;
    /** The button type for styling (e.g., 'transparent', 'emphasized'). */
    readonly fdType: i0.InputSignal<ButtonType>;
    /** Whether the button is in toggled state. */
    readonly toggled: i0.InputSignal<boolean | null | undefined>;
    /** @hidden */
    _elRef: ElementRef<any>;
    /** @hidden */
    protected _handleClick(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ShellbarActionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ShellbarActionComponent, "fd-shellbar-action", never, { "glyph": { "alias": "glyph"; "required": false; "isSignal": true; }; "glyphFont": { "alias": "glyphFont"; "required": false; "isSignal": true; }; "callback": { "alias": "callback"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "notificationLabel": { "alias": "notificationLabel"; "required": false; "isSignal": true; }; "notificationCount": { "alias": "notificationCount"; "required": false; "isSignal": true; }; "fdType": { "alias": "fdType"; "required": false; "isSignal": true; }; "toggled": { "alias": "toggled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class ShellbarActionsMobileComponent implements AfterContentChecked {
    /** @hidden */
    shellbarActions: QueryList<ShellbarActionComponent>;
    /**
     * Whether the search is present in the shellbar.
     */
    searchExists: boolean;
    /** @hidden */
    assistiveToolsCallback: Nullable<(event: MouseEvent) => void>;
    /** @hidden */
    showSearch: EventEmitter<void>;
    /** @hidden */
    totalNotifications: number;
    /** The button type for styling (e.g., 'transparent', 'emphasized'). */
    readonly fdType: i0.InputSignal<ButtonType>;
    /** Whether the button is in toggled state. */
    readonly toggled: i0.InputSignal<boolean | null | undefined>;
    /** @hidden */
    actionClicked(item: ShellbarActionComponent, event: MouseEvent): void;
    /** @hidden */
    ngAfterContentChecked(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ShellbarActionsMobileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ShellbarActionsMobileComponent, "fd-shellbar-actions-mobile", never, { "shellbarActions": { "alias": "shellbarActions"; "required": false; }; "searchExists": { "alias": "searchExists"; "required": false; }; "assistiveToolsCallback": { "alias": "assistiveToolsCallback"; "required": false; }; "fdType": { "alias": "fdType"; "required": false; "isSignal": true; }; "toggled": { "alias": "toggled"; "required": false; "isSignal": true; }; }, { "showSearch": "showSearch"; }, never, never, true, never>;
}

declare class ShellbarUserMenuButtonDirective implements OnInit {
    /** The type of the button. In case of the ShellbarUserMenuButtonDirective, the type is always 'transparent'. */
    fdType: "transparent";
    /** @hidden */
    private _hostButton;
    /** @hidden */
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ShellbarUserMenuButtonDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ShellbarUserMenuButtonDirective, "[fd-button][fdShellbarUserMenuButton]", never, { "fdType": { "alias": "fdType"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * This Component extends popover component and passes all the options and events from outside to popover component
 * and Vice Versa
 * */
declare class ShellbarUserMenuComponent {
    /** The user data. */
    user: ShellbarUser;
    /** The user menu data. */
    userMenu: ShellbarUserMenu[];
    /**
     * Preset options for the popover body width.
     * * `at-least` will apply a minimum width to the body equivalent to the width of the control.
     * * `equal` will apply a width to the body equivalent to the width of the control.
     * * Leave blank for no effect.
     */
    fillControlMode: PopoverFillMode | null;
    /** The placement of the popover. It can be one of: top, top-start, top-end, bottom,
     *  bottom-start, bottom-end, right, right-start, right-end, left, left-start, left-end. */
    placement: Placement;
    /** The trigger events that will open/close the popover.
     *  Accepts any [HTML DOM Events](https://www.w3schools.com/jsref/dom_obj_event.asp). */
    triggers: string[];
    /** Whether the popover should close when the escape key is pressed. */
    closeOnEscapeKey: boolean;
    /** Whether the popover should close when a click is made outside its boundaries. */
    closeOnOutsideClick: boolean;
    /** Whether the popover is disabled. */
    disabled: boolean;
    /** Whether or not to show the popover arrow */
    noArrow: boolean;
    /** Event emitted on item click */
    itemClicked: EventEmitter<void>;
    /** @hidden */
    _menu: MenuComponent;
    /** @hidden */
    _contentPassedMenu: MenuComponent;
    /** @hidden */
    _shellbarUserMenuButton: ShellbarUserMenuButtonDirective;
    /** Reference to Menu Component */
    get menu(): MenuComponent;
    /**
     * @hidden
     */
    itemClick(item: ShellbarUserMenu, event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ShellbarUserMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ShellbarUserMenuComponent, "fd-shellbar-user-menu", never, { "user": { "alias": "user"; "required": false; }; "userMenu": { "alias": "userMenu"; "required": false; }; "fillControlMode": { "alias": "fillControlMode"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "triggers": { "alias": "triggers"; "required": false; }; "closeOnEscapeKey": { "alias": "closeOnEscapeKey"; "required": false; }; "closeOnOutsideClick": { "alias": "closeOnOutsideClick"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "noArrow": { "alias": "noArrow"; "required": false; }; }, { "itemClicked": "itemClicked"; }, ["_contentPassedMenu", "_shellbarUserMenuButton"], ["[fdShellbarUserMenuButton]"], true, never>;
}

/**
 * The component that represents shellbar actions.
 * It is a container wrapper for all product actions and links (required element).
 * ```html
 * <fd-shellbar-actions [user]="user"
 *                      [userMenu]="userMenu"
 *                      [productSwitcher]="productSwitcher">
 *        <button fd-button fdType="standard">Custom Button</button>
 *
 *        <fd-shellbar-action *ngFor="let action of actions"
 *                            [glyph]="action.glyph"
 *                            [callback]="action.callback"
 *                            [label]="action.label"
 *                            [notificationCount]="action.notificationCount"
 *                            [notificationLabel]="action.notificationLabel">
 *        </fd-shellbar-action>
 * </fd-shellbar-actions>
 * ```
 */
declare class ShellbarActionsComponent implements OnDestroy {
    /** The user data. */
    user: ShellbarUser;
    /** The user menu data. */
    userMenu: ShellbarUserMenu[];
    /** When set to true, popover list will be closed after selecting the option */
    closePopoverOnSelect: boolean;
    /** Whether to show the assistive tools icon. */
    assistiveTools: boolean;
    /** @hidden */
    assistiveToolsCallback: Nullable<(event: MouseEvent) => void>;
    /**
     * Event emitted when search opened.
     */
    searchOpen: EventEmitter<boolean>;
    /** @hidden */
    shellbarActions: QueryList<ShellbarActionComponent>;
    /** @hidden */
    userComponent: ShellbarUserMenuComponent;
    /** @hidden */
    userComponentView: ShellbarUserMenuComponent;
    /** @hidden */
    comboboxComponent: ComboboxInterface;
    /** @hidden */
    productSwitchComponent: ProductSwitchComponent;
    /** @hidden */
    userMenuComponent: UserMenuComponent;
    /** @hidden */
    _portalOutlet: Nullable<CdkPortalOutlet>;
    /** @hidden */
    _addSearchIcon: boolean;
    /** @hidden */
    _searchPortal: DomPortal;
    /** @hidden */
    _showMobileActions: boolean;
    /**
     * Whether to show the search field.
     */
    showSearch: boolean;
    /** @hidden */
    currentSize: ShellbarSizes;
    /** @hidden */
    _elRef: ElementRef<any>;
    /** @hidden */
    private readonly _cd;
    /** @hidden */
    private readonly _shellbar;
    /** @hidden */
    private _searchComponent;
    /** @hidden */
    _toggleSearch: () => void;
    /** @hidden */
    get userItem(): ShellbarUser;
    /** @hidden */
    ngOnDestroy(): void;
    /** @hidden */
    _handleOverflow(shouldOverflow: boolean): void;
    /** @hidden */
    _attachSearch(portal: DomPortal, searchComponent: Nullable<SearchComponent>, size: ShellbarSizes): void;
    /** @hidden */
    _detachSearch(): void;
    /** @hidden */
    _triggerItems(): void;
    /** @hidden */
    _setSearchVisibility(visible: boolean): void;
    /** @hidden */
    private _toggleSearchPortal;
    static ɵfac: i0.ɵɵFactoryDeclaration<ShellbarActionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ShellbarActionsComponent, "fd-shellbar-actions", never, { "user": { "alias": "user"; "required": false; }; "userMenu": { "alias": "userMenu"; "required": false; }; "closePopoverOnSelect": { "alias": "closePopoverOnSelect"; "required": false; }; "assistiveTools": { "alias": "assistiveTools"; "required": false; }; "assistiveToolsCallback": { "alias": "assistiveToolsCallback"; "required": false; }; }, { "searchOpen": "searchOpen"; }, ["userComponent", "comboboxComponent", "productSwitchComponent", "userMenuComponent", "shellbarActions"], ["fd-combobox", "*", "fd-shellbar-action", "fd-shellbar-user-menu", "fd-user-menu", "fd-product-switch"], true, never>;
}

/**
 * The component for shellbar branding.
 */
declare class ShellbarBrandingComponent {
    private _elRef;
    /** Whether the shellbar branding is interactive. */
    interactiveBranding: boolean;
    /** @hidden */
    private readonly _shellbar;
    /** @hidden */
    constructor(_elRef: ElementRef);
    /** @hidden */
    hideTitleIfNeeded(): void;
    /** @hidden */
    showTitle(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ShellbarBrandingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ShellbarBrandingComponent, "fd-shellbar-branding", never, { "interactiveBranding": { "alias": "interactiveBranding"; "required": false; }; }, {}, never, ["*"], true, never>;
}

/**
 * Component representing the context area of the shellbar.
 * It manages the visibility of its child elements based on the available width.
 */
declare class ShellbarContextAreaComponent implements AfterViewInit {
    /** Event emitted when items in the context area are hidden or shown. Event parameter is an array of all the items that are hidden. */
    contentItemVisibilityChange: i0.OutputEmitterRef<HTMLElement[]>;
    /** @hidden */
    el: ElementRef;
    /** @hidden */
    private readonly _shellbar;
    /** @hidden */
    private _resizeObserverService;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    private _hiddenItems;
    /** @hidden */
    ngAfterViewInit(): void;
    /**
     * Iteratively hides elements if the end of the actions exceed the end of the shellbar.
     */
    hideElementsIfNeeded(): void;
    /**
     * Iteratively shows elements if they can be displayed in the shellbar without causing the actions
     * to exceed the end of th eshellbar.
     */
    showElements(): void;
    /**
     * Retrieves the child elements with their respective priority values.
     * The elements are sorted based on their priority, with elements having
     * higher priority shown first.
     */
    private _getContextAreaItemsWithPriority;
    /**
     * Compares two arrays of HTMLElements for equality.
     * Sorts both arrays and checks if all elements are the same.
     */
    private _arraysEqual;
    static ɵfac: i0.ɵɵFactoryDeclaration<ShellbarContextAreaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ShellbarContextAreaComponent, "fd-shellbar-context-area", never, {}, { "contentItemVisibilityChange": "contentItemVisibilityChange"; }, never, ["*"], true, never>;
}

declare class ShellbarHidePriorityDirective {
    /** @hidden */
    priority: any;
    /** @hidden */
    elRef: ElementRef<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ShellbarHidePriorityDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ShellbarHidePriorityDirective, "[fdShellbarHidePriority]", never, { "priority": { "alias": "fdShellbarHidePriority"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * The component that represents a shellbar logo.
 * The logo is a required element and is used for company branding.
 * ```html
 *   <fd-shellbar-logo>
 *      <a href="#" class="fd-shellbar__logo fd-shellbar__logo--image-replaced" aria-label="SAP"></a>
 *   </fd-shellbar-logo>
 * ```
 */
declare class ShellbarLogoComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<ShellbarLogoComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ShellbarLogoComponent, "fd-shellbar-logo", never, {}, {}, never, ["*"], true, never>;
}

/**
 * The shellbar separator component.
 */
declare class ShellbarSeparatorComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<ShellbarSeparatorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ShellbarSeparatorComponent, "fd-shellbar-separator", never, {}, {}, never, never, true, never>;
}

declare class ShellbarSidenavDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<ShellbarSidenavDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ShellbarSidenavDirective, "[fdShellbarSidenav], [fd-shellbar-side-nav]", never, {}, {}, never, never, true, never>;
}

/**
 * @deprecated The shellbar subtitle component has been deprecated as of 0.54.2.
 *
 * The component that represents a shellbar subtitle.
 * The subtitle is optional and should be used rarely.
 * ```html
 *   <fd-shellbar-subtitle>
 *      Corporate Portal
 *   </fd-shellbar-subtitle>
 * ```
 */
declare class ShellbarSubtitleComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<ShellbarSubtitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ShellbarSubtitleComponent, "fd-shellbar-subtitle", never, {}, {}, never, ["*"], true, never>;
}

/**
 * The component that represents a shellbar title.
 * The title is a required element and displays the current application name.
 * ```html
 *   <fd-shellbar-title>
 *      Corporate Portal
 *   </fd-shellbar-title>
 * ```
 */
declare class ShellbarTitleComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<ShellbarTitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ShellbarTitleComponent, "fd-shellbar-title", never, {}, {}, never, ["*"], true, never>;
}

/**
 * The shellbar offers consistent, responsive navigation across all products and applications.
 * Includes support for branding, product navigation, search, notifications, and user settings.
 * Shellbar is a composite component comprised of mandatory and optional elements.
 */
declare class ShellbarComponent implements AfterContentInit, AfterViewInit, OnDestroy {
    /** Size of Shellbar component 's' | 'm' | 'l' | 'xl' */
    set size(value: ShellbarSizes | undefined);
    get size(): ShellbarSizes | undefined;
    /**
     * Responsive breakpoints.
     */
    set breakpoints(breakpoints: Breakpoints);
    /**
     * Whether the Shellbar is used with Side Navigation.
     * When set to true, the responsive paddings are not applied.
     * Can also accept a template variable referring to a SideNavigationInterface (fd-side-nav or fdx-side-nav), and
     * will add the corresponding class.
     */
    sideNav: boolean | SideNavigationInterface;
    /**
     * Shellbar group flex configuration.
     */
    set groupFlex(value: Nullable<ShellbarGroupFlexOptions>);
    get groupFlex(): Nullable<ShellbarGroupFlexOptions>;
    /** Whether to show the navigation button. */
    showNavigationButton: boolean;
    /**
     * Custom template for navigation button. When provided, this template will be rendered instead of the default button.
     * Use this when you need to render a complex component like a popover with a button inside.
     * The template should handle its own click events and accessibility attributes.
     */
    navigationButtonTemplate: TemplateRef<any> | null;
    /** Whether to show the back button. */
    showBackButton: boolean;
    /** Label for the navigation button. */
    navigationButtonLabel: string;
    /** Label for the back button. */
    backButtonLabel: string;
    /** Whether to show the search when the shellbar size is set to small. */
    showSearchFieldOnSizeSmall: boolean;
    /** Emitted event when navigation button is clicked. */
    navigationButtonClicked: EventEmitter<Event>;
    /** Emitted event when back button is clicked. */
    backButtonClicked: EventEmitter<Event>;
    /** @hidden */
    comboboxComponent: ComboboxInterface;
    /** @hidden */
    buttons: QueryList<ElementRef>;
    /** @hidden */
    productSwitches: QueryList<ProductSwitchComponent>;
    /** @hidden */
    contextArea: ShellbarContextAreaComponent;
    /** @hidden */
    branding: ShellbarBrandingComponent;
    /** @hidden */
    private _actions?;
    /** @hidden */
    private readonly _searchPortalOutlet;
    /** @hidden */
    private readonly _shellbar;
    /** @hidden */
    _showMobileSearch: boolean;
    protected readonly navigationIcon: i0.Signal<string>;
    /** @hidden */
    private readonly isRtl;
    /**
     * Search component placed inside the shellbar
     */
    set searchComponent(component: Nullable<SearchComponent>);
    get searchComponent(): Nullable<SearchComponent>;
    /** @hidden */
    get _hideTitleComponents(): boolean;
    /** @hidden */
    get _hideAllComponents(): boolean;
    /** @hidden */
    get _currentSize(): ShellbarSizes;
    /** @hidden */
    private _groupFlex;
    /** @hidden */
    private _searchPortal;
    /** @hidden */
    private _searchComponent;
    /** @hidden */
    private readonly _currentSize$;
    /** @hidden */
    private _size;
    /** @hidden */
    private _breakpointSize;
    /** @hidden */
    private readonly _cd;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    private _breakpoints;
    /** @hidden */
    private _searchSubmitSubscription;
    /** @hidden */
    private _resizeObserverService;
    /** @hidden */
    private readonly _rtlService;
    /** @hidden */
    ngAfterContentInit(): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** @hidden */
    applyShellbarModeToCombobox(): void;
    /** @hidden */
    applyShellbarModeToButtons(): void;
    /** @hidden */
    _closeMobileSearch(): void;
    /** @hidden */
    _getSideNavClass(): string;
    /** @hidden */
    _getShellbarEnd(): number;
    /** @hidden */
    _getActionsEnd(): number;
    /** @hidden */
    _actionsExceedShellbarWidth(): boolean;
    /** @hidden */
    _searchToggledFromActions(): void;
    /** @hidden */
    _navigationClicked(event: Event): void;
    /** @hidden */
    _backClicked(event: Event): void;
    /** @hidden */
    private _setSearchComponentListeners;
    private _placeSearch;
    /** @hidden */
    private _setCurrentBreakpoint;
    /** @hidden */
    private _handleOverflow;
    /** @hidden */
    private _resetOverflow;
    /** @hidden */
    private _normalizeBreakpoints;
    /** @hidden */
    private _attachSearch;
    /** @hidden */
    private _detachSearch;
    /** @hidden */
    private _setProductSwitchDensities;
    static ɵfac: i0.ɵɵFactoryDeclaration<ShellbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ShellbarComponent, "fd-shellbar", never, { "size": { "alias": "size"; "required": false; }; "breakpoints": { "alias": "breakpoints"; "required": false; }; "sideNav": { "alias": "sideNav"; "required": false; }; "groupFlex": { "alias": "groupFlex"; "required": false; }; "showNavigationButton": { "alias": "showNavigationButton"; "required": false; }; "navigationButtonTemplate": { "alias": "navigationButtonTemplate"; "required": false; }; "showBackButton": { "alias": "showBackButton"; "required": false; }; "navigationButtonLabel": { "alias": "navigationButtonLabel"; "required": false; }; "backButtonLabel": { "alias": "backButtonLabel"; "required": false; }; "showSearchFieldOnSizeSmall": { "alias": "showSearchFieldOnSizeSmall"; "required": false; }; }, { "navigationButtonClicked": "navigationButtonClicked"; "backButtonClicked": "backButtonClicked"; }, ["comboboxComponent", "contextArea", "branding", "_actions", "searchComponent", "buttons", "productSwitches"], ["fd-shellbar-branding", "[fd-shellbar-side-nav]", "fd-shellbar-logo", "fd-shellbar-title", "fd-product-menu", "fd-shellbar-subtitle", "fd-shellbar-separator", "fd-shellbar-context-area", "*", "fd-shellbar-actions"], true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class ShellbarModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ShellbarModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ShellbarModule, never, [typeof ShellbarComponent, typeof ProductMenuComponent, typeof ShellbarSubtitleComponent, typeof ShellbarActionsComponent, typeof ShellbarActionsMobileComponent, typeof ShellbarActionComponent, typeof ShellbarLogoComponent, typeof ShellbarTitleComponent, typeof ShellbarUserMenuComponent, typeof ShellbarSidenavDirective, typeof ShellbarUserMenuButtonDirective, typeof ShellbarSidenavDirective, typeof ShellbarBrandingComponent, typeof ShellbarContextAreaComponent, typeof ShellbarSeparatorComponent, typeof ShellbarHidePriorityDirective], [typeof ShellbarComponent, typeof ProductMenuComponent, typeof ShellbarSubtitleComponent, typeof ShellbarActionsComponent, typeof ShellbarActionsMobileComponent, typeof ShellbarActionComponent, typeof ShellbarLogoComponent, typeof ShellbarTitleComponent, typeof ShellbarUserMenuComponent, typeof ShellbarSidenavDirective, typeof ShellbarUserMenuButtonDirective, typeof ShellbarSidenavDirective, typeof ShellbarBrandingComponent, typeof ShellbarContextAreaComponent, typeof ShellbarSeparatorComponent, typeof ShellbarHidePriorityDirective, typeof i16.ContentDensityModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ShellbarModule>;
}

declare const FD_SHELLBAR_SEARCH_CONFIG: InjectionToken<unknown>;
declare const FD_SHELLBAR_SEARCH_COMPONENT: InjectionToken<SearchComponent>;
declare const FD_SHELLBAR_ACTION_COMPONENT: InjectionToken<unknown>;
declare const FD_SHELLBAR_COMPONENT: InjectionToken<Shellbar>;

export { FD_SHELLBAR_ACTION_COMPONENT, FD_SHELLBAR_COMPONENT, FD_SHELLBAR_SEARCH_COMPONENT, FD_SHELLBAR_SEARCH_CONFIG, ProductMenuComponent, ShellbarActionComponent, ShellbarActionsComponent, ShellbarActionsMobileComponent, ShellbarBrandingComponent, ShellbarComponent, ShellbarContextAreaComponent, ShellbarHidePriorityDirective, ShellbarLogoComponent, ShellbarModule, ShellbarSeparatorComponent, ShellbarSidenavDirective, ShellbarSubtitleComponent, ShellbarTitleComponent, ShellbarUserMenuButtonDirective, ShellbarUserMenuComponent };
export type { Breakpoints, NormalizedBreakpoint, Shellbar, ShellbarGroup, ShellbarGroupFlexOptions, ShellbarMenuItem, ShellbarSizes, ShellbarUser, ShellbarUserMenu };
