import { Area } from 'react-easy-crop';
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 { ForwardRefComponent } from 'framer-motion';
import { HTMLAttributes } from 'react';
import { HTMLMotionProps } from 'framer-motion';
import { IStyledComponentBase } from 'styled-components/dist/types';
import { JSX } from 'react/jsx-runtime';
import { PropsWithChildren } from 'react';
import { Ref } from 'react';
import { RefAttributes } from 'react';
import { RuleSet } from 'styled-components';
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 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']];

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

declare interface addSXProps {
    sx?: SXProps;
}

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

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;

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

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

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

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

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 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_2<Pick<ImageSelectProps, 'sx' | 'error' | 'genre' | 'size'>>;

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

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

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

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

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 interface IThemeGenreTypeDefault {
    background: {
        rest: string;
        hover: string;
    };
    border: {
        rest: string;
        hover: string;
    };
    color: {
        rest: string;
        hover: string;
        placeholder: string;
    };
}

declare interface IThemeGenreTypeImageSelect {
    background: {
        rest: string;
        hover: string;
    };
    border: {
        rest: string;
        hover: string;
    };
    color: {
        rest: string;
        hover: 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 interface IThemeSizePropertyDefault {
    font: number;
    height: number;
    heightIcon: number;
    padding: number;
    radius: number;
}

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

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

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

declare type TButtonGenre = keyof IThemeGenre;

export declare type TImageSelectGenre = keyof IThemeGenreImageSelect;

declare type TypographyAllProps = TypographyDataProps | TypographyVariantProps;

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 TypographySXProps = {
    default: TypographyAllProps;
} & {
    [K in IThemeDevice]?: TypographyAllProps;
};

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

export { }