import { AddressSchema } from '@anoki/fse-common';
import { ComponentPropsWithoutRef } from 'react';
import { ComponentType } from 'react';
import { CSSProperties } from 'react';
import { DayHours } from '@anoki/fse-common';
import { default as default_2 } from 'react';
import { ElementType } from 'react';
import { FC } from 'react';
import { GeneralPractitionerResponse } from '@anoki/fse-common/dist/types/general-practitioner-service';
import { GetValues } from '@anoki/fse-common/dist';
import { GetValues as GetValues_2 } from '@anoki/fse-common/dist/index';
import { JSX } from 'react/jsx-runtime';
import { Link as Link_2 } from '@anoki/fse-common/dist';
import { Link as Link_3 } from '@anoki/fse-common/dist/index';
import { MouseEvent as MouseEvent_2 } from 'react';
import { OpeningHours } from '@anoki/fse-common';
import { PropsWithChildren } from 'react';
import * as React_2 from 'react';
import { ReactNode } from 'react';
import { SectionLink } from '@anoki/fse-common';
import { Service } from '@anoki/fse-common';
import { Structure } from '@anoki/fse-common';

export declare const AccessLogSkeleton: () => JSX.Element;

export declare const ActionBanner: default_2.FC<ActionBannerProps>;

declare interface ActionBannerProps {
    title: string;
    description: string;
    variant?: ActionBannerVariantTypes;
    link?: Link_2;
    firstAction?: Link_2;
    secondAction?: Link_2;
}

export declare enum ActionBannerVariantEnum {
    DEFAULT = "default",
    OUTLINE = "outline",
    SIMPLE = "simple"
}

export declare type ActionBannerVariantTypes = GetValues<typeof ActionBannerVariantEnum>;

export declare interface ActionData {
    label: string;
    ariaLabel: string;
    type: "link" | "button";
    link?: string;
    action?: () => void;
}

export declare const ActionIconText: ({ iconColor, icon, noIcon, textLabel, handleAction, handleIconAction, classNameComponent, classNameText, disablePointer, iconPosition, popupInfo, positionPopUp, }: ActionIconTextProps) => JSX.Element;

declare type ActionIconTextProps = PropsWithChildren<{
    icon?: ReactNode;
    noIcon?: boolean;
    textLabel?: string;
    handleAction?: () => void;
    handleIconAction?: () => void;
    classNameComponent?: string;
    classNameText?: string;
    disablePointer?: boolean;
    iconPosition?: "left" | "right";
    popupInfo?: InfoPopupProps;
    iconColor?: ColorKeys;
    positionPopUp?: "left" | "right";
}>;

declare type ActionItem = PropsWithChildren<{
    label: string;
    icon: ReactNode;
    onClick: () => void;
    loading?: boolean;
}>;

export declare const ActionPoint: ({ links }: ActionPointProps) => JSX.Element;

declare type ActionPointProps = {
    links: Array<Link_2>;
};

export declare const Actions: ({ width, height, className, color, }: IconProps) => JSX.Element;

export declare const Add: ({ width, height, className, color, }: IconProps) => JSX.Element;

export declare type AggregationItemsProps = {
    title: ReactNode;
    description?: ReactNode;
    goToLabel?: string;
    href?: string;
    asLink?: "a" | ComponentType<any>;
    items: any[];
    layout?: Layout;
    className?: string;
};

export declare const Alert: default_2.FC<AlertProps>;

declare type AlertDialogProps = {
    isOpen: boolean;
    onClose: () => void;
    title?: string;
    description?: string;
    confirmBtnLabel?: string;
};

export declare const AlertDialogUI: ({ title, description, confirmBtnLabel, isOpen, onClose, }: AlertDialogProps) => JSX.Element;

export declare type AlertProps = {
    title: string;
    description: string;
    subtitle: string;
    link: Link_2;
    variant?: AlertVariant;
};

export declare type AlertVariant = GetValues<typeof AlertVariantEnum>;

export declare const AlertVariantEnum: {
    readonly DEFAULT: "default";
    readonly INFO: "info";
    readonly WARNING: "warning";
    readonly DANGER: "danger";
    readonly SUCCESS: "success";
};

export declare const ArrowDown: ({ width, height, className, color, }: IconProps) => JSX.Element;

export declare const ArrowLeft: ({ width, height, className, color, }: IconProps) => JSX.Element;

export declare const ArrowLink: ({ href, asLink, isExternal, fs, children, className, onClick, type, asButton, ...props }: ArrowLinkProps) => JSX.Element;

declare type ArrowLinkAsButtonProps = BaseArrowLinkProps & {
    onClick?: () => void;
    type?: "button";
    asButton?: true;
    asLink?: never;
    href?: never;
};

declare type ArrowLinkAsLinkProps = BaseArrowLinkProps & {
    href: string;
    asLink?: "a" | default_2.ComponentType<any>;
    onClick?: never;
    type?: never;
    asButton?: never;
};

declare type ArrowLinkProps = ArrowLinkAsLinkProps | ArrowLinkAsButtonProps;

export declare const ArrowRight: ({ width, height, className, color, }: IconProps) => JSX.Element;

export declare const ArrowTop: ({ width, height, className, color, }: IconProps) => JSX.Element;

export declare const Attachment: ({ width, height, className, color, }: IconProps) => JSX.Element;

export declare const AuthorBlock: ({ titleTag: TitleTag, authorName, avatar, avatarSize, publishedLabel, publishedDate, readingTimeLabel, readingTimeValue, readingMinuteLabel, }: CardDoctorProps_2) => JSX.Element;

export declare const Avatar: ({ initials, bg, textColor, size, className, }: AvatarProps) => JSX.Element;

declare type AvatarProps = {
    initials: string;
    bg?: ColorKeys;
    textColor?: ColorKeys;
    size?: AvatarSize;
    className?: string;
};

export declare type AvatarSize = "1" | "2" | "3";

export declare const AvatarSkeleton: ({ size }: AvatarSkeletonProps) => JSX.Element;

declare type AvatarSkeletonProps = {
    size?: "1" | "2" | "3";
};

declare type BaseArrowLinkProps = {
    isExternal?: boolean;
    fs?: TypographyKeys;
    children: default_2.ReactNode;
    className?: string;
};

declare type BaseButtonProps = {
    children: React.ReactNode;
    variant?: ButtonVariant;
    bg?: ColorKeys;
    textColor?: ColorKeys;
    border?: ColorKeys;
    size?: ButtonSize;
    className?: string;
    disabled?: boolean;
    loading?: boolean;
    form?: string;
    rel?: string;
    target?: string;
};

export declare const BaseModal: {
    ({ open, setOpen, overrideClassNames, id, children, }: BaseModalProps): JSX.Element;
    Header: ({ labels, onCloseClick, onBackClick, showBackButton, children, }: {
        labels?: {
            closeButton?: string;
            backButton?: string;
        };
        onCloseClick?: () => void;
        onBackClick?: () => void;
        showBackButton?: boolean;
        children?: React.ReactNode;
    }) => JSX.Element;
    HeaderBack: ({ onBackClick, backButton, children, }: {
        onBackClick: () => void;
        backButton: string;
        children?: React.ReactNode;
    }) => JSX.Element;
    Content: ({ className, children, }: {
        className?: string;
        children: React.ReactNode;
    }) => JSX.Element;
    Footer: ({ children, className, }: {
        className?: string;
        children: React.ReactNode;
    }) => JSX.Element;
};

