@elacity-js/uikit/dist/types.d.ts

React / Material UI Design kit for Elacity project

/// <reference types="react" />
import * as React from 'react';
import React__default, { FC, ReactElement, ReactNode, CSSProperties, Context, MutableRefObject, PropsWithChildren } from 'react';
import * as _mui_material_OverridableComponent from '@mui/material/OverridableComponent';
import * as _mui_material from '@mui/material';
import * as _elacity_js_lib from '@elacity-js/lib';
import { IStorage, IUser, IAuth } from '@elacity-js/lib';
import { FormikHelpers, FormikErrors } from 'formik';
import * as _mui_material_styles from '@mui/material/styles';
import { Breakpoint, SxProps as SxProps$1, PaletteColor, Theme, ThemeOptions } from '@mui/material/styles';
import * as _mui_material_AccordionDetails from '@mui/material/AccordionDetails';
import * as _mui_material_ButtonBase_TouchRipple from '@mui/material/ButtonBase/TouchRipple';
import * as _mui_material_AccordionSummary from '@mui/material/AccordionSummary';
import * as _emotion_styled from '@emotion/styled';
import * as _mui_system from '@mui/system';
import { SxProps } from '@mui/system';
import { AccordionProps } from '@mui/material/Accordion';
import { AvatarProps } from '@mui/material/Avatar';
import { LinkProps as LinkProps$1 } from '@mui/material/Link';
import { LinkProps, NavLinkProps } from 'react-router-dom';
import { BoxProps } from '@mui/material/Box';
import { PaginationProps as PaginationProps$1 } from '@mui/material/Pagination';
import { SwitchProps } from '@mui/material/Switch';
import { PopoverProps } from '@mui/material/Popover';
import * as _mui_material_Button from '@mui/material/Button';
import { ButtonProps } from '@mui/material/Button';
import { LoadingButtonProps } from '@mui/lab/LoadingButton';
import { DropzoneOptions, FileRejection } from 'react-dropzone';
import { IconifyIcon } from '@iconify/react';

declare type ThemeValue = 'light' | 'dark';
interface IUserPreferences {
    theme?: ThemeValue;
    direction?: 'ltr' | 'rtl';
    lang?: string;
    walletProvider?: string | null;
    searchbar?: boolean;
    sidebarMinimized?: boolean;
}

declare const Logo: FC<any>;
interface FullLogoProps {
    size?: number;
    minimized?: boolean;
    responsive?: boolean;
}
declare const FullLogo: FC<FullLogoProps>;

declare const _default$q: _mui_material_OverridableComponent.OverridableComponent<_mui_material.SvgIconTypeMap<{}, "svg">> & {
    muiName: string;
};

declare const _default$p: _mui_material_OverridableComponent.OverridableComponent<_mui_material.SvgIconTypeMap<{}, "svg">> & {
    muiName: string;
};

declare const _default$o: _mui_material_OverridableComponent.OverridableComponent<_mui_material.SvgIconTypeMap<{}, "svg">> & {
    muiName: string;
};

declare const _default$n: _mui_material_OverridableComponent.OverridableComponent<_mui_material.SvgIconTypeMap<{}, "svg">> & {
    muiName: string;
};

declare const _default$m: _mui_material_OverridableComponent.OverridableComponent<_mui_material.SvgIconTypeMap<{}, "svg">> & {
    muiName: string;
};

declare const _default$l: ({ style }: {
    style: any;
}) => JSX.Element;

interface AppLinks {
    documentation?: string;
    socials?: {
        provider: string;
        url: string;
    }[];
}
interface LogoSet {
    primary: string;
    alt?: string;
    minimized?: string;
}
interface AppSettingsContextValue {
    appName: string;
    logo: LogoSet;
    links?: AppLinks;
    values: IUserPreferences;
    setValues: (v: Partial<IUserPreferences>) => void;
    load: () => void;
}
declare const defaultValues: IUserPreferences;
interface AppSettingsProviderProps {
    appName: string;
    logo: LogoSet;
    storage: IStorage<IUserPreferences>;
    links?: AppLinks;
}
declare const AppSettingsContext: React__default.Context<AppSettingsContextValue>;
declare const AppSettingsProvider: ({ appName, logo: _logo, links, storage, children, }: React__default.PropsWithChildren<AppSettingsProviderProps>) => JSX.Element;

