import * as React$1 from 'react';
import React__default, { InputHTMLAttributes, ReactNode, ForwardRefRenderFunction, ImgHTMLAttributes, ComponentType, ForwardRefExoticComponent, RefAttributes, AnchorHTMLAttributes, MouseEvent, CSSProperties, HTMLAttributes, LiHTMLAttributes, ButtonHTMLAttributes, LabelHTMLAttributes, FC, ReactElement } from 'react';
export { ButtonHTMLAttributes, CSSProperties, ReactNode } from 'react';
import { ButtonProps as ButtonProps$1 } from '@shared/components/button/types';
export { ButtonProps } from '@shared/components/button/types';
import { ImageProps as ImageProps$1 } from '@shared/components/image/types';
import { ImageProps as ImageProps$2 } from 'next/image';
import * as react_jsx_runtime from 'react/jsx-runtime';
import { CallButtonProps } from '@shared/components/call-button/types';
export { CallButtonProps } from '@shared/components/call-button/types';
import { Props } from 'react-modal';
import { AccordionProps } from '@shared/components/accordion/types';
export { AccordionProps } from '@shared/components/accordion/types';
import { Props as Props$1 } from 'react-select';
import { TextVariant as TextVariant$1 } from '@shared/components/text';
import { ButtonProps as ButtonProps$2 } from '@shared/components/brand-button/types';
import { ChecklistProps } from '@shared/components/checklist/types';
export { ChecklistItem, ChecklistProps } from '@shared/components/checklist/types';
import { SeeMoreProps } from '@shared/components/see-more/types';
export { SeeMoreProps } from '@shared/components/see-more/types';
import { ButtonProps as ButtonProps$3 } from '@shared/contentful/blocks/button/types';
import { CheckPlansProps } from '@shared/types/micro-components';
import { HTMLMotionProps } from 'framer-motion';
import { ClassValue } from 'clsx';
export { ClassValue, clsx } from 'clsx';
import { IconName as IconName$1, Size as Size$2, Fill as Fill$1 } from '@shared/components/material-icon/types';
import { AnimationType as AnimationType$1 } from '@shared/components/animation-wrapper';

declare const Button: React$1.ForwardRefExoticComponent<ButtonProps$1 & React$1.RefAttributes<HTMLButtonElement>>;

type InputProps = Omit<InputHTMLAttributes<HTMLInputElement>, "size"> & {
    loading?: boolean;
    iconLeft?: ReactNode;
    size?: "sm" | "md";
    hasError?: boolean;
    label?: string;
    labelClassName?: string;
    containerClassName?: string;
    mapPinIcon?: boolean;
    isLightMapPinIcon?: boolean;
    passwordToggle?: boolean;
    helperText?: string;
    error?: string;
    variant?: "default" | "unstyled";
};
type InputFieldProps = Omit<InputHTMLAttributes<HTMLInputElement>, "size"> & {
    state?: "default" | "focus" | "active" | "hover" | "filled" | "error";
    size?: "slim" | "medium" | "large";
    label?: string;
    errorText?: string;
    prefixIconName?: "location_on" | "search";
    prefixIconSize?: 20 | 24 | 40 | 48;
    prefixIconFill?: boolean;
    suffixIconFill?: boolean;
    suffixIconName?: "visibility" | "visibility_off" | "lock";
    suffixIconSize?: 20 | 24 | 40 | 48;
    containerClassName?: string;
    prefixIconClassName?: string;
    loading?: boolean;
    hasError?: boolean;
};

