/// <reference types="react" />
/// <reference types="google.maps" />
import React, { ElementType, ReactNode, RefObject } from 'react';
import { SwiperProps } from 'swiper/react';
import { HTMLElement as HTMLElement$1 } from 'node-html-parser';
import { Variants, MotionProps } from 'framer-motion';

interface BoldTitleProps {
    title?: string;
    html?: string | null;
    as?: ElementType;
    className?: string;
}
declare const BoldTitle: ({ as: Tag, html, title, className }: BoldTitleProps) => JSX.Element;

interface HeadingProps {
    title?: string;
    titleHtml?: string | null;
    titleAs?: ElementType | null;
    subtitle?: string | null;
    className?: string;
    classNameTitle?: string;
    classNameSubtitle?: string;
}
declare const Heading: ({ titleAs, className, classNameTitle, classNameSubtitle, title, titleHtml, subtitle }: HeadingProps) => JSX.Element;

interface ImageTextProps<T> {
    odd?: boolean;
    heading: HeadingProps;
    html?: string;
    description?: string;
    button?: ReactNode;
    image?: ReactNode;
    className?: string;
    classNameText?: string;
    classNameImage?: string;
    classNameProse?: string;
    classNameTitle?: string;
    classNameSubtitle?: string;
    classNameHeading?: string;
    classNameRow?: string | (({ data }: {
        data?: T;
    }) => string);
    renderImage?: ({ image, odd, data }: {
        image?: ReactNode;
        odd?: boolean;
        data?: T;
    }) => ReactNode | undefined;
    renderText?: ({ description, button, data }: {
        description?: string;
        button?: ReactNode;
        html?: string;
        heading: HeadingProps;
        odd?: boolean;
        data?: T;
    }) => ReactNode | undefined;
    data?: T;
}
declare const ImageText: <T extends object = {}>({ className, classNameText, classNameImage, classNameProse, classNameRow, odd, heading, description, html, button, image, renderImage, renderText, data }: ImageTextProps<T>) => JSX.Element;

interface ProseProps {
    html?: string | null;
    tag?: ElementType;
    text?: string;
    className?: string;
}
declare const Prose: React.ForwardRefExoticComponent<ProseProps & React.RefAttributes<HTMLElement>>;

interface TextProps {
    title?: string;
    titleHtml?: string;
    titleAs?: ElementType | null;
    subtitle?: string | null;
    subtitleAs?: ElementType | null;
    html?: string;
    text?: string;
    button?: ReactNode;
    className?: string;
    classNameRow?: string;
    classNameContainer?: string;
    classNameProse?: string;
    classNameTitle?: string;
    classNameSubtitle?: string;
    classNameHeading?: string;
}
declare const Text: ({ className, classNameRow, classNameProse, classNameTitle, classNameSubtitle, classNameHeading, classNameContainer, title, titleHtml, titleAs, subtitle, text, html, button }: TextProps) => JSX.Element;

interface TeaserProps {
    as?: ElementType;
    image?: ReactNode;
    className?: string;
    classNameImage?: string;
    classNameDescription?: string;
    heading: HeadingProps;
    description: string;
    button?: ReactNode;
}
declare const Teaser: ({ as: Tag, image, classNameImage, className, heading, description, classNameDescription, button }: TeaserProps) => JSX.Element;

interface TeasersProps {
    teasers: TeaserProps[];
    defaultTeaserProps?: Partial<TeaserProps>;
    swiperProps?: SwiperProps;
    heading: HeadingProps;
    className?: string;
    classNameButtonPrevious?: string;
    classNameButtonNext?: string;
    classNameHeader?: string;
}
declare const Teasers: ({ teasers, defaultTeaserProps, swiperProps, className, classNameButtonPrevious, classNameButtonNext, classNameHeader, heading }: TeasersProps) => JSX.Element;

