import * as React$1 from 'react';
import React__default, { ReactNode, CSSProperties, FC } from 'react';
import { AnimationType } from '@shared/components/animation-wrapper';
import { ResponsiveSize } from '@shared/components/brand-button/types';
import { Fill, Size } from '@shared/components/material-icon/types';
import { CheckPlansProps, Asset, Button as Button$1, ButtonGroup } from '@shared/types/micro-components';
import { VideoLinkProps } from '@shared/components/video-link';
import * as react_jsx_runtime from 'react/jsx-runtime';
import { ButtonProps as ButtonProps$1 } from '@shared/contentful/blocks/button/types';
import { BlogCardImageProps as BlogCardImageProps$1 } from '@shared/contentful/blocks/cards/blog-card/types';
import { Document } from '@contentful/rich-text-types';
import { Options } from '@contentful/rich-text-react-renderer';

type AccordionItem = {
    anchorId?: string;
    title: string;
    description: React__default.ReactNode;
};
type AccordionProps = {
    /** Section-level anchor ID applied to the outer <section> element */
    anchorId?: string;
    title: string;
    enableHeading?: boolean;
    background?: ThemeKey$1;
    items: AccordionItem[];
    maxWidth?: boolean;
    /** Array of anchorIds that should be expanded on mount */
    initialExpandedItems?: string[];
    /** Enable URL hash auto-expand on mount */
    hashAutoExpand?: boolean;
    /** Max-width class for item descriptions (default: "max-w-[980px]") */
    descriptionMaxWidth?: string;
    /** Custom class for the accordion list wrapper */
    itemContainerClassName?: string;
};
type ThemeKey$1 = "blue" | "green" | "yellow" | "purple" | "white" | "navy" | "cream500";

declare const Accordion: React__default.FC<AccordionProps>;

type ButtonProps = {
    showButtonAs?: "solid" | "text" | "unstyled" | "button-with-icon" | "text-with-icon";
    buttonVariant?: "primary_brand" | "secondary" | "primary_inverse";
    buttonLabel?: string;
    buttonPrefix?: string;
    badge?: string;
    badgeIcon?: string;
    buttonIconName?: string;
    buttonIconPosition?: "left" | "right";
    href?: string;
    target?: "_self" | "_blank";
    anchorId?: string;
    preserveQueryParameters?: boolean;
    clickToOpen?: string;
    tabmodalNameToOpen?: string;
    idNameToOpen?: string;
    preDefinedFunctionExecution?: string;
    renderCheckPlans?: (overrides?: CheckPlansProps) => React__default.ReactNode;
    linkClassName?: string;
    buttonClassName?: string;
    linkVariant?: "unstyled" | "default";
    fullWidth?: boolean;
    size?: ResponsiveSize;
    onClick?: (event: React__default.MouseEvent<HTMLAnchorElement | HTMLButtonElement>) => void;
    children?: React__default.ReactNode;
    modalTitle?: string;
    modalSubtitle?: string;
    onModalButtonClick?: (id?: string) => void;
    iconName?: string;
    iconFill?: Fill;
    iconSize?: Size;
    disableAnimation?: boolean;
    animationType?: AnimationType | AnimationType[];
};

