import * as i0 from '@angular/core';
import { InjectionToken, InputSignal, ElementRef, OnInit, OnChanges, OnDestroy, AfterContentInit, EventEmitter, TemplateRef, AfterViewInit, QueryList, ChangeDetectorRef } from '@angular/core';
import { KeyboardSupportItemInterface, CssClassBuilder, Nullable, ColorAccent, FocusEscapeDirection, KeyboardSupportService } from '@fundamental-ngx/cdk/utils';
import * as i35 from '@fundamental-ngx/core/content-density';
import { ContentDensityObserver } from '@fundamental-ngx/core/content-density';
import { ObjectStatus } from '@fundamental-ngx/core/object-status';
import { NumberInput } from '@angular/cdk/coercion';
import { Subject } from 'rxjs';
import * as _fundamental_ngx_core_card from '@fundamental-ngx/core/card';
import { HasElementRef } from '@fundamental-ngx/cdk';

interface FdCardMainHeaderComponent {
    interactive: InputSignal<boolean>;
}
declare const FD_CARD: InjectionToken<unknown>;
declare const FD_CARD_MAIN_HEADER: InjectionToken<FdCardMainHeaderComponent>;
declare const FD_CARD_TITLE: InjectionToken<unknown>;
declare const FD_CARD_SUBTITLE: InjectionToken<unknown>;
declare const FD_CARD_SECOND_SUBTITLE: InjectionToken<unknown>;
declare const FD_CARD_COUNTER: InjectionToken<unknown>;
declare const FD_CARD_HEADER_ACTION: InjectionToken<unknown>;
declare const FD_CARD_KPI_HEADER: InjectionToken<unknown>;
declare const FD_CARD_MEDIA_HEADING: InjectionToken<unknown>;

