export { keyframes } from '@emotion/react';
import * as _chakra_ui_react from '@chakra-ui/react';
import { UseMediaQueryOptions, AlertRootProps, RecipeVariantProps, AccordionRootProps, AccordionItemTriggerProps, AccordionItemProps as AccordionItemProps$1, AccordionItemBodyProps, BoxProps, ButtonProps, CheckboxCheckedChangeDetails, SeparatorProps, InputProps as InputProps$1, LinkProps as LinkProps$2, LinkOverlayProps as LinkOverlayProps$1, ListRootProps, UseDialogProps, CloseButtonProps, UsePopoverProps, IconProps as IconProps$1, NumberInput, NativeSelectRootProps, NativeSelectFieldProps, MenuTriggerProps, MenuContentProps, MenuRootProps, SimpleGridProps, SkeletonProps, StackProps, Switch as Switch$1, TabsTriggerProps, TabsRootProps, TableCellProps, TableColumnHeaderProps, TextProps, ConditionalValue, AspectRatioProps, BadgeProps as BadgeProps$1, BreadcrumbRootProps, BreadcrumbLinkProps as BreadcrumbLinkProps$1, Card, CardBodyProps, CardHeaderProps, CardFooterProps, CenterProps as CenterProps$1, CollapsibleRootProps, DrawerContentProps, DrawerBodyProps, DrawerRootProps, FlexProps as FlexProps$1, GridProps, GridItemProps, HeadingProps as HeadingProps$1, UseHoverCardProps, Accordion as Accordion$1, Slider, SpinnerProps as SpinnerProps$1, TabsListProps, TabsContentProps, HTMLChakraProps, CreateToasterReturn, TooltipRootProps, TooltipContentProps } from '@chakra-ui/react';
export { AspectRatioProps, CardBodyProps, CardFooterProps, CardHeaderProps, GridItemProps, GridProps, LinkBox, LinkBoxProps, Portal, PortalProps, useBreakpointValue, useChakraContext } from '@chakra-ui/react';
import * as React from 'react';
import React__default, { FocusEventHandler, ChangeEventHandler, FC, ReactNode, RefObject, PropsWithChildren, ReactElement, ElementType as ElementType$1, KeyboardEventHandler, JSX, ChangeEvent, ComponentProps } from 'react';
export { PropsWithChildren as FullHeightProps } from 'react';
import { IFuseOptions, FuseResult, RangeTuple } from 'fuse.js';
import { Language as Language$1 } from '@smg-automotive/i18n-pkg';
import { EnrichedSessionUser } from '@smg-automotive/auth';

declare const emBreakpoints: {
    base: string;
    '2xs': string;
    xs: string;
    sm: string;
    md: string;
    lg: string;
    xl: string;
};
type BreakpointName = keyof typeof emBreakpoints;
declare const breakpoints: Record<BreakpointName, {
    em: number;
    px: number;
}>;

type BreakpointKey = keyof typeof emBreakpoints;
type AboveBelowQueryProps = {
    above: BreakpointKey;
    below?: BreakpointKey;
} | {
    below: BreakpointKey;
    above?: BreakpointKey;
} | {
    above: BreakpointKey;
    below: BreakpointKey;
};
type BreakpointQueryProps = {
    breakpoint: string;
};
type QueryProps = AboveBelowQueryProps | BreakpointQueryProps;
declare const useMediaQuery: (query: QueryProps, options?: UseMediaQueryOptions) => boolean;

declare const useDebouncedOnChange: ({ onChange, onBlur, debounce, }: {
    onBlur?: FocusEventHandler<HTMLInputElement>;
    onChange?: ChangeEventHandler<HTMLInputElement>;
    debounce?: number;
}) => {
    onChange: ChangeEventHandler<HTMLInputElement> | undefined;
    onBlur: FocusEventHandler<HTMLInputElement> | undefined;
};

declare const useToken: (scale: string, token: string[], fallback?: string[]) => string[];

declare const alertRecipe: _chakra_ui_react.SlotRecipeDefinition<"title" | "content" | "root" | "indicator" | "description" | "toastClose", {
    status: {
        info: {
            root: {
                '--alert-fg': "var(--chakra-colors-blue-700)";
                '--alert-bg': "var(--chakra-colors-blue-100)";
            };
        };
        success: {
            root: {
                '--alert-fg': "var(--chakra-colors-green-500)";
                '--alert-bg': "var(--chakra-colors-green-100)";
            };
        };
        warning: {
            root: {
                '--alert-fg': "var(--chakra-colors-orange-500)";
                '--alert-bg': "var(--chakra-colors-orange-100)";
            };
        };
        error: {
            root: {
                '--alert-fg': "var(--chakra-colors-red-500)";
                '--alert-bg': "var(--chakra-colors-red-100)";
            };
        };
    };
}>;

type AlertStatus = 'error' | 'warning' | 'info' | 'success';
type AlertLinkProps = {
    as?: 'link' | 'button' | React__default.ElementType;
    text: string;
    url?: string;
    isExternal?: boolean;
    onClick?: () => void;
};
type AlertRecipeProps = RecipeVariantProps<typeof alertRecipe>;
type RootProps = Omit<AlertRootProps, 'status' | 'variant' | 'title'>;
type SharedProps$3 = RootProps & Omit<AlertRecipeProps, 'status'> & {
    description: string | ReactNode;
    title?: string;
    link?: AlertLinkProps;
    icon?: React__default.ReactNode;
    type?: AlertStatus;
};
type DismissibleProps = SharedProps$3 & {
    onDismiss?: () => void;
    dismissible?: true;
};
type NonDismissibleProps = SharedProps$3 & {
    onDismiss?: never;
    dismissible?: false;
};
type AlertProps = DismissibleProps | NonDismissibleProps;
declare const Alert: FC<AlertProps>;

type ToastPosition = 'top' | 'top-right';
type ToastOptions = {
    position?: ToastPosition;
    onClose?: () => void;
} & Omit<SharedProps$3, 'position'>;
declare const useToast: () => (options: ToastOptions) => {
    closeToast: () => any;
};

declare const useFocusWhenVisible: ({ ref, enabled, maxWaitTime, }: {
    ref: RefObject<HTMLElement | null>;
    enabled?: boolean;
    maxWaitTime?: number;
}) => void;

type UseClipboardOptions = {
    timeout?: number;
};
type UseClipboardReturn = {
    hasCopied: boolean;
    onCopy: () => Promise<boolean>;
};
declare const useClipboard: (value: string, options?: UseClipboardOptions) => UseClipboardReturn;

type UseFuseSearchOptions<TItem, TResult = TItem> = {
    items: TItem[];
    fuseOptions: IFuseOptions<TItem>;
    mapResults?: (searchResults: FuseResult<TItem>[]) => TResult[];
    getInitialResults?: (items: TItem[]) => TResult[];
    normalizeQuery?: (query: string) => string;
    initialQuery?: string;
};
declare const useFuseSearch: <TItem, TResult = TItem>({ items, fuseOptions, mapResults, getInitialResults, normalizeQuery, initialQuery, }: UseFuseSearchOptions<TItem, TResult>) => {
    hasQuery: boolean;
    query: string;
    results: TResult[];
    setSearchQuery: (newQuery: string) => void;
};

type UseDisclosureOptions = {
    onOpen?: () => void;
    onClose?: () => void;
};
declare const useDisclosure: (options?: UseDisclosureOptions) => {
    isOpen: boolean;
    onClose: () => void;
    onToggle: () => void;
    setOpen: React.Dispatch<React.SetStateAction<boolean>>;
    onOpen: () => void;
};

declare const accordionRecipe: _chakra_ui_react.SlotRecipeDefinition<"content" | "indicator" | "body" | "button" | "item", {
    variant: {
        light: {
            item: {
                color: string;
                borderColor: string;
                _last: {
                    borderBottom: string;
                    borderColor: string;
                };
            };
            button: {
                _hover: {
                    bg: string;
                };
            };
            body: {
                textStyle: "body";
            };
        };
        dark: {
            item: {
                borderColor: string;
                bg: string;
                color: string;
                _last: {
                    borderColor: string;
                };
            };
            button: {
                textStyle: "heading5";
                _hover: {
                    bg: string;
                };
            };
            body: {
                textStyle: "body-small";
            };
        };
        minimal: {
            item: {
                borderTop: string;
                _last: {
                    borderBottom: string;
                };
            };
            button: {
                width: string;
                textStyle: "body";
                paddingX: string;
                maxWidth: string;
                _hover: {
                    bg: string;
                };
            };
            indicator: {
                marginLeft: string;
            };
            body: {
                pb: string;
                paddingX: string;
                textStyle: "body";
            };
        };
    };
}>;

type AccordionProps = AccordionRootProps & RecipeVariantProps<typeof accordionRecipe>;
declare const Accordion: FC<PropsWithChildren<AccordionProps>>;

type AccordionButtonProps = AccordionItemTriggerProps & RecipeVariantProps<typeof accordionRecipe> & {
    leftIcon?: React__default.ReactNode;
};
declare const AccordionButton: FC<PropsWithChildren<AccordionButtonProps>>;

type AccordionItemProps = AccordionItemProps$1 & RecipeVariantProps<typeof accordionRecipe>;
declare const AccordionItem: FC<PropsWithChildren<AccordionItemProps>>;

type AccordionPanelProps = AccordionItemBodyProps & RecipeVariantProps<typeof accordionRecipe>;
declare const AccordionPanel: FC<PropsWithChildren<AccordionPanelProps>>;

type ElementType = React__default.ElementType;
type PropsOf<E extends ElementType> = React__default.ComponentPropsWithoutRef<E>;
type PolymorphicProps<E extends ElementType, OwnProps extends object> = OwnProps & {
    as?: E;
} & Omit<PropsOf<E>, keyof OwnProps | 'as' | 'children'>;
type Props$q = Omit<BoxProps, 'color'> & {
    textColor?: BoxProps['color'];
    spacing?: BoxProps['gap'];
};
type BoxAdapterProps<E extends ElementType = 'div'> = PolymorphicProps<E, Props$q>;
declare const Box: <E extends ElementType = "div">(props: BoxAdapterProps<E> & {
    ref?: React__default.Ref<HTMLElement>;
}) => React__default.ReactElement | null;

