import { AnimationProps } from 'framer-motion';
import { Area } from 'react-easy-crop';
import { BaseObject } from 'styled-components/dist/types';
import { ButtonHTMLAttributes } from 'react';
import { ClipboardEventHandler } from 'react';
import { Component } from 'react';
import { ComponentType } from 'react';
import { Context } from 'react';
import { CSSObject } from 'styled-components';
import { CSSProperties } from 'react';
import { default as default_2 } from 'react';
import { default as default_3 } from 'node_modules/@types/js-cookie';
import { DefaultTheme } from 'styled-components';
import { DetailedHTMLProps } from 'react';
import { DragEvent as DragEvent_2 } from 'react';
import { DragEventHandler } from 'react';
import { DraggableProps } from 'framer-motion';
import { ExecutionProps } from 'styled-components';
import { FastOmit } from 'styled-components';
import { FC } from 'react';
import { FocusEvent as FocusEvent_2 } from 'react';
import { FocusEventHandler } from 'react';
import { FocusHandlers } from 'framer-motion';
import { ForwardRefComponent } from 'framer-motion';
import { HoverHandlers } from 'framer-motion';
import { HTMLAttributes } from 'react';
import { HTMLInputAutoCompleteAttribute } from 'react';
import { HTMLInputTypeAttribute } from 'react';
import { HTMLMotionProps } from 'framer-motion';
import { ImgHTMLAttributes } from 'react';
import { InputAttributes } from 'react-number-format';
import { InputHTMLAttributes } from 'react';
import { InternalNumberFormatBase } from 'react-number-format/types/types';
import { IStyledComponentBase } from 'styled-components/dist/types';
import { JSX } from 'react/jsx-runtime';
import { KeyboardEventHandler } from 'react';
import { LayoutProps } from 'framer-motion';
import { LiHTMLAttributes } from 'react';
import { LinkComponent } from '@tanstack/react-router';
import { LinkProps } from '@tanstack/react-router';
import { MemoExoticComponent } from 'react';
import { MouseEventHandler } from 'react';
import { NamedExoticComponent } from 'react';
import { NumberFormatValues } from 'react-number-format';
import { NumericFormat } from 'react-number-format';
import { NumericFormatProps } from 'react-number-format';
import { PatternFormat } from 'react-number-format';
import { PatternFormatProps } from 'react-number-format';
import { Placement } from '@floating-ui/react';
import { PropsWithChildren } from 'react';
import { ReactElement } from 'react';
import { ReactNode } from 'react';
import { Ref } from 'react';
import { RefAttributes } from 'react';
import { RefObject } from 'react';
import { RuleSet } from 'styled-components';
import { Substitute } from 'styled-components/dist/types';
import { SVGProps } from 'react';
import { TapHandlers } from 'framer-motion';
import { TextareaHTMLAttributes } from 'react';

export declare const Accordion: FC<AccordionProps>;

export declare const AccordionDetails: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, AddDollarSign<Pick<AccordionProps, "expanded">>>> & string;

export declare type AccordionDetailsProps = AddDollarSign<Pick<AccordionProps, 'expanded'>>;

export declare interface AccordionProps {
    accordionDetails: ReactNode;
    accordionSummary: ReactNode;
    expanded: boolean;
    wrapperProps: StackProps;
    isAccordionIcon?: boolean;
    onClickIcon?: () => void;
    onClickSummary?: () => void;
    triggerUpdate?: unknown[];
}

export declare const AccordionStyledIcon: IStyledComponentBase<"web", Substitute<IconItemProps & BaseObject, AddDollarSign<Pick<AccordionProps, "expanded">>>> & string & Omit<(props: IconItemProps) => JSX.Element, keyof Component<any, {}, any>>;

export declare type AccordionStyledIconProps = AddDollarSign<Pick<AccordionProps, 'expanded'>>;

export declare const AccordionSummary: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;

export declare const AccordionSummaryContent: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, AddDollarSign<Pick<AccordionProps, "isAccordionIcon">>>> & string;

export declare type AccordionSummaryContentProps = AddDollarSign<Pick<AccordionProps, 'isAccordionIcon'>>;

export declare const AccordionWrapper: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;

export declare const addAlwaysOutline: RuleSet<    {
$isShowAlwaysOutline?: boolean;
}>;

export declare const addColorTransition: RuleSet<object>;

export declare const addDateDropdownDaySize: RuleSet<DateDropdownDayProps>;

export declare const addDateInputButtonClearSize: RuleSet<ButtonProps>;

export declare const addDateInputButtonSize: RuleSet<ButtonProps>;

/****************************************** Size *************************************************/
export declare const addDateInputWrapperSize: RuleSet<AddDollarSign<Pick<DatePickerProps, "size" | "font" | "isDisabled" | "error" | "isReadOnly" | "isDisabledOutline" | "isOutlineBoxShadow" | "genre" | "isBold"> & {
isOpen?: boolean;
isActive?: boolean;
isHaveValue?: boolean;
isShowPlaceholder?: boolean;
}>>;

export declare const addDisabled: RuleSet<    {
$isDisabled?: boolean;
}>;

export declare type AddDollarSign<T> = {
    [K in keyof T as `$${string & K}`]: T[K];
};

export declare const addError: RuleSet<AddDollarSign<addErrorProps>>;

export declare interface addErrorProps {
    error?: ErrorMessageProps;
}

export declare type addErrorStylesProps = AddDollarSign<addErrorProps>;

export declare const addFont: RuleSet<AddDollarSign<addFontProps>>;

export declare type addFontProps = {
    font?: FontSizeStylesProps;
};

export declare const addFontSizeTransition: RuleSet<    {
$isTransitionFontSize?: boolean;
}>;

export declare const addGridTransition: RuleSet<object>;

export declare type addIconProps = {
    [T in keyof DefaultTheme['icon']['map']]: Omit<IconItemProps, 'size'> & {
        type: T;
        name: DefaultTheme['icon']['map'][T][number];
        isHidden?: boolean;
        size?: IconItemProps['size'];
    };
}[keyof DefaultTheme['icon']['map']];

export declare type addIconPropsGeneric<T extends keyof DefaultTheme['icon']['map'] = keyof DefaultTheme['icon']['map']> = {
    type: T;
    name: DefaultTheme['icon']['map'][T][number];
    className?: string;
    onClick?: (event: default_2.MouseEvent<SVGSVGElement>) => void;
    size?: IThemeSize | '100%';
    color?: IThemePaletteKeys;
    turn?: number;
    order?: number;
    tabIndex?: number;
    isHidden?: boolean;
} & addSXProps;

/****************************************** is isInputEffect *************************************************/
export declare const addInputIsInputEffect: RuleSet<Pick<StyledInputProps, "$isInputEffect">>;

/****************************************** Placeholder *************************************************/
export declare const addInputPlaceholder: RuleSet<StyledInputProps>;

export declare const addInputPlaceholderNiceNumber: RuleSet<StyledInputProps>;

export declare const addNiceNumber: RuleSet<object>;

export declare const addOutline: RuleSet<AddDollarSign<addOutlineProps>>;

export declare const addOutlineChildren: RuleSet<AddDollarSign<addOutlineProps>>;

export declare type addOutlineProps = {
    isReadOnly?: boolean;
    isDisabledOutline?: boolean;
    isOutlineBoxShadow?: boolean;
};

export declare type addOutlinePropsDollar = AddDollarSign<addOutlineProps>;

export declare const addRemoveOutline: RuleSet<object>;

export declare const addRemoveScrollbar: RuleSet<object>;

export declare const addRipple: RuleSet<    {
$isRipple?: boolean;
}>;

export declare const addRippleDefault: RuleSet<object>;

export declare const addSX: RuleSet<AddDollarSign<addSXProps>>;

export declare interface addSXProps {
    sx?: SXProps;
}

export declare type addSXStyleProps = AddDollarSign<addSXProps>;

export declare const addSXTypography: RuleSet<AddDollarSign<addSXTypographyProps>>;

export declare type addSXTypographyProps = {
    sxTypography?: TypographySXProps;
};

export declare type addSXTypographyStyleProps = AddDollarSign<addSXTypographyProps>;

export declare const addTextArea: RuleSet<AddDollarSign<Pick<TextAreaProps, "size" | "font" | "isDisabled" | "error" | "genre" | "isLoading" | "isBold" | "isResize" | "isInputEffect"> & {
lineHeight: number;
}>>;

export declare const addTooltipBoxSize: RuleSet<PopoverProps>;

export declare const addTooltipBoxSizeConstructor: (props: IThemeSizePropertyDefault) => RuleSet<object>;

export declare const addTransition: RuleSet<object>;

export declare const addTransitionWithoutSize: RuleSet<object>;

export declare const AppContext: Context<AppContextProps | null>;

export declare interface AppContextProps {
    changePreview: (newPreviewProps: PreviewAdditionalProps) => void;
    changeStatusBarColor: (color: IThemePaletteKeys) => void;
    changeBgColor: (color: IThemePaletteKeys) => void;
    changeBgImage: (image: string) => void;
    changeTitle: (title: string) => void;
    changeDescription: (description: string) => void;
    setDefaultStatusBarColor: () => void;
    setDefaultBgColor: () => void;
    setDefaultBgImage: () => void;
    setDefaultTitle: () => void;
    setDefaultDescription: () => void;
    historyStatusBarColor: (step: number) => void;
    historyBgColor: (step: number) => void;
    setHistoryTitle: (step: number) => void;
    historyBgImage: (step: number) => void;
    historyDescription: (step: number) => void;
}

declare type AutoHeightTextAreaProps = BaseTextAreaProps & {
    isAutoHeight: true;
    maxRows: number;
    isResize?: false | undefined;
};

declare type BaseInputProps = CommonInputProps & (ControlledValue | UncontrolledValue);

declare type BaseTextAreaProps = CommonTextAreaProps & (ControlledValue_3 | UncontrolledValue_3);

export declare function BlurIn({ children }: {
    children: ReactNode;
}): JSX.Element;

export declare const Button: FC<ButtonProps>;

export declare const ButtonGroup: FC<ButtonGroupProps>;

export declare type ButtonGroupProps = {
    value: ButtonProps[];
    className?: string;
    position: 'horizontal' | 'vertical';
} & addSXProps;

export declare const ButtonGroupWrapper: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, StyledButtonGroupProps>> & string;

export declare const ButtonList: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, AddDollarSign<Pick<SelectProps<ISelectItem>, "size">>>> & string;

export declare type ButtonListProps = AddDollarSign<Pick<SelectProps<ISelectItem>, 'size'>>;

export declare type ButtonProps = ButtonPropsStandard | ButtonPropsIconGroup;

