@anoki/fse-ui/dist/index.d.ts

FSE UI components library

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 { MouseEvent as MouseEvent_2 } from 'react';
import { OpeningHours } from '@anoki/fse-common';
import { PropsWithChildren } from 'react';
import * as React_2 from 'react';
import { ReactNode } from 'react';
import { SectionLink } from '@anoki/fse-common';
import { Service } from '@anoki/fse-common';
import { SettingFooterLink } from '@anoki/fse-common/dist';
import { Structure } from '@anoki/fse-common';

export declare const AccessLogSkeleton: () => 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;
    variant?: ActionBannerVariantTypes;
    link?: WithLinkType<LinkTypeEnum>;
    withIcon?: boolean;
    firstAction?: WithLinkType<LinkTypeEnum>;
    secondAction?: WithLinkType<LinkTypeEnum>;
}

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

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

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;
    subtitle: string;
    link: Link_2;
    variant?: AlertVariant;
};

export declare type AlertVariant = GetValues<typeof AlertVariantEnum>;

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

export declare const ArrowDown: ({ width, height, className, color, 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, ...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 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 Avatar: ({ initials, bg, textColor, size, className, }: AvatarProps) => JSX.Element;

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

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

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

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

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

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";
};

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 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;
    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;
    author: string;
    variant?: BlockquoteVariantEnum;
};

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

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_4) => JSX.Element;

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

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

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

declare type CardClinicalDataProps = {
    information?: {
        label: string;
        value: string;
    }[];
    className?: string;
    clinicalCode?: string;
    isOpen: boolean;
    onToggle: () => void;
    selectedStructures?: string[];
    hasBorder?: boolean;
    clinicalLabel?: string;
    label?: string;
    classNameTitle?: string;
    deleteLabel?: string;
    onDelete?: () => void;
};

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

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

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

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

export declare const CardDocument: ({ eventNumber, date, documentType, showBottomActions, showFavorite, 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;
    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;
    link: string;
    openModal?: Function;
    isExternal?: boolean;
    asLink?: "a" | default_2.ComponentType<any>;
}

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, }: CardFileProps): JSX.Element;

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

export declare type CardFileActionTypeTypes = GetValues_2<typeof CardFileActionTypeEnum>;

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

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, setSelectedCard, addressLabel, }: 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;
    isExternal?: boolean;
    showIcon?: boolean;
    asLink?: "a";
    className?: string;
    plainAddress?: string;
    setSelectedCard?: (id: string) => void;
    addressLabel?: string;
};

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;
    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 CardPreview: default_2.FC<CardPreviewProps>;

export declare interface CardPreviewProps {
    variant?: CardPreviewVariant;
    sectionTitle?: string;
    imageUrl?: string;
    title: string;
    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 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 }: CarouselProps): JSX.Element;

declare type CarouselProps = {
    title?: string;
    children?: Array<ReactNode>;
};

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;
    }[];
    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;

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 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 Col: <E extends ElementType = "div">({ as, className, justifyContent, alignItems, flexWrap, ref, style, ...rest }: PolymorphicProps_4<E>) => JSX.Element;

declare type ColorKeys = "primary" | "white" | "status-success" | "warning" | "error" | "muted" | "emphasis" | "slate-20" | "slate-14" | "slate-28" | "border-divider" | "transparent" | "blue-30" | "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";

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

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 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) => void;
};

export declare const CommunicationSearchSection: ({ title, searchProps, }: Props_11) => 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 CookieBanner: ({ onlyTechniciansLabel, text, textSecond, acceptLabel, onPressCookieLink, hasThirdPartyCookies, hasTechnicalCookies, onPressAcceptThirdPartCookie, onPressAcceptTechnicalCookie, onCloseBanner, }: CookieBannerProps) => JSX.Element;

export declare type CookieBannerProps = {
    hasThirdPartyCookies?: boolean;
    hasTechnicalCookies?: boolean;
    onPressAcceptThirdPartCookie: () => void;
    onPressAcceptTechnicalCookie: () => void;
    onCloseBanner: () => void;
    onPressCookieLink: () => void;
    onlyTechniciansLabel: string;
    acceptLabel: string;
    text: string;
    textSecond: string;
};

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;

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

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

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

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

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

export declare const 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 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, colorTitle, fontSizeTitle, }: Props_5) => 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, }: EditorialWidgetProps): JSX.Element;

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

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

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

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

export declare const Favourite: ({ width, height, className, color, filled, decorative, ariaLabel, }: 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_3;
    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;
};

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

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

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

e