import { AggregationPage } from '@anoki/fse-common/dist';
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 { FeedBackProps } from '@anoki/fse-common';
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';
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';
import { LinkTypeEnum } from '@anoki/fse-common/dist';
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 as Service_2 } from '@anoki/fse-common';
import { SettingFooterLink } from '@anoki/fse-common/dist';
import { Structure } from '@anoki/fse-common';

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

export declare const AccordionContainer: ({ title, toggleableLabel, children, defaultOpen }: Props) => JSX.Element;

export declare const AccordionStepper: default_2.FC<AccordionStepperProps>;

declare interface AccordionStepperProps {
    mainTitle?: string;
    toggleStepsLabels: ToggleLabel;
    toggleSingleStepsLabel: ToggleLabel;
    steps: StepData[];
}

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

declare interface ActionBannerProps {
    title: string;
    description: string | default_2.ReactNode;
    variant?: ActionBannerVariantTypes;
    link?: WithLinkType<LinkTypeEnum>;
    withIcon?: boolean;
    icon?: IconInfoType;
    firstAction?: WithLinkType<LinkTypeEnum>;
    secondAction?: WithLinkType<LinkTypeEnum>;
    maxWidth?: string;
    minHeight?: string;
    linkPositionFixed?: boolean;
}

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

export declare type ActionBannerVariantTypes = GetValues<typeof ActionBannerVariantEnum>;

export declare interface ActionData {
    label: string | React_2.ReactNode;
    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, justifyContent, alignItems, children, }: ActionIconTextProps) => JSX.Element;

export 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?: "right" | "top" | "bottom" | "left" | undefined;
    justifyContent?: CSSProperties["justifyContent"];
    alignItems?: CSSProperties["alignItems"];
    children?: ReactNode;
}>;

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

declare type ActionItem_2 = 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, decorative, ariaLabel, }: IconProps) => JSX.Element;

export declare const ActionsPopup: ({ isOpen, onClickCloseBtn, className, actions, children, parentRef, }: ActionsPopupProps) => JSX.Element | null;

export declare type ActionsPopupProps = PropsWithChildren<{
    isOpen: boolean;
    onClickCloseBtn?: () => void;
    className?: string;
    actions?: React.ReactNode[];
    parentRef?: React.RefObject<HTMLElement>;
}>;

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

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

declare type AddNewModalProps = {
    open: boolean;
    overrideClassNames?: string;
    setOpen: (open: boolean) => void;
    children: ReactNode;
    role?: "dialog" | "alertdialog";
};

export declare const AggregationItemCard: ({ category, tags, totalTags, image, title, titleTag: TitleTag, href, isExternal, asImage, className, handleOnClick, }: AggregationItemCardProps) => JSX.Element;

declare type AggregationItemCardProps = {
    category?: {
        type: string;
        published_at: string;
    };
    tags?: Array<TagProps>;
    totalTags?: number;
    image?: Image_2;
    title: string;
    titleTag?: HeadingLevel;
    href?: string;
    description?: string | ReactNode;
    description2?: string;
    isExternal?: boolean;
    asImage?: "img";
    asLink?: "a" | ComponentType<any>;
    className?: string;
    classNameTitle?: string;
    handleOnClick?: (e: MouseEvent_2<HTMLAnchorElement>) => void;
};

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

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

export declare const AlertBanner: ({ type, title, children }: Props_2) => JSX.Element;

declare type AlertDialogProps = {
    isOpen: boolean;
    onClose: () => void;
    title?: string;
    description?: string;
    confirmBtnLabel?: string;
    role?: "alertdialog" | "dialog";
    variant?: "default" | "error" | "success";
};

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

export declare type AlertProps = {
    title: string;
    description: string | default_2.ReactNode;
    subtitle: string | default_2.ReactNode;
    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, decorative, ariaLabel, }: IconProps) => JSX.Element;

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

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

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

declare type ArrowLinkAsLinkProps = BaseArrowLinkProps & {
    href: string;
    asLink?: "a" | ElementType;
    onClick?: never;
    type?: never;
    asButton?: never;
    arrowVisible?: boolean;
};

declare type ArrowLinkProps = ArrowLinkAsLinkProps | ArrowLinkAsButtonProps;

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

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

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

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

export declare const AuthorBlock: ({ publishedLabel, publishedDate, readingTimeLabel, readingTimeValue, readingMinuteLabel, }: CardAuthorProps) => JSX.Element;

export declare const AuthorWithImage: ({ data, ImageComponent, imageProps, variant, publishedLabel, readingTimeLabel, readingMinuteLabel, tagsLabelTitle, shareLabel, copyLinkLabel, copiedTextLabel, isPreview, modeAuthenticated, eventCardDescriptionTitle, tags, }: AuthorWithImageProps) => JSX.Element;

declare interface AuthorWithImageCommonProps {
    publishedLabel?: string;
    readingTimeLabel?: string;
    readingMinuteLabel?: string;
    tagsLabelTitle?: string;
    shareLabel?: string;
    copyLinkLabel?: string;
    copiedTextLabel?: string;
    ImageComponent?: "img" | React.ComponentType<any>;
    imageProps?: Record<string, any>;
    isPreview?: boolean;
    modeAuthenticated?: boolean;
    eventCardDescriptionTitle?: string;
    tags?: string[];
}

export declare type AuthorWithImageProps = ServiceProps | EventProps;

export declare const AutoplayButton: ({ autoplay, toggleAutoPlay, }: AutoplayButtonProps) => JSX.Element;

export declare type AutoplayButtonProps = {
    autoplay: boolean;
    toggleAutoPlay: () => void;
};

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 const Avatars: default_2.FC<AvatarsProps>;

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

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

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

declare type AvatarsProps = {
    users: RelatedPeople[];
    maxVisible?: number;
    size?: number;
};

export declare const BannerNewPortal: default_2.FC<BannerNewPortalProps>;

export declare type BannerNewPortalProps = {
    title: string;
    subtitle: string;
    link: Link_2;
    onClose?: () => void;
};

declare type BaseArrowLinkProps = {
    isExternal?: boolean;
    fs?: TypographyKeys;
    children: default_2.ReactNode;
    className?: string;
    iconPosition?: "left" | "right";
};

declare type BaseButtonProps = {
    children: React_2.ReactNode;
    icon?: CommonIconsType;
    variant?: ButtonVariant;
    variantBg?: string;
    bg?: ColorKeys;
    textColor?: ColorKeys;
    border?: ColorKeys;
    size?: ButtonSize;
    className?: string;
    disabled?: boolean;
    loading?: boolean;
    form?: string;
    rel?: string;
    target?: string;
    isExternal?: boolean;
    fwClassName?: "fw-bold" | "fw-semibold" | "fw-normal";
};

/**
 * @deprecated This component is deprecated and will be removed in a future version.
 * Please use the new modal system instead.
 */
export declare const BaseModal: {
    ({ open, setOpen, overrideClassNames, stacked, overrideBaseModalClassName, id, role, children, }: BaseModalProps): JSX.Element;
    Header: ({ labels, onCloseClick, onBackClick, showBackButton, children, classNameModalHeader, }: {
        labels?: {
            closeButton?: string;
            backButton?: string;
        };
        onCloseClick?: () => void;
        onBackClick?: () => void;
        showBackButton?: boolean;
        children?: default_2.ReactNode;
        classNameModalHeader?: string;
    }) => JSX.Element;
    HeaderV2: ({ labels, onCloseClick, children, classNameModalHeader, }: {
        labels?: {
            closeButton?: string;
            backButton?: string;
        };
        onCloseClick?: () => void;
        onBackClick?: () => void;
        showBackButton?: boolean;
        children?: default_2.ReactNode;
        classNameModalHeader?: string;
    }) => JSX.Element;
    HeaderBack: ({ onBackClick, backButton, children, }: {
        onBackClick: () => void;
        backButton: string;
        children?: default_2.ReactNode;
    }) => JSX.Element;
    Content: ({ className, children, classNameModalContent, }: {
        className?: string;
        classNameModalContent?: string;
        children: default_2.ReactNode;
    }) => JSX.Element;
    Footer: ({ children, className, }: {
        className?: string;
        children: default_2.ReactNode;
    }) => JSX.Element;
};

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

