import * as React from 'react';
import { FC, ReactNode, DetailedHTMLProps, ImgHTMLAttributes, CSSProperties } from 'react';
import { BoxProps as BoxProps$1 } from '@mui/material/Box';
import { ResponsiveStyleValue } from '@mui/system/styleFunctionSx';
import { ButtonProps as ButtonProps$2 } from '@mui/material/Button';
import { IconButtonProps as IconButtonProps$1, CardProps, CheckboxProps, RadioProps, SliderProps as SliderProps$1 } from '@mui/material';
import * as react_apexcharts from 'react-apexcharts';
import { FormControlLabelProps } from '@mui/material/FormControlLabel/FormControlLabel';
import { BoxProps as BoxProps$2 } from '@mui/material/Box/Box';
import { DialogProps as DialogProps$1 } from '@mui/material/Dialog';
import { GridProps as GridProps$1, GridSize } from '@mui/material/Grid';
import { SvgIconProps } from '@mui/material/SvgIcon';
import { StandardLonghandProperties } from 'csstype';
import { PaginationProps } from '@mui/material/Pagination';
import { SkeletonProps } from '@mui/material/Skeleton';
import { SliderProps } from '@mui/material/Slider';
import * as notistack from 'notistack';
import { OptionsObject as OptionsObject$1 } from 'notistack';
import { SwitchProps } from '@mui/material/Switch';
import { TabsProps as TabsProps$1 } from '@mui/material/Tabs';
import { TabProps as TabProps$1 } from '@mui/material/Tab';
import { TextFieldProps as TextFieldProps$1 } from '@mui/material/TextField';
import { TypographyProps } from '@mui/material/Typography';
import { TooltipProps as TooltipProps$1 } from '@mui/material/Tooltip';
import { TypographyProps as TypographyProps$1 } from '@mui/material/Typography/Typography';
import { AbstractConnector } from '@web3-react/abstract-connector';
import { ChainNames } from '@web3chief/sdk/config/network';
import * as _mui_styled_engine from '@mui/styled-engine';
import * as _mui_material_styles from '@mui/material/styles';
import { OverridableStringUnion } from '@mui/types';
import { BreakpointOverrides } from '@mui/system/createTheme/createBreakpoints';

declare type AlertProps = {
    variant: string;
};
declare const Alert: FC<AlertProps>;

declare type AvatarsProps$1 = {
    avatarUrl: string;
    level?: string | number;
};
declare const Avatar: FC<AvatarsProps$1>;

declare type AvatarsProps = {
    avatarUrl: string;
};
declare const AvatarProfile: FC<AvatarsProps>;

declare type SizeBadge = 'small' | 'medium';
declare const BadgeCustom: FC<{
    badge: string;
    color: string;
    size?: SizeBadge;
}>;

declare type BoxProps = BoxProps$1 & {
    background?: BoxProps$1['bgcolor'];
    mixBlendMode?: string;
    opacity?: number;
    cursor?: string;
    transform?: string;
    backdropFilter?: string;
    filter?: ResponsiveStyleValue<string>;
};
declare const Box: FC<BoxProps>;

declare type BannerProps = Pick<BoxProps, 'background' | 'height' | 'width'>;
declare const Banner: FC<BannerProps>;

declare const BannerContainer: FC<BannerProps>;

declare type ModalProps = ReturnType<typeof useModal>;
declare function useModal(value?: boolean): {
    isOpen: boolean;
    openModal: () => void;
    closeModal: () => void;
    toggleModal: () => void;
};

interface BaseModalProps {
    text: string;
    textButton: string;
    title: string;
    onClick: () => void;
    loadingButton?: boolean;
}
declare const BaseModal: FC<Pick<ModalProps, 'isOpen' | 'closeModal'> & BaseModalProps>;

interface BigNftBoxProps {
    image: string;
    background?: string;
    soldOut?: boolean;
}

declare type ButtonProps$1 = ButtonProps$2 & {
    loading?: boolean;
};
declare const Button: FC<ButtonProps$1>;

declare type IconButtonProps = IconButtonProps$1 & {
    variant: 'text' | 'contained' | 'square';
};
declare const IconButton: FC<IconButtonProps>;

declare type MenuButtonProps = ButtonProps$2 & {
    isActive?: boolean;
};
declare const MenuButton: FC<MenuButtonProps>;

interface BuyTokenModalProps {
    isOpen: boolean;
    closeModal: () => void;
    buttons?: {
        icon: ReactNode;
        link: string;
        name: string;
    }[];
    links?: {
        name: string;
        link: string;
    }[];
}
declare const BuyTokenModal: FC<BuyTokenModalProps>;

declare const Cross: FC<BoxProps>;
declare const Card: FC<CardProps>;
declare const PopupCard: FC<CardProps>;
declare const CornerBox: FC<BoxProps>;
declare const CrossBox: FC<BoxProps>;

declare const Chart: React.ComponentType<react_apexcharts.Props>;

declare const Checkbox: FC<CheckboxProps>;

declare type CheckboxFormControlLabelProps = Omit<FormControlLabelProps, 'control'>;
declare const CheckboxFormControlLabel: FC<CheckboxFormControlLabelProps>;

declare type ButtonProps = {
    icon: ReactNode;
    name: string;
    link: string;
    color: string;
};
declare type CommunityProps = BoxProps$2 & {
    title: string;
    images: BoxProps$2['bgcolor'];
    buttons: ButtonProps[];
};
declare const Community: FC<CommunityProps>;

declare type DialogProps = DialogProps$1;
declare const Dialog: FC<DialogProps>;