declare const buttonRecipe: _chakra_ui_react.RecipeDefinition<{
    variant: {
        primary: {
            bg: string;
            color: string;
            boxShadow: string;
            _hover: {
                filter: string;
            };
            _active: {
                filter: string;
                bg: string;
                boxShadow: string;
            };
            _disabled: {
                bg: string;
                boxShadow: string;
                color: string;
                pointerEvents: string;
            };
        };
        secondary: {
            bg: string;
            color: string;
            border: string;
            borderColor: string;
            _hover: {
                bg: string;
            };
            _active: {
                bg: string;
            };
            _disabled: {
                color: string;
                borderColor: string;
                pointerEvents: string;
            };
        };
        success: {
            bg: string;
            color: string;
            _hover: {
                filter: string;
            };
            _active: {
                filter: string;
                bg: string;
            };
            _disabled: {
                bg: string;
                boxShadow: string;
                color: string;
                pointerEvents: string;
            };
        };
        transparent: {
            bg: string;
            color: string;
            border: string;
            borderColor: string;
            _hover: {
                bg: string;
            };
            _active: {
                bg: string;
            };
            _disabled: {
                color: string;
                borderColor: string;
                pointerEvents: string;
            };
        };
        scouty: {
            bg: string;
            color: string;
            border: string;
            borderBottom: string;
            borderBottomColor: string;
            borderRadius: string;
            boxShadow: string;
            aspectRatio: string;
            flexShrink: number;
            gap: string;
            minWidth: string;
            px: string;
            py: string;
            _hover: {
                bg: string;
            };
            _active: {
                bg: string;
                borderBottomWidth: string;
                transform: string;
            };
            _disabled: {
                bg: string;
                borderBottomColor: string;
                color: string;
                pointerEvents: string;
            };
        };
    };
    size: {
        md: {
            height: string;
            textStyle: "button";
        };
        lg: {
            height: string;
            textStyle: "button";
        };
    };
}>;

type Overwrite<T, NewT> = Omit<T, keyof NewT> & NewT;
type Never<Source> = {
    [P in keyof Source]?: never;
};
type LinkButton = {
    href?: string;
    isExternal?: boolean;
    prefetch?: boolean;
    rel?: string;
    replace?: boolean;
};
type IconButton = {
    ariaLabel: string;
    icon: ReactElement;
};
type ButtonSharedProps = RecipeVariantProps<typeof buttonRecipe> & {
    as?: 'button';
    children: ReactNode;
    leftIcon?: ReactElement;
    rightIcon?: ReactElement;
    onClick?: ButtonProps['onClick'];
    disabled?: boolean;
} & Omit<ButtonProps, 'backgroundColor' | 'background' | 'color' | 'textColor' | 'border' | 'textStyle'> & Never<LinkButton> & Never<IconButton>;
type SubmitType = Overwrite<ButtonSharedProps, {
    type: 'submit';
}>;
type ButtonType = Overwrite<ButtonSharedProps, {
    type?: 'button';
    onClick: Exclude<ButtonProps['onClick'], undefined>;
}>;
type BaseButtonProps = SubmitType | ButtonType;
type LinkProps$1 = Overwrite<ButtonSharedProps, LinkButton & {
    as: ElementType$1;
    disabled?: false;
}>;
type IconProps = IconButton & Never<Pick<ButtonSharedProps, 'leftIcon' | 'rightIcon' | 'children'>>;
type IconButtonProps = Overwrite<ButtonType, IconProps> | Overwrite<SubmitType, IconProps> | Overwrite<LinkProps$1, IconProps>;
type UnifiedButtonProps = BaseButtonProps | IconButtonProps | LinkProps$1;

declare const Button: React__default.ForwardRefExoticComponent<Omit<UnifiedButtonProps, "disabled"> & {
    isDisabled?: boolean;
    disabled?: boolean;
    isLoading?: boolean;
} & React__default.RefAttributes<HTMLButtonElement>>;

declare const checkboxRecipe: _chakra_ui_react.SlotRecipeDefinition<"content" | "root" | "label" | "control", {
    variant: {
        alignCenter: {
            root: {
                alignItems: string;
            };
        };
        alignTop: {
            root: {
                alignItems: string;
            };
            control: {
                marginTop: string;
            };
        };
        alignTopForSmallSize: {
            root: {
                alignItems: string;
            };
            control: {
                marginTop: string;
            };
        };
    };
}>;

type CheckboxVariantProps = RecipeVariantProps<typeof checkboxRecipe>;
type CheckboxVariant = keyof NonNullable<typeof checkboxRecipe.variants>['variant'];
type CheckboxProps = CheckboxVariantProps & {
    name: string;
    value?: string;
    disabled?: boolean;
    checked?: boolean | 'indeterminate';
    invalid?: boolean;
    indeterminate?: boolean;
    readOnly?: boolean;
    fullWidth?: boolean;
    label?: ReactNode | string;
    paddingY?: BoxProps['paddingY'];
    fontWeight?: 'regular' | 'bold';
    variant?: CheckboxVariant;
    onChange?: (details: CheckboxCheckedChangeDetails) => void;
};

declare const Checkbox: React__default.ForwardRefExoticComponent<Omit<CheckboxProps, "onChange" | "disabled" | "checked" | "invalid"> & {
    isChecked?: boolean;
    isDisabled?: boolean;
    isInvalid?: boolean;
    onChange?: (event: React__default.ChangeEvent<HTMLInputElement>) => void;
    name: string;
} & React__default.RefAttributes<HTMLInputElement>>;

declare const chipRecipe: _chakra_ui_react.RecipeDefinition<{
    variant: {
        solid: {
            '--chip-border-style': "solid";
        };
        dashed: {
            '--chip-border-style': "dashed";
        };
    };
    selected: {
        false: {
            _hover: {
                bg: string;
                borderColor: string;
                _active: {
                    bg: string;
                    borderColor: string;
                };
            };
        };
        true: {
            bg: string;
            px: string;
            borderColor: string;
            _hover: {
                bg: string;
                _active: {
                    bg: string;
                };
            };
        };
    };
}>;

type ChipProps$1 = {
    onClick?: () => void;
    href?: string;
    'aria-label'?: string;
    disabled?: boolean;
} & RecipeVariantProps<typeof chipRecipe>;

type ChipProps = Omit<ChipProps$1, 'selected' | 'disabled'> & {
    isActive?: boolean;
    isDisabled?: boolean;
};
declare const Chip: FC<PropsWithChildren<ChipProps>>;

type Props$p = SeparatorProps;
declare const Divider: FC<Props$p>;

declare const fieldSlotRecipe: _chakra_ui_react.SlotRecipeDefinition<"root" | "button" | "label" | "errorText" | "helperText" | "labelRoot" | "requiredIndicator" | "tooltipWrapper" | "tooltipIcon", {
    size: {
        sm: {
            label: {
                fontSize: string;
            };
        };
        lg: {
            label: {
                fontSize: string;
            };
        };
    };
}>;

type FieldVariantProps = RecipeVariantProps<typeof fieldSlotRecipe>;
type FieldProps = FieldVariantProps & {
    id: string;
    disabled?: boolean;
    required?: boolean;
    errorMessage?: string;
    label?: string;
    hint?: string;
    tooltip?: string;
    labelButtonText?: string;
    labelButtonOnClick?: () => void;
};

type Props$o = Omit<FieldProps, 'required' | 'disabled'> & {
    isRequired?: boolean;
    isDisabled?: boolean;
};
declare const FormControl: FC<PropsWithChildren<Props$o>>;

declare const FormLabel: FC<PropsWithChildren>;

type Props$n = BoxProps & {
    above?: BreakpointName;
    below?: BreakpointName;
};
declare const Hide: FC<PropsWithChildren<Props$n>>;

declare const inputSlotRecipe: _chakra_ui_react.SlotRecipeDefinition<"icon" | "field" | "clearButton", {
    variant: {
        outline: {
            field: _chakra_ui_react.SystemStyleObject;
        };
    };
    size: {
        lg: {
            field: _chakra_ui_react.SystemStyleObject;
            icon: {
                paddingLeft: string;
            };
            clearButton: {
                paddingRight: string;
            };
        };
        md: {
            field: _chakra_ui_react.SystemStyleObject;
            icon: {
                paddingLeft: string;
            };
            clearButton: {
                paddingRight: string;
            };
        };
    };
}>;

type InputVariantProps$2 = RecipeVariantProps<typeof inputSlotRecipe>;
type SharedProps$2 = InputProps$1 & InputVariantProps$2 & {
    placeholder?: string;
    disabled?: boolean;
    onBlur?: FocusEventHandler<HTMLInputElement>;
    onFocus?: FocusEventHandler<HTMLInputElement>;
    onKeyDown?: KeyboardEventHandler<HTMLInputElement>;
    autoFocus?: boolean;
    name: string;
    type?: 'text' | 'number' | 'password';
    icon?: React__default.ComponentType;
    isClearable?: boolean;
    endElement?: ReactElement;
    rightAddonElement?: ReactElement;
    leftAddonElement?: ReactElement;
    autoComplete?: 'on' | 'off';
    readOnly?: boolean;
};
type ControlledInputProps = {
    debounce?: false;
    value: string | number;
    onChange: ChangeEventHandler<HTMLInputElement>;
    setInputValue?: never;
} & SharedProps$2;
type BaseInputPros = {
    debounce?: false;
    value?: never;
    onChange?: ChangeEventHandler<HTMLInputElement>;
    setInputValue?: never;
} & SharedProps$2;
type DebouncedInputPros = {
    value: string | number;
    onChange?: never;
    debounce: true;
    setInputValue: (value: string) => void;
} & SharedProps$2;
type ReadOnlyValueProps = {
    value: string | number;
    readOnly?: true;
    onChange?: never;
    debounce?: false;
    setInputValue?: never;
} & SharedProps$2;
type InputProps = ControlledInputProps | BaseInputPros | DebouncedInputPros | ReadOnlyValueProps;

type AdapterType<T> = T extends unknown ? Omit<T, 'disabled' | 'readOnly' | 'invalid'> & {
    isDisabled?: boolean;
    isReadOnly?: boolean;
    isInvalid?: boolean;
    textColor?: InputProps['color'];
} : never;
type Props$m = AdapterType<InputProps>;
declare const Input: React__default.ForwardRefExoticComponent<Props$m & React__default.RefAttributes<HTMLInputElement>>;

declare const sizes: {
    0: {
        value: string;
    };
    auto: {
        value: string;
    };
    xxs: {
        value: string;
    };
    xs: {
        value: string;
    };
    sm: {
        value: string;
    };
    md: {
        value: string;
    };
    lg: {
        value: string;
    };
    xl: {
        value: string;
    };
    '2xl': {
        value: string;
    };
    '3xl': {
        value: string;
    };
    '4xl': {
        value: string;
    };
    '5xl': {
        value: string;
    };
    '6xl': {
        value: string;
    };
    '7xl': {
        value: string;
    };
    '8xl': {
        value: string;
    };
    half: {
        value: string;
    };
    full: {
        value: string;
    };
    fit: {
        value: string;
    };
    container: {
        sm: {
            value: string;
        };
        md: {
            value: string;
        };
        lg: {
            value: string;
        };
        xl: {
            value: string;
        };
        '2xl': {
            value: string;
        };
    };
    'auth0-width': {
        value: string;
    };
    'auth0-height': {
        value: string;
    };
    'screen-height': {
        value: string;
    };
};