declare abstract class CardFocusItem<T = any> implements KeyboardSupportItemInterface {
    /**
     * Tab index attribute
     */
    readonly tabindex: i0.InputSignalWithTransform<number | undefined, NumberInput>;
    /**
     * Value of the list item.
     */
    readonly value: i0.InputSignal<T | undefined>;
    /**
     * @hidden
     * Implementation of KeyboardSupportItemInterface
     */
    readonly keyDown: i0.OutputEmitterRef<KeyboardEvent>;
    /** @hidden */
    readonly elementRef: ElementRef;
    /** @hidden */
    readonly _focused$: Subject<{
        focusedWithin: boolean;
    }>;
    /** @hidden */
    readonly _clicked$: Subject<MouseEvent>;
    /** @hidden */
    protected _isFirstItem$: i0.WritableSignal<boolean>;
    /** @hidden */
    protected _normalizedTabIndex$: i0.Signal<number>;
    /**
     * Get the current tab index.
     * Returns the internal tab index which may have been modified programmatically.
     * This getter is a replacement for directly binding to the `tabindex` input, which may not reflect the actual tab index if it was left unset and defaulted to 0 for the first item.
     */
    getTabIndex(): number;
    /** @hidden */
    click(): void;
    /** @hidden */
    focus(): void;
    /** @hidden */
    setIsFirst(value: boolean): void;
    /** @hidden */
    protected onFocus(event: FocusEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardFocusItem<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CardFocusItem<any>, never, never, { "tabindex": { "alias": "tabindex"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "keyDown": "keyDown"; }, never, never, true, never>;
}

type CardType = 'standard' | 'component' | 'analytical' | 'list' | 'table' | 'object' | 'quickView' | 'linkList' | 'banner';

declare class CardTitleDirective implements OnInit, CssClassBuilder {
    readonly elementRef: ElementRef<HTMLElement>;
    /** Card title id, it has some default value if not set,  */
    id: i0.InputSignal<string>;
    /** @hidden */
    class: string;
    /** @hidden */
    constructor(elementRef: ElementRef<HTMLElement>);
    /** @hidden */
    buildComponentCssClass(): string[];
    /** @hidden */
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardTitleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CardTitleDirective, "[fd-card-title]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class CardMediaHeadingDirective {
    /** Card title id, it has some default value if not set,  */
    id: i0.InputSignal<string>;
    /**
     * Heading level
     * Available values: number from 1 to 6
     */
    level: i0.InputSignal<Nullable<number>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardMediaHeadingDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CardMediaHeadingDirective, "[fd-card-media-heading]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "level": { "alias": "level"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class CardComponent<T = any> extends CardFocusItem<T> implements OnChanges, OnInit, CssClassBuilder, OnDestroy {
    readonly elementRef: ElementRef<HTMLElement>;
    readonly _contentDensityObserver: ContentDensityObserver;
    /** @hidden */
    cardTitle: i0.Signal<CardTitleDirective | undefined>;
    /** @hidden */
    cardMediaHeading: i0.Signal<CardMediaHeadingDirective | undefined>;
    /**
     * text for the card badge
     */
    badge: i0.InputSignal<Nullable<string>>;
    /**
     * icon/glyph for the card badge
     */
    badgeIcon: i0.InputSignal<Nullable<string>>;
    /**
     * Indication color for the card badge
     * Possible values: integers from 1 to 10
     */
    badgeColor: i0.InputSignal<Nullable<ColorAccent>>;
    /**
     * Whether to use secondary set of indication colors for the card badge
     * Default value: false
     */
    badgeColorSecondary: i0.InputSignal<boolean>;
    /**
     * Color status for the card badge
     * Possible values: 'negative' | 'critical' | 'positive' | 'informative' | 'neutral'
     * Default value: null
     */
    badgeStatus: i0.InputSignal<Nullable<ObjectStatus>>;
    /**
     * aria-label for the card badge
     * Default value: null
     */
    badgeAriaLabel: i0.InputSignal<Nullable<string>>;
    /**
     * text for the card second badge
     */
    secondBadge: i0.InputSignal<Nullable<string>>;
    /**
     * icon/glyph for the card second badge
     */
    secondBadgeIcon: i0.InputSignal<Nullable<string>>;
    /**
     * Indication color for the card second badge
     * Possible values: integers from 1 to 10
     */
    secondBadgeColor: i0.InputSignal<Nullable<ColorAccent>>;
    /**
     * Whether to use secondary set of indication colors for the card second badge
     * Default value: false
     */
    secondBadgeColorSecondary: i0.InputSignal<boolean>;
    /**
     * Color status for the card second badge
     * Possible values: 'negative' | 'critical' | 'positive' | 'informative' | 'neutral'
     * Default value: null
     */
    secondBadgeStatus: i0.InputSignal<Nullable<ObjectStatus>>;
    /**
     * aria-label for the card second badge
     * Default value: null
     */
    secondBadgeAriaLabel: i0.InputSignal<Nullable<string>>;
    /**
     * whether the card is in loading state
     * default: false
     */
    isLoading: i0.InputSignal<boolean>;
    /**
     * set the Caard type
     * options: 'object' | 'standard' | 'component' | 'analytical' | 'list' | 'table' | 'quickView' | 'linkList' | 'banner'
     * default: 'standard'
     *
     */
    cardType: i0.InputSignal<CardType>;
    /**
     * card id
     * if not set, a default value is provided
     */
    id: i0.InputSignal<string>;
    /**
     * card aria-roledescription
     * default: 'Card'
     */
    ariaRoledescription: i0.InputSignal<string>;
    /**
     * card aria-description
     * default: 'Activate for action or navigation'
     */
    ariaDescription: i0.InputSignal<string>;
    /**
     * card aria-label
     * used when there's no title describing the card
     */
    ariaLabel: i0.InputSignal<Nullable<string>>;
    /**
     * card role
     * default: 'region'
     */
    role: i0.InputSignal<string>;
    /**
     * whether the card is interactive
     * default: false
     */
    interactive: i0.InputSignal<boolean>;
    /**
     * whether the card is selected
     * default: false
     */
    selected: i0.InputSignal<boolean>;
    /**
     * value for aria-posinset
     */
    ariaPosinset: i0.ModelSignal<Nullable<number>>;
    /**
     * value for aria-setsize
     */
    ariaSetsize: i0.ModelSignal<Nullable<number>>;
    /**
     * @hidden
     * Implementation of KeyboardSupportItemInterface
     */
    readonly keyDown: i0.OutputEmitterRef<KeyboardEvent>;
    /** @hidden */
    class: string;
    /** @hidden */
    private _subscriptions;
    /** @hidden */
    constructor(elementRef: ElementRef<HTMLElement>, _contentDensityObserver: ContentDensityObserver);
    /** @hidden */
    keydownHandler(event: KeyboardEvent): void;
    /** @hidden */
    buildComponentCssClass(): string[];
    /** @hidden */
    ngOnChanges(): void;
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardComponent<any>, "fd-card", never, { "badge": { "alias": "badge"; "required": false; "isSignal": true; }; "badgeIcon": { "alias": "badgeIcon"; "required": false; "isSignal": true; }; "badgeColor": { "alias": "badgeColor"; "required": false; "isSignal": true; }; "badgeColorSecondary": { "alias": "badgeColorSecondary"; "required": false; "isSignal": true; }; "badgeStatus": { "alias": "badgeStatus"; "required": false; "isSignal": true; }; "badgeAriaLabel": { "alias": "badgeAriaLabel"; "required": false; "isSignal": true; }; "secondBadge": { "alias": "secondBadge"; "required": false; "isSignal": true; }; "secondBadgeIcon": { "alias": "secondBadgeIcon"; "required": false; "isSignal": true; }; "secondBadgeColor": { "alias": "secondBadgeColor"; "required": false; "isSignal": true; }; "secondBadgeColorSecondary": { "alias": "secondBadgeColorSecondary"; "required": false; "isSignal": true; }; "secondBadgeStatus": { "alias": "secondBadgeStatus"; "required": false; "isSignal": true; }; "secondBadgeAriaLabel": { "alias": "secondBadgeAriaLabel"; "required": false; "isSignal": true; }; "isLoading": { "alias": "isLoading"; "required": false; "isSignal": true; }; "cardType": { "alias": "cardType"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "ariaRoledescription": { "alias": "ariaRoledescription"; "required": false; "isSignal": true; }; "ariaDescription": { "alias": "ariaDescription"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "ariaPosinset": { "alias": "ariaPosinset"; "required": false; "isSignal": true; }; "ariaSetsize": { "alias": "ariaSetsize"; "required": false; "isSignal": true; }; }, { "ariaPosinset": "ariaPosinsetChange"; "ariaSetsize": "ariaSetsizeChange"; "keyDown": "keyDown"; }, ["cardTitle", "cardMediaHeading"], ["*", "fd-card-footer", "fd-card-loader"], true, never>;
}

declare class CardListDirective implements OnInit, AfterContentInit, OnDestroy {
    private _keyboardSupportService;
    /**
     * an event thrown, when focus escapes the list
     */
    focusEscapeList: EventEmitter<FocusEscapeDirection>;
    /** @hidden */
    private _focusItems;
    /**
     * whether internal keyboard support should be enabled.
     * default: true
     */
    keyboardSupport: i0.InputSignal<boolean>;
    /**
     * aria-roledescription for the Card list
     * default: 'Card Container'
     */
    ariaRoleDescription: i0.InputSignal<string>;
    /**
     * aria-label for the Card list
     */
    ariaLabel: i0.InputSignal<Nullable<string>>;
    /** @hidden */
    private _cards;
    /**
     * an RxJS Subject that will kill the data stream upon component’s destruction
     * for unsubscribing
     */
    private readonly _destroyRef;
    /**
     * an RxJS Subject that will kill the data stream upon queryList changes
     * for unsubscribing
     */
    private readonly _onRefresh$;
    /** @hidden */
    constructor(_keyboardSupportService: KeyboardSupportService<CardFocusItem>);
    /** @hidden */
    keyDownHandler(event: KeyboardEvent): void;
    /** Set fake focus on element with passed index */
    setItemActive(index: number, updateOnly?: boolean): void;
    /**
     * @returns Currently active list item.
     */
    getActiveItem(): CardFocusItem | null;
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    ngAfterContentInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** @hidden */
    private _listenOnQueryChange;
    /** @hidden */
    private _listenOnItemsClick;
    /** @hidden */
    private _listenOnListFocusEscape;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardListDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CardListDirective, "[fd-card-list]", never, { "keyboardSupport": { "alias": "keyboardSupport"; "required": false; "isSignal": true; }; "ariaRoleDescription": { "alias": "ariaRoleDescription"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "focusEscapeList": "focusEscapeList"; }, ["_cards", "_focusItems"], never, true, never>;
}

declare class CardHeaderComponent {
    /**
     * aria-roledescription for the container
     * default: 'Card Header'
     */
    ariaRoleDescription: i0.InputSignal<string>;
    /** @hidden */
    readonly _cardMainHeader: i0.Signal<_fundamental_ngx_core_card.FdCardMainHeaderComponent | undefined>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardHeaderComponent, "fd-card-header", never, { "ariaRoleDescription": { "alias": "ariaRoleDescription"; "required": false; "isSignal": true; }; }, {}, ["_cardMainHeader"], ["*"], true, never>;
}

declare class CardMainHeaderComponent {
    /**
     * whether the main header is interactive
     * default: false
     */
    interactive: i0.InputSignal<boolean>;
    /**
     * Text for the title, aria-label and aria-description
     * of the main container with role button
     * when the card main header is interactive
     * default: "Activate for action/navigation"
     */
    title: i0.InputSignal<string>;
    /** @hidden */
    readonly _cardTitle: i0.Signal<unknown>;
    /** @hidden */
    readonly _cardSubtitle: i0.Signal<unknown>;
    /** @hidden */
    readonly _cardCounter: i0.Signal<unknown>;
    /** @hidden */
    readonly _cardHeaderAction: i0.Signal<unknown>;
    /** @hidden */
    readonly _cardKpiHeader: i0.Signal<unknown>;
    /** @hidden */
    readonly _cardSecondSubtitle: i0.Signal<unknown>;
    /** @hidden */
    readonly _cardAvatar: i0.Signal<unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardMainHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardMainHeaderComponent, "fd-card-main-header", never, { "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; }, {}, ["_cardTitle", "_cardSubtitle", "_cardCounter", "_cardHeaderAction", "_cardKpiHeader", "_cardSecondSubtitle", "_cardAvatar"], ["fd-avatar", "[fd-card-title]", "[fd-card-subtitle]", "fd-card-kpi-header", "[fd-card-second-subtitle]", "[fd-card-header-action]", "[fd-card-counter]", "*"], true, never>;
}

declare class CardHeaderActionDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<CardHeaderActionDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CardHeaderActionDirective, "[fd-card-header-action]", never, {}, {}, never, never, true, never>;
}

declare class CardExtendedHeaderComponent {
    /**
     * aria-roledescription for the container
     * default: 'Extended content'
     */
    ariaRoleDescription: i0.InputSignal<string>;
    /**
     * vertical alignment of the elements inside the header columns
     * possible options: 'top' | 'bottom' | null
     * default: null (middle)
     */
    align: i0.InputSignal<"top" | "bottom" | null>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardExtendedHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardExtendedHeaderComponent, "fd-card-extended-header", never, { "ariaRoleDescription": { "alias": "ariaRoleDescription"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class CardNumericHeaderComponent {
    /**
     * aria-roledescription for the container
     * default: 'Numeric content'
     */
    ariaRoleDescription: i0.InputSignal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardNumericHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardNumericHeaderComponent, "fd-card-numeric-header", never, { "ariaRoleDescription": { "alias": "ariaRoleDescription"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class CardHeaderRowDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<CardHeaderRowDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CardHeaderRowDirective, "[fd-card-header-row]", never, {}, {}, never, never, true, never>;
}

declare class CardHeaderColumnDirective {
    /**
     * horizontal alignment of the elements inside the column
     * possible options: 'left' | 'right'
     * default: 'left'
     */
    align: i0.InputSignal<"left" | "right">;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardHeaderColumnDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CardHeaderColumnDirective, "[fd-card-header-column]", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class CardNumericContainerComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<CardNumericContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardNumericContainerComponent, "fd-card-numeric-container", never, {}, {}, never, ["[fd-card-kpi-value]", "[fd-card-kpi-scale-icon]", "[fd-card-kpi-scale-text]"], true, never>;
}

declare class CardIndicatorComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<CardIndicatorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardIndicatorComponent, "fd-card-indicator", never, {}, {}, never, ["[fd-card-indicator-title]", "[fd-card-indicator-value]"], true, never>;
}

declare class CardIndicatorTitleDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<CardIndicatorTitleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CardIndicatorTitleDirective, "[fd-card-indicator-title]", never, {}, {}, never, never, true, never>;
}

declare class CardIndicatorValueDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<CardIndicatorValueDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CardIndicatorValueDirective, "[fd-card-indicator-value]", never, {}, {}, never, never, true, never>;
}

declare class CardContentComponent implements OnInit, CssClassBuilder {
    readonly elementRef: ElementRef<HTMLElement>;
    /** @hidden */
    class: string;
    /** @hidden */
    constructor(elementRef: ElementRef<HTMLElement>);
    /** @hidden */
    buildComponentCssClass(): string[];
    /** @hidden */
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardContentComponent, "fd-card-content", never, {}, {}, never, ["*"], true, never>;
}

declare class CardSubtitleDirective implements OnInit, CssClassBuilder {
    readonly elementRef: ElementRef<HTMLElement>;
    /** @hidden */
    class: string;
    /** @hidden */
    constructor(elementRef: ElementRef<HTMLElement>);
    /** @hidden */
    buildComponentCssClass(): string[];
    /** @hidden */
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardSubtitleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CardSubtitleDirective, "[fd-card-subtitle]", never, {}, {}, never, never, true, never>;
}

declare class CardSecondSubtitleDirective implements OnInit, CssClassBuilder {
    readonly elementRef: ElementRef<HTMLElement>;
    /** @hidden */
    class: string;
    /** @hidden */
    constructor(elementRef: ElementRef<HTMLElement>);
    /** @hidden */
    buildComponentCssClass(): string[];
    /** @hidden */
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardSecondSubtitleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CardSecondSubtitleDirective, "[fd-card-second-subtitle]", never, {}, {}, never, never, true, never>;
}

declare class CardCounterDirective implements HasElementRef {
    readonly elementRef: ElementRef<HTMLElement>;
    /**
     * the status represented by the Object Status.
     * can be one of the following: 'negative' | 'critical' | 'positive' | 'informative' | 'neutral'
     */
    readonly statusInput: i0.InputSignal<ObjectStatus>;
    /** @hidden */
    protected readonly _cssClass: i0.Signal<string>;
    /** @hidden */
    constructor(elementRef: ElementRef<HTMLElement>);
    static ɵfac: i0.ɵɵFactoryDeclaration<CardCounterDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CardCounterDirective, "[fd-card-counter]", never, { "statusInput": { "alias": "statusInput"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class CardLoaderComponent implements OnInit, CssClassBuilder {
    readonly elementRef: ElementRef<HTMLElement>;
    /** @hidden */
    class: string;
    /** @hidden */
    constructor(elementRef: ElementRef<HTMLElement>);
    /** @hidden */
    buildComponentCssClass(): string[];
    /** @hidden */
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardLoaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardLoaderComponent, "fd-card-loader", never, {}, {}, never, ["*"], true, never>;
}

declare class CardKpiHeaderComponent implements OnInit, CssClassBuilder {
    readonly elementRef: ElementRef<HTMLElement>;
    /** @hidden */
    class: string;
    /** @hidden */
    constructor(elementRef: ElementRef<HTMLElement>);
    /** @hidden */
    buildComponentCssClass(): string[];
    /** @hidden */
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardKpiHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardKpiHeaderComponent, "fd-card-kpi-header", never, {}, {}, never, ["[fd-card-kpi-value]", "[fd-card-kpi-scale-icon]", "[fd-card-kpi-scale-text]", "[fd-card-kpi-analytics]"], true, never>;
}

type KpiStatus = 'positive' | 'negative' | 'critical' | 'informative';
declare class CardKpiValueDirective implements OnInit, CssClassBuilder {
    readonly elementRef: ElementRef<HTMLElement>;
    /** Set type of KPI value. eg: 'positive', 'negative', 'critical', 'informative' */
    status: KpiStatus;
    /** @hidden */
    class: string;
    /** @hidden */
    constructor(elementRef: ElementRef<HTMLElement>);
    /** @hidden */
    buildComponentCssClass(): string[];
    /** @hidden */
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardKpiValueDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CardKpiValueDirective, "[fd-card-kpi-value]", never, { "status": { "alias": "status"; "required": false; }; }, {}, never, never, true, never>;
}

declare class CardKpiScaleIconDirective implements OnInit, CssClassBuilder {
    readonly elementRef: ElementRef<HTMLElement>;
    /** @hidden */
    class: string;
    /** @hidden */
    constructor(elementRef: ElementRef<HTMLElement>);
    /** @hidden */
    buildComponentCssClass(): string[];
    /** @hidden */
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardKpiScaleIconDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CardKpiScaleIconDirective, "[fd-card-kpi-scale-icon]", never, {}, {}, never, never, true, never>;
}

declare class CardKpiScaleTextDirective implements OnInit, CssClassBuilder {
    readonly elementRef: ElementRef<HTMLElement>;
    /** @hidden */
    class: string;
    /** @hidden */
    constructor(elementRef: ElementRef<HTMLElement>);
    /** @hidden */
    buildComponentCssClass(): string[];
    /** @hidden */
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardKpiScaleTextDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CardKpiScaleTextDirective, "[fd-card-kpi-scale-text]", never, {}, {}, never, never, true, never>;
}

declare class CardKpiAnalyticsDirective implements OnInit, CssClassBuilder {
    readonly elementRef: ElementRef<HTMLElement>;
    /** @hidden */
    class: string;
    /** @hidden */
    constructor(elementRef: ElementRef<HTMLElement>);
    /** @hidden */
    buildComponentCssClass(): string[];
    /** @hidden */
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardKpiAnalyticsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CardKpiAnalyticsDirective, "[fd-card-kpi-analytics]", never, {}, {}, never, never, true, never>;
}

declare class CardKpiAnalyticsLabelDirective implements OnInit, CssClassBuilder {
    readonly elementRef: ElementRef<HTMLElement>;
    /** @hidden */
    class: string;
    /** @hidden */
    constructor(elementRef: ElementRef<HTMLElement>);
    /** @hidden */
    buildComponentCssClass(): string[];
    /** @hidden */
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardKpiAnalyticsLabelDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CardKpiAnalyticsLabelDirective, "[fd-card-kpi-analytics-label]", never, {}, {}, never, never, true, never>;
}

declare class CardKpiAnalyticsContentDirective implements OnInit, CssClassBuilder {
    readonly elementRef: ElementRef<HTMLElement>;
    /** @hidden */
    class: string;
    /** @hidden */
    constructor(elementRef: ElementRef<HTMLElement>);
    /** @hidden */
    buildComponentCssClass(): string[];
    /** @hidden */
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardKpiAnalyticsContentDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CardKpiAnalyticsContentDirective, "[fd-card-kpi-analytics-content]", never, {}, {}, never, never, true, never>;
}

declare class CardFooterActionItemDirective {
    readonly templateRef: TemplateRef<void>;
    /** @hidden */
    constructor(templateRef: TemplateRef<void>);
    static ɵfac: i0.ɵɵFactoryDeclaration<CardFooterActionItemDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CardFooterActionItemDirective, "[fdCardFooterActionItem]", never, {}, {}, never, never, true, never>;
}

declare class CardFooterComponent implements AfterViewInit {
    private _changeDetectorRef;
    /** @hidden */
    cardActionItems: QueryList<CardFooterActionItemDirective>;
    /** @hidden */
    actionItems: CardFooterActionItemDirective[];
    /** @hidden */
    private _destroyed$;
    /** @hidden */
    constructor(_changeDetectorRef: ChangeDetectorRef);
    /** @hidden */
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardFooterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardFooterComponent, "fd-card-footer", never, {}, {}, ["cardActionItems"], ["*"], true, never>;
}

declare class CardMediaComponent {
    /** @hidden */
    get cssClass(): string[];
    /**
     * aria-roledescription for the container
     * default: 'Card Media Block'
     */
    ariaRoleDescription: i0.InputSignal<string>;
    /**
     * Whether the media container comes with a 1rem padding
     * Default value: false
     */
    hasPadding: i0.InputSignalWithTransform<boolean, unknown>;
    /**
     * Shell Category Colors
     * Available values: number from 1 to 16
     */
    shellColor: i0.InputSignal<Nullable<number>>;
    /**
     * Legend Background Colors
     * Available values: number from 1 to 20
     */
    legendColor: i0.InputSignal<Nullable<number>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardMediaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardMediaComponent, "fd-card-media", never, { "ariaRoleDescription": { "alias": "ariaRoleDescription"; "required": false; "isSignal": true; }; "hasPadding": { "alias": "hasPadding"; "required": false; "isSignal": true; }; "shellColor": { "alias": "shellColor"; "required": false; "isSignal": true; }; "legendColor": { "alias": "legendColor"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class CardMediaImageDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<CardMediaImageDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CardMediaImageDirective, "[fd-card-media-image]", never, {}, {}, never, never, true, never>;
}

declare class CardMediaImageContainerDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<CardMediaImageContainerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CardMediaImageContainerDirective, "[fd-card-media-image-container]", never, {}, {}, never, never, true, never>;
}

declare class CardMediaContentContainerDirective {
    /** @hidden */
    get cssClass(): string[];
    /**
     * Whether the media content container is an overlay
     * Default value: false
     */
    isOverlay: i0.InputSignalWithTransform<boolean, unknown>;
    /**
     * Shell Category Colors
     * Available values: number from 1 to 16
     */
    shellColor: i0.InputSignal<Nullable<number>>;
    /**
     * Legend Background Colors
     * Available values: number from 1 to 20
     */
    legendColor: i0.InputSignal<Nullable<number>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardMediaContentContainerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CardMediaContentContainerDirective, "[fd-card-media-content-container]", never, { "isOverlay": { "alias": "isOverlay"; "required": false; "isSignal": true; }; "shellColor": { "alias": "shellColor"; "required": false; "isSignal": true; }; "legendColor": { "alias": "legendColor"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class CardMediaTextDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<CardMediaTextDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CardMediaTextDirective, "[fd-card-media-text]", never, {}, {}, never, never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class CardModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CardModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CardModule, never, [typeof CardComponent, typeof CardListDirective, typeof CardHeaderComponent, typeof CardMainHeaderComponent, typeof CardHeaderActionDirective, typeof CardExtendedHeaderComponent, typeof CardNumericHeaderComponent, typeof CardHeaderRowDirective, typeof CardHeaderColumnDirective, typeof CardNumericContainerComponent, typeof CardIndicatorComponent, typeof CardIndicatorTitleDirective, typeof CardIndicatorValueDirective, typeof CardContentComponent, typeof CardTitleDirective, typeof CardSubtitleDirective, typeof CardSecondSubtitleDirective, typeof CardCounterDirective, typeof CardLoaderComponent, typeof CardKpiHeaderComponent, typeof CardKpiValueDirective, typeof CardKpiScaleIconDirective, typeof CardKpiScaleTextDirective, typeof CardKpiAnalyticsDirective, typeof CardKpiAnalyticsLabelDirective, typeof CardKpiAnalyticsContentDirective, typeof CardFooterComponent, typeof CardFooterActionItemDirective, typeof CardMediaComponent, typeof CardMediaImageDirective, typeof CardMediaImageContainerDirective, typeof CardMediaContentContainerDirective, typeof CardMediaHeadingDirective, typeof CardMediaTextDirective, typeof i35.ContentDensityModule], [typeof CardComponent, typeof CardListDirective, typeof CardHeaderComponent, typeof CardMainHeaderComponent, typeof CardHeaderActionDirective, typeof CardExtendedHeaderComponent, typeof CardNumericHeaderComponent, typeof CardHeaderRowDirective, typeof CardHeaderColumnDirective, typeof CardNumericContainerComponent, typeof CardIndicatorComponent, typeof CardIndicatorTitleDirective, typeof CardIndicatorValueDirective, typeof CardContentComponent, typeof CardTitleDirective, typeof CardSubtitleDirective, typeof CardSecondSubtitleDirective, typeof CardCounterDirective, typeof CardLoaderComponent, typeof CardKpiHeaderComponent, typeof CardKpiValueDirective, typeof CardKpiScaleIconDirective, typeof CardKpiScaleTextDirective, typeof CardKpiAnalyticsDirective, typeof CardKpiAnalyticsLabelDirective, typeof CardKpiAnalyticsContentDirective, typeof CardFooterComponent, typeof CardFooterActionItemDirective, typeof CardMediaComponent, typeof CardMediaImageDirective, typeof CardMediaImageContainerDirective, typeof CardMediaContentContainerDirective, typeof CardMediaHeadingDirective, typeof CardMediaTextDirective, typeof i35.ContentDensityModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CardModule>;
}

export { CardComponent, CardContentComponent, CardCounterDirective, CardExtendedHeaderComponent, CardFooterActionItemDirective, CardFooterComponent, CardHeaderActionDirective, CardHeaderColumnDirective, CardHeaderComponent, CardHeaderRowDirective, CardIndicatorComponent, CardIndicatorTitleDirective, CardIndicatorValueDirective, CardKpiAnalyticsContentDirective, CardKpiAnalyticsDirective, CardKpiAnalyticsLabelDirective, CardKpiHeaderComponent, CardKpiScaleIconDirective, CardKpiScaleTextDirective, CardKpiValueDirective, CardListDirective, CardLoaderComponent, CardMainHeaderComponent, CardMediaComponent, CardMediaContentContainerDirective, CardMediaHeadingDirective, CardMediaImageContainerDirective, CardMediaImageDirective, CardMediaTextDirective, CardModule, CardNumericContainerComponent, CardNumericHeaderComponent, CardSecondSubtitleDirective, CardSubtitleDirective, CardTitleDirective, FD_CARD, FD_CARD_COUNTER, FD_CARD_HEADER_ACTION, FD_CARD_KPI_HEADER, FD_CARD_MAIN_HEADER, FD_CARD_MEDIA_HEADING, FD_CARD_SECOND_SUBTITLE, FD_CARD_SUBTITLE, FD_CARD_TITLE };
export type { CardType, FdCardMainHeaderComponent };