declare type BaseModalProps = {
    open: boolean;
    setOpen: (open: boolean) => void;
    overrideClassNames?: string;
    id?: string;
    children: React.ReactNode;
};

export declare const Blockquote: default_2.FC<BlockquoteProps>;

declare type BlockquoteProps = {
    text: string;
    author: string;
    variant?: Variant_2;
};

export declare const BottomNavigation: ({ className, title, removeLabel, applyLabel, selectedFilters, onApplyFilters, onClearFilters, applyDisabled, }: BottomNavigationProps) => JSX.Element;

declare type BottomNavigationProps = {
    className?: string;
    title: string;
    removeLabel: string;
    applyLabel: string;
    selectedFilters: Record<string, string[]>;
    onApplyFilters: () => void;
    onClearFilters: () => void;
    applyDisabled?: boolean;
};

export declare const Breadcrumb: ({ items, }: BreadcrumbProps) => JSX.Element;

declare type BreadcrumbItemProps = {
    label: string;
    href?: string;
    isClickable?: boolean;
    asLink?: "a" | ComponentType<any>;
};

export declare type BreadcrumbProps = {
    items: BreadcrumbItemProps[];
};

declare type BreakpointSpace = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "10" | "11" | "12";

export declare const Button: ({ children, variant, bg, textColor, border, size, className, disabled, loading, onClick, type, form, asLink, href, target, rel, ...props }: ButtonProps) => JSX.Element;

declare type ButtonAsButtonProps = BaseButtonProps & {
    onClick?: () => void;
    type?: "button" | "submit" | "reset";
    asLink?: never;
    href?: never;
};

declare type ButtonAsLinkProps = BaseButtonProps & {
    href: string;
    onClick?: never;
    type?: never;
    asLink?: "a" | React.ComponentType<any>;
};

declare type ButtonProps = ButtonAsButtonProps | ButtonAsLinkProps;

declare type ButtonSize = "2" | "3" | "4";

declare type ButtonVariant = "primary" | "secondary";

export declare const Calendar: ({ width, height, className, filled, color, }: IconProps) => JSX.Element;

export declare const Callout: React.FC<CalloutProps>;

declare interface CalloutProps {
    title: string;
    description: React.ReactNode;
    variant?: Variant_3;
}

export declare const CardCategory: ({ image, title, titleTag: TitleTag, href, description, description2, isExternal, showIcon, goToLabel, asLink, asImage, className, classNameTitle, classNameDescription, handleOnClick, }: CardCategoryProps) => JSX.Element;

declare type CardCategoryProps = {
    image?: Image_2;
    title: string;
    titleTag?: HeadingLevel;
    href?: string;
    description?: string;
    description2?: string;
    isExternal?: boolean;
    showIcon?: boolean;
    goToLabel?: string;
    asImage?: "img";
    asLink?: "a" | ComponentType<any>;
    className?: string;
    classNameTitle?: string;
    classNameDescription?: string;
    handleOnClick?: (e: MouseEvent_2<HTMLAnchorElement>) => void;
};

export declare const CardDoctor: ({ titleTag: TitleTag, doctorName, specialties, contactInfo, schedule, avatar, avatarSize, button, }: CardDoctorProps) => JSX.Element;

export declare const CardDoctorInfo: ({ titleTag: TitleTag, doctorName, specialties, contactInfo, avatar, className, officesInfo, officeLabel, }: CardDoctorInfoProps) => JSX.Element;

declare type CardDoctorInfoProps = {
    titleTag?: HeadingLevel_8;
    doctorName: string;
    specialties?: string[];
    contactInfo?: Info_2[];
    avatar?: {
        initials: string;
        bg?: ColorKeys;
        textColor?: ColorKeys;
    };
    className?: string;
    officesInfo?: Info_2[][];
    officeLabel?: string;
};

declare type CardDoctorProps = {
    titleTag?: HeadingLevel_11;
    doctorName: string;
    specialties?: string[];
    contactInfo?: Info_3[];
    schedule?: {
        label: string;
        days: ScheduleDay[];
    };
    avatar?: {
        initials: string;
        bg?: ColorKeys;
        textColor?: ColorKeys;
    };
    avatarSize?: AvatarSize;
    button?: {
        label: string;
        onClick: () => void;
    };
};

declare type CardDoctorProps_2 = {
    titleTag?: HeadingLevel_13;
    authorName: string;
    avatar?: {
        initials: string;
        bg?: ColorKeys;
        textColor?: ColorKeys;
    };
    avatarSize?: AvatarSize;
    publishedLabel?: string;
    publishedDate?: string;
    readingTimeLabel?: string;
    readingTimeValue?: string;
    readingMinuteLabel?: string;
};

export declare const CardDocument: ({ eventNumber, date, documentType, documentTitle, label, subtitle, action, CTA, handleDownloadDocument, hrefDocument, isLoading, openDocumentLabel, releaseDateLabel, eventLabel, asLink, }: CardDocumentProps) => JSX.Element;

declare type CardDocumentProps = {
    eventNumber?: string;
    date?: string | number;
    documentType?: string;
    documentTitle: string;
    label?: string;
    subtitle?: string;
    action?: string;
    CTA?: string;
    iconView?: "attachments" | "obscured";
    favorite?: boolean;
    handleDownloadDocument?: () => void;
    hrefDocument?: string;
    isLoading?: boolean;
    openDocumentLabel?: string;
    releaseDateLabel?: string;
    eventLabel?: string;
    asLink?: "a" | ComponentType<any>;
};

export declare const CardExemption: ({ information, className, exemptionCode, isOpen, onToggle, hasBorder, exemptionLabel, }: CardExemptionProps) => JSX.Element;

declare type CardExemptionProps = {
    information?: {
        label: string;
        value: string;
    }[];
    className?: string;
    exemptionCode: string;
    isOpen: boolean;
    onToggle: () => void;
    selectedStructures?: string[];
    hasBorder?: boolean;
    exemptionLabel?: string;
};

export declare function CardFile({ title, description, issued_at, file, action, }: CardFileProps): JSX.Element;

export declare enum CardFileActionTypeEnum {
    DOWNLOAD = "download",
    GOTO = "goto",
    EXTERNAL = "external"
}

export declare type CardFileActionTypeTypes = GetValues_2<typeof CardFileActionTypeEnum>;

export declare type CardFileProps = {
    title: string;
    description?: string;
    issued_at: string;
    file?: {
        type: string;
        size: string;
    };
    action: {
        type: CardFileActionTypeTypes;
        link: Link_3;
    };
};

export declare const CardMap: ({ id, title, titleTag: TitleTag, href, description, isExternal, asLink, className, address, setSelectedCard, }: CardMapProps) => JSX.Element;

export declare const CardMapDoctor: ({ titleTag: TitleTag, availableLabel, specialization, href, addressLabel, linkLabel, asLink, className, doctor, setSelectedCard, keepSelectionOnNavigation, }: CardMapDoctorProps) => JSX.Element;

declare type CardMapDoctorProps = {
    titleTag: HeadingLevel_3;
    availableLabel: string;
    specialization?: string;
    href?: string;
    addressLabel?: string;
    linkLabel?: string;
    asLink?: "a";
    className?: string;
    doctor: GeneralPractitionerResponse;
    setSelectedCard?: (id: string) => void;
    keepSelectionOnNavigation?: boolean;
};