type Props$l = PropsWithChildren<{
    maxContentWidth?: keyof (typeof sizes)['container'];
}>;
declare const InsertionLayout: FC<Props$l>;

declare const linkRecipe: _chakra_ui_react.RecipeDefinition<{
    variant: {
        baseLink: {
            _hover: {
                cursor: string;
                textDecoration: string;
            };
        };
        navigationLink: {
            color: string;
            cursor: string;
            fontSize: string;
            _hover: {
                textDecoration: string;
                color: string;
            };
        };
        subNavigationLink: {
            color: string;
            cursor: string;
            fontSize: string;
            _hover: {
                textDecoration: string;
            };
            _focusVisible: {
                outline: string;
            };
        };
        footerLink: {
            color: string;
            _hover: {
                textDecoration: string;
            };
            _active: {
                color: string;
            };
            _visited: {
                color: string;
            };
        };
    };
    disabled: {
        true: {
            textDecoration: string;
            pointerEvents: string;
            color: string;
            _hover: {
                textDecoration: string;
            };
        };
    };
}>;

type LinkProps = LinkProps$2 & {
    isExternal?: boolean;
} & RecipeVariantProps<typeof linkRecipe>;

type Props$k = Omit<LinkProps, 'lineClamp' | 'href' | 'onClick' | 'truncate'> & {
    prefetch?: boolean;
    leftIcon?: React__default.ReactNode;
    rightIcon?: React__default.ReactNode;
    noOfLines?: number;
    href?: string | null;
    isTruncated?: LinkProps['truncate'];
    onClick?: React__default.MouseEventHandler<HTMLAnchorElement> | null;
    textColor?: LinkProps['color'];
    replace?: boolean;
};
declare const Link: FC<PropsWithChildren<Props$k>>;

type LinkOverlayProps = LinkOverlayProps$1 & {
    prefetch?: boolean;
};
declare const LinkOverlay: FC<PropsWithChildren<LinkOverlayProps>>;

declare const ListItem: React__default.ForwardRefExoticComponent<_chakra_ui_react.ListItemProps & React__default.RefAttributes<HTMLLIElement>>;
type ListProps = ListRootProps & {
    size?: ListRootProps['size'];
    spacing?: ListRootProps['gap'];
};
declare const List: FC<PropsWithChildren<ListProps>>;
declare const UnorderedList: FC<PropsWithChildren<{
    variant?: 'icon-outside' | 'icon-inside';
} & ListRootProps>>;
declare const OrderedList: FC<PropsWithChildren>;

type MotionPreset = 'none' | 'scale';
type DialogRootProps = {
    size?: 'md' | 'lg' | 'auth0' | 'full';
    variant?: 'fullScreen' | 'topScroll';
    overlayColor?: 'gray';
};
type ActionButton = {
    action: () => void;
    label: string;
};
type DialogProps = DialogRootProps & {
    title?: string;
    open?: UseDialogProps['open'];
    onOpenChange?: UseDialogProps['onOpenChange'];
    motionPreset?: MotionPreset;
    primaryActionButton?: ActionButton;
    secondaryActionButton?: ActionButton;
    disableBodyPadding?: boolean;
};
declare const Dialog: FC<PropsWithChildren<DialogProps>>;

declare const DialogCloseButton: React__default.ForwardRefExoticComponent<CloseButtonProps & React__default.RefAttributes<HTMLButtonElement>>;

type ModalCloseButtonProps = React__default.ComponentProps<typeof DialogCloseButton>;
declare const ModalCloseButton: FC<ModalCloseButtonProps>;
type Props$j = Omit<DialogProps, 'open'> & {
    isOpen?: boolean;
    onClose?: () => void;
};
declare const Modal: FC<PropsWithChildren<Props$j>>;

type ContentPadding$1 = '2xl' | '0';
type MaxWidth$1 = '6xl' | '8xl';
type Placement$2 = NonNullable<UsePopoverProps['positioning']>['placement'];
type PopoverProps = PropsWithChildren<{
    content: ReactNode;
    contentPadding?: ContentPadding$1;
    maxWidth?: MaxWidth$1;
    contentPosition?: 'relative' | 'absolute';
    placement?: Placement$2;
    size?: 'md' | 'xl';
    open?: boolean;
    onOpenChange?: UseDialogProps['onOpenChange'];
    showArrow?: boolean;
    closeOnInteractOutside?: boolean;
    gutter?: number;
    autoFocus?: boolean;
}>;

type Props$i = PopoverProps & {
    trigger?: 'hover' | 'click';
    onOpen?: () => void;
    onClose?: () => void;
    isOpen?: boolean;
    closeOnBlur?: boolean;
};
declare const Popover: React__default.FC<Props$i>;

declare const zIndex: {
    hide: {
        value: number;
    };
    auto: {
        value: string;
    };
    base: {
        value: number;
    };
    docked: {
        value: number;
    };
    header: {
        value: number;
    };
    dropdown: {
        value: number;
    };
    sticky: {
        value: number;
    };
    banner: {
        value: number;
    };
    overlay: {
        value: number;
    };
    modal: {
        value: number;
    };
    popover: {
        value: number;
    };
    skipLink: {
        value: number;
    };
    toast: {
        value: number;
    };
    fullScreenModal: {
        value: number;
    };
    tooltip: {
        value: number;
    };
};
type ZIndex = keyof typeof zIndex;

type FilterPatternProps = {
    /**
     * Shows the value of the filter in default and open state.
     * Can be a string or ReactNode (e.g., JSX with strikethrough formatting).
     */
    displayValue: string | ReactNode;
    /**
     * Showing an icon (e.g. EV indicator) on the filter button and heading
     */
    Icon?: FC<IconProps$1>;
    /**
     * To know if a filter is applied or not.
     * Controls styling and to know which button is shown.
     */
    isApplied: boolean;
    /**
     * Label for the filter button and the modal/popover title.
     */
    label: string;
    language: Language$1;
    /**
     * In case multiple filters are shown in the same filter (e.g. a list of checkboxes).
     * This can be used to show a branded bubble next to the filter title that shows how many filters are applied.
     */
    numberOfAppliedFilters?: number;
    /**
     * Callback that is called if the reset filter button is pressed.
     */
    onResetFilter: (placement: 'filterButton' | 'filter') => void;
    /**
     * If a call-to-action button is displayed in the filter footer
     * @default true
     */
    showCallToActionButton?: boolean;
    /**
     * To show a custom filter header.
     */
    header?: ReactNode;
    /**
     * Content of the filter.
     */
    children: ReactNode;
};

type ActionButtonProps = {
    /**
     * The primary action button if a filter is applied.
     * If a filter is not applied, a secondary close button is shown.
     */
    actionButton: {
        label: string;
        onClick?: () => void;
        href?: () => void;
    };
    onClose: () => void;
} & Pick<FilterPatternProps, 'isApplied'>;

type PopoverFilterProps = FilterPatternProps & Omit<ActionButtonProps, 'onClose'> & {
    initialPopoverState?: 'open' | 'closed';
    onPopoverClose?: () => void;
    onPopoverOpen?: () => void;
    appliedLabel?: string;
    enforceHeight?: boolean;
    triggerHeight?: 'md' | 'lg';
    disabled?: boolean;
    hasFlip?: boolean;
    zIndex?: ZIndex;
};

type Props$h = PopoverFilterProps & {
    isDisabled?: boolean;
};
declare const PopoverFilter: React__default.FC<Props$h>;

type NumericMinMaxValue = {
    min: number | null | undefined;
    max: number | null | undefined;
};
type ChangeCallback$1 = {
    touched: 'min' | 'max';
    value: NumericMinMaxValue;
};

type Facet = {
    from: number;
    to?: number | null;
    value: number;
};
interface RangeSliderWithChartProps {
    facets: Facet[];
    selection: NumericMinMaxValue;
    onSliderChange: (event: ChangeCallback$1) => void;
    onSliderRelease: (event: ChangeCallback$1) => void;
    chartHeight?: BoxProps['h'];
}

type RangeFilterInputField<Name> = {
    name: Name;
    value?: number | null;
    placeholder?: string;
    ariaLabel?: string;
};
type ChangeCallback<Name> = {
    value?: number | null;
    name: Name;
};
type PickedNumberInputProps = Pick<React__default.ComponentProps<typeof NumberInput.Root>, 'min' | 'max' | 'disabled' | 'onFocus'>;
type RangeFilterInputProps<NameFrom extends string, NameTo extends string> = {
    from: RangeFilterInputField<NameFrom>;
    handleChange: (event: ChangeCallback<NameFrom | NameTo>) => void;
    onBlur?: (event: ChangeCallback<NameFrom | NameTo>) => void;
    to: RangeFilterInputField<NameTo>;
    unit?: string;
} & PickedNumberInputProps;
declare const RangeFilterInput: <NameFrom extends string, NameTo extends string>({ from, to, handleChange, unit, onBlur, ...rest }: RangeFilterInputProps<NameFrom, NameTo>) => React__default.JSX.Element;

type ChangeRangeInputWithSliderCallback<Name> = {
    changeType?: 'inputfield' | 'slider';
} & ChangeCallback<Name>;
type RangeSliderProps$1 = {
    facets?: Facet[];
    rangeSliderScale?: number[];
    chartHeight?: RangeSliderWithChartProps['chartHeight'];
} & ({
    facets: Facet[];
    chartHeight?: string;
    rangeSliderScale?: never;
} | {
    rangeSliderScale: number[];
    facets?: never;
    chartHeight?: never;
});
type RangeFilterInputWithSliderProps<NameFrom, NameTo> = {
    from: RangeFilterInputField<NameFrom>;
    onChange: (event: ChangeRangeInputWithSliderCallback<NameFrom | NameTo>) => void;
    onBlur?: (event: ChangeRangeInputWithSliderCallback<NameFrom | NameTo>) => void;
    to: RangeFilterInputField<NameTo>;
    unit?: string;
} & RangeSliderProps$1 & PickedNumberInputProps;

type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
type AdapterProps<NFrom extends string, NTo extends string> = DistributiveOmit<RangeFilterInputWithSliderProps<NFrom, NTo>, 'disabled' | 'onFocus'> & {
    isDisabled?: boolean;
    onFocus?: FocusEventHandler<HTMLInputElement>;
};
declare function RangeFilterInputWithSlider<NFrom extends string, NTo extends string>(props: AdapterProps<NFrom, NTo>): React__default.JSX.Element;

