import { Nullable } from '@fundamental-ngx/cdk/utils';
import { IconFont } from '@fundamental-ngx/core/icon';
import * as i0 from '@angular/core';
import { InjectionToken, OnInit, ElementRef, ChangeDetectorRef, OnDestroy, AfterViewInit, QueryList } from '@angular/core';
import { Subject } from 'rxjs';

declare class MicroProcessFlowIconComponent {
    /** The icon name to display. See the icon page for the list of icons
     * here: https://sap.github.io/fundamental-ngx/icon
     */
    glyph: string;
    /**
     * The icon font
     * Options include: 'SAP-icons', 'BusinessSuiteInAppSymbols' and 'SAP-icons-TNT'
     */
    font: IconFont;
    /** user's custom classes */
    class: string;
    /** Aria-label for Icon. */
    ariaLabel: Nullable<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MicroProcessFlowIconComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MicroProcessFlowIconComponent, "fd-micro-process-flow-icon", never, { "glyph": { "alias": "glyph"; "required": false; }; "font": { "alias": "font"; "required": false; }; "class": { "alias": "class"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, {}, never, never, true, never>;
}

interface MicroProcessFlowComponentInterface {
    canItemsReceiveFocus: Subject<boolean>;
    setFocusedElementIndex(elm: HTMLElement): void;
}
declare const MICRO_PROCESS_FLOW: InjectionToken<MicroProcessFlowComponentInterface>;

declare class MicroProcessFlowFocusableItemDirective implements OnInit {
    elRef: ElementRef<HTMLElement>;
    private _microProcessFlow;
    /** @hidden */
    constructor(elRef: ElementRef<HTMLElement>, _microProcessFlow: MicroProcessFlowComponentInterface);
    /**
     * @hidden
     * Handler for focus events
     */
    onFocus(): void;
    /** @hidden */
    onBlur(): void;
    /** @hidden */
    ngOnInit(): void;
    /** Sets ability to focus on the element or not. */
    setFocusable(focusable?: boolean): void;
    /** Focuses on the element without scrolling it to the viewport */
    focus(options: FocusOptions): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MicroProcessFlowFocusableItemDirective, [null, { optional: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MicroProcessFlowFocusableItemDirective, "[fdMicroProcessFlowFocusableItem], [fd-micro-process-flow-focusable-item]", never, {}, {}, never, never, true, never>;
}

type MicroProcessFlowItemType = 'positive' | 'critical' | 'negative' | 'information' | 'none';

declare class MicroProcessFlowItemComponent {
    private _cd;
    elRef: ElementRef;
    /** Item state */
    state: MicroProcessFlowItemType;
    /** Whether or not display connector line */
    intermediate: boolean;
    /** Element that can receive focus. */
    focusableElement: MicroProcessFlowFocusableItemDirective;
    /** @hidden */
    _lastItem: boolean;
    /** @hidden */
    constructor(_cd: ChangeDetectorRef, elRef: ElementRef);
    /**
     * @param value Is current item the last one
     */
    setLastItem(value: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MicroProcessFlowItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MicroProcessFlowItemComponent, "fd-micro-process-flow-item", never, { "state": { "alias": "state"; "required": false; }; "intermediate": { "alias": "intermediate"; "required": false; }; }, {}, ["focusableElement"], ["*", "[fd-micro-process-flow-intermediary-item]"], true, never>;
}

declare class MicroProcessFlowComponent implements OnInit, OnDestroy, AfterViewInit {
    /** Should connector between items be hidden. */
    independentSteps: boolean;
    /** Pagination transition speed in milliseconds */
    transitionSpeed: number;
    /** Pagination transition effect */
    transitionTimingFunction: string;
    /** Micro process flow items. */
    items: QueryList<MicroProcessFlowItemComponent>;
    /** Micro process flow items. */
    focusableItems: QueryList<MicroProcessFlowFocusableItemDirective>;
    /** @hidden */
    private _wrapperContainer;
    /** @hidden */
    private _container;
    /** @hidden */
    private _goNextButton;
    /**
     * Previous items outside the viewport.
     */
    previousItemsCount: number;
    /**
     * Next items outside the viewport.
     */
    nextItemsCount: number;
    /** Indicating whether or not any element is focused */
    canItemsReceiveFocus: Subject<boolean>;
    /** Should show next button. */
    get showNextButton(): boolean;
    /** Should show previous button. */
    get showPreviousButton(): boolean;
    /** @hidden */
    private readonly _isRtl;
    /** @hidden */
    private get _paginationDirection();
    /** @hidden */
    private _subscriptions;
    /** @hidden */
    private _navigationKeys;
    /** @hidden */
    private _actionKeys;
    /** @hidden */
    private _focusedElementIndex;
    /** @hidden */
    private readonly _cd;
    /** @hidden */
    private readonly _rtlService;
    /** @hidden */
    constructor();
    /** @hidden */
    handleKeyboardEvent(event: KeyboardEvent): void;
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** Listens on items change and checks if navigation buttons should be visible. */
    listenOnItemsChange(): void;
    /** Scrolls to the next item. */
    goNext(): void;
    /** Scrolls to the previous item. */
    goBack(): void;
    /**
     * Sets last focused element index.
     * @param elm Focused HTML element.
     */
    setFocusedElementIndex(elm: HTMLElement): void;
    /**
     * Navigates to a specific page when the user presses 'Space' or 'Enter' key.
     * @param offset How much items needs to be scrolled relatively to the hidden previous items.
     * @param event The keyboard event.
     */
    onKeypressHandler(offset: number, event: KeyboardEvent): void;
    /**
     * Checks if navigation buttons should be visible depending on the amount of items
     * and current pagination offset.
     */
    private _setNavigationButtons;
    /**
     * Calculate how many items are out of the viewport.
     * @param itemsToDisplay Array of html elements that needs to be shown.
     * @param containerWidth Width of the parent container to calculate amount of items possible to fit.
     */
    private _setNextItemsCount;
    /**
     * @hidden
     * Performs scrolling to the defined element based on the offset argument.
     * @param offset How much items needs to be scrolled relatively to the hidden previous items.
     */
    private _paginate;
    /**
     * @hidden
     * Calculates total width of previously shown items.
     * @returns {Number} total width of previously shown items.
     */
    private _getPreviousItemsWidth;
    /** @hidden */
    private _disableFocusableItems;
    /** @hidden */
    private _setFocusableVisibleItems;
    /** @hidden */
    private _getPreviousItemsCount;
    static ɵfac: i0.ɵɵFactoryDeclaration<MicroProcessFlowComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MicroProcessFlowComponent, "fd-micro-process-flow", never, { "independentSteps": { "alias": "independentSteps"; "required": false; }; "transitionSpeed": { "alias": "transitionSpeed"; "required": false; }; "transitionTimingFunction": { "alias": "transitionTimingFunction"; "required": false; }; }, {}, ["items", "focusableItems"], ["fd-micro-process-flow-item"], true, never>;
}

declare class MicroProcessFlowIntermediaryItemDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<MicroProcessFlowIntermediaryItemDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MicroProcessFlowIntermediaryItemDirective, "[fdMicroProcessFlowIntermediaryItem], [fd-micro-process-flow-intermediary-item]", never, {}, {}, never, never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class MicroProcessFlowModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<MicroProcessFlowModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<MicroProcessFlowModule, never, [typeof MicroProcessFlowComponent, typeof MicroProcessFlowItemComponent, typeof MicroProcessFlowIconComponent, typeof MicroProcessFlowIntermediaryItemDirective, typeof MicroProcessFlowFocusableItemDirective], [typeof MicroProcessFlowComponent, typeof MicroProcessFlowItemComponent, typeof MicroProcessFlowIconComponent, typeof MicroProcessFlowIntermediaryItemDirective, typeof MicroProcessFlowFocusableItemDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<MicroProcessFlowModule>;
}

export { MICRO_PROCESS_FLOW, MicroProcessFlowComponent, MicroProcessFlowFocusableItemDirective, MicroProcessFlowIconComponent, MicroProcessFlowIntermediaryItemDirective, MicroProcessFlowItemComponent, MicroProcessFlowModule };
export type { MicroProcessFlowComponentInterface, MicroProcessFlowItemType };
