import React$1, { ReactNode, ReactElement, HTMLAttributes, AnchorHTMLAttributes, FC } from 'react';
import * as react_jsx_runtime from 'react/jsx-runtime';

interface AccordionProps$1 {
    /** Heading level from 1 to 6 */
    headingLevel?: number;
    /** Accordion is enclosed in another component */
    isEnclosed?: boolean;
    /** If true, the top border on the first item will be removed */
    noTopBorder?: boolean;
    /** Adjustable spacing */
    size?: "large";
    /** Additional CSS classes */
    className?: string;
    /** Accordion content */
    children: ReactNode;
    /** Additional HTML attributes */
    [key: string]: any;
}
declare const Accordion: React$1.FC<AccordionProps$1>;

interface AccordionHeaderProps {
    /** Header id */
    id: string;
    /** Active state */
    isActive?: boolean;
    /** Header title */
    title: string;
    renderTitle?: (title: string) => React$1.ReactNode;
    /** Additional CSS classes */
    className?: string;
    /** Custom toggle attribute for specialized accordions (defaults to 'data-accordion-toggle') */
    toggleAttribute?: string;
    /** Additional HTML attributes */
    [key: string]: any;
}

interface AccordionItemProps extends Pick<AccordionHeaderProps, "renderTitle"> {
    /** Accordion item id (automatically generated by default)  */
    id?: string;
    /** Open state indication */
    isActive?: boolean;
    /** Custom header renderer. Receives title, id and isActive props as function parameters. */
    renderHeader?: (title: string, id: string, isActive: boolean) => ReactNode;
    /** Title of accordion item */
    title: string;
    /** Additional CSS classes */
    className?: string;
    /** Accordion item content */
    children: ReactNode;
    /** Additional HTML attributes */
    [key: string]: any;
}
declare const AccordionItem: React$1.FC<AccordionItemProps>;

type AlertType = "warning" | "info" | "danger" | "success";
interface AlertProps extends React$1.HTMLAttributes<HTMLDivElement> {
    /** Additional action buttons to add interactivity */
    actionButtons?: React$1.ReactNode;
    /** Description of the alert */
    description?: React$1.ReactNode;
    /** Level of the heading in heading hierarchy */
    headingLevel?: number;
    /** Sets Alert to full width */
    isFullWidth?: boolean;
    /** Callback function when close button is clicked */
    onClose?: () => void;
    /** Custom title renderer. Passes props as function parameter. */
    renderTitle?: (props: AlertProps) => React$1.ReactNode;
    /** Main text message */
    title?: string;
    /** Type of alert, sets icon and color */
    type?: AlertType;
    className?: string;
}
declare const Alert: React$1.FC<AlertProps>;

interface AnchorNavigationItem {
    label: string;
    href: string;
    isActive?: boolean;
}
interface AnchorNavigationProps {
    items: AnchorNavigationItem[];
    className?: string;
    children?: React$1.ReactNode;
}
declare const AnchorNavigation: {
    ({ items, className, children, ...other }: AnchorNavigationProps): react_jsx_runtime.JSX.Element;
    displayName: string;
};

type BarAlign = "start" | "end" | "center";
type BarSpace = "small" | "large";
interface BarProps extends React$1.HTMLAttributes<HTMLElement> {
    /** Flex vertical alignment */
    align?: BarAlign;
    /** Allow horizontally stacked items to wrap into new lines */
    canWrap?: boolean;
    /** Stack BarItems vertically */
    isVertical?: boolean;
    /** Item spacing */
    space?: BarSpace;
    /** Html tag to render */
    tag?: React$1.ElementType;
    /** Additional class names */
    className?: string;
    /** Child content */
    children?: React$1.ReactNode;
}
declare const Bar: React$1.ForwardRefExoticComponent<BarProps & React$1.RefAttributes<HTMLElement>>;

interface BarBreakProps extends React$1.HTMLAttributes<HTMLElement> {
    /** HTML tag to render the compontent with */
    tag?: React$1.ElementType;
    /** Additional class names */
    className?: string;
    /** Child content */
    children?: React$1.ReactNode;
}
declare const BarBreak: React$1.ForwardRefExoticComponent<BarBreakProps & React$1.RefAttributes<HTMLElement>>;

interface CommonProps$3 {
    /** Bar item could shrink and wrap content if there is not enough empty space */
    canShrink?: boolean;
    /** Bar item should fill empty space */
    isFilling?: boolean;
    /** Tag of the item */
    tag?: React$1.ElementType;
    /** Additional class name */
    className?: string;
    /** Child content */
    children?: React$1.ReactNode;
}
declare const BarItem: React$1.ForwardRefExoticComponent<CommonProps$3 & React$1.HTMLAttributes<HTMLElement> & React$1.RefAttributes<HTMLElement>>;

interface BlockActionProps {
    /** 1 and only one single element */
    children: ReactElement;
    className?: string;
    /** Add border on hover */
    hasBorderOnHover?: boolean;
    [key: string]: any;
}
declare const BlockAction: React$1.FC<BlockActionProps>;

interface BlockActionControlProps {
    /** 1 and only one single element */
    children: ReactElement;
    className?: string;
    [key: string]: any;
}
declare const BlockActionControl: React$1.FC<BlockActionControlProps>;

interface BlockActionIndicatorProps {
    /** 1 and only one single element */
    children: ReactElement;
    className?: string;
    [key: string]: any;
}
declare const BlockActionIndicator: React$1.FC<BlockActionIndicatorProps>;

interface BlockActionOverrideProps {
    /** 1 and only one single element */
    children: ReactElement;
    className?: string;
    [key: string]: any;
}

declare const BlockActionOverride: React$1.FC<BlockActionOverrideProps>;

declare const bodyBannerColors: readonly ["background-primary", "background-accent", "surface-subtle"];
type BodyBannerColor = (typeof bodyBannerColors)[number];
interface BodyBannerProps {
    size?: "large";
    /** Background color using design tokens */
    color?: BodyBannerColor;
    /** Additional CSS classes */
    className?: string;
    /** Image element */
    image?: React$1.ReactNode;
    /** Content area - typically heading and description */
    children?: React$1.ReactNode;
    /** Button text */
    buttonText?: string;
    /** Additional CSS classes for button */
    buttonClassName?: string;
}
declare const BodyBanner: ({ className, size, color, image, children, buttonText, buttonClassName, ...other }: BodyBannerProps) => react_jsx_runtime.JSX.Element;

interface BreadcrumbItemData {
    /** Item text */
    text: string;
    /** Item URL. Omit the URL for current item. */
    url?: string;
}
interface BreadcrumbsProps {
    /** Additional CSS classes */
    className?: string;
    /** Breadcrumb items */
    items: BreadcrumbItemData[];
    /** Navigation label */
    label?: string;
    /** Additional props */
    [key: string]: any;
}
declare const Breadcrumbs: React.FC<BreadcrumbsProps>;