declare const InputField: ForwardRefRenderFunction<HTMLInputElement, InputFieldProps>;
declare const Input: React$1.ForwardRefExoticComponent<Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "size"> & {
    state?: "default" | "focus" | "active" | "hover" | "filled" | "error" | undefined;
    size?: "slim" | "medium" | "large" | undefined;
    label?: string | undefined;
    errorText?: string | undefined;
    prefixIconName?: "search" | "location_on" | undefined;
    prefixIconSize?: 20 | 24 | 40 | 48 | undefined;
    prefixIconFill?: boolean | undefined;
    suffixIconFill?: boolean | undefined;
    suffixIconName?: "visibility" | "visibility_off" | "lock" | undefined;
    suffixIconSize?: 20 | 24 | 40 | 48 | undefined;
    containerClassName?: string | undefined;
    prefixIconClassName?: string | undefined;
    loading?: boolean | undefined;
    hasError?: boolean | undefined;
} & React$1.RefAttributes<HTMLInputElement>>;

/**
 * Props passed to the custom image component when using the `as` prop.
 * Covers native img attributes plus optional Next.js Image props (fill, sizes, priority, etc.).
 */
interface ImageComponentProps extends Omit<ImgHTMLAttributes<HTMLImageElement>, "alt"> {
    /** Image source URL */
    src: string;
    /** Alt text (required for accessibility; use "" for decorative images) */
    alt: string;
    /** Optional; used by Next.js Image when using fill layout */
    fill?: boolean;
    /** Optional; used by Next.js Image for responsive sizes */
    sizes?: string;
    /** Optional; used by Next.js Image for priority loading */
    priority?: boolean;
    /** Optional; used by Next.js Image for blur placeholder */
    placeholder?: "blur" | "empty";
    /** Optional; used by Next.js Image for quality (1–100) */
    quality?: number;
}
/** Type for custom image component that supports ref forwarding */
type ImageComponent = ComponentType<ImageComponentProps> | ForwardRefExoticComponent<ImageComponentProps & RefAttributes<HTMLImageElement>>;
interface ImageProps extends ImageComponentProps {
    /** Custom component to render instead of native img (e.g. next/image) */
    as?: ImageComponent;
}

declare const Image: React$1.ForwardRefExoticComponent<ImageProps$1 & React$1.RefAttributes<HTMLImageElement>>;

interface NextImageComponentProps extends ImageProps$2 {
    className?: string;
}
declare const NextImage: React$1.ForwardRefExoticComponent<NextImageComponentProps & React$1.RefAttributes<HTMLImageElement>>;

interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
    /** Content to render inside the link */
    children: ReactNode;
    /** URL to navigate to */
    href?: string;
    /** Custom className for the link */
    className?: string;
    /** Click handler function */
    onClick?: (event: MouseEvent<HTMLAnchorElement>) => void;
    /** Additional styling options */
    variant?: "default" | "unstyled";
    /** Custom styles */
    style?: CSSProperties;
    /** External link behavior - opens in new tab */
    external?: boolean;
    /** Disable the link */
    disabled?: boolean;
}

declare const Link: React__default.ForwardRefExoticComponent<LinkProps & React__default.RefAttributes<HTMLAnchorElement>>;

type ListType = "ul" | "ol";
type ListVariant = "default" | "unstyled";
type ListItem$1 = {
    id: string | number;
    content: ReactNode;
    className?: string;
    [key: string]: any;
};
interface ListProps extends Omit<HTMLAttributes<HTMLUListElement | HTMLOListElement>, "type"> {
    /** List type - unordered (ul) or ordered (ol) */
    type?: ListType;
    /** Array of items to render */
    items?: ListItem$1[];
    /** Custom className for the list */
    className?: string;
    /** Custom item renderer function */
    renderItem?: (item: ListItem$1, index: number) => ReactNode;
    /** Children to render instead of items */
    children?: ReactNode;
    /** Additional styling options */
    variant?: ListVariant;
    /** Custom styles */
    style?: CSSProperties;
}

interface ListItemProps extends LiHTMLAttributes<HTMLLIElement> {
    /** Content to render inside the list item */
    children: ReactNode;
    /** Custom className for the list item */
    className?: string;
    /** Additional styling options */
    variant?: ListVariant;
    /** Custom styles */
    style?: CSSProperties;
}

declare const ListItem: React$1.ForwardRefExoticComponent<ListItemProps & React$1.RefAttributes<HTMLLIElement>>;