interface ForgotPasswordProps {
    title: string;
    descriptionAboutCode?: string;
    securityCodeInput?: boolean;
    ruleDescription?: string;
    timerMessage?: string;
    email?: string;
    securityButton?: {
        title: string;
        onClick: () => void;
    };
    submitButton?: {
        title: string;
        onClick: () => void;
    };
    signUpControl?: {
        description: string;
        title: string;
        onClick: () => void;
    };
    closeModal: () => void;
    isOpen: boolean;
}
declare const ForgotPassword: FC<ForgotPasswordProps>;

declare type GridProps = GridProps$1 & {
    xxl?: boolean | GridSize;
    xxxl?: boolean | GridSize;
};
declare const Grid: FC<GridProps>;

declare const InventoryContainer: FC;

declare const AppleLogo: FC<SvgIconProps>;

declare const ArmIcon: FC<SvgIconProps>;

declare const ArrowRightIcon: FC<SvgIconProps>;

declare const ArrowTabsIcon: FC<SvgIconProps>;

declare const AvatarDefault: FC<SvgIconProps>;

declare const AvaxWalletIcon: FC<SvgIconProps>;

declare const BinanceChainIcon: FC<SvgIconProps>;

declare const BinanceUsd: FC<SvgIconProps>;

declare const BinanceUsd2: FC<SvgIconProps>;

declare const BnbIcon: FC<SvgIconProps>;

declare const BnbWalletIcon: FC<SvgIconProps>;

declare const BorderIcon: FC<SvgIconProps>;

declare const BoxIcon: FC<SvgIconProps>;

declare const BoxIcon2: FC<SvgIconProps>;

declare const BurgerIcon: FC<SvgIconProps>;

declare const ChevronLeftIcon: FC<SvgIconProps>;

declare const ChevronRightIcon: FC<SvgIconProps>;

declare const CircularProgress: FC<SvgIconProps>;

declare const CloseIcon: FC<SvgIconProps>;

declare const Coin98Icon: FC<SvgIconProps>;

declare const CoinbaseIcon: FC<SvgIconProps>;

declare const CollectionsIcon: FC<SvgIconProps>;

declare const CopyIcon: FC<SvgIconProps>;

declare const CornerAvatar: FC<SvgIconProps>;

declare const CornerComingSoon: FC<SvgIconProps>;

declare const CornerIcon: FC<SvgIconProps>;

declare const DisconnectIcon: FC<SvgIconProps>;

declare const DiscordIcon: FC<SvgIconProps>;

declare const DollarIcon: FC<SvgIconProps>;

declare const ErrorIcon: FC<SvgIconProps>;

declare const ExampleIcon: FC<SvgIconProps>;

declare const ExternalIcon: FC<SvgIconProps>;

declare const EyeIcon: FC<SvgIconProps>;

declare const FacebookIcon: FC<SvgIconProps>;

declare const FilterIcon: FC<SvgIconProps>;

declare const FlagUsaIcon: FC<SvgIconProps>;

declare const GoaIcon: FC<SvgIconProps>;

declare const HeroIcon: FC<SvgIconProps>;

declare const HeroIcon64: FC<SvgIconProps>;

declare const HumanIcon: FC<SvgIconProps>;

declare const IconLinkOn: FC<SvgIconProps>;

declare const InfoFillIcon: FC<SvgIconProps>;

declare const InfoOutlinedIcon: FC<SvgIconProps>;

declare const InventoryItemError: FC<SvgIconProps>;

declare const InventoryItemWarning: FC<SvgIconProps>;

declare const ItemIcon: FC<SvgIconProps>;

declare const KeyIcon: FC<SvgIconProps>;

declare const LockIcon: FC<SvgIconProps>;

declare const LockIcon2: FC<SvgIconProps>;

declare const LockIcon3: FC<SvgIconProps>;

declare const LogoIcon: FC<SvgIconProps>;

declare const LogoutIcon: FC<SvgIconProps>;

declare const MetamaskIcon: FC<SvgIconProps>;

declare const MinusIcon: FC<SvgIconProps>;

declare const MyProfilesIcon: FC<SvgIconProps>;

declare const PackIcon: FC<SvgIconProps>;

declare const PancakeIcon: FC<SvgIconProps>;

declare const PlayMarketLogo: FC<SvgIconProps>;

declare const PlusIcon: FC<SvgIconProps>;

declare const PlusIcon2: FC<SvgIconProps>;

declare const ProfileIcon: FC<SvgIconProps>;

declare const SafepalIcon: FC<SvgIconProps>;

declare const SearchIcon: FC<SvgIconProps>;

declare const SettingsIcon: FC<SvgIconProps>;

declare const ShareIcon: FC<SvgIconProps>;

declare const SpaceshipIcon: FC<SvgIconProps>;

declare const SuccessIcon: FC<SvgIconProps>;

declare const SupportIcon: FC<SvgIconProps>;

declare const SwordIcon: FC<SvgIconProps>;

declare const TankIcon: FC<SvgIconProps>;

declare const TelegramIcon: FC<SvgIconProps>;

declare const TokenPocketIcon: FC<SvgIconProps>;

declare const TrustIcon: FC<SvgIconProps>;

declare const TwitterIcon: FC<SvgIconProps>;

declare const TypeBoxIcon: FC<SvgIconProps>;

declare const TypeCarryIcon: FC<SvgIconProps>;

declare const TypeItemIcon: FC<SvgIconProps>;

declare const TypeOfPack: FC<SvgIconProps>;

declare const TypeSupportIcon: FC<SvgIconProps>;

declare const TypeTankIcon: FC<SvgIconProps>;

declare const UniswapIcon: FC<SvgIconProps>;

declare const UnlockIcon: FC<SvgIconProps>;

declare const UnlockIcon2: FC<SvgIconProps>;

declare const WalletConnectIcon: FC<SvgIconProps>;

declare const WalletIcon: FC<SvgIconProps>;

declare const WarningIcon: FC<SvgIconProps>;