declare const selectSlotRecipe: _chakra_ui_react.SlotRecipeDefinition<"root" | "indicator" | "field", {
    variant: {
        outline: {
            field: _chakra_ui_react.SystemStyleObject;
        };
    };
    size: {
        lg: {
            field: _chakra_ui_react.SystemStyleObject;
        };
        md: {
            field: _chakra_ui_react.SystemStyleObject;
        };
    };
}>;

type Option<T extends string | number> = {
    value: T;
    label: string;
};
type OptionsAndValue<T extends string | number> = {
    options: Option<T>[];
    value?: T;
};
type SelectVariantProps = RecipeVariantProps<typeof selectSlotRecipe>;
type SelectProps = SelectVariantProps & Pick<NativeSelectRootProps, 'disabled' | 'invalid'> & NativeSelectFieldProps & {
    name: string;
} & (OptionsAndValue<string> | OptionsAndValue<number>);

type Props$g = Omit<SelectProps, 'disabled'> & {
    isDisabled?: boolean;
    isInvalid?: boolean;
};
declare const Select: React__default.ForwardRefExoticComponent<Omit<Props$g, "ref"> & React__default.RefAttributes<HTMLSelectElement>>;

interface MenuItem {
    text: JSX.Element | string;
    value: string;
    onClick: () => void;
}
interface MenuProps {
    title: string | ReactElement;
    items: MenuItem[];
    value?: string;
    fontWeightTitle?: MenuTriggerProps['fontWeight'];
    offset?: {
        mainAxis?: number;
        crossAxis?: number;
    };
    menuColor?: MenuTriggerProps['color'];
    menuOptionColor?: MenuContentProps['color'];
    showChevron?: boolean;
    icon?: ReactElement;
    iconSpacing?: MenuTriggerProps['gap'];
    placement?: Exclude<MenuRootProps['positioning'], undefined>['placement'];
    showOptionsCheckmark?: boolean;
}
declare const Menu: FC<MenuProps>;

type MenuOption = {
    value: string;
    label: string;
    onClick: () => void;
};
type SelectMenuProps = Omit<MenuProps, 'items' | 'showOptionsCheckmark' | 'icon'> & {
    options: MenuOption[];
    withIndicator?: boolean;
    leftIcon?: ReactElement;
};
declare const SelectMenu: FC<SelectMenuProps>;

type Props$f = BoxProps & {
    showDisplay?: BoxProps['display'];
    above?: BreakpointName;
    below?: BreakpointName;
};
declare const Show: FC<PropsWithChildren<Props$f>>;

type Props$e = SimpleGridProps & {
    columns?: SimpleGridProps['columns'];
    spacing?: SimpleGridProps['gap'];
    spacingX?: SimpleGridProps['gapX'];
    spacingY?: SimpleGridProps['gapY'];
};
declare const SimpleGrid: FC<Props$e>;

type Props$d = Omit<SkeletonProps, 'loading'> & {
    isLoaded?: boolean;
};
declare const Skeleton: React__default.FC<PropsWithChildren<Props$d>>;

type Props$c = StackProps & {
    spacing?: StackProps['gap'];
};
declare const Stack: FC<Props$c>;

type SwitchProps = Pick<Switch$1.RootProps, 'onCheckedChange' | 'checked' | 'disabled'> & {
    id: string;
    label?: ReactNode;
};

type Props$b = Omit<SwitchProps, 'disabled' | 'checked' | 'onCheckedChange'> & {
    isChecked?: boolean;
    isDisabled?: boolean;
    onChange?: (event: ChangeEvent<HTMLInputElement>) => void;
};
declare const Switch: React__default.FC<Props$b>;

declare const tabsRecipe: _chakra_ui_react.SlotRecipeDefinition<"content" | "root" | "list" | "trigger" | "contentGroup", {
    variant: {
        default: {
            trigger: {
                display: string;
                _selected: {
                    borderBottomColor: string;
                };
            };
        };
        spaceBetween: {
            list: {
                justifyContent: string;
            };
            trigger: {
                _selected: {
                    borderBottomColor: string;
                };
            };
        };
        spaceAround: {
            list: {
                justifyContent: string;
            };
            trigger: {
                _selected: {
                    borderBottomColor: string;
                };
            };
        };
        enclosed: {
            list: {
                borderBottom: string;
            };
            trigger: {
                color: string;
                fontWeight: string;
                flexBasis: string;
                border: string;
                borderColor: string;
                backgroundColor: string;
                borderRight: string;
                '--tabs-border-width': "1px";
                _selected: {
                    backgroundColor: string;
                    borderBottomColor: string;
                };
                _last: {
                    borderRight: string;
                    borderRightColor: string;
                };
            };
            content: {
                m: string;
            };
        };
        fullWidth: {
            trigger: {
                flex: number;
                _selected: {
                    borderBottomColor: string;
                };
            };
            content: {
                m: string;
            };
        };
    };
}>;

type TabProps = Omit<TabsTriggerProps, 'variant'> & RecipeVariantProps<typeof tabsRecipe>;

type Props$a = TabProps & {
    isDisabled?: boolean;
    marginX?: TabProps['marginX'];
    value: TabProps['value'];
};
declare const Tab: FC<PropsWithChildren<Props$a>>;

type TabsProps = Omit<TabsRootProps, 'variant'> & RecipeVariantProps<typeof tabsRecipe>;

type Props$9 = Omit<TabsProps, 'onValueChange' | 'onChange'> & {
    onChange?: (value: string) => void;
};
declare const Tabs: React__default.FC<Props$9>;

declare const Table: React__default.ForwardRefExoticComponent<_chakra_ui_react.TableRootProps & React__default.RefAttributes<HTMLTableElement>>;
declare const Thead: React__default.ForwardRefExoticComponent<_chakra_ui_react.TableHeaderProps & React__default.RefAttributes<HTMLTableSectionElement>>;
declare const Tbody: React__default.ForwardRefExoticComponent<_chakra_ui_react.TableBodyProps & React__default.RefAttributes<HTMLTableSectionElement>>;
declare const Tr: React__default.ForwardRefExoticComponent<_chakra_ui_react.TableRowProps & React__default.RefAttributes<HTMLTableRowElement>>;
declare const Tfoot: React__default.ForwardRefExoticComponent<_chakra_ui_react.TableFooterProps & React__default.RefAttributes<HTMLTableSectionElement>>;
type ThProps = TableColumnHeaderProps & {
    isNumeric?: boolean;
};
declare const Th: FC<PropsWithChildren<ThProps>>;
type TdProps = TableCellProps & {
    isNumeric?: boolean;
};
declare const Td: FC<PropsWithChildren<TdProps>>;

type Props$8 = Omit<TextProps, 'truncated' | 'lineClamp'> & {
    noOfLines?: ConditionalValue<number>;
    isTruncated?: boolean;
    textColor?: TextProps['color'];
    align?: TextProps['textAlign'];
};
declare const Text: FC<PropsWithChildren<Props$8>>;

declare const articleTeaserRecipe: _chakra_ui_react.SlotRecipeDefinition<"title" | "text", _chakra_ui_react.SlotRecipeVariantRecord<"title" | "text">>;

type ArticleTeaserVariantProps = RecipeVariantProps<typeof articleTeaserRecipe>;
type ArticleTeaserProps = ArticleTeaserVariantProps & {
    title: string;
    text: string;
    imageUrl: string;
    url: string;
    maxImgW?: BoxProps['maxWidth'];
};
declare const ArticleTeaser: FC<ArticleTeaserProps>;

declare const AspectRatio: React.ForwardRefExoticComponent<AspectRatioProps & React.RefAttributes<HTMLDivElement>>;

type AvatarProps = {
    withNotification?: boolean;
    color?: BoxProps['color'];
};
declare const Avatar: FC<AvatarProps>;

type BadgeProps = Exclude<BadgeProps$1, 'children'> & {
    text: string;
};
declare const Badge: FC<BadgeProps>;

interface BreadcrumbsPropsExtended extends BreadcrumbRootProps {
    separator?: React__default.ReactNode;
}
declare const Breadcrumbs: FC<PropsWithChildren<BreadcrumbsPropsExtended>>;

declare const BreadcrumbsItem: FC<PropsWithChildren>;

type BreadcrumbLinkProps = Omit<BreadcrumbLinkProps$1, 'href'> & {
    href?: BreadcrumbLinkProps$1['href'] | null;
    prefetch?: boolean;
    replace?: boolean;
};
declare const BreadcrumbLink: FC<BreadcrumbLinkProps>;

declare const Root: React.ForwardRefExoticComponent<Card.RootProps & React.RefAttributes<HTMLDivElement>>;
declare const Header: React.ForwardRefExoticComponent<CardHeaderProps & React.RefAttributes<HTMLDivElement>>;
declare const Body: React.ForwardRefExoticComponent<CardBodyProps & React.RefAttributes<HTMLDivElement>>;
declare const Footer$1: React.ForwardRefExoticComponent<CardFooterProps & React.RefAttributes<HTMLDivElement>>;
declare const CardComponents: {
    Root: React.ForwardRefExoticComponent<Card.RootProps & React.RefAttributes<HTMLDivElement>>;
    Body: React.ForwardRefExoticComponent<CardBodyProps & React.RefAttributes<HTMLDivElement>>;
    Header: React.ForwardRefExoticComponent<CardHeaderProps & React.RefAttributes<HTMLDivElement>>;
    Footer: React.ForwardRefExoticComponent<CardFooterProps & React.RefAttributes<HTMLDivElement>>;
};

type BreakpointKeys = keyof typeof breakpoints;
type ResponsiveValue<T> = Partial<Record<BreakpointKeys, T>>;

type SharedProps$1 = {
    startIndex?: number;
    onSlideClick?: (index: number) => void;
    onSlideSelect?: (index: number) => void;
    slidesPerView?: ResponsiveValue<number> | 1;
    loop?: boolean;
    slidesToScroll?: 'auto' | number;
};
type DefaultProps = {
    fullScreen?: never;
    children: ReactNode[];
    paginationType?: Exclude<PaginationType, PaginationType.Thumbnail>;
} & SharedProps$1;
type FullScreenSlide = {
    slide: ReactNode;
    thumbnail: ReactNode;
    onSlideEnter?: () => void;
    onSlideLeave?: () => void;
};
type FullScreenProps = {
    fullScreen: true;
    paginationType?: never;
    children: FullScreenSlide[];
} & SharedProps$1;
type CarouselProps = DefaultProps | FullScreenProps;
declare enum PaginationType {
    Thumbnail = "thumbnail",
    Number = "number",
    None = "none",
    Dot = "dot"
}
declare const Carousel: FC<CarouselProps>;