declare const List: React__default.ForwardRefExoticComponent<ListProps & React__default.RefAttributes<HTMLUListElement | HTMLOListElement>>;

declare const iconNameList: readonly ["info", "download", "featured_seasonal_and_gifts", "visibility", "paid", "check_box", "check_box_outline_blank", "radio_button_unchecked", "radio_button_checked", "counter_1", "counter_2", "counter_3", "error", "search", "cancel", "router", "broadcast_on_home", "check", "check_circle", "lock", "shield_lock", "phone_in_talk", "call", "chevron_left", "chevron_right", "keyboard_arrow_down", "keyboard_arrow_up", "arrow_back", "arrow_forward", "help", "home_pin", "location_on", "timer", "schedule", "add", "remove", "bolt", "rocket", "cloud_sync", "close", "groups", "speed", "mail", "credit_card", "language", "forum", "contract", "local_atm", "headset_mic", "sensors", "wifi", "settings", "home", "devices", "build", "thumb_up", "desktop_windows", "block", "all_inclusive", "verified_user", "extension", "stadia_controller", "visibility_off", "close_fullscreen", "progress_activity", "travel_explore", "share", "business_center", "upload", "videocam", "expand_circle_right", "add_circle", "do_not_disturb_on", "expand_circle_up", "expand_circle_down", "replay", "fiber_manual_record", "menu", "dangerous", "star", "play_arrow", "calendar_clock", "shopping_cart"];
declare const OpticalSizes: readonly ["20dp", "24dp", "40dp", "48dp"];
declare const weights: readonly ["100", "200", "300", "400", "500", "600", "700"];
declare const emphasis: readonly [-25, 0, 200];
declare const sizes: readonly [20, 24, 32, 40, 48, 52];

type Fill = 1 | 0;
type IconName = (typeof iconNameList)[number];
type OpticalSize = (typeof OpticalSizes)[number];
type Weight = (typeof weights)[number];
type Emphasis = (typeof emphasis)[number];
type Size$1 = (typeof sizes)[number];
type IconProps = {
    name: IconName;
    fill?: Fill;
    opticalSize?: OpticalSize;
    weight?: Weight;
    emphasis?: Emphasis;
    size?: Size$1;
    color?: string;
    style?: CSSProperties;
    className?: string;
    onClick?: () => void;
    dataTestId?: string;
};

declare const MaterialIcon: React__default.FC<IconProps>;

type SpinnerProps = {
    size?: "small" | "medium" | "large" | "xlarge";
    color?: string;
    className?: string;
} & React.HTMLAttributes<HTMLDivElement>;

declare const Spinner: React__default.FunctionComponent<SpinnerProps>;

type TextVariant = "heading1" | "heading2" | "heading3" | "heading4" | "heading5" | "heading6" | "subheading1" | "subheading2" | "subheading3" | "subheading4" | "subheading5" | "subheading6" | "body1" | "body2" | "body3" | "footnote" | "micro" | "label1" | "label2" | "label3" | "label4" | "error" | "unstyled";
interface TextProps extends HTMLAttributes<HTMLElement> {
    /** Content to render inside the text element */
    children?: ReactNode;
    /** Custom HTML element to render as */
    as?: keyof React$1.JSX.IntrinsicElements;
    /** Custom className for the text */
    className?: string;
    /** Custom styles */
    style?: CSSProperties;
}

declare const Text: React__default.ForwardRefExoticComponent<TextProps & React__default.RefAttributes<HTMLElement>>;

declare const CallButton: {
    (props: CallButtonProps): react_jsx_runtime.JSX.Element;
    displayName: string;
};