declare type CardMapProps = {
    id: string;
    title: string;
    titleTag: HeadingLevel_2;
    href?: string;
    description?: string;
    isExternal?: boolean;
    showIcon?: boolean;
    asLink?: "a";
    className?: string;
    address?: AddressSchema;
    setSelectedCard?: (id: string) => void;
};

export declare const CardNotification: ({ type, onClickEdit, onClickRightManage, showExpired, buttonMaxWidth, onClickGoToDetails, icon, variant, onClickManage, date, title, showBadge, text, }: CardNotificationProps) => JSX.Element;

declare type CardNotificationProps = {
    type: string;
    date: string;
    icon: NotificationIcon;
    showBadge?: boolean;
    title: string;
    text: string;
    variant?: Variant;
    onClickEdit?: () => void;
    onClickManage?: () => void;
    onClickGoToDetails?: () => void;
    showExpired?: boolean;
    buttonMaxWidth?: boolean;
    onClickRightManage?: () => void;
};

export declare const CardOpeningHours: ({ title, titleTag: TitleTag, openingHours, weekDaysMap, openLabel, todayLabel, closeLabel, open24Label, opensSoonLabel, opensAtLabel, opensTomorrowLabel, opensOnLabel, atLabel, closesAtLabel, }: CardOpeningHoursProps) => JSX.Element;

declare type CardOpeningHoursProps = {
    title: string;
    titleTag: HeadingLevel_4;
    openingHours: OpeningHours;
    weekDaysMap: WeekDaysMap;
    openLabel?: string;
    todayLabel?: string;
    closeLabel?: string;
    open24Label?: string;
    opensSoonLabel?: string;
    opensAtLabel?: string;
    opensTomorrowLabel?: string;
    opensOnLabel?: string;
    atLabel?: string;
    closesAtLabel?: string;
};

export declare const CardReminder: ({ icon, titleTag: TitleTag, title, description, footer, }: CardReminderProps) => JSX.Element;

declare type CardReminderProps = {
    icon?: React.ReactNode;
    title: string;
    description?: React.ReactNode;
    titleTag?: HeadingLevel_10;
    footer?: React.ReactNode;
};

export declare const CardSelectDoctor: ({ id, title, titleTag: TitleTag, description, className, setSelectedCard, description2, keepSelectionOnNavigation, disabled, }: CardSelectDoctorProps) => JSX.Element;

declare type CardSelectDoctorProps = {
    id: string;
    title: string;
    titleTag?: HeadingLevel_7;
    href?: string;
    description?: string;
    isExternal?: boolean;
    showIcon?: boolean;
    asLink?: "a";
    className?: string;
    setSelectedCard?: (id: string) => void;
    description2?: string;
    keepSelectionOnNavigation?: boolean;
    disabled?: boolean;
};

export declare const CardService: ({ title, href, titleTag: TitleTag, asLink, className, iconType, }: CardServiceProps) => JSX.Element;

export declare type CardServiceProps = {
    title: string;
    href?: string;
    titleTag: "h3";
    asLink?: "a" | ComponentType<any>;
    className?: string;
    iconType?: "icon1" | "icon2" | "icon3";
};

export declare const CardUser: ({ titleTag: TitleTag, userName, avatar, information, }: CardUserProps) => JSX.Element;

declare type CardUserProps = {
    titleTag?: HeadingLevel_12;
    userName: string;
    avatar?: {
        initials: string;
        bg?: ColorKeys;
        textColor?: ColorKeys;
    };
    information?: {
        label: string;
        value: string;
    }[];
};

export declare const CategoryContent: ({ className, items, selectedItems, onChange, }: CategoryContentProps) => JSX.Element;

declare type CategoryContentProps = {
    className?: string;
    items: {
        id: string;
        label: string;
        checked: boolean;
    }[];
    selectedItems: string[];
    onChange: (selected: string[]) => void;
};

export declare const CategoryHeader: ({ className, title, isOpen, onToggle, selectedStructures, hasBorder, }: CategoryHeaderProps) => JSX.Element;

declare type CategoryHeaderProps = {
    className?: string;
    title: string;
    isOpen: boolean;
    onToggle: () => void;
    selectedStructures?: string[];
    hasBorder?: boolean;
};

export declare const CenterMap: ({ width, height, className, color, }: IconProps) => JSX.Element;

export declare const ChangeProfileModal: {
    ({ open, overrideClassNames, showFooter, showHeader, OnPressConfirm, disabledConfirm, setOpen, children, }: ChangeProfileModalProps): JSX.Element;
    Content: ({ overrideClassNames, children, }: {
        overrideClassNames?: string;
        children?: React.ReactNode;
    }) => JSX.Element;
};

declare type ChangeProfileModalProps = {
    open: boolean;
    overrideClassNames?: string;
    setOpen: (open: boolean) => void;
    children: React.ReactNode;
    OnPressConfirm: () => void;
    disabledConfirm?: boolean;
    showHeader?: boolean;
    showFooter?: boolean;
};

export declare const ChangeRelatedCard: ({ title, isSelected, region, }: ChangeRelatedCardProps) => JSX.Element;

declare type ChangeRelatedCardProps = {
    title: string;
    region: Region;
    isSelected?: boolean;
};

export declare const Checkbox: ({ id, label, checked, onChange, classNameText, }: CheckboxProps) => JSX.Element;

export declare const CheckboxFilter: ({ id, label, checked, onChange, classNameText, }: CheckboxFilterProps) => JSX.Element;

declare type CheckboxFilterProps = PropsWithChildren<{
    id: string;
    label?: ReactNode;
    checked: boolean;
    onChange: (checked: boolean) => void;
    classNameText?: string;
}>;

declare type CheckboxProps = {
    id: string;
    label?: React.ReactNode;
    checked: boolean;
    onChange: (checked: boolean) => void;
    classNameText?: string;
};

export declare const Close: ({ width, height, className, color, onClick, }: IconProps) => JSX.Element;

export declare const Col: <E extends ElementType = "div">({ as, className, justifyContent, alignItems, flexWrap, ref, style, ...rest }: PolymorphicProps_4<E>) => JSX.Element;

declare type ColorKeys = "primary" | "white" | "status-success" | "warning" | "error" | "muted" | "emphasis" | "slate-20" | "slate-14" | "slate-28" | "border-divider" | "transparent" | "blue-30" | "disabled" | "lightblue-a01" | "lightblue-a02" | "lightblue-a03" | "secondary" | "blue-48";

declare type ColorProps = {
    bg?: ColorKeys;
    text?: ColorKeys;
    color?: ColorKeys;
    border?: ColorKeys;
};

export declare interface ColumnConfig {
    label: string;
    ariaLabel: string;
    sortable: boolean;
    action?: () => void;
    iconAction?: () => void;
    popupInfo?: InfoPopupProps;
    icon?: React_2.ReactNode | CommonIconsType;
    iconPosition?: "left" | "right";
    key?: string;
    type?: "string" | "date" | "number";
}

declare type CommonIconsType = "info" | "download";

declare type Config = {
    REGION: "marche" | "lazio" | "nazionale";
};

export declare const Confirm: ({ width, height, className, color, }: IconProps) => JSX.Element;