type CenterProps = Pick<CenterProps$1, 'children' | 'padding'>;
declare const Center: FC<CenterProps>;

type Item<ItemKey, FilterName> = {
    childCheckboxes?: Item<ItemKey, FilterName>[];
    facet?: number | null;
    filterName?: FilterName;
    highlightIndices?: ReadonlyArray<[number, number]>;
    image?: ReactNode;
    isChecked?: boolean;
    key: ItemKey;
    label: string;
};
type Props$7<ItemKey extends string, FilterName extends string> = {
    alwaysExpanded?: boolean;
    /**
     * @template ItemKey
     * @template FilterName
     * @param {Item} item     renders one checkbox { key: ItemKey, label: string, facet: number, isChecked: boolean }
     * @param item.key        unique name of the checkbox
     * @param item.label      label shown on the UI
     * @param item.facet      Numeric value shown next to the checkbox label. Indicates how many search results are going to be visible after the checkbox has been applied.
     * @param item.isChecked  The checkbox filter is a controlled component and the updated filter value must be passed in order to see the correct state.
     * @param item.image      image/icon shown on the UI
     * @param item.childCheckboxes      to show a collapsible checkbox with child items
     * @param item.filterName      in case multiple filters are controlled
     */
    items: Item<ItemKey, FilterName>[];
    /**
     * Callback function that is triggered after any checkbox has been clicked.
     * In case of the nested checkboxes it needs to update the parent/children respectively
     * @param updatedItem     contains the modified checkbox with the new value
     */
    onApply: (updatedItem: Item<ItemKey, FilterName>) => void;
    numberOfColumnsOnDesktop?: number;
    onToggleCheckboxGroup?: (pressedItem: Item<ItemKey, FilterName>) => void;
    language: Language$1;
};

declare function CheckboxFilter<ItemKey extends string, FilterName extends string>({ alwaysExpanded, items, onApply, numberOfColumnsOnDesktop, onToggleCheckboxGroup, language, }: Props$7<ItemKey, FilterName>): React__default.JSX.Element;

interface CheckboxGroupProps extends CheckboxProps {
    /**
     * Array of children checkboxes
     */
    checkboxes?: CheckboxProps[];
    addDividerAfterIndex?: number[];
}
declare const CheckboxGroup: FC<CheckboxGroupProps>;

type CollapseProps = {
    in: boolean;
    animateOpacity?: boolean;
} & Omit<CollapsibleRootProps, 'open'>;
declare const Collapse: FC<PropsWithChildren<CollapseProps>>;

interface ColorPickerProps extends InputProps$1 {
    invalid?: boolean;
}
declare const ColorPicker: React__default.ForwardRefExoticComponent<ColorPickerProps & React__default.RefAttributes<HTMLInputElement>>;

declare const countRecipe: _chakra_ui_react.RecipeDefinition<{
    variant: {
        primary: {
            bg: string;
            color: string;
        };
        inverted: {
            bg: string;
            color: string;
        };
        info: {
            bg: string;
            color: string;
        };
        success: {
            bg: string;
            color: string;
        };
        warning: {
            bg: string;
            color: string;
        };
        error: {
            bg: string;
            color: string;
        };
    };
}>;

type CountVariantProps = RecipeVariantProps<typeof countRecipe>;
type CountProps = CountVariantProps & {
    count: number;
    ariaLabel?: string;
};
declare const Count: FC<CountProps>;

type InputVariantProps$1 = RecipeVariantProps<typeof inputSlotRecipe>;
type DatePickerProps = Pick<InputProps$1, 'onFocus' | 'onBlur' | 'onChange'> & InputVariantProps$1 & {
    min?: Date;
    value?: string;
    invalid?: boolean;
};
declare const DatePicker: React__default.ForwardRefExoticComponent<Pick<InputProps$1, "onChange" | "onBlur" | "onFocus"> & {
    variant?: _chakra_ui_react.ConditionalValue<"outline" | undefined>;
    size?: _chakra_ui_react.ConditionalValue<"md" | "lg" | undefined>;
} & {
    min?: Date;
    value?: string;
    invalid?: boolean;
} & React__default.RefAttributes<HTMLInputElement>>;

declare enum Brand {
    AutoScout24 = "autoscout24",
    MotoScout24 = "motoscout24"
}

type DevOverlayVariables = {
    name: string;
    value: string;
}[];
type DevOverlayProps = {
    hideDevOverlay: Exclude<ButtonSharedProps['onClick'], undefined>;
    toggleTheme: Exclude<SwitchProps['onCheckedChange'], undefined>;
    toggleTranslation: Exclude<SwitchProps['onCheckedChange'], undefined>;
    variables: DevOverlayVariables;
    activeTheme: Brand;
    displayTranslationKeys: boolean;
};
declare const DevOverlay: FC<DevOverlayProps>;

type DiscreteSliderMark<T> = {
    stepValue?: number;
    label: ReactNode;
    value: T;
};
type DiscreteSliderProps<T> = {
    applyIndentation?: boolean;
    marks: DiscreteSliderMark<T>[];
    value: T;
    onValueChanged: (arg: T) => void;
};
declare const DiscreteSlider: <T>({ marks, applyIndentation, onValueChanged, value, }: DiscreteSliderProps<T>) => React__default.JSX.Element;

declare const DrawerOverlay: FC<PropsWithChildren>;

interface Props$6 extends DrawerContentProps {
    withCloseButton?: boolean;
    p?: DrawerContentProps['p'];
    borderRadius?: DrawerContentProps['borderRadius'];
}
declare const DrawerContent: FC<PropsWithChildren<Props$6>>;

declare const DrawerBody: FC<PropsWithChildren<DrawerBodyProps>>;

interface DrawerProps extends Omit<DrawerRootProps, 'open' | 'onOpenChange'> {
    isOpen: boolean;
    onClose: () => void;
}
declare const Drawer: FC<PropsWithChildren<DrawerProps>>;

declare const energyLabelRecipe: _chakra_ui_react.SlotRecipeDefinition<"root" | "text" | "triangle" | "textWrapper", {
    efficiency: {
        A: {
            root: {
                '--label-color': "#4CA651";
            };
        };
        B: {
            root: {
                '--label-color': "#54B646";
            };
        };
        C: {
            root: {
                '--label-color': "#CAD143";
            };
        };
        D: {
            root: {
                '--label-color': "#FEF050";
            };
        };
        E: {
            root: {
                '--label-color': "#F1AE3D";
            };
        };
        F: {
            root: {
                '--label-color': "#EE6E2D";
            };
        };
        G: {
            root: {
                '--label-color': "#D02F26";
            };
        };
    };
}>;

type RecipeProps = RecipeVariantProps<typeof energyLabelRecipe>;
type EnergyLabelProps = Required<Pick<RecipeProps, 'efficiency'>> & RecipeProps;
declare const EnergyLabel: FC<EnergyLabelProps>;

type ErrorStatusCode = 404 | 500 | 'clientSide' | 'UNVERIFIED_EMAIL' | 'INITIAL_UNVERIFIED_EMAIL' | 'USER_BLOCKED' | 'UNKNOWN_AUTH_ERROR' | 'EMAIL_CHANGE_VERIFICATION_ERROR';

interface ErrorPageContentProps {
    statusCode: ErrorStatusCode;
    language: Language$1;
    onButtonClick?: () => void;
}

declare const ErrorPage: React.FC<ErrorPageContentProps>;

declare const colors: {
    white: {
        value: string;
    };
    black: {
        value: string;
    };
    whiteAlpha: {
        50: {
            value: string;
        };
        100: {
            value: string;
        };
        200: {
            value: string;
        };
        300: {
            value: string;
        };
        400: {
            value: string;
        };
        500: {
            value: string;
        };
        600: {
            value: string;
        };
        700: {
            value: string;
        };
        800: {
            value: string;
        };
        900: {
            value: string;
        };
    };
    blackAlpha: {
        50: {
            value: string;
        };
        100: {
            value: string;
        };
        200: {
            value: string;
        };
        300: {
            value: string;
        };
        400: {
            value: string;
        };
        500: {
            value: string;
        };
        600: {
            value: string;
        };
        700: {
            value: string;
        };
        800: {
            value: string;
        };
        900: {
            value: string;
        };
    };
    blue: {
        50: {
            value: string;
        };
        100: {
            value: string;
        };
        200: {
            value: string;
        };
        300: {
            value: string;
        };
        400: {
            value: string;
        };
        500: {
            value: string;
        };
        600: {
            value: string;
        };
        700: {
            value: string;
        };
        800: {
            value: string;
        };
        900: {
            value: string;
        };
    };
    teal: {
        50: {
            value: string;
        };
        100: {
            value: string;
        };
        200: {
            value: string;
        };
        300: {
            value: string;
        };
        400: {
            value: string;
        };
        500: {
            value: string;
        };
        600: {
            value: string;
        };
        700: {
            value: string;
        };
        800: {
            value: string;
        };
        900: {
            value: string;
        };
    };
    anthracite: {
        50: {
            value: string;
        };
        100: {
            value: string;
        };
        200: {
            value: string;
        };
        300: {
            value: string;
        };
        400: {
            value: string;
        };
        500: {
            value: string;
        };
        600: {
            value: string;
        };
        700: {
            value: string;
        };
        800: {
            value: string;
        };
        900: {
            value: string;
        };
    };
    gray: {
        50: {
            value: string;
        };
        100: {
            value: string;
        };
        200: {
            value: string;
        };
        300: {
            value: string;
        };
        400: {
            value: string;
        };
        500: {
            value: string;
        };
        600: {
            value: string;
        };
        700: {
            value: string;
        };
        800: {
            value: string;
        };
        900: {
            value: string;
        };
    };
    green: {
        50: {
            value: string;
        };
        100: {
            value: string;
        };
        200: {
            value: string;
        };
        300: {
            value: string;
        };
        400: {
            value: string;
        };
        500: {
            value: string;
        };
        600: {
            value: string;
        };
        700: {
            value: string;
        };
        800: {
            value: string;
        };
        900: {
            value: string;
        };
    };
    orange: {
        50: {
            value: string;
        };
        100: {
            value: string;
        };
        200: {
            value: string;
        };
        300: {
            value: string;
        };
        400: {
            value: string;
        };
        500: {
            value: string;
        };
        600: {
            value: string;
        };
        700: {
            value: string;
        };
        800: {
            value: string;
        };
        900: {
            value: string;
        };
    };
    red: {
        50: {
            value: string;
        };
        100: {
            value: string;
        };
        200: {
            value: string;
        };
        300: {
            value: string;
        };
        400: {
            value: string;
        };
        500: {
            value: string;
        };
        600: {
            value: string;
        };
        700: {
            value: string;
        };
        800: {
            value: string;
        };
        900: {
            value: string;
        };
    };
    purple: {
        50: {
            value: string;
        };
        100: {
            value: string;
        };
        200: {
            value: string;
        };
        300: {
            value: string;
        };
        400: {
            value: string;
        };
        500: {
            value: string;
        };
        600: {
            value: string;
        };
        700: {
            value: string;
        };
        800: {
            value: string;
        };
        900: {
            value: string;
        };
    };
    violet: {
        50: {
            value: string;
        };
        100: {
            value: string;
        };
        200: {
            value: string;
        };
        300: {
            value: string;
        };
        400: {
            value: string;
        };
        500: {
            value: string;
        };
        600: {
            value: string;
        };
        700: {
            value: string;
        };
        800: {
            value: string;
        };
        900: {
            value: string;
        };
    };
    none: {
        value: string;
    };
    inherit: {
        value: string;
    };
    currentColor: {
        value: string;
    };
    transparent: {
        value: string;
    };
};
type Colors = {
    [K in keyof typeof colors]: 'value' extends keyof (typeof colors)[K] ? K : K extends string ? `${K}.${Extract<keyof (typeof colors)[K], string | number>}` : never;
}[keyof typeof colors];