declare type BasePositionLinkProps = {
    isExternal?: boolean;
    fs?: TypographyKeys;
    children: default_2.ReactNode;
    className?: string;
    iconPosition?: "left" | "right";
};

declare type BaseProps = {
    title: ReactNode;
    subtitle?: ReactNode;
    items: OperatorCardTableItem[];
    className?: string;
    disabled?: boolean;
};

declare type BaseServiceProps = {
    name: string;
    previewImageUrl?: string;
    previewImageTitle?: string;
    updatedBy?: {
        name?: string;
        surname?: string;
    };
    updatedAt?: string;
    readingTime?: number;
};

declare type BaseServiceProps_2 = {
    name: string;
    previewImageUrl?: string;
    previewImageTitle?: string;
    previewImageTextAlign?: string;
    previewImageTextColor?: string;
    updatedBy?: {
        name?: string;
        surname?: string;
    };
    updatedAt?: string;
    readingTime?: number;
};

export declare function Blockquote({ text, author, variant, }: BlockquoteProps): JSX.Element;

export declare type BlockquoteProps = {
    text: string | React.ReactNode;
    author: string;
    variant?: BlockquoteVariantEnum;
};

export declare enum BlockquoteVariantEnum {
    LEFTLINE = "left-line",
    BLUEBOX = "blue-box",
    LIGHTBG = "light-bg"
}

export declare const BlurImageSlide: ({ ImageComponent, tagsLabelTitle, gradientStyle, withShadow, ...slide }: BlurImageSlideProps) => JSX.Element;

declare type BlurImageSlideProps = {
    tagsLabelTitle?: SliderProps["tagsLabelTitle"];
    ImageComponent: React.ComponentType<any> | "img";
    gradientStyle?: CSSProperties;
    withShadow?: boolean;
} & Slide;

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, variantBg, bg, textColor, border, size, className, disabled, loading, onClick, type, form, asLink, href, isExternal, target, rel, icon, fwClassName, ...props }: ButtonProps) => JSX.Element;

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

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

declare type ButtonProps = ButtonAsButtonProps | ButtonAsLinkProps;

declare type ButtonProps_2 = {
    children: ReactNode;
    variant?: ButtonVariant_2;
    disabled?: boolean;
    loading?: boolean;
    onClick?: (e?: default_2.MouseEvent<HTMLButtonElement>) => void;
    type?: "button";
};

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

export declare const ButtonV2: ({ children, variant, disabled, loading, onClick, type, ...props }: ButtonProps_2) => JSX.Element;

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

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

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

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

export declare function Callout({ title, description, variant, }: CalloutProps): JSX.Element;

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

export declare enum CalloutVariantEnum {
    INFO = "info",
    WARNING = "warning",
    DANGER = "danger",
    SUCCESS = "success"
}

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

export declare const CardBanner: ({ actions, description, title, link, firstStatusLabel, secondStatusLabel, personalStatusLabel, }: Props_3) => JSX.Element;

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

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

export declare const CardClinicalAction: ({ title, subtitle, information, statusLabel, statusVariant, buttonLabel, buttonVariant, onButtonClick, toggleOnButton, toggleLabels, isOpen, deleteLabel, onDelete, deleteButtonPosition, externalLink, asLink, className, classNameTitle, }: CardClinicalActionProps) => JSX.Element;

declare type CardClinicalActionProps = {
    title: string;
    subtitle?: string;
    information?: {
        label: string;
        value: string | number;
    }[];
    statusLabel?: string;
    statusVariant?: "default" | "warning" | "success" | "error";
    buttonLabel?: string;
    buttonVariant?: "primary" | "secondary";
    onButtonClick?: () => void;
    toggleOnButton?: boolean;
    toggleLabels?: {
        open: string;
        close: string;
    };
    isOpen?: boolean;
    deleteLabel?: string;
    onDelete?: () => void;
    deleteButtonPosition?: "left" | "right";
    externalLink?: {
        title: string;
        href: string;
    };
    asLink?: "a" | default_2.ComponentType<any>;
    className?: string;
    classNameTitle?: string;
};

export declare const CardClinicalData: ({ information, className, clinicalCode, isOpen, hideArrow, onToggle, hasBorder, clinicalLabel, label, classNameTitle, deleteLabel, onDelete, deleteButtonPosition, statusIndex, }: CardClinicalDataProps) => JSX.Element;

declare type CardClinicalDataProps = {
    information?: {
        label: string;
        value: string;
    }[];
    className?: string;
    clinicalCode?: string;
    isOpen?: boolean;
    hideArrow?: boolean;
    onToggle?: () => void;
    hasBorder?: boolean;
    clinicalLabel?: string;
    label?: string;
    classNameTitle?: string;
    deleteLabel?: string;
    onDelete?: () => void;
    deleteButtonPosition?: "left" | "right";
    statusIndex?: 0 | 1 | 2;
};

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, officesInfoV2, officeLabel, }: CardDoctorInfoProps) => JSX.Element;

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

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

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

declare type CardDocumentProps = {
    eventNumber?: string;
    date?: string | number;
    documentType?: string;
    documentTitle: string;
    label?: string;
    subtitle?: string;
    showFavorite?: boolean;
    favoriteLabel?: string;
    handleFavoriteClick?: () => void;
    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>;
    showBottomActions?: boolean;
    showIsHidden?: boolean;
    isLoadingVisibility?: boolean;
    obscuredLabel?: string;
};

export declare const CardEventSlim: default_2.FC<EventCardProps>;

export declare const CardFaqCTA: default_2.FC<CardFaqCTAProps>;

declare interface CardFaqCTAProps {
    type: CardFaqCTAType;
    title: string;
    description?: string | ReactNode;
    link: string;
    openModal?: CallableFunction;
    isExternal?: boolean;
    asLink?: "a" | default_2.ComponentType<any>;
    icon?: IconInfoType;
}

export declare enum CardFaqCTAType {
    FAQ = "FAQ",//it has a title a description and a link
    CTA = "CTA",//it has a title and a link
    CTAICON = "CTAICON"
}

export declare function CardFile({ title, description, issued_at, file, action, asLink, goToLink, }: 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;
    issued_at_position?: "top" | "bottom";
    file?: {
        type: string;
        size: string;
    };
    action: {
        type: CardFileActionTypeTypes;
        link: Link_3;
    };
    asLink?: "a" | ElementType;
    goToLink?: Link_3;
};

export declare const CardInfoDoctorModal: {
    ({ open, overrideClassNames, overrideBaseModalClassName, setOpen, children, role, }: CardInfoDoctorModalProps): 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;
};

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

export declare const CardMap: ({ id, title, titleTag: TitleTag, href, description, isExternal, asLink, className, plainAddress, showGoToLabel, goToLabel, setSelectedCard, addressLabel, addressLabelTitleTag: AddressLabelTitleTag, }: CardMapProps) => JSX.Element;

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

declare type CardMapDoctorProps = {
    titleTag: HeadingLevel;
    availableLabel: string;
    specialization?: string;
    addressLabel?: string;
    className?: string;
    doctor: GeneralPractitionerResponse;
    setSelectedCard?: (id: string) => void;
    keepSelectionOnNavigation?: boolean;
    ctaTitle?: string;
    ctaAction?: () => void;
};