export declare const ConsentModal: {
    ({ open, overrideClassNames, setOpen, children, }: ConsentModalProps): JSX.Element;
    Header: ({ closeButton, onCloseClick, children, }: {
        closeButton?: string;
        onCloseClick?: () => void;
        children?: React.ReactNode;
    }) => JSX.Element;
    Content: ({ overrideClassNames, children, }: {
        overrideClassNames?: string;
        children?: React.ReactNode;
    }) => JSX.Element;
    Footer: ({ children }: {
        children?: React.ReactNode;
    }) => JSX.Element;
};

declare type ConsentModalProps = {
    open: boolean;
    overrideClassNames?: string;
    setOpen: (open: boolean) => void;
    children: React.ReactNode;
};

export declare const ConsentPrivacySkeleton: () => JSX.Element;

export declare const Container: ({ as, children, className, display, justifyContent, alignItems, flexWrap, ...rest }: ContainerProps) => JSX.Element;

export declare type ContainerProps = {
    as?: React.ElementType;
    children: React.ReactNode;
    className?: string;
    display?: CSSProperties["display"];
    justifyContent?: CSSProperties["justifyContent"];
    alignItems?: CSSProperties["alignItems"];
    flexWrap?: CSSProperties["flexWrap"];
} & SpacingProps;

export declare const CopyLink: ({ width, height, className, color, }: IconProps) => JSX.Element;

declare type ctaLevel = "link" | "button" | "outlineButton";

export declare const DatePicker: ({ label, value, maxValue, minValue, className, disabled, onClick, onChange, error, required, id, }: DatePickerProps) => JSX.Element;

declare type DatePickerProps = {
    label: string;
    value?: Date | null;
    maxValue?: Date;
    minValue?: Date;
    className?: string;
    disabled?: boolean;
    onClick?: () => void;
    onChange: (date: Date) => void;
    error?: string;
    required?: boolean;
    id?: string;
};

export declare const DatePickerRange: ({ label, startDateLabel, endDateLabel, startDate, endDate, className, disabled, required, error, onStartDateChange, onEndDateChange, onStartDateClick, onEndDateClick, }: DatePickerRangeProps) => JSX.Element;

declare type DatePickerRangeProps = {
    label?: string;
    startDateLabel?: string;
    endDateLabel?: string;
    startDate?: Date;
    endDate?: Date;
    className?: string;
    disabled?: boolean;
    required?: boolean;
    error?: string;
    onStartDateChange: (date: Date) => void;
    onEndDateChange: (date: Date) => void;
    onStartDateClick?: () => void;
    onEndDateClick?: () => void;
};

export declare const DelegateCard: ({ id, isSelected, title, subtitle, region, relation, isMe, showRegion, setSelectedCard, className, }: DelegateCardProps) => JSX.Element;

export declare type DelegateCardProps = {
    id: string;
    isSelected: boolean;
    title: string;
    subtitle: string;
    relation: string;
    isMe?: boolean;
    setSelectedCard: (id: string) => void;
    className?: string;
    showRegion?: boolean;
    region?: Region;
};

export declare const DelegateFilterDropDown: ({ size, items, className, selectedPerson, setSelectedPerson, placeholder, btnText, }: RelatedPeopleDropDownProps) => JSX.Element;

declare const Description: ({ fs, color, className, children, }: DescriptionProps) => JSX.Element;

declare type DescriptionProps = PropsWithChildren<{
    fs?: TypographyKeys;
    color?: ColorKeys;
    className?: string;
}>;

export declare const Doctor: ({ width, height, className, filled, color, }: IconProps) => JSX.Element;

export declare const DoctorConfirmModal: {
    ({ open, overrideClassNames, setOpen, children, }: DoctorConfirmModalProps): JSX.Element;
    Header: ({ closeButton, onCloseClick, children, }: {
        closeButton?: string;
        onCloseClick?: () => void;
        children?: React.ReactNode;
    }) => JSX.Element;
    Content: ({ overrideClassNames, children, }: {
        overrideClassNames?: string;
        children?: React.ReactNode;
    }) => JSX.Element;
    Footer: ({ children, }: {
        children?: React.ReactNode;
    }) => JSX.Element;
};

declare type DoctorConfirmModalProps = {
    open: boolean;
    overrideClassNames?: string;
    setOpen: (open: boolean) => void;
    children: React.ReactNode;
};

export declare const DoctorModal: {
    ({ open, overrideClassNames, setOpen, children, }: DoctorModalProps): JSX.Element;
    Content: ({ overrideClassNames, children, }: {
        overrideClassNames?: string;
        children?: React.ReactNode;
    }) => JSX.Element;
    Footer: ({ children }: {
        children?: React.ReactNode;
    }) => JSX.Element;
};

declare type DoctorModalHeaderProps = PropsWithChildren<{
    closeButton?: string;
    onCloseClick?: () => void;
    children?: ReactNode;
    title?: string;
    stepLabel?: string;
    currentStep?: number;
    totalSteps?: number;
}>;

declare type DoctorModalProps = {
    open: boolean;
    overrideClassNames?: string;
    setOpen: (open: boolean) => void;
    children: React.ReactNode;
};

export declare const DoctorSkeleton: () => JSX.Element;

declare const Document_2: ({ width, height, className, filled, color, }: IconProps) => JSX.Element;
export { Document_2 as Document }

export declare const DocumentDetailSkeleton: () => JSX.Element;

export declare const Documents: ({ title, items, colorTitle, fontSizeTitle, }: Props_3) => JSX.Element;

export declare const DocumentsListSkeleton: () => JSX.Element;

export declare const DocumentUploadComponent: ({ onFileUpload, isLoading, title, description, titleTag: TitleTag, actionText, className, classNameTitle, classNameDescription, id, name, fileSizeLabel, removeLabel, }: DocumentUploadProps) => JSX.Element;

export declare const DocumentUploadModal: {
    ({ open, overrideClassNames, setOpen, children, }: DocumentUploadModalProps): JSX.Element;
    Header: ({ closeButton, onCloseClick, children, }: {
        closeButton?: string;
        onCloseClick?: () => void;
        children?: ReactNode;
    } & {
        children?: ReactNode | undefined;
    }) => JSX.Element;
    Content: ({ overrideClassNames, children, }: {
        overrideClassNames?: string;
        children?: React.ReactNode;
    }) => JSX.Element;
    Footer: ({ children, }: {
        children?: React.ReactNode;
    }) => JSX.Element;
};

declare type DocumentUploadModalProps = PropsWithChildren<{
    open: boolean;
    overrideClassNames?: string;
    setOpen: (open: boolean) => void;
    children: ReactNode;
}>;

declare interface DocumentUploadProps {
    onFileUpload: (base64File: string, fileName: string, fileType: string) => void;
    isLoading: boolean;
    title: string;
    description?: string;
    titleTag: HeadingLevel_9;
    actionText?: string;
    className?: string;
    classNameTitle?: string;
    classNameDescription?: string;
    id?: string;
    name?: string;
    fileSizeLabel?: string;
    removeLabel?: string;
}

export declare interface DoubleLineData {
    firstLine: string;
    secondLine: string;
}

export declare const Download: ({ width, height, className, color, }: IconProps) => JSX.Element;