type Size = Exclude<keyof typeof sizes, 0 | 'container'>;
type OpenFilterButtonPaddingX = '0' | 'md';
type OpenFilterButtonDisplayType = 'default' | 'inline';
type Variant = 'sm' | 'md';
type Props$5 = Pick<DialogFilterProps, 'label' | 'displayValue' | 'Icon' | 'isApplied'> & {
    appliedLabel?: string;
    onClick: () => void;
    variant?: Variant;
    isDisabled?: boolean;
    height?: ConditionalValue<Size>;
    paddingX?: OpenFilterButtonPaddingX;
    color?: Colors;
    backgroundColor?: Colors;
    showResetButton?: boolean;
    resetButtonAriaLabel?: string;
    onResetFilter?: () => void;
    displayType?: OpenFilterButtonDisplayType;
};
declare const OpenFilterButton: FC<Props$5>;

type DialogFilterProps = FilterPatternProps & Omit<ActionButtonProps, 'onClose'> & {
    onDialogOpen?: () => void;
    onDialogClose?: () => void;
    initialDialogState?: 'open' | 'closed';
    isDisabled?: boolean;
    backgroundColor?: Colors;
    color?: Colors;
    paddingX?: OpenFilterButtonPaddingX;
    trapFocus?: boolean;
    triggerHeight?: 'lg' | 'md';
    showResetButton?: boolean;
    triggerDisplayType?: OpenFilterButtonDisplayType;
    appliedLabel?: string;
};

declare const DialogFilter: React.FC<DialogFilterProps>;

type FilterHeadingContentProps = {
    onClose?: () => void;
    language: Language$1;
    contentRef?: RefObject<HTMLElement | null>;
} & Pick<FilterPatternProps, 'Icon' | 'isApplied' | 'label' | 'numberOfAppliedFilters' | 'onResetFilter'>;

declare const FilterHeading: React.FC<FilterHeadingContentProps>;

type FlexProps = Omit<FlexProps$1, 'gap' | 'columnGap' | 'rowGap'>;
declare const Flex: FC<FlexProps>;

type FocusedHeaderProps = {
    brand: Brand;
};
declare const FocusedHeader: FC<FocusedHeaderProps>;

type BaseProps = {
    id: string;
    errorMessage?: string;
    label?: string;
    hint?: string;
    tooltip?: string;
};
declare const FormControlSection: FC<PropsWithChildren<BaseProps>>;

declare const FullHeight: FC<PropsWithChildren>;

type Language = 'de' | 'fr' | 'it' | 'en';

interface GalleryHeaderProps {
    currentSlide: number;
    slidesCount: number;
    onClose: () => void;
    language: Language;
}

declare const GalleryHeader: React.FC<PropsWithChildren<GalleryHeaderProps>>;

declare const Grid: React.ForwardRefExoticComponent<GridProps & React.RefAttributes<HTMLDivElement>>;
declare const GridItem: React.ForwardRefExoticComponent<GridItemProps & React.RefAttributes<HTMLDivElement>>;

type HeadingProps = Omit<HeadingProps$1, 'as' | 'asChild'>;
declare const H1: FC<HeadingProps>;
declare const H2: FC<HeadingProps>;
declare const H3: FC<HeadingProps>;
declare const H4: FC<HeadingProps>;
declare const H5: FC<HeadingProps>;
declare const H6: FC<HeadingProps>;

type Placement$1 = NonNullable<UseHoverCardProps['positioning']>['placement'];
type ContentPadding = '2xl' | '0';
type MaxWidth = '6xl' | '8xl';
type HoverCardProps = PropsWithChildren<{
    content: ReactNode;
    showArrow?: boolean;
    contentPadding?: ContentPadding;
    maxWidth?: MaxWidth;
    contentPosition?: 'relative' | 'absolute';
    placement?: Placement$1;
    size?: 'md' | 'xl';
    gutter?: number;
}>;
declare const HoverCard: FC<HoverCardProps>;

declare const AiSearchIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const AdvancedSearchIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const SparkIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ArrowCircleIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ArrowDiagonalIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ArrowDownIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ArrowLeftIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ArrowRightIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ArrowUpIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const AutoScout24AppLogo: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const AvatarIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const AvatarWithNotificationIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const BatteryIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const BookmarkIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const CalculatorIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const CalendarIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const CallIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const CamperIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const CarConditionIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const CarIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const CopyIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ChartIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const CheckmarkIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const CheckmarkCircleIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const CheckShieldIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ChevronDownLargeIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ChevronDownSmallIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ChevronLeftLargeIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ChevronLeftSmallIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ChevronRightLargeIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ChevronRightSmallIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ChevronRightTinyIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ChevronUpLargeIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ChevronUpSmallIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const CloseIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const CompareIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ConsumptionIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const CreditIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const CreditCardIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const DaylightIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const DeleteIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const DocumentCheckIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const DocumentIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const DragIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const DriveSystemIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const DriveTypeIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const EquipmentIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ErrorIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ExchangeIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const EyeIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const EyeCrossedIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const FacebookIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const FlagIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const FlameIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const FlashIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const GasStationIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const HeartIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const HistoryClockIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const HouseIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ImageIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const InfoIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const InstagramIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const InteriorIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const LinkedinIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const LinkIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ListIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const LocationPinIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const MagnifierIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const MessageIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const MessageSparkleIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const MissingImageIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const MotorcycleIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const MotoScout24AppLogo: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const PdfIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const PhoneIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const PenIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const PlusIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ChfCurrencyIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const PrintIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const RangeIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const RoadIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const RotateIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const SafeNumberIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ShareIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const StarIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const SteeringWheelIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ThreeSixtyIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const TimeIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const TooltipIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const InformationIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const TopListingIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const TrailerIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const TransmissionIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const TransparentLockIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const TrashIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const TruckIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const TwitterIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const UtilityVehicleIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const VehiclePowerIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const VehicleTypesMotorcycleIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const VideoIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const VideoCameraIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ViewCarIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const DriveSystemLargeIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const WarningIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const WhatsAppIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const YoutubeIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const SortIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ViewMotorcycleIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const GoogleIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const SaveSearchIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const AutoScout24Icon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const MotoScout24Icon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const MagnifierLargeIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const RocketIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const CartIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const VanIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const MiniVanIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const SuvIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const CoupeIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const CabrioletIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const SmallCarIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const SedanIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const WagonIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const PickUpIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const InformationBubbleIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const OverflowVerticalIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const PartialClockIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const LockIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const TiltedRectangleIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const PlusCircleIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const StarCircleIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const InfinityCircleIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const VehicleTypesMotorcycleStarIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const CategoryAOneIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const CategoryAIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const CategoryAMinusIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const BankNotesIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ChatBubbleIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const DigitalContractIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const OptimizerIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const CheckmarkCircleColorIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ArrowDownCircleIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ArrowUpCircleIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const NotAvailableIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const LabelIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const BulbIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const NoPhotoIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ThumbsUpIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ThumbsDownIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const MinusIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const DoubleChevronUpIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const DoubleChevronDownIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const DoubleLineIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const NotAvailableSquareIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const WarrantyIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const DownloadIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const TriangleIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const SwissFlagIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const GlobeIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const GarageIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const HamburgerMenuIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const LogoutIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const AndroidIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const AppleIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const WindowsIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const SpeakerIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const SquareIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const AddPhotoIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ScreenIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const QualitySealIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ExpandIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const CollapseIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ForwardIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const BalanceIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ParagraphIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const UploadIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ZoomInIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

declare const ZoomOutIcon: React__default.ForwardRefExoticComponent<_chakra_ui_react.IconProps & React__default.RefAttributes<SVGSVGElement>>;

type SearchFieldOptions = {
    placeholder?: string;
    onFocus?: () => void;
    onBlur?: () => void;
    autofocusOnDesktop?: boolean;
    autoComplete?: 'on' | 'off';
};
type SearchFieldProps = {
    name: string;
    ariaControls?: string;
    searchQuery: string;
    setSearchQuery: (newQuery: string) => void;
} & SearchFieldOptions;
declare const SearchField: FC<SearchFieldProps>;

declare const repeatArea: (count: number, area: string) => string;

interface Props$4 {
    header?: ReactNode;
    maxContentWidth: keyof typeof sizes.container;
    skyScraperAd?: ReactNode;
    heroAd?: ReactNode;
    footer?: ReactNode;
}
declare const PageLayout: FC<PropsWithChildren<Props$4>>;

type SingleColumnCenteredLayoutProps = PropsWithChildren<{
    maxContentWidth?: keyof (typeof sizes)['container'];
}>;
declare const SingleColumnCenteredLayout: FC<SingleColumnCenteredLayoutProps>;

type ColumnSize = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11;
interface TwoColumnsLayoutProps {
    header?: ReactNode;
    title?: string | ReactNode;
    backLink?: {
        text: string;
        url: string;
    } | ReactNode;
    left: {
        content: ReactNode;
        columns?: ColumnSize;
    };
    right: {
        content: ReactNode;
        columns?: ColumnSize;
    };
    maxContentWidth?: keyof typeof sizes.container;
}
declare const TwoColumnsLayout: FC<TwoColumnsLayoutProps>;