declare type CardMapDoctorProps_2 = {
    doctorCode: string;
    titleTag: HeadingLevel;
    title: string;
    specialization?: string;
    tag?: string;
    officeAddressLabel?: string;
    officeAddress?: string;
    asLink?: "a";
    className?: string;
    isActive: boolean;
    setSelectedDoctorCode: (code?: string) => void;
    keepSelectionOnNavigation?: boolean;
    ctaTitle?: string;
    ctaAction?: () => void;
};

export declare const CardMapDoctorV2: ({ titleTag: TitleTag, title, specialization, tag, officeAddressLabel, officeAddress, className, doctorCode, setSelectedDoctorCode, keepSelectionOnNavigation, ctaTitle, ctaAction, isActive, }: CardMapDoctorProps_2) => JSX.Element;

declare type CardMapProps = {
    id: string;
    title: string;
    titleTag: HeadingLevel;
    href?: string;
    description?: string;
    showGoToLabel?: boolean;
    goToLabel?: string;
    isExternal?: boolean;
    showIcon?: boolean;
    asLink?: "a";
    className?: string;
    plainAddress?: string;
    setSelectedCard?: (id: string) => void;
    addressLabel?: string;
    addressLabelTitleTag?: HeadingLevel;
};

export declare const CardNotification: ({ type, onClickEdit, onClickRightManage, rightManageTitle, goToDetailsTitle, 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_2;
    onClickEdit?: () => void;
    onClickManage?: () => void;
    onClickGoToDetails?: () => void;
    showExpired?: boolean;
    buttonMaxWidth?: boolean;
    onClickRightManage?: () => void;
    rightManageTitle?: string;
    goToDetailsTitle?: string;
};

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;
    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 CardPaymentDocument: ({ headerText, beforeTitle, title, subtitle, footer, isLoading, asLink, }: CardPaymentDocumentProps) => JSX.Element;

declare type CardPaymentDocumentProps = {
    headerText?: string;
    beforeTitle?: {
        leftText?: string;
        rightBadgeText?: string;
        rightBadgeColor?: string;
    };
    title?: string;
    subtitle?: string | React.ReactNode;
    footer?: {
        descriptionText?: string | React.ReactNode;
        downloadDoc?: {
            label?: string;
            clickCta?: () => void;
        };
        ctaRight?: {
            label?: string;
            href?: string;
        };
    };
    isLoading?: boolean;
    asLink?: "a" | ComponentType<any>;
};

export declare const CardPreview: default_2.FC<CardPreviewProps>;

export declare interface CardPreviewProps {
    variant?: CardPreviewVariant;
    sectionTitle?: string;
    imageUrl?: string;
    title: string | default_2.ReactNode;
    description: string | default_2.ReactNode;
    link: Link_2;
    asLink?: "a" | default_2.ComponentType<any>;
    topic?: string;
    date?: string;
}

export declare enum CardPreviewVariant {
    WITH_TOPIC_DATE = "withTopicDate",
    NO_TOPIC_DATE = "noTopicDate"
}

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;
    footer?: React.ReactNode;
};

export declare const CardScreening: ({ title, infobox, badge, date, address, description, footer, isLoading, asLink, }: CardScreeningProps) => JSX.Element;

declare type CardScreeningProps = {
    title: string;
    infobox?: string;
    badge?: {
        text?: string;
        color?: string;
    };
    date?: {
        label: string;
        value: string;
    };
    address?: {
        label: string;
        value: string;
    };
    description?: string;
    footer?: {
        ctaLeft?: {
            label?: string;
            clickCta?: () => void;
        };
        ctaRight?: {
            label?: string;
            href?: string;
        };
    };
    isLoading?: boolean;
    asLink?: "a" | ComponentType<any>;
};

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

declare type CardSelectDoctorProps = {
    id: string;
    title: string;
    titleTag?: HeadingLevel;
    href?: string;
    description?: string;
    isExternal?: boolean;
    showIcon?: boolean;
    asLink?: "a";
    className?: string;
    setSelectedCard?: (id?: string) => void;
    description2?: string;
    isActive: boolean;
    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: HeadingLevel;
    asLink?: "a" | ComponentType<any>;
    className?: string;
    iconType?: "icon1" | "icon2" | "icon3";
};

export declare const CardTable: ({ columns, sortConfig, data, onSortChange, }: CardTableProps) => JSX.Element;

export declare type CardTableProps = {
    columns: ColumnConfig[];
    data: TableRowData;
    sortConfig: {
        key: string;
        direction: "asc" | "desc";
    } | null;
    onSortChange?: (key: string, direction: "asc" | "desc") => void;
};

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

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

export declare function Carousel({ title, children, type, linkHref, linkLabel, asLink, }: CarouselProps): JSX.Element;

declare type CarouselProps = {
    title?: string;
    children?: Array<ReactNode>;
    type?: "default" | "sectionHome";
    linkHref?: string;
    linkLabel?: string;
    asLink?: React.ElementType;
};

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

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

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

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

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

/**
 * @deprecated This component is deprecated and will be removed in a future version.
 * Please use the new modal system instead.
 */
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, mainLabel, regionLabel, }: ChangeRelatedCardProps) => JSX.Element;

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

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

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

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

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

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

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

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

export declare type ChipItem = {
    value: string;
    label: string;
};

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

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

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

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

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

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

export declare const Col: <E extends ElementType = "div">({ as, className, justifyContent, alignItems, flexWrap, ref, style, ...rest }: PolymorphicProps<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" | "blue-15" | "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";
    scope?: "col" | "row" | "colgroup" | "rowgroup";
}

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

export declare function CommunicationContents({ title, elements, total, totalLabels, handleLoadMore, loading, showMoreTitle, noResultsLabel, }: CommunicationContentsProps): JSX.Element;

export declare function CommunicationContentsHome({ sectionId, title, elements, loading, noResultsLabel, linkHref, linkLabel, asLink, }: CommunicationContentsHomeProps): JSX.Element;

export declare type CommunicationContentsHomeProps = {
    sectionId?: string;
    title: string;
    elements: any[];
    loading?: boolean;
    noResultsLabel?: string;
    linkHref?: string;
    linkLabel?: string;
    asLink?: React.ElementType;
};

export declare type CommunicationContentsProps = {
    sectionId?: string;
    title: string;
    elements: any[];
    total: number;
    totalLabels?: {
        first: string;
        middle: string;
        end: string;
    };
    loading?: boolean;
    handleLoadMore: () => void;
    showMoreTitle?: string;
    noResultsLabel?: string;
};

export declare const CommunicationContentsSkeleton: ({ cardsCount, }: CommunicationContentsSkeletonProps) => JSX.Element;

declare type CommunicationContentsSkeletonProps = {
    cardsCount?: number;
};

export declare const CommunicationSearch: ({ btnText, helperText, value, loading, items, emptyLabel, setValue, setSelectedElement, }: CommunicationSearchProps) => JSX.Element;

export declare type CommunicationSearchProps = {
    btnText: string;
    helperText?: string;
    value: string;
    items: Suggestion[];
    loading?: boolean;
    emptyLabel?: string;
    setValue: (value: string) => void;
    setSelectedElement: (value: Service_2) => void;
};

export declare const CommunicationSearchSection: ({ title, searchProps, }: Props_15) => JSX.Element;

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

export declare const Confirm: ({ width, height, className, color, decorative, ariaLabel, }: 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, containerClass, ...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"];
    containerClass?: string;
} & SpacingProps;

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

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

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

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

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

declare type CTAType = {
    label: string;
    href: string;
};