type Size = "xl" | "lg" | "md" | "sm" | "xs";
type Shape = "rounded" | "default";
type Animation = "popper" | "bottomSheet";
type OwnProps$2 = {
    size?: Size;
    shape?: Shape;
    title?: string;
    bodyClassName?: string | null | undefined;
    closeWrapperClassName?: string | null | undefined;
    closeButtonClassName?: string | null | undefined;
    bodyStyle?: React.CSSProperties;
    centered?: boolean;
    hideScrollOnIsOpenFalse?: boolean;
    parentSelector?: string;
    animation?: Animation;
    hideCloseButton?: boolean;
    ["data-testid"]?: string;
    ["data-cy"]?: string;
};
type ModalProps = OwnProps$2 & Props;

declare const Modal: React__default.FC<ModalProps>;

declare const Accordion: React.FC<AccordionProps>;

type InfoIconProps = {
    onClick?: () => void;
    dataTestId?: string;
    iconSize?: number;
};
type CheckboxProps = {
    checked?: boolean;
    onChange?: ((isChecked: boolean) => void) | (() => void);
    state?: "default" | "focus" | "disabled";
    className?: string;
    containerClassName?: string;
    label?: string | ReactNode;
    labelClassName?: string;
    name?: string;
    value?: string | number | boolean;
    id?: string;
    disabled?: boolean;
    required?: boolean;
    error?: boolean;
    "data-cy"?: string;
    renderInfoIcon?: InfoIconProps;
} & Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "checked" | "onChange">;

declare const Checkbox: React__default.FC<CheckboxProps>;

interface SelectOption<T = any> {
    label: string;
    value: string;
    data?: T;
}
type FilterOptions = {
    ignoreCase?: boolean;
    ignoreAccents?: boolean;
    trim?: boolean;
    matchFrom?: "start" | "any";
};
type OwnProps$1 = {
    options: SelectOption[];
    value?: SelectOption;
    className?: string;
    isCustomStyle?: boolean;
    controlClassName?: string;
    menuClassName?: string;
    filterOptions?: FilterOptions;
    hasError?: boolean;
    error?: string;
    helperText?: string;
    label?: string;
    labelClassName?: string;
    singleValueClassName?: string;
    size?: "sm" | "md" | "lg";
    variant?: "default" | "unstyled";
    "data-cy"?: string;
    "data-testid"?: string;
};
type SelectProps = OwnProps$1 & Omit<Props$1<SelectOption>, "options" | "value" | "className">;

declare const Select: React__default.FC<SelectProps>;

type AlertCardProps = {
    errorMessage?: string | ReactNode;
    className?: string;
    iconName?: IconName;
    iconClassName?: string;
    textVariant?: TextVariant$1;
    iconSize?: Size$1;
};

declare const AlertCard: React__default.FC<AlertCardProps>;

type ButtonVariantsT = "primary_brand" | "primary_inverse" | "secondary";
type ButtonSizeT = "small" | "medium" | "large" | "x-large";
type ResponsiveSize = {
    base?: ButtonSizeT;
    md?: ButtonSizeT;
    lg?: ButtonSizeT;
};
type ButtonCustomProps = {
    /** Button styling variant */
    variant?: ButtonVariantsT;
    /** Loading state - shows spinner and disables button */
    isLoading?: boolean;
    label?: string;
    text?: string;
    disabled?: boolean;
    fullWidth?: boolean;
    buttonClassName?: string;
    size?: ResponsiveSize;
    iconName?: IconName$1;
    iconSize?: Size$2;
    iconFill?: Fill$1;
    disableAnimation?: boolean;
    animationType?: AnimationType$1 | AnimationType$1[];
};
type ButtonAsButton = ButtonCustomProps & Omit<ButtonHTMLAttributes<HTMLButtonElement>, "children" | "className"> & {
    as?: "button";
};
type ButtonAsAnchor = ButtonCustomProps & Omit<AnchorHTMLAttributes<HTMLAnchorElement>, "children" | "className"> & {
    as: "a";
    href: string;
};
type ButtonProps = ButtonAsButton | ButtonAsAnchor;

declare const BrandButton: React__default.ForwardRefExoticComponent<ButtonProps$2 & React__default.RefAttributes<HTMLAnchorElement | HTMLButtonElement>>;

declare const Checklist: React__default.FC<ChecklistProps>;