interface ParagraphProps {
    heading?: HeadingProps;
    prose?: ProseProps;
    button?: ReactNode;
}
declare const Paragraph: ({ heading, prose, button }: ParagraphProps) => JSX.Element;

interface ImageTextsProps<T> {
    imageTexts: ImageTextProps<T>[];
    defaultImageTextProps?: Partial<ImageTextProps<T>>;
    className?: string;
    odd?: boolean;
}
declare const ImageTexts: <T extends object = {}>({ imageTexts, defaultImageTextProps, className, odd }: ImageTextsProps<T>) => JSX.Element;

interface NavigationItem {
    id: number | string;
    title: string;
    path?: string;
    external: boolean;
    bold?: boolean;
    [key: string]: any;
    items?: NavigationItem[];
}
interface HeaderProps {
    open: boolean;
    close: () => void;
    navigation: NavigationItem[];
    renderLogo: (firstItemRef: RefObject<HTMLAnchorElement>, close: () => void) => ReactNode;
    renderToggle: ({ ref, open }: {
        ref: RefObject<HTMLButtonElement>;
        close: () => void;
        open: boolean;
    }) => ReactNode;
    renderRightContent?: () => ReactNode;
    renderMenuItem: ({ item, close, mobile, ref }: {
        item: NavigationItem;
        close: () => void;
        mobile: boolean;
        ref?: RefObject<HTMLAnchorElement>;
    }) => ReactNode;
    renderMenu?: ({ navigation, close }: {
        navigation: NavigationItem[];
        close: () => void;
    }) => ReactNode;
    renderMobileMenu?: (navigation: NavigationItem[], close: () => void, open: boolean, firstItemRef: RefObject<HTMLAnchorElement>, closeRef: RefObject<HTMLButtonElement>, lastItemRef: RefObject<HTMLAnchorElement>) => ReactNode;
    renderMobileMenuWrapper: (children: ReactNode) => ReactNode;
    skipContentLabel?: string;
    classNameHeader?: string;
    className?: string;
    classNameSkipContent?: string;
    classNameMenu?: string;
    classNameMenuNav?: string;
    classNameMobileMenu?: string;
    classNameMobileMenuContainer?: string;
    classNameMobileMenuItems?: string;
    classNameMenuItem?: string;
    classNameInner?: string;
}
interface HeaderWrapperProps extends HeaderProps {
}
declare const HeaderWrapper: (props: HeaderWrapperProps) => JSX.Element;