export declare const DatePicker: ({ label, value, maxValue, minValue, className, disabled, onClick, onChange, error, required, id, autoComplete, }: 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;
    autoComplete?: "off";
};

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 DeclarantsSelect: ({ size, items, className, selectedItem, setSelectedItem, placeholder, }: DeclarantsSelectProps) => JSX.Element;

declare type DeclarantsSelectProps = {
    size?: "small" | "large";
    items: IncomeBasedDeclarant[];
    className?: string;
    selectedItem: string | null;
    setSelectedItem: (item: string | null) => void;
    placeholder?: string;
    btnText?: string;
};

export declare const DelegateCard: ({ id, isSelected, title, subtitle, region, relation, isMe, showRegion, setSelectedCard, className, labelRelation, labelRegion, labelRecord, }: 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;
    labelRelation?: string;
    labelRegion?: string;
    labelRecord?: string;
};

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

export declare function DelegationHomeBanner({ users, title, linkLabel, onChangeProfileClick, }: HomeBannerProps): JSX.Element;

export declare const DeleteTrash: ({ width, height, className, fillColor, decorative, ariaLabel, }: DeleteTrashProps) => JSX.Element;

declare interface DeleteTrashProps extends IconProps {
    className?: string;
}

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

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

export declare const Divider: ({ direction, bg, className, }: DividerProps) => JSX.Element;

declare type DividerProps = Pick<ColorProps, "bg"> & {
    direction?: "horizontal" | "vertical";
    className?: string;
};

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

/**
 * @deprecated This component is deprecated and will be removed in a future version.
 * Please use the new modal system instead.
 */
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, overrideBaseModalClassName, role, }: 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;
    onlyTitle?: boolean;
}>;

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

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

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

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

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

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

export declare const Documents: ({ title, description, items }: Props_9) => 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, accept, }: 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;
    actionText?: string;
    className?: string;
    classNameTitle?: string;
    classNameDescription?: string;
    id?: string;
    name?: string;
    fileSizeLabel?: string;
    removeLabel?: string;
    accept?: string;
}

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

export declare const Download: ({ width, height, className, color, decorative, ariaLabel, }: 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 function EditorialWidget({ title, children, subtitle, variant, maxWidth, }: EditorialWidgetProps): JSX.Element;

export declare type EditorialWidgetProps = {
    title?: default_2.ReactNode;
    subtitle?: default_2.ReactNode;
    children?: default_2.ReactNode;
    variant: EditorialWidgetVariantEnum;
    maxWidth?: string;
};

export declare enum EditorialWidgetVariantEnum {
    LIGHT = "light",
    EVIDENCE = "evidence",
    DEFAULT = "default"
}

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

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

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

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

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

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

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

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

export declare const ErrorExagon: ({ width, height, className, decorative, ariaLabel, }: ErrorExagonProps) => JSX.Element;

declare interface ErrorExagonProps extends IconProps {
    className?: string;
}

declare type Event_2 = BaseServiceProps & {
    eventCardTitle?: string;
    eventCardDescription?: string;
    eventTitle?: string;
    eventDescriptionTitle?: string;
    eventDescription?: string;
    tags?: string[];
};

declare type Event_3 = BaseServiceProps_2 & {
    eventCardTitle?: string;
    eventCardDescription?: string | React.ReactNode;
    eventTitle?: string;
    eventDescriptionTitle?: string;
    eventDescription?: string;
    tags?: string[];
};

declare interface EventCardProps {
    type?: string;
    title: string;
    location?: string;
    date: string;
    link?: string;
    asLink?: "a" | default_2.ComponentType<any>;
}

declare type EventProps = {
    data: Event_2;
    variant: "event";
} & AuthorWithImageCommonProps;

declare type EventProps_2 = {
    data: Event_3;
    variant: "event";
} & HeroContentCardCommonProps;

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

declare type ExpandableProps = BaseProps & {
    variant: "expandable";
    children?: ReactNode;
    actionLabel?: {
        moreInfo?: string;
        lessInfo?: string;
    };
    onAction?: () => void;
};

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

export declare type FaqItem = {
    key?: string;
    type: CardFaqCTAType;
    title: string;
    description?: string;
    link?: string;
    isExternal?: boolean;
    icon?: IconInfoType;
};

export declare const FaqSections: ({ title, description, items, colorTitle, fontSizeTitle, handleOpenModal, }: Props_16) => JSX.Element;

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

export declare const FeaturedCard: ({ sectionTitle, cardTitle, image, description, cta, cardFormat, asLink, asImage, }: FeaturedCardProps) => JSX.Element;

export declare enum FeaturedCardFormatType {
    LANDSCAPE = "landscape",
    SQUARE = "square"
}

declare type FeaturedCardProps = {
    sectionTitle?: string;
    cardTitle: string;
    image?: Image_4;
    description?: string | ReactNode;
    cta: CTAType;
    cardFormat?: FeaturedCardFormatType;
    asLink?: "a" | ComponentType<any>;
    asImage?: "img" | ComponentType<any>;
};

export declare function Feedback({ question, rating, questions, onSend, buttons, maxCharactersMessage, successMessage, errorMessage, loadingMessage, isLoading, hasError, openAnswerPlaceholder, }: FeedBackProps): JSX.Element;

export declare function FeedbackSection({ section: { feedback, sectionId }, }: FeedbackSectionProps): JSX.Element;

declare type FeedbackSectionProps = {
    section: {
        feedback: FeedBackProps;
        sectionId?: string;
    };
};

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

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

export declare type FilterDropDownItem = {
    label: string;
    value: string;
};

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

export declare const FilterDropDownV2: ({ items, className, label, value, setValue, }: FilterDropDownV2Props) => JSX.Element;

export declare type FilterDropDownV2Item = {
    label: string;
    value: string;
};

declare type FilterDropDownV2Props = {
    items: FilterDropDownV2Item[];
    className?: string;
    value?: string;
    label?: string;
    setValue: (filter: string) => void;
};

declare type FilterItem = {
    id: string;
    label: string;
    checked: boolean;
};

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

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

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

export declare const FilterSearchSection: ({ items, selectedItems, onChange, searchPlaceholder, canMultiple, }: FilterSearchSectionProps) => JSX.Element;

declare type FilterSearchSectionProps = {
    items: FilterItem[];
    selectedItems: string[];
    onChange: (items: string[]) => void;
    searchPlaceholder: string;
    canMultiple?: boolean;
};

export declare type FilterTag = {
    selected: boolean;
    onClick?: () => void;
} & Partial<AggregationPage>;

export declare type FinancialClassCode = {
    code: string;
    codingScheme: string;
    labels: {
        it: string;
        en?: string;
    };
};

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

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

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

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

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

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

export declare const FseIT: ({ width, height, className, color, decorative, ariaLabel, variant, }: WithVariant<IconProps>) => JSX.Element;

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

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

export declare const FseOperators: ({ width, height, className, color, decorative, ariaLabel, }: WithVariant<IconProps>) => JSX.Element;

export declare const FseOperatorsDGT: ({ width, height, className, color, decorative, ariaLabel, }: WithVariant<IconProps>) => JSX.Element;

export declare const FseOperatorsMEF: ({ width, height, className, color, decorative, ariaLabel, }: WithVariant<IconProps>) => JSX.Element;

export declare const FseOperatorsMS: ({ width, height, className, color, decorative, ariaLabel, }: WithVariant<IconProps>) => JSX.Element;

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

export declare const GenericAccordion: default_2.FC<GenericAccordionProps>;

declare interface GenericAccordionProps {
    mainTitle?: string;
    steps: StepDataGenericAccordion[];
}

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

export declare const GpHomeSection: ({ sectionId, title, className, doctorName, specialties, contactInfo, schedule, avatar, button, }: GpHomeSectionProps) => JSX.Element;

export declare type GpHomeSectionProps = {
    sectionId?: string;
    title?: string;
    className?: string;
    doctorName?: string;
    specialties?: string[];
    contactInfo?: Info_4[];
    schedule?: {
        label: string;
        days: ScheduleDay_3[];
    };
    avatar?: {
        initials: string;
        bg?: ColorKeys;
        textColor?: ColorKeys;
    };
    button?: {
        label: string;
        onClick: () => void;
    };
};

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

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

declare type GroupCodeExemptionDropDownProps = {
    size?: "small" | "large";
    items: FinancialClassCode[];
    className?: string;
    selectedGroupCode: FinancialClassCode | null;
    setSelectedGroupCode: (groupCode: FinancialClassCode | null) => void;
    placeholder?: string;
    btnText?: string;
    onSearch?: (groupCode: FinancialClassCode | null) => void;
};

export declare const GroupCodeExemptionFilterDropDown: ({ size, items, className, selectedGroupCode, setSelectedGroupCode, placeholder, btnText, onSearch, }: GroupCodeExemptionDropDownProps) => JSX.Element;

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

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

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

declare type HeaderMobileProps = HeaderTopBannerProps & WithVariant<{
    shortTitle: React.ReactNode;
    menuTitle?: string;
    region: Region;
    navigatonItems: NavigationItem[];
    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, isExpanded, expandTitle, subtitle, variant, toggleExpand, }: HeaderPostLoginProps) => JSX.Element;