declare const vehicleReferenceRecipe: _chakra_ui_react.SlotRecipeDefinition<"carTitle" | "price" | "dealerName" | "dealerAddress", _chakra_ui_react.SlotRecipeVariantRecord<"carTitle" | "price" | "dealerName" | "dealerAddress">>;

type VehicleReferenceVariantProps = RecipeVariantProps<typeof vehicleReferenceRecipe>;
type VehicleReferenceProps = VehicleReferenceVariantProps & {
    image?: ReactNode;
    vehicleTitle: string;
    price?: string | null;
    sellerName?: string | null;
    sellerAddress?: string | null;
    callToAction?: ReactNode;
    templateColumns?: ComponentProps<typeof Grid>['templateColumns'];
};
declare const VehicleReference: FC<VehicleReferenceProps>;

interface Props$3 extends Omit<TwoColumnsLayoutProps, 'left' | 'right'> {
    vehicle: VehicleReferenceProps;
    leftColumnSize?: ColumnSize;
    rightColumnSize?: ColumnSize;
}
declare const LayoutWithVehicleReference: FC<PropsWithChildren<Props$3>>;

declare const AppLayout: React__default.ForwardRefExoticComponent<GridProps & {
    children?: React__default.ReactNode | undefined;
} & React__default.RefAttributes<HTMLDivElement>>;

declare const AppLayoutContent: React__default.ForwardRefExoticComponent<GridItemProps & React__default.RefAttributes<HTMLDivElement>>;

declare const AppLayoutHeader: React__default.ForwardRefExoticComponent<GridItemProps & React__default.RefAttributes<HTMLDivElement>>;

declare const AppLayoutFooter: React__default.ForwardRefExoticComponent<GridItemProps & React__default.RefAttributes<HTMLDivElement>>;

type CommonListItem = {
    label: string;
    value: string;
    facet?: string;
    isSelected: boolean;
    showChevron?: boolean;
    highlightIndices?: readonly RangeTuple[];
    isCheckbox?: boolean;
    paddingLeft?: ConditionalValue<'md' | '2xl'>;
};
type CheckboxListItem = {
    onClick: (details: CheckboxCheckedChangeDetails) => void;
    isCheckbox: true;
    isIndeterminate?: boolean;
} & CommonListItem;
type RadioButtonListItem = {
    onClick: React__default.MouseEventHandler<HTMLButtonElement>;
    isCheckbox?: false;
} & CommonListItem;
type ListItemType = CheckboxListItem | RadioButtonListItem;

type ListItemWithChildren = ListItemType & {
    children?: ListItemType[];
};
type Props$2 = {
    listItems: ListItemWithChildren[];
    NoResults?: FC;
    EmptyQueryPlaceholder?: FC;
    listAriaLabel?: string;
    searchFieldOptions?: SearchFieldOptions;
    listOptions?: {
        columns?: number;
        childrenSpacing?: 'md' | '2xl';
    };
    listRef?: React__default.RefObject<HTMLUListElement | null>;
};
declare const SearchableList: FC<Props$2>;

type MissingImageProps = Pick<BoxProps, 'width' | 'height' | 'aspectRatio'>;
declare const MissingImage: FC<MissingImageProps>;

type MobileOnlyAccordionProps = RecipeVariantProps<typeof accordionRecipe> & Pick<Accordion$1.RootProps, 'multiple' | 'collapsible' | 'value' | 'onValueChange'>;
declare const MobileOnlyAccordion: FC<PropsWithChildren<MobileOnlyAccordionProps>>;

type Project = 'listings-web' | 'seller-web';

type Environment = 'production' | 'preprod';

interface FooterProps {
    brand: Brand;
    language: Language;
    environment?: Environment;
    useAbsoluteUrls?: boolean;
    project?: Project;
}
declare const Footer: FC<FooterProps>;

type CustomEvent = {
    eventAction: string;
    eventCategory: string;
    eventLabel?: string | null;
};

interface NavigationProps {
    brand: Brand;
    comparisonItemIds?: number[] | null;
    entitlements?: string[];
    environment: Environment;
    experiments?: Record<string, string>;
    hasNotification: boolean;
    language: Language$1;
    onLogin: () => void;
    onLogout: () => void;
    trackEvent?: (event: CustomEvent) => void;
    useAbsoluteUrls?: boolean;
    project?: Project;
    user: EnrichedSessionUser | null;
    selectTenant: (sellerId: number | string) => Promise<void>;
    showTenantSelection?: boolean;
}
declare const Navigation: FC<NavigationProps>;

type PaginationProps = {
    totalPages: number;
    /**
     * index of the current page, zero-based
     */
    currentPage: number;
    /**
     * @param page zero-based page index
     */
    onChange: (page: number) => void;
} & Pick<BoxProps, 'marginTop' | 'marginBottom'>;
declare const Pagination: FC<PaginationProps>;

interface ProgressProps {
    current: number;
    max: number;
    label: (current: number, max: number) => ReactNode;
}
declare const Progress: FC<ProgressProps>;

declare const radioRecipe: _chakra_ui_react.SlotRecipeDefinition<"root" | "indicator" | "label" | "item" | "control", {
    variant: {
        fontRegular: {
            root: {};
            item: {};
            control: {};
            indicator: {};
            label: {
                fontWeight: string;
            };
        };
        fontBold: {
            root: {};
            item: {};
            control: {};
            indicator: {};
            label: {
                fontWeight: string;
            };
        };
    };
    size: {
        base: {
            root: {};
            item: {};
            control: {};
            indicator: {};
            label: {
                fontSize: string;
            };
        };
        md: {
            root: {};
            item: {};
            control: {};
            indicator: {};
            label: {
                fontSize: string;
            };
        };
    };
}>;

type RadioItemProps = {
    value: string;
    label?: string;
    invalid?: boolean;
    disabled?: boolean;
};
type RadioRenderFn = (renderedItems: React__default.ReactElement[]) => ReactNode;
type RadioProps = RecipeVariantProps<typeof radioRecipe> & {
    value?: string;
    items: RadioItemProps[];
    orientation?: 'horizontal' | 'vertical';
    name?: string;
    onChange?: (event: ChangeEvent<HTMLInputElement>) => void;
    children?: RadioRenderFn;
};
declare const Radio: React__default.ForwardRefExoticComponent<{
    variant?: _chakra_ui_react.ConditionalValue<"fontRegular" | "fontBold" | undefined>;
    size?: _chakra_ui_react.ConditionalValue<"base" | "md" | undefined>;
} & {
    value?: string;
    items: RadioItemProps[];
    orientation?: "horizontal" | "vertical";
    name?: string;
    onChange?: (event: ChangeEvent<HTMLInputElement>) => void;
    children?: RadioRenderFn;
} & React__default.RefAttributes<HTMLInputElement>>;

type RadioListProps = {
    options: React__default.ReactElement[];
    name?: string;
    defaultValue?: string;
    onChange?: (value: string) => void;
};
declare const RadioList: FC<RadioListProps>;

type SliderRootProps = Omit<React__default.ComponentProps<typeof Slider.Root>, 'onChange'>;
type RangeSliderProps = SliderRootProps & {
    onChange?: (values: number[]) => void;
    onChangeEnd?: (values: number[]) => void;
};
declare const RangeSlider: React__default.FC<RangeSliderProps>;

declare const ratingRecipe: _chakra_ui_react.RecipeDefinition<{
    size: {
        sm: {
            fontSize: string;
        };
        lg: {
            fontSize: string;
        };
    };
}>;

type RatingVariantProps = RecipeVariantProps<typeof ratingRecipe>;
type RatingProps = RatingVariantProps & {
    rating: number;
};
declare const Rating: FC<RatingProps>;

declare const sectionRecipe: _chakra_ui_react.SlotRecipeDefinition<"title" | "root" | "text" | "imageContainer" | "textContainer", {
    variant: {
        hero: {
            title: {
                textStyle: "heading1";
            };
            text: {
                textStyle: "body-large";
            };
        };
        regular: {
            title: {
                textStyle: "heading2";
            };
            text: {
                textStyle: "body";
            };
        };
    };
}>;

type SectionVariantProps = RecipeVariantProps<typeof sectionRecipe>;
type SectionProps = SectionVariantProps & {
    title: string;
    text?: string;
    image?: ReactNode;
    maxImgW?: BoxProps['maxWidth'];
};
declare const Section: FC<SectionProps>;

type SpinnerProps = SpinnerProps$1 & {
    size?: 'xs' | 'sm' | 'md' | 'lg';
};
declare const Spinner: FC<SpinnerProps>;

type TabListProps = Omit<TabsListProps, 'variant'> & RecipeVariantProps<typeof tabsRecipe>;
declare const TabList: FC<PropsWithChildren<TabListProps>>;

type TabPanelProps = Omit<TabsContentProps, 'variant'> & RecipeVariantProps<typeof tabsRecipe>;
declare const TabPanel: FC<PropsWithChildren<TabPanelProps>>;

type TabPanelsProps = RecipeVariantProps<typeof tabsRecipe>;
declare const TabPanels: FC<PropsWithChildren<TabPanelsProps>>;

type TenantSelectionState = {
    showSelection: boolean;
    persistSelection: boolean;
    selectedTenant: null | number;
};
type TenantSelectionProps = {
    user: EnrichedSessionUser | null;
    isLoading?: boolean;
    selectTenant: (sellerId: number | string) => void;
    language: Language$1;
};
declare const TenantSelection: FC<TenantSelectionProps>;

type HighlightedTextProps = {
    text: string;
    highlightIndices?: ReadonlyArray<[number, number]>;
} & Omit<TextProps, 'as' | 'fontWeight'>;
declare const HighlightedText: FC<HighlightedTextProps>;

declare const markedTextRecipe: _chakra_ui_react.SlotRecipeDefinition<"container" | "mark" | "text", {
    variant: {
        highlight: {
            container: {
                '--mark-top': "0";
                '--mark-left': "0";
                '--mark-width': "100%";
                '--mark-height': "100%";
                paddingX: string;
            };
        };
        underline: {
            container: {
                '--mark-top': "1.25em";
                '--mark-left': "-0.25ch";
                '--mark-width': "calc(100% + 0.5ch)";
                '--mark-height': {
                    md: "8px";
                    base: "6px";
                };
                paddingX: string;
            };
            text: {
                lineHeight: string;
            };
        };
    };
}>;