interface AuthenticationContextValue<T, P extends IUser.ProfileBase<T>> extends IAuth.IConnector<T, P> {
}
declare const AuthenticationContext: React__default.Context<AuthenticationContextValue<any, IUser.ProfileBase<any>>>;

interface AuthenticationProviderProps<T, P extends IUser.ProfileBase<T>> {
    connector: IAuth.IConnector<T, P>;
}
declare const AuthenticationProvider: <T, P extends IUser.ProfileBase<T>>({ connector, children }: React__default.PropsWithChildren<AuthenticationProviderProps<T, P>>) => JSX.Element;

interface ProgressState {
    value?: number;
    label?: string | null;
}
interface ProgressUtil extends ProgressState {
    set: (label: string | null, value?: number) => void;
}
interface ModalOptionsProps<FormDataShape = any> {
    title?: string;
    maxWidth?: Breakpoint;
    centerActions?: boolean;
    okLabel?: string;
    onOk?: (values: FormDataShape, helpers?: FormikHelpers<FormDataShape>) => Promise<void> | void;
    Component: React__default.ComponentType;
    formData?: FormDataShape;
    formValidator?: (values: FormDataShape) => void | Promise<FormikErrors<FormDataShape>>;
    withProgress?: boolean;
    progress?: ProgressUtil;
    withoutLogo?: boolean;
    ActionsWrapper?: React__default.ComponentType<React__default.PropsWithChildren>;
    additionalActions?: React__default.ReactNode;
}
interface ModalContextValue {
    openModal: <T>(options: ModalOptionsProps<T>) => void;
    updateProgress?: ProgressUtil['set'];
    closeModal?: () => void;
}
declare const ModalContext: React__default.Context<ModalContextValue>;
interface ModalProviderProps {
}
declare const ModalProvider: React__default.FC<React__default.PropsWithChildren<ModalProviderProps>>;

declare const Accordion: _emotion_styled.StyledComponent<AccordionProps & _mui_system.MUIStyledCommonProps<_mui_material_styles.Theme>, {}, {}>;
declare const AccordionSummary: _emotion_styled.StyledComponent<{
    children?: React.ReactNode;
    classes?: Partial<_mui_material_AccordionSummary.AccordionSummaryClasses>;
    expandIcon?: React.ReactNode;
    sx?: _mui_material_styles.SxProps<_mui_material_styles.Theme>;
} & Omit<{
    action?: React.Ref<_mui_material.ButtonBaseActions>;
    centerRipple?: boolean;
    children?: React.ReactNode;
    classes?: Partial<_mui_material.ButtonBaseClasses>;
    disabled?: boolean;
    disableRipple?: boolean;
    disableTouchRipple?: boolean;
    focusRipple?: boolean;
    focusVisibleClassName?: string;
    LinkComponent?: React.ElementType<any>;
    onFocusVisible?: React.FocusEventHandler<any>;
    sx?: _mui_material_styles.SxProps<_mui_material_styles.Theme>;
    tabIndex?: number;
    TouchRippleProps?: Partial<_mui_material_ButtonBase_TouchRipple.TouchRippleProps>;
    touchRippleRef?: React.Ref<_mui_material_ButtonBase_TouchRipple.TouchRippleActions>;
}, "classes"> & _mui_material_OverridableComponent.CommonProps & Omit<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
    ref?: React.Ref<HTMLDivElement>;
}, "children" | "disabled" | "sx" | keyof _mui_material_OverridableComponent.CommonProps | "tabIndex" | "action" | "centerRipple" | "disableRipple" | "disableTouchRipple" | "focusRipple" | "focusVisibleClassName" | "LinkComponent" | "onFocusVisible" | "TouchRippleProps" | "touchRippleRef" | "expandIcon"> & _mui_system.MUIStyledCommonProps<_mui_material_styles.Theme>, {}, {}>;
declare const AccordionDetails: _emotion_styled.StyledComponent<_mui_material_AccordionDetails.AccordionDetailsProps & _mui_system.MUIStyledCommonProps<_mui_material_styles.Theme>, {}, {}>;
interface AccordionGroupProps {
    opened?: number | null;
    readonly?: boolean;
    allowMany?: boolean;
    elements: {
        title?: string | React.ReactNode;
        content: React.ReactNode;
    }[];
}
declare const AccordionGroup: React.FC<AccordionGroupProps>;