export declare const Dropdown: ({ text, leftIcon, options, asLinkItem, textColor, }: DropdownProps) => JSX.Element;

declare type DropdownOption = {
    label: string;
    href?: string;
    onClick?: () => void;
    active?: boolean;
};

declare type DropdownProps = {
    text: string;
    leftIcon?: React.ReactNode;
    options: DropdownOption[];
    asLinkItem?: "a" | React.ComponentType<any>;
    textColor?: ColorKeys;
};

export declare const EditorialWidget: ({ title, children, subtitle, variant, }: Props_2) => JSX.Element;

declare type EditorialWidgetVariant = "light" | "evidence";

export declare const EditPencil: ({ width, height, className, color, }: IconProps) => JSX.Element;

export declare const Ellipse: ({ width, height, className, color, }: IconProps) => JSX.Element;

export declare const Ellipse2: ({ width, height, className, color, }: IconProps) => JSX.Element;

export declare const Ellipse3: ({ width, height, className, color, }: IconProps) => JSX.Element;

declare type EnhancedSectionLink = SectionLink & {
    isNewTab?: boolean;
};

export declare const EntryButton: ({ href, asLink, showIcon, ariaLabel, children, }: EntryButtonProps) => JSX.Element;

declare type EntryButtonProps = {
    href: string;
    asLink?: "a" | React.ComponentType<any>;
    showIcon?: boolean;
    ariaLabel: string;
    children: React.ReactNode;
};

export declare const ErrorExagon: ({ width, height }: IconProps) => JSX.Element;

export declare const ExternalLink: ({ width, height, className, color, }: IconProps) => JSX.Element;

export declare const Favourite: ({ width, height, className, color, filled, }: IconProps) => JSX.Element;

declare const File_2: ({ height, width }: IconProps) => JSX.Element;
export { File_2 as File }

export declare const FilterDropDown: ({ size, items, className, filter, setFilter, allStructuresLabel, }: FilterDropdownProps) => JSX.Element;

declare type FilterDropdownProps = {
    size: "small" | "large";
    items: string[];
    className?: string;
    filter: string;
    setFilter: (filter: string) => void;
    allStructuresLabel: string;
};

export declare const FiltersChips: ({ chips, id, additionalClassName, onChange, selectedChip, }: FiltersChipsProps) => JSX.Element;

declare type FiltersChipsProps = PropsWithChildren<{
    chips: string[];
    id: string;
    additionalClassName?: string;
    onChange: (selectedChip: string) => void;
    selectedChip?: string;
}>;

export declare const Footer: ({ footerLinks, version, asLink, className, additionalLogo, settingsFooterLinks, }: FooterProps) => JSX.Element;

declare type FooterLink = {
    label: string;
    href: string;
    target?: "_blank" | "_self";
};

declare type FooterProps = {
    footerLinks?: FooterLink[];
    version?: string;
    asLink?: "a" | React.ComponentType<any>;
    className?: string;
    additionalLogo?: string;
    settingsFooterLinks?: {
        FseMS?: string;
        FseMEF?: string;
        FseDGT?: string;
        FseUE?: string;
        externalLink?: string;
    };
};

export declare const Fse: ({ width, height, className, color, }: IconProps) => JSX.Element;

export declare const FseDGT: ({ width, height, className, color, }: IconProps) => JSX.Element;

export declare const FseMEF: ({ width, height, className, color, }: IconProps) => JSX.Element;

export declare const FseMS: ({ width, height, className, color, }: IconProps) => JSX.Element;

export declare const FseUE: ({ width, height, className, color, }: IconProps) => JSX.Element;

export declare const GenericSkeleton: () => JSX.Element;

export declare const GridContainer: <E extends ElementType = "div">({ as, className, style, ...rest }: PolymorphicProps<E>) => JSX.Element;

export declare const GridItem: <E extends ElementType = "div">({ as, className, style, md, sm, xs, ...rest }: PolymorphicProps_2<E>) => JSX.Element;

export declare const Hamburguer: ({ width, height, className, color, }: IconProps) => JSX.Element;

export declare const Header: ({ title, region, shortTitle, asLink, navigatonItems, labels, supportLink, loginLink, headerTitleClassname, headerLogoUrl2, children, }: HeaderProps) => JSX.Element;

declare type HeaderDesktopProps = {
    title: React.ReactNode | string;
    region: Region;
    asLink?: "a" | React.ComponentType<any>;
    children?: React.ReactNode;
    labels: NavigationLabels_2;
    navigatonItems: NavigationItem_4[];
    supportLink?: NavigationItem_4;
    loginLink?: string;
    shortTitle?: React.ReactNode;
    headerTitleClassname?: string;
    headerLogoUrl2?: string;
};

declare type HeaderMobileProps = HeaderTopBannerProps & {
    shortTitle: React.ReactNode;
    menuTitle?: string;
    region: Region;
    navigatonItems: NavigationItem_3[];
    labels: NavigationLabels;
    loginLink?: string;
};

export declare const HeaderNavigation: ({ className, title, closeButton, onCloseClick, }: HeaderNavigationProps) => JSX.Element;

declare type HeaderNavigationProps = {
    className?: string;
    title: string;
    closeButton: string;
    onCloseClick?: () => void;
};

export declare const HeaderPostLogin: ({ shortTitle, region, asLink, navigationItems, generalClassName, navItemsClassName, }: HeaderPostLoginProps) => JSX.Element;

export declare type HeaderPostLoginProps = {
    shortTitle: ReactNode;
    region: Region;
    navigationItems: NavigationItem[];
    loginLink?: string;
    asLink?: "a" | ComponentType<any>;
    generalClassName?: string;
    navItemsClassName?: string;
};

declare type HeaderProps = HeaderMobileProps & HeaderDesktopProps & {
    children?: ReactNode;
};

export declare const HeaderSlim: ({ as, className, hasContainer, display, justifyContent, alignItems, flexWrap, children, }: HeaderSlimProps) => JSX.Element;

declare type HeaderSlimProps = {
    as?: "div" | "header";
    className?: string;
    hasContainer?: boolean;
    display?: CSSProperties["display"];
    justifyContent?: CSSProperties["justifyContent"];
    alignItems?: CSSProperties["alignItems"];
    flexWrap?: CSSProperties["flexWrap"];
    children: React.ReactNode;
} & SpacingProps;

export declare const HeaderTopBanner: ({ asLink, shortTitle, region, className, }: HeaderTopBannerProps) => JSX.Element;

export declare type HeaderTopBannerProps = {
    asLink?: "a" | React.ComponentType<any>;
    shortTitle: React.ReactNode;
    region?: Region;
    className?: string;
};

declare type Heading = {
    id: string;
    text: string;
};

declare type HeadingLevel = "h2" | "h3" | "h4";

declare type HeadingLevel_10 = "h2" | "h3" | "h4";

declare type HeadingLevel_11 = "h2" | "h3" | "h4";

declare type HeadingLevel_12 = "h2" | "h3" | "h4";

declare type HeadingLevel_13 = "h2" | "h3" | "h4";

declare type HeadingLevel_14 = "h2" | "h3" | "h4";

declare type HeadingLevel_2 = "h2" | "h3" | "h4";

declare type HeadingLevel_3 = "h2" | "h3" | "h4";

declare type HeadingLevel_4 = "h2" | "h3" | "h4";