type CollapsibleProps = {
    open: boolean;
    children: React__default.ReactNode;
};

declare const Collapse: {
    (props: CollapsibleProps): react_jsx_runtime.JSX.Element;
    displayName: string;
};

type DividerProps = {
    className?: string;
} & React.HTMLAttributes<HTMLDivElement>;

declare const Divider: React__default.FC<DividerProps>;

type OwnProps = {
    name: string;
    value?: string | number;
    checked?: boolean;
    onChange?: (newVal?: string | number) => void;
    label?: string | ReactNode;
    subText?: string;
    className?: string;
    labelProps?: LabelHTMLAttributes<HTMLLabelElement>;
    variant?: "circle";
    hasError?: boolean;
    "data-cy"?: string;
    labelClassName?: string;
};
type RadioButtonProps = OwnProps & Omit<InputHTMLAttributes<HTMLInputElement>, "onChange" | "value" | "name" | "checked">;

declare const RadioButton: React__default.FC<RadioButtonProps>;

declare const SeeMore: React.FC<SeeMoreProps>;

type SelectPlanButtonProps = {
    onSelect: () => void;
    speed: string;
    techType?: string;
    isMax?: boolean;
    iconSize?: Size$1;
    isSelected?: boolean;
    iconClassName?: string;
    renderCheckPlans?: (overrides?: CheckPlansProps) => React__default.ReactNode;
    cta?: ButtonProps$3;
};

declare const SelectPlanButton: React__default.FC<SelectPlanButtonProps>;

type SkeletonProps = {
    className?: string;
    count?: number;
};

declare const Skeleton: FC<SkeletonProps>;

declare const PageSkeleton: FC;

type ToolTipProps = {
    tooltipMsg: string;
    children: ReactNode;
    className?: string;
};

declare function Tooltip({ tooltipMsg, className, children }: ToolTipProps): react_jsx_runtime.JSX.Element;
declare namespace Tooltip {
    var displayName: string;
}

type AnimationType = "scale" | "shadow" | "lift" | "opacity" | "grow" | "pop";
/**
 * Single source of truth for the default button animation type.
 * Change this value to update the default button animation across the app.
 */
declare const DEFAULT_BUTTON_ANIMATION_TYPE: AnimationType;
interface AnimationWrapperProps extends Omit<HTMLMotionProps<"div">, "children"> {
    children: ReactElement;
    animationType?: AnimationType | AnimationType[];
    disableAnimation?: boolean;
}

declare function AnimationWrapper({ children, animationType, disableAnimation, whileHover, whileTap, transition, ...motionProps }: AnimationWrapperProps): react_jsx_runtime.JSX.Element;
declare namespace AnimationWrapper {
    var displayName: string;
}

type ViewCartButtonProps = {
    cartTotalText: string;
    onClick: () => void;
    isOpen: boolean;
} & React.ButtonHTMLAttributes<HTMLButtonElement>;

declare const ViewCartButton: React.FC<ViewCartButtonProps>;

/**
 * A custom hook that locks the body scroll based on the `isOpen` and `hideScrollOnIsOpenFalse` flags.
 *
 * @param {boolean} isOpen - Determines if the scroll should be locked (hidden).
 * @param {boolean} hideScrollOnIsOpenFalse - Determines if the scroll should be reset when `isOpen` is false.
 */
declare function useBodyScrollLock(isOpen: boolean, hideScrollOnIsOpenFalse: boolean): void;

/**
 * Configuration options for the carousel swipe behavior
 */
interface CarouselSwipeConfig {
    /** Total number of items in the carousel */
    itemCount: number;
    /** Percentage of card width to offset each slide (default: 105) */
    cardOffsetPercentage?: number;
    /** Percentage of container width needed to trigger slide change (default: 0.15) */
    swipeThreshold?: number;
    /** Mobile breakpoint in pixels (default: 768) */
    mobileBreakpoint?: number;
    /** Auto-scroll interval in milliseconds (default: 8000). Set to 0 to disable. */
    autoScrollInterval?: number;
    /** Enable auto-scroll (default: true) */
    enableAutoScroll?: boolean;
}
/**
 * Return value from the useCarouselSwipe hook
 */