declare const WarningWithBg: FC<SvgIconProps>;

declare type ImageFallbackProps = DetailedHTMLProps<ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement> & {
    objectFit?: StandardLonghandProperties['objectFit'];
    objectPosition?: StandardLonghandProperties['objectPosition'];
    fallbackImage?: string;
    layout?: 'fill';
};
declare const ImageFallback: FC<ImageFallbackProps>;

declare const Loader: () => JSX.Element;

interface ButtonPlayNowModalProps {
    icon: ReactNode;
    link?: string;
    name: string;
    comingSoon?: boolean;
}
interface PlayNowModalProps {
    isOpen: boolean;
    closeModal: () => void;
    buttons: ButtonPlayNowModalProps[];
}
declare const PlayNowModal: FC<PlayNowModalProps>;

declare type NewsBannerProps = {
    id: number;
    date: string;
    news: string;
    img: string;
};

declare type NewsProps = {
    newsArray: NewsBannerProps[];
};
declare const News: FC<NewsProps>;

declare const NonConnectorModal: FC<Pick<ModalProps, 'isOpen' | 'closeModal'>>;

declare const Notification: FC;

declare const Pagination: FC<PaginationProps>;

declare type PresaleProps = Pick<BoxProps, 'background' | 'height'> & {
    title: string;
    description: string;
    timer: {
        startTimestamp?: number;
        endTimestamp?: number | string;
    };
    loading?: boolean;
};
declare const Presale: FC<PresaleProps>;

declare const Radio: FC<RadioProps>;

declare type RadioFormControlLabelProps = Omit<FormControlLabelProps, 'control'>;
declare const RadioFormControlLabel: FC<RadioFormControlLabelProps>;

interface SignInProps {
    isOpen: boolean;
    closeModal: () => void;
}
declare const SignIn: FC<SignInProps>;

declare const Skeleton: FC<SkeletonProps>;

declare const Slider: FC<SliderProps>;

declare type SliderBoldProps = SliderProps$1 & {
    labelTitle: string;
    labelValue: string;
    value: number;
};
declare const SliderBold: FC<SliderBoldProps>;

interface SmallNftProps {
    standard: string;
    image: string;
    background?: string;
}

declare type OptionsObject = OptionsObject$1 & {
    message: string;
};
declare function useSnackbar(): {
    enqueueSnackbar: (message: notistack.SnackbarMessage, options?: OptionsObject$1 | undefined) => notistack.SnackbarKey;
    closeSnackbar: (key?: notistack.SnackbarKey | undefined) => void;
};

declare type SnackbarContentProps = Pick<ButtonProps$1, 'onClick'> & {
    variant: 'success' | 'error' | 'warning' | 'default' | 'info';
};
declare const SnackbarContent: FC<SnackbarContentProps>;
declare const SnackContent: (key: string, { message, variant }: OptionsObject) => JSX.Element;

declare const SnackbarProvider: FC;

declare const Switch: FC<SwitchProps>;

declare type SwitchFormControlLabelProps = Omit<FormControlLabelProps, 'control'>;
declare const SwitchFormControlLabel: FC<SwitchFormControlLabelProps>;

declare type TabsProps = TabsProps$1 & {
    size?: 'xs' | 'sm' | 'lg';
    tabs: Array<TabProps>;
    onChangeTab: (value: string) => void;
    currentTab: string;
};
declare type TabProps = TabProps$1 & {
    icon?: React.ReactElement | string;
    variant?: 'tinyTabs' | 'menu' | 'largeTabs';
};
declare const Tabs: FC<TabsProps>;

declare type AlignProps = {
    textalign?: string;
};
declare type TextFieldVariants = {
    variant?: 'filledCounter' | 'filled' | 'standard' | 'outlined';
};
declare type TextFieldProps = Omit<TextFieldProps$1, 'variant' | 'value'> & TextFieldVariants & AlignProps & {
    value: string | number;
};
declare const TextField: FC<TextFieldProps>;

interface TextRowProps {
    label: string;
    tooltip?: string;
    labelVariant?: TypographyProps['variant'];
    value: string;
    valueVariant?: TypographyProps['variant'];
    valueColor?: TypographyProps['color'];
    subValue?: string;
    subValueVariant?: TypographyProps['variant'];
    icon?: ReactNode;
    liner?: boolean;
    isLoading?: boolean;
}
declare const TextRow: FC<TextRowProps>;

declare type TimerProps = {
    startTimestamp?: number;
    endTimestamp?: number | string;
    loading?: boolean;
};

declare type TokenVestingBoardProps = {
    totalValue: string | number;
    token: string;
    currentValue: string;
};
declare const TokenVestingBoard: FC<TokenVestingBoardProps>;

declare type TokenVestingCardProps = {
    title: string;
    value: string;
};
declare const TokenVestingCard: FC<TokenVestingCardProps>;

declare type TokenVestingTimerCardProps = {
    time: string;
    value: string;
    progress: number;
};
declare const TokenVestingTimerCard: FC<TokenVestingTimerCardProps>;

declare type TooltipProps = Omit<TooltipProps$1, 'title' | 'children'> & {
    typographyProps?: TypographyProps$1;
    icon?: FC<SvgIconProps>;
    label?: React.ReactNode;
} & Pick<SvgIconProps, 'fontSize'>;
declare const Tooltip: FC<TooltipProps>;

declare type WalletItemProps = {
    id?: number;
    icon?: FC<SvgIconProps>;
    name?: string;
    description?: string;
    count?: number | string;
    usd?: number | string;
};
declare const WalletItem: FC<WalletItemProps>;

declare type ConnectorNames = 'metamask' | 'coinbase' | 'coin98' | 'trustWallet' | 'tokenPocket' | 'walletConnect' | 'binance' | 'safePal';
declare type ConnectorConfig = {
    type: ConnectorNames;
    title: string;
    createConnector: (chainID: ChainNames) => AbstractConnector;
};