declare type HeadingLevel_5 = "h2" | "h3" | "h4";

declare type HeadingLevel_6 = "h2" | "h3" | "h4";

declare type HeadingLevel_7 = "h2" | "h3" | "h4";

declare type HeadingLevel_8 = "h2" | "h3" | "h4";

declare type HeadingLevel_9 = "h2" | "h3" | "h4";

export declare const HealthProfileSkeleton: () => JSX.Element;

export declare const Home: ({ width, height, className, filled, color, }: IconProps) => JSX.Element;

export declare const HOME_SERVICES_LAYOUTS: {
    readonly LayoutOne: "LayoutOne";
    readonly LayoutTwo: "LayoutTwo";
    readonly LayoutThree: "LayoutThree";
};

export declare const HomeServices: ({ title, description, goToLabel, href, asLink, items, layout, className, }: AggregationItemsProps) => JSX.Element;

declare type IconProps = Pick<ColorProps, "color"> & {
    width?: number;
    height?: number;
    className?: string;
    filled?: boolean;
    onClick?: () => void;
    decorative?: boolean;
};

declare type Image_2 = {
    alt: string;
    src: string;
    title: string;
};

declare type Image_3 = {
    alt: string;
    src: string;
    title: string;
};

export declare const Info: ({ width, height, className, filled, color, decorative, }: IconProps) => JSX.Element;

declare type Info_2 = {
    label: string;
    value: string;
};

declare type Info_3 = {
    label: string;
    value: string;
};

export declare const InfoCardSkeleton: () => JSX.Element;

export declare const InfoModal: ({ open, setOpen, id, title, text }: InfoModalProps) => JSX.Element;

declare type InfoModalProps = {
    open: boolean;
    setOpen: (open: boolean) => void;
    id?: string;
    title: string;
    text: string;
};

export declare const InfoPopup: ({ title, description, isOpen, onClickCloseBtn, className, positionPopUp, }: InfoPopupProps) => JSX.Element | null;

export declare type InfoPopupProps = PropsWithChildren<{
    title: string;
    description: string | React.ReactNode;
    isOpen: boolean;
    onClickCloseBtn?: () => void;
    className?: string;
    positionPopUp?: "left" | "right" | "center";
}>;

declare type Layout = (typeof HOME_SERVICES_LAYOUTS)[keyof typeof HOME_SERVICES_LAYOUTS];

export declare const Lazio: ({ width, height, className, color, }: IconProps) => JSX.Element;

export declare function Link({ title, src, decoration, transform, icon: Icon, asLink, }: Props): JSX.Element;

export declare const ListStructures: ({ width, height, className, }: IconProps) => JSX.Element;

export declare const Loader: ({ loading, className, }: {
    loading?: boolean;
    className?: string;
}) => JSX.Element;

export declare const Login: ({ title, description, loginTitle, loginDescription, buttonLabel, buttonAriaLabel, buttonHref, asImage, region, authSrc, }: LoginProps) => JSX.Element;

export declare type LoginProps = {
    title: React.ReactNode;
    description?: React.ReactNode;
    loginTitle: string;
    loginDescription: React.ReactNode;
    buttonLabel: string;
    buttonAriaLabel: string;
    buttonHref: string;
    asImage?: "img";
    region?: Config["REGION"];
    authSrc?: string;
};

export declare const LOGOS: Record<Region, ComponentType<IconProps>>;

export declare const Marche: ({ width, height, className, color, }: IconProps) => JSX.Element;

export declare const MedicHistory: ({ width, height, className, color, }: IconProps) => JSX.Element;

export declare const ModalsHeader: ({ title, closeButton, onCloseClick, }: ModalsHeaderProps) => JSX.Element;

declare type ModalsHeaderProps = {
    title: string;
    closeButton: string;
    onCloseClick: () => void;
};

export declare const More: ({ width, height, className, filled, color, }: IconProps) => JSX.Element;

export declare const MoreActions: ({ width, height, className, color, }: IconProps) => JSX.Element;

declare type NavigationItem = {
    label: string;
    href: string;
    icon?: ComponentType<any>;
    active?: boolean;
    isNewTab?: boolean;
};

declare type NavigationItem_2 = {
    label: string;
    href: string;
    icon?: React.ComponentType<any>;
    active?: boolean;
    shortLabel?: string;
};

declare type NavigationItem_3 = {
    label: string;
    href: string;
    active?: boolean;
    isNewTab?: boolean;
};

declare type NavigationItem_4 = {
    label: string;
    href: string;
    active?: boolean;
    isNewTab?: boolean;
};

declare type NavigationLabels = {
    closeMenu: string;
    login: string;
};

declare type NavigationLabels_2 = {
    closeMenu: string;
    login: string;
};

export declare const NavList: ({ links, asLink, onClick }: NavListProps) => JSX.Element;

declare type NavListProps = {
    links: {
        value: string;
        href: string;
        icon?: React.ComponentType<any>;
    }[];
    asLink?: "a" | React.ComponentType<any>;
    onClick?: () => void;
};

export declare const NotChecked: ({ width, height, className, color, }: IconProps) => JSX.Element;

declare const Notification_2: ({ width, height, className, color, }: IconProps) => JSX.Element;
export { Notification_2 as Notification }

declare type NotificationIcon = "calendar" | "actions";

export declare const NotificationSettingsSkeleton: () => JSX.Element;

export declare const NotificationsListSkeleton: () => JSX.Element;

export declare const NotificationsSettingsHeader: ({ className, ...props }: TableHeaderProps_2) => JSX.Element;

export declare const Obscured: ({ width, height, className, color, }: IconProps) => JSX.Element;

export declare const Pagination: React_2.FC<PaginationProps>;

export declare interface PaginationProps {
    currentPage: number;
    totalResults: number;
    resultsPerPage: number;
    setCurrentPage: (page: number) => void;
    onPageChange?: (page: number) => void;
    className?: string;
}

declare type PolymorphicProps<E extends ElementType> = {
    as?: E;
} & SpacingProps & Omit<ComponentPropsWithoutRef<E>, keyof SpacingProps>;

declare type PolymorphicProps_2<E extends ElementType> = {
    as?: E;
    md?: BreakpointSpace;
    sm?: BreakpointSpace;
    xs?: BreakpointSpace;
} & SpacingProps & Omit<ComponentPropsWithoutRef<E>, keyof SpacingProps>;

declare type PolymorphicProps_3<E extends ElementType> = {
    as?: E;
    display?: CSSProperties["display"];
    justifyContent?: CSSProperties["justifyContent"];
    alignItems?: CSSProperties["alignItems"];
    flexWrap?: CSSProperties["flexWrap"];
    ref?: React.Ref<HTMLDivElement>;
} & SpacingProps & ColorProps & TypographyProps & Omit<ComponentPropsWithoutRef<E>, keyof SpacingProps | keyof ColorProps | keyof TypographyProps>;

declare type PolymorphicProps_4<E extends ElementType> = {
    as?: E;
    justifyContent?: CSSProperties["justifyContent"];
    alignItems?: CSSProperties["alignItems"];
    flexWrap?: CSSProperties["flexWrap"];
    ref?: React.Ref<HTMLDivElement>;
} & SpacingProps & ColorProps & TypographyProps & Omit<ComponentPropsWithoutRef<E>, keyof SpacingProps | keyof ColorProps | keyof TypographyProps>;

