import * as _angular_core from '@angular/core';
import { InjectionToken, InputSignal, ElementRef, OnInit, AfterContentInit, OnDestroy, EventEmitter, TemplateRef, AfterViewInit, QueryList } from '@angular/core';
import { KeyboardSupportItemInterface, HasElementRef as HasElementRef$1, Nullable, ColorAccent, FocusEscapeDirection } 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 { HasElementRef } from '@fundamental-ngx/cdk';
import * as _fundamental_ngx_core_card from '@fundamental-ngx/core/card';

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: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
    /**
     * Value of the list item.
     */
    readonly value: _angular_core.InputSignal<T | undefined>;
    /**
     * @hidden
     * Implementation of KeyboardSupportItemInterface
     */
    readonly keyDown: _angular_core.OutputEmitterRef<KeyboardEvent>;
    /** @hidden */
    readonly elementRef: ElementRef;
    /** @hidden */
    readonly _focused$: Subject<{
        focusedWithin: boolean;
    }>;
    /** @hidden */
    readonly _clicked$: Subject<MouseEvent>;
    /** @hidden */
    protected _isFirstItem$: _angular_core.WritableSignal<boolean>;
    /** @hidden */
    protected _normalizedTabIndex$: _angular_core.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: _angular_core.ɵɵFactoryDeclaration<CardFocusItem<any>, never>;
    static ɵdir: _angular_core.ɵɵ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 CardCounterDirective implements HasElementRef {
    /** Card counter id, it has some default value if not set,  */
    readonly id: _angular_core.InputSignal<string>;
    /**
     * the status represented by the Object Status.
     * can be one of the following: 'negative' | 'critical' | 'positive' | 'informative' | 'neutral'
     */
    readonly statusInput: _angular_core.InputSignal<ObjectStatus>;
    /** @hidden */
    readonly elementRef: ElementRef<any>;
    /** @hidden */
    protected readonly _cssClass: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardCounterDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CardCounterDirective, "[fd-card-counter]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "statusInput": { "alias": "statusInput"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class CardSecondSubtitleDirective implements HasElementRef$1 {
    /** @hidden */
    readonly elementRef: ElementRef<any>;
    /** Card second subtitle id, it has some default value if not set,  */
    readonly id: _angular_core.InputSignal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardSecondSubtitleDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CardSecondSubtitleDirective, "[fd-card-second-subtitle]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class CardSubtitleDirective implements HasElementRef$1 {
    /** Card subtitle id, it has some default value if not set,  */
    readonly id: _angular_core.InputSignal<string>;
    /** @hidden */
    readonly elementRef: ElementRef<any>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardSubtitleDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CardSubtitleDirective, "[fd-card-subtitle]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class CardTitleDirective implements HasElementRef$1 {
    /** Card title id, it has some default value if not set,  */
    readonly id: _angular_core.InputSignal<string>;
    /** @hidden */
    readonly elementRef: ElementRef<any>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardTitleDirective, never>;
    static ɵdir: _angular_core.ɵɵ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,  */
    readonly id: _angular_core.InputSignal<string>;
    /**
     * Heading level
     * Available values: number from 1 to 6
     */
    readonly level: _angular_core.InputSignal<Nullable<number>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardMediaHeadingDirective, never>;
    static ɵdir: _angular_core.ɵɵ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 HasElementRef$1 {
    /** @hidden */
    readonly cardTitle: _angular_core.Signal<CardTitleDirective | undefined>;
    /** @hidden */
    readonly cardSubtitle: _angular_core.Signal<CardSubtitleDirective | undefined>;
    /** @hidden */
    readonly cardSecondSubtitle: _angular_core.Signal<CardSecondSubtitleDirective | undefined>;
    /** @hidden */
    readonly cardCounter: _angular_core.Signal<CardCounterDirective | undefined>;
    /** @hidden */
    readonly cardMediaHeading: _angular_core.Signal<CardMediaHeadingDirective | undefined>;
    /**
     * text for the card badge
     */
    readonly badge: _angular_core.InputSignal<string | null | undefined>;
    /**
     * icon/glyph for the card badge
     */
    readonly badgeIcon: _angular_core.InputSignal<string | null | undefined>;
    /**
     * Indication color for the card badge
     * Possible values: integers from 1 to 10
     */
    readonly badgeColor: _angular_core.InputSignal<ColorAccent | null | undefined>;
    /**
     * Whether to use secondary set of indication colors for the card badge
     * Default value: false
     */
    readonly badgeColorSecondary: _angular_core.InputSignal<boolean>;
    /**
     * Color status for the card badge
     * Possible values: 'negative' | 'critical' | 'positive' | 'informative' | 'neutral'
     * Default value: null
     */
    readonly badgeStatus: _angular_core.InputSignal<ObjectStatus | null | undefined>;
    /**
     * aria-label for the card badge
     * Default value: null
     */
    readonly badgeAriaLabel: _angular_core.InputSignal<string | null | undefined>;
    /**
     * text for the card second badge
     */
    readonly secondBadge: _angular_core.InputSignal<string | null | undefined>;
    /**
     * icon/glyph for the card second badge
     */
    readonly secondBadgeIcon: _angular_core.InputSignal<string | null | undefined>;
    /**
     * Indication color for the card second badge
     * Possible values: integers from 1 to 10
     */
    readonly secondBadgeColor: _angular_core.InputSignal<ColorAccent | null | undefined>;
    /**
     * Whether to use secondary set of indication colors for the card second badge
     * Default value: false
     */
    readonly secondBadgeColorSecondary: _angular_core.InputSignal<boolean>;
    /**
     * Color status for the card second badge
     * Possible values: 'negative' | 'critical' | 'positive' | 'informative' | 'neutral'
     * Default value: null
     */
    readonly secondBadgeStatus: _angular_core.InputSignal<ObjectStatus | null | undefined>;
    /**
     * aria-label for the card second badge
     * Default value: null
     */
    readonly secondBadgeAriaLabel: _angular_core.InputSignal<string | null | undefined>;
    /**
     * whether the card is in loading state
     * default: false
     */
    readonly isLoading: _angular_core.InputSignal<boolean>;
    /**
     * set the Card type
     * options: 'object' | 'standard' | 'component' | 'analytical' | 'list' | 'table' | 'quickView' | 'linkList' | 'banner'
     * default: 'standard'
     *
     */
    readonly cardType: _angular_core.InputSignal<CardType>;
    /**
     * card id
     * if not set, a default value is provided
     */
    readonly id: _angular_core.InputSignal<string>;
    /**
     * card aria-roledescription
     * default: 'Card'
     */
    readonly ariaRoledescription: _angular_core.InputSignal<string | null | undefined>;
    /**
     * card aria-description
     * Overrides the default translated aria description.
     */
    readonly ariaDescription: _angular_core.InputSignal<string | null | undefined>;
    /**
     * card aria-label
     * used when there's no title describing the card
     */
    readonly ariaLabel: _angular_core.InputSignal<string | null | undefined>;
    /**
     * card role
     * default: 'region'
     */
    readonly role: _angular_core.InputSignal<string>;
    /**
     * whether the card is interactive
     * default: false
     */
    readonly interactive: _angular_core.InputSignal<boolean>;
    /**
     * whether the card is selected
     * default: false
     */
    readonly selected: _angular_core.InputSignal<boolean>;
    /**
     * value for aria-posinset
     */
    readonly ariaPosinset: _angular_core.ModelSignal<number | null | undefined>;
    /**
     * value for aria-setsize
     */
    readonly ariaSetsize: _angular_core.ModelSignal<number | null | undefined>;
    /**
     * Additional IDs to include in aria-describedby attribute
     * Can be used to reference additional descriptive content
     */
    readonly ariaDescribedby: _angular_core.InputSignal<string | null | undefined>;
    /** @hidden */
    readonly contentDensityObserver: ContentDensityObserver;
    /** @hidden */
    readonly elementRef: ElementRef<HTMLElement>;
    /**
     * @hidden
     * Implementation of KeyboardSupportItemInterface
     */
    readonly keyDown: _angular_core.OutputEmitterRef<KeyboardEvent>;
    /** @hidden Default translated aria description */
    protected readonly defaultAriaDescription: _angular_core.Signal<string>;
    /** @hidden Resolved aria description: input overrides translated default */
    protected readonly resolvedAriaDescription: _angular_core.Signal<string>;
    /** @hidden ID for the visually hidden span announcing the card description */
    protected readonly ariaDescriptionId: _angular_core.Signal<string>;
    /** @hidden ID for the visually hidden span announcing the card role description */
    protected readonly ariaRoleDescriptionId: _angular_core.Signal<string>;
    /** @hidden Badge ID for first badge */
    protected readonly badgeId: _angular_core.Signal<string | null>;
    /** @hidden Second badge ID */
    protected readonly secondBadgeId: _angular_core.Signal<string | null>;
    /** @hidden Computed aria-describedby value */
    protected readonly ariaDescribedbyComputed: _angular_core.Signal<string | null>;
    protected readonly cssClass: _angular_core.Signal<string>;
    constructor();
    /** @hidden */
    keydownHandler(event: KeyboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵ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; }; "ariaDescribedby": { "alias": "ariaDescribedby"; "required": false; "isSignal": true; }; }, { "ariaPosinset": "ariaPosinsetChange"; "ariaSetsize": "ariaSetsizeChange"; "keyDown": "keyDown"; }, ["cardTitle", "cardSubtitle", "cardSecondSubtitle", "cardCounter", "cardMediaHeading"], ["*", "fd-card-footer", "fd-card-loader"], true, never>;
}