export declare type HeaderPostLoginProps = {
    shortTitle: ReactNode;
    region: Region;
    navigationItems: NavigationItem_3[];
    loginLink?: string;
    asLink?: "a" | ComponentType<any>;
    generalClassName?: string;
    navItemsClassName?: string;
    isExpanded?: boolean;
    toggleExpand?: () => void;
    expandTitle?: string;
    subtitle?: string;
    variant?: "operators" | "default";
};

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

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

declare type HeaderSlimProps = {
    as?: "div" | "header";
    className?: string;
    containerClassName?: 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, variant, }: HeaderTopBannerProps) => JSX.Element;

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

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

declare type HeadingLevel = "h1" | "h2" | "h3" | "h4" | "h5" | "h6";

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

export declare const HeroContentCard: ({ data, ImageComponent, imageProps, variant, publishedLabel, readingTimeLabel, readingMinuteLabel, tagsLabelTitle, shareLabel, copyLinkLabel, copiedTextLabel, isPreview, modeAuthenticated, eventCardDescriptionTitle, tags, }: HeroContentCardProps) => JSX.Element;

declare interface HeroContentCardCommonProps {
    publishedLabel?: string;
    readingTimeLabel?: string;
    readingMinuteLabel?: string;
    tagsLabelTitle?: string;
    shareLabel?: string;
    copyLinkLabel?: string;
    copiedTextLabel?: string;
    ImageComponent?: "img" | React.ComponentType<any>;
    imageProps?: Record<string, any>;
    isPreview?: boolean;
    modeAuthenticated?: boolean;
    eventCardDescriptionTitle?: string;
    tags?: string[];
}

export declare type HeroContentCardProps = ServiceProps_2 | EventProps_2;

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

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

declare type HomeBannerProps = {
    users: Array<any>;
    title?: string;
    linkLabel?: string;
    onChangeProfileClick?: () => void;
};

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

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

export declare const HTML: (html: string, as?: "div" | "p") => JSX.Element;

/**
 * @deprecated
 */
export declare const HTMLBalancer: (html: string, as?: string | undefined) => JSX.Element;

export declare type IconInfoType = {
    id?: string;
    url?: string;
    data?: any;
    size?: {
        width: number;
        height: number;
    };
    position?: {
        x: number;
        y: number;
    };
};

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

export declare type IconWithVariantProps = WithVariant<IconProps>;

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

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

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

export declare interface ImageDescriptionItem {
    _id: string;
    image: {
        src: string;
        alt: string;
        title?: string;
    };
    description: string;
}

export declare const IMAGES_DESCRIPTION_LAYOUTS: {
    readonly FULL_1_1: "FULL_1_1";
    readonly FULL_4_3: "FULL_4_3";
    readonly FULL_16_9: "FULL_16_9";
    readonly FULL_21_9: "FULL_21_9";
    readonly FULL_32_9: "FULL_32_9";
    readonly TWO_COL_1_1: "TWO_COL_1_1";
    readonly TWO_COL_4_3: "TWO_COL_4_3";
    readonly TWO_COL_16_9: "TWO_COL_16_9";
    readonly TWO_COL_21_9: "TWO_COL_21_9";
    readonly TWO_COL_32_9: "TWO_COL_32_9";
    readonly THREE_COL_1_1: "THREE_COL_1_1";
    readonly THREE_COL_4_3: "THREE_COL_4_3";
    readonly THREE_COL_16_9: "THREE_COL_16_9";
    readonly THREE_COL_21_9: "THREE_COL_21_9";
    readonly THREE_COL_32_9: "THREE_COL_32_9";
};

export declare const ImagesDescription: ({ title, items, layout, className, }: ImagesDescriptionProps) => JSX.Element;

export declare type ImagesDescriptionLayout = (typeof IMAGES_DESCRIPTION_LAYOUTS)[keyof typeof IMAGES_DESCRIPTION_LAYOUTS];

export declare interface ImagesDescriptionProps {
    title: ReactNode;
    items: ImageDescriptionItem[];
    layout?: ImagesDescriptionLayout;
    className?: string;
}

export declare type IncomeBasedDeclarant = {
    code?: string;
    labels: Labels;
};

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

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

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

declare type Info_4 = {
    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, width, className, positionPopUp, onClickCloseBtn, isOpen, ariaLabel, children, }: InfoPopupProps) => JSX.Element;

export declare type InfoPopupProps = PropsWithChildren<{
    title: string;
    description: string | default_2.ReactNode;
    isOpen?: boolean;
    onClickCloseBtn?: () => void;
    className?: string;
    positionPopUp?: "right" | "top" | "bottom" | "left" | undefined;
    width?: string;
    ariaLabel?: string;
}>;

export declare const InfoSectionCard: ({ title, children }: InfoSectionCardProps) => JSX.Element;

declare type InfoSectionCardProps = {
    title?: string;
    children?: React.ReactNode;
};

declare type InfoSectionCardProps_2 = {
    title?: string;
    firstStatusLabel?: string;
    secondStatusLabel?: string;
    code?: string;
    description?: any;
    onPressPay?: () => void;
    onPressPayLink?: string;
    onPressEdit?: () => void;
    onPressDownload?: () => void;
    downloadLabel?: string;
    payLabel?: string;
    editLabel?: string;
    asLink?: "a" | React.ComponentType<any>;
};

export declare const Insights: ({ title, items, colorTitle, showBackgroundRectangle, }: Props_11) => JSX.Element;

declare type LabelProps = BaseProps & {
    variant: "label";
    children?: never;
    bottomLabel: string;
};

export declare type Labels = {
    it?: string;
};

export declare const LatestCardClinicalData: ({ className, categoryLabel, effectiveTime, entity, device, value, measurementUnit, variationValue, variationUnit, variationStatus, }: LatestCardClinicalDataProps) => JSX.Element;

export declare type LatestCardClinicalDataProps = {
    className?: string;
    categoryLabel: string;
    effectiveTime?: string;
    entity: string;
    device?: string | null;
    value?: number | null;
    measurementUnit?: string;
    variationValue?: string;
    variationUnit?: string;
    variationStatus?: "normal" | "alert";
};

export declare type LatestClinicalParameter = {
    categoryLabel: string;
    effectiveTime?: string;
    entity: string;
    device?: string | null;
    value?: number | null;
    measurementUnit?: string;
    variationValue?: string;
    variationUnit?: string;
    variationStatus?: "normal" | "alert";
};