interface CarouselSwipeReturn {
    /** Current active slide index */
    currentIndex: number;
    /** Current swipe offset in pixels */
    swipeOffset: number;
    /** Whether user is currently swiping */
    isSwiping: boolean;
    /** Whether viewport is mobile size */
    isMobile: boolean;
    /** Memoized container width */
    containerWidth: number;
    /** Ref to attach to the carousel container element */
    containerRef: React__default.RefObject<HTMLDivElement>;
    /** Navigate to next slide */
    nextSlide: () => void;
    /** Navigate to previous slide */
    prevSlide: () => void;
    /** Navigate to specific slide index */
    goToSlide: (index: number) => void;
    /** Touch start handler */
    handleTouchStart: (e: React__default.TouchEvent) => void;
    /** Touch move handler */
    handleTouchMove: (e: React__default.TouchEvent) => void;
    /** Touch end handler */
    handleTouchEnd: () => void;
    /** Constants used for calculations */
    constants: {
        CARD_OFFSET_PERCENTAGE: number;
        SWIPE_THRESHOLD: number;
        MOBILE_BREAKPOINT: number;
        AUTO_SCROLL_INTERVAL: number;
    };
}
/**
 * Custom hook for implementing swipe/touch gestures in carousels
 *
 * Features:
 * - Touch/swipe support with smooth finger-following
 * - Auto-scroll with pause on interaction
 * - Responsive mobile detection with resize listener
 * - Performance optimized with memoization
 * - Configurable thresholds and behavior
 *
 * @example
 * ```tsx
 * const carousel = useCarouselSwipe({
 *   itemCount: items.length,
 *   autoScrollInterval: 5000,
 * });
 *
 * return (
 *   <div
 *     ref={carousel.containerRef}
 *     onTouchStart={carousel.handleTouchStart}
 *     onTouchMove={carousel.handleTouchMove}
 *     onTouchEnd={carousel.handleTouchEnd}
 *   >
 *     {items.map((item, index) => (
 *       <div
 *         key={index}
 *         style={{
 *           transform: `translateX(${calculateTransform(index, carousel)})`,
 *         }}
 *       >
 *         {item}
 *       </div>
 *     ))}
 *   </div>
 * );
 * ```
 */
declare function useCarouselSwipe(config: CarouselSwipeConfig): CarouselSwipeReturn;

/**
 * Utility function to combine class names using clsx
 * @param inputs - Class values to combine
 * @returns Combined class string
 */
declare const cx: (...val: ClassValue[]) => string;

export { Accordion, AlertCard, AnimationWrapper, BrandButton, Button, CallButton, Checkbox, Checklist, Collapse, DEFAULT_BUTTON_ANIMATION_TYPE, Divider, Image, Input, InputField, Link, List, ListItem, MaterialIcon, Modal, NextImage, PageSkeleton, RadioButton, SeeMore, Select, SelectPlanButton, Skeleton, Spinner, Text, Input as TextInput, Tooltip, ViewCartButton, cx, useBodyScrollLock, useCarouselSwipe };
export type { AlertCardProps, Animation, AnimationType, AnimationWrapperProps, ButtonProps as BrandButtonProps, ButtonSizeT, ButtonVariantsT, CarouselSwipeConfig, CarouselSwipeReturn, CheckboxProps, CollapsibleProps, DividerProps, FilterOptions, IconName, IconProps, ImageComponentProps, ImageProps, InputFieldProps, InputProps, LinkProps, ListItemProps, ListProps, ModalProps, NextImageComponentProps, RadioButtonProps, ResponsiveSize, SelectOption, SelectPlanButtonProps, SelectProps, Shape, Size, SkeletonProps, SpinnerProps, TextProps, TextVariant, ToolTipProps, ViewCartButtonProps };