type ButtonSize = "small" | "large";
type ButtonType = "primary" | "fill" | "ghost";
interface CommonProps$2 {
    elemRef?: React$1.Ref<any>;
    htmlType?: "button" | "submit" | "reset";
    isActive?: boolean;
    isDefault?: boolean;
    isDisabled?: boolean;
    isSquare?: boolean;
    size?: ButtonSize;
    type?: ButtonType;
    className?: string;
    children?: React$1.ReactNode;
    preserveWidth?: boolean;
}
type AnchorProps$1 = CommonProps$2 & Omit<React$1.AnchorHTMLAttributes<HTMLAnchorElement>, keyof CommonProps$2 | "type" | "ref"> & {
    href: string;
};
type NativeButtonProps = CommonProps$2 & Omit<React$1.ButtonHTMLAttributes<HTMLButtonElement>, keyof CommonProps$2 | "href" | "ref"> & {
    href?: undefined;
};
type ButtonProps$2 = AnchorProps$1 | NativeButtonProps;
declare const Button: React$1.ForwardRefExoticComponent<ButtonProps$2 & React$1.RefAttributes<any>>;

type IconPosition = "left" | "right";
interface IconButtonProps extends Omit<React$1.ButtonHTMLAttributes<HTMLButtonElement>, "type" | "ref"> {
    /** Name of the icon */
    iconName: string;
    /** Position of the icon */
    iconPosition?: IconPosition;
    /** Class of the icon */
    iconClassName?: string;
    /** Button size. Also affects icon size */
    size?: ButtonSize;
    /** Use square button. Children are rendered as visually hidden */
    isSquare?: boolean;
    children?: React$1.ReactNode;
}
declare const IconButton: React$1.ForwardRefExoticComponent<IconButtonProps & React$1.RefAttributes<HTMLButtonElement>>;

declare const ButtonPrimary: {
    (props: ButtonProps$2): react_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const ButtonFill: {
    (props: ButtonProps$2): react_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const ButtonGhost: {
    (props: ButtonProps$2): react_jsx_runtime.JSX.Element;
    displayName: string;
};

interface ButtonsProps extends React.HTMLAttributes<HTMLDivElement> {
    /** On XS viewport, forces buttons to stack vertically and span the available width. */
    isStackedOnXs?: boolean;
    className?: string;
    children?: React.ReactNode;
}
declare const Buttons: React.FC<ButtonsProps>;

declare const cardColors: readonly ["background-primary", "background-secondary", "background-contrast", "background-accent", "background-accent1-blog", "background-accent2-blog", "fill-subtle", "fill-accent1", "fill-accent2", "fill-accent3", "fill-accent4", "fill-accent5"];
type CardColor = (typeof cardColors)[number];
interface CardProps extends React$1.HTMLAttributes<HTMLDivElement> {
    /** Custom background color */
    color?: CardColor;
    noBorder?: boolean;
}
declare const Card: React$1.ForwardRefExoticComponent<CardProps & React$1.RefAttributes<HTMLDivElement>>;

interface CardProductHeaderProps extends React$1.HTMLAttributes<HTMLDivElement> {
    image?: React$1.ReactNode;
    /** Use small spacing */
    space?: "small";
}
declare const CardProductHeader: React$1.ForwardRefExoticComponent<CardProductHeaderProps & React$1.RefAttributes<HTMLDivElement>>;

type CardSectionColor = (typeof cardColors)[number];
interface CardSectionProps extends React$1.HTMLAttributes<HTMLDivElement> {
    /** Custom background color */
    color?: CardSectionColor;
    /** Fill available space using flexbox */
    isFilling?: boolean;
    /** Use small spacing */
    space?: "small";
}
declare const CardSection: React$1.ForwardRefExoticComponent<CardSectionProps & React$1.RefAttributes<HTMLDivElement>>;

interface CarouselProps extends HTMLAttributes<HTMLDivElement> {
    /** Swiper.js (https://swiperjs.com/) options object */
    swiperOptions?: Record<string, any>;
    /** Carousel items */
    items: ReactNode[];
    /** Always show scrollbar and hide dots */
    showScrollbar?: boolean;
    /** Make carousel bleed to the right edge of screen while keeping left aligned with container */
    bleedRight?: boolean;
    className?: string;
}
declare const Carousel: React$1.FC<CarouselProps>;

interface CarouselHeroItemProps extends HTMLAttributes<HTMLDivElement> {
    className?: string;
    children?: ReactNode;
    image: string;
}
declare const CarouselHeroItem: React$1.FC<CarouselHeroItemProps>;

interface TabItem {
    label: string;
    id?: string;
    [key: string]: any;
}
interface CarouselHeroProps {
    className?: string;
    swiperOptions?: Record<string, any>;
    children?: ReactNode;
    tabs?: TabItem[];
    interval?: number;
    enableAutoplay?: boolean;
    [key: string]: any;
}
declare const CarouselHero: React$1.FC<CarouselHeroProps>;

interface CarouselPromotionsProps {
    className?: string;
    swiperOptions?: Record<string, any>;
    children?: ReactNode;
    [key: string]: any;
}
declare const CarouselPromotions: React$1.FC<CarouselPromotionsProps>;

interface Price {
    monthly?: number;
    upfront?: number;
}
interface Discount {
    monthly?: number;
    upfront?: number;
    monthsCount?: number;
}
interface Item$1 {
    type?: string;
    name?: string;
    icon?: string;
    image?: string;
    price?: Price;
    isSubitem?: boolean;
    isOptional?: boolean;
    isMandatory?: boolean;
    discount?: Discount;
    monthsFree?: number;
    tooltip?: string;
    badge?: string;
}

interface Footer {
    name?: string;
    tooltip?: string;
    hideFirst?: boolean;
}
interface Labels {
    [key: string]: string;
    remove: string;
    add: string;
    free: string;
    upfront: string;
    monthly: string;
}

interface CartTableProps {
    footer?: Footer;
    hideEmpty?: boolean;
    isEditable?: boolean;
    items: Item$1[];
    labels?: Labels;
    size?: "large";
}
declare const CartTable: React$1.FC<CartTableProps>;

declare const Container: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;

interface IControlsProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
    elemRef?: React$1.Ref<any>;
    icon: string;
    className?: string;
    isDisabled?: boolean;
}
declare const Controls: React$1.ForwardRefExoticComponent<IControlsProps & Omit<React$1.ButtonHTMLAttributes<HTMLButtonElement>, "ref" | "href" | keyof IControlsProps> & {
    href?: undefined;
} & React$1.RefAttributes<any>>;

interface CoverProps {
    /** Background image source. URL string or an object of breakpoint: url pairs
     *
     * ```
  {
    default: string, // default image to load (fallback)
    xxxl: string, // different image for each breakpoint (optional). while these are mobile first breakpoints, they MUST be ordered from largest to smallest
    xxl: string,
    xl: string,
    lg: string,
    md: string,
    sm: string,
    xs: string,
  }
    * ```
    */
    bgSrc: string | {
        default: string;
        xs?: string;
        sm?: string;
        md?: string;
        lg?: string;
        xl?: string;
        xxl?: string;
        xxxl?: string;
    };
    /** Set vertical position of image */
    bgPosition?: "top" | "center" | "bottom";
    /** Applies custom classNames to overlay content */
    contentClass?: string;
    /** Cover size */
    size?: "small" | "medium" | "large" | "xlarge";
    /** Additional className for the cover container */
    className?: string;
    /** Children content */
    children?: React$1.ReactNode;
    /** Additional props passed to Image component */
    [key: string]: any;
}
declare const Cover: React$1.FC<CoverProps>;

interface DividerProps extends Omit<HTMLAttributes<HTMLDivElement>, "content"> {
    /** Custom content inside divider */
    content?: ReactNode;
    /** Icon which will be rendered inside divider */
    icon?: string;
}
declare const Divider: React$1.FC<DividerProps>;

type DropdownButtonProps = {
    className?: string;
    children?: ReactNode;
    iconName?: string;
    type?: ButtonProps$2["type"];
};
type DropdownProps = {
    button: DropdownButtonProps;
    children: ReactNode;
    hasFocusTrap?: boolean;
    hasSpacing?: boolean;
    id: string;
    isInteractive?: boolean;
    placement?: "left" | "center" | "right";
    className?: string;
    [key: string]: any;
};
declare const Dropdown: React$1.FC<DropdownProps>;

declare const DropdownDivider: React$1.FC<React$1.HTMLAttributes<HTMLDivElement>>;

interface DropdownItemProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
    className?: string;
    children?: ReactNode;
    disabled?: boolean;
    href?: string;
}
declare const DropdownItem: React$1.FC<DropdownItemProps>;