export declare const LatestClinicalParametersSection: ({ sectionId, title, linkHref, linkLabel, asLink, parameters, }: LatestClinicalParametersSectionProps) => JSX.Element;

export declare type LatestClinicalParametersSectionProps = {
    sectionId?: string;
    title?: string;
    linkHref?: string;
    linkLabel?: string;
    asLink?: ElementType;
    parameters?: LatestClinicalParameter[];
};

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

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

export declare type LazioProps = IconProps & {
    bgColor?: string;
};

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

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

declare type LinkProps = BaseProps & {
    variant: "link";
    link: Link_3;
    children?: never;
};

export declare const ListStructures: ({ width, height, className, decorative, ariaLabel, }: 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, authSrc, }: LoginProps) => JSX.Element;

export declare const LoginBanner: ({ title, description, entries, rightDescription, rightContent, className, entryButtonAsLink, }: LoginBannerProps) => JSX.Element;

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

export declare type LoginBannerProps = {
    title: React.ReactNode;
    description?: React.ReactNode;
    entries: LoginBannerEntry[];
    rightDescription?: React.ReactNode;
    rightContent: React.ReactNode;
    className?: string;
    entryButtonAsLink?: "a" | React.ComponentType<any>;
};

export declare const LoginOperator: ({ title, description, loginTitle, loginDescription, entries, rightDescription, rightContent, entryButtonAsLink, bannerClassName, }: LoginOperatorProps) => JSX.Element;

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

export declare type LoginOperatorProps = {
    title: React.ReactNode;
    description?: React.ReactNode;
    loginTitle: React.ReactNode;
    loginDescription?: React.ReactNode;
    entries: LoginOperatorEntry[];
    rightDescription?: React.ReactNode;
    rightContent: React.ReactNode;
    entryButtonAsLink?: "a" | React.ComponentType<any>;
    bannerClassName?: string;
};

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 | IconWithVariantProps>>;

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

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

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

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

export declare const Microphone: ({ width, height, className, color, decorative, ariaLabel, }: 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, decorative, ariaLabel, }: IconProps) => JSX.Element;

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

export declare const MostVisitedHoursChart: ({ data, title, labels, updateValue, updateUnit, statusHighlightText, }: MostVisitedHoursChartProps) => JSX.Element;

export declare interface MostVisitedHoursChartProps {
    data?: VisitData[];
    title?: string;
    labels?: string[];
    updateValue?: number;
    updateUnit?: string;
    statusHighlightText?: string;
}

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

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

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

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

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, decorative, ariaLabel, }: IconProps) => JSX.Element;

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

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

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

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

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

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

export declare const notificationsSettingsHeaderId: (columnKey: string) => string;

export declare const Obscured: ({ width, height, className, color, decorative, ariaLabel, fillColor, bgCircle, }: ObscuredProps) => JSX.Element;

export declare type ObscuredProps = IconProps & {
    bgCircle?: boolean;
};

declare type OfficeInfo = {
    info: Info_3[];
    schedule?: {
        label: string;
        days: ScheduleDay_2[];
    };
};

declare type OnActionsProps = BaseProps & {
    variant: "onAction";
    onAction: () => void;
    onActionLabel?: string;
    children?: never;
};

export declare function OperatorCardDocument({ title, issuedAt, details, downloadAction, openAction, className, topRightContent, }: OperatorCardDocumentProps): JSX.Element;

export declare type OperatorCardDocumentProps = {
    title: string;
    issuedAt: string;
    topRightContent?: ReactNode;
    details: {
        label: string;
        value: string;
    }[];
    downloadAction: {
        title?: string;
        onDownload: () => void | Promise<void>;
        link?: Link_3;
    } | {
        title?: string;
        link: Link_3;
        onDownload?: () => void | Promise<void>;
    };
    openAction: {
        title: string;
        link: string;
        asLink?: "a" | ElementType;
    };
    className?: string;
};

export declare const OperatorCardTable: (props: Props_5) => JSX.Element;

declare type OperatorCardTableItem = {
    label: string;
    value: ReactNode;
};

export declare const OperatorListSkeleton: ({ elementsNumber }: Props_6) => JSX.Element;

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

export declare interface PaginationProps {
    currentPage: number;
    totalResults: number;
    currentResultsPerPage?: number;
    resultsPerPage: number;
    setCurrentPage: (page: number) => void;
    onPageChange?: (page: number) => void;
    className?: string;
    serverSide?: boolean;
    totalItems?: number;
    hasNextPage?: boolean;
    hasPreviousPage?: boolean;
    onNextPage?: () => void;
    onPreviousPage?: () => void;
}

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

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

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

declare type PolymorphicProps<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>;

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

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

declare type PolymorphicProps_4<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>;

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

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

declare type PositionLinkAsButtonProps = BasePositionLinkProps & {
    onClick?: () => void;
    type?: "button";
    asButton?: true;
    asLink?: never;
    href?: never;
    iconVisible?: boolean;
};

declare type PositionLinkAsLinkProps = BasePositionLinkProps & {
    href: string;
    asLink?: "a" | ElementType;
    onClick?: never;
    type?: never;
    asButton?: never;
    iconVisible?: boolean;
};

declare type PositionLinkProps = PositionLinkAsLinkProps | PositionLinkAsButtonProps;

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

declare type Props = {
    title: string;
    toggleableLabel?: string;
    children: React.ReactNode;
    defaultOpen?: boolean;
};

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

declare type Props_11 = {
    title: string;
    items: CardPreviewProps[];
    colorTitle?: ColorKeys;
    showBackgroundRectangle?: boolean;
};

declare type Props_12 = {
    title: string;
    description: string | default_2.ReactNode;
    steps: Step[];
    type: StepVariantEnum;
};

declare type Props_13 = {
    title: string;
    headerTitle: string;
    data?: CardFileProps[];
};

declare type Props_14 = {
    title: string;
    showAllLabel?: string;
    showAllHref?: string;
    mainTag: {
        label?: string;
        onClick?: () => void;
        selected?: boolean;
    };
    tags: Array<FilterTag>;
    onTagClick: () => void;
};

declare type Props_15 = {
    title: string;
    tags?: Array<{
        title: string;
        href: string;
    }>;
    searchProps: CommunicationSearchProps;
};

declare type Props_16 = {
    title?: string;
    description?: string | ReactNode;
    items: FaqItem[];
    colorTitle?: ColorKeys;
    fontSizeTitle?: TypographyKeys;
    handleOpenModal?: (item: FaqItem) => void;
};

declare type Props_2 = {
    type: 'info' | 'warning' | 'error' | 'success';
    title: string;
    children?: React.ReactNode;
};

declare type Props_3 = {
    title: string;
    description: string | ReactNode;
    link?: Link_2;
    actions?: Array<ActionIconTextProps>;
    firstStatusLabel?: string;
    secondStatusLabel?: string;
    personalStatusLabel?: string;
};

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

declare type Props_5 = ExpandableProps | LinkProps | OnActionsProps | LabelProps;

declare interface Props_6 {
    elementsNumber?: number;
}

declare type Props_7 = {
    textLabel: string;
    titleShared?: string;
};

declare type Props_8 = {
    type: StepVariantEnum;
    steps: Array<Step>;
    asLink?: "a" | any;
};

declare type Props_9 = {
    title?: string;
    description?: string | ReactNode;
    items: CardFileProps[];
    colorTitle?: ColorKeys;
    fontSizeTitle?: TypographyKeys;
};

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

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

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

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

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

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 ReservationRecapCard: ({ title, code, onPressDownload, firstStatusLabel, secondStatusLabel, description, onPressPay, onPressPayLink, onPressEdit, downloadLabel, payLabel, editLabel, asLink, }: InfoSectionCardProps_2) => JSX.Element;

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

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

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

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

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

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