type CalloutCardType = "simple" | "blog" | "fullImage" | "floatingImage";
type CalloutCtaProps = ButtonProps & {
    label?: string;
};
type CalloutItem = {
    /**
     * Optional per-item card type. When provided, overrides the top-level
     * `cardType` for this single item — enables mixed card variants in one
     * Callout (e.g. one full-image + two simple cards).
     */
    cardType?: CalloutCardType;
    [key: string]: any;
};
type CalloutProps = {
    /** Outer `<section>` id — anchor link target. */
    anchorId?: string;
    title?: string;
    enableHeading?: boolean;
    subtitle?: string;
    description?: string;
    finePrint?: ReactNode;
    cta?: CalloutCtaProps;
    applyBoxShadow?: boolean;
    cardStackingMobile?: boolean;
    color?: "dark" | "light";
    /**
     * When `true` (default) cards are laid out in a responsive Tailwind
     * grid sized by `maxCardsPerRow`. When `false` the cards stretch
     * full-width and stack vertically (no inner widths).
     *
     * Accepts a string for backward compatibility with legacy consumers
     * that pass a Tailwind width class (e.g. "w-1/2"); any truthy value
     * enables grid mode — the string itself is not applied.
     */
    cardsWidth?: boolean | string;
    maxCardsPerRow?: number;
    noGutter?: boolean;
    items: CalloutItem[];
    maxWidth?: boolean;
    /** Top-level card type used when an item does not specify its own. */
    cardType?: CalloutCardType;
    /**
     * Background color token. When omitted the section has no background
     * (preserves prior behavior for existing 0.1.70 consumers).
     */
    backgroundColor?: "cream500" | "gray100" | "white" | "transparent" | "blue" | "green" | "navy" | "purple" | "yellow";
    /** Raw background CSS value (overrides `backgroundColor` when present). */
    background?: string;
    /** Inline text color override applied to the heading region. */
    textColor?: string;
    /** Extra class names for the outer <section>. */
    containerClassName?: string;
    /** Extra class names for the inner content wrapper. */
    innerClassName?: string;
    /** Disable card hover/tap animations. */
    disableAnimation?: boolean;
    /** Animation type(s) applied to each card. */
    animationType?: AnimationType | AnimationType[];
};

declare const Callout: React__default.FC<CalloutProps>;

type CardsProps = {};

declare const Cards: React.FC<{
    fields: CardsProps;
}>;

type PinwheelColor = "Blue-#307998" | "Green-#209A61" | "Orange-#DE7E0A" | "Purple-#7E1458" | (string & {});
type SimpleCardCtaBottom = {
    title?: string;
    href?: string;
};
type Item = {
    title?: string;
    image?: string;
    imageAlt?: string;
    imageWidth?: number;
    imageHeight?: number;
    imageAlignment?: "left" | "right" | "center";
    iconAlignment?: "left" | "right" | "center";
    /**
     * Layout variant for the image. `standard` / `icon` render an inline
     * icon above the content. `full` renders a full-bleed top image.
     * `margin` is `full` with horizontal padding.
     */
    imageView?: "standard" | "icon" | "full" | "margin" | "inset";
    body?: ReactNode;
    /** Optional secondary rich-text region (port of local `richText`). */
    richText?: ReactNode;
    cta?: ButtonProps;
    ctaAlignment?: "left" | "right" | "center";
    /** Top "location" CTA, rendered above the title with a `location_on` icon. */
    ctaBottom?: SimpleCardCtaBottom;
    ctaAlignmentBottom?: "left" | "right" | "center";
    /** Legacy token-based card background (mapped via `backgroundColorMap`). */
    backgroundColor?: string;
    /** Raw color value used when `applyCardBackgroundColor` is true. */
    applyCardBackgroundColor?: boolean;
    textColor?: string;
    showBackgroundImage?: boolean;
    pinwheelColor?: PinwheelColor;
    /** On `lg:` and up, lays out icon + content side-by-side. */
    imageToRichTextAlignment?: boolean;
    /** Bold label between title and the phone/hours table. */
    titleLocation?: string;
    phoneNumber?: string[];
    /** Each entry uses a `label|value` separator. */
    workingHours?: string[];
    shadow?: boolean;
};
type SimpleCardProps = {
    card: Item;
    lgWidth?: string;
    mdWidth?: string;
    className?: string;
    contentClassName?: string;
    style?: CSSProperties;
};

declare const SimpleCard: React__default.FC<SimpleCardProps>;