interface AppealProps {
    title?: string;
    subtitle?: string;
    label?: string;
    navigateTo?: string;
    Icon?: React__default.ComponentType;
}
declare const _default$k: ({ title, subtitle, label, children, navigateTo, Icon }: React__default.PropsWithChildren<AppealProps>) => JSX.Element;

interface ImageGracefullyLoadOptions {
    src?: string;
    fallbackImage?: string;
    errorImage?: string;
    retries?: number;
    retryInterval?: number;
    backoffFactor?: number;
    disabled?: boolean;
}
interface ImageProps extends React__default.ImgHTMLAttributes<HTMLImageElement> {
    processing?: boolean;
    retries?: number;
    retryInterval?: number;
    backoffFactor?: number;
}
declare const ImageComponent: ({ src, style, retries, retryInterval, backoffFactor, processing, ...props }: ImageProps) => JSX.Element;

declare const _default$j: ({ src, alt, sx, fallbackImage, errorImage, retries, retryInterval, backoffFactor, ...props }: AvatarProps & Omit<ImageGracefullyLoadOptions, 'src'>) => JSX.Element;

interface Props$2 {
    noMenu?: boolean;
    size?: number;
    label?: string;
    altLabel?: string;
}
declare function AccountPopover({ label, altLabel, noMenu, size, children }: React__default.PropsWithChildren<Props$2>): JSX.Element;
declare namespace AccountPopover {
    var defaultProps: {
        size: number;
        label: string;
        altLabel: string;
    };
}

interface FrostedBackground {
    src: string;
    leftOffset?: number;
    alt?: string;
}
declare const _default$i: ({ src, leftOffset, alt }: FrostedBackground) => JSX.Element;

interface FullScreenDialogProps {
    open?: boolean;
    onClose: () => void;
}
declare const _default$h: ({ open, onClose, children }: React.PropsWithChildren<FullScreenDialogProps>) => JSX.Element;

interface InlineInformationProps<T = unknown> {
    label: string;
    value?: T;
    sx?: SxProps;
    gutter?: number;
}
declare const _default$g: <T>({ label, value, sx, children, gutter }: React__default.PropsWithChildren<InlineInformationProps<T>>) => JSX.Element;

interface LikeButtonProps {
    likeCount?: number;
    isLiked?: boolean;
    handlers?: [() => void, () => void];
    sx?: SxProps;
}
declare const _default$f: ({ likeCount, isLiked, handlers, sx }: LikeButtonProps) => JSX.Element;

declare const RouterLink: React__default.ForwardRefExoticComponent<LinkProps & React__default.RefAttributes<HTMLAnchorElement>>;
declare const NavLink: ({ to, ...props }: NavLinkProps) => JSX.Element;
declare const Link: ({ href, ...props }: LinkProps$1) => JSX.Element;

interface Props$1 {
    width: string;
    children: ReactNode;
    alsoIf?: boolean;
}
declare const MHidden: ({ width, children, alsoIf }: Props$1) => ReactElement | null;

declare const _default$e: {
    Splash: React__default.FC<{}>;
    Dots: ({ ...props }: BoxProps<"div", {}>) => JSX.Element;
};

interface ListGroupProps<T> extends BoxProps {
    loading?: boolean;
    title?: string;
    assets: T[];
    hideEmpty?: boolean;
    keyExtractor: (item: T, index: number) => string;
    renderItem: (item: T) => React__default.ReactNode;
    EmptyComponent?: React__default.ComponentType;
    seeMoreLink?: string;
    seeMoreText?: string;
    containerSx?: BoxProps['sx'];
}
declare const _default$d: <T>({ loading, hideEmpty, title, assets, renderItem, keyExtractor, EmptyComponent, seeMoreLink, seeMoreText, containerSx, ...props }: ListGroupProps<T>) => JSX.Element;