export declare const ProgressBar: ({ closeButton, onCloseClick, title, stepLabel, currentStep, totalSteps, }: DoctorModalHeaderProps) => JSX.Element;

declare type Props = {
    title: string;
    src: string;
    decoration?: string;
    transform?: "uppercase" | "lowercase" | "capitalize" | "none";
    icon?: ElementType;
    asLink?: ElementType;
};

declare type Props_2 = {
    title: default_2.ReactNode;
    subtitle: default_2.ReactNode;
    children: default_2.ReactNode;
    variant: EditorialWidgetVariant;
};

declare type Props_3 = {
    title: string;
    items: CardFileProps[];
    colorTitle?: ColorKeys;
    fontSizeTitle?: TypographyKeys;
};

declare type Props_4 = {
    title: string;
    items: any[];
};

export declare const RadioCard: ({ id, name, value, checked, label, description, onChange, }: RadioCardProps) => JSX.Element;

declare type RadioCardProps = {
    id: string;
    name: string;
    value: string;
    checked: boolean;
    label: string;
    description?: string;
    onChange: (event: React.ChangeEvent<HTMLInputElement>) => void;
};

export declare type Region = "marche" | "lazio" | "nazionale";

export declare type RelatedPeople = {
    birthDate: string;
    firstName: string;
    fiscalCode: string;
    lastName: string;
    relationship: string;
};

declare type RelatedPeopleDropDownProps = {
    size?: "small" | "large";
    items: RelatedPeople[];
    className?: string;
    selectedPerson: RelatedPeople | null;
    setSelectedPerson: (person: RelatedPeople | null) => void;
    placeholder?: string;
    btnText?: string;
};

export declare const RichText: ({ title, description, fontSize, mdFontSize, classNameTitle, children, }: RichTextProps) => JSX.Element;

declare type RichTextProps = PropsWithChildren<{
    title: ReactNode;
    description?: ReactNode;
    links?: SectionLink[];
    asLink?: "a" | ComponentType<any>;
    fontSize?: TypographyKeys;
    mdFontSize?: TypographyKeys;
    classNameTitle?: string;
}>;

export declare const Row: <E extends ElementType = "div">({ as, className, display, justifyContent, alignItems, flexWrap, style, ref, ...rest }: PolymorphicProps_3<E>) => JSX.Element;

declare type ScheduleDay = {
    label: string;
    slots: DayHours[];
};

export declare const Search: ({ btnText, helperText, onChangeValue, value, }: SearchProps_2) => JSX.Element;

export declare const SearchDocument: ({ btnText, helperText, value, items, setValue, }: SearchDocumentProps) => JSX.Element;

export declare type SearchDocumentProps = {
    btnText: string;
    helperText: string;
    value: string;
    items: any;
    setValue: (value: string) => void;
};

export declare function SearchGeneric<T extends object>({ btnText, helperText, mobileHelperText, value, items, setValue, setTypedValue, getSearchField, getDisplayField, onItemSelect, minCharsToSearch, className, }: SearchGenericProps<T>): JSX.Element;

export declare type SearchGenericProps<T extends object> = {
    btnText: string;
    helperText: string;
    mobileHelperText?: string;
    value: string;
    items: T[];
    setValue: (value: string) => void;
    setTypedValue?: (value: string) => void;
    getSearchField: (item: T) => string;
    getDisplayField?: (item: T) => string;
    onItemSelect?: (item: T) => void;
    minCharsToSearch?: number;
    className?: string;
};

export declare type SearchProps = {
    btnText: string;
    helperText: string;
    mobileHelperText?: string;
    value: string;
    items: Structure[];
    setValue: (value: string) => void;
};

declare type SearchProps_2 = {
    btnText: string;
    helperText: string;
    value: string;
    onChangeValue?: (value: string) => void;
};

export declare const SearchService: ({ btnText, helperText, value, items, setValue, }: SearchServiceProps) => JSX.Element;

export declare type SearchServiceProps = {
    btnText: string;
    helperText: string;
    value: string;
    items: Service[];
    setValue: (value: string) => void;
};

export declare const SearchStructure: ({ btnText, helperText, mobileHelperText, value, items, setValue, }: SearchProps) => JSX.Element;

export declare const SearchStructureSkeleton: () => JSX.Element;

export declare const Section: SectionComponent;

declare interface SectionComponent extends FC<SectionProps> {
    Title: typeof Title;
    Description: typeof Description;
}

declare type SectionProps = PropsWithChildren<{
    className?: string;
}>;

export declare const Services: ({ title, description, goToLabel, href, asLink, items, layout, className, }: ServicesProps) => JSX.Element;

export declare const SERVICES_LAYOUTS: {
    readonly LayoutOne: "LayoutOne";
    readonly LayoutTwo: "LayoutTwo";
    readonly LayoutThree: "LayoutThree";
    readonly LayoutFour: "LayoutFour";
};

declare type ServicesLayout = (typeof SERVICES_LAYOUTS)[keyof typeof SERVICES_LAYOUTS];

export declare const ServicesListSkeleton: () => JSX.Element;

export declare type ServicesProps = {
    title: ReactNode;
    description?: ReactNode;
    goToLabel?: string;
    href?: string;
    asLink?: "a" | ComponentType<any>;
    items: any[];
    layout?: ServicesLayout;
    className?: string;
};

export declare const Shape: ({ width, height, className, color, }: IconProps) => JSX.Element;

export declare const ShareLink: ({ width, height, className, color, }: IconProps) => JSX.Element;

declare type SpacingKey = "x4" | "x8" | "x12" | "x16" | "x20" | "x24" | "x28" | "x32" | "x36" | "x40" | "x44" | "x48" | "x52" | "x56" | "x60" | "x64" | "x68" | "x72" | "x76" | "x80" | "x84" | "x88" | "x92" | "x96" | "x100" | "x104";

declare type SpacingProps = {
    gap?: SpacingKey;
    m?: SpacingKey;
    mx?: SpacingKey;
    my?: SpacingKey;
    mt?: SpacingKey;
    mr?: SpacingKey;
    mb?: SpacingKey;
    ml?: SpacingKey;
    p?: SpacingKey;
    px?: SpacingKey;
    py?: SpacingKey;
    pt?: SpacingKey;
    pr?: SpacingKey;
    pb?: SpacingKey;
    pl?: SpacingKey;
    br?: SpacingKey;
    "br-t"?: SpacingKey;
    "br-r"?: SpacingKey;
    "br-b"?: SpacingKey;
    "br-l"?: SpacingKey;
    "min-h"?: SpacingKey;
    "min-w"?: SpacingKey;
    "max-h"?: SpacingKey;
    "max-w"?: SpacingKey;
};

export declare const Spinner: () => JSX.Element;

export declare const SuggestedServices: ({ title, description, goToLabel, href, asLink, items, className, }: SuggestedServicesProps) => JSX.Element;

export declare type SuggestedServicesProps = {
    title: ReactNode;
    description?: ReactNode;
    goToLabel?: string;
    href?: string;
    asLink?: "a" | ComponentType<any>;
    items: any[];
    className?: string;
};

export declare const Support: ({ width, height, className }: IconProps) => JSX.Element;

export declare const SupportBanner: ({ cta, bannerType, title, description, titleTag: TitleTag, href, icon, linkText, mainLayout, className, classNameTitle, classNameDescription, handleAction, }: SupportBannerProps) => JSX.Element;

