import { BaseObject } from 'styled-components/dist/types';
import { Component } from 'react';
import { CSSObject } from 'styled-components';
import { CSSProperties } from 'react';
import { default as default_2 } from 'react';
import { DefaultTheme } from 'styled-components';
import { DetailedHTMLProps } from 'react';
import { FastOmit } from 'styled-components';
import { FC } from 'react';
import { FocusEvent as FocusEvent_2 } from 'react';
import { ForwardRefComponent } from 'framer-motion';
import { HTMLAttributes } from 'react';
import { HTMLInputAutoCompleteAttribute } from 'react';
import { HTMLMotionProps } from 'framer-motion';
import { IStyledComponentBase } from 'styled-components/dist/types';
import { JSX } from 'react/jsx-runtime';
import { KeyboardEventHandler } from 'react';
import { LiHTMLAttributes } from 'react';
import { MemoExoticComponent } from 'react';
import { MouseEventHandler } from 'react';
import { ReactNode } from 'react';
import { Ref } from 'react';
import { RefAttributes } from 'react';
import { RefObject } from 'react';
import { Substitute } from 'styled-components/dist/types';

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

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

declare interface addErrorProps {
    error?: ErrorMessageProps;
}

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

declare interface addSXProps {
    sx?: SXProps;
}

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

declare type BaseTextAreaProps = CommonTextAreaProps & (ControlledValue | UncontrolledValue);

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

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

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 | null | undefined;
    defaultValue?: never;
};

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_2<Pick<SelectProps<ISelectItem>, 'genre' | 'size'> & {
    checked?: boolean;
}>;

export declare type DropdownListOptionProps = AddDollarSign_2<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_2<Pick<SelectProps<ISelectItem>, 'size'>>;

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

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

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

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 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;
}

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

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

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';

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

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

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

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;
    };
}

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';

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

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

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

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

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

export declare type SelectInputProps = AddDollarSign_2<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_2<Pick<SelectProps<ISelectItem>, 'genre' | 'size' | 'isCenter' | 'isNotShowHoverStyle' | 'isBold' | 'isWrapSelectOption' | 'isClearWhenClickSelectListOption' | 'isOnlyColorInSelectListOption'> & {
    item?: ISelectItem;
    isChecked?: boolean;
}>;

export declare type SelectListProps = AddDollarSign_2<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_2<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';
};

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

declare type TextAreaGenre = keyof IThemeGenreTextArea;

declare type TextAreaProps = AutoHeightTextAreaProps | ResizableTextAreaProps | FixedTextAreaProps;

export declare type TInputSelect = keyof IThemeGenreSelect;

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;
};

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

export { }