import * as react_jsx_runtime from 'react/jsx-runtime';
import React$1, { ReactNode } from 'react';
import { IconType } from 'react-icons';

type AccordionContainerProps = {
    children: React$1.ReactNode;
};
declare const AccordionContainer: ({ children }: AccordionContainerProps) => react_jsx_runtime.JSX.Element;
type AccordionItemProps = {
    title: React$1.ReactNode;
    content: React$1.ReactNode;
    isOpen?: boolean;
};
declare const AccordionItem: ({ title, content, isOpen }: AccordionItemProps) => react_jsx_runtime.JSX.Element;

interface AnimationObserverProps {
    children: React$1.ReactElement;
    animationClassNames: string;
    threshold?: number;
    defaultClassNames: string;
}
declare const AnimationObserver: ({ children, animationClassNames, threshold, defaultClassNames, }: AnimationObserverProps) => React$1.ReactElement<any, string | React$1.JSXElementConstructor<any>>;

interface AnimateBorderProps {
    elementToAnimate?: React$1.ReactElement;
    children: React$1.ReactElement;
    speed?: string;
    hideOverflow?: boolean;
    iconsToAnimate?: React$1.ReactElement[];
    borderRadius?: string;
}
declare const AnimateBorder: ({ elementToAnimate, children, speed, hideOverflow, iconsToAnimate, borderRadius }: AnimateBorderProps) => react_jsx_runtime.JSX.Element;

interface AnimatedHeaderProps {
    textToAnimate: string;
    textClassNames: string;
    containerClassNames?: string;
    textAnimation: {
        start: string;
        end: string;
    };
    scaleAnimation: {
        start: number;
        end: number;
    };
    identifiers: {
        parent: string;
        child: string;
    };
    pin?: boolean;
    once?: boolean;
    paragraph?: boolean;
}
declare const AnimatedHeader: ({ textToAnimate, textClassNames, containerClassNames, textAnimation, scaleAnimation, identifiers, pin, once, }: AnimatedHeaderProps) => react_jsx_runtime.JSX.Element;

interface BentoBoxProps {
    children: ReactNode[];
    classNames?: string;
}
declare const BentoBox: React$1.FC<BentoBoxProps>;

interface BookNowProps {
    vendor?: "tidycal" | "calendly";
    scriptPathUrl: string;
    show: boolean;
    dataUrl?: string;
    className?: string;
    dataPath?: string;
}
declare const BookNow: ({ scriptPathUrl, show, vendor, dataUrl, className, dataPath, }: BookNowProps) => react_jsx_runtime.JSX.Element;

interface CookieConsentFormProps {
    positionX: string;
    positionY: string;
    cookieText: string;
    cookieHeader: string;
    onAccept: () => void;
    onReject: () => void;
    show: boolean;
    classNames?: string;
    type?: "absolute" | "fixed";
}
declare const CookieConsentForm: ({ positionX, positionY, cookieHeader, cookieText, onAccept, onReject, show, classNames, type, }: CookieConsentFormProps) => react_jsx_runtime.JSX.Element | null;

interface CTAProps {
    type?: "basic" | "emphasized" | "minimal";
    smallheading: string;
    ctaText?: string;
    onClick?: () => void;
    subheading?: string;
    paragraph?: string;
    classNames?: string;
}
declare const CTA: ({ type, ctaText, onClick, subheading, paragraph, smallheading, classNames, }: CTAProps) => react_jsx_runtime.JSX.Element;

type IndividualLinkType = {
    text: string;
    url: string;
};
type SocialLinkType = {
    icon: IconType;
    url: string;
};
type LinkType = {
    header: string;
    links: IndividualLinkType[];
};
type HoursType = {
    day: string;
    openingTime: string;
};
type OpeningHourType = {
    header: string;
    hours: HoursType[];
};
interface FooterProps {
    links?: LinkType[];
    logo?: string;
    logoText?: string;
    newsletter?: boolean;
    socialLinks?: SocialLinkType[];
    maxLogoHeight?: string;
    leftElement?: JSX.Element;
    openingHours?: OpeningHourType;
}
declare const Footer: ({ links, logo, logoText, newsletter, socialLinks, maxLogoHeight, leftElement, openingHours, }: FooterProps) => react_jsx_runtime.JSX.Element;

interface HeroProps {
    styleType: string | 'Bento' | 'Traditional' | 'Image';
    headline?: string;
    subheadline?: string;
    description?: string;
    children?: ReactNode;
    imageSrc?: string;
    classNames?: string;
    offerText?: string;
    offerDate?: Date;
    offerCta?: string;
    offerCtaFunctionality?: () => void;
    imageAlt?: string;
    imageOverlayOpacity?: number;
}
declare const Hero: ({ styleType, headline, subheadline, children, imageSrc, classNames, imageAlt, imageOverlayOpacity, }: HeroProps) => react_jsx_runtime.JSX.Element;

interface MasonryProps {
    children: ReactNode[];
    classNames?: string;
    itemMaxWidth?: string;
}
declare const Masonry: React$1.FC<MasonryProps>;