interface carouselFieldsInterface {
    __typename: "ComponentCarousel";
    sys: {
        id: string;
    };
    entryName?: string;
    anchorId?: string;
    title?: string;
    subTitle?: string;
    rotationTiming?: number;
    showArrows?: boolean;
    autoRotate?: boolean;
    initialSlideIndex?: number;
    infiniteScroll?: boolean;
    mobileNavigationType?: boolean;
    disclaimerText?: {
        json: any;
    };
    backgroundColor?: "blue" | "green" | "orange" | "purple" | "white";
    items: {
        items: Array<CarouselItemsType>;
    };
}
type CarouselItemsType = TestimonialCardFields | ProductCardFields | CardFields;
interface TestimonialCardFields {
    __typename: "ComponentTestimonialCard";
    sys: {
        id: string;
    };
    title?: string;
    author?: string;
    role?: string;
    rating?: number;
    quote?: ReactNode;
    authorImage?: {
        url: string;
        title?: string;
        width?: number;
        height?: number;
    } | null;
    avatarurl?: string;
}
interface ProductCardFields {
    __typename: "ComponentProductCard";
    sys: {
        id: string;
    };
    speed?: string;
    price?: string;
    priceSuffix?: string;
    techType?: string;
    highlighted?: boolean;
    productCardDescription?: string;
    benefitsTitle?: string;
    benefitsExpanded?: boolean;
    innerBadge?: string;
    productCategory?: string;
    benefits?: {
        items: Array<any>;
    };
    giftRewards?: {
        list?: {
            items: Array<any>;
        };
    };
    cta?: {
        buttonLabel?: string;
        [key: string]: any;
    };
    innerBadgeIcon?: {
        url: string;
        [key: string]: any;
    };
}
interface CardFields {
    __typename: "ComponentCard";
    sys: {
        id: string;
    };
    title?: string;
    subtitle?: string;
    eyebrow?: string;
    body?: {
        json: any;
    };
    image?: {
        url: string;
        [key: string]: any;
    };
    cta?: {
        buttonLabel?: string;
        [key: string]: any;
    };
    ctaBottom?: {
        buttonLabel?: string;
        [key: string]: any;
    };
}
type CarouselProps = {
    fields: carouselFieldsInterface;
    hasTestimonialCards: boolean;
    hasProductCards: boolean;
    disclaimerText: ReactNode;
    backgroundColor: string;
    activeTab: string;
    setActiveTab: (tab: string) => void;
    tabs: string[];
    showSwitch?: boolean;
    testimonialAutoScroll?: boolean;
    onModalButtonClick?: (id?: string) => void;
    renderCheckPlans?: (overrides?: CheckPlansProps) => React__default.ReactNode;
};

declare const Carousel: React__default.FC<CarouselProps>;

type FloatingBannerProps = {
    title?: string;
    enableHeading?: boolean;
    subtitle?: string;
    icon?: string;
    description?: React__default.ReactNode;
    cta?: any | null;
    disclaimer?: React__default.ReactNode;
    background?: "green" | "navy" | "white" | "purple" | "blue" | "yellow";
    color?: "dark" | "light";
    maxWidth?: boolean;
};

declare const FloatingBanner: React__default.FC<FloatingBannerProps>;

type FooterProps = {
    body: React__default.ReactNode;
    links?: Array<any>;
    bottomLinks?: Array<any>;
    copyrights?: React__default.ReactNode;
    terms?: string;
    maxWidth?: boolean;
    onClick?: (event: React__default.MouseEvent<HTMLAnchorElement | HTMLButtonElement>) => void;
};

declare const Footer: React__default.FC<FooterProps>;

type ImagePromoBarProps = {
    brow: string;
    enableHeading: boolean;
    title: string;
    subTitle: string;
    image: string;
    imageWidth: number;
    imageHeight: number;
    useOriginalImageAspectRatio?: boolean;
    isAboveTheFold?: boolean;
    mediaPosition: boolean;
    description: React__default.ReactNode;
    openDescriptionLinksOnANewTab: boolean;
    checklist: string[];
    disclaimer: React__default.ReactNode;
    imageLinks: {
        url: string;
        image: string;
    }[];
    cta: any;
    secondaryCta: any;
    ctaDisclaimer: React__default.ReactNode;
    videoLink?: VideoLinkProps;
    maxWidth?: boolean;
    color: "light" | "dark";
    enableAnimation?: boolean;
    onModalButtonClick?: (id?: string) => void;
    onClick?: (event: React__default.MouseEvent, source: "primary" | "secondary") => void;
    renderCheckPlans?: (overrides?: CheckPlansProps) => React__default.ReactNode;
};