interface MenuPopoverProps {
    open: boolean;
    width?: number | 'auto';
    onClose: () => void;
    anchorEl?: any;
    sx?: SxProps;
}
declare function MenuPopover({ children, sx, width, ...other }: React__default.PropsWithChildren<MenuPopoverProps>): JSX.Element;

interface NumberDeltaProps {
    from?: number;
    to?: number;
}
declare const NumberDelta: {
    ({ from, to }: NumberDeltaProps): JSX.Element;
    defaultProps: {
        from: number;
        to: number;
    };
};

interface NumberLabelProps extends BoxProps {
    value?: number;
    label: string;
    loading?: boolean;
    children?: React__default.ReactNode;
    minWidth?: number;
}
declare function NumberLabel({ value, label, loading, children, minWidth, ...props }: NumberLabelProps): JSX.Element;

declare const _default$c: _emotion_styled.StyledComponent<_mui_system.SystemProps<_mui_material.Theme> & {
    align?: "left" | "right" | "inherit" | "center" | "justify";
    children?: React.ReactNode;
    classes?: Partial<_mui_material.TypographyClasses>;
    gutterBottom?: boolean;
    noWrap?: boolean;
    paragraph?: boolean;
    sx?: _mui_material.SxProps<_mui_material.Theme>;
    variant?: "button" | "caption" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "inherit" | "overline" | "subtitle1" | "subtitle2" | "body1" | "body2";
    variantMapping?: Partial<Record<"button" | "caption" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "inherit" | "overline" | "subtitle1" | "subtitle2" | "body1" | "body2", string>>;
} & _mui_material_OverridableComponent.CommonProps & Omit<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "key" | keyof React.HTMLAttributes<HTMLSpanElement>> & {
    ref?: React.Ref<HTMLSpanElement>;
}, "children" | "sx" | keyof _mui_material_OverridableComponent.CommonProps | ("p" | "alignContent" | "alignItems" | "alignSelf" | "bottom" | "boxShadow" | "boxSizing" | "color" | "columnGap" | "display" | "flexBasis" | "flexDirection" | "flexGrow" | "flexShrink" | "flexWrap" | "fontFamily" | "fontSize" | "fontStyle" | "fontWeight" | "gridAutoColumns" | "gridAutoFlow" | "gridAutoRows" | "gridTemplateAreas" | "gridTemplateColumns" | "gridTemplateRows" | "height" | "justifyContent" | "justifyItems" | "justifySelf" | "left" | "letterSpacing" | "lineHeight" | "marginBottom" | "marginLeft" | "marginRight" | "marginTop" | "maxHeight" | "maxWidth" | "minHeight" | "minWidth" | "order" | "paddingBottom" | "paddingLeft" | "paddingRight" | "paddingTop" | "position" | "right" | "rowGap" | "textAlign" | "textOverflow" | "textTransform" | "top" | "visibility" | "whiteSpace" | "width" | "zIndex" | "border" | "borderBottom" | "borderColor" | "borderLeft" | "borderRadius" | "borderRight" | "borderTop" | "flex" | "gap" | "gridArea" | "gridColumn" | "gridRow" | "margin" | "overflow" | "padding" | "bgcolor" | "m" | "mt" | "mr" | "mb" | "ml" | "mx" | "marginX" | "my" | "marginY" | "pt" | "pr" | "pb" | "pl" | "px" | "paddingX" | "py" | "paddingY" | "typography" | "displayPrint") | "align" | "gutterBottom" | "noWrap" | "paragraph" | "variant" | "variantMapping"> & _mui_system.MUIStyledCommonProps<_mui_material.Theme>, {}, {}>;

interface PageProps {
    title: string;
}
declare const Page: FC<React__default.PropsWithChildren<PageProps>>;