declare type SupportBannerProps = {
    cta: ctaLevel;
    bannerType: "filled" | "outline";
    title: string;
    description?: string;
    titleTag: HeadingLevel_5;
    href?: string | string[];
    icon?: boolean;
    linkText?: string | string[];
    mainLayout?: "layout1" | "layout2";
    className?: string;
    classNameTitle?: string;
    classNameDescription?: string;
    handleAction?: () => void;
};

export declare const Switch: ({ id, label, checked, setValue, name, disabled, }: SwitchProps) => JSX.Element;

declare type SwitchProps = {
    id?: string;
    label?: string;
    checked?: boolean;
    name?: string;
    disabled?: boolean;
    setValue: (name: string, value: boolean) => void;
};

export declare const TabBar: ({ navigatonItems, asLink, className, }: TabBarProps) => JSX.Element;

export declare type TabBarProps = {
    navigatonItems: NavigationItem_2[];
    asLink?: "a" | React.ComponentType<any>;
    className?: string;
};

declare type TabItem = {
    label: string;
    disabled?: boolean;
};

export declare const Table: React_2.ForwardRefExoticComponent<TableProps & React_2.RefAttributes<HTMLTableElement>>;

export declare const TableBody: React_2.ForwardRefExoticComponent<TableBodyProps & React_2.RefAttributes<HTMLTableSectionElement>>;

export declare interface TableBodyProps extends React_2.HTMLAttributes<HTMLTableSectionElement> {
    className?: string;
    children?: React_2.ReactNode;
}

export declare const TableCell: React_2.ForwardRefExoticComponent<TableCellProps & React_2.RefAttributes<HTMLTableCellElement>>;

export declare interface TableCellBaseProps extends Omit<React_2.TdHTMLAttributes<HTMLTableCellElement>, "content"> {
    type?: "double-line" | "action";
}

export declare interface TableCellProps extends TableCellBaseProps {
    content: string | DoubleLineData | ActionData;
}

export declare const TableHead: React_2.ForwardRefExoticComponent<TableHeadProps & {
    config: ColumnConfig;
    sortConfig: {
        key: string;
        direction: "asc" | "desc";
    };
    onSort?: () => void;
} & React_2.RefAttributes<HTMLTableCellElement>>;

export declare const TableHeader: React_2.ForwardRefExoticComponent<TableHeaderProps & React_2.RefAttributes<HTMLTableSectionElement>>;

export declare interface TableHeaderProps extends React_2.HTMLAttributes<HTMLTableSectionElement> {
    className?: string;
    children?: React_2.ReactNode;
}

declare type TableHeaderProps_2 = {
    className?: string;
};

export declare interface TableHeadProps extends React_2.ThHTMLAttributes<HTMLTableCellElement> {
    className?: string;
    children?: React_2.ReactNode;
}

export declare const TableOfContents: ({ title, headings, titleTag: TitleTag, isOpen, onToggle, }: TableOfContentsProps) => JSX.Element;

declare type TableOfContentsProps = {
    title: string;
    headings: Heading[];
    titleTag?: HeadingLevel_14;
    isOpen?: boolean;
    onToggle?: () => void;
};

export declare interface TableProps extends React_2.TableHTMLAttributes<HTMLTableElement> {
    className?: string;
    columns: ColumnConfig[];
    data: TableRowData[];
    pagination?: boolean;
    initialCurrentPage?: number;
    resultsPerPage?: number;
    defaultSortDirection?: "asc" | "desc";
}

export declare const TableRow: React_2.ForwardRefExoticComponent<TableRowProps & React_2.RefAttributes<HTMLTableRowElement>>;

export declare interface TableRowData {
    [key: string]: string | DoubleLineData | ActionData;
}

export declare interface TableRowProps extends React_2.HTMLAttributes<HTMLTableRowElement> {
    className?: string;
    children?: React_2.ReactNode;
}

export declare const TableSkeleton: () => JSX.Element;

export declare const TabsGlossary: ({ CTA, navigationItems, children, activeIndex, onTabChange, actions, }: TabsGlossaryProps) => JSX.Element;

declare type TabsGlossaryProps = {
    CTA?: "link" | "primary";
    navigationItems: TabItem[];
    activeIndex: number;
    onTabChange: (index: number) => void;
    actions?: ActionItem[];
    children?: ReactNode;
};

export declare const Tag: React.FC<TagProps>;

declare interface TagProps {
    label: string;
}

export declare const Tags: ({ title, items }: Props_4) => JSX.Element;

export declare const TagsGroup: ({ topics }: TagsProps) => JSX.Element;

declare type TagsProps = {
    topics?: Array<string>;
};

declare const Title: ({ className, fs, mdFs, color, as, children, }: TitleProps) => JSX.Element;

declare type TitleProps = {
    className?: string;
    fs?: TypographyKeys;
    mdFs?: TypographyKeys;
    color?: ColorKeys;
    as?: "h2" | "h3" | "h4" | "h5" | "h6";
    children: ReactNode;
};

export declare const TitleSection: ({ action1, action2, mainButton, secondaryButton, titleSection, classNameTitle, isMoreOption, handleMoreOption, titleTag: TitleTag, }: TitleSectionProps) => JSX.Element;

declare type TitleSectionProps = PropsWithChildren<{
    action1?: ReactNode;
    action2?: ReactNode;
    mainButton?: ReactNode;
    secondaryButton?: ReactNode;
    titleSection: string;
    classNameTitle?: string;
    isMoreOption?: boolean;
    handleMoreOption?: () => void;
    titleTag?: "h2" | "h3" | "h4";
}>;

export declare const Tool: ({ width, height, className, color, }: IconProps) => JSX.Element;

export declare const TriangleDown: ({ width, height, className, filled, color, decorative, }: IconProps) => JSX.Element;

export declare const TriangleUp: ({ width, height, className, filled, color, decorative, }: IconProps) => JSX.Element;

declare type TypographyKeys = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "custom";

declare type TypographyProps = {
    fs?: TypographyKeys;
    fw?: "regular" | "medium" | "semibold" | "bold";
};

declare type Variant = "primary" | "secondary";

declare type Variant_2 = "left-line" | "blue-box" | "light-bg";

declare type Variant_3 = "info" | "warning" | "danger" | "success";

export declare const VideoPlayer: ({ btnText, sizeComp, titleTag: TitleTag, image, asImage, }: VideoPlayerProps) => JSX.Element;

declare type VideoPlayerProps = {
    btnText: string;
    sizeComp?: "small" | "medium" | "large";
    titleTag: HeadingLevel_6;
    image?: Image_3;
    asImage?: "img";
};

export declare const Visible: ({ width, height, className, color, }: IconProps) => JSX.Element;

declare type WeekDaysMap = Record<keyof OpeningHours, string>;

export declare const WhatDoYouNeed: ({ title, description, links, asLink, }: WhatDoYouNeedProps) => JSX.Element;

declare type WhatDoYouNeedProps = PropsWithChildren<{
    title: ReactNode;
    description?: ReactNode;
    links: EnhancedSectionLink[];
    asLink?: "a" | ComponentType<any>;
}>;

export declare const World: ({ width, height, className, color, }: IconProps) => JSX.Element;

export { }