declare const ImagePromoBar: React__default.FC<ImagePromoBarProps>;

type Color = string;
interface Navigation$1 {
    __typename?: "ComponentNavigation";
    primaryNavigationLogo?: Asset;
    anchorId?: string;
    primaryNavigationLinks?: (Button$1 | ButtonGroup)[];
    supportNavigationLinks?: ButtonGroup[];
    utilityNavigationLinks?: (Button$1 | ButtonGroup)[];
    accountNavigationLinks?: ButtonGroup[];
    searchBarIcon?: Asset;
    searchBarPlaceholder?: string;
    navigationBackgroundColor?: Color;
    utilityNavBackgroundColor?: Color;
    utilityNavLinkColor?: Color;
    /**
     * Tailwind class (or raw class string) applied to the main nav row's
     * text color, e.g. `"text-white"` or `"text-secondary-navy500"`. Used
     * by section / secondary navbars rendered on a dark background where
     * the labels need to be inverted.
     */
    navigationLinkColor?: string;
    utilityNavActiveIndex?: number;
    callNowCtaText?: string;
    callNowCtaIcon?: Asset;
    displaySearchBar?: boolean;
    displayCallNowCta?: boolean;
    displayUtilityNavigation?: boolean;
    showCallButton?: boolean;
    showMobileSliderMenu?: boolean;
    showCallNowCtaInMainNav?: boolean;
    invocaPhoneNumberLink?: string;
    invocaPhoneNumberDisplayText?: string;
    checkPlansJSX?: React__default.ReactNode;
    onSearch?: (query: string) => void;
    /** When true, renders a cart icon (desktop utility nav and mobile main nav). */
    displayCartIcon?: boolean;
    /** Final URL the cart icon should navigate to (computed by the host app). */
    cartHref?: string;
    /** When true, shows a small accent dot on the cart icon (e.g. retention/cart-recovery). */
    cartHasRetention?: boolean;
    /** Optional aria-label for the cart icon link. Defaults to "Cart". */
    cartIconAriaLabel?: string;
    /** Optional callback fired when the desktop CallButton is clicked. */
    onCallClickDesktop?: (event: React__default.MouseEvent<HTMLAnchorElement>) => void;
    /** Optional callback fired when the mobile CallButton is clicked. */
    onCallClickMobile?: (event: React__default.MouseEvent<HTMLAnchorElement>) => void;
    /** Optional callback fired when the cart icon is clicked. */
    onCartClick?: (event: React__default.MouseEvent<HTMLAnchorElement>) => void;
    /** Optional logo width in px. Defaults to 76.5. */
    primaryNavigationLogoWidth?: number;
    /** Optional logo height in px. Defaults to 24. */
    primaryNavigationLogoHeight?: number;
    /** When true, hides the CallButton from the mobile main nav row
     *  (the one next to the cart icon and hamburger). The drawer
     *  still renders the CallButton. Defaults to false. */
    hideMobileCallButton?: boolean;
}
type NavigationProps = Navigation$1;

declare const Navigation: React__default.FC<NavigationProps>;

type PrimaryHeroVideo = {
    url?: string;
    title?: string;
};
type PrimaryHeroProps = {
    title: string;
    showAsHeading?: boolean;
    subTitle?: string;
    price?: string;
    priceSuffix?: string;
    priceCallout?: string;
    pricingDescription?: string;
    pricingDescriptionDisclaimer?: string;
    checklist?: {
        title: string;
        iconUrl?: string;
        anchorId?: string;
    }[];
    logoLockup?: string;
    checkAvailabilityEyebrow?: string;
    primaryCtaPrefix1?: string;
    primaryCtaPrefix2?: string;
    primaryCta1?: any;
    primaryCta2?: any;
    hideOnMobileCta1?: boolean;
    hideOnMobileCta2?: boolean;
    secondaryCtaPrefix?: string;
    secondaryCta?: any;
    bottomLink?: any;
    carouselImages?: string[];
    heroVideo?: PrimaryHeroVideo;
    heroVideoMobile?: PrimaryHeroVideo;
    squareImage?: boolean;
    badgeImage?: string;
    textColor?: "light" | "dark";
    maxWidth?: boolean;
    renderCheckPlans?: (overrides?: CheckPlansProps) => React__default.ReactNode;
    onModalButtonClick?: (id?: string) => void;
};