interface PaginationProps extends PaginationProps$1 {
    perPage: number;
}
declare const _default$b: ({ perPage, ...props }: PaginationProps) => JSX.Element;

interface ScrollbarProps {
    sx: SxProps;
}
declare function Scrollbar({ children, sx, ...other }: React__default.PropsWithChildren<ScrollbarProps>): JSX.Element;

declare type StepStatuses = 'error' | 'finished' | 'ongoing';
interface StepProgressProps {
    open: boolean;
    onClose: () => void;
    isSubmitting: boolean;
    step: number;
    stepStatus: StepStatuses;
    steps: string[];
    stepsError: string[];
}
declare const StepProgress: React__default.FC<StepProgressProps>;

interface SwitchRadioProps extends SwitchProps {
    label?: string;
}
declare function SwitchRadio({ label, ...props }: SwitchRadioProps): JSX.Element;

interface ThemeSwitcherProps {
    value: ThemeValue;
    onChange?: (newValue: ThemeValue) => void;
}
declare const _default$a: ({ value, onChange }: ThemeSwitcherProps) => JSX.Element;

declare const _default$9: () => JSX.Element;

interface Route {
    title: string;
    path?: string;
    icon?: ReactElement;
    info?: string;
    external?: boolean;
    children?: Route[];
}
interface NavItemProps {
    item: Route;
    active?: (s: string) => boolean;
    anchorOrigin?: PopoverProps['anchorOrigin'];
    transformOrigin?: PopoverProps['transformOrigin'];
    style?: CSSProperties;
    id?: string;
}
interface SubmenuPopoverProps extends PopoverProps {
    id?: string;
    anchorEl: HTMLElement | null;
    sublistSx?: SxProps;
    sublistActiveSx?: SxProps;
    path: string;
    submenu?: Route['children'];
    active?: NavItemProps['active'];
}
interface VerticalNavItemProps {
    item: Route;
    active: (s: string) => boolean;
    minimized?: boolean;
}

interface VerticalMenuProps extends BoxProps {
    minimized?: boolean;
    menus: Route[];
}

interface HorizontalMenuProps {
    menus: Route[];
}

declare const getIcon: (name: string | IconifyIcon) => React__default.ReactElement;

declare const _default$8: {
    HorizontalMenu: ({ menus }: HorizontalMenuProps) => JSX.Element;
    VerticalMenu: ({ menus, minimized, ...other }: VerticalMenuProps) => JSX.Element;
    ItemMini: ({ item, active, anchorOrigin, transformOrigin, style, id }: NavItemProps) => JSX.Element;
};

interface MinifiableButtonProps extends ButtonProps {
    Icon: React__default.ComponentType;
}

interface MintButtonProps extends LoadingButtonProps {
    label?: string;
    onClick?: () => void;
    responsive?: boolean;
}

interface AnimateButtonProps extends ButtonProps {
    label: string;
    altLabel?: string;
}
declare function AnimateButton({ label, altLabel, ...props }: AnimateButtonProps): JSX.Element;

declare const _default$7: {
    Mint: ({ onClick, responsive, label, ...props }: MintButtonProps) => JSX.Element;
    Minifiable: ({ onClick, children, Icon, ...props }: MinifiableButtonProps) => JSX.Element;
    Animate: typeof AnimateButton;
    Standard: _mui_material.ExtendButtonBase<_mui_material_Button.ButtonTypeMap<{}, "button">>;
};

declare type FileType = 'image' | 'video' | '3d' | 'default';
declare type ViewMode = 'view' | 'fullscreen' | 'preview';
interface MediaPreviewProps {
    mode?: ViewMode;
    src: string;
    type: FileType;
    mimeType?: string;
    style?: CSSProperties;
    onClick?: React__default.MouseEventHandler<HTMLElement | HTMLDivElement>;
}
declare const _default$6: {
    Preview: {
        ({ src, type, style, mimeType, mode, onClick }: MediaPreviewProps): JSX.Element;
        defaultProps: {
            mode: string;
        };
    };
};