declare type WalletModalProps = Pick<ModalProps, 'isOpen' | 'closeModal'> & {
    walletsData: ConnectorConfig[];
    onClickWallet: (walletData: ConnectorConfig) => void;
};
declare const WalletModal: FC<WalletModalProps>;

declare type BreakpointUpdate = OverridableStringUnion<'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl' | 'xxxl', BreakpointOverrides>;
declare function useBreakpoint(): BreakpointUpdate;

declare function useCopyClipboard(): {
    handleCopy: (copyText?: string) => void;
};

declare function usePagination(page: number, list: Array<any>, perPage: number): Array<any>;

declare function useSqareicon(address?: string): string;

declare const HistoryContext: React.Context<string[]>;

interface WarningModalProps {
    text?: string;
    buttons?: ReactNode[];
    title?: string;
    contentVariant?: any;
}
declare const WarningModal: FC<Pick<ModalProps, 'isOpen' | 'closeModal'> & WarningModalProps>;

declare module '@mui/material/Typography' {
    interface TypographyPropsVariantOverrides {
        h1alt: true;
        h7: true;
        h8: true;
        counter: true;
        subtitle0: true;
        subtitle1alt: true;
        subtitle2alt: true;
        subtitle3: true;
        subtitle3alt: true;
        subtitle4: true;
        subtitle4alt: true;
        subtitle5: true;
        subtitle6: true;
        menu: true;
        menuAlt: true;
        menu2alt: true;
        largeTabs: true;
        tinyTabs: true;
        buttonSmall: true;
        buttonBig: true;
        modalTitle: true;
        tierSmall: true;
        tierLarge: true;
        timersubtitle: true;
        subtitle2altadaptive: true;
    }
}
declare module '@mui/material/SvgIcon' {
    interface SvgIconPropsSizeOverrides {
        xlarge: true;
        xsmall: true;
        xxsmall: true;
        xxxsmall: true;
        xmedium: true;
        xxlarge: true;
    }
    interface SvgIconPropsColorOverrides {
        third: true;
        warningAlt: true;
    }
}
declare module '@mui/material/TextField' {
    interface TextFieldPropsSizeOverrides {
        big: true;
        filledCounter: true;
        large: true;
        number: true;
    }
}
declare module '@mui/material/InputBase' {
    interface InputBasePropsSizeOverrides {
        large: true;
    }
}
declare module '@mui/material/styles' {
    interface PaletteOptions {
        paper?: {
            cross?: string;
            bg?: string;
        };
        itemRarity?: {
            common?: string;
            rare?: string;
            epic?: string;
            elite?: string;
            legendary?: string;
        };
        boxType?: {
            basic?: string;
            starter?: string;
            enhanced?: string;
            limited?: string;
            deluxe?: string;
            promo?: string;
        };
        controls: {
            bg: string;
        };
        menu: {
            bg: string;
        };
        alpha: {
            5: string;
            8: string;
            10: string;
            12: string;
            20: string;
            30: string;
            40: string;
            60: string;
        };
    }
    interface TypeBackground {
        secondary: string;
    }
    interface TypeText {
        icon: string;
        altPrimary: string;
        third: string;
        action: string;
    }
    interface TypographyVariantsOptions {
        h1alt?: CSSProperties;
        h7?: CSSProperties;
        h8?: CSSProperties;
        counter?: CSSProperties;
        subtitle0?: CSSProperties;
        subtitle1alt?: CSSProperties;
        subtitle2alt?: CSSProperties;
        subtitle3?: CSSProperties;
        subtitle3alt?: CSSProperties;
        subtitle4?: CSSProperties;
        subtitle4alt?: CSSProperties;
        subtitle5?: CSSProperties;
        subtitle6?: CSSProperties;
        menu?: CSSProperties;
        menuAlt?: CSSProperties;
        menu2alt?: CSSProperties;
        largeTabs?: CSSProperties;
        tinyTabs?: CSSProperties;
        buttonSmall?: CSSProperties;
        buttonBig?: CSSProperties;
        modalTitle?: CSSProperties;
        tierSmall?: CSSProperties;
        tierLarge?: CSSProperties;
        timersubtitle?: CSSProperties;
        subtitle2altadaptive?: CSSProperties;
    }
}
declare module '@mui/material/styles' {
    interface BreakpointOverrides {
        xs: true;
        sm: true;
        md: true;
        lg: true;
        xl: true;
        xxl: true;
        xxxl: true;
        container: true;
    }
    interface Theme {
        palette: typeof palette;
    }
}
declare module '@mui/material/Button' {
    interface ButtonPropsVariantOverrides {
        action: true;
        simple: true;
        base: true;
        menuActive: true;
    }
    interface ButtonPropsSizeOverrides {
        xsmall: true;
    }
}
declare module '@mui/material/Skeleton' {
    interface SkeletonPropsVariantOverrides {
        radius: true;
    }
}
declare module '@mui/material/Slider' {
    interface SliderPropsSizeOverrides {
        large: true;
    }
}
declare const palette: {
    mode: "dark";
    background: {
        default: string;
        secondary: string;
    };
    controls: {
        bg: string;
    };
    menu: {
        bg: string;
        bgOpacity: string;
    };
    paper: {
        bg: string;
        cross: string;
    };
    primary: {
        main: string;
        dark: string;
    };
    secondary: {
        main: string;
    };
    text: {
        primary: string;
        secondary: string;
        third: string;
        altPrimary: string;
        icon: string;
        action: string;
    };
    success: {
        main: string;
        light: string;
    };
    warning: {
        main: string;
        light: string;
    };
    info: {
        main: string;
    };
    error: {
        main: string;
        light: string;
    };
    itemRarity: {
        common: string;
        rare: string;
        epic: string;
        elite: string;
        legendary: string;
    };
    boxType: {
        basic: string;
        starter: string;
        enhanced: string;
        limited: string;
        deluxe: string;
    };
    nftBoxType: {
        basic: string;
        starter: string;
        enhanced: string;
        limited: string;
        deluxe: string;
    };
    alpha: {
        4: string;
        5: string;
        8: string;
        10: string;
        12: string;
        20: string;
        24: string;
        30: string;
        40: string;
        60: string;
    };
    chart: {
        axis: string;
    };
};
declare type Theme = typeof darkTheme & typeof themeOptions;
declare const themeOptions: {
    breakpoints: _mui_material_styles.Breakpoints;
    typography: {
        fontFamily: string;
        h1: {
            [x: string]: string | number | {
                fontSize: string;
                lineHeight?: undefined;
            } | {
                fontSize: string;
                lineHeight: number;
            };
            fontFamily: string;
            fontSize: string;
            lineHeight: number;
            fontWeight: number;
        };
        h2: {
            [x: string]: string | number | {
                fontSize: string;
                lineHeight: number;
            };
            fontFamily: string;
            fontSize: string;
            lineHeight: number;
            fontWeight: number;
        };
        h3: {
            [x: string]: string | number | {
                fontSize: string;
                lineHeight: number;
            };
            fontFamily: string;
            lineHeight: number;
            fontSize: string;
            fontWeight: number;
        };
        h4: {
            [x: string]: string | number | {
                fontSize: string;
                lineHeight: number;
            };
            fontFamily: string;
            fontSize: string;
            lineHeight: number;
            fontWeight: number;
        };
        h5: {
            [x: string]: string | number | {
                fontSize: string;
                lineHeight: number;
            };
            fontFamily: string;
            fontSize: string;
            lineHeight: number;
            fontWeight: number;
        };
        h6: {
            [x: string]: string | number | {
                fontSize: string;
                lineHeight: number;
            };
            fontFamily: string;
            textTransform: string;
            fontSize: string;
            lineHeight: number;
            fontWeight: number;
        };
        h7: {
            fontFamily: string;
            textTransform: string;
            fontSize: string;
            lineHeight: number;
            fontWeight: number;
        };
        h8: {
            fontFamily: string;
            textTransform: string;
            fontSize: string;
            lineHeight: number;
            fontWeight: number;
        };
        counter: {
            fontFamily: string;
            fontSize: string;
            lineHeight: number;
            fontWeight: number;
        };
        subtitle0: {
            [x: string]: string | number | {
                fontSize: string;
            };
            fontWeight: number;
            fontSize: string;
            lineHeight: number;
        };
        subtitle1: {
            fontWeight: number;
            fontSize: string;
            lineHeight: number;
            color: string;
        };
        subtitle1alt: {
            fontWeight: number;
            fontSize: string;
            lineHeight: number;
            color: string;
        };
        subtitle2: {
            fontWeight: number;
            fontSize: string;
            lineHeight: number;
        };
        subtitle2alt: {
            fontWeight: number;
            fontSize: string;
            lineHeight: number;
        };
        subtitle2altadaptive: {
            [x: string]: string | number | {
                fontWeight: number;
                fontSize: string;
                lineHeight: number;
            };
            fontWeight: number;
            fontSize: string;
            lineHeight: number;
        };
        menu: {
            fontWeight: number;
            fontSize: string;
            lineHeight: number;
            letterSpacing: string;
        };
        menuAlt: {
            fontWeight: number;
            fontSize: string;
            lineHeight: number;
            textTransform: string;
            letterSpacing: string;
        };
        menu2alt: {
            [x: string]: string | number | {
                fontSize: string;
            };
            fontWeight: number;
            fontSize: string;
            lineHeight: number;
        };
        subtitle3: {
            fontSize: string;
            lineHeight: number;
            fontWeight: number;
        };
        subtitle3alt: {
            fontSize: string;
            lineHeight: number;
            fontWeight: number;
        };
        timersubtitle: {
            fontSize: string;
            fontWeight: number;
            lineHeight: number;
            textTransform: string;
        };
        subtitle4: {
            fontSize: string;
            fontWeight: number;
            lineHeight: number;
        };
        subtitle4alt: {
            fontSize: string;
            fontWeight: number;
            lineHeight: number;
            letterSpacing: string;
        };
        subtitle5: {
            fontSize: string;
            fontWeight: number;
            lineHeight: number;
        };
        subtitle6: {
            fontSize: string;
            fontWeight: number;
            lineHeight: number;
        };
        button: {
            letterSpacing: string;
        };
        buttonBig: {
            fontSize: string;
            fontWeight: number;
            letterSpacing: string;
            lineHeight: number;
        };
        buttonSmall: {
            fontSize: string;
            fontWeight: number;
            letterSpacing: string;
            lineHeight: number;
        };
        largeTabs: {
            fontWeight: number;
            fontSize: string;
            lineHeight: number;
            textTransform: string;
            letterSpacing: string;
        };
        tinyTabs: {
            fontWeight: number;
            fontSize: string;
            lineHeight: number;
            textTransform: string;
            letterSpacing: string;
        };
        modalTitle: {
            fontFamily: string;
            fontWeight: number;
            fontSize: string;
            lineHeight: number;
        };
        tierLarge: {
            [x: string]: string | number | {
                fontSize: string;
                lineHeight: number;
            };
            fontFamily: string;
            textTransform: string;
            fontSize: string;
            lineHeight: number;
            fontWeight: number;
        };
        tierSmall: {
            fontFamily: string;
            textTransform: string;
            fontSize: string;
            lineHeight: number;
            fontWeight: number;
        };
    };
    palette: {
        mode: "dark";
        background: {
            default: string;
            secondary: string;
        };
        controls: {
            bg: string;
        };
        menu: {
            bg: string;
            bgOpacity: string;
        };
        paper: {
            bg: string;
            cross: string;
        };
        primary: {
            main: string;
            dark: string;
        };
        secondary: {
            main: string;
        };
        text: {
            primary: string;
            secondary: string;
            third: string;
            altPrimary: string;
            icon: string;
            action: string;
        };
        success: {
            main: string;
            light: string;
        };
        warning: {
            main: string;
            light: string;
        };
        info: {
            main: string;
        };
        error: {
            main: string;
            light: string;
        };
        itemRarity: {
            common: string;
            rare: string;
            epic: string;
            elite: string;
            legendary: string;
        };
        boxType: {
            basic: string;
            starter: string;
            enhanced: string;
            limited: string;
            deluxe: string;
        };
        nftBoxType: {
            basic: string;
            starter: string;
            enhanced: string;
            limited: string;
            deluxe: string;
        };
        alpha: {
            4: string;
            5: string;
            8: string;
            10: string;
            12: string;
            20: string;
            24: string;
            30: string;
            40: string;
            60: string;
        };
        chart: {
            axis: string;
        };
    };
    shape: {
        borderRadius: number;
    };
    components: {
        MuiCssBaseline: {
            styleOverrides: string;
        };
        MuiUseMediaQuery: {
            defaultProps: {
                noSsr: boolean;
            };
        };
        MuiButtonBase: {
            defaultProps: {
                disableRipple: boolean;
            };
        };
        MuiButton: {
            defaultProps: {
                disableFocusRipple: boolean;
                variant: string;
                disableElevation: boolean;
                size: string;
            };
            variants: ({
                props: {
                    variant: string;
                    size?: undefined;
                };
                style: _mui_styled_engine.CSSObject;
            } | {
                props: {
                    variant: string;
                    size: string;
                };
                style: _mui_styled_engine.CSSObject;
            })[];
            styleOverrides: {
                root: _mui_styled_engine.CSSObject;
                sizeXsmall: _mui_styled_engine.CSSObject;
                sizeLarge: _mui_styled_engine.CSSObject;
                sizeMedium: _mui_styled_engine.CSSObject;
                sizeSmall: _mui_styled_engine.CSSObject;
                containedPrimary: _mui_styled_engine.CSSObject;
                outlinedPrimary: _mui_styled_engine.CSSObject;
                textPrimary: _mui_styled_engine.CSSObject;
            };
        };
        MuiIconButton: {
            defaultProps: any;
            variants: ({
                props: any;
                style: {
                    background: string;
                    borderRadius: string;
                };
            } | {
                props: any;
                style: {
                    background: string;
                    borderRadius?: undefined;
                };
            })[];
            styleOverrides: {
                root: _mui_styled_engine.CSSObject;
                sizeMedium: _mui_styled_engine.CSSObject;
                sizeSmall: _mui_styled_engine.CSSObject;
            };
        };
        MuiAppBar: {
            defaultProps: {
                elevation: number;
            };
            styleOverrides: {
                root: _mui_styled_engine.CSSObject;
            };
        };
        MuiToolbar: {
            styleOverrides: {
                root: _mui_styled_engine.CSSObject;
            };
        };
        MuiContainer: {
            defaultProps: {
                maxWidth: string;
            };
            styleOverrides: {
                root: _mui_styled_engine.CSSObject;
            };
        };
        MuiCard: {
            defaultProps: {
                variant: string;
                square: boolean;
            };
            styleOverrides: {
                root: _mui_styled_engine.CSSObject;
            };
        };
        MuiTypography: {
            styleOverrides: {
                subtitle1: _mui_styled_engine.CSSObject;
            };
        };
        MuiTextField: {
            styleOverrides: {
                root: _mui_styled_engine.CSSObject;
            };
            variants: ({
                props: any;
                style: {
                    input: {
                        fontSize: string;
                        fontWeight?: undefined;
                    };
                    '& .MuiInputBase-root.MuiInputBase-formControl'?: undefined;
                };
            } | {
                props: any;
                style: {
                    input: {
                        fontSize: string;
                        fontWeight: number;
                    };
                    '& .MuiInputBase-root.MuiInputBase-formControl': {
                        paddingBottom: number;
                        paddingTop: number;
                    };
                };
            } | {
                props: {
                    variant: string;
                    size?: undefined;
                };
                style: _mui_styled_engine.CSSObject;
            } | {
                props: {
                    size: string;
                    variant?: undefined;
                };
                style: _mui_styled_engine.CSSObject;
            })[];
        };
        MuiFormControl: {
            styleOverrides: {
                root: _mui_styled_engine.CSSObject;
            };
        };
        MuiFormHelperText: {
            styleOverrides: {
                root: _mui_styled_engine.CSSObject;
            };
        };
        MuiLink: {
            defaultProps: {
                variant: string;
                underline: string;
            };
            variants: {
                props: {
                    variant: string;
                };
                style: _mui_styled_engine.CSSObject;
            }[];
            styleOverrides: {
                root: _mui_styled_engine.CSSObject;
            };
        };
        MuiDialogTitle: {
            styleOverrides: {
                root: _mui_styled_engine.CSSObject;
            };
        };
        MuiDialog: {
            defaultProps: {
                maxWidth: string;
                fullScreen: boolean;
                fullWidth: boolean;
            };
            styleOverrides: {
                paper: _mui_styled_engine.CSSObject;
                container: {
                    height: string;
                    overflow: string;
                    alignItems: string;
                };
                paperWidthSm: {
                    width: string;
                };
            };
            variants: {
                props: {
                    maxWidth: string;
                };
                style: {
                    '& .MuiPaper-root': {
                        maxWidth: number;
                    };
                };
            }[];
        };
        MuiGrid: {
            defaultProps: {
                columns: {
                    xs: number;
                    sm: number;
                    md: number;
                    lg: number;
                    xl: number;
                    xxl: number;
                };
                spacing: {
                    xs: number;
                    sm: number;
                    md: number;
                    lg: number;
                    xl: number;
                    xxl: number;
                };
            };
            styleOverrides: {
                container: _mui_styled_engine.CSSObject;
            };
        };
        MuiTooltip: {
            styleOverrides: {
                tooltip: {
                    padding: number;
                    background: string;
                };
                tooltipPlacementBottom: {
                    marginTop: string;
                };
            };
        };
        MuiSvgIcon: {
            defaultProps: {
                fontSize: string;
            };
            styleOverrides: {
                fontSizeXxxsmall: _mui_styled_engine.CSSObject;
                fontSizeXxsmall: _mui_styled_engine.CSSObject;
                fontSizeXsmall: _mui_styled_engine.CSSObject;
                fontSizeSmall: _mui_styled_engine.CSSObject;
                fontSizeMedium: _mui_styled_engine.CSSObject;
                fontSizeXmedium: _mui_styled_engine.CSSObject;
                fontSizeLarge: _mui_styled_engine.CSSObject;
                fontSizeXlarge: _mui_styled_engine.CSSObject;
                fontSizeXxlarge: _mui_styled_engine.CSSObject;
                colorThird: _mui_styled_engine.CSSObject;
                colorWarningAlt: _mui_styled_engine.CSSObject;
            };
        };
        MuiSwitch: {
            styleOverrides: {
                root: {
                    width: number;
                    height: number;
                    padding: number;
                    marginRight: number;
                    '&:hover': {
                        '.MuiSwitch-switchBase.Mui-checked + .MuiSwitch-track': {
                            backgroundColor: string;
                        };
                        '.MuiSwitch-switchBase + .MuiSwitch-track': {
                            backgroundColor: string;
                        };
                        '.MuiSwitch-switchBase.Mui-disabled + .MuiSwitch-track': {
                            backgroundColor: string;
                        };
                    };
                    '.MuiSwitch-switchBase': {
                        padding: number;
                        margin: number;
                        transitionDuration: string;
                        border: number;
                    };
                    '.MuiSwitch-switchBase.Mui-checked': {
                        transform: string;
                    };
                    '.MuiSwitch-switchBase.Mui-checked + .MuiSwitch-track': {
                        backgroundColor: string;
                        opacity: number;
                    };
                    '.MuiSwitch-switchBase.Mui-disabled + .MuiSwitch-track': {
                        opacity: number;
                    };
                    '.MuiSwitch-switchBase.Mui-checked.Mui-disabled + .MuiSwitch-track': {
                        backgroundColor: string;
                    };
                    '.Mui-disabled + .MuiSwitch-track': {
                        backgroundColor: string;
                    };
                    '.MuiSwitch-thumb': {
                        boxSizing: string;
                        width: number;
                        height: number;
                    };
                    '.MuiSwitch-track': {
                        borderRadius: string;
                        backgroundColor: string;
                        opacity: number;
                    };
                };
            };
        };
        MuiAccordion: {
            styleOverrides: {
                root: {
                    background: string;
                    boxShadow: string;
                };
            };
        };
        MuiAccordionSummary: {
            styleOverrides: {
                root: {
                    flexDirection: string;
                    padding: number;
                };
                expandIconWrapper: {
                    marginRight: string;
                };
            };
        };
        MuiAccordionDetails: {
            styleOverrides: {
                root: {
                    padding: string;
                    transition: string;
                    '&.active': {
                        background: string;
                    };
                };
            };
        };
        MuiDrawer: {
            styleOverrides: {
                root: {
                    width: string;
                    flexShrink: number;
                    top: number;
                    '& .MuiDrawer-paper': {
                        [x: string]: string | number | {
                            padding: string;
                        };
                        top: number;
                        width: string;
                        padding: string;
                        boxSizing: string;
                        background: string;
                    };
                };
            };
        };
        MuiBadge: {
            styleOverrides: {
                root: {
                    '& .MuiBadge-badge': {
                        background: string;
                        right: number;
                        top: number;
                        fontSize: string;
                        height: string;
                        minWidth: string;
                        padding: string;
                    };
                };
            };
        };
        MuiSelect: {
            styleOverrides: {
                root: {
                    '& .MuiSelect-select.MuiInputBase-input': {
                        background: string;
                        borderRadius: string;
                    };
                    '& .MuiSvgIcon-root': {
                        color: string;
                    };
                };
            };
            variants: ({
                props: {
                    size: string;
                    variant: string;
                };
                style: _mui_styled_engine.CSSObject;
            } | {
                props: {
                    size: string;
                    variant?: undefined;
                };
                style: _mui_styled_engine.CSSObject;
            })[];
        };
        MuiMenu: {
            styleOverrides: {
                root: {
                    '& .MuiPaper-root': {
                        backgroundColor: string;
                        borderRadius: string;
                    };
                };
            };
        };
        MuiPaper: {
            styleOverrides: {
                root: {
                    borderRadius: string;
                };
            };
        };
        MuiMenuItem: {
            styleOverrides: {
                root: {
                    '&.Mui-selected': {
                        backgroundColor: string;
                    };
                    '&.:hover': {
                        backgroundColor: string;
                    };
                };
            };
        };
        MuiTabs: {
            styleOverrides: {
                root: {
                    position: string;
                    alignItems: string;
                    '& .MuiBox-root:first-of-type': {
                        transform: string;
                        left: number;
                    };
                    '& .MuiBox-root:last-of-type': {
                        right: number;
                    };
                    '&:before': {
                        position: string;
                        background: string;
                        width: string;
                        height: string;
                        bottom: number;
                        content: string;
                        display: string;
                        zIndex: number;
                    };
                    '& .MuiTab-iconWrapper': {
                        opacity: number;
                    };
                    '& .MuiButtonBase-root': {
                        '&:hover': {
                            '& .MuiTab-iconWrapper': {
                                opacity: number;
                            };
                        };
                    };
                    '& .Mui-selected': {
                        '& .MuiTypography-root': {
                            color: string;
                        };
                        '& .MuiTab-iconWrapper': {
                            opacity: number;
                        };
                    };
                };
                indicator: {
                    backgroundColor: string;
                    height: string;
                };
                flexContainer: {
                    height: string;
                };
                scroller: {
                    '&:hover': {
                        '& .MuiTabs-indicator': {
                            backgroundColor: string;
                        };
                    };
                };
            };
        };
        MuiTab: {
            styleOverrides: {
                root: _mui_styled_engine.CSSObject;
                sizeLarge: _mui_styled_engine.CSSObject;
            };
            variants: {
                props: any;
                style: _mui_styled_engine.CSSObject;
            }[];
        };
        MuiTabPanel: {
            styleOverrides: {
                root: {
                    paddingRight: number;
                    paddingLeft: number;
                };
            };
        };
        MuiSlider: {
            styleOverrides: {
                root: {
                    height: string;
                    '& .MuiSlider-track': {
                        backgroundColor: string;
                        border: string;
                    };
                    '& .MuiSlider-rail': {
                        backgroundColor: string;
                    };
                };
                thumbColorPrimary: {
                    background: string;
                    width: number;
                    height: number;
                };
            };
            variants: {
                props: {
                    size: string;
                };
                style: _mui_styled_engine.CSSObject;
            }[];
        };
        MuiFormControlLabel: {
            styleOverrides: {
                label: {
                    fontSize: string;
                };
            };
        };
        MuiPaginationItem: {
            styleOverrides: {
                root: {
                    borderRadius: string;
                };
            };
        };
        MuiSkeleton: {
            variants: {
                props: any;
                style: _mui_styled_engine.CSSObject;
            }[];
        };
    };
};
declare const darkTheme: _mui_material_styles.Theme;