declare const PrimaryHero: React__default.FC<PrimaryHeroProps>;

interface OrderedListProps {
    anchorId?: string;
    backgroundColor?: "white" | "cream";
    title: ReactNode;
    description: ReactNode;
    tabs: any[];
}

declare const OrderedList: ({ anchorId, backgroundColor, title, description, tabs, }: OrderedListProps) => react_jsx_runtime.JSX.Element;

type TextProps = {};

declare const Text: React.FC<{
    fields: TextProps;
}>;

declare const Button: React__default.FC<ButtonProps>;

type ModalProps = {
    isOpen: boolean;
    onRequestClose?: () => void;
    size?: "lg" | "md" | "sm" | "xl" | "xs";
    title?: string;
    description?: React__default.ReactNode;
    content?: React__default.ReactNode;
    children?: React__default.ReactNode;
    bodyClassName?: string;
};

type ExtendedModalProps = ModalProps & {
    type?: string;
    index?: number;
};
declare const Modal: React__default.FC<ExtendedModalProps>;

declare const svgPaths: Record<string, string>;
type ThemeKey = "blue" | "green" | "yellow" | "purple" | "white" | "navy";
type SvgPathKey = keyof typeof svgPaths;
type ShapeBackgroundWrapperProps = {
    path?: SvgPathKey;
    fill?: ThemeKey | string;
    className?: string;
    children?: React__default.ReactNode;
    maxFit?: boolean;
    background?: ThemeKey | string;
    show?: boolean;
};

declare const ShapeBackgroundWrapper: React__default.FC<ShapeBackgroundWrapperProps>;

type CtaCalloutProps = {
    title?: string;
    subTitle?: string;
    enableHeading?: boolean;
    color?: "dark" | "light";
    background?: "blue" | "green" | "navy" | "purple" | "white" | "yellow";
    description?: React__default.ReactNode;
    descriptionAlignment?: "center" | "left" | "right";
    contentAlignment?: "center" | "left" | "right";
    button?: any;
    maxWidth?: boolean;
    onModalButtonClick?: (id?: string) => void;
    renderCheckPlans?: (overrides?: CheckPlansProps) => React__default.ReactNode;
};

declare const CtaCallout: React__default.FC<CtaCalloutProps>;

type FindKineticProps = {
    title?: string;
    enableHeading?: boolean;
    subTitle?: string;
    description?: string;
    localPathPrefix?: string;
    background?: "blue" | "green" | "navy" | "purple" | "white" | "yellow";
    image?: string;
    list?: {
        name: string;
        code: string;
    }[];
    maxWidth?: boolean;
    color?: "dark" | "light";
    columns?: 2 | 3 | 4;
    addTrailingSlash?: boolean;
};

declare const FindKinetic: React__default.FC<FindKineticProps>;

type ComparisonTableProps = {
    title?: string;
    disclaimer?: React.ReactNode;
    table: React.ReactNode;
    maxWidth?: boolean;
};

declare const ComparisonTable: React__default.FC<ComparisonTableProps>;

interface TestimonialCardProps {
    title?: string;
    quote?: ReactNode;
    rating?: number;
    author?: string;
    role?: string;
    avatarUrl?: string;
    isActive?: boolean;
    className?: string;
}

declare const TestimonialCard: React__default.FC<TestimonialCardProps>;

