import * as _angular_core from '@angular/core';
import { TemplateRef, Signal, EventEmitter, QueryList, Injector, ElementRef } from '@angular/core';
import { TriggerConfig } from '@fundamental-ngx/core/popover';
import { Placement } from '@fundamental-ngx/core/shared';
import { SearchFieldComponent } from '@fundamental-ngx/btp/search-field';
import { FdbViewMode } from '@fundamental-ngx/btp/shared';
import { OverflowItemRef } from '@fundamental-ngx/core/overflow-layout';
import { ButtonComponent } from '@fundamental-ngx/core/button';
import * as i1 from '@fundamental-ngx/btp/button';
import * as i2 from '@fundamental-ngx/cdk/utils';
import { HasElementRef } from '@fundamental-ngx/cdk/utils';
import * as i1$1 from '@fundamental-ngx/core/content-density';
import { ContentDensityMode, ContentDensityDirective } from '@fundamental-ngx/core/content-density';

declare class ToolHeaderActionClass<ActionTemplateContext = any> {
    /** Whether the element is forced to be visible. */
    forceVisibility: boolean;
    /** Template of the action section */
    templateRef: TemplateRef<ActionTemplateContext>;
    /** @hidden */
    readonly isSeparator: boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToolHeaderActionClass<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ToolHeaderActionClass<any>, never, never, { "forceVisibility": { "alias": "forceVisibility"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_forceVisibility: unknown;
}

declare class ToolHeaderActionSeparatorComponent extends ToolHeaderActionClass {
    /** @hidden */
    templateRef: TemplateRef<void>;
    /** @hidden */
    readonly isSeparator = true;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToolHeaderActionSeparatorComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToolHeaderActionSeparatorComponent, "fdb-tool-header-action-separator", never, {}, {}, never, never, true, never>;
}

declare class ToolHeaderProductSwitchComponent {
    /** Placement of a popover. */
    readonly placement: _angular_core.InputSignal<Placement>;
    /** Whether the product switch is disabled. */
    readonly disabled: _angular_core.InputSignal<boolean>;
    /** Whether the popover should close when the escape key is pressed. */
    readonly closeOnEscapeKey: _angular_core.InputSignal<boolean>;
    /** Whether the popover should close when a click is made outside its boundaries. */
    readonly closeOnOutsideClick: _angular_core.InputSignal<boolean>;
    /** Whether the popover should have an arrow. */
    readonly noArrow: _angular_core.InputSignal<boolean>;
    /** Whether to wrap content with fd-scrollbar directive. */
    readonly disableScrollbar: _angular_core.InputSignal<boolean>;
    /** The trigger events that will open/close the popover. */
    readonly triggers: _angular_core.InputSignal<(string | TriggerConfig)[]>;
    /** Whether the popover should be focusTrapped. */
    readonly focusTrapped: _angular_core.InputSignal<boolean>;
    /** Whether the popover should automatically move focus into the trapped region. */
    readonly focusAutoCapture: _angular_core.InputSignal<boolean>;
    /** Two-way binding for isOpen state */
    readonly isOpen: _angular_core.ModelSignal<boolean>;
    /** Event emitted right before the popover is being opened. */
    readonly beforeOpen: _angular_core.OutputEmitterRef<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToolHeaderProductSwitchComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToolHeaderProductSwitchComponent, "fdb-tool-header-product-switch", never, { "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "closeOnEscapeKey": { "alias": "closeOnEscapeKey"; "required": false; "isSignal": true; }; "closeOnOutsideClick": { "alias": "closeOnOutsideClick"; "required": false; "isSignal": true; }; "noArrow": { "alias": "noArrow"; "required": false; "isSignal": true; }; "disableScrollbar": { "alias": "disableScrollbar"; "required": false; "isSignal": true; }; "triggers": { "alias": "triggers"; "required": false; "isSignal": true; }; "focusTrapped": { "alias": "focusTrapped"; "required": false; "isSignal": true; }; "focusAutoCapture": { "alias": "focusAutoCapture"; "required": false; "isSignal": true; }; "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; }, { "isOpen": "isOpenChange"; "beforeOpen": "beforeOpen"; }, never, ["*"], true, never>;
}

interface ToolHeaderActionContext {
    hidden: boolean;
}
declare class ToolHeaderActionDirective extends ToolHeaderActionClass {
    /**
     * Button component which will be used for the action
     **/
    button: ButtonComponent;
    /** @hidden */
    templateRef: TemplateRef<ToolHeaderActionContext>;
    /** @hidden */
    static ngTemplateContextGuard(dir: ToolHeaderActionDirective, ctx: unknown): ctx is ToolHeaderActionContext;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToolHeaderActionDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ToolHeaderActionDirective, "[fdbToolHeaderAction]", never, {}, {}, ["button"], never, true, never>;
}

declare class ToolHeaderLogoDirective {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToolHeaderLogoDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ToolHeaderLogoDirective, "[fdbToolHeaderLogo]", never, {}, {}, never, never, true, never>;
}

declare class ToolHeaderUserDirective {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToolHeaderUserDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ToolHeaderUserDirective, "[fdbToolHeaderUser]", never, {}, {}, never, never, true, never>;
}

interface FdbToolHeaderState {
    backButtonVisible: boolean;
    menuButtonVisible: boolean;
    logoVisible: boolean;
    productNameVisible: boolean;
    secondTitleVisible: boolean;
    searchFieldVisible: boolean;
    searchFieldToggleActionVisible: boolean;
    providedActionsVisible: boolean;
    userAvatarVisible: boolean;
    productSwitchVisible: boolean;
    voiceInputVisible: boolean;
    separatorsBetweenActionsVisible: boolean;
}

declare abstract class ToolHeaderComponentClass {
    /** @hidden */
    mode$: Signal<FdbViewMode>;
    /** @hidden */
    orientation$: Signal<'landscape' | 'portrait'>;
    /** @hidden */
    searchField$: Signal<SearchFieldComponent | null>;
    /** @hidden */
    searchFieldExpanded$: Signal<boolean>;
    /** Mode signal */
    protected _mode$: _angular_core.WritableSignal<FdbViewMode>;
    /** @hidden */
    protected _orientation$: _angular_core.WritableSignal<"landscape" | "portrait">;
    /** @hidden */
    protected fdbToolHeaderState: Signal<FdbToolHeaderState>;
    /** Search field signal */
    protected _searchField$: _angular_core.WritableSignal<SearchFieldComponent | null>;
    /** @hidden */
    protected _searchFieldExpanded$: _angular_core.WritableSignal<boolean>;
    /**
     * RTL signal
     * @hidden
     */
    protected rtl: Signal<boolean>;
    /** @hidden */
    private readonly _rtlService;
    /** @hidden */
    constructor();
}

declare class ToolHeaderComponent extends ToolHeaderComponentClass {
    /**
     * (required) the Product Name is the official name of the tool.
     */
    productName: string;
    /**
     * Second Title is an optional second text identifier of the tool.
     **/
    secondTitle?: string;
    /** Mode */
    set _mode(mode: FdbViewMode);
    /** @hidden */
    set _orientation(orientation: 'landscape' | 'portrait');
    /**
     * Whether to show the menu button
     */
    showMenuButton: boolean;
    /**
     * Whether to show the voice input action button on
     * the right side of the tool header, when the mode is mobile
     * and the search input is expanded
     */
    showVoiceInputAction: boolean;
    /**
     * Event emitted when the menu button is clicked
     **/
    menuClick: EventEmitter<void>;
    /**
     * Event emitted when user intends to expand the menu.
     * Happens when user clicks `right arrow` key on the menu button
     * if on ltr or `left arrow` key if on rtl.
     **/
    menuExpand: EventEmitter<void>;
    /**
     * Event emitted when user intends to collapse the menu.
     * Happens when user clicks `left arrow` key on the menu button
     * if on ltr or `right arrow` key if on rtl.
     **/
    menuCollapse: EventEmitter<void>;
    /**
     * Event emitted when the microphone button is clicked
     **/
    microphoneClick: EventEmitter<void>;
    /**
     * Event emitted when the default logo is clicked
     */
    logoClick: EventEmitter<void>;
    /** @hidden */
    _contentActions: QueryList<ToolHeaderActionClass>;
    /** @hidden */
    _toolHeaderLogoDirective?: ToolHeaderLogoDirective;
    /** @hidden */
    set _searchField(searchField: SearchFieldComponent);
    /** @hidden */
    _toolHeaderUser?: ToolHeaderUserDirective;
    /** @hidden */
    _toolHeaderProductSwitch?: unknown;
    /** @hidden */
    protected readonly _hiddenActions$: _angular_core.WritableSignal<OverflowItemRef<ToolHeaderActionDirective>[]>;
    /** @hidden */
    private readonly _injector;
    /** @hidden */
    private _mapOfItemsAndInjectors;
    /**
     * The handler, responsible for closing the search field
     * on outside click
     * @hidden
     **/
    _onClick(event: MouseEvent): void;
    /**
     * The handler, responsible for the focusing on the search field,
     * when the user presses `Ctrl + K` or `Cmd + K` keys
     * @hidden
     **/
    _onKeyDown(): void;
    /**
     * Expand the search field
     **/
    expandSearchField(): void;
    /** @hidden */
    protected _handleMenuLeftArrowKey(): void;
    /** @hidden */
    protected _handleMenuRightArrowKey(): void;
    /** @hidden */
    protected _handleHiddenItemsChange($event: OverflowItemRef<ToolHeaderActionDirective>[]): void;
    /** @hidden */
    protected _indirectFocusableItemInjector(parent: Injector, item: OverflowItemRef<ToolHeaderActionDirective>): Injector;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToolHeaderComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToolHeaderComponent, "fdb-tool-header", never, { "productName": { "alias": "productName"; "required": true; }; "secondTitle": { "alias": "secondTitle"; "required": false; }; "_mode": { "alias": "mode"; "required": false; }; "_orientation": { "alias": "orientation"; "required": false; }; "showMenuButton": { "alias": "showMenuButton"; "required": false; }; "showVoiceInputAction": { "alias": "showVoiceInputAction"; "required": false; }; }, { "menuClick": "menuClick"; "menuExpand": "menuExpand"; "menuCollapse": "menuCollapse"; "microphoneClick": "microphoneClick"; "logoClick": "logoClick"; }, ["_toolHeaderLogoDirective", "_searchField", "_toolHeaderUser", "_toolHeaderProductSwitch", "_contentActions"], ["[fdbToolHeaderLogo]", "fdb-search-field", "[fdbToolHeaderUser]", "fdb-tool-header-product-switch, fd-product-switch"], true, never>;
    static ngAcceptInputType_showMenuButton: unknown;
    static ngAcceptInputType_showVoiceInputAction: unknown;
}

declare class ToolHeaderActionButtonDirective {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToolHeaderActionButtonDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ToolHeaderActionButtonDirective, "[fd-button][fdbToolHeaderActionButton]", never, {}, {}, never, never, true, [{ directive: typeof i1.ToolHeaderButtonDirective; inputs: { "fdType": "fdType"; }; outputs: {}; }, { directive: typeof i2.IndirectFocusableItemDirective; inputs: {}; outputs: {}; }, { directive: typeof i2.FocusableItemDirective; inputs: {}; outputs: {}; }]>;
}

interface FdbToolHeaderModeConfig {
    desktop: number;
    tabletLandscape: [number, number];
    tabletPortrait: [number, number];
    phone: number;
}
/**
 * Directive that automatically adjusts the ToolHeader's mode, orientation,
 * and content density based on the element's width.
 *
 * Content density is derived from the detected mode:
 * - Desktop mode (empty string): COMPACT density for mouse/keyboard interaction
 * - Tablet/Phone modes: COZY density for touch-friendly interaction
 *
 * @example
 * <fdb-tool-header fdbToolHeaderAutoMode>
 *   <!-- Content density automatically adjusts based on width -->
 * </fdb-tool-header>
 *
 * @example
 * <fdb-tool-header
 *   fdbToolHeaderAutoMode
 *   (modeChange)="onModeChange($event)"
 *   (contentDensityChange)="onDensityChange($event)">
 * </fdb-tool-header>
 */
declare class ToolHeaderAutoModeDirective implements HasElementRef {
    /**
     * What sizes should be used to determine mode.
     * Sizes mean the width of the tool header, not the whole screen.
     **/
    set config(config: Partial<FdbToolHeaderModeConfig>);
    /**
     * Current mode of the ToolHeaderComponent
     */
    modeChange: EventEmitter<FdbViewMode>;
    /**
     * Current orientation of the ToolHeaderComponent
     */
    orientationChange: EventEmitter<"landscape" | "portrait">;
    /**
     * Current content density of the ToolHeaderComponent
     */
    contentDensityChange: EventEmitter<ContentDensityMode>;
    /**
     * Reference to the element on which the directive is applied.
     */
    readonly elementRef: ElementRef;
    /**
     * Current configuration of the directive.
     */
    protected _config: _angular_core.WritableSignal<FdbToolHeaderModeConfig>;
    /**
     * Reference to the ContentDensityDirective provided via hostDirectives.
     * Used to programmatically set the content density based on the detected mode.
     */
    protected _contentDensity: ContentDensityDirective;
    /**
     * Signal of the Width of the element
     */
    protected _elementWidth: _angular_core.Signal<any>;
    /**
     * Reference to the ToolHeaderComponent
     */
    protected _toolHeaderComponent: ToolHeaderComponent;
    /**
     * Computed signal that determines the current mode and orientation
     * based on the element's width and configuration breakpoints.
     *
     * Returns a tuple of [mode, orientation] where mode is:
     * - '' (empty): desktop mode, triggers COMPACT density
     * - 'tablet': tablet mode, triggers COZY density
     * - 'phone': phone mode, triggers COZY density
     */
    protected _currentMode: _angular_core.Signal<[FdbViewMode, "landscape" | "portrait"]>;
    /**
     * @hidden
     */
    private readonly _destroyRef;
    /**
     * @hidden
     */
    constructor();
    /**
     * Determines the mode and orientation based on width and configuration.
     *
     * @param width - Current width of the element in pixels
     * @param config - Breakpoint configuration for mode detection
     * @returns Tuple of [mode, orientation] where mode affects content density
     */
    private _getMode;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToolHeaderAutoModeDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ToolHeaderAutoModeDirective, "fdb-tool-header[fdbToolHeaderAutoMode]", ["fdbToolHeaderAutoMode"], { "config": { "alias": "config"; "required": false; }; }, { "modeChange": "modeChange"; "orientationChange": "orientationChange"; "contentDensityChange": "contentDensityChange"; }, never, never, true, [{ directive: typeof i1$1.ContentDensityDirective; inputs: {}; outputs: {}; }]>;
}

interface FdbToolHeaderActionButton {
    templateRef?: TemplateRef<void>;
    glyph: string;
    label: string;
    forceVisibility?: boolean;
    clickCallback: () => void;
    hasBadge?: boolean;
    hasSeparator?: boolean;
}

export { ToolHeaderActionButtonDirective, ToolHeaderActionDirective, ToolHeaderActionSeparatorComponent, ToolHeaderAutoModeDirective, ToolHeaderComponent, ToolHeaderLogoDirective, ToolHeaderProductSwitchComponent, ToolHeaderUserDirective };
export type { FdbToolHeaderActionButton, ToolHeaderActionContext };