declare class CardListDirective implements OnInit, AfterContentInit, OnDestroy {
    /**
     * an event thrown, when focus escapes the list
     */
    focusEscapeList: EventEmitter<FocusEscapeDirection>;
    /** @hidden */
    private _focusItems;
    /**
     * whether internal keyboard support should be enabled.
     * default: true
     */
    keyboardSupport: _angular_core.InputSignal<boolean>;
    /**
     * aria-roledescription for the Card list
     * default: 'Card Container'
     */
    ariaRoleDescription: _angular_core.InputSignal<string>;
    /**
     * aria-label for the Card list
     */
    ariaLabel: _angular_core.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 */
    private readonly _rtlService;
    /** @hidden */
    private readonly _keyboardSupportService;
    /** @hidden */
    private readonly _isRtl;
    /** @hidden */
    constructor();
    /** @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: _angular_core.ɵɵFactoryDeclaration<CardListDirective, never>;
    static ɵdir: _angular_core.ɵɵ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'
     */
    readonly ariaRoleDescription: _angular_core.InputSignal<string>;
    /** @hidden */
    readonly cardMainHeader: _angular_core.Signal<_fundamental_ngx_core_card.FdCardMainHeaderComponent | undefined>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardHeaderComponent, never>;
    static ɵcmp: _angular_core.ɵɵ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: _angular_core.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: _angular_core.InputSignal<string>;
    /** @hidden */
    readonly _cardTitle: _angular_core.Signal<unknown>;
    /** @hidden */
    readonly _cardSubtitle: _angular_core.Signal<unknown>;
    /** @hidden */
    readonly _cardCounter: _angular_core.Signal<unknown>;
    /** @hidden */
    readonly _cardHeaderAction: _angular_core.Signal<unknown>;
    /** @hidden */
    readonly _cardKpiHeader: _angular_core.Signal<unknown>;
    /** @hidden */
    readonly _cardSecondSubtitle: _angular_core.Signal<unknown>;
    /** @hidden */
    readonly _cardAvatar: _angular_core.Signal<unknown>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardMainHeaderComponent, never>;
    static ɵcmp: _angular_core.ɵɵ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: _angular_core.ɵɵFactoryDeclaration<CardHeaderActionDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CardHeaderActionDirective, "[fd-card-header-action]", never, {}, {}, never, never, true, never>;
}

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