interface ProductCardProps {
    planName: string;
    planSubtext?: string;
    speed: string;
    techType?: string;
    ismaxSpeed?: boolean;
    price: string;
    description: string;
    bestValue?: boolean;
    bestValueText?: string;
    giftBadge?: [{
        title: ReactNode;
        icon: string;
    }];
    innerBadge?: {
        badgeText: string;
        badgeIcon: string;
    };
    theme?: "light" | "dark";
    featuresTitle?: string;
    features: ReactNode[];
    isExpanded?: boolean;
    onToggleExpand?: () => void;
    ctaText?: string;
    cta?: ButtonProps$1;
    onCtaClick: () => void;
    hostType: "residential" | "smb";
    renderCheckPlans?: (overrides?: CheckPlansProps) => React__default.ReactNode;
}

declare const ProductCard: React__default.FC<ProductCardProps>;

interface BlogCardImageProps {
    src: string;
    alt: string;
    width: number;
    height: number;
    className?: string;
    sizes?: string;
    loading?: "lazy" | "eager";
    decoding?: "async" | "auto" | "sync";
    [key: string]: unknown;
}
interface BlogCardProps$2 {
    href: string;
    title?: string;
    description?: string;
    date?: string;
    category?: string;
    image?: {
        src: string;
        alt: string;
        width: number;
        height: number;
    };
    /** Pass next/image's Image component here to enable image optimization */
    imageComponent?: React__default.ComponentType<BlogCardImageProps>;
    asGrid?: boolean;
    index?: number;
}

declare const BlogCard: React__default.FC<BlogCardProps$2>;

interface BlogCardProps$1 {
    slug: string;
    title?: string;
    shortDescription?: string;
    blogCreationDate?: string;
    category?: string;
    cover?: {
        url: string;
        width?: number;
        height?: number;
        title?: string;
    };
}
interface BlogGridProps {
    paginatedArticles: BlogCardProps$1[];
    totalArticles: number;
    currentPage: number;
    totalPages: number;
    selectedCategory: BlogCategoryOption$1;
    categoryOptions: BlogCategoryOption$1[];
}
interface BlogCategoryOption$1 {
    value: string;
    label: string;
}

declare function BlogGrid({ paginatedArticles, totalArticles, currentPage, totalPages, selectedCategory, categoryOptions, }: BlogGridProps): react_jsx_runtime.JSX.Element;

interface BlogCardProps {
    slug: string;
    title?: string;
    shortDescription?: string;
    blogCreationDate?: string;
    category?: string;
    cover?: {
        url: string;
        width?: number;
        height?: number;
        title?: string;
    };
}
interface BlogGridBaseProps {
    title?: string;
    description?: string;
    paginatedArticles: BlogCardProps[];
    totalArticles: number;
    currentPage: number;
    totalPages: number;
    selectedCategory: BlogCategoryOption;
    categoryOptions: BlogCategoryOption[];
    onCategoryChange?: (category: BlogCategoryOption) => void;
    onPageChange?: (page: number) => void;
    getPageHref?: (page: number) => string;
    /** When true, render cards in a single-column list instead of a grid. */
    asList?: boolean;
    /** Pass next/image's Image component here to enable image optimization */
    imageComponent?: React__default.ComponentType<BlogCardImageProps$1>;
}
interface BlogCategoryOption {
    value: string;
    label: string;
}

declare function BlogGridBase({ title, description, paginatedArticles, totalArticles, currentPage, totalPages, selectedCategory, categoryOptions, onCategoryChange, onPageChange, getPageHref, asList, imageComponent, }: BlogGridBaseProps): react_jsx_runtime.JSX.Element;

type BreadcrumbNavigationProps = {
    links?: Array<any>;
    textColor?: "dark" | "light";
    mobileTextColor?: "dark" | "light";
    desktopTextColor?: "dark" | "light";
    maxWidth?: boolean;
    float?: "none" | "mobile" | "desktop" | "always";
};

declare const BreadcrumbNavigation: React__default.FC<BreadcrumbNavigationProps>;

type SearchBlockProps = {
    anchorId?: string;
    title?: string;
    subTitle?: string;
    searchDescription?: string;
    searchInputPlaceholder?: string;
    caption?: React__default.ReactNode;
    basicCaption?: React__default.ReactNode;
    enableHeading?: boolean;
    backgroundColor: "supporting" | "white" | "brand";
    color: "light" | "dark";
    onSubmit?: (values: {
        searchText: string;
    }) => void;
};