export { Alert, AppleLogo, ArmIcon, ArrowRightIcon, ArrowTabsIcon, Avatar, AvatarDefault, AvatarProfile, AvaxWalletIcon, BadgeCustom, Banner, BannerContainer, BannerProps, BaseModal, BaseModalProps, BigNftBoxProps, BinanceChainIcon, BinanceUsd, BinanceUsd2, BnbIcon, BnbWalletIcon, BorderIcon, Box, BoxIcon, BoxIcon2, BoxProps, BreakpointUpdate, BurgerIcon, Button, ButtonPlayNowModalProps, ButtonProps$1 as ButtonProps, BuyTokenModal, BuyTokenModalProps, Card, Chart, Checkbox, CheckboxFormControlLabel, CheckboxFormControlLabelProps, ChevronLeftIcon, ChevronRightIcon, CircularProgress, CloseIcon, Coin98Icon, CoinbaseIcon, CollectionsIcon, Community, CommunityProps, CopyIcon, CornerAvatar, CornerBox, CornerComingSoon, CornerIcon, Cross, CrossBox, Dialog, DialogProps, DisconnectIcon, DiscordIcon, DollarIcon, ErrorIcon, ExampleIcon, ExternalIcon, EyeIcon, FacebookIcon, FilterIcon, FlagUsaIcon, ForgotPassword, ForgotPasswordProps, GoaIcon, Grid, GridProps, HeroIcon, HeroIcon64, HistoryContext, HumanIcon, IconButton, IconButtonProps, IconLinkOn, ImageFallback, InfoFillIcon, InfoOutlinedIcon, InventoryContainer, InventoryItemError, InventoryItemWarning, ItemIcon, KeyIcon, Loader, LockIcon, LockIcon2, LockIcon3, LogoIcon, LogoutIcon, MenuButton, MenuButtonProps, MetamaskIcon, MinusIcon, ModalProps, MyProfilesIcon, News, NewsProps, NonConnectorModal, Notification, OptionsObject, PackIcon, Pagination, PancakeIcon, PlayMarketLogo, PlayNowModal, PlayNowModalProps, PlusIcon, PlusIcon2, PopupCard, Presale, PresaleProps, ProfileIcon, Radio, RadioFormControlLabel, RadioFormControlLabelProps, SafepalIcon, SearchIcon, SettingsIcon, ShareIcon, SignIn, SignInProps, Skeleton, Slider, SliderBold, SliderBoldProps, SmallNftProps, SnackContent, SnackbarContent, SnackbarProvider, SpaceshipIcon, SuccessIcon, SupportIcon, Switch, SwitchFormControlLabel, SwitchFormControlLabelProps, SwordIcon, TabProps, Tabs, TabsProps, TankIcon, TelegramIcon, TextField, TextFieldProps, TextRow, TextRowProps, Theme, TimerProps, TokenPocketIcon, TokenVestingBoard, TokenVestingBoardProps, TokenVestingCard, TokenVestingCardProps, TokenVestingTimerCard, TokenVestingTimerCardProps, Tooltip, TooltipProps, TrustIcon, TwitterIcon, TypeBoxIcon, TypeCarryIcon, TypeItemIcon, TypeOfPack, TypeSupportIcon, TypeTankIcon, UniswapIcon, UnlockIcon, UnlockIcon2, WalletConnectIcon, WalletIcon, WalletItem, WalletModal, WalletModalProps, WarningIcon, WarningModal, WarningModalProps, WarningWithBg, darkTheme, palette, useBreakpoint, useCopyClipboard, useModal, usePagination, useSnackbar, useSqareicon };