declare type ButtonPropsDefault = PropsWithChildren & {
    size: IThemeSize;
    genre: TButtonGenre;
    id?: string;
    tabIndex?: number;
    ref?: Ref<HTMLElement | null>;
    className?: string;
    icons?: addIconProps[];
    isDisabled?: boolean;
    isDisabledRipple?: boolean;
    isHidden?: boolean;
    isOnlyIcon?: boolean;
    isWhileTapEffect?: boolean;
    isWidthAsHeight?: boolean;
    isMinWidthAsContent?: boolean;
    isRadius?: boolean;
    isHiddenBorder?: boolean;
    isPlaystationEffect?: boolean;
    isNotHoverEffect?: boolean;
    isFullSize?: boolean;
    onFocus?: (event: default_2.FocusEvent<HTMLButtonElement, Element>) => void;
    onClick?: (event: default_2.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
    onMouseDown?: (event: default_2.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
    type?: 'button' | 'submit' | 'reset';
} & addSXProps & addFontProps & addOutlineProps & addSXTypographyProps;

export declare type ButtonPropsIconGroup = ButtonPropsDefault & {
    isIconGroup?: true;
    iconGroupOrder?: number;
};

export declare type ButtonPropsStandard = ButtonPropsDefault & {
    isIconGroup?: false;
};

export declare const Checkbox: FC<CheckboxProps>;

export declare const CheckboxChildren: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;

/****************************************** Genre *************************************************/
export declare const CheckboxGenre: RuleSet<StyledCheckboxProps>;

export declare const CheckboxGroup: <T extends ICheckboxValue>(props: CheckboxGroupProps<T>) => JSX.Element;

export declare const CheckboxGroupItem: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;

export declare const CheckboxGroupLabel: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;

export declare type CheckboxGroupProps<T extends ICheckboxValue> = {
    checkboxGenre: CheckboxProps['genre'];
    checkBoxView: CheckboxProps['view'];
    checkboxSX?: CheckboxProps['sx'];
    checkboxIsHiddenBorder?: CheckboxProps['isHiddenBorder'];
    className?: string;
    childrenField?: keyof T;
    isClickOnlyIcon?: boolean;
    size: CheckboxProps['size'];
    labelField?: keyof T;
    multiple?: boolean;
    onChange?: (props: T[]) => void;
    options: T[];
    value: T[];
    valueField: keyof T;
} & addSXProps & addFontProps;

/****************************************** Size *************************************************/
export declare const CheckboxGroupSize: RuleSet<CheckboxGroupWrapperProps>;

export declare const CheckboxGroupSizeConstructor: (props: IThemeSizePropertyDefault) => RuleSet<object>;

/****************************************** Default *************************************************/
export declare const CheckboxGroupWrapper: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, CheckboxGroupWrapperProps>> & string;

export declare type CheckboxGroupWrapperProps = AddDollarSign<Pick<CheckboxGroupProps<ICheckboxValue>, 'size' | 'font'>> & addSXStyleProps;

export declare type CheckboxProps = PropsWithChildren & {
    checked?: boolean;
    genre: TCheckboxGenre;
    view: {
        true: addIconProps;
        false: addIconProps;
    };
    isDisabled?: boolean;
    isOnlyLoading?: boolean;
    isLoading?: boolean;
    isHiddenBorder?: boolean;
    isNotBackground?: boolean;
    onChange?: (checked: boolean) => void;
    isWidthAsHeight?: boolean;
    size: IThemeSize;
} & addSXProps & addErrorProps & addSXTypographyProps & addOutlineProps & addFontProps;

/****************************************** Size *************************************************/
export declare const CheckboxSize: RuleSet<StyledCheckboxProps>;

export declare const CheckboxSizeConstructor: (props: IThemeSizePropertyDefault & {
    isWidthAsHeight?: boolean;
}) => RuleSet<object>;

/****************************************** Default *************************************************/
export declare const CheckboxWrapper: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, StyledCheckboxProps>> & string;

export declare type CommonDatePickerProps = addErrorProps & addSXProps & addFontProps & addOutlineProps & {
    genre: TDateGenre;
    id?: string;
    isDisabled?: boolean;
    isBold?: boolean;
    isMinWidth?: boolean;
    isShowClearButton?: boolean;
    isInputEffect?: InputStandardProps['isInputEffect'];
    isOnClickClose?: boolean;
    labelPlaceholder?: string;
    locale: {
        months: SelectMonthProps['monthsLocale'];
        weeks: WeekItem[];
        inputs: InputItem;
    };
    notValidDate?: Omit<ErrorMessageProps, 'size' | 'isError'>;
    mode?: DatePickerMode;
    type?: DatePickerType;
    name?: string;
    ariaLabel?: string;
    autoComplete?: HTMLInputAutoCompleteAttribute | string;
    onBlur?: () => void;
    onChange: (timestamp: number | null) => void;
    onFocus?: () => void;
    size: IThemeSize;
    dateMax?: number;
    dateMin?: number;
    dateDefault: number;
};

declare type CommonInputProps = addErrorProps & addFontProps & addOutlineProps & addSXProps & {
    ref?: Ref<HTMLInputElement | null>;
    name?: string;
    ariaLabel?: string;
    id?: string;
    className?: string;
    isNotShowHoverStyle?: boolean;
    autoComplete?: HTMLInputAutoCompleteAttribute | string;
    isAllowEmptyFormatting?: boolean;
    genre: TInputGenre;
    size: IThemeSize;
    tabIndex?: number;
    isWidthAsHeight?: boolean;
    isNiceNumber?: boolean;
    isDisabled?: boolean;
    isLoading?: boolean;
    isInputEffect?: boolean;
    isRequired?: boolean;
    isCenter?: boolean;
    isNoSpaces?: boolean;
    onBlur?: FocusEventHandler<HTMLInputElement>;
    onPaste?: ClipboardEventHandler<HTMLInputElement>;
    onFocus?: FocusEventHandler<HTMLInputElement>;
    onKeyDown?: KeyboardEventHandler<HTMLInputElement>;
    placeholder?: string;
    isBold?: boolean;
    postfixChildren?: InputChildrenProps;
    prefixChildren?: InputChildrenProps;
    inputMode?: 'text' | 'none' | 'tel' | 'url' | 'email' | 'numeric' | 'decimal' | 'search';
    maxLength?: number;
    minLength?: number;
};

declare type CommonTextAreaProps = addErrorProps & addFontProps & addSXProps & {
    name?: string;
    ariaLabel?: string;
    autoComplete?: HTMLInputAutoCompleteAttribute | string;
    id?: string;
    ref?: RefObject<HTMLTextAreaElement | null>;
    className?: string;
    genre: TextAreaGenre;
    minRows: number;
    size: IThemeSize;
    placeholder?: string;
    maxLength?: number;
    minLength?: number;
    isDisabled?: boolean;
    isDisabledOutline?: boolean;
    isOutlineBoxShadow?: boolean;
    isResize?: boolean;
    isLoading?: boolean;
    isReadOnly?: boolean;
    isInputEffect?: boolean;
    isRequired?: boolean;
    isNoSpaces?: boolean;
    isBold?: boolean;
    onFocus?: (event?: FocusEvent_2<HTMLTextAreaElement>) => void;
    onBlur?: (event?: FocusEvent_2<HTMLTextAreaElement>) => void;
    onChange?: (value: string) => void;
    onClick?: MouseEventHandler<HTMLTextAreaElement>;
    onMouseDown?: MouseEventHandler<HTMLTextAreaElement>;
    onKeyDown?: KeyboardEventHandler<HTMLTextAreaElement>;
};

export declare const ContainerDropdownListOption: MemoExoticComponent<(<T extends object & ISelectItem>(props: ContainerDropdownListOptionProps<T>) => JSX.Element)>;

export declare type ContainerDropdownListOptionProps<T extends ISelectItem> = Pick<SelectProps<T>, 'genre' | 'size' | 'isCenter' | 'isNotShowHoverStyle' | 'isBold' | 'isShowDropdownOptionIcon' | 'font'> & {
    item: T;
    isChecked?: boolean;
    isShowScroll?: boolean;
    onClick: () => void;
    virtualRowSize: number;
    virtualRowStart: number;
};

export declare const ContainerSelectListOption: MemoExoticComponent<(<T extends object & ISelectItem>(props: ContainerSelectListOptionProps<T>) => JSX.Element)>;

export declare type ContainerSelectListOptionProps<T extends ISelectItem> = Pick<SelectProps<T>, 'genre' | 'size' | 'isCenter' | 'isNotShowHoverStyle' | 'isBold' | 'isWrapSelectOption' | 'isClearWhenClickSelectListOption' | 'isOnlyColorInSelectListOption'> & {
    item: T;
    isChecked?: boolean;
    onClick: () => void;
};

declare type ControlledValue = {
    value: string | number | null | undefined;
    defaultValue?: never;
};

declare type ControlledValue_2 = {
    value: number | null | undefined;
    defaultValue?: never;
};

declare type ControlledValue_3 = {
    value: string | null | undefined;
    defaultValue?: never;
};

export declare type CookieAttributes = default_3.CookieAttributes;

/**
 * Context for managing cookies.
 */
export declare const CookieContext: Context<CookieContextProps | null>;

export declare interface CookieContextProps {
    getCookie: <K extends keyof ValidCookieObject>(name: K) => ValidCookieObject[K] | undefined;
    setCookie: <K extends keyof ValidCookieObject>(name: K, value: ValidCookieObject[K], options?: CookieAttributes) => void;
    removeCookieValue: <K extends keyof ValidCookieObject>(name: K, options?: CookieAttributes) => void;
    removeCookieValues: () => void;
    checkCookie: () => void;
    cookieValues: ValidCookieObject | undefined;
}

export declare interface DateDayProps {
    dayOfWeek: number;
    isCurrentMonth: boolean;
    isDisabled: boolean;
    isToday: boolean;
    isWeekend: boolean;
    labelNumber: number;
    labelString: string;
    value: number;
    weekOfMonth: number;
}

export declare const DateDropdownDay: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, DateDropdownDayProps>> & string;

export declare const DateDropdownDayOfWeek: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, DateDropdownDayProps>> & string;

export declare type DateDropdownDayProps = AddDollarSign<Pick<DatePickerProps, 'genre' | 'size' | 'font'> & Pick<DateDayProps, 'isToday' | 'isWeekend'> & {
    row: number;
    column: number;
    isChoice?: boolean;
    isCurrentMonth?: boolean;
    isDisabled?: boolean;
}> & addOutlinePropsDollar;

export declare const DateDropdownDays: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
$rows: number;
}>> & string;

export declare const DateDropdownList: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, AddDollarSign<Pick<DatePickerProps, "isInputEffect"> & Pick<DatePickerProps, "size" | "genre">>>> & string;

export declare const DateDropdownListParent: IStyledComponentBase<"web", Substitute<Omit<HTMLMotionProps<"div">, "ref"> & RefAttributes<HTMLDivElement>, AddDollarSign<Pick<InputStandardProps, "size" | "genre">>>> & string & Omit<ForwardRefComponent<HTMLDivElement, HTMLMotionProps<"div">>, keyof Component<any, {}, any>>;

export declare type DateDropdownListProps = AddDollarSign<Pick<DatePickerProps, 'isInputEffect'> & Pick<DatePickerProps, 'genre' | 'size'>>;

export declare const DateInput: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, AddDollarSign<Pick<DatePickerProps, "size" | "font" | "isDisabled" | "error" | "isReadOnly" | "isDisabledOutline" | "isOutlineBoxShadow" | "genre" | "isBold"> & {
isOpen?: boolean;
isActive?: boolean;
isHaveValue?: boolean;
isShowPlaceholder?: boolean;
}>>> & string;

export declare const DateInputButton: IStyledComponentBase<"web", Substitute<ButtonProps & BaseObject, BaseObject>> & string & Omit<FC<ButtonProps>, keyof Component<any, {}, any>>;

export declare const DateInputButtonClear: IStyledComponentBase<"web", Substitute<ButtonProps & BaseObject, BaseObject>> & string & Omit<FC<ButtonProps>, keyof Component<any, {}, any>>;

export declare type DateInputProps = AddDollarSign<Pick<DatePickerProps, 'error' | 'genre' | 'size' | 'isBold' | 'isReadOnly' | 'isDisabledOutline' | 'isOutlineBoxShadow' | 'isDisabled' | 'font'> & {
    isOpen?: boolean;
    isActive?: boolean;
    isHaveValue?: boolean;
    isShowPlaceholder?: boolean;
}>;

export declare const DateInputWrapper: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, AddDollarSign<Pick<DatePickerProps, "size" | "font" | "isDisabled" | "error" | "isReadOnly" | "isDisabledOutline" | "isOutlineBoxShadow" | "genre" | "isBold"> & {
isOpen?: boolean;
isActive?: boolean;
isHaveValue?: boolean;
isShowPlaceholder?: boolean;
}>>> & string;

export declare const DatePicker: (props: DatePickerProps) => JSX.Element;

export declare type DatePickerMode = DatePickerVariant[];

export declare type DatePickerProps = CommonDatePickerProps & (ControlledValue_2 | UncontrolledValue_2);

export declare type DatePickerType = 'manual' | 'select' | 'manualAndSelect';

export declare enum DatePickerVariant {
    DD = "DD",
    MM = "MM",
    YYYY = "YYYY"
}

export declare type DateStyledListProps = AddDollarSign<Pick<InputStandardProps, 'genre' | 'size'>>;

export declare type DateStyledOptionProps = AddDollarSign<{
    isSelectedItem?: boolean;
    isCheckboxProps?: boolean;
}> & StyledInputProps;

export declare const DateWrapper: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, DateWrapperProps>> & string;

export declare type DateWrapperProps = AddDollarSign<Pick<InputStandardProps, 'genre' | 'isDisabled'> & {
    parentListHeight: number;
    radius: number;
    isMinWidth?: boolean;
}> & StyledInputWrapperProps;

export declare const DEFAULT_COMPONENT_PAGINATION_GAP = 12;

export declare const DEFAULT_PROVIDER_DIALOG_DURATION_ELEMENT = 0.3;

export declare const DEFAULT_PROVIDER_DIALOG_DURATION_LAYOUT = 0.4;

export declare const DEFAULT_PROVIDER_DIALOG_ELEMENT_BACKGROUND: IThemePaletteKeys;

export declare const DEFAULT_PROVIDER_DIALOG_ELEMENT_BORDER_RADIUS: string;

export declare const DEFAULT_PROVIDER_DIALOG_ELEMENT_MAX_HEIGHT: string;

export declare const DEFAULT_PROVIDER_DIALOG_ELEMENT_MAX_WIDTH: string;

export declare const DEFAULT_PROVIDER_DIALOG_ELEMENT_PADDING: string;

export declare const DEFAULT_PROVIDER_SONNER_BUTTON: ProviderSonnerProps['default']['button'];

export declare const DEFAULT_PROVIDER_SONNER_DURATION = 0.3;

export declare const DEFAULT_PROVIDER_SONNER_GENRE: keyof ITheme['colors']['sonner'];

export declare const DEFAULT_PROVIDER_SONNER_MARGIN_BOTTOM = 60;

export declare const DEFAULT_PROVIDER_SONNER_SCALE = 0.04;

export declare const DEFAULT_PROVIDER_SONNER_Y = 100;

export declare const DEFAULT_PROVIDER_SONNER_Z_INDEX = 100;

export declare const DEFAULT_RIPPLE_DURATION = 600;

export declare const DEFAULT_RIPPLE_ID = "JENESEI_RIPPLE";

export declare const DEFAULT_TOOLTIP_OFFSET_FALLBACK: number;

export declare const DEFAULT_TOOLTIP_PLACEMENT_FALLBACK: Placement;

declare type DefaultScrollProps = {
    vertical?: boolean;
    horizontal?: boolean;
    isAlwaysVertical?: boolean;
    isAlwaysHorizontal?: boolean;
};

export declare const DialogContent: IStyledComponentBase<"web", FastOmit<Omit<HTMLMotionProps<"div">, "ref"> & RefAttributes<HTMLDivElement>, never>> & string & Omit<ForwardRefComponent<HTMLDivElement, HTMLMotionProps<"div">>, keyof Component<any, {}, any>>;

declare type DialogContentObjectPropsContent<T extends object> = (remove?: () => void, isAnimating?: boolean, propsCustom?: T) => ReactNode;

declare type DialogContentObjectPropsDialog = {
    maxWidth?: string;
    maxHeight?: string;
    padding?: string;
    borderRadius?: string;
    background?: IThemePaletteKeys;
    isRemoveOnOutsideClick?: boolean;
};

export declare type DialogContentProps<T extends object = any> = {
    props?: useDialogProps<T>;
    id?: string;
    index?: number;
    onRemove?: () => void;
};

export declare const DialogContext: Context<DialogContextProps | null>;

export declare type DialogContextItemProps = {
    add: () => void;
    remove: () => void;
    id: string | null;
};

export declare type DialogContextProps<T extends object = any> = {
    add: (dialog: DialogContentProps<T>) => void;
    remove: (id: DialogContentProps<T>['id']) => void;
    update: (dialog: DialogContentProps<T>) => void;
    dialogHistory: DialogContentProps<T>[];
};

export declare type DialogElementProps<T extends object> = DialogContentProps<T>;

export declare const DialogElementWrapper: IStyledComponentBase<"web", Substitute<Omit<HTMLMotionProps<"dialog">, "ref"> & RefAttributes<HTMLDialogElement>, AddDollarSign<addOutlineProps & Pick<useDialogProps<object>, "propsDialog">>>> & string & Omit<ForwardRefComponent<HTMLDialogElement, HTMLMotionProps<"dialog">>, keyof Component<any, {}, any>>;

export declare type DialogElementWrapperProps<T extends object> = AddDollarSign<addOutlineProps & Pick<useDialogProps<T>, 'propsDialog'>>;

export declare const DialogLayout: IStyledComponentBase<"web", Substitute<Omit<HTMLMotionProps<"div">, "ref"> & RefAttributes<HTMLDivElement>, AddDollarSign<Pick<ProviderDialogProps, "zIndex">>>> & string & Omit<ForwardRefComponent<HTMLDivElement, HTMLMotionProps<"div">>, keyof Component<any, {}, any>>;

export declare type DialogLayoutProps = AddDollarSign<Pick<ProviderDialogProps, 'zIndex'>>;

export declare const DropdownList: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<HTMLAttributes<HTMLUListElement>, HTMLUListElement>, never>> & string;

export declare const DropdownListOption: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, AddDollarSign<Pick<SelectProps<ISelectItem>, "size" | "font" | "genre" | "isCenter" | "isNotShowHoverStyle" | "isBold"> & {
item?: ISelectItem;
isChecked?: boolean;
isShowScroll?: boolean;
}>>> & string;

export declare const DropdownListOptionIcon: IStyledComponentBase<"web", Substitute<IconItemProps & BaseObject, AddDollarSign<Pick<SelectProps<ISelectItem>, "size" | "genre"> & {
checked?: boolean;
}>>> & string & Omit<(props: IconItemProps) => JSX.Element, keyof Component<any, {}, any>>;

export declare type DropdownListOptionIconProps = AddDollarSign<Pick<SelectProps<ISelectItem>, 'genre' | 'size'> & {
    checked?: boolean;
}>;

export declare type DropdownListOptionProps = AddDollarSign<Pick<SelectProps<ISelectItem>, 'genre' | 'size' | 'isCenter' | 'isNotShowHoverStyle' | 'isBold' | 'font'> & {
    item?: ISelectItem;
    isChecked?: boolean;
    isShowScroll?: boolean;
}>;

export declare const DropdownListParent: IStyledComponentBase<"web", Substitute<Omit<HTMLMotionProps<"div">, "ref"> & RefAttributes<HTMLDivElement>, AddDollarSign<Pick<SelectProps<ISelectItem>, "size">>>> & string & Omit<ForwardRefComponent<HTMLDivElement, HTMLMotionProps<"div">>, keyof Component<any, {}, any>>;

export declare type DropdownListParentProps = AddDollarSign<Pick<SelectProps<ISelectItem>, 'size'>>;

declare type EnumOption = {
    value: string;
    label: string;
    placeholder: string;
    search: string;
};

export declare const ErrorMessage: FC<ErrorMessageProps>;

export declare const ErrorMessageComponent: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, AddDollarSign<ErrorMessageProps>>> & string;

export declare type ErrorMessageProps = {
    errorMessage?: string;
    isError?: boolean;
    isErrorAbsolute?: boolean;
    size?: IThemeSize;
    sx?: addSXProps['sx'];
} & addFontProps;

export declare type ErrorMessagePropsDollar = AddDollarSign<ErrorMessageProps>;

declare type FixedTextAreaProps = BaseTextAreaProps & {
    isResize?: false | undefined;
    isAutoHeight?: false | undefined;
    maxRows?: never;
};

export declare type FontSizeStylesProps = {
    size?: TypographyDataProps['size'];
    weight?: TypographyDataProps['weight'];
    family?: TypographyDataProps['family'];
    height?: TypographyDataProps['height'];
};

export declare function formatPhoneNumber(dialCode: string, international: string): {
    format: string;
    placeholder: string;
};

declare type GenericObject<T> = {
    [key: string]: T;
};

export declare const GeolocationContext: Context<GeolocationContextProps | null>;

export declare interface GeolocationContextProps {
    geolocationPermission: PermissionState | null;
    requestGeolocationPermission: () => void;
    location: GeolocationPosition | null;
    error: GeolocationPositionError | null;
}

export declare function getContrastYIQ(hexcolor: string): "#000000" | "#FFFFFF";

export declare const getFontSizeStyles: (size: TypographyDataProps["size"], weight: TypographyDataProps["weight"], family: TypographyDataProps["family"], height?: TypographyDataProps["height"]) => RuleSet<object>;

export declare function getFromCookie<T>(key: string): T | null;

export declare function getFromLocalStorage<T>(key: string): T | null;

export declare function getIconComponents(props: getIconComponentsProps): JSX.Element[];

export declare type getIconComponentsProps = {
    size: IThemeSize;
    icons?: addIconProps[];
};

export declare function getScrollbarWidth(): number;

export declare function GradualSpacing({ text }: {
    text: string;
}): JSX.Element;

export declare interface ICheckboxValue {
    label: string | number;
    value: string | number;
}

export declare const Icon: (props: IconItemProps) => JSX.Element;

export declare type IconItemProps = {
    [K in keyof DefaultTheme['icon']['map']]: {
        type: K;
        name: DefaultTheme['icon']['map'][K][number];
        className?: string;
        onClick?: (event: default_2.MouseEvent<SVGSVGElement>) => void;
        size: IThemeSize | '100%';
        color?: IThemePaletteKeys;
        turn?: number;
        order?: number;
        tabIndex?: number;
    } & addSXProps;
}[keyof DefaultTheme['icon']['map']];

export declare type IImageFormat = (typeof LIST_IMAGE_SUPPORTED_FORMAT)[number];

export declare type ILanguage = Record<ILanguageKeys, {
    value: ILanguageKeys;
    label: string;
    placeholder: string;
    search: string;
}>;

export declare type ILanguageKeys = 'eng' | 'rus';

declare const Image_2: FC<ImageProps>;
export { Image_2 as Image }

export declare const ImageButton: FC<ImageButtonProps>;

export declare interface ImageButtonProps extends addSXProps {
    button: ButtonProps;
    dialog: {
        button: ButtonProps;
        buttonDelete: ButtonProps;
    };
    imageSettings: {
        maxSize: number;
        maxCount: number;
        aspect?: number;
    };
    locale: {
        buttonAdd: string;
        dialogSave: string;
        dialogCancel: string;
        dialogAddImage: string;
        dialogDeleteImage: string;
    };
    onSave: (files: ImageSelectItemProps[] | null) => void;
}

export declare const ImageIMG: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, ImageIMGProps>> & string;

export declare type ImageIMGProps = {
    $isPending: boolean;
} & addSXStyleProps;

export declare interface ImageProps {
    alt: string;
    componentFallback?: ReactNode;
    componentLoading?: ReactNode;
    isShowBeforeImage?: boolean;
    src?: string;
    sxImage?: addSXProps['sx'];
    sxStack?: addSXProps['sx'];
}

export declare const IMAGES: ImageSliderProps['images'];

export declare const ImageSelect: (props: ImageSelectProps) => JSX.Element;

export declare type ImageSelectItemProps = {
    crop?: {
        x: number;
        y: number;
    };
    croppedArea?: Area | null;
    file?: File;
    format?: string;
    id: number;
    index: number;
    isCropped?: boolean;
    isDeleted?: boolean;
    isNew?: boolean;
    name?: string;
    url?: string;
    zoom?: number;
};

/****************************************** Size *************************************************/
export declare const ImageSelectListSize: RuleSet<AddDollarSign<Pick<ImageSelectProps, "size" | "sx" | "error" | "genre">>>;

export declare const ImageSelectListSizeConstructor: (props: IThemeSizePropertyDefault) => RuleSet<object>;

export declare const ImageSelectListWrapper: IStyledComponentBase<"web", Substitute<Omit<HTMLMotionProps<"div">, "ref"> & RefAttributes<HTMLDivElement>, AddDollarSign<Pick<ImageSelectProps, "size" | "sx" | "error" | "genre">>>> & string & Omit<ForwardRefComponent<HTMLDivElement, HTMLMotionProps<"div">>, keyof Component<any, {}, any>>;

export declare type ImageSelectProps = {
    locale: {
        imageFallback: string;
        buttonReset: string;
        dragAndDrop: string;
    } & ImageButtonProps['locale'];
    genre: TImageSelectGenre;
    size: IThemeSize;
    propsButton: {
        default: Pick<ButtonProps, 'size' | 'genre'>;
        delete: Pick<ButtonProps, 'size' | 'genre'>;
    };
    id?: string;
    onChange?: (images: ImageSelectItemProps[]) => void;
    isContain?: boolean;
    imageSettings: {
        maxSize: number;
        maxCount: number;
        width: number;
        height: number;
        aspect: number;
    };
    defaultImages: ImageSelectItemProps[];
    images: ImageSelectItemProps[];
} & addErrorProps & addSXProps;

export declare const ImageSelectSize: RuleSet<AddDollarSign<Pick<ImageSelectProps, "size" | "sx" | "error" | "genre">>>;

export declare const ImageSelectSizeConstructor: (props: IThemeSizePropertyDefault) => RuleSet<object>;

export declare const ImageSelectWrapper: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, AddDollarSign<Pick<ImageSelectProps, "size" | "sx" | "error" | "genre">>>> & string;

export declare type ImageSelectWrapperProps = AddDollarSign<Pick<ImageSelectProps, 'sx' | 'error' | 'genre' | 'size'>>;

export declare const ImageSlider: FC<ImageSliderProps>;

export declare type ImageSliderProps = {
    genre: TImageSelectGenre;
    size: IThemeSize;
    imageSettings: {
        aspect: number;
    };
    images: {
        id: number;
        imageSrc: string;
        children?: ReactNode;
    }[];
    children?: (props: {
        isDialog: boolean;
    }) => ReactNode | ReactNode;
    onIndexChange?: (index: number) => void;
    propsStack?: StackProps;
    isLoading?: boolean;
    locales: {
        noImagesAvailable: string;
    } & useImageSliderProps['locales'];
};

export declare const Input: (props: InputProps) => JSX.Element;

export declare interface InputChildrenProps extends PropsWithChildren {
    left: string;
    right: string;
    width: string;
}

export declare type InputItem = {
    day: string;
    month: string;
    year: string;
};

export declare type InputNumericProps = BaseInputProps & {
    variety: 'numeric';
    onChange?: (value: NumberFormatValues) => void;
    propsNumeric: Pick<NumericFormatProps, 'allowLeadingZeros' | 'thousandSeparator' | 'allowNegative' | 'allowedDecimalSeparators' | 'decimalScale' | 'decimalSeparator' | 'fixedDecimalScale' | 'prefix' | 'thousandsGroupStyle' | 'isAllowed' | 'suffix'>;
};

export declare const InputOTP: (props: InputOTPProps) => JSX.Element;

export declare type InputOTPProps = {
    length: number;
    onComplete?: (otp: string) => void;
    onFocus?: (event?: FocusEvent_2<HTMLElement>) => void;
    onBlur?: (event?: FocusEvent_2<HTMLElement>) => void;
} & Pick<InputStandardProps, 'size' | 'genre' | 'id' | 'sx' | 'error' | 'onChange' | 'font'>;

/****************************************** Size *************************************************/
export declare const InputOTPSize: RuleSet<AddDollarSign<Pick<InputOTPProps, "size" | "sx" | "error">>>;

export declare const InputOTPSizeConstructor: (props: IThemeSizePropertyDefault & InputOTPWrapperProps) => RuleSet<object>;

export declare const InputOTPWrapper: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, AddDollarSign<Pick<InputOTPProps, "size" | "sx" | "error">>>> & string;

export declare type InputOTPWrapperProps = AddDollarSign<Pick<InputOTPProps, 'size' | 'sx' | 'error'>>;

export declare type InputPatternProps = BaseInputProps & {
    variety: 'pattern';
    onChange?: (value: NumberFormatValues) => void;
    propsPattern: Pick<PatternFormatProps, 'format' | 'mask' | 'allowEmptyFormatting' | 'patternChar' | 'valueIsNumericString' | 'type'>;
};

export declare const InputPostfixChildren: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, AddDollarSign<Pick<InputProps, "isDisabled"> & Pick<InputChildrenProps, "left" | "right" | "width">>>> & string;

/****************************************** Children *************************************************/
export declare const InputPrefixChildren: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, AddDollarSign<Pick<InputProps, "isDisabled"> & Pick<InputChildrenProps, "left" | "right" | "width">>>> & string;

export declare type InputProps = InputStandardProps | InputPatternProps | InputNumericProps;

/****************************************** Size *************************************************/
export declare const InputSize: RuleSet<StyledInputProps>;

export declare const InputSizeConstructor: (props: IThemeSizePropertyDefault) => RuleSet<object>;

export declare type InputStandardProps = BaseInputProps & {
    variety: 'standard';
    onChange?: (value: string) => void;
    type?: HTMLInputTypeAttribute;
    min?: number;
    max?: number;
    step?: number;
};

export declare interface ISelectItem {
    [key: string]: unknown;
    isDisabled?: boolean;
    isLoading?: boolean;
    label: string | number | ReactNode;
    value: string | number;
}

export declare interface ISelectLanguageOption extends ISelectItem {
    placeholder: string;
    search?: string;
}

export declare type IService = Record<IServiceKeys, {
    value: IServiceKeys;
    label: string;
    placeholder: string;
    search: string;
}>;

export declare type IServiceKeys = 'jenesei_id';

export declare interface ITheme {
    icon: {
        map: {
            id: typeof ThemeMapId;
            checkbox: typeof ThemeMapCheckbox;
            loading: typeof ThemeMapLoading;
            realebail: typeof ThemeMapRealebail;
            logo: typeof ThemeMapLogo;
            bustmarket: typeof ThemeMapBustmarket;
        };
        getIconId: <T extends keyof ITheme['icon']['map']>(props: {
            type: T;
            name: ITheme['icon']['map'][T][number];
        }) => string;
        getSpriteUrl: (props: {
            type: keyof ITheme['icon']['map'];
        }) => string;
    };
    states: {
        focus: string;
        danger: string;
    };
    colors: {
        range: IThemeGenreRange;
        date: IThemeGenreDate;
        button: IThemeGenre;
        toggle: IThemeGenreToggle;
        checkbox: IThemeGenre;
        input: IThemeGenreInput;
        imageSelect: IThemeGenreImageSelect;
        select: IThemeGenreSelect;
        sonner: IThemeGenreSonner;
    };
    effects: {
        input: string;
        button: string;
    };
    font: {
        family: IThemeFontFamily;
        weight: IThemeTypographyWeight;
        sizeDefault: Record<IThemeDevice, number>;
        sizeHeading: Record<IThemeTypographyHeading, number>;
        lineHeight: number;
    };
    palette: Record<IThemePaletteKeys, string>;
    background: Record<IThemePaletteKeys, string>;
    screens: IThemeScreen;
    scrollbar: {
        width: number;
        background: string;
        thumb: string;
        thumbBorder: string;
    };
    transition: {
        duration: string;
        timingFunction: string;
        default: string;
        icon: string;
    };
    getContrastYIQ: (hexcolor: string) => string;
}

export declare type IThemeDevice = 'default' | 'tablet' | 'mobile';

export declare type IThemeFontFamily = 'Inter' | 'Roboto' | 'Work Sans' | 'Roboto Mono' | 'Manrope';

export declare type IThemeGenre = Record<Extract<IThemeGenreName, 'gray' | 'grayBorder' | 'black' | 'blackBorder' | 'product' | 'productBorder' | 'white' | 'greenTransparent' | 'redTransparent' | 'yellowTransparent' | 'realebail-product' | 'realebail-gray' | 'realebail-white' | 'bustmarket-gray' | 'bustmarket-gray-violet' | 'bustmarket-violet' | 'bustmarket-white-violet'>, IThemeGenreTypeDefault>;

export declare type IThemeGenreDate = Record<Extract<IThemeGenreName, 'gray' | 'grayBorder' | 'blackBorder' | 'realebail-white'>, IThemeGenreTypeDate>;

export declare type IThemeGenreImageSelect = Record<Extract<IThemeGenreName, 'gray' | 'grayBorder' | 'blackBorder' | 'realebail-white'>, IThemeGenreTypeImageSelect>;

export declare type IThemeGenreInput = Record<Extract<IThemeGenreName, 'gray' | 'grayBorder' | 'blackBorder' | 'realebail-white' | 'bustmarket-gray'>, IThemeGenreTypeDefault>;

export declare type IThemeGenreName = 'gray' | 'grayBorder' | 'black' | 'blackBorder' | 'product' | 'productBorder' | 'white' | 'greenTransparent' | 'redTransparent' | 'yellowTransparent' | 'realebail-product' | 'realebail-gray' | 'realebail-white' | 'bustmarket-gray-violet' | 'bustmarket-gray' | 'bustmarket-violet' | 'bustmarket-white-violet';

export declare type IThemeGenreRange = Record<Extract<IThemeGenreName, 'gray' | 'grayBorder' | 'blackBorder' | 'realebail-white' | 'bustmarket-gray'>, IThemeGenreTypeRange>;

export declare type IThemeGenreSelect = Record<Extract<IThemeGenreName, 'gray' | 'grayBorder' | 'blackBorder' | 'realebail-white'>, IThemeGenreTypeSelect>;

export declare type IThemeGenreSonner = Record<Extract<IThemeGenreName, 'black' | 'greenTransparent' | 'redTransparent' | 'yellowTransparent'>, IThemeGenreTypeSonner>;

export declare type IThemeGenreTextArea = Record<Extract<IThemeGenreName, 'gray' | 'grayBorder' | 'blackBorder' | 'realebail-white'>, IThemeGenreTypeDefault>;

export declare type IThemeGenreToggle = Record<Extract<IThemeGenreName, 'product'>, IThemeGenreTypeToggle>;

export declare interface IThemeGenreTypeDate {
    background: {
        rest: string;
        hover: string;
        today: string;
        weekend: string;
        choice: string;
        line: string;
    };
    border: {
        rest: string;
        hover: string;
        today: string;
        weekend: string;
        choice: string;
        line: string;
    };
    color: {
        rest: string;
        hover: string;
        placeholder: string;
        today: string;
        weekend: string;
        choice: string;
        line: string;
    };
}

export declare interface IThemeGenreTypeDefault {
    background: {
        rest: string;
        hover: string;
    };
    border: {
        rest: string;
        hover: string;
    };
    color: {
        rest: string;
        hover: string;
        placeholder: string;
    };
}

export declare interface IThemeGenreTypeImageSelect {
    background: {
        rest: string;
        hover: string;
    };
    border: {
        rest: string;
        hover: string;
    };
    color: {
        rest: string;
        hover: string;
        placeholder: string;
    };
}

export declare interface IThemeGenreTypeRange {
    thumb: {
        background: {
            rest: string;
            hover: string;
        };
        border: {
            rest: string;
            hover: string;
        };
    };
    track: {
        background: {
            rest: string;
        };
        gradient: {
            rest: string;
        };
    };
}

export declare interface IThemeGenreTypeSelect {
    background: {
        rest: string;
        hover: string;
        select: string;
    };
    border: {
        rest: string;
        hover: string;
        select: string;
    };
    color: {
        rest: string;
        hover: string;
        select: string;
        placeholder: string;
    };
}

export declare interface IThemeGenreTypeSonner {
    button: {
        genre: keyof IThemeGenre;
    };
    description: {
        color: string;
    };
    icon: {
        color: string;
    };
    title: {
        color: string;
    };
    wrapper: {
        background: string;
        borderColor: string;
        boxShadow: string;
        boxShadowHover: string;
    };
}

export declare interface IThemeGenreTypeToggle {
    active: {
        rest: {
            track: string;
            thumb: string;
            border: string;
            thumbBoxShadow: string;
        };
        hover: {
            track: string;
            thumb: string;
            border: string;
            thumbBoxShadow: string;
        };
    };
    unActive: {
        rest: {
            track: string;
            thumb: string;
            border: string;
            thumbBoxShadow: string;
        };
        hover: {
            track: string;
            thumb: string;
            border: string;
            thumbBoxShadow: string;
        };
    };
}

export declare type IThemePaletteKeys = 'transparent' | 'black100' | 'black80' | 'black60' | 'black50' | 'black40' | 'black10' | 'black05' | 'black04' | 'blackHelena' | 'blackJanice' | 'grayJanice' | 'grayKaren' | 'grayMonica' | 'graySandra' | 'grayPatricia' | 'graySarah' | 'grayStassie' | 'grayAdriana' | 'greenGoogle' | 'grayBarbara' | 'grayStephanie' | 'grayFrances' | 'grayTina' | 'green100' | 'green50' | 'green25' | 'green10' | 'green10Background' | 'whiteStandard' | 'whiteJanice' | 'yellowGoogle' | 'yellow100' | 'yellow50' | 'yellow25' | 'yellow10' | 'yellow10Background' | 'redGoogle' | 'red100' | 'red50' | 'red25' | 'red10' | 'red10Background' | 'blueGoogle' | 'blueRest' | 'blueActive' | 'blueHover' | 'blueFocus' | 'blueBr' | 'blueKaren' | 'blueMonica' | 'violetStephanie' | 'violetJanice' | 'amnezia' | 'inherit' | 'currentColor';

export declare type IThemeScreen = Record<IThemeDevice, {
    width: number;
}>;

export declare type IThemeSize = 'large' | 'largeMedium' | 'medium' | 'mediumSmall' | 'small';

export declare interface IThemeSizePropertyDefault {
    font: number;
    height: number;
    heightIcon: number;
    padding: number;
    radius: number;
}

export declare interface IThemeSizePropertyToggle {
    height: number;
    padding: number;
    thumb: number;
    width: number;
}

export declare type IThemeTypographyHeading = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'h7' | 'h8' | 'h9';

export declare type IThemeTypographyWeight = 100 | 300 | 400 | 500 | 700 | 900;

export declare const JeneseiGlobalStyles: NamedExoticComponent<ExecutionProps & object>;

export declare const JeneseiPalette: Record<IThemePaletteKeys, string>;

export declare const KEY_SIZE_DATA: Record<IThemeSize, IThemeSizePropertyDefault>;

export declare const KEY_SIZE_DATA_TOGGLE: Record<IThemeSize, IThemeSizePropertyToggle>;

export declare const LIBRARY_VERSION: any;

export declare const LIST_IMAGE_SUPPORTED_FORMAT: readonly ["image/jpeg", "image/jpg", "image/png", "image/webp", "image/avif"];

export declare const LIST_IMAGE_SUPPORTED_FORMAT_FOR_INPUT: string;

export declare const LIST_KEY_LANGUAGE: {
    [key: string]: string;
};

export declare const LIST_KEY_SERVICE: {
    [key: string]: string;
};

export declare const LIST_LANGUAGE: {
    value: ILanguageKeys;
    label: string;
    placeholder: string;
    search: string;
}[];

export declare const LIST_SERVICE: {
    value: IServiceKeys;
    label: string;
    placeholder: string;
    search: string;
}[];

export declare const LOCALE_INPUT: InputItem;

export declare const LOCALE_MONTHS: MonthItem[];

export declare const LOCALE_WEEKS: WeekItem[];

export declare const LocalStorageContext: Context<LocalStorageContextProps | null>;

export declare interface LocalStorageContextProps {
    getLocalStorage: <K extends keyof ValidLocalStorageObject>(name: K) => ValidLocalStorageObject[K] | undefined;
    setLocalStorage: <K extends keyof ValidLocalStorageObject>(name: K, value: ValidLocalStorageObject[K]) => void;
    removeLocalStorageValue: <K extends keyof ValidLocalStorageObject>(name: K) => void;
    removeLocalStorageValues: () => void;
    checkLocalStorage: () => void;
    localStorageValues: ValidLocalStorageObject | undefined;
}

export declare const LOREM_IPSUM_TEXT = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.";

export declare type MonthItem = {
    localeLong: string;
    localeShort: string;
    value: 'january' | 'february' | 'march' | 'april' | 'may' | 'june' | 'july' | 'august' | 'september' | 'october' | 'november' | 'december';
};

export declare const OBJECT_LANGUAGE: ILanguage;

export declare const OBJECT_SERVICE: IService;

export declare const Outside: FC<OutsideProps>;

declare type OutsideProps = PropsWithChildren & addSXProps & {
    onOutsideClick: (event: MouseEvent) => void;
};

export declare const Pagination: FC<PaginationProps>;

export declare type PaginationProps = {
    buttonControl: Pick<ButtonProps, 'size' | 'genre' | 'isRadius' | 'isWidthAsHeight' | 'isPlaystationEffect'>;
    buttonCount: {
        active: Pick<ButtonProps, 'size' | 'genre' | 'isRadius' | 'isPlaystationEffect'>;
        inactive: Pick<ButtonProps, 'size' | 'genre' | 'isRadius' | 'isPlaystationEffect'>;
    };
    gap?: number;
    index: number;
    lengthData?: Record<number, Pick<ButtonProps, 'genre' | 'icons'>>;
    length: number;
    isInfinity?: boolean;
    viewQuantity: number;
    changeIndex: (index: number) => void;
    locale: {
        prev: string;
        next: string;
    };
} & addSXProps;

export declare const PermissionContext: Context<PermissionContextProps | null>;

export declare interface PermissionContextProps {
    geolocationPermission: PermissionState | null;
    isBiometricSupported: boolean;
    isNotificationPermissionLoading: boolean;
    notificationPermission: NotificationPermission | null;
    pushNotificationSupported: boolean;
    requestGeolocationPermission: () => void;
    requestNotificationPermission: () => Promise<NotificationPermission | undefined>;
}

/**
 * Props for the Popover component. / Свойства компонента Popover.
 */
declare type PopoverProps = PropsWithChildren & {
    /**
     * Additional class name for the popover root element.
     * Дополнительный CSS-класс для корневого элемента поповера.
     */
    className?: string;
    /**
     * Maximum width of the popover (CSS value, e.g. '300px' or '100%').
     * Максимальная ширина поповера (CSS-значение, например, '300px' или '100%').
     */
    maxWidth?: string;
    /**
     * Maximum height of the popover (CSS value, e.g. '400px' or '100%').
     * Максимальная высота поповера (CSS-значение, например, '400px' или '100%').
     */
    maxHeight?: string;
    /**
     * Controls whether the popover is open (visible).
     * Управляет открытием поповера (видимостью).
     */
    isOpen: boolean;
    /**
     * If true, always show the outline (for accessibility/debug).
     * Если true — всегда показывать обводку (для доступности/отладки).
     */
    isShowAlwaysOutline?: boolean;
    /**
     * Styles for the floating popover element (from floating-ui).
     * Стили для плавающего элемента поповера (от floating-ui).
     */
    floatingStyles: CSSProperties;
    /**
     * Callback fired when the popover should close (e.g. click outside).
     * Колбэк, вызываемый при необходимости закрыть поповер (например, при клике вне).
     */
    onClose?: () => void;
    /**
     * Ref to the popover root element.
     * Ref на корневой элемент поповера.
     */
    ref?: Ref<HTMLElement | null>;
    /**
     * Size of the popover (affects padding, font, etc.).
     * Размер поповера (влияет на отступы, шрифт и т.д.).
     */
    size?: IThemeSize;
    /**
     * Visual genre/style of the popover (e.g. 'black', 'primary').
     * Визуальный стиль поповера (например, 'black', 'primary').
     */
    genre?: TButtonGenre;
} & addSXProps & addFontProps & addSXTypographyProps;

export declare const Preview: FC<PreviewProps>;

export declare type PreviewAdditionalProps = PreviewIsShowProps | PreviewTimeProps;

declare type PreviewDefaultProps = {
    defaultVisible?: boolean;
    content?: ReactNode;
} & {
    sxLoader?: addSXProps['sx'];
    sxChildren?: addSXProps['sx'];
};

declare interface PreviewIsShowProps extends PreviewDefaultProps {
    visible: boolean;
    minTime?: number;
}

export declare type PreviewProps = PropsWithChildren & PreviewAdditionalProps;

declare interface PreviewTimeProps extends PreviewDefaultProps {
    time: number;
}

/**
 * ProviderApp component is a context context that manages various application-level states
 * such as background color, status bar color, background image, title, and description.
 * It uses several custom hooks to handle these states and provides them via the AppContext.
 *
 * @component
 *
 * @param {ProviderAppProps} props - The properties passed to the ProviderApp component.
 * @param {string} props.defaultBgColor - The default background color.
 * @param {string} props.defaultStatusBarColor - The default status bar color.
 * @param {string} [props.defaultBgImage] - The default background image.
 * @param {string} [props.defaultTitle] - The default title.
 * @param {string} [props.defaultDescription] - The default description.
 * @param {boolean} [props.isScrollOutlet] - Determines if the outlet should be scrollable.
 * @param {object} [props.footer] - The footer component and its properties.
 * @param {object} [props.notification] - The notification component and its properties.
 * @param {object} [props.header] - The header component and its properties.
 * @param {object} [props.nav] - The navigation component and its properties.
 * @param {object} [props.leftAside] - The left aside component and its properties.
 * @param {object} [props.rightAside] - The right aside component and its properties.
 * @param {React.ReactNode} props.children - The children components to be rendered inside the ProviderApp.
 *
 * @returns {JSX.Element} The rendered ProviderApp component.
 */
export declare const ProviderApp: FC<ProviderAppProps>;

export declare type ProviderAppElementProps = Partial<AddDollarSign<Pick<ProviderAppProps, 'notification' | 'header' | 'nav' | 'footer' | 'leftAside' | 'rightAside'>>>;

export declare const ProviderAppOutlet: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, Partial<AddDollarSign<Pick<ProviderAppProps, "footer" | "header" | "nav" | "isScrollOutlet" | "notification" | "leftAside" | "rightAside">>>>> & string;

export declare const ProviderAppOutletChildren: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>, AddDollarSign<Pick<ProviderAppProps, "main" | "isScrollOutlet">>>> & string;

export declare type ProviderAppOutletChildrenProps = AddDollarSign<Pick<ProviderAppProps, 'main' | 'isScrollOutlet'>>;

export declare const ProviderAppOutletFooter: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>, Partial<AddDollarSign<Pick<ProviderAppProps, "footer" | "header" | "nav" | "isScrollOutlet" | "notification" | "leftAside" | "rightAside">>>>> & string;

export declare const ProviderAppOutletHeader: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>, Partial<AddDollarSign<Pick<ProviderAppProps, "footer" | "header" | "nav" | "isScrollOutlet" | "notification" | "leftAside" | "rightAside">>>>> & string;

export declare const ProviderAppOutletLeftAside: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>, Partial<AddDollarSign<Pick<ProviderAppProps, "footer" | "header" | "nav" | "isScrollOutlet" | "notification" | "leftAside" | "rightAside">>>>> & string;

export declare const ProviderAppOutletNav: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>, Partial<AddDollarSign<Pick<ProviderAppProps, "footer" | "header" | "nav" | "isScrollOutlet" | "notification" | "leftAside" | "rightAside">>>>> & string;

export declare const ProviderAppOutletNotification: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>, Partial<AddDollarSign<Pick<ProviderAppProps, "footer" | "header" | "nav" | "isScrollOutlet" | "notification" | "leftAside" | "rightAside">>>>> & string;

export declare type ProviderAppOutletProps = Partial<AddDollarSign<Pick<ProviderAppProps, 'isScrollOutlet' | 'notification' | 'header' | 'nav' | 'footer' | 'leftAside' | 'rightAside'>>>;

export declare const ProviderAppOutletRightAside: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>, Partial<AddDollarSign<Pick<ProviderAppProps, "footer" | "header" | "nav" | "isScrollOutlet" | "notification" | "leftAside" | "rightAside">>>>> & string;

export declare interface ProviderAppProps extends PropsWithChildren {
    defaultPreview?: PreviewAdditionalProps;
    defaultBgColor: IThemePaletteKeys;
    defaultStatusBarColor: IThemePaletteKeys;
    defaultBgImage?: string;
    defaultTitle: string;
    defaultDescription: string;
    isScrollOutlet?: boolean;
    notification?: {
        component: ReactElement;
        length?: ScreenWidthProps<string | null>;
        zIndex?: number;
    };
    header?: {
        component: ReactElement;
        length?: ScreenWidthProps<string | null>;
        zIndex?: number;
    };
    nav?: {
        component: ReactElement;
        length?: ScreenWidthProps<string | null>;
        zIndex?: number;
    };
    footer?: {
        component: ReactElement;
        length?: ScreenWidthProps<string | null>;
        zIndex?: number;
    };
    leftAside?: {
        component: ReactElement;
        length?: ScreenWidthProps<string | null>;
        isTopHeader?: boolean;
        isTopFooter?: boolean;
        isTopNav?: boolean;
        zIndex?: number;
    };
    rightAside?: {
        component: ReactElement;
        length?: ScreenWidthProps<string | null>;
        isTopHeader?: boolean;
        isTopFooter?: boolean;
        isTopNav?: boolean;
        zIndex?: number;
    };
    main?: {
        zIndex?: number;
    };
}

export declare const ProviderAppWrapper: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, ProviderAppWrapperProps>> & string;

export declare interface ProviderAppWrapperProps {
    $bgColor: ProviderAppProps['defaultBgColor'];
    $bgImage: ProviderAppProps['defaultBgImage'] | null;
}

/**
 * Provider component for managing cookies.
 *
 * @remarks
 * You should understand which cookies you are changing and whether you have access to them.
 *
 * @remarks
 * The local storage is typed using the `jenesei-kit-react.d.ts` file:
 *
 * ```typescript
 * import '@jenesei-software/jenesei-kit-react'
 *
 * declare module '@jenesei-software/jenesei-kit-react' {
 *   export interface ValidCookieObject {
 *    access_token: string
 *    refresh_token: string
 *   }
 * }
 * ```
 */
export declare const ProviderCookie: FC<ProviderCookieProps>;

export declare interface ProviderCookieProps extends PropsWithChildren {
    validate?: {
        validateKeys: (keyof ValidCookieObject)[];
        getValidateCookieValue: <K extends keyof ValidCookieObject>(key: K, value: ValidCookieObject[K]) => value is ValidCookieObject[K];
    };
}

export declare const ProviderDialog: FC<ProviderDialogProps>;

export declare type ProviderDialogProps = PropsWithChildren & {
    zIndex: number;
};

export declare const ProviderGeolocation: FC<ProviderGeolocationProps>;

export declare type ProviderGeolocationProps = PropsWithChildren & {
    isAskEntrance?: boolean;
};

/**
 * Provider component for managing local storage.
 *
 * @remarks
 * The local storage is typed using the `jenesei-kit-react.d.ts` file:
 *
 * ```typescript
 * import '@jenesei-software/jenesei-kit-react'
 *
 * declare module '@jenesei-software/jenesei-kit-react' {
 *   export interface ValidLocalStorageObject {
 *     access_token: string
 *     refresh_token: string
 *   }
 * }
 * ```
 */
export declare const ProviderLocalStorage: FC<ProviderLocalStorageProps>;

export declare interface ProviderLocalStorageProps extends PropsWithChildren {
    validate?: {
        validateKeys: (keyof ValidLocalStorageObject)[];
        getValidateLocalStorageValue: <K extends keyof ValidLocalStorageObject>(key: K, value: ValidLocalStorageObject[K]) => value is ValidLocalStorageObject[K];
    };
}

export declare const ProviderPermission: (props: ProviderPermissionProps) => JSX.Element;

export declare type ProviderPermissionProps = PropsWithChildren;

export declare const ProviderScreenWidth: FC<ProviderScreenWidthProps>;

export declare type ProviderScreenWidthProps = PropsWithChildren;

export declare const ProviderSonner: FC<ProviderSonnerProps>;

export declare type ProviderSonnerProps = PropsWithChildren & {
    gap: number;
    position: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left' | 'bottom-center' | 'top-center';
    visibleToasts?: number;
    zIndex?: number;
    default: Omit<SonnerContentStandardProps, 'index'>;
};

declare const Range_2: (props: RangeProps) => JSX.Element;
export { Range_2 as Range }

export declare type RangeComponentProps = AddDollarSign<Pick<RangeProps, 'size' | 'genre'>>;

export declare type RangeProps = {
    values: number[];
    onChange: (values: number[]) => void;
    step: number;
    min: number;
    max: number;
    isShowMarker?: boolean;
    onBlur?: FocusEventHandler<HTMLDivElement>;
} & Pick<InputStandardProps, 'size' | 'genre' | 'id' | 'sx' | 'error'>;

export declare const RangeThumb: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, RangeThumbProps>> & string;

export declare type RangeThumbProps = RangeComponentProps & AddDollarSign<{
    colorBorder: string;
    colorBackground: string;
}>;

export declare const RangeTrack: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, AddDollarSign<Pick<RangeProps, "size" | "genre">>>> & string;

export declare const RangeWrapper: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, AddDollarSign<Pick<RangeProps, "size" | "sx" | "error">>>> & string;

export declare type RangeWrapperProps = AddDollarSign<Pick<RangeProps, 'size' | 'sx' | 'error'>>;

declare type ResizableTextAreaProps = BaseTextAreaProps & {
    isResize: true;
    isAutoHeight?: false | undefined;
    maxRows?: never;
};

export declare const Ripple: FC<RippleProps>;

export declare interface RippleArrayElement {
    x: number;
    y: number;
    size: number;
}

export declare const RippleContainer: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, AddDollarSign<RippleProps>>> & string;

export declare type RippleContainerProps = AddDollarSign<RippleProps>;

export declare interface RippleProps {
    duration?: number;
    color?: string;
    isDisabled?: boolean;
    isHidden?: boolean;
}

export declare const RippleSpan: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, AddDollarSign<RippleProps>>> & string;

export declare type Screens = keyof IThemeScreen;

export declare const ScreenWidthContext: Context<ScreenWidthContextProps | null>;

export declare interface ScreenWidthContextProps {
    screenWidth: Screens;
    screens: {
        value: Screens;
        isScreen: boolean;
    }[];
    screenActual: Screens;
}

export declare type ScreenWidthProps<T> = {
    [K in IThemeDevice]?: T;
};

export declare const Scroll: FC<ScrollProps>;

export declare type ScrollProps = StackProps & DefaultScrollProps;

export declare const Select: <T extends object & ISelectItem>(props: SelectProps<T>) => JSX.Element;

export declare type SelectInputProps = AddDollarSign<Pick<SelectProps<ISelectItem>, 'size' | 'genre'>>;

export declare const SelectLanguage: FC<SelectLanguageProps>;

export declare type SelectLanguageProps = Omit<SelectProps<ISelectItem>, 'option' | 'value' | 'onChange'> & {
    value: string | null;
    onChange: (language: string | null) => void;
};

export declare const SelectList: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLUListElement>, HTMLUListElement>, AddDollarSign<Pick<SelectProps<ISelectItem>, "size" | "isWrapSelectOption">>>> & string;

export declare const SelectListOption: IStyledComponentBase<"web", Substitute<Omit<HTMLMotionProps<"li">, "ref"> & RefAttributes<HTMLLIElement>, AddDollarSign<Pick<SelectProps<ISelectItem>, "size" | "genre" | "isCenter" | "isNotShowHoverStyle" | "isBold" | "isWrapSelectOption" | "isClearWhenClickSelectListOption" | "isOnlyColorInSelectListOption"> & {
item?: ISelectItem;
isChecked?: boolean;
}>>> & string & Omit<ForwardRefComponent<HTMLLIElement, HTMLMotionProps<"li">>, keyof Component<any, {}, any>>;

export declare type SelectListOptionProps = AddDollarSign<Pick<SelectProps<ISelectItem>, 'genre' | 'size' | 'isCenter' | 'isNotShowHoverStyle' | 'isBold' | 'isWrapSelectOption' | 'isClearWhenClickSelectListOption' | 'isOnlyColorInSelectListOption'> & {
    item?: ISelectItem;
    isChecked?: boolean;
}>;

export declare type SelectListProps = AddDollarSign<Pick<SelectProps<ISelectItem>, 'size' | 'isWrapSelectOption'>>;

export declare const SelectMonth: FC<SelectMonthProps>;

export declare type SelectMonthProps = Omit<SelectProps<ISelectItem>, 'option' | 'value' | 'onChange'> & {
    dateMin?: number;
    dateMax?: number;
    value: number | null;
    isShortLabel?: boolean;
    onChange: (value: number | null) => void;
    monthsLocale: MonthItem[];
};

export declare const SelectMonths: FC<SelectMonthsProps>;

export declare type SelectMonthsProps = Omit<SelectProps<ISelectItem>, 'option' | 'value' | 'onChange'> & {
    dateMin?: number;
    dateMax?: number;
    value: number[];
    isShortLabel?: boolean;
    onChange: (value: number[]) => void;
    monthsLocale: MonthItem[];
};

export declare type SelectProps<T extends ISelectItem> = addErrorProps & addFontProps & addSXProps & {
    id?: string;
    size: IThemeSize;
    genre: TInputSelect;
    isToggleWhenClickSelectListOption?: boolean;
    isDisabled?: boolean;
    isShowDropdownOptionIcon?: boolean;
    isShowIconToggle?: boolean;
    isShowIconSearchClear?: boolean;
    isShowIconFetching?: boolean;
    isShowSelectAll?: boolean;
    isShowSelectAllLabel?: boolean;
    isShowAddOption?: boolean;
    isNotShowDisabledOptions?: boolean;
    isOnClickOptionClose?: boolean;
    isNotShowHoverStyle?: boolean;
    isSortValueAsOption?: boolean;
    isCenter?: boolean;
    isStayValueAfterSelect?: boolean;
    isBold?: boolean;
    isWrapSelectOption?: boolean;
    isMulti?: boolean;
    isFetching?: boolean;
    isClearWhenClickSelectListOption?: boolean;
    isStaySearchAfterSelect?: boolean;
    isOnlyColorInSelectListOption?: boolean;
    labelPlaceholder?: string;
    labelEmptyOption?: string;
    labelSelectAll?: string;
    labelAndMore?: (count: number) => string;
    labelAddOption?: (value: string) => string;
    isSearch?: boolean;
    valueSearch?: string;
    onChangeSearch?: (value: string) => void;
    optionAllLength?: number;
    option: T[];
    value: T[];
    maxViewSelect?: number;
    maxViewDropdown?: number;
    minViewDropdown?: number;
    refFloating?: Ref<HTMLElement | null>;
    refReference?: Ref<HTMLElement | null>;
    onAddOption?: (value: string) => void;
    onChange: (value: T[]) => void;
    onChangeAll?: (value: T[], isAll: boolean) => void;
    onFocus?: (event?: FocusEvent_2<HTMLElement>) => void;
    onBlur?: (event?: FocusEvent_2<HTMLElement>) => void;
    fetchNextPage?: () => void;
    getEstimateSize?: (index: number) => number;
};

export declare const SelectTextArea: IStyledComponentBase<"web", Substitute<TextAreaProps & BaseObject, BaseObject>> & string & Omit<(props: TextAreaProps) => JSX.Element, keyof Component<any, {}, any>>;

export declare const SelectWrapper: IStyledComponentBase<"web", Substitute<Omit<HTMLMotionProps<"div">, "ref"> & RefAttributes<HTMLDivElement>, AddDollarSign<Pick<SelectProps<ISelectItem>, "size" | "sx" | "error" | "genre" | "isCenter" | "isNotShowHoverStyle"> & {
isOpen: boolean;
}>>> & string & Omit<ForwardRefComponent<HTMLDivElement, HTMLMotionProps<"div">>, keyof Component<any, {}, any>>;

export declare type SelectWrapperProps = AddDollarSign<Pick<SelectProps<ISelectItem>, 'genre' | 'sx' | 'size' | 'isNotShowHoverStyle' | 'error' | 'isCenter'> & {
    isOpen: boolean;
}>;

export declare const SelectYear: FC<SelectYearProps>;

export declare type SelectYearProps = Omit<SelectMonthProps, 'monthsLocale'> & {
    dateMin?: number;
    dateMax?: number;
    sortOrder?: 'asc' | 'desc';
};

export declare const Separator: FC<SeparatorProps>;

export declare interface SeparatorProps {
    sx?: addSXProps['sx'];
    radius?: string;
    type?: 'horizontal' | 'vertical';
    color?: IThemePaletteKeys;
    thickness?: string;
}

export declare const SeparatorWrapper: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, AddDollarSign<Pick<SeparatorProps, "color" | "sx" | "type" | "radius" | "thickness">>>> & string;

export declare type SeparatorWrapperProps = AddDollarSign<Pick<SeparatorProps, 'sx' | 'radius' | 'color' | 'type' | 'thickness'>>;

export declare function setToCookie<T>(key: string, value: T, options?: CookieAttributes): void;

export declare function setToLocalStorage<T>(key: string, value: T): void;

export declare const Skeleton: FC<SkeletonProps>;

declare type SkeletonDefaultProps = {
    className?: string;
    defaultVisible?: boolean;
    type?: 'primary' | 'secondary';
    color?: IThemePaletteKeys;
    isInheritColor?: boolean;
};

declare interface SkeletonIsShowProps extends SkeletonDefaultProps {
    visible: boolean;
}

export declare type SkeletonProps = StackProps & (SkeletonIsShowProps | SkeletonTimeProps);

declare interface SkeletonTimeProps extends SkeletonDefaultProps {
    time: number;
}

export declare const SliderDot: IStyledComponentBase<"web", FastOmit<Omit<HTMLMotionProps<"div">, "ref"> & RefAttributes<HTMLDivElement>, never>> & string & Omit<ForwardRefComponent<HTMLDivElement, HTMLMotionProps<"div">>, keyof Component<any, {}, any>>;

export declare const SliderImage: IStyledComponentBase<"web", FastOmit<Omit<HTMLMotionProps<"div">, "ref"> & RefAttributes<HTMLDivElement>, never>> & string & Omit<ForwardRefComponent<HTMLDivElement, HTMLMotionProps<"div">>, keyof Component<any, {}, any>>;

export declare type SliderImageProps = {
    id: number;
    imageSrc: string;
    children?: ReactNode;
};

export declare const Smooth: FC<StackProps>;

export declare const SonnerButtonWrapper: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;

export declare const SonnerContent: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;

declare type SonnerContentContentProps = SonnerContentDefaultProps & {
    content: ReactNode | false;
};

declare type SonnerContentDefaultProps = {
    hidingMode?: 'clickOnSonner' | 'clickOnButton';
    hidingTime?: number;
    icon?: addIconProps;
    id?: string;
    genre?: keyof ITheme['colors']['sonner'];
    isLoading?: boolean;
    button?: {
        content?: string | ReactNode;
        onClick?: () => void;
    } | false;
    index: number;
} & addFontProps;

export declare const SonnerContentDescription: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, Required<AddDollarSign<Pick<SonnerContentStandardProps, "font" | "genre">>>>> & string;

export declare type SonnerContentDescriptionProps = Required<AddDollarSign<Pick<SonnerContentStandardProps, 'genre' | 'font'>>>;

export declare type SonnerContentProps = SonnerContentContentProps | SonnerContentStandardProps;

export declare type SonnerContentStandardProps = SonnerContentDefaultProps & {
    description?: string | ReactNode;
    title?: string | ReactNode;
};

export declare const SonnerContentTitle: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, Required<AddDollarSign<Pick<SonnerContentStandardProps, "font" | "genre">>>>> & string;

export declare type SonnerContentTitleProps = Required<AddDollarSign<Pick<SonnerContentStandardProps, 'genre' | 'font'>>>;

export declare const SonnerContext: Context<SonnerContextProps | null>;

export declare type SonnerContextProps = {
    toast: (content: Omit<SonnerContentStandardProps, 'index'>) => void;
    promise: <T>(promise: Promise<T>, expectation: Omit<SonnerContentStandardProps, 'index'>, toast: (success: T | undefined, error: any | undefined) => Omit<SonnerContentProps, 'index'>) => void;
    remove: (id: SonnerContentDefaultProps['id']) => void;
    contentHistory: SonnerContentProps[];
};

declare type SonnerElementDefaultProps = {
    id: SonnerContentDefaultProps['id'];
    title: SonnerContentStandardProps['title'];
    description: SonnerContentStandardProps['description'];
    content: SonnerContentContentProps['content'];
    icon?: SonnerContentDefaultProps['icon'];
    isLoading: SonnerContentDefaultProps['isLoading'];
    hidingMode: SonnerContentDefaultProps['hidingMode'];
    button: SonnerContentDefaultProps['button'];
    index: number;
    handleOnClick: (id: SonnerContentDefaultProps['id'], hidingMode?: SonnerContentDefaultProps['hidingMode']) => void;
    isMoreThanLastViewIndexPlusOne: boolean;
    isMoreThanLastViewIndex: boolean;
    isHovered: boolean;
    isLastViewIndex: boolean;
    buttonGenre: keyof IThemeGenre;
    isTop: boolean;
} & Required<Pick<SonnerContentDefaultProps, 'genre'>>;

export declare type SonnerElementProps = SonnerElementDefaultProps;

export declare const SonnerElementWrapper: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, Required<AddDollarSign<Pick<SonnerContentStandardProps, "genre">>>>> & string;

export declare type SonnerElementWrapperProps = Required<AddDollarSign<Pick<SonnerContentStandardProps, 'genre'>>>;

export declare const SonnerIcon: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;

export declare const SonnerLayout: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, Required<AddDollarSign<Pick<ProviderSonnerProps, "position" | "zIndex" | "gap">>>>> & string;

export declare type SonnerLayoutProps = Required<AddDollarSign<Pick<ProviderSonnerProps, 'position' | 'gap' | 'zIndex'>>>;

export declare const Stack: FC<StackProps>;

export declare const StackMotion: FC<StackMotionProps>;

export declare type StackMotionProps = StackProps & LayoutProps & AnimationProps & HoverHandlers & TapHandlers & FocusHandlers & DraggableProps & {
    style?: CSSProperties;
};

export declare interface StackProps extends addSXProps, PropsWithChildren {
    className?: string;
    isHover?: boolean;
    isRipple?: boolean;
    onClick?: () => void;
    onDragOver?: DragEventHandler<HTMLDivElement>;
    onDrop?: (e: DragEvent_2<HTMLDivElement>) => void;
    ref?: Ref<HTMLDivElement | null>;
}

/**
 * Styled
 */
export declare const StyledButton: IStyledComponentBase<"web", Substitute<Omit<HTMLMotionProps<"button">, "ref"> & RefAttributes<HTMLButtonElement>, StyledDollarButtonProps>> & string & Omit<ForwardRefComponent<HTMLButtonElement, HTMLMotionProps<"button">>, keyof Component<any, {}, any>>;

export declare type StyledButtonGroupProps = AddDollarSign<Pick<ButtonGroupProps, 'position'>> & addSXStyleProps;

export declare const StyledButtonIconsWrapper: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, AddDollarSign<Pick<ButtonProps, "size" | "isIconGroup"> & Pick<ButtonPropsIconGroup, "iconGroupOrder">>>> & string;

export declare type StyledCheckboxProps = AddDollarSign<Pick<CheckboxProps, 'checked' | 'genre' | 'view' | 'isWidthAsHeight' | 'size' | 'isDisabled' | 'isNotBackground' | 'isHiddenBorder' | 'font'>> & addSXStyleProps & addErrorStylesProps & addSXTypographyStyleProps & addOutlinePropsDollar;

export declare type StyledDollarButtonIconsWrapperProps = AddDollarSign<Pick<ButtonProps, 'isIconGroup' | 'size'> & Pick<ButtonPropsIconGroup, 'iconGroupOrder'>>;

export declare type StyledDollarButtonProps = AddDollarSign<Pick<ButtonProps, 'genre' | 'isDisabled' | 'isHidden' | 'isWidthAsHeight' | 'isMinWidthAsContent' | 'isRadius' | 'isHiddenBorder' | 'isPlaystationEffect' | 'size' | 'isFullSize' | 'isNotHoverEffect' | 'font'>> & addSXStyleProps & addOutlinePropsDollar & addSXTypographyStyleProps;

export declare const StyledIcon: IStyledComponentBase<"web", Substitute<SVGProps<SVGSVGElement>, StyledIconItemProps>> & string;

export declare type StyledIconItemProps = AddDollarSign<Pick<IconItemProps, 'size' | 'turn' | 'order'> & {
    color?: IThemePaletteKeys;
}> & addSXStyleProps;

export declare type StyledIconProps = AddDollarSign<Pick<CheckboxProps, 'genre' | 'checked'>>;

export declare const StyledIconSkeleton: IStyledComponentBase<"web", Substitute<SkeletonProps & BaseObject, AddDollarSign<Pick<IconItemProps, "size" | "order">>>> & string & Omit<FC<SkeletonProps>, keyof Component<any, {}, any>>;

export declare type StyledIconSkeletonProps = AddDollarSign<Pick<IconItemProps, 'size' | 'order'>>;

export declare const StyledInput: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, StyledInputProps>> & string;

export declare type StyledInputChildrenProps = AddDollarSign<Pick<InputProps, 'isDisabled'> & Pick<InputChildrenProps, 'left' | 'right' | 'width'>>;

/****************************************** Default *************************************************/
export declare const StyledInputCSS: RuleSet<StyledInputProps>;

export declare const StyledInputNumeric: IStyledComponentBase<"web", Substitute<InternalNumberFormatBase & {
thousandSeparator?: boolean | string;
decimalSeparator?: string;
allowedDecimalSeparators?: Array<string>;
thousandsGroupStyle?: "thousand" | "lakh" | "wan" | "none";
decimalScale?: number;
fixedDecimalScale?: boolean;
allowNegative?: boolean;
allowLeadingZeros?: boolean;
suffix?: string;
prefix?: string;
} & Omit<InputAttributes, never> & Omit<unknown, "value" | "ref" | "defaultValue" | "prefix" | "inputMode" | "onFocus" | "onBlur" | "onChange" | "onKeyDown" | "onMouseUp" | "type" | "displayType" | "renderText" | "getInputRef" | "valueIsNumericString" | "onValueChange" | "isAllowed" | "thousandSeparator" | "decimalSeparator" | "allowedDecimalSeparators" | "thousandsGroupStyle" | "decimalScale" | "fixedDecimalScale" | "allowNegative" | "allowLeadingZeros" | "suffix"> & {
customInput?: ComponentType<unknown> | undefined;
}, StyledInputProps>> & string & Omit<typeof NumericFormat, keyof Component<any, {}, any>>;

export declare const StyledInputPattern: IStyledComponentBase<"web", Substitute<InternalNumberFormatBase & {
format: string;
mask?: string | string[];
allowEmptyFormatting?: boolean;
patternChar?: string;
} & Omit<InputAttributes, never> & Omit<unknown, "value" | "mask" | "ref" | "defaultValue" | "inputMode" | "onFocus" | "onBlur" | "onChange" | "onKeyDown" | "onMouseUp" | "type" | "format" | "displayType" | "renderText" | "getInputRef" | "valueIsNumericString" | "onValueChange" | "isAllowed" | "allowEmptyFormatting" | "patternChar"> & {
customInput?: ComponentType<unknown> | undefined;
}, StyledInputProps>> & string & Omit<typeof PatternFormat, keyof Component<any, {}, any>>;

export declare type StyledInputProps = AddDollarSign<Pick<InputProps, 'genre' | 'size' | 'error' | 'isLoading' | 'isInputEffect' | 'isDisabled' | 'postfixChildren' | 'prefixChildren' | 'isBold' | 'isNiceNumber' | 'isNotShowHoverStyle' | 'sx' | 'isCenter' | 'font'>> & addOutlinePropsDollar;

/****************************************** Wrapper *************************************************/
export declare const StyledInputWrapper: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, AddDollarSign<Pick<InputProps, "size" | "sx" | "isDisabled" | "isWidthAsHeight" | "isInputEffect">>>> & string;

export declare type StyledInputWrapperProps = AddDollarSign<Pick<InputProps, 'isDisabled' | 'isInputEffect' | 'sx' | 'size' | 'isWidthAsHeight'>>;

export declare const StyledMotionInput: IStyledComponentBase<"web", Substitute<Omit<HTMLMotionProps<"input">, "ref"> & RefAttributes<HTMLInputElement>, StyledInputProps>> & string & Omit<ForwardRefComponent<HTMLInputElement, HTMLMotionProps<"input">>, keyof Component<any, {}, any>>;

export declare const StyledScroll: IStyledComponentBase<"web", Substitute<StackProps, StyledScrollProps>> & string & Omit<FC<StackProps>, keyof Component<any, {}, any>>;

export declare type StyledScrollProps = StackProps & AddDollarSign<DefaultScrollProps>;

export declare const StyledSkeleton: IStyledComponentBase<"web", Substitute<StackProps, StyledSkeletonProps>> & string & Omit<FC<StackProps>, keyof Component<any, {}, any>>;

export declare type StyledSkeletonProps = StackProps & AddDollarSign<Pick<SkeletonIsShowProps & SkeletonTimeProps, 'visible' | 'type' | 'color' | 'isInheritColor'>>;

export declare const StyledStack: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, AddDollarSign<StackProps>>> & string;

export declare const StyledStackMotion: IStyledComponentBase<"web", Substitute<Omit<HTMLMotionProps<"div">, "ref"> & RefAttributes<HTMLDivElement>, AddDollarSign<StackProps>>> & string & Omit<ForwardRefComponent<HTMLDivElement, HTMLMotionProps<"div">>, keyof Component<any, {}, any>>;

export declare type StyledStackProps = AddDollarSign<StackProps>;

export declare const StyledTextArea: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>, AddDollarSign<Pick<TextAreaProps, "size" | "font" | "isDisabled" | "error" | "genre" | "isLoading" | "isBold" | "isResize" | "isInputEffect"> & {
lineHeight: number;
}>>> & string;

export declare type StyledTextAreaProps = AddDollarSign<Pick<TextAreaProps, 'genre' | 'size' | 'error' | 'isLoading' | 'isInputEffect' | 'isDisabled' | 'isBold' | 'isResize' | 'font'> & {
    lineHeight: number;
}>;

export declare type StyledToggleProps = AddDollarSign<Pick<ToggleProps, 'genre' | 'isDisabled' | 'value' | 'size'>> & addErrorStylesProps & addOutlinePropsDollar;

export declare type SXProps = ({
    default: CSSObject;
} & {
    [K in IThemeDevice]?: CSSObject;
}) | ((theme: DefaultTheme) => {
    default: CSSObject;
} & {
    [K in IThemeDevice]?: CSSObject;
});

export declare type TButtonGenre = keyof IThemeGenre;

export declare type TCheckboxGenre = keyof IThemeGenre;

export declare type TDateGenre = keyof IThemeGenreDate;

export declare const TextArea: (props: TextAreaProps) => JSX.Element;

export declare type TextAreaGenre = keyof IThemeGenreTextArea;

export declare type TextAreaProps = AutoHeightTextAreaProps | ResizableTextAreaProps | FixedTextAreaProps;

export declare const TextAreaWrapper: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, AddDollarSign<Pick<TextAreaProps, "size" | "sx" | "isDisabled" | "isReadOnly" | "isDisabledOutline" | "isOutlineBoxShadow" | "genre" | "isInputEffect"> & {
lineHeight: number;
}>>> & string;

export declare type TextAreaWrapperProps = AddDollarSign<Pick<TextAreaProps, 'isDisabled' | 'isInputEffect' | 'sx' | 'size' | 'genre' | 'isReadOnly' | 'isDisabledOutline' | 'isOutlineBoxShadow'> & {
    lineHeight: number;
}>;

export declare const ThemeBlack: ITheme;

export declare const ThemeLight: ITheme;

export declare const ThemeMapBustmarket: readonly ["Card", "Delivery", "Heart", "Reviews", "Search", "Menu"];

export declare const ThemeMapCheckbox: readonly ["Radio-true", "Radio-false", "Square-true", "Square-false", "Heart-true", "Heart-false", "Arrow"];

export declare const ThemeMapId: readonly ["Close", "Biometry", "Qr", "Search", "Folder", "Wallet", "Graph", "Bookmark", "Browser", "Category", "Home", "Notification", "Chat", "Heart", "Paper", "Plus", "Minus", "PaperPlus", "PaperNegative", "PaperFail", "PaperDownload", "PaperUpload", "Send", "Password", "Swap", "Work", "Arrow1", "Arrow2", "Arrow3", "Arrow4", "ArrowMini1", "ArrowMini2", "Scan", "Activity", "Calendar", "Message", "PlusMini", "ChartMini", "Game", "Bag1", "Bag2", "TicketStar", "MoreCircle", "MoreSquare", "Discount", "Buy", "Web", "InfoMini", "DangerMini", "CloseMini", "TickMini", "Video", "Discovery", "Location", "Document", "Setting", "Time", "VolumeUp", "VolumeDown", "VolumeOff", "Star", "Select", "Ticket", "Camera", "Profile", "AddUser", "TwoUser", "ThreeUser", "Login", "Logout", "Download", "Upload", "Voice1", "Voice2", "Delete", "Edit", "PlayMini", "ShieldDone", "ShieldFail", "Show", "Hide", "Filter1", "Filter2", "Image", "Call", "Calling", "CallMissed", "CallSilent", "Lock", "Unlock", "Resources", "Language"];

export declare const ThemeMapLoading: readonly ["Line", "Circle", "Blocks", "Balls"];

export declare const ThemeMapLogo: readonly ["Jenesei", "BustMarket"];

export declare const ThemeMapRealebail: readonly ["MapCluster", "HomeLikes", "HomeManagement", "UserSettings", "User"];

export declare type TImageSelectGenre = keyof IThemeGenreImageSelect;

export declare type TInputGenre = keyof IThemeGenreInput;

export declare type TInputSelect = keyof IThemeGenreSelect;

export declare const Title: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, TypographyCSSProps>> & string;

export declare const Toggle: (props: ToggleProps) => JSX.Element;

export declare const ToggleCenter: IStyledComponentBase<"web", Substitute<Omit<HTMLMotionProps<"div">, "ref"> & RefAttributes<HTMLDivElement>, StyledToggleProps>> & string & Omit<ForwardRefComponent<HTMLDivElement, HTMLMotionProps<"div">>, keyof Component<any, {}, any>>;

export declare type ToggleProps = {
    value: boolean;
    onChange?: (checked: boolean) => void;
    isDisabled?: boolean;
    genre: TToggleGenre;
    size: IThemeSize;
} & addErrorProps & addOutlineProps;

/****************************************** Standard *************************************************/
export declare const ToggleWrapper: IStyledComponentBase<"web", Substitute<Omit<HTMLMotionProps<"div">, "ref"> & RefAttributes<HTMLDivElement>, StyledToggleProps>> & string & Omit<ForwardRefComponent<HTMLDivElement, HTMLMotionProps<"div">>, keyof Component<any, {}, any>>;

export declare const Tooltip: FC<TooltipProps>;

/****************************************** TooltipBox *************************************************/
export declare const TooltipBox: IStyledComponentBase<"web", FastOmit<    {
children?: ReactNode | undefined;
} & {
className?: string;
maxWidth?: string;
maxHeight?: string;
isOpen: boolean;
isShowAlwaysOutline?: boolean;
floatingStyles: CSSProperties;
onClose?: () => void;
ref?: Ref<HTMLElement | null>;
size?: IThemeSize;
genre?: TButtonGenre;
} & addSXProps & addFontProps & addSXTypographyProps, never>> & string & Omit<FC<PopoverProps>, keyof Component<any, {}, any>>;

export declare const TooltipContainer: IStyledComponentBase<"web", FastOmit<StackProps, never>> & string & Omit<FC<StackProps>, keyof Component<any, {}, any>>;

export declare const TooltipContent: FC<TooltipProps>;

export declare type TooltipProps = PropsWithChildren & Pick<PopoverProps, 'genre' | 'size' | 'maxHeight' | 'maxWidth'> & {
    content: ReactNode;
    isDisabled?: boolean;
} & addSXProps & addSXTypographyProps & Pick<UsePopoverProps, 'isWidthAsContent' | 'offset' | 'isClickOutside' | 'isFloatingHover' | 'mode' | 'hoverCloseDelay' | 'hoverOffset' | 'placement'>;

export declare function transformEnumToOptions<T extends Record<string, string>>(enumObj: T): EnumOption[];

export declare function transformObjectToArray<T>(obj: GenericObject<T>): Array<T>;

export declare function transformObjectValuesToKeys<T>(obj: GenericObject<T>): GenericObject<string>;

export declare type TToggleGenre = keyof IThemeGenreToggle;

export declare function TypingEffect({ text }: {
    text: string;
}): JSX.Element;

export declare const Typography: (props: TypographyProps) => JSX.Element;

export declare type TypographyAllProps = TypographyDataProps | TypographyVariantProps;

export declare type TypographyCSSProps = AddDollarSign<{
    sxTypography: TypographySXProps;
    sx?: SXProps;
    isTransitionFontSize?: boolean;
}> & addOutlinePropsDollar;

export declare type TypographyDataProps = TypographyDefaultProps & {
    size?: number;
};

declare type TypographyDefaultProps = {
    align?: CSSProperties['textAlign'];
    color?: IThemePaletteKeys;
    cursor?: CSSProperties['cursor'];
    decoration?: CSSProperties['textDecoration'];
    family?: IThemeFontFamily;
    flex?: string;
    height?: number | string;
    isHoverUnderlining?: boolean;
    letterSpacing?: CSSProperties['letterSpacing'];
    line?: number;
    overflow?: CSSProperties['overflow'];
    shadow?: 'shadowPulse';
    transform?: CSSProperties['textTransform'];
    weight?: IThemeTypographyWeight;
    wrap?: CSSProperties['textWrap'];
    isNoUserSelect?: boolean;
};

export declare const TypographyLink: LinkComponent<    {
(props: TypographyProps & LinkProps): JSX.Element;
displayName: string;
}, string>;

export declare type TypographyProps = PropsWithChildren & {
    onClick?: () => void;
    className?: string;
    style?: CSSProperties;
    href?: string;
    isParagraph?: boolean;
    isAnchor?: boolean;
    isSpan?: boolean;
    isTransitionFontSize?: boolean;
    ref?: Ref<HTMLElement | HTMLHeadingElement | HTMLAnchorElement | null>;
    sx: TypographySXProps;
    sxStandard?: SXProps;
} & addOutlineProps;

export declare type TypographySXProps = {
    default: TypographyAllProps;
} & {
    [K in IThemeDevice]?: TypographyAllProps;
};

export declare const TypographyTooltip: MemoExoticComponent<(props: TypographyTooltipProps) => JSX.Element>;

export declare type TypographyTooltipProps = {
    typography: TypographyProps;
    tooltip: Omit<TooltipProps, 'children' | 'content'>;
} & PropsWithChildren;

declare type TypographyVariantProps = TypographyDefaultProps & {
    variant: IThemeTypographyHeading;
};

declare type UncontrolledValue = {
    defaultValue: string | number | null | undefined;
    value?: never;
};

declare type UncontrolledValue_2 = {
    defaultValue: number | null | undefined;
    value?: never;
};

declare type UncontrolledValue_3 = {
    value?: never;
    defaultValue: string;
};

export declare const urlBase64ToUint8Array: (base64String: string) => Uint8Array<ArrayBuffer>;

/**
 * Custom hook to access the AppContext.
 */
export declare const useApp: () => AppContextProps;

export declare const useBgColor: (defaultColor: IThemePaletteKeys) => {
    bgColor: IThemePaletteKeys;
    changeBgColor: (color: IThemePaletteKeys) => void;
    historyBgColor: (steps: number) => void;
    setDefaultBgColor: () => void;
    bgColorIndex: number;
};

export declare const useBgImage: (defaultImage: string | null) => {
    bgImage: string | null;
    changeBgImage: (image: string | null) => void;
    historyBgImage: (steps: number) => void;
    setDefaultBgImage: () => void;
    bgImageIndex: number;
};

/**
 * Custom hook to access the CookieContext.
 *
 * @remarks
 * You should understand which cookies you are changing and whether you have access to them.
 *
 */
export declare const useCookie: () => CookieContextProps;

export declare const useDebouncedCallback: (callback: () => void, delay?: number) => () => void;

export declare const useDeepCompareMemoize: <T>(value: T) => T;

export declare const useDescription: (defaultDescription: string) => {
    description: string;
    changeDescription: (newDescription: string) => void;
    historyDescription: (steps: number) => void;
    setDefaultDescription: () => void;
    descriptionIndex: number;
};

export declare const useDialog: <T extends object = object>(props?: useDialogProps<T>) => DialogContextItemProps;

export declare type useDialogProps<T extends object = any> = {
    content?: DialogContentObjectPropsContent<T>;
    propsDialog?: DialogContentObjectPropsDialog;
    propsOutline?: addOutlineProps;
    propsCustom?: T;
    onRemove?: () => void;
};

export declare const useDialogs: () => DialogContextProps;

export declare const useGeolocation: () => GeolocationContextProps;

declare type useImageSliderProps = Pick<ImageSliderProps, 'genre' | 'size'> & Pick<ImageSliderProps, 'images' | 'imageSettings' | 'onIndexChange' | 'children'> & {
    locales: {
        failedToLoad: string;
    };
};

export declare function useInjectSprites(urls: string[]): void;

export declare function useLazyInjectSprite(url: string): {
    loaded: boolean;
    error: Error | null;
};

/**
 * Custom hook to access the LocalStorageContext.
 */
export declare const useLocalStorage: () => LocalStorageContextProps;

/**
 * Custom hook to access the PermissionContext.
 */
export declare const usePermission: () => PermissionContextProps;

/**
 * Props for the usePopover hook (popover logic and behavior).
 * Свойства для хука usePopover (логика и поведение поповера).
 */
declare type UsePopoverProps = {
    /**
     * Поддержка фокуса внутри поповера (если true, фокус будет удерживаться внутри поповера).
     */
    isFocusTrap?: boolean;
    /**
     * Delay in ms before closing popover on hover out (default: 100).
     * Задержка в мс перед закрытием поповера при уходе мыши (по умолчанию: 100).
     */
    hoverCloseDelay?: number;
    /**
     * Offset in px for hover zone around popover (default: 8).
     * Отступ в пикселях для hover-зоны вокруг поповера (по умолчанию: 8).
     */
    hoverOffset?: number;
    /**
     * If true, popover closes when clicking outside.
     * Если true — поповер закрывается при клике вне его.
     */
    isClickOutside?: boolean;
    /**
     * If true, disables all popover logic and interaction.
     * Если true — отключает всю логику и взаимодействие поповера.
     */
    isDisabled?: boolean;
    /**
     * If true, enables floating hover mode (popover stays open while mouse is near).
     * Если true — включает режим плавающего hover (поповер открыт, пока мышь рядом).
     */
    isFloatingHover?: boolean;
    /**
     * If true, popover width matches reference element.
     * Если true — ширина поповера совпадает с reference-элементом.
     */
    isWidthAsContent?: boolean;
    /**
     * Popover open/close mode: 'click', 'hover', 'clickOpen', or 'independence'.
     * Режим открытия/закрытия поповера: 'click', 'hover', 'clickOpen', 'independence'.
     */
    mode?: 'click' | 'hover' | 'clickOpen' | 'independence';
    /**
     * Offset in px between reference and popover (default: 8).
     * Отступ в пикселях между reference и поповером (по умолчанию: 8).
     */
    offset?: number;
    /**
     * Placement of the popover relative to reference (from floating-ui).
     * Положение поповера относительно reference (из floating-ui).
     */
    placement: Placement;
    /**
     * Refs to elements that should not trigger click outside close.
     * Массив ref'ов, которые не должны вызывать закрытие при клике вне.
     */
    refsExcludeClickOutside?: Ref<HTMLElement | null>[];
    /**
     * Refs to elements that should not trigger blur close.
     * Массив ref'ов, которые не должны вызывать закрытие при потере фокуса.
     */
    refsExcludeBlur?: Ref<HTMLElement | null>[];
    /**
     * Callback fired when popover is focused/opened.
     * Колбэк, вызываемый при открытии/фокусе поповера.
     */
    onFocus?: () => void;
    /**
     * Callback fired when popover is blurred/closed.
     * Колбэк, вызываемый при закрытии/потере фокуса поповера.
     */
    onBlur?: () => void;
    /**
     * Callback fired when reference element loses focus (not to excluded refs).
     * Колбэк, вызываемый при потере фокуса reference-элемента (не на исключённые ref'ы).
     */
    onBlurReference?: () => void;
};

export declare const useRemovePreviewLoader: () => void;

export declare const useScreenWidth: () => ScreenWidthContextProps;

export declare const useSonner: () => SonnerContextProps;

export declare const useStatusBarColor: (defaultColor: IThemePaletteKeys) => {
    statusBarColor: IThemePaletteKeys;
    changeStatusBarColor: (color: IThemePaletteKeys) => void;
    historyStatusBarColor: (steps: number) => void;
    setDefaultStatusBarColor: () => void;
    statusBarColorIndex: number;
};

export declare interface ValidCookieObject {
}

export declare interface ValidLocalStorageObject {
}

export declare type WeekItem = {
    localeLong: string;
    localeShort: string;
    value: 'mo' | 'tu' | 'we' | 'th' | 'fr' | 'sa' | 'su';
};

export declare function WordsPullUp({ text }: {
    text: string;
}): JSX.Element;

export { }