interface UploadProps extends DropzoneOptions {
    onDropped: (acceptedFiles: any) => void;
    onRejected?: (rejectedFiles: FileRejection[]) => void;
    sx?: SxProps;
    supportedFileDescription?: string;
    previewStyle?: CSSProperties;
}
interface InlineUploaderProps extends Omit<UploadProps, 'onDropped'> {
    initialValue?: any;
    sx?: any;
    hideName?: boolean;
    onDropped: (acceptedFile: File) => void;
    onMimeTypeAcquired?: (mimeType: string) => void;
}
declare const _default$5: {
    Base: React__default.FC<React__default.PropsWithChildren<UploadProps>>;
    Inline: React__default.FC<React__default.PropsWithChildren<InlineUploaderProps>>;
};

declare const buildContextHook: <T>(ContextValue: Context<T>, hookName: string, providerName: string) => () => T;

declare const useMounted: () => MutableRefObject<boolean>;

declare const useAppSettings: () => AppSettingsContextValue;

declare const useAuthentication: () => AuthenticationContextValue<any, _elacity_js_lib.IUser.ProfileBase<any>>;

declare const _default$4: ($el: HTMLElement | null, by: 'width' | 'height') => void;

declare const _default$3: <T>(value: T, delay: number) => T;

interface QueryResult<T> {
    isLoading?: boolean;
    total?: number;
    offset?: number;
    data?: T[];
    error?: Error;
    requestId?: string;
}
declare type QueryHook<T, Q> = (query: Q, options?: {
    skip?: boolean;
}) => QueryResult<T>;
interface InfiniteQueryParams<T, Q> {
    pageSize: number;
    index?: number;
    query: Q;
    useQuery: QueryHook<T, Q>;
    onRequestId?: (requestGroupId: string, requestId: string) => void;
}
declare const _default$2: <T, Q extends {
    from?: number;
    count?: number;
}>({ useQuery, query, index, pageSize, onRequestId, }: InfiniteQueryParams<T, Q>) => {
    ref: (node?: Element) => void;
    inView: boolean;
    data: T[];
    total: number;
    isLoading: boolean;
    requestId: string;
    currentPage: number;
    offset: number;
    rewindZero: () => void;
};

interface StickyElementOptions<T extends HTMLElement> {
    $el: T;
    /**
     * scroll position distance from top of the screen
     * to make the sticky state transition
     *
     * 0 or undefined mean the top of the screen
     */
    top?: number;
}
declare const _default$1: <T extends HTMLElement>({ $el, top }: StickyElementOptions<T>) => void;

interface WrapperProps {
    mt?: number;
    mx?: number;
}
declare const _default: _emotion_styled.StyledComponent<_mui_system.MUIStyledCommonProps<_mui_material_styles.Theme> & WrapperProps, React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

interface NavbarProps {
    onOpenSidebar?: () => void;
    minimizedSidebar?: boolean;
    shadowEffect?: boolean;
    menus?: Route[];
}
declare function Navbar({ onOpenSidebar, menus, shadowEffect, children }: React__default.PropsWithChildren<NavbarProps>): JSX.Element;
declare namespace Navbar {
    var defaultProps: {
        shadowEffect: boolean;
        menus: any[];
        onOpenSidebar: () => void;
    };
}

declare type FooterPosition = 'fixed' | 'relative' | 'absolute';
interface Props {
    sx?: SxProps$1;
    hideLeftFrom?: Breakpoint;
    position?: FooterPosition;
}
declare function FooterLayout({ sx, hideLeftFrom, position }: Props): JSX.Element;
declare namespace FooterLayout {
    var defaultProps: {
        position: string;
    };
}

interface LayoutProps {
    noPadding?: boolean;
    withBottomNav?: boolean;
    scrollToTop?: boolean;
    sidebar?: React__default.ReactNode;
    hiddenBottom?: React__default.ReactNode;
    Navbar?: React__default.ComponentType;
    Footer?: React__default.ComponentType;
}
declare function DefaultLayout({ sidebar, hiddenBottom, scrollToTop, Navbar, Footer, ...props }: LayoutProps): JSX.Element;
declare namespace DefaultLayout {
    var defaultProps: {
        Footer: typeof FooterLayout;
        Navbar: typeof Navbar;
    };
}

