import * as i0 from '@angular/core';
import { ElementRef } from '@angular/core';
import { HasElementRef } from '@fundamental-ngx/cdk/utils';
import { IconFont } from '@fundamental-ngx/core/icon';

type NumericContentState = 'negative' | 'critical' | 'positive' | 'informative' | 'neutral';
type NumericContentSize = 's' | 'm' | 'l';
declare class NumericContentDirective implements HasElementRef {
    /** Size of the numeric content. Options are 's', 'm', or 'l'. */
    readonly size: i0.InputSignal<NumericContentSize | null | undefined>;
    /** @hidden */
    readonly elementRef: ElementRef<any>;
    /** @hidden */
    protected readonly cssClass: i0.Signal<string>;
    /** @hidden */
    private readonly _isSmallTile;
    static ɵfac: i0.ɵɵFactoryDeclaration<NumericContentDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NumericContentDirective, "[fd-numeric-content]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare class NumericContentLaunchIconContainerDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<NumericContentLaunchIconContainerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NumericContentLaunchIconContainerDirective, "[fd-numeric-content-launch-icon-container]", never, {}, {}, never, never, true, never>;
}
declare class NumericContentLaunchIconDirective implements HasElementRef {
    /** Glyph (icon) to display. */
    readonly glyph: i0.InputSignal<string | undefined>;
    /** Glyph font family. */
    readonly glyphFont: i0.InputSignal<IconFont>;
    /** Aria label for accessibility. */
    readonly ariaLabel: i0.InputSignal<string | null>;
    /** @hidden */
    readonly elementRef: ElementRef<any>;
    /** @hidden */
    protected readonly cssClass: i0.Signal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NumericContentLaunchIconDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NumericContentLaunchIconDirective, "[fd-numeric-content-launch-icon]", never, { "glyph": { "alias": "glyph"; "required": false; "isSignal": true; }; "glyphFont": { "alias": "glyphFont"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare class NumericContentKpiContainerDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<NumericContentKpiContainerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NumericContentKpiContainerDirective, "[fd-numeric-content-kpi-container]", never, {}, {}, never, never, true, never>;
}
declare class NumericContentKpiDirective implements HasElementRef {
    /** State of the KPI. Options are 'neutral' (default), 'positive', 'negative', 'critical', or 'informative'. */
    readonly state: i0.InputSignal<NumericContentState | null | undefined>;
    /** Glyph (icon) to display. */
    readonly glyph: i0.InputSignal<string | undefined>;
    /** @hidden */
    readonly elementRef: ElementRef<any>;
    /** @hidden */
    protected readonly cssClass: i0.Signal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NumericContentKpiDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NumericContentKpiDirective, "[fd-numeric-content-kpi]", never, { "state": { "alias": "state"; "required": false; "isSignal": true; }; "glyph": { "alias": "glyph"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare class NumericContentScaleContainerDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<NumericContentScaleContainerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NumericContentScaleContainerDirective, "[fd-numeric-content-scale-container]", never, {}, {}, never, never, true, never>;
}
declare class NumericContentScaleArrowDirective implements HasElementRef {
    /** Glyph (icon) to display. */
    readonly glyph: i0.InputSignal<string | undefined>;
    /** Glyph font family. */
    readonly glyphFont: i0.InputSignal<IconFont>;
    /** Aria label for accessibility. */
    readonly ariaLabel: i0.InputSignal<string | null>;
    /** @hidden */
    readonly elementRef: ElementRef<any>;
    /** @hidden */
    protected readonly cssClass: i0.Signal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NumericContentScaleArrowDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NumericContentScaleArrowDirective, "[fd-numeric-content-scale-arrow]", never, { "glyph": { "alias": "glyph"; "required": false; "isSignal": true; }; "glyphFont": { "alias": "glyphFont"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare class NumericContentScaleDirective implements HasElementRef {
    /** State of the scale. Options are 'neutral' (default), 'positive', 'negative', 'critical', or 'informative'. */
    readonly state: i0.InputSignal<NumericContentState | null | undefined>;
    /** @hidden */
    readonly elementRef: ElementRef<any>;
    /** @hidden */
    protected readonly cssClass: i0.Signal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NumericContentScaleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NumericContentScaleDirective, "[fd-numeric-content-scale]", never, { "state": { "alias": "state"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare class NumericContentScaleTextDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<NumericContentScaleTextDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NumericContentScaleTextDirective, "[fd-numeric-content-scale-text]", never, {}, {}, never, never, true, never>;
}

declare class TileContentDirective {
    /** Divides the tile content in to two columns. */
    readonly twoColumn: i0.InputSignalWithTransform<boolean, unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TileContentDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TileContentDirective, "[fdTileContent], [fd-tile-content]", never, { "twoColumn": { "alias": "twoColumn"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare class TileContentTextDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<TileContentTextDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TileContentTextDirective, "[fdTileContentText], [fd-tile-content-text]", never, {}, {}, never, never, true, never>;
}
declare class TileFooterDirective {
    /** Divides the tile footer in to two columns. */
    readonly twoColumn: i0.InputSignalWithTransform<boolean, unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TileFooterDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TileFooterDirective, "[fdTileFooter], [fd-tile-footer]", never, { "twoColumn": { "alias": "twoColumn"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare class TileFooterTextDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<TileFooterTextDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TileFooterTextDirective, "[fdTileFooterText], [fd-tile-footer-text]", never, {}, {}, never, never, true, never>;
}
declare class TileHeaderDirective {
    /** Divides the tile header in to two columns. */
    readonly twoColumn: i0.InputSignalWithTransform<boolean, unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TileHeaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TileHeaderDirective, "[fdTileHeader], [fd-tile-header]", never, { "twoColumn": { "alias": "twoColumn"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare class TileHeaderContentDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<TileHeaderContentDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TileHeaderContentDirective, "[fdTileHeaderContent], [fd-tile-header-content]", never, {}, {}, never, never, true, never>;
}
declare class TileSectionDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<TileSectionDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TileSectionDirective, "[fdTileSection], [fd-tile-section]", never, {}, {}, never, never, true, never>;
}
declare class TileSubtitleDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<TileSubtitleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TileSubtitleDirective, "[fdTileTitle], [fd-tile-subtitle]", never, {}, {}, never, never, true, never>;
}
declare class TileTitleDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<TileTitleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TileTitleDirective, "[fdTileTitle], [fd-tile-title]", never, {}, {}, never, never, true, never>;
}
declare class TileTitleContainerDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<TileTitleContainerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TileTitleContainerDirective, "[fdTileTitleContainer], [fd-tile-title-container]", never, {}, {}, never, never, true, never>;
}
declare class TileRefreshDirective implements HasElementRef {
    /** Glyph (icon) to display. */
    readonly glyph: i0.InputSignal<string | undefined>;
    /** Glyph font family. */
    readonly glyphFont: i0.InputSignal<IconFont>;
    /** Aria label for accessibility. */
    readonly ariaLabel: i0.InputSignal<string>;
    /** @hidden */
    readonly elementRef: ElementRef<any>;
    /** @hidden */
    protected readonly cssClass: i0.Signal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TileRefreshDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TileRefreshDirective, "[fdTileRefresh], [fd-tile-refresh]", never, { "glyph": { "alias": "glyph"; "required": false; "isSignal": true; }; "glyphFont": { "alias": "glyphFont"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare class TileProfileImgDirective {
    /** Unique identifier for the tile. */
    readonly id: i0.InputSignal<string>;
    /** Aria label for accessibility. */
    readonly ariaLabel: i0.InputSignal<string | null | undefined>;
    /** Aria labelledby attribute referencing element(s) describing the tile. */
    readonly ariaLabelledby: i0.InputSignal<string | null | undefined>;
    /** Background image URL. */
    readonly backgroundImage: i0.InputSignal<string | null | undefined>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TileProfileImgDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TileProfileImgDirective, "[fdTileProfileImg], [fd-tile-profile-img]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "ariaLabelledby"; "required": false; "isSignal": true; }; "backgroundImage": { "alias": "backgroundImage"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare class TileLogoDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<TileLogoDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TileLogoDirective, "[fdTileLogo], [fd-tile-logo]", never, {}, {}, never, never, true, never>;
}
declare class TileToggleDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<TileToggleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TileToggleDirective, "[fdTileToggle], [fd-tile-toggle]", never, {}, {}, never, never, true, never>;
}
declare class TileContainerDirective {
    /** Whether the container uses list layout (applies on screens smaller than 450px). */
    readonly list: i0.InputSignalWithTransform<boolean, unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TileContainerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TileContainerDirective, "[fdTileContainer], [fd-tile-container]", never, { "list": { "alias": "list"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare class TileBackgroundImgDirective {
    /** Background image URL. */
    readonly backgroundImage: i0.InputSignal<string | null | undefined>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TileBackgroundImgDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TileBackgroundImgDirective, "[fdTileBackgroundImg], [fd-tile-background-img]", never, { "backgroundImage": { "alias": "backgroundImage"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare class TilePageIndicatorDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<TilePageIndicatorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TilePageIndicatorDirective, "[fdTilePageIndicator], [fd-tile-page-indicator]", never, {}, {}, never, never, true, never>;
}
declare class TileActionCloseDirective {
    /** @hidden */
    private readonly _elementRef;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<TileActionCloseDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TileActionCloseDirective, "[fdTileActionClose], [fd-tile-action-close]", never, {}, {}, never, never, true, never>;
}
declare class TileActionIndicatorDirective {
    /** @hidden */
    private readonly _elementRef;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<TileActionIndicatorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TileActionIndicatorDirective, "[fdTileActionIndicator], [fd-tile-action-indicator]", never, {}, {}, never, never, true, never>;
}
declare class TileActionContainerDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<TileActionContainerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TileActionContainerDirective, "[fdTileActionContainer], [fd-tile-action-container]", never, {}, {}, never, never, true, never>;
}

type TileType = null | 'kpi' | 'launch' | 'feed';
type TileSize = null | 's';
declare class TileComponent {
    /** Size modifier. Options are 's' or null (default). */
    readonly size: i0.InputSignal<TileSize | undefined>;
    /** Doubles the tile width. */
    readonly double: i0.InputSignalWithTransform<boolean, unknown>;
    /** Type of tile. Options are 'kpi', 'launch', 'feed', or null (default). */
    readonly type: i0.InputSignal<TileType | undefined>;
    /** Whether the tile is in action mode. */
    readonly action: i0.InputSignalWithTransform<boolean, unknown>;
    /** Whether tile is focusable and clickable. */
    readonly clickable: i0.InputSignalWithTransform<boolean, unknown>;
    /** The role for the tile. */
    readonly role: i0.InputSignal<string | null | undefined>;
    /** Aria-label for accessibility. */
    readonly ariaLabel: i0.InputSignal<string | null | undefined>;
    /** Aria-labelledby for accessibility. */
    readonly ariaLabelledby: i0.InputSignal<string | null | undefined>;
    /** Unique identifier for the Tile. */
    readonly id: i0.InputSignal<string | null | undefined>;
    /** Emitted when tile is clicked or activated via space/enter keys. */
    readonly tileClick: i0.OutputEmitterRef<void>;
    /**
     * @hidden
     * Computed tabindex - native links manage their own, custom elements use clickable
     */
    protected readonly tabindex: i0.Signal<0 | -1 | null>;
    /** @hidden Computed role - don't override native link semantics */
    protected readonly roleValue: i0.Signal<string | null>;
    /** @hidden */
    protected readonly cssClass: i0.Signal<string>;
    /** @hidden */
    private readonly _elementRef;
    /** @hidden */
    private readonly _isNativeLink;
    constructor();
    /** @hidden Handle click events */
    protected handleClick(): void;
    /** @hidden Handle keyboard activation for non-link tiles */
    protected handleKeyboard(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TileComponent, "fd-tile, [fd-tile]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "double": { "alias": "double"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "action": { "alias": "action"; "required": false; "isSignal": true; }; "clickable": { "alias": "clickable"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "ariaLabelledby"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, { "tileClick": "tileClick"; }, never, ["[fd-tile-action-close]", "[fd-tile-action-indicator]", "[fd-badge]", "[fd-tile-header]", "[fd-tile-header-content]", "[fd-tile-content]", "[fd-tile-footer]", "[fd-tile-action-container]", "*"], true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class TileModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TileModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TileModule, never, [typeof TileComponent, typeof TileHeaderDirective, typeof TileContentDirective, typeof TileFooterDirective, typeof TileTitleDirective, typeof TileSubtitleDirective, typeof TileSectionDirective, typeof TileRefreshDirective, typeof TileFooterTextDirective, typeof TileHeaderContentDirective, typeof TileProfileImgDirective, typeof TileLogoDirective, typeof TileContentTextDirective, typeof TileBackgroundImgDirective, typeof TileToggleDirective, typeof TileContainerDirective, typeof TilePageIndicatorDirective, typeof TileActionCloseDirective, typeof TileActionIndicatorDirective, typeof TileTitleContainerDirective, typeof TileActionContainerDirective, typeof NumericContentDirective, typeof NumericContentScaleArrowDirective, typeof NumericContentKpiContainerDirective, typeof NumericContentKpiDirective, typeof NumericContentLaunchIconContainerDirective, typeof NumericContentLaunchIconDirective, typeof NumericContentScaleContainerDirective, typeof NumericContentScaleDirective, typeof NumericContentScaleTextDirective], [typeof TileComponent, typeof TileHeaderDirective, typeof TileContentDirective, typeof TileFooterDirective, typeof TileTitleDirective, typeof TileSubtitleDirective, typeof TileSectionDirective, typeof TileRefreshDirective, typeof TileFooterTextDirective, typeof TileHeaderContentDirective, typeof TileProfileImgDirective, typeof TileLogoDirective, typeof TileContentTextDirective, typeof TileBackgroundImgDirective, typeof TileToggleDirective, typeof TileContainerDirective, typeof TilePageIndicatorDirective, typeof TileActionCloseDirective, typeof TileActionIndicatorDirective, typeof TileTitleContainerDirective, typeof TileActionContainerDirective, typeof NumericContentDirective, typeof NumericContentKpiContainerDirective, typeof NumericContentKpiDirective, typeof NumericContentLaunchIconContainerDirective, typeof NumericContentLaunchIconDirective, typeof NumericContentScaleArrowDirective, typeof NumericContentScaleContainerDirective, typeof NumericContentScaleDirective, typeof NumericContentScaleTextDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TileModule>;
}

export { NumericContentDirective, NumericContentKpiContainerDirective, NumericContentKpiDirective, NumericContentLaunchIconContainerDirective, NumericContentLaunchIconDirective, NumericContentScaleArrowDirective, NumericContentScaleContainerDirective, NumericContentScaleDirective, NumericContentScaleTextDirective, TileActionCloseDirective, TileActionContainerDirective, TileActionIndicatorDirective, TileBackgroundImgDirective, TileComponent, TileContainerDirective, TileContentDirective, TileContentTextDirective, TileFooterDirective, TileFooterTextDirective, TileHeaderContentDirective, TileHeaderDirective, TileLogoDirective, TileModule, TilePageIndicatorDirective, TileProfileImgDirective, TileRefreshDirective, TileSectionDirective, TileSubtitleDirective, TileTitleContainerDirective, TileTitleDirective, TileToggleDirective };
export type { NumericContentSize, NumericContentState };