declare class CardHeaderRowDirective {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardHeaderRowDirective, never>;
    static ɵdir: _angular_core.ɵɵ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'
     */
    readonly align: _angular_core.InputSignal<"left" | "right">;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardHeaderColumnDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CardHeaderColumnDirective, "[fd-card-header-column]", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class CardNumericContainerComponent {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardNumericContainerComponent, never>;
    static ɵcmp: _angular_core.ɵɵ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: _angular_core.ɵɵFactoryDeclaration<CardIndicatorComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CardIndicatorComponent, "fd-card-indicator", never, {}, {}, never, ["[fd-card-indicator-title]", "[fd-card-indicator-value]"], true, never>;
}

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

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

declare class CardContentComponent implements HasElementRef$1 {
    /** @hidden */
    readonly elementRef: ElementRef<any>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardContentComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CardContentComponent, "fd-card-content", never, {}, {}, never, ["*"], true, never>;
}

declare class CardLoaderComponent implements HasElementRef$1 {
    /** @hidden */
    readonly elementRef: ElementRef<any>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardLoaderComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CardLoaderComponent, "fd-card-loader", never, {}, {}, never, ["*"], true, never>;
}

declare class CardKpiHeaderComponent implements HasElementRef$1 {
    /** @hidden */
    readonly elementRef: ElementRef<any>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardKpiHeaderComponent, never>;
    static ɵcmp: _angular_core.ɵɵ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 HasElementRef$1 {
    /** Set type of KPI value. eg: 'positive', 'negative', 'critical', 'informative' */
    readonly status: _angular_core.InputSignal<KpiStatus | undefined>;
    /** @hidden */
    readonly elementRef: ElementRef<any>;
    /** @hidden */
    protected readonly cssClass: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardKpiValueDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CardKpiValueDirective, "[fd-card-kpi-value]", never, { "status": { "alias": "status"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class CardKpiScaleIconDirective implements HasElementRef$1 {
    /** @hidden */
    readonly elementRef: ElementRef<any>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardKpiScaleIconDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CardKpiScaleIconDirective, "[fd-card-kpi-scale-icon]", never, {}, {}, never, never, true, never>;
}

declare class CardKpiScaleTextDirective implements HasElementRef$1 {
    /** @hidden */
    readonly elementRef: ElementRef<any>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardKpiScaleTextDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CardKpiScaleTextDirective, "[fd-card-kpi-scale-text]", never, {}, {}, never, never, true, never>;
}

declare class CardKpiAnalyticsDirective implements HasElementRef$1 {
    /** @hidden */
    readonly elementRef: ElementRef<any>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardKpiAnalyticsDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CardKpiAnalyticsDirective, "[fd-card-kpi-analytics]", never, {}, {}, never, never, true, never>;
}

declare class CardKpiAnalyticsLabelDirective implements HasElementRef$1 {
    /** @hidden */
    readonly elementRef: ElementRef<any>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardKpiAnalyticsLabelDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CardKpiAnalyticsLabelDirective, "[fd-card-kpi-analytics-label]", never, {}, {}, never, never, true, never>;
}

declare class CardKpiAnalyticsContentDirective implements HasElementRef$1 {
    /** @hidden */
    readonly elementRef: ElementRef<any>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardKpiAnalyticsContentDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CardKpiAnalyticsContentDirective, "[fd-card-kpi-analytics-content]", never, {}, {}, never, never, true, never>;
}

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

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

declare class CardMediaComponent {
    /**
     * aria-roledescription for the container
     * default: 'Card Media Block'
     */
    readonly ariaRoleDescription: _angular_core.InputSignal<string>;
    /**
     * Whether the media container comes with a 1rem padding
     * Default value: false
     */
    readonly hasPadding: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Shell Category Colors
     * Available values: number from 1 to 16
     */
    readonly shellColor: _angular_core.InputSignal<number | null | undefined>;
    /**
     * Legend Background Colors
     * Available values: number from 1 to 20
     */
    readonly legendColor: _angular_core.InputSignal<number | null | undefined>;
    /** @hidden */
    protected readonly cssClass: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardMediaComponent, never>;
    static ɵcmp: _angular_core.ɵɵ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: _angular_core.ɵɵFactoryDeclaration<CardMediaImageDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CardMediaImageDirective, "[fd-card-media-image]", never, {}, {}, never, never, true, never>;
}

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

declare class CardMediaContentContainerDirective {
    /**
     * Whether the media content container is an overlay
     * Default value: false
     */
    readonly isOverlay: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Shell Category Colors
     * Available values: number from 1 to 16
     */
    readonly shellColor: _angular_core.InputSignal<number | null | undefined>;
    /**
     * Legend Background Colors
     * Available values: number from 1 to 20
     */
    readonly legendColor: _angular_core.InputSignal<number | null | undefined>;
    /** @hidden */
    protected readonly cssClass: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardMediaContentContainerDirective, never>;
    static ɵdir: _angular_core.ɵɵ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: _angular_core.ɵɵFactoryDeclaration<CardMediaTextDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CardMediaTextDirective, "[fd-card-media-text]", never, {}, {}, never, never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class CardModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardModule, never>;
    static ɵmod: _angular_core.ɵɵ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: _angular_core.ɵɵ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 };