declare const SearchBlock: React__default.FC<SearchBlockProps>;

interface AddressInputBannerProps {
    entryName?: string;
    title: string;
    variant?: string;
    cta?: ButtonProps$1;
    navHeight?: number;
    isVisible?: boolean;
    renderCheckPlans?: (overrides?: CheckPlansProps) => React__default.ReactNode;
}

declare const AddressInputBanner: FC<AddressInputBannerProps>;

interface DynamicTabT {
    tabName: string;
    anchorId: string;
    tabContent: ReactNode;
}
interface DynamicTabsT {
    tabs?: {
        items: DynamicTabT[];
    };
    dynamic?: boolean;
    /** When isOrderedList is true, each tab's `tabContent` is rendered as columns of children. */
    isOrderedList?: boolean;
    entryTitle?: string;
    anchorId?: string;
    title?: string;
    subTitle?: string;
    description?: string;
    backgroundColor?: "white";
    textColor?: "navy";
    navigationType?: boolean;
    mobileSidebarTabType?: boolean;
}

declare function DynamicTabs(props: DynamicTabsT): react_jsx_runtime.JSX.Element;

interface AnchoredBottomBannerProps {
    ctaSuffixText?: string;
    backgroundColor?: "navy" | "yellow" | "green" | "purple" | "blue" | "white";
    iconName?: string;
    boxShadow?: boolean;
    ctaButtonLabel?: string;
    ctaButtonLink?: string;
    ctaButtonTarget?: string;
    anchorId?: string;
    enableCountdownTimer?: boolean;
    countdownStartDateTime?: string;
    countdownEndDateTime?: string;
}

declare const AnchoredBottomBanner: React__default.FC<AnchoredBottomBannerProps>;

interface TypeComponentRichTextFields {
    entryName?: string;
    anchorId?: string;
    title?: string;
    isTargetBlank?: boolean;
    richText: React.ReactNode;
}

declare function CookieBanner({ content, }: {
    content: TypeComponentRichTextFields;
}): react_jsx_runtime.JSX.Element | null;

interface EmailInputBlockProps {
    anchorId?: string;
    title?: string;
    subTitle?: string;
    emailInputDescription?: string;
    inputPlaceholder?: string;
    successFeedback?: string;
    ctaButtonText?: string;
    ctaText?: string;
    caption?: React__default.ReactNode;
    backgroundColor?: "green" | "white" | "yellow" | "blue" | "navy" | "gray90";
    themeColor?: "blue" | "green" | "orange" | "purple" | "white";
    showPinWheel?: boolean;
    padding?: "none" | "large";
    validationErrorMessage?: string;
    requiredErrorMessage?: string;
    onSubmit: (values: EmailInputFormValues) => void;
}
interface EmailInputFormValues {
    email: string;
}

declare const EmailInputBlock: React__default.FC<EmailInputBlockProps>;

interface TypeCartRetentionBannerFields {
    entryTitle?: string;
    anchorId?: string;
    mainHeading?: string;
    description?: {
        json: any;
    };
    cta?: {
        buttonLabel?: string;
        disableAnimation?: boolean;
        animationType?: AnimationType | AnimationType[];
        [key: string]: any;
    };
}

declare const CartRetentionBanner: React.FC<{
    fields: TypeCartRetentionBannerFields;
    sys?: any;
    isInPopupContainer?: boolean;
    onClose?: () => void;
    onContinueCheckout?: () => void;
    checkShouldShowBanner?: () => boolean;
    onBannerShown?: () => void;
}>;

declare const bgColorMap: {
    readonly gray90: "#464646";
    readonly green: "#24A76A";
    readonly white: "#FFFFFF";
};
type BackgroundColor = keyof typeof bgColorMap;
type IframeEmbedProps = {
    /** The full URL of the third-party iframe to embed (e.g., Brand Featured badge URL). */
    iframeUrl: string;
    /** Optional HTML `id` for the wrapping `<section>`, useful for anchor linking or scroll-to navigation. */
    anchorId?: string;
    /** Optional background color applied behind the iframe. Defaults to `"transparent"` when not provided. */
    backgroundColor?: BackgroundColor;
    /** Optional initial/minimum height (in px) for the iframe before postMessage auto-resize kicks in. */
    height?: number;
};