interface GlassyProperties {
    backgroundColor?: string;
    backdropFilter?: string;
    WebkitBackdropFilter?: string;
}
declare type GradientColorOption = string | [string, number];
declare module '@mui/material/Button' {
    interface ButtonPropsVariantOverrides {
        shape?: 'normal' | 'rounded' | 'square';
    }
}
declare module '@mui/material/styles' {
    interface LayoutSettings {
        appBarMobile?: number;
        appBarDesktop?: number;
        drawerWidth?: number;
        drawerWidthMin?: number;
        cardMobileXsWidth?: number;
    }
    interface ThemeOptions {
        layoutSettings?: LayoutSettings;
    }
    interface Palette {
        vivid: PaletteColor;
        vivid2: PaletteColor;
        badge1: PaletteColor;
    }
    interface PaletteOptions {
        vivid?: PaletteOptions['primary'];
        vivid2?: PaletteOptions['secondary'];
        badge1?: PaletteOptions['primary'];
    }
    interface TypeBackground {
        sidebar?: string;
    }
    interface Theme {
        glassy?: (background: string, value: number, blur: number) => GlassyProperties;
        gardientBackground?: (tilt: number, ...colors: GradientColorOption[]) => CSSProperties;
        gardientText?: (tilt: number, ...colors: GradientColorOption[]) => CSSProperties;
        radialRadientBackground?: (...colors: GradientColorOption[]) => CSSProperties;
        layoutSettings?: LayoutSettings;
    }
}
declare const themes: Record<ThemeValue, ThemeOptions>;
/**
 * Create a mui theme based on config and customization
 *
 * config: IUserPreferences {theme: 'light' | 'dark', direction: 'ltr' | 'rtl'}
 * customization: Record<'light' | 'dark', ThemeOptions>
 *
 * @showcase https://codesandbox.io/s/stoic-moon-y51cyz
 *
 * @param {*} config
 * @param {*} customization
 */
declare const createThemeWith: (config?: IUserPreferences, customization?: Partial<typeof themes>) => Theme;
interface ThemeProviderProps {
    customization?: Partial<typeof themes>;
}
declare const ThemeProvider: FC<PropsWithChildren<ThemeProviderProps>>;

export { Accordion, AccordionDetails, AccordionGroup, AccordionSummary, AccountPopover, AppSettingsContext, AppSettingsContextValue, AppSettingsProvider, _default$k as Appeal, AuthenticationContext, AuthenticationContextValue, AuthenticationProvider, AuthenticationProviderProps, _default$j as Avatar, _default$7 as Button, FooterLayout as DefaultFooter, DefaultLayout, Navbar as DefaultNavbar, _default as DefaultWrapper, _default$p as Discord, _default$q as Elastos, _default$n as Ethereum, FileType, _default$i as FrostedBackground, FullLogo, _default$h as FullscreenDialog, IUserPreferences, ImageComponent as Image, _default$g as InlineInformation, InlineUploaderProps, _default$l as KycMe, _default$f as LikeButton, Link, _default$d as ListGroup, Logo, MHidden, _default$6 as MediaViewer, _default$o as Medium, MenuPopover, ModalContext, ModalContextValue, ModalOptionsProps, ModalProvider, _default$8 as Nav, NavItemProps, NavLink, NumberDelta, NumberLabel, Page, _default$b as Paginate, Route, RouterLink, _default$9 as ScrollToTop, Scrollbar, _default$e as Spinner, StepProgress, SubmenuPopoverProps, SwitchRadio, _default$c as TextLabeled, ThemeProvider, _default$a as ThemeSwitcher, ThemeValue, _default$m as TokenUSDC, UploadProps, _default$5 as Uploader, VerticalNavItemProps, ViewMode, buildContextHook, createThemeWith, defaultValues, getIcon, useAppSettings, useAuthentication, _default$3 as useDebounce, _default$2 as useInfiniteQuery, useMounted, _default$4 as useSquareElement, _default$1 as useStickyElement };