type LinkTypes = {
    link: string;
    text: string;
};
interface NavbarProps {
    links: LinkTypes[];
    logo?: string;
    type?: "rounded" | "full" | "default";
    ctaElement?: JSX.Element;
    classNames?: string;
    maxLogoHeight?: string;
    children?: React$1.ReactNode;
}
declare const Navbar: ({ logo, links, type, ctaElement, classNames, maxLogoHeight, children, }: NavbarProps) => react_jsx_runtime.JSX.Element;

interface OfferProps {
    offer: string;
    offerDateEnd: Date;
    ctaText?: string;
    ctaFunctionality?: () => void;
    btnClassnames?: string;
    fontSize?: string;
    classNames?: string;
}
declare module "react" {
    interface CSSProperties {
        "--value"?: string | number;
    }
}
declare const Offer: React$1.FC<OfferProps>;

type PrettyCardProps = {
    buttonText?: string;
    altButtonJsx?: JSX.Element;
    content: JSX.Element;
    cardImage?: string;
    children?: ReactNode;
    gradientColors?: {
        start: string;
        end: string;
    };
    showAnimationOnce?: boolean;
    className?: string;
};
declare const PrettyCard: ({ buttonText, altButtonJsx, content, cardImage, children, gradientColors, showAnimationOnce, className, }: PrettyCardProps) => react_jsx_runtime.JSX.Element;

interface RatingsProps {
    column?: boolean;
    rating: number;
    imagesSrc: string[];
    trusted: number | undefined;
}
declare const Ratings: ({ imagesSrc, rating, trusted, column }: RatingsProps) => react_jsx_runtime.JSX.Element;

interface SectionContainerProps {
    children: ReactNode;
    classNames?: string;
    padded?: boolean;
    id?: string;
}
declare const SectionContainer: ({ children, classNames, padded, id }: SectionContainerProps) => react_jsx_runtime.JSX.Element;

interface SectionHeaderProps {
    headline: string;
    subheadline?: string;
    classNames?: string;
    children?: ReactNode;
    breakpoint?: "sm" | "md" | "lg" | "xl";
    headlineTag?: "h1" | "h2" | "h3" | "h4" | "h5" | "h6";
    mobileAlignment?: "left" | "center" | "right";
    desktopAlignment?: "left" | "center" | "right";
    gap?: string;
}
declare const SectionHeader: ({ headline, subheadline, classNames, children, breakpoint, headlineTag, mobileAlignment, desktopAlignment, gap, }: SectionHeaderProps) => react_jsx_runtime.JSX.Element;

type ItemType = {
    a: ReactNode | string;
    b: ReactNode | string;
};
interface SellingPropositionProps {
    sellingItems: ItemType[];
    containerClassNames?: string;
}
declare const SellingProposition: ({ sellingItems, containerClassNames, }: SellingPropositionProps) => react_jsx_runtime.JSX.Element;

interface SellinPropsContainerProps {
    smallHeader?: string;
    mainHeader: string;
    text: string;
    ctaText?: string;
    ctaFunctionality?: () => void;
}
declare const SellingPropContainer: ({ smallHeader, mainHeader, text, ctaText, ctaFunctionality, }: SellinPropsContainerProps) => react_jsx_runtime.JSX.Element;

type ServiceType = {
    text?: string;
    title: string;
};
interface StackedScrollerProps {
    services: ServiceType[];
    defaultHeading?: string;
    activeHeaderClassNames?: string;
    activeTextClassNames?: string;
    activeContainerClassNames?: string;
    defaultContainerClassNames?: string;
}
declare const StackedScroller: ({ services, defaultHeading, activeHeaderClassNames, activeTextClassNames, activeContainerClassNames, defaultContainerClassNames, }: StackedScrollerProps) => react_jsx_runtime.JSX.Element;

type TestimonialType = {
    text: string;
    author: string;
    photoUrl?: string;
    link?: string;
    companyOrPosition?: string;
};
interface TestimonialDisplayProps {
    style?: "carousel" | "grid";
    children: ReactNode;
}
declare const TestimonialDisplay: ({ style, children, }: TestimonialDisplayProps) => JSX.Element;

interface TestimonialCardProps {
    testimonialContent: TestimonialType;
    carousel?: boolean;
    classNames?: string;
}
declare const TestimonialCard: ({ testimonialContent, carousel, classNames, }: TestimonialCardProps) => react_jsx_runtime.JSX.Element;

interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
    children: React.ReactNode;
}
declare function Button({ children, ...other }: ButtonProps): JSX.Element;
declare namespace Button {
    var displayName: string;
}

export { AccordionContainer, AccordionItem, AnimateBorder, type AnimateBorderProps, AnimatedHeader, AnimationObserver, type AnimationObserverProps, BentoBox, BookNow, Button, type ButtonProps, CTA, CookieConsentForm, Footer, Hero, Masonry, Navbar, Offer, PrettyCard, Ratings, SectionContainer, SectionHeader, SellingPropContainer, SellingProposition, StackedScroller, TestimonialCard, TestimonialDisplay };