/**
 * IframeEmbed — A generic, responsive iframe component for embedding third-party content
 * such as Brand Featured badges, widgets, or any external HTML page.
 *
 * Features:
 * - **Auto-resize:** Listens for `postMessage` events with an `{ iframeHeight: number }` payload
 *   from the embedded page and adjusts the iframe height dynamically.
 * - **Background color:** Supports predefined background colors (`gray90`, `green`, `white`)
 *   behind the iframe, defaulting to transparent.
 * - **Lazy loading:** The iframe uses `loading="lazy"` for performance.
 * - **Anchor support:** An optional `anchorId` is applied to the wrapping `<section>` for
 *   deep-linking or scroll-to navigation.
 *
 * @example
 * ```tsx
 * <IframeEmbed
 *   iframeUrl="https://api.brandfeatured.com/badges/badge-news_dark.html?id=123"
 *   backgroundColor="green"
 *   anchorId="brand-badge"
 * />
 * ```
 */
declare const IframeEmbed: React__default.FC<IframeEmbedProps>;

declare const toDocument: (v: unknown | null | undefined) => Document | null;

/**
 * Utility function to render Contentful Rich Text.
 * Safe to use inside .map() loops.
 */
declare function renderContentfulRichText(doc: Document | null | undefined, target?: boolean, className?: string, linkClassName?: string, options?: Options): ReactNode | null;
declare function useContentfulRichText(doc: Document | null | undefined, options?: Options, config?: {
    boldClassName?: string;
}): ReactNode | null;
declare function renderContentfulRichTextTable(doc: Document | null | undefined, links?: any): ReactNode;

declare const label1BoldOptions: {
    renderMark: {
        bold: (text: ReactNode) => React$1.DetailedReactHTMLElement<{
            className: string;
        }, HTMLElement>;
    };
};
interface ProcessedChecklistItem {
    title: string;
    iconUrl?: string;
    anchorId?: string;
}
declare function useProcessedChecklist<T extends boolean = false>(checklistData?: any, titlesOnly?: T, richTextOptions?: Options, richTextClassName?: string): T extends true ? string[] : ProcessedChecklistItem[];

export { Accordion, AddressInputBanner, AnchoredBottomBanner, BlogCard, BlogGrid, BlogGridBase, BreadcrumbNavigation, Button, Callout, Cards, Carousel, CartRetentionBanner, ComparisonTable, CookieBanner, CtaCallout, DynamicTabs, EmailInputBlock, FindKinetic, FloatingBanner, Footer, IframeEmbed, ImagePromoBar, Modal, Navigation, OrderedList, PrimaryHero, ProductCard, SearchBlock, ShapeBackgroundWrapper, SimpleCard, TestimonialCard, Text, label1BoldOptions, renderContentfulRichText, renderContentfulRichTextTable, toDocument, useContentfulRichText, useProcessedChecklist };
export type { AccordionProps, AddressInputBannerProps, AnchoredBottomBannerProps, BlogCardProps$2 as BlogCardProps, BlogGridBaseProps, BlogGridProps, BreadcrumbNavigationProps, ButtonProps, CalloutProps, CardsProps, CarouselProps, TypeCartRetentionBannerFields as CartRetentionBannerProps, ComparisonTableProps, TypeComponentRichTextFields as CookieBannerProps, CtaCalloutProps, DynamicTabsT, EmailInputBlockProps, FindKineticProps, FloatingBannerProps, FooterProps, IframeEmbedProps, ImagePromoBarProps, ModalProps, NavigationProps, OrderedListProps, PrimaryHeroProps, ProcessedChecklistItem, ProductCardProps, SearchBlockProps, ShapeBackgroundWrapperProps, SimpleCardProps, TestimonialCardProps, TextProps };