interface LocationFinderProps {
    googleMapsApiKey: string;
    locations: Location[];
    listInputPlaceholder?: string;
    numberOfLocationsLabel?: string;
    maxItemsInList?: number;
    styles?: google.maps.MapTypeStyle[];
    cluster?: boolean;
    markerIcon?: {
        url: string;
        width: number;
        height: number;
    };
    selectedItemBackLabel?: string;
    language?: string;
    region?: string;
    listItemOpeningHourSlotLabel?: string;
    defaultZoom?: number;
    defaultCenter?: google.maps.LatLngLiteral;
    defaultBounds?: google.maps.LatLngBoundsLiteral;
    defaultLocationId?: string;
    listInputDefaultValue?: string;
    listInputLocationButtonIcon?: string;
    classNameContainer: string;
    classNameCard?: string;
    classNameCardWrapper?: string;
    classNameList?: string;
    classNameListHeader?: string;
    classNameListInput?: string;
    classNameListInputLocationButton?: string;
    classNameListInputLocationButtonIcon?: string;
    classNameListNumberOfLocations?: string;
    classNameListItem?: string;
    classNameListItemWrapper?: string;
    classNameListItemDistance?: string;
    classNameListItemDistanceKm?: string;
    classNameListItemDistanceKmLabel?: string;
    classNameListItemTitle?: string;
    classNameListItemStreet?: string;
    classNameSelectedItem?: string;
    classNameSelectedItemBack?: string;
    renderListHeaderTop?: ({ numberOfLocations, numberOfLocationsLabel }: {
        numberOfLocations: number;
        numberOfLocationsLabel: string;
    }) => ReactNode;
    renderListHeaderBottom?: ({ numberOfLocations, numberOfLocationsLabel }: {
        numberOfLocations: number;
        numberOfLocationsLabel: string;
    }) => ReactNode;
    renderSelectedItemBack?: ({ onClick }: {
        onClick: () => void;
    }) => ReactNode;
    renderSelectedItemImage?: ({ image }: {
        image?: string;
    }) => ReactNode;
    renderSelectedItemDirections?: ({ link }: {
        link: string;
    }) => ReactNode;
    renderSelectedItemContent?: ({ location }: {
        location: Location;
    }) => ReactNode;
    onPlaceChanged?: () => void;
    onSelectedLocationChange?: ({ location }: {
        location: Location | undefined;
    }) => void;
}
interface Location {
    id: string;
    title: string;
    position: google.maps.LatLngLiteral;
    distance?: number;
    street: string;
    city: string;
    openingHours?: OpeningHours;
    image?: string[];
    phone?: string;
    email?: string;
}
interface OpeningHours {
    days: OpeningHoursDays;
}
interface OpeningHoursDays {
    [key: number]: OpeningHoursDaysDay;
}
interface OpeningHoursDaysDay {
    closed?: boolean;
    slots: OpeningHoursDaysDaySlot[];
}
interface OpeningHoursDaysDaySlot {
    from: OpeningHoursDaysDaySlotTime;
    to: OpeningHoursDaysDaySlotTime;
}
interface OpeningHoursDaysDaySlotTime {
    hours: number;
    minutes: number;
}
declare const LocationFinder: ({ googleMapsApiKey, listInputPlaceholder, locations, region, numberOfLocationsLabel, defaultZoom, defaultCenter, defaultBounds, defaultLocationId, styles, classNameContainer, classNameCard, classNameCardWrapper, classNameListInput, classNameListNumberOfLocations, classNameListItem, classNameListInputLocationButton, classNameListInputLocationButtonIcon, classNameListItemWrapper, classNameListItemDistance, classNameListItemDistanceKm, classNameListItemDistanceKmLabel, classNameListItemTitle, classNameListItemStreet, classNameList, classNameListHeader, classNameSelectedItem, classNameSelectedItemBack, renderListHeaderTop, renderListHeaderBottom, renderSelectedItemBack, renderSelectedItemImage, renderSelectedItemDirections, renderSelectedItemContent, markerIcon, listInputDefaultValue, listInputLocationButtonIcon, listItemOpeningHourSlotLabel, selectedItemBackLabel, language, onPlaceChanged, onSelectedLocationChange }: LocationFinderProps) => JSX.Element;

interface BoldTitleAnimatedProps {
    html?: string | null;
    as?: ElementType;
    className?: string;
    classNameLetter?: string | (({ type, text, bold }: {
        type: 'text';
        text: string;
        bold: boolean;
    }) => string);
    classNameWord?: string;
    variantsTitle?: Variants;
    variantsLine?: Variants;
    variantsLetter?: Variants;
    motion?: MotionProps;
}
type Line = {
    type: 'break';
} | {
    type: 'text';
    text: string;
    bold: boolean;
};
declare const BoldTitleAnimated: React.ForwardRefExoticComponent<BoldTitleAnimatedProps & React.RefAttributes<HTMLElement$1>>;

export { BoldTitle, BoldTitleAnimated, BoldTitleAnimatedProps, BoldTitleProps, HeaderWrapper as Header, HeaderProps, Heading, HeadingProps, ImageText, ImageTextProps, ImageTexts, ImageTextsProps, Line, LocationFinder, LocationFinderProps, NavigationItem, OpeningHoursDaysDay, OpeningHoursDaysDaySlot, Paragraph, ParagraphProps, Prose, ProseProps, Teaser, TeaserProps, Teasers, TeasersProps, Text, TextProps };
