import { Context } 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 { HTMLAttributes } from 'react';
import { IStyledComponentBase } from 'styled-components/dist/types';
import { PropsWithChildren } from 'react';
import { ReactNode } 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 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 interface addSXProps {
    sx?: SXProps;
}

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;

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

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 IThemeGenreDate = Record<Extract<IThemeGenreName, 'gray' | 'grayBorder' | 'blackBorder' | 'realebail-white'>, IThemeGenreTypeDate>;

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

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

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 IThemeGenreRange = Record<Extract<IThemeGenreName, 'gray' | 'grayBorder' | 'blackBorder' | 'realebail-white' | 'bustmarket-gray'>, IThemeGenreTypeRange>;

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

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

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

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

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 interface IThemeGenreTypeRange {
    thumb: {
        background: {
            rest: string;
            hover: string;
        };
        border: {
            rest: string;
            hover: string;
        };
    };
    track: {
        background: {
            rest: string;
        };
        gradient: {
            rest: 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 interface IThemeGenreTypeSonner {
    button: {
        genre: keyof IThemeGenre;
    };
    description: {
        color: string;
    };
    icon: {
        color: string;
    };
    title: {
        color: string;
    };
    wrapper: {
        background: string;
        borderColor: string;
        boxShadow: string;
        boxShadowHover: string;
    };
}

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

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 IThemeScreen = Record<IThemeDevice, {
    width: number;
}>;

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

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

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

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

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_2<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_2<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_2<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_2<Pick<ProviderSonnerProps, "position" | "zIndex" | "gap">>>>> & string;

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

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

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

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

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

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

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

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

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 useSonner: () => SonnerContextProps;

export { }