type SharedProps = Exclude<BoxProps, 'position' | 'width' | 'display' | 'alignItems'> & RecipeVariantProps<typeof markedTextRecipe>;
type HighlightProps = SharedProps & {
    variant?: 'highlight';
    highlightColor?: 'white' | 'gray.100' | 'brand.primary';
};
type UnderlineProps = SharedProps & {
    variant: 'underline';
    highlightColor?: never;
};
type MarkedTextProps = HighlightProps | UnderlineProps;
declare const MarkedText: FC<MarkedTextProps>;

interface TextareaProps {
    name: string;
    value?: string;
    placeholder?: string;
    disabled?: boolean;
    autoFocus?: boolean;
    autoresize?: boolean;
    onBlur?: FocusEventHandler<HTMLTextAreaElement>;
    onFocus?: FocusEventHandler<HTMLTextAreaElement>;
    onChange?: ChangeEventHandler<HTMLTextAreaElement>;
    onKeyDown?: KeyboardEventHandler<HTMLTextAreaElement>;
    rows?: number;
    cols?: number;
    textStyle?: 'body' | 'body-small';
    minHeight?: HTMLChakraProps<'textarea'>['minHeight'];
    maxHeight?: HTMLChakraProps<'textarea'>['maxHeight'];
    padding?: HTMLChakraProps<'textarea'>['padding'];
}
declare const Textarea: React__default.ForwardRefExoticComponent<TextareaProps & React__default.RefAttributes<HTMLTextAreaElement>>;

type InputVariantProps = RecipeVariantProps<typeof inputSlotRecipe>;
type TimePickerProps = Pick<InputProps$1, 'onFocus' | 'onBlur' | 'onChange'> & InputVariantProps & {
    value?: string;
    invalid?: boolean;
};
declare const TimePicker: React__default.ForwardRefExoticComponent<Pick<InputProps$1, "onChange" | "onBlur" | "onFocus"> & {
    variant?: _chakra_ui_react.ConditionalValue<"outline" | undefined>;
    size?: _chakra_ui_react.ConditionalValue<"md" | "lg" | undefined>;
} & {
    value?: string;
    invalid?: boolean;
} & React__default.RefAttributes<HTMLInputElement>>;

declare const topToaster: CreateToasterReturn;
declare const TopToast: FC;
declare const topRightToaster: CreateToasterReturn;
declare const TopRightToast: FC;

type Placement = Exclude<Exclude<TooltipRootProps['positioning'], undefined>['placement'], undefined>;
type TooltipProps = Pick<TooltipRootProps, 'children'> & {
    placement?: Placement;
    label: ReactNode;
    maxWidth?: TooltipContentProps['maxWidth'];
};
declare const Tooltip: FC<TooltipProps>;

type Props$1 = {
    aspectRatio?: number;
};
declare const TopListingBadge: FC<PropsWithChildren<Props$1>>;

type Props = {
    aspectRatio?: number;
    brand: Brand;
};
declare const TopVehicleSharedBadge: FC<PropsWithChildren<Props>>;

declare const convertRemEmToPx: (value: string) => number;

declare class Logger {
    onMissingTranslation: (error: Error) => void;
}
declare const logger: Logger;

export { Accordion, AccordionButton, AccordionItem, AccordionPanel, AddPhotoIcon, AdvancedSearchIcon, AiSearchIcon, Alert, AndroidIcon, AppLayout, AppLayoutContent, AppLayoutFooter, AppLayoutHeader, AppleIcon, ArrowCircleIcon, ArrowDiagonalIcon, ArrowDownCircleIcon, ArrowDownIcon, ArrowLeftIcon, ArrowRightIcon, ArrowUpCircleIcon, ArrowUpIcon, ArticleTeaser, AspectRatio, AutoScout24AppLogo, AutoScout24Icon, Avatar, AvatarIcon, AvatarWithNotificationIcon, Badge, BalanceIcon, BankNotesIcon, BatteryIcon, BookmarkIcon, Box, BreadcrumbLink, Breadcrumbs, BreadcrumbsItem, BulbIcon, Button, CabrioletIcon, CalculatorIcon, CalendarIcon, CallIcon, CamperIcon, CarConditionIcon, CarIcon, Root as Card, Body as CardBody, CardComponents, Footer$1 as CardFooter, Header as CardHeader, Carousel, CartIcon, CategoryAIcon, CategoryAMinusIcon, CategoryAOneIcon, Center, ChartIcon, ChatBubbleIcon, CheckShieldIcon, Checkbox, CheckboxFilter, CheckboxGroup, CheckmarkCircleColorIcon, CheckmarkCircleIcon, CheckmarkIcon, ChevronDownLargeIcon, ChevronDownSmallIcon, ChevronLeftLargeIcon, ChevronLeftSmallIcon, ChevronRightLargeIcon, ChevronRightSmallIcon, ChevronRightTinyIcon, ChevronUpLargeIcon, ChevronUpSmallIcon, ChfCurrencyIcon, Chip, CloseIcon, Collapse, CollapseIcon, ColorPicker, CompareIcon, ConsumptionIcon, CopyIcon, Count, CoupeIcon, CreditCardIcon, CreditIcon, DatePicker, DaylightIcon, DeleteIcon, DevOverlay, Dialog, DialogFilter, DigitalContractIcon, DiscreteSlider, Divider, DocumentCheckIcon, DocumentIcon, DoubleChevronDownIcon, DoubleChevronUpIcon, DoubleLineIcon, DownloadIcon, DragIcon, Drawer, DrawerBody, DrawerContent, DrawerOverlay, DriveSystemIcon, DriveSystemLargeIcon, DriveTypeIcon, EnergyLabel, EquipmentIcon, ErrorIcon, ErrorPage, ExchangeIcon, ExpandIcon, EyeCrossedIcon, EyeIcon, FacebookIcon, FilterHeading, FlagIcon, FlameIcon, FlashIcon, Flex, FocusedHeader, Footer, FormControl, FormControlSection, FormLabel, ForwardIcon, FullHeight, GalleryHeader, GarageIcon, GasStationIcon, GlobeIcon, GoogleIcon, Grid, GridItem, H1, H2, H3, H4, H5, H6, HamburgerMenuIcon, Navigation as HeaderNavigation, HeartIcon, Hide, HighlightedText, HistoryClockIcon, HouseIcon, HoverCard, ImageIcon, InfinityCircleIcon, InfoIcon, InformationBubbleIcon, InformationIcon, Input, InsertionLayout, InstagramIcon, InteriorIcon, LabelIcon, LayoutWithVehicleReference, Link, LinkIcon, LinkOverlay, LinkedinIcon, List, ListIcon, ListItem, LocationPinIcon, LockIcon, LogoutIcon, MagnifierIcon, MagnifierLargeIcon, MarkedText, Menu, MessageIcon, MessageSparkleIcon, MiniVanIcon, MinusIcon, MissingImage, MissingImageIcon, MobileOnlyAccordion, Modal, ModalCloseButton, MotoScout24AppLogo, MotoScout24Icon, MotorcycleIcon, NoPhotoIcon, NotAvailableIcon, NotAvailableSquareIcon, OpenFilterButton, OptimizerIcon, OrderedList, OverflowVerticalIcon, PageLayout, Pagination, PaginationType, ParagraphIcon, PartialClockIcon, PdfIcon, PenIcon, PhoneIcon, PickUpIcon, PlusCircleIcon, PlusIcon, Popover, PopoverFilter, PrintIcon, Progress, QualitySealIcon, Radio, RadioList, RangeFilterInput, RangeFilterInputWithSlider, RangeIcon, RangeSlider, Rating, RoadIcon, RocketIcon, RotateIcon, SafeNumberIcon, SaveSearchIcon, ScreenIcon, SearchField, SearchableList, Section, SedanIcon, Select, SelectMenu, ShareIcon, Show, SimpleGrid, SingleColumnCenteredLayout, Skeleton, SmallCarIcon, SortIcon, SparkIcon, SpeakerIcon, Spinner, SquareIcon, Stack, StarCircleIcon, StarIcon, SteeringWheelIcon, SuvIcon, SwissFlagIcon, Switch, Tab, TabList, TabPanel, TabPanels, Table, Tabs, Tbody, Td, TenantSelection, Text, Textarea, Tfoot, Th, Thead, ThreeSixtyIcon, ThumbsDownIcon, ThumbsUpIcon, TiltedRectangleIcon, TimeIcon, TimePicker, Tooltip, TooltipIcon, TopListingBadge, TopListingIcon, TopRightToast, TopToast, TopVehicleSharedBadge, Tr, TrailerIcon, TransmissionIcon, TransparentLockIcon, TrashIcon, TriangleIcon, TruckIcon, TwitterIcon, TwoColumnsLayout, UnorderedList, UploadIcon, UtilityVehicleIcon, VanIcon, VehiclePowerIcon, VehicleReference, VehicleTypesMotorcycleIcon, VehicleTypesMotorcycleStarIcon, VideoCameraIcon, VideoIcon, ViewCarIcon, ViewMotorcycleIcon, WagonIcon, WarningIcon, WarrantyIcon, WhatsAppIcon, WindowsIcon, YoutubeIcon, ZoomInIcon, ZoomOutIcon, convertRemEmToPx, logger, repeatArea, topRightToaster, topToaster, useClipboard, useDebouncedOnChange, useDisclosure, useFocusWhenVisible, useFuseSearch, useMediaQuery, useToast, useToken };
export type { AccordionButtonProps, AccordionItemProps, AccordionPanelProps, AccordionProps, AlertProps, ArticleTeaserProps, AvatarProps, BadgeProps, BaseProps, BoxAdapterProps, BreadcrumbsPropsExtended, CarouselProps, CenterProps, ChangeCallback, Item as CheckboxFilterItem, CheckboxGroupProps, CollapseProps, CountProps, DatePickerProps, DevOverlayProps, DevOverlayVariables, DialogProps, DiscreteSliderMark, DiscreteSliderProps, DismissibleProps, DrawerProps, EnergyLabelProps, FlexProps, BaseProps as FormControlSectionProps, HeadingProps, HighlightedTextProps, HoverCardProps, LinkOverlayProps, ListItemWithChildren, MarkedTextProps, MenuProps, MissingImageProps, MobileOnlyAccordionProps, NavigationProps, NonDismissibleProps, OpenFilterButtonDisplayType, OpenFilterButtonPaddingX, Option, PaginationProps, PickedNumberInputProps, ProgressProps, Props$7 as Props, RadioItemProps, RadioProps, RadioRenderFn, RangeFilterInputField, RangeSliderProps, RatingProps, SearchFieldOptions, SearchFieldProps, SectionProps, SharedProps$3 as SharedProps, SpinnerProps, TabListProps, TabPanelProps, TabPanelsProps, TenantSelectionProps, TenantSelectionState, TextareaProps, TimePickerProps, TooltipProps, VehicleReferenceProps };