interface DropdownToggleButtonProps extends React$1.HTMLAttributes<HTMLButtonElement> {
    id: string;
    className?: string;
}
declare const DropdownToggleButton: React$1.FC<DropdownToggleButtonProps>;

interface ExpanderProps {
    /** Custom summary text renderer. Passes props as function parameter. */
    renderSummary?: (props: ExpanderProps) => React$1.ReactNode;
    /** Custom summary text renderer when details are opened. Passes props as function parameter. */
    renderSummaryOpened?: (props: ExpanderProps) => React$1.ReactNode;
    /** Trigger text */
    summary?: string;
    /** Trigger text when details are opened */
    summaryOpened?: string;
    /** Additional CSS classes */
    className?: string;
    /** Child elements */
    children?: React$1.ReactNode;
    /** Expander takes full width of its container */
    isFullWidth?: boolean;
    /** Position of trigger relative to content when opened */
    placement?: "top" | "bottom";
    /** Group identifier for syncing multiple expanders together */
    toggleGroup?: string;
    /** Initial open state */
    open?: boolean;
}
declare const Expander: React$1.FC<ExpanderProps>;

interface AccordionProps {
    /** Additional CSS classes */
    className?: string;
}
declare const FeatureAccordion: (props: AccordionProps & {
    children: React$1.ReactNode;
}) => react_jsx_runtime.JSX.Element;

interface FeatureAccordionItemProps extends AccordionItemProps {
    image?: string | object;
    imageUrl?: string;
    imageAlt?: string;
    imageSrcSet?: string;
    [key: string]: any;
}
declare const FeatureAccordionItem: React$1.FC<FeatureAccordionItemProps>;

type AutocompleteOption = string | {
    title: string;
    value: string;
};
interface AutocompleteProps extends Omit<React$1.SelectHTMLAttributes<HTMLSelectElement>, "size" | "value"> {
    /** Module config. For more see accessible-autocomplete docs */
    autocompleteConfig?: Record<string, any>;
    /** Array of string options */
    options?: AutocompleteOption[];
    /** Placeholder text */
    placeholder?: string;
    /** Additional CSS classes */
    className?: string;
    /** Select value */
    value?: string | string[];
}
declare const Autocomplete: React$1.FC<AutocompleteProps>;

type CheckboxSize = "default" | "large";
interface CheckboxProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "size"> {
    /** Html id attribute */
    id: string;
    /** Checked state. */
    isChecked?: boolean;
    /** Disabled state. */
    isDisabled?: boolean;
    /** Invalid state */
    isInvalid?: boolean;
    /** Checkbox is displayed as Toggle */
    isToggle?: boolean;
    /** Html name attribute. Id is used when not set.*/
    name?: string;
    /** Size of element. */
    size?: CheckboxSize;
    className?: string;
}
declare const Checkbox: React$1.FC<CheckboxProps>;

interface FieldContextType {
    controlId?: string;
    messages?: any[];
    control?: {
        type?: string;
        control?: any;
        renderControl?: (props: any) => React.ReactNode;
        isToggle?: boolean;
        [key: string]: any;
    };
    hint?: React.ReactNode;
    label?: React.ReactNode;
    labelAfter?: React.ReactNode;
    tooltip?: React.ReactNode;
    isRadioCheck?: boolean;
}

interface InputFieldProps {
    className?: string;
    control: FieldContextType["control"];
    hint?: React$1.ReactNode;
    label?: React$1.ReactNode;
    labelAfter?: React$1.ReactNode;
    messages?: Array<{
        type: string;
        text: string;
    }>;
    tooltip?: React$1.ReactNode;
    [key: string]: any;
}
declare const Field: React$1.FC<InputFieldProps>;

interface FieldsetMessage {
    [key: string]: any;
}
interface FieldsetProps extends React$1.FieldsetHTMLAttributes<HTMLFieldSetElement> {
    /** Required `<legend />` for fieldset */
    legend: ReactNode;
    /** Additional legend props */
    legendProps?: React$1.HTMLAttributes<HTMLLegendElement>;
    description?: ReactNode;
    messages?: FieldsetMessage[];
    className?: string;
    children?: ReactNode;
}
declare const Fieldset: React$1.FC<FieldsetProps>;

type FileSize = "default" | "large";
interface FileProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "size"> {
    /** Html id attribute. Generated automatically if omitted. */
    id?: string;
    /** Disabled state. */
    isDisabled?: boolean;
    /** Invalid state */
    isInvalid?: boolean;
    /** Input name. */
    name?: string;
    /** Size of element. */
    size?: FileSize;
    className?: string;
}
declare const File: FC<FileProps>;

interface ControlShape {
    type: "autocomplete" | "text" | "select";
    [key: string]: any;
}
interface GroupProps extends HTMLAttributes<HTMLDivElement> {
    control: ControlShape;
    addonPrefix?: ReactNode | ReactNode[];
    size?: "large";
    addonSuffix?: ReactNode | ReactNode[];
    className?: string;
    /** Invalid state */
    isInvalid?: boolean;
}
declare const Group: React$1.FC<GroupProps>;

interface HintProps extends React$1.HTMLAttributes<HTMLParagraphElement> {
    className?: string;
    children?: React$1.ReactNode;
}
declare const Hint: React$1.FC<HintProps>;

interface InputStepperConfig {
    min?: number;
    max?: number;
    defaultValue?: number;
    nonEditableInput?: boolean;
}
interface InputStepperProps {
    config?: InputStepperConfig;
    id: string;
    inputClassName?: string;
    isDisabled?: boolean;
    /** Invalid state */
    isInvalid?: boolean;
    name?: string;
    nonEditableInput?: boolean;
    className?: string;
    [key: string]: any;
}
declare const InputStepper: React$1.FC<InputStepperProps>;

interface LabelProps extends React$1.LabelHTMLAttributes<HTMLLabelElement> {
    htmlFor: string;
    className?: string;
    children?: React$1.ReactNode;
}
declare const Label: React$1.FC<LabelProps>;

type MessageType = "info" | "warning" | "error" | "invalid";
interface MessageProps extends React$1.HTMLAttributes<HTMLParagraphElement> {
    /** Type of message */
    type?: MessageType;
    /** Additional CSS classes */
    className?: string;
    /** Message content */
    children?: React$1.ReactNode;
}
declare const Message: React$1.FC<MessageProps>;

type RadioSize = "default" | "large";
interface RadioProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "size"> {
    /** Html id attribute */
    id: string;
    /** Checked state. */
    isChecked?: boolean;
    /** Disabled state. */
    isDisabled?: boolean;
    /** Invalid state */
    isInvalid?: boolean;
    /** Html name attribute. */
    name: string;
    /** Size of element. */
    size?: RadioSize;
    /** HTML value. Uses id when not set. */
    value?: string;
    className?: string;
}
declare const Radio: React$1.FC<RadioProps>;

type RangeSliderWidth = "default" | "fullwidth";
interface RangeSliderConfig {
    connect?: boolean | boolean[];
    format?: (value: number) => string;
    handleAttributes?: Array<Record<string, any>>;
    pips?: {
        mode?: "positions" | "count" | "values";
        filter?: (value: number) => boolean;
        format?: (value: number) => string;
        values?: number[] | number;
        density?: number;
    };
    range: {
        min: number | number[];
        max: number | number[];
    };
    start: number[];
    [key: string]: any;
}
interface RangeSliderProps extends React$1.HTMLAttributes<HTMLDivElement> {
    /** [noUiSlider config object](https://refreshless.com/nouislider/slider-options/) */
    config: RangeSliderConfig;
    /** insert arbitrary element after rangeslider */
    elementAfter?: React$1.ReactNode;
    /** insert arbitrary element before rangeslider */
    elementBefore?: React$1.ReactNode;
    /** render data-rangeslider attribute and initialize RangeSlider.static.js */
    hasDataAttr?: boolean;
    /** element id. required by RangeSlider.static.js and generated automatically in React environment. */
    id?: string;
    /** Invalid state */
    isInvalid?: boolean;
    /** width of the element */
    width?: RangeSliderWidth;
    /** Additional CSS classes */
    className?: string;
}
declare const RangeSlider: React$1.FC<RangeSliderProps>;

type SelectOption = {
    text: string;
    value: string;
} | string;
type SelectSize = "default" | "large";
type SelectWidth = "default" | "12ch" | "shrink" | "fullwidth";
interface SelectProps extends Omit<React$1.SelectHTMLAttributes<HTMLSelectElement>, "size"> {
    /** Forwarded DOM element ref. */
    elemRef?: React$1.Ref<HTMLSelectElement>;
    /** Html id attribute. */
    id?: string;
    /** Disabled state. */
    isDisabled?: boolean;
    /** Invalid state. */
    isInvalid?: boolean;
    /** Html name attribute. */
    name?: string;
    /** Select option can be specified via children or as options array */
    options?: SelectOption[];
    /** Size of element. */
    size?: SelectSize;
    /** Select value. */
    value?: string | string[];
    /** Element width */
    width?: SelectWidth;
    /** Additional CSS classes */
    className?: string;
    /** Child elements */
    children?: React$1.ReactNode;
}
declare const Select: React$1.FC<SelectProps>;

type TextAreaSize = "default" | "large";
type TextAreaWidth = "default" | "fullwidth";
interface TextAreaProps extends React$1.TextareaHTMLAttributes<HTMLTextAreaElement> {
    /** Html id attribute. */
    id: string;
    /** Disabled state. */
    isDisabled?: boolean;
    /** Invalid state */
    isInvalid?: boolean;
    /** Readonly state. */
    isReadonly?: boolean;
    /** Valid state */
    isValid?: boolean;
    /** Html name attribute. If not present, id is used.*/
    name?: string;
    /** Placeholder text */
    placeholder?: string;
    /** Size of element. */
    size?: TextAreaSize;
    /** Input width */
    width?: TextAreaWidth;
    /** Additional CSS classes */
    className?: string;
    /** Child elements */
    children?: React$1.ReactNode;
}
declare const TextArea: React$1.FC<TextAreaProps>;

type TextInputSize = "default" | "large";
type TextInputWidth = "3ch" | "8ch" | "12ch" | "default" | "fullwidth";
type TextInputType = "email" | "hidden" | "password" | "search" | "tel" | "number" | "text" | "url";
type TextInputSearchIcon = "none" | "transient" | "persistent";
interface TextInputProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "size"> {
    /** Input html type. */
    htmlType?: TextInputType;
    /** Html id attribute. */
    id: string;
    /** Disabled state. */
    isDisabled?: boolean;
    /** Invalid state */
    isInvalid?: boolean;
    /** Readonly state. */
    isReadonly?: boolean;
    /** Valid state */
    isValid?: boolean;
    /** Html name attribute. If not present, id is used.*/
    name?: string;
    /** Placeholder text */
    placeholder?: string;
    /** Size of element. */
    size?: TextInputSize;
    /** Input value. */
    value?: string;
    /** Input width */
    width?: TextInputWidth;
    /** Additional CSS classes */
    className?: string;
    /** Search icon mode. `transient` shows icon only on empty unfocused input, `persistent` keeps it visible with placeholder. */
    searchIcon?: TextInputSearchIcon;
}
declare const TextInput: React$1.ForwardRefExoticComponent<TextInputProps & React$1.RefAttributes<HTMLInputElement>>;

interface GaugeProps {
    /** Text inside the gauge */
    children?: React$1.ReactNode;
    /** Value filling the gauge */
    percentage?: number;
    className?: string;
    [key: string]: any;
}
declare const Gauge: React$1.ForwardRefExoticComponent<Omit<GaugeProps, "ref"> & React$1.RefAttributes<HTMLElement>>;

type GridVAlign = "stretch" | "start" | "end" | "center";
type GridHAlign = "end" | "center" | "space-around" | "space-between";
type GridRowGapSize = "none" | "xsmall" | "small" | "medium" | "large" | "xlarge" | Record<string, "none" | "xsmall" | "small" | "medium" | "large" | "xlarge">;
type GridColumnGapSize = "none" | "small" | "default" | "large" | "xlarge" | Record<string, "none" | "small" | "default" | "large" | "xlarge">;
interface GridProps extends React$1.HTMLAttributes<HTMLElement> {
    vAlign?: GridVAlign;
    hAlign?: GridHAlign;
    tag?: React$1.ElementType;
    justifyHeight?: boolean;
    rowGapSize?: GridRowGapSize;
    columnGapSize?: GridColumnGapSize;
}
declare const Grid: React$1.ForwardRefExoticComponent<GridProps & React$1.RefAttributes<HTMLElement>>;

type GridColAlign = "top" | "middle" | "bottom" | "stretch";
type GridColSize = number | "shrink" | "fill" | "auto" | Record<string, number | "shrink" | "fill" | "auto">;
interface GridColProps extends React$1.HTMLAttributes<HTMLElement> {
    align?: GridColAlign;
    tag?: React$1.ElementType;
    size?: GridColSize;
}
declare const GridCol: {
    ({ className, align, tag, size, ...other }: GridColProps): react_jsx_runtime.JSX.Element;
    displayName: string;
};

type HeroTextSize = "medium" | "large";
type StickerColor = "black" | "orange";
interface HeroImageSrc {
    src: string;
    srcSet?: string;
}
interface HeroImageResponsive {
    default: string;
    sm?: string;
    lg?: string;
    xl?: string;
    xxl?: string;
    [key: string]: string | undefined;
}
type HeroImage = HeroImageSrc | HeroImageResponsive;
interface HeroPriceObject {
    amount: number;
    prefix?: React$1.ReactNode;
    suffix?: React$1.ReactNode;
}
type HeroPrice = string | HeroPriceObject;
interface HeroButtonProps {
    children: React$1.ReactNode;
    [key: string]: any;
}
interface HeroStickerProps {
    color?: StickerColor;
    children?: React$1.ReactNode;
    className?: string;
}
interface HeroProps {
    /** Action button props */
    button?: HeroButtonProps;
    /** Main text */
    description?: React$1.ReactNode;
    hasFullwidthImage?: boolean;
    /** Gradient overlay ensures proper text readability */
    hasGradientOverlay?: boolean;
    /** Use svg illustrations, png for product images and jpg for photos */
    image?: HeroImage;
    price?: HeroPrice;
    sticker?: HeroStickerProps;
    /** Adjust title and description size. Medium sets display-2 title and 18px text, large uses display-1 title and 20px text.  */
    textSize?: HeroTextSize;
    /** Hero title */
    title: string;
}
declare const Hero: React$1.FC<HeroProps>;

type IconColor = "info" | "success" | "warning" | "danger" | "orange";
type IconSize = "small" | "medium" | "large" | "xlarge" | "xxlarge" | "huge";
type IconType = "icon" | "pictogram";
interface IconProps extends React$1.SVGAttributes<SVGSVGElement> {
    /** Accessible label for the icon. */
    alt?: string;
    /** Icon color. */
    color?: IconColor;
    /** Icon name (required). */
    name: string;
    /** Icon size. */
    size?: IconSize;
    /** Path to the SVG sprite. */
    spritePath?: string;
    /**
     * Icon type. When set to "pictogram", the component will automatically
     * switch between light and dark versions based on theme classes (.is-light/.is-dark).
     */
    type?: IconType;
    /**
     * @deprecated Use type="pictogram" instead.
     * Whether this icon should adapt to theme (light/dark).
     * When true, the component will automatically switch between
     * light and dark versions based on theme classes (.is-light/.is-dark).
     */
    className?: string;
}
declare const Icon: React$1.FC<IconProps>;

interface PictogramProps extends Omit<IconProps, "type"> {
    /**
     * Pictogram name. Should correspond to your pictogram sprite entries.
     * For example: 'pictogram-skylink' will look for 'pictogram-skylink' (light)
     * and 'pictogram-skylink--dark' (dark) in the sprite.
     */
    name: string;
}
/**
 * Pictogram component for theme-aware pictographic icons.
 *
 * This component automatically handles light/dark theme switching by using
 * different sprite entries based on the current theme (.is-light/.is-dark classes).
 *
 * Your sprite should contain both light and dark versions:
 * - Light version: Use the exact name provided (e.g., 'pictogram-skylink')
 * - Dark version: Add '--dark' suffix (e.g., 'pictogram-skylink--dark')
 */
declare const Pictogram: React$1.FC<PictogramProps>;

declare const SpritePathContext: React$1.Context<string>;
interface SpritePathProviderProps {
    children: ReactNode;
    value?: string;
}
declare const SpritePathProvider: React$1.FC<SpritePathProviderProps>;

interface IconListItem {
    icon: string;
    content: React$1.ReactNode;
    tooltip?: React$1.ReactNode;
}
interface IconListProps {
    items?: IconListItem[];
    className?: string;
    [key: string]: any;
}
declare const IconList: React$1.FC<IconListProps>;

interface ItemProps {
    icon: string;
    children: React$1.ReactNode;
    tooltip?: React$1.ReactNode;
    [key: string]: any;
}
declare const Item: React$1.FC<ItemProps>;

interface ImageSrcObject {
    default: string;
    xxxl?: string;
    xxl?: string;
    xl?: string;
    lg?: string;
    md?: string;
    sm?: string;
    xs?: string;
    [key: string]: string | undefined;
}
interface ImageProps {
    alt: string;
    src: string | ImageSrcObject;
    className?: string;
    [key: string]: any;
}
declare const Image: React$1.FC<ImageProps>;

interface LinkProps$1 {
    /** destination address */
    href?: string;
    /** rendered HTML element */
    tag?: "a" | "button";
    /** additional CSS classes */
    className?: string;
    /** link content */
    children?: React$1.ReactNode;
    /** whether the link should be underlined */
    isUnderline?: boolean;
    /** whether the link should have normal font weight */
    isNormal?: boolean;
    /** when true, adds the .no-accent modifier to disable orange accent color on hover (useful for dark backgrounds) */
    noAccent?: boolean;
}
declare const Link: React$1.FC<LinkProps$1 & React$1.HTMLAttributes<HTMLElement>>;

interface ListProps {
    /** Size determines color of list items and color of their borders*/
    color?: "gray";
    /** Spacious lists have horizontal spacing */
    isEnclosed?: boolean;
    /** Size determines vertical spacing */
    size?: "small";
    className?: string;
    children?: React$1.ReactNode;
}
declare const List: React$1.FC<ListProps>;

interface ControlProps {
    href?: string;
    className?: string;
    children?: React$1.ReactNode;
    [key: string]: any;
}
interface ListItemProps {
    /** Item with control props automatically creates a clickable item and renders an interactive element. If the object contains a href property, it renders an anchor element. If not, it renders a button of type="button" instead. */
    controlProps?: ControlProps;
    className?: string;
    children?: React$1.ReactNode;
    [key: string]: any;
}
declare const ListItem: React$1.FC<ListItemProps>;

interface LoaderProps {
    colour?: "default" | "inverse";
    isDelayed?: boolean;
    /** Messages that the loader will cycle until done */
    messages?: string[];
    /** Size variants */
    size?: "default" | "large";
    className?: string;
    children?: ReactNode;
    [key: string]: any;
}
declare const Loader: React$1.FC<LoaderProps>;

interface LoaderFullscreenProps {
    className?: string;
    children?: ReactNode;
}
declare const LoaderFullscreen: React$1.FC<LoaderFullscreenProps>;

type MegamenuProps = {
    className?: string;
    title?: string;
    isSticky?: boolean;
    searchEmpty?: boolean;
    searchFilled?: boolean;
};
declare const Megamenu: ({ className, title, isSticky, searchEmpty, searchFilled, }: MegamenuProps) => react_jsx_runtime.JSX.Element;

declare const MegamenuBlog: ({ className, title, isSticky, searchEmpty, searchFilled, }: MegamenuProps) => react_jsx_runtime.JSX.Element;

declare const sizes$1: readonly ["small", "large"];
type ModalSize = (typeof sizes$1)[number];
interface ModalProps extends React$1.HTMLAttributes<HTMLDivElement> {
    /** Action buttons in footer */
    actions?: React$1.ReactNode[];
    /** Full height on XS */
    fullHeight?: boolean;
    /** Sticky footer is visible when modal content is too long */
    hasStickyFooter?: boolean;
    /** Html id attribute. */
    id: string;
    /** isActive controls if modal is opened or closed */
    isActive?: boolean;
    /** Callback fired when modal is closed */
    onHide?: () => void;
    /** Custom header renderer. Receives id as function param. Returned element(s) must contain a header with close button. */
    renderHeader?: (id: string) => React$1.ReactNode;
    /** Custom body renderer. Receives title as function param. Returned element(s) must contain a title. */
    renderBody?: () => React$1.ReactNode;
    /** Custom footer renderer. Receives actions as function param. Returned element(s) must contain the actions. */
    renderFooter?: () => React$1.ReactNode;
    /** Custom main title renderer. Receives id as function param. Returned element must be a heading and use this id for accessibility purposes */
    renderTitle?: (id: string) => React$1.ReactNode;
    /** Modal dialog size */
    size?: ModalSize;
    /** Main title */
    title?: string;
    /** Child elements */
    children?: React$1.ReactNode;
    /** Additional CSS classes */
    className?: string;
    /** Disables header paddings */
    disableHeaderSpacing?: boolean;
    /** Disables footer paddings */
    disableFooterSpacing?: boolean;
}
declare const Modal: React$1.FC<ModalProps>;

declare const modalBodyColors: readonly ["background-primary", "background-secondary", "background-contrast", "background-accent", "background-accent1-blog", "background-accent2-blog", "surface-primary", "surface-secondary", "surface-tertiary", "surface-subtle", "surface-moderate", "surface-contrast", "surface-accent", "fill-subtle", "fill-accent1", "fill-accent2", "fill-accent3", "fill-accent4", "fill-accent5"];
type ModalBodyColor = (typeof modalBodyColors)[number];
interface ModalBodyProps extends React$1.HTMLAttributes<HTMLDivElement> {
    color?: ModalBodyColor;
    className?: string;
    children?: React$1.ReactNode;
    withTopPadding?: boolean;
    disableSpacing?: boolean;
}
declare const ModalBody: React$1.FC<ModalBodyProps>;

interface ExtendedIconButtonProps extends IconButtonProps {
    type?: ButtonType;
}
type ModalCloseButtonProps = Omit<ExtendedIconButtonProps, "iconName">;
declare const ModalCloseButton: React.FC<ModalCloseButtonProps>;

interface ModalProductFooterProps extends React$1.HTMLAttributes<HTMLDivElement> {
    image?: React$1.ReactNode;
    /** Use small spacing */
    space?: "small";
    button?: React$1.ReactNode;
}
declare const ModalProductFooter: React$1.ForwardRefExoticComponent<ModalProductFooterProps & React$1.RefAttributes<HTMLDivElement>>;

interface ModalProductHeaderProps extends React$1.HTMLAttributes<HTMLDivElement> {
    image?: React$1.ReactNode;
    /** Use small spacing */
    space?: "small";
    /** Optional id for accessibility (e.g., for aria-labelledby) */
    titleId?: string;
}
declare const ModalProductHeader: React$1.ForwardRefExoticComponent<ModalProductHeaderProps & React$1.RefAttributes<HTMLDivElement>>;

declare const sizes: readonly ["small", "large"];
type TitleSize = (typeof sizes)[number];
interface ModalTitleProps extends React.HTMLAttributes<HTMLHeadingElement> {
    size?: TitleSize;
    className?: string;
    children?: React.ReactNode;
}
declare const ModalTitle: React.FC<ModalTitleProps>;

interface PaginationItemProps {
    /** Page link href */
    href: string;
    /** Text label inside page item */
    label: string;
    /** Active state. */
    isActive?: boolean;
    /** aria-label of page item */
    ariaLabel?: string;
}
interface PaginationProps {
    /** Collapsed version */
    isCompact?: boolean;
    /** All pagination items - buttons & numbers */
    items: PaginationItemProps[];
    /** Accessibility label */
    label?: string;
    /** Additional CSS class name */
    className?: string;
    /** Additional props */
    [key: string]: any;
}
declare const Pagination: React$1.FC<PaginationProps>;

declare const pillColors: readonly ["surface-primary", "surface-secondary", "surface-tertiary", "surface-subtle", "surface-moderate", "surface-contrast", "surface-accent", "fill-moderate", "fill-disabled", "transparent"];
type PillColor = (typeof pillColors)[number];
interface PillProps extends HTMLAttributes<HTMLSpanElement> {
    className?: string;
    children?: ReactNode;
    color?: PillColor;
    size?: "small" | "medium" | "large" | "xlarge" | "xxlarge";
}
declare const Pill: React$1.FC<PillProps>;

interface ProgressProps {
    /** Color of the indicator */
    color?: "orange" | "green" | "yellow" | "red" | "blue";
    /** Provides clear instruction on what the horizontal bar represents */
    label: React$1.ReactNode;
    /** Textual representation of the indicator */
    value: React$1.ReactNode;
    /** Width of the progress indicator where 0 = empty, 1 = full */
    width?: number;
    className?: string;
    children?: React$1.ReactNode;
}
declare const Progress: React$1.FC<ProgressProps>;

interface PromoBannerProps {
    className?: string;
    image?: string;
    alignImage?: "bottom" | "top";
    /** Remove top padding from item on sm and smaller breakpoints */
    flushTopSmDown?: boolean;
    /** Remove bottom padding from item on sm and smaller breakpoints */
    flushBottomSmDown?: boolean;
    imageFullWidth?: boolean;
    /** Make image extend to the edge of viewport even when inside container */
    bleedImage?: boolean;
    children?: React$1.ReactNode;
    itemClassName?: string;
    imageClassName?: string;
    variant?: "vertical" | "reverse";
}
declare const PromoBanner: ({ image, className, alignImage, flushTopSmDown, flushBottomSmDown, bleedImage, children, itemClassName, imageClassName, variant, imageFullWidth, }: PromoBannerProps) => react_jsx_runtime.JSX.Element;

interface PromotionCardProps {
    className?: string;
    children?: React$1.ReactNode;
    color?: CardColor;
    [key: string]: any;
}
declare const PromotionCard: React$1.FC<PromotionCardProps>;

interface PromotionCardContentProps {
    className?: string;
    children?: React$1.ReactNode;
    [key: string]: any;
}
declare const PromotionCardContent: React$1.FC<PromotionCardContentProps>;

interface PromotionCardImageWrapperProps {
    className?: string;
    children?: React$1.ReactNode;
    [key: string]: any;
}
declare const PromotionCardImageWrapper: React$1.FC<PromotionCardImageWrapperProps>;

interface PromotionCardSectionProps {
    /** Inverse colors */
    isInverse?: boolean;
    className?: string;
    children?: React$1.ReactNode;
    [key: string]: any;
}
declare const PromotionCardSection: React$1.FC<PromotionCardSectionProps>;

interface PromotionCardTitleProps {
    className?: string;
    children: React$1.ReactElement;
    [key: string]: any;
}
declare const PromotionCardTitle: React$1.FC<PromotionCardTitleProps>;

declare const sectionColors: readonly ["background-secondary", "background-contrast", "background-accent", "background-accent1-blog", "background-accent2-blog", "background-none", "surface-subtle"];
type SectionColor = (typeof sectionColors)[number];
type SectionSpacing = "default" | "small" | "xsmall";
interface SectionProps {
    /** Background color of section */
    color?: SectionColor;
    /**
     * Spacing between sections
     *
     * if two sections with different color meet
     * use default (larger) spacing, if two section have same color
     * use small spacing on second one. Use xsmall for specific
     * cases e.g. as part of Megamenu
     */
    spacing?: SectionSpacing;
    /** Rendered HTML element */
    tag?: React$1.ElementType;
    /** Additional CSS classes */
    className?: string;
    /** Section content */
    children?: React$1.ReactNode;
    /** Additional classes passed to the container */
    containerClassName?: string;
}
declare const Section: React$1.FC<SectionProps>;

declare const Skeleton: React$1.FC<React$1.HTMLAttributes<HTMLSpanElement>>;

interface SkipLinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
    href?: string;
}
declare const SkipLink: React$1.FC<SkipLinkProps>;

type SocialName = "x" | "facebook-2" | "linkedin-2" | "instagram" | "pinterest" | "snapchat" | "tiktok" | "whatsapp" | "youtube" | "email";
type CommonProps$1 = {
    name: SocialName;
    className?: string;
};
type ButtonProps$1 = CommonProps$1 & Omit<React$1.ButtonHTMLAttributes<HTMLButtonElement>, "type" | keyof CommonProps$1>;
type LinkProps = CommonProps$1 & Omit<React$1.AnchorHTMLAttributes<HTMLAnchorElement>, keyof CommonProps$1> & {
    href: string;
};
type SocialButtonProps = ButtonProps$1 | LinkProps;
declare const SocialButton: React$1.ForwardRefExoticComponent<SocialButtonProps & React$1.RefAttributes<HTMLAnchorElement | HTMLButtonElement>>;

declare const showTitlesFromOptions: readonly ["md", "lg", "xl"];
type ShowTitlesFrom = (typeof showTitlesFromOptions)[number];
interface StepbarStep {
    href?: string;
    isCurrent?: boolean;
    title: React$1.ReactNode;
}
interface StepbarProps extends React$1.HTMLAttributes<HTMLElement> {
    /** Arial label of nav element */
    label?: string;
    /** Titles of non-current steps are visible from this breakpoint */
    showTitlesFrom?: ShowTitlesFrom;
    /** Array of step objects */
    steps: StepbarStep[];
}
declare const Stepbar: React$1.FC<StepbarProps>;

interface StickerProps {
    color?: "black" | "orange";
    size?: "small";
    children?: React$1.ReactNode;
    className?: string;
    [key: string]: any;
}
declare const Sticker: React$1.FC<StickerProps>;

interface CellValue {
    value: React$1.ReactNode;
    rawValue?: number | string;
    [key: string]: any;
}
interface TableHeader {
    key: string;
    label: React$1.ReactNode;
    isSortable?: boolean;
    sort?: "none" | "ascending" | "descending";
    cellProps?: React$1.HTMLAttributes<HTMLTableCellElement>;
    headCellProps?: React$1.HTMLAttributes<HTMLTableCellElement>;
}
interface TableRow {
    [key: string]: React$1.ReactNode | CellValue | TableRow[] | boolean | undefined;
    expand?: TableRow[];
    isExpanded?: boolean;
    id?: string;
}
interface ExpandableRowsCaptions {
    header: string;
    emptyRow: string;
}

interface TableProps extends React$1.TableHTMLAttributes<HTMLTableElement> {
    /** Caption helps users with screen readers to find a table and understand what it's about and decide if they want to read it. */
    caption?: React$1.ReactNode;
    expandableRowsCaptions?: ExpandableRowsCaptions;
    /** Foot element for table */
    footers?: TableRow[];
    /** Labels for headers in the table. Value of the key in headers match with the key name in rows */
    headers: TableHeader[];
    /** Compact table only takes spaced needed to display its content */
    isCompact?: boolean;
    /** Enable responsive card layout below md breakpoint for better accessibility */
    isResponsive?: boolean;
    /** If table has horizontal scrollbar */
    isScrollable?: boolean;
    /** Different colors for even and odd rows. */
    isStriped?: boolean;
    /** rows to print out in the table. */
    rows: TableRow[];
    className?: string;
}
declare const Table: React$1.FC<TableProps>;

interface TabProps extends React.HTMLAttributes<HTMLButtonElement | HTMLAnchorElement> {
    /** Id of the tabpanel this tab controls. */
    controls?: string;
    href?: string;
    /** Active state */
    isActive?: boolean;
    /** Disabled state. */
    isDisabled?: boolean;
    className?: string;
    children?: React.ReactNode;
}
declare const Tab: React.FC<TabProps>;

interface TabPanelProps extends React.HTMLAttributes<HTMLDivElement> {
    /** Optional href for the tab */
    href?: string;
    /** Tabpanel id */
    id?: string;
    /** Active state */
    isActive?: boolean;
    /** Whether the tab is disabled */
    isDisabled?: boolean;
    /** Tab content/label */
    tab?: React.ReactNode;
    /** Custom render function for tab */
    renderTab?: (props: TabPanelProps) => React.ReactElement;
    /** Additional class names */
    className?: string;
    /** Children components */
    children?: React.ReactNode;
}
declare const TabPanel: React.FC<TabPanelProps>;

interface TabsProps extends React$1.HTMLAttributes<HTMLUListElement> {
    /** Active Tab index */
    activeTabIndex?: number;
    /** Additional classes for tabs header. */
    classesTabNav?: string;
    /** All tabs have equal width inside a full-width container */
    hasEqualTabWidth?: boolean;
    /** Fullwidth container */
    isFullWidth?: boolean;
    /** Tabs behave as links rather than tabs */
    isLink?: boolean;
    /** Tab panels as children */
    children: React$1.ReactElement<TabPanelProps>[];
}
declare const Tabs: React$1.FC<TabsProps>;

type TagButtonProps = {
    className?: string;
    onClick?: React$1.MouseEventHandler<HTMLButtonElement>;
    children?: React$1.ReactNode;
    isDisabled?: boolean;
    ariaLabel?: string;
    iconName: string;
    size?: string;
};
declare const TagButton: React$1.ForwardRefExoticComponent<TagButtonProps & React$1.RefAttributes<HTMLButtonElement>>;

declare const colors: readonly ["black", "orange", "yellow", "green", "blue", "success", "info", "warning", "danger", "transparent"];
type TagColor = (typeof colors)[number];
type TagSize = "small" | "large";
interface CommonProps {
    color?: TagColor;
    size?: TagSize;
    isDisabled?: boolean;
    className?: string;
    children?: React$1.ReactNode;
    actionButton?: React$1.ReactElement<TagButtonProps>;
}
type SpanProps = CommonProps & Omit<React$1.HTMLAttributes<HTMLSpanElement>, keyof CommonProps> & {
    onClick?: undefined;
    href?: undefined;
};
type ButtonProps = CommonProps & Omit<React$1.ButtonHTMLAttributes<HTMLButtonElement>, keyof CommonProps> & {
    onClick: React$1.MouseEventHandler<HTMLButtonElement>;
    href?: undefined;
};
type AnchorProps = CommonProps & Omit<React$1.AnchorHTMLAttributes<HTMLAnchorElement>, keyof CommonProps> & {
    href: string;
    onClick?: undefined;
};
type TagProps = SpanProps | ButtonProps | AnchorProps;
declare const Tag: React$1.ForwardRefExoticComponent<TagProps & React$1.RefAttributes<HTMLElement>>;

interface TestimonialProps {
    className?: string;
    children?: React$1.ReactNode;
    color?: "default" | "orange";
    isDiv?: boolean;
    [key: string]: any;
}
declare const Testimonial: React$1.FC<TestimonialProps>;

type TileHAlign = "center";
type TileVAlign = "center" | "end" | "space-between";
type TileVariant = "compact" | "action";
interface TileProps extends React$1.HTMLAttributes<HTMLDivElement> {
    /** Horizontal alignment of the tile content. */
    hAlign?: TileHAlign;
    /** Vertical alignment of the tile content. */
    vAlign?: TileVAlign;
    /** Tile variant. */
    variant?: TileVariant;
    children?: ReactNode;
    className?: string;
}
declare const Tile: React$1.FC<TileProps>;

type TooltipPlacement = "auto" | "top" | "top-start" | "top-end" | "bottom" | "bottom-start" | "bottom-end" | "right" | "right-start" | "right-end" | "left" | "left-start" | "left-end";
interface TooltipProps extends React$1.HTMLAttributes<HTMLElement> {
    /** Tooltip dialog content */
    dialog?: React$1.ReactNode;
    /** Tooltip ID */
    id?: string;
    /** Preferred placement, if there is enough room. Defaults to top. */
    placement?: TooltipPlacement;
    /** Custom trigger renderer. Passes required aria attributes and children in an object as argument. */
    renderTrigger?: (props: {
        "data-tooltip-trigger": true;
        "aria-describedby": string;
        "aria-owns": string;
        children: React$1.ReactNode;
    }) => React$1.ReactNode;
    /** Render dialog as */
    tag?: "span";
    /** Additional CSS classes */
    className?: string;
    children?: React$1.ReactNode;
}
declare const Tooltip: React$1.FC<TooltipProps>;

type InfoTooltipProps = Omit<TooltipProps, "onAbort"> & Omit<React$1.HTMLAttributes<HTMLButtonElement>, "onAbort"> & {
    children?: React$1.ReactNode;
    className?: string;
};
declare const InfoTooltip: React$1.FC<InfoTooltipProps>;

export { Accordion, AccordionItem, Alert, AnchorNavigation, Autocomplete, Bar, BarBreak, BarItem, BlockAction, BlockActionControl, BlockActionIndicator, BlockActionOverride, BodyBanner, Breadcrumbs, Button, ButtonFill, ButtonGhost, ButtonPrimary, Buttons, Card, CardProductHeader, CardSection, Carousel, CarouselHero, CarouselHeroItem, CarouselPromotions, CartTable, Checkbox, Container, Controls, Cover, Divider, Dropdown, DropdownDivider, DropdownItem, DropdownToggleButton, Expander, FeatureAccordion, FeatureAccordionItem, Field, Fieldset, File, Gauge, Grid, GridCol, Group, Hero, Hint, Icon, IconButton, IconList, Image, InfoTooltip, InputStepper, Item, Label, Link, List, ListItem, Loader, LoaderFullscreen, Megamenu, MegamenuBlog, Message, Modal, ModalBody, ModalCloseButton, ModalProductFooter, ModalProductHeader, ModalTitle, Pagination, Pictogram, Pill, Progress, PromoBanner, PromotionCard, PromotionCardContent, PromotionCardImageWrapper, PromotionCardSection, PromotionCardTitle, Radio, RangeSlider, Section, Select, Skeleton, SkipLink, SocialButton, SpritePathContext, SpritePathProvider, Stepbar, Sticker, Tab, TabPanel, Table, Tabs, Tag, TagButton, Testimonial, TextArea, TextInput, Tile, Tooltip };