declare interface SeactionHeadingProps {
    className?: string;
    titleMarginBottom?: string;
    descriptionMarginBottom?: string;
    descriptionClassName?: string;
    title?: string | ReactNode;
    titleId?: string;
    mdFs?: TypographyKeys;
    fs?: TypographyKeys;
    color?: ColorKeys;
    description?: string | ReactNode;
    children?: ReactNode;
}

export declare const Search: ({ btnText, helperText, onChangeValue, value, variant, onSearch, dimensionStrategy }: 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, instructionsText, mobileHelperText, value, items, setValue, setTypedValue, getSearchField, getDisplayField, onItemSelect, minCharsToSearch, className, dimensionStrategy, }: SearchGenericProps<T>): JSX.Element;

export declare type SearchGenericProps<T extends object> = {
    btnText: string;
    helperText: string;
    instructionsText?: 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;
    dimensionStrategy?: "fixed" | "auto";
};

export declare function SearchGenericV2<T = unknown>(props: SearchGenericV2Props<T>): JSX.Element;

declare type SearchGenericV2BaseProps<T = unknown> = {
    btnText: string;
    helperText?: string;
    value: string;
    loading?: boolean;
    emptyLabel?: string;
    minCharsToShow?: number;
    setValue: (value: string) => void;
    setSelectedElement: (item: SearchGenericV2Item<T>) => void;
    className?: string;
    dimensionStrategy?: "fixed" | "auto";
};

declare type SearchGenericV2CategorizedProps<T = unknown> = SearchGenericV2BaseProps<T> & {
    mode?: "categorized";
    items: SearchGenericV2Suggestion<T>[];
};

declare type SearchGenericV2FlatProps<T = unknown> = SearchGenericV2BaseProps<T> & {
    mode: "flat";
    items: SearchGenericV2Item<T>[];
};

export declare type SearchGenericV2Item<T = unknown> = {
    value: string;
    label: string;
    originalData: T;
};

export declare type SearchGenericV2Props<T = unknown> = SearchGenericV2CategorizedProps<T> | SearchGenericV2FlatProps<T>;

export declare type SearchGenericV2Suggestion<T = unknown> = {
    category: string;
    items: SearchGenericV2Item<T>[];
};

export declare const SearchIcon: ({ width, height, className, decorative, ariaLabel, fillColor, }: IconProps) => JSX.Element;

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;
    variant?: "outlined" | "basic";
    onChangeValue?: (value: string) => void;
    onSearch?: (value: string) => void;
    dimensionStrategy?: "fixed" | "auto";
};

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

export declare type SearchServiceProps = {
    btnText: string;
    helperText: string;
    value: string;
    items: Service_2[];
    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;
}

export declare const SectionHeading: ({ className, title, titleId, color, titleMarginBottom, descriptionClassName, descriptionMarginBottom, description, children, mdFs, fs, }: SeactionHeadingProps) => JSX.Element;

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

declare type Service = BaseServiceProps;

declare type Service_3 = BaseServiceProps_2;

declare type ServiceProps = {
    data: Service;
    variant: "service";
} & AuthorWithImageCommonProps;

declare type ServiceProps_2 = {
    data: Service_3;
    variant: "service";
} & HeroContentCardCommonProps;

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";
    readonly LayoutFive: "LayoutFive";
};

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, decorative, ariaLabel, }: IconProps) => JSX.Element;

export declare const ShareButton: ({ textLabel, titleShared }: Props_7) => JSX.Element;

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

export declare type Slide = {
    category?: {
        type: string;
        published_at: string;
    };
    src: string;
    alt: string;
    slideTitle?: string;
    title: string;
    description?: string;
    titleAlignment?: "left" | "center" | "right";
    blurPercentage?: number;
    href?: string;
    tags?: string[];
};

export declare const Slider: React.FC<SliderProps>;

export declare const SliderPagination: ({ slides, currentIndex, goPrev, goNext, autoplay, toggleAutoPlay, gradientColorStyle, type, paginationLabel, }: SliderPaginationProps) => JSX.Element;

export declare type SliderPaginationProps = {
    slides: Slide[];
    currentIndex: number;
    goPrev: () => void;
    goNext: () => void;
    autoplay: boolean;
    toggleAutoPlay: () => void;
    gradientColorStyle: CSSProperties;
    paginationLabel?: string;
    type: SliderType;
};

export declare type SliderProps = {
    slides: Slide[];
    asImage: React.ComponentType<any> | "img";
    asLink?: ElementType;
    timeout?: number;
    openInNewTab?: boolean;
    paginationLabel?: string;
    withShadow?: boolean;
    gradientColor?: string;
    type?: SliderType;
    swiperHeight?: number;
    tagsLabelTitle?: string;
};

export declare type SliderType = GetValues<SliderTypeEnum>;

export declare enum SliderTypeEnum {
    FULL_IMAGE = "full-image",
    BLUR_IMAGE = "blur-image"
}

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 Spid: ({ width, height, className, color, decorative, ariaLabel, }: IconProps) => JSX.Element;

export declare const Spinner: ({ width, height, className, decorative, ariaLabel, }: SpinnerProps) => JSX.Element;

declare type SpinnerProps = {
    width?: number;
    height?: number;
    className?: string;
    decorative?: boolean;
    ariaLabel?: string;
};

export declare type Step = {
    label: string;
    title: string;
    description: string | React.ReactNode;
    meta: string;
    link?: Link_2;
    linkType?: LinkTypeEnum;
};

declare interface StepData {
    title: string;
    content: React.ReactNode;
}

declare interface StepDataGenericAccordion {
    title: string;
    badge?: string;
    content: React.ReactNode;
}

export declare enum StepVariantEnum {
    DATE = "date",
    HEADLINE = "headline",
    ORDERED = "ordered",
    CHECK = "check"
}

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

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

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

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

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

export declare const StructurePrevention: ({ width, height, className, color, decorative, ariaLabel, }: IconProps) => 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 type Suggestion = {
    category: string;
    items: Service_2[];
};

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

export declare const SupportBanner: ({ bannerType, title, description, titleTag: TitleTag, mainLayout, className, classNameTitle, classNameDescription, links, asLink, children, }: SupportBannerProps) => JSX.Element;

declare interface SupportBannerLink {
    text: string;
    href?: string;
    icon?: boolean;
    target?: string;
    isExternal?: boolean;
    handleAction?: () => void;
    variant?: "link" | "button" | "outlineButton" | "outlineButtonHref";
}

declare type SupportBannerProps = {
    bannerType?: "filled" | "outline";
    title: string;
    description?: string;
    titleTag?: HeadingLevel;
    mainLayout?: "layout1" | "layout2";
    className?: string;
    classNameTitle?: string;
    classNameDescription?: string;
    links?: SupportBannerLink[];
    asLink?: "a" | React.ComponentType<any>;
    children?: React.ReactNode;
};

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

export declare const SvgIcon: default_2.FC<SvgIconProps>;

declare interface SvgIconProps {
    icon: IconInfoType;
    className?: string;
    style?: default_2.CSSProperties;
}

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

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

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

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

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

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

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

export declare enum TableAlignment {
    LEFT = "text-left",
    CENTER = "text-center",
    RIGHT = "text-right"
}

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 TableCard: ({ title, headerTitle, data }: Props_13) => JSX.Element;

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;
    variant?: "default" | "exemptions";
} & 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;
    showEmail?: boolean;
    showSms?: boolean;
};

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

export declare const TableList: ({ title, description, fontSize, mdFontSize, classNameTitle, additionalClass, variantClassTable, children, }: TableListProps) => JSX.Element;

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

export declare const TableMobile: ({ data, columns, pagination, resultsPerPage, totalResults, initialCurrentPage, serverSidePagination, totalItems, hasNextPage, hasPreviousPage, onNextPage, onPreviousPage, onPageChange, setCurrentPage: externalSetCurrentPage, sortConfig, onSortChange, }: TableMobileProps) => JSX.Element;

export declare const TableMobileList: ({ title, description, tableJson, fontSize, mdFontSize, classNameTitle, additionalClass, variantClassTable, pagination, resultsPerPage, sortConfig, onSortChange, totalResults, initialCurrentPage, serverSidePagination, totalItems, hasNextPage, hasPreviousPage, onNextPage, onPreviousPage, onPageChange, setCurrentPage, children, }: TableMobileListProps) => JSX.Element;

declare type TableMobileListProps = PropsWithChildren<{
    title?: ReactNode;
    description?: ReactNode;
    tableJson?: {
        columns: ColumnConfig[];
        rows: TableRowData[];
    };
    links?: SectionLink[];
    asLink?: "a" | ComponentType<any>;
    fontSize?: TypographyKeys;
    mdFontSize?: TypographyKeys;
    classNameTitle?: string;
    additionalClass?: string;
    variantClassTable?: TableAlignment;
    pagination?: boolean;
    resultsPerPage?: number;
    sortConfig?: {
        key: string;
        direction: "asc" | "desc";
    } | null;
    onSortChange?: (key: string, direction: "asc" | "desc") => void;
    totalResults?: number;
    initialCurrentPage?: number;
    serverSidePagination?: boolean;
    totalItems?: number;
    hasNextPage?: boolean;
    hasPreviousPage?: boolean;
    onNextPage?: () => void;
    onPreviousPage?: () => void;
    onPageChange?: (page: number) => void;
    setCurrentPage?: (page: number) => void;
}>;

export declare const TableMobilePagination: React_2.FC<TableMobilePaginationProps>;

export declare type TableMobilePaginationProps = {
    currentPage?: number;
    totalResults?: number;
    resultsPerPage: number;
    setCurrentPage?: (page: number) => void;
    onPageChange?: (page: number) => void;
    className?: string;
    serverSide?: boolean;
    totalItems?: number;
    hasNextPage?: boolean;
    hasPreviousPage?: boolean;
    onNextPage?: () => void;
    onPreviousPage?: () => void;
    currentResultsPerPage?: number;
};

export declare type TableMobileProps = {
    data: TableRowData[];
    columns: ColumnConfig[];
    pagination?: boolean;
    resultsPerPage?: number;
    totalResults?: number;
    initialCurrentPage?: number;
    serverSidePagination?: boolean;
    totalItems?: number;
    hasNextPage?: boolean;
    hasPreviousPage?: boolean;
    onNextPage?: () => void;
    onPreviousPage?: () => void;
    onPageChange?: (page: number) => void;
    setCurrentPage?: (page: number) => void;
    sortConfig?: {
        key: string;
        direction: "asc" | "desc";
    } | null;
    onSortChange?: (key: string, direction: "asc" | "desc") => void;
};

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

declare type TableOfContentsProps = {
    title: string;
    headings: Heading[];
    titleTag?: HeadingLevel;
    modeAuthenticated?: boolean;
    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";
    setSelectedSort?: (sortConfig: {
        key: string;
        direction: "asc" | "desc";
    }) => void;
    initialSortConfig?: {
        key: string;
        direction: "asc" | "desc";
    };
    serverSidePagination?: boolean;
    totalItems?: number;
    hasNextPage?: boolean;
    hasPreviousPage?: boolean;
    onNextPage?: () => void;
    onPreviousPage?: () => void;
    onPageChange?: (page: number) => void;
    variant?: "default" | "exemptions";
}

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 TabsGlossaryV2: ({ CTA, navigationItems, children, activeIndex, onTabChange, actions, }: TabsGlossaryV2Props) => JSX.Element;

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

export declare const Tag: ({ label, mode, selected, className, onClick, }: TagProps) => JSX.Element;

export declare type TagMode = "filter" | "decorative";

export declare type TagProps = {
    label: string;
    mode?: TagMode;
    className?: string;
    selected?: boolean;
    onClick?: () => void;
};

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

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

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

export declare const TagsSection: ({ title, mainTag, tags, showAllHref, showAllLabel, onTagClick, }: Props_14) => JSX.Element;

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

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

export declare const TitleSection: ({ action1, action2, mainButton, secondaryButton, titleSection, subtitle, classNameTitle, borderBottom, titleTag: TitleTag, gotoLinkHref, gotoLinkLabel, gotoLinkAsLink, }: TitleSectionProps) => JSX.Element;

declare type TitleSectionProps = PropsWithChildren<{
    action1?: ReactNode;
    action2?: ReactNode;
    mainButton?: ReactNode;
    secondaryButton?: ReactNode;
    titleSection: string;
    subtitle?: string | ReactNode;
    classNameTitle?: string;
    borderBottom?: boolean;
    isMoreOption?: boolean;
    handleMoreOption?: () => void;
    titleTag?: HeadingLevel;
    gotoLinkHref?: string;
    gotoLinkLabel?: string;
    gotoLinkAsLink?: ElementType | "a";
}>;

declare type ToggleLabel = {
    activeLabel: string;
    closeLabel: string;
};

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

export declare const Tooltip: default_2.FC<TooltipProps>;

declare type TooltipPosition = "top" | "bottom" | "left" | "right";

declare interface TooltipProps {
    children: ReactNode;
    label: ReactNode;
    opened?: boolean;
    defaultOpened?: boolean;
    position?: TooltipPosition;
    withArrow?: boolean;
    delay?: number;
    className?: string;
}

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

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

export declare const Twitter: ({ className, height, width, decorative, ariaLabel, }: 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";
};

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

declare type Variant = "default" | "operator";

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

export declare const VerticalCardStepper: ({ steps, type, asLink }: Props_8) => JSX.Element;

export declare const VerticalCardStepperSection: ({ title, description, steps, type, }: Props_12) => JSX.Element;

export declare enum VIDEO_PLAYER_SIZE {
    SMALL = "small",
    MEDIUM = "medium",
    LARGE = "large",
    EXTRA_LARGE = "extra-large",
    VERTICAL = "vertical",
    FULL_WIDTH = "full-width"
}

export declare const VideoPlayer: ({ btnText, sizeComp, transcription, previewImageSrc, videoSrc, videoTitle, videoLang, playButtonLabel, videoAriaLabel, showDivider, }: VideoPlayerProps) => JSX.Element;

export declare type VideoPlayerProps = {
    btnText?: string;
    sizeComp?: VIDEO_PLAYER_SIZE;
    previewImageSrc?: string;
    transcription?: string;
    videoSrc: string;
    videoTitle?: string;
    videoLang?: string;
    playButtonLabel?: string;
    videoAriaLabel?: string;
    transcriptionHeading?: string;
    transcriptionHeadingLevel?: "h2" | "h3" | "h4" | "h5" | "h6";
    showDivider?: boolean;
};

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

export declare interface VisitData {
    hour: number;
    value: number;
    isActive?: boolean;
}

export declare const WaitTimeTable: ({ data, }: WaitTimeTableProps) => JSX.Element;

export declare interface WaitTimeTableData {
    color: string;
    label: string;
    time: number | string;
    waiting: number;
    treatment: number;
}

export declare interface WaitTimeTableProps {
    data: WaitTimeTableData[];
}

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

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

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

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

declare type WithLinkType<T> = Link_2 & {
    linkType?: T;
};

declare type WithVariant<T> = T & {
    variant?: Variant;
};

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

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

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

export { }