@meduza-bank/ui-kit/dist/index.d.ts

UI Kit of the bank of Meme World "Peoples Bank Memes" or "Meduza Bank"

import * as React from 'react';
import React__default, { FunctionComponent, ExoticComponent, ReactNode, Dispatch, SetStateAction, FC, PropsWithChildren, MouseEventHandler, Component, ForwardRefRenderFunction, PropsWithoutRef, RefAttributes, ForwardRefExoticComponent, useLayoutEffect } from 'react';
import * as cva from 'cva';
import { VariantProps } from 'cva';
import { DayPicker } from 'react-day-picker';
import * as react_hook_form from 'react-hook-form';
import { UseFormRegisterReturn, FieldValues, FieldPath, ControllerProps } from 'react-hook-form';
import * as AvatarPrimitive from '@radix-ui/react-avatar';
import * as DialogPrimitive from '@radix-ui/react-dialog';
import { DialogProps, DialogTriggerProps } from '@radix-ui/react-dialog';
import { Command as Command$1 } from 'cmdk';
import { FileRejection, DropEvent } from 'react-dropzone';
import { Area } from 'react-easy-crop';
import * as vaul from 'vaul';
import { Drawer as Drawer$1 } from 'vaul';
import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
import * as _radix_ui_react_slot from '@radix-ui/react-slot';
import * as LabelPrimitive from '@radix-ui/react-label';
import * as HoverCardPrimitive from '@radix-ui/react-hover-card';
import * as input_otp from 'input-otp';
import * as NavigationMenuPrimitive from '@radix-ui/react-navigation-menu';
import * as PopoverPrimitive from '@radix-ui/react-popover';
import { ClassNameValue } from 'tailwind-merge';
import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
import * as SeparatorPrimitive from '@radix-ui/react-separator';
import * as SliderPrimitive from '@radix-ui/react-slider';
import { Toaster as Toaster$1 } from 'sonner';
import * as SwitchPrimitives from '@radix-ui/react-switch';
import { TextareaAutosizeProps } from 'react-textarea-autosize';
import * as ToastPrimitives from '@radix-ui/react-toast';
import * as TooltipPrimitive from '@radix-ui/react-tooltip';
import { LucideProps } from 'lucide-react';
import { ClassValue } from 'clsx';

declare const BackButton: React.FC<{
    onClick?: () => void;
}>;

type Iconable = FunctionComponent<{
    className?: string | null;
}> | ExoticComponent<{
    className?: string | null;
}> | FunctionComponent<{
    className?: string;
}> | ExoticComponent<{
    className?: string;
}>;

declare const buttonVariants: (props?: ({
    variant?: "link" | "default" | "vk" | "destructive" | "outline" | "secondary" | "ghost" | "linkWithoutColor" | undefined;
    size?: "default" | "sm" | "lg" | "icon" | "none" | "defaultNoPadding" | "xs" | undefined;
} & ({
    class?: cva.ClassValue;
    className?: never;
} | {
    class?: never;
    className?: cva.ClassValue;
})) | undefined) => string;
type ButtonVariants = VariantProps<typeof buttonVariants>;
interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
    asChild?: boolean;
}
declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;

type OptionType = {
    value: string;
    label: ReactNode;
    Icon?: Iconable;
} | null;
interface ComboBoxProps extends Omit<ButtonProps, "onChange" | "unselectable">, React__default.RefAttributes<HTMLButtonElement> {
    Icon?: Iconable;
    placeholder: string;
    empty?: ReactNode;
    loadingElement?: ReactNode;
    value?: string;
    setValue?: Dispatch<SetStateAction<string | null>>;
    onOpenChange?: Dispatch<SetStateAction<boolean>>;
    open?: boolean;
    onSearchChange?: (search: string) => void;
    name?: string;
    required?: boolean;
    loading?: boolean;
    defaultValue?: string;
    notCloseOnSelect?: boolean;
    listRef?: React__default.Ref<HTMLDivElement>;
    unselectable?: boolean;
    onChange?: React__default.ChangeEventHandler<HTMLInputElement>;
    onlyIconValue?: boolean;
    hideChevrons?: boolean;
}
declare const ComboBox: React__default.ForwardRefExoticComponent<Omit<React__default.PropsWithChildren<ComboBoxProps>, "ref"> & React__default.RefAttributes<HTMLInputElement>>;
declare const MultiselectComboBox: React__default.ForwardRefExoticComponent<Omit<React__default.PropsWithChildren<Omit<ComboBoxProps, "onlyIconValue"> & {
    value?: string[];
    defaultValue?: string[];
    setValue: React__default.Dispatch<React__default.SetStateAction<string[]>>;
}>, "ref"> & React__default.RefAttributes<HTMLInputElement>>;
declare const ComboBoxItem: React__default.ForwardRefExoticComponent<Omit<Omit<{
    children?: React__default.ReactNode;
} & Omit<Pick<Pick<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React__default.HTMLAttributes<HTMLDivElement>> & {
    ref?: React__default.Ref<HTMLDivElement>;
} & {
    asChild?: boolean;
}, "asChild" | "key" | keyof React__default.HTMLAttributes<HTMLDivElement>>, "disabled" | "value" | "onSelect"> & {
    disabled?: boolean;
    onSelect?: (value: string) => void;
    value?: string;
    keywords?: string[];
    forceMount?: boolean;
} & React__default.RefAttributes<HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>, "ref"> & {
    Icon?: Iconable;
} & React__default.RefAttributes<HTMLDivElement>>;
declare const ComboBoxGroup: React__default.ForwardRefExoticComponent<Omit<{
    children?: React__default.ReactNode;
} & Omit<Pick<Pick<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React__default.HTMLAttributes<HTMLDivElement>> & {
    ref?: React__default.Ref<HTMLDivElement>;
} & {
    asChild?: boolean;
}, "asChild" | "key" | keyof React__default.HTMLAttributes<HTMLDivElement>>, "value" | "heading"> & {
    heading?: React__default.ReactNode;
    value?: string;
    forceMount?: boolean;
} & React__default.RefAttributes<HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;

type CalendarProps = React.ComponentProps<typeof DayPicker>;

declare const DatePicker: React.FC<Omit<CalendarProps, "mode" | "className"> & Pick<ButtonVariants, "size"> & {
    onSelect?: React.Dispatch<React.SetStateAction<Date | undefined>>;
    selected?: Date;
    withTime?: boolean;
    open?: boolean;
    onOpenChange?: React.Dispatch<React.SetStateAction<boolean>>;
    format?: "relative" | "absolute";
    className?: string;
}>;

declare const Footer: React.FC;

interface LogotypeProps extends React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement> {
    superscriptLogo?: string;
    badgeText?: string;
    logoSrc?: string;
    appName?: string;
}
declare const Logotype: React.FC<LogotypeProps>;

interface UserAccount {
    displayName: string;
    avatarSrc?: string;
    tag: string;
    backgroundSrc?: string;
}
interface UserAccountActions {
    openMeduzaSanctum?: () => void;
    open?: () => void;
    logOut?: () => void;
    goverment?: () => void;
}
interface Balance {
    balance: number;
    unReadTransaction?: boolean;
    currencyImageSrc?: string;
    currencyId?: string;
    openTransactions?: () => void;
    buy?: () => void;
    transaction?: () => void;
}
interface HeaderProps {
    returnToBank?: () => void;
    user?: UserAccount;
    userActions?: UserAccountActions;
    login?: () => void;
    themeSwitch?: (theme: "system" | "dark" | "light") => void;
    useTooltipProvider?: boolean;
    balance?: Balance;
    sanctumShow?: boolean;
    search?: (text: string) => void;
    Notifications?: React.FC;
    unReadNotify?: boolean;
    logo?: Omit<LogotypeProps, "isButton">;
    homePage?: () => void;
}
declare const Header: React.FC<React.PropsWithChildren<HeaderProps>>;

interface InputProps extends React.InputHTMLAttributes<HTMLInputElement> {
}
declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;

interface InputFormFieldProps extends InputProps {
    label?: string;
    name: string;
    skeletonLoad?: boolean;
    description?: string;
    LabelIcon?: Iconable;
    rhfControl?: boolean | UseFormRegisterReturn;
    error?: string;
}
declare const InputFormField: React.FC<InputFormFieldProps>;

declare const Layout: React.FC<React.PropsWithChildren<{
    isNavigate?: boolean;
}>>;

declare const LoadingDialog: React.FC;

interface NavigationLayoutType extends React.FC<React.PropsWithChildren<{
    className?: string;
}>> {
    NavigatorBlock: React.FC<React.PropsWithChildren<{
        className?: string;
    }>>;
    PageBlock: React.FC<React.PropsWithChildren<{
        className?: string;
    }>>;
}
declare const NavigationLayout: NavigationLayoutType;

interface IPageBlockErrorProps {
    close(): void;
    error: string;
}
declare const PageBlockError: React.FC<IPageBlockErrorProps>;

declare const VKAuthRequireDialog: React.FC<{
    connect?: () => void;
}>;

declare const Avatar: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
declare const AvatarImage: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarImageProps & React.RefAttributes<HTMLImageElement>, "ref"> & React.RefAttributes<HTMLImageElement>>;
declare const AvatarFallback: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarFallbackProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
interface StandardAvatarProps {
    src?: string;
    fallback?: string;
    className?: string;
}
declare const StandardAvatar: React.FC<React.PropsWithChildren<StandardAvatarProps>>;

declare const badgeVariants: (props?: ({
    variant?: "default" | "destructive" | "outline" | "secondary" | undefined;
} & ({
    class?: cva.ClassValue;
    className?: never;
} | {
    class?: never;
    className?: cva.ClassValue;
})) | undefined) => string;
interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
}
declare function Badge({ className, variant, ...props }: BadgeProps): React.JSX.Element;

declare const Card: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
declare const CardHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
declare const CardTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLParagraphElement>>;
declare const CardDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
declare const CardContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
declare const CardFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;

declare const Command: React.ForwardRefExoticComponent<Omit<{
    children?: React.ReactNode;
} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
    ref?: React.Ref<HTMLDivElement>;
} & {
    asChild?: boolean;
}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
    label?: string;
    shouldFilter?: boolean;
    filter?: (value: string, search: string, keywords?: string[]) => number;
    defaultValue?: string;
    value?: string;
    onValueChange?: (value: string) => void;
    loop?: boolean;
    disablePointerSelection?: boolean;
    vimBindings?: boolean;
} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
interface CommandDialogProps extends DialogProps {
    commandProps: React.ComponentPropsWithoutRef<typeof Command$1>;
}
declare const CommandDialog: ({ children, commandProps, ...props }: CommandDialogProps) => React.JSX.Element;
declare const CommandInput: React.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "key" | keyof React.InputHTMLAttributes<HTMLInputElement>> & {
    ref?: React.Ref<HTMLInputElement>;
} & {
    asChild?: boolean;
}, "asChild" | "key" | keyof React.InputHTMLAttributes<HTMLInputElement>>, "type" | "value" | "onChange"> & {
    value?: string;
    onValueChange?: (search: string) => void;
} & React.RefAttributes<HTMLInputElement>, "ref"> & {
    loading?: boolean;
} & React.RefAttributes<HTMLInputElement>>;
declare const CommandList: React.ForwardRefExoticComponent<Omit<{
    children?: React.ReactNode;
} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
    ref?: React.Ref<HTMLDivElement>;
} & {
    asChild?: boolean;
}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
    label?: string;
} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const CommandEmpty: React.ForwardRefExoticComponent<Omit<{
    children?: React.ReactNode;
} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
    ref?: React.Ref<HTMLDivElement>;
} & {
    asChild?: boolean;
}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const CommandGroup: React.ForwardRefExoticComponent<Omit<{
    children?: React.ReactNode;
} & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
    ref?: React.Ref<HTMLDivElement>;
} & {
    asChild?: boolean;
}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>>, "value" | "heading"> & {
    heading?: React.ReactNode;
    value?: string;
    forceMount?: boolean;
} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const CommandSeparator: React.ForwardRefExoticComponent<Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
    ref?: React.Ref<HTMLDivElement>;
} & {
    asChild?: boolean;
}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
    alwaysRender?: boolean;
} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const CommandItem: React.ForwardRefExoticComponent<Omit<{
    children?: React.ReactNode;
} & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
    ref?: React.Ref<HTMLDivElement>;
} & {
    asChild?: boolean;
}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>>, "disabled" | "value" | "onSelect"> & {
    disabled?: boolean;
    onSelect?: (value: string) => void;
    value?: string;
    keywords?: string[];
    forceMount?: boolean;
} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const CommandShortcut: {
    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): React.JSX.Element;
    displayName: string;
};

type CropArea = Area;
type CropAreaAspectType = "background" | "avatar";
type OnDrop = <T extends File>(acceptedFiles: T[], fileRejections: FileRejection[], event: DropEvent) => void;
type OnUpload = (file: File, area: CropArea) => void;
declare const CropperControls: React__default.ForwardRefExoticComponent<{
    type: CropAreaAspectType;
    image: string;
    onDrop?: OnDrop;
    onUpload: (area: Area) => void;
} & React__default.RefAttributes<unknown>>;
declare const CropperDialogContent: React__default.FC<{
    type: CropAreaAspectType;
    onUpload: OnUpload;
    openState?: boolean;
    image?: string;
}>;

type DrawerProps = React.ComponentProps<typeof Drawer$1.Root>;
declare const Drawer: {
    ({ shouldScaleBackground, ...props }: DrawerProps): React.JSX.Element;
    displayName: string;
};
declare const NestedDrawer: {
    ({ shouldScaleBackground, ...props }: DrawerProps): React.JSX.Element;
    displayName: string;
};
declare const DrawerTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
declare const DrawerPortal: typeof vaul.Portal;
declare const DrawerClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
declare const DrawerOverlay: React.ForwardRefExoticComponent<Omit<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const DrawerContent: React.ForwardRefExoticComponent<Omit<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & {
    autoClose?: boolean;
    noScroll?: boolean;
} & React.RefAttributes<HTMLDivElement>>;
declare const DrawerHeader: {
    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
    displayName: string;
};
declare const DrawerFooter: {
    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
    displayName: string;
};
declare const DrawerTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
declare const DrawerDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;

declare const DialogNonResponsibility: React.FC<DialogPrimitive.DialogProps>;
declare const DialogTriggerNonResponsibility: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
declare const DialogContentNonResponsibility: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
    autoClose?: boolean;
} & React.RefAttributes<HTMLDivElement>>;
declare const DialogHeaderNonResponsibility: {
    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
    displayName: string;
};
declare const DialogFooterNonResponsibility: {
    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
    displayName: string;
};
declare const DialogTitleNonResponsibility: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
declare const DialogDescriptionNonResponsibility: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
declare const DialogContent: React.ForwardRefExoticComponent<Omit<Omit<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & {
    autoClose?: boolean;
    noScroll?: boolean;
} & React.RefAttributes<HTMLDivElement> & Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
    autoClose?: boolean;
}, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const DialogTrigger: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
declare const DialogHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<unknown>>;
declare const DialogFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<unknown>>;
declare const DialogTitle: React.ForwardRefExoticComponent<Omit<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
declare const DialogDescription: React.ForwardRefExoticComponent<Omit<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
declare const Dialog: React.FC<DialogPrimitive.DialogProps & DrawerProps>;

declare const DropdownMenuNonResponsibility: React.FC<DropdownMenuPrimitive.DropdownMenuProps>;
declare const DropdownMenuTriggerNonResponsibility: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuPortalNonResponsibility: React.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
declare const DropdownMenuSubNonResponsibility: React.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
declare const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuSubTriggerNonResponsibility: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean;
} & React.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuSubContentNonResponsibility: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuContentNonResponsibility: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean;
} & React.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuLabelNonResponsibility: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean;
} & React.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuShortcut: {
    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): React.JSX.Element;
    displayName: string;
};
declare const DropdownMenu: React.FC<DropdownMenuPrimitive.DropdownMenuProps & DrawerProps>;
declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<Omit<DialogTriggerProps & React.RefAttributes<HTMLButtonElement> & DropdownMenuPrimitive.DropdownMenuTriggerProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<Omit<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & {
    autoClose?: boolean;
    noScroll?: boolean;
} & React.RefAttributes<HTMLDivElement> & Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref">, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuSub: React.FC<DropdownMenuPrimitive.DropdownMenuProps & DrawerProps>;
declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<Omit<DialogTriggerProps & React.RefAttributes<HTMLButtonElement> & Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean;
} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement & HTMLButtonElement>>;
declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<Omit<Omit<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & {
    autoClose?: boolean;
    noScroll?: boolean;
} & React.RefAttributes<HTMLDivElement> & Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref">, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuPortal: React.ForwardRefExoticComponent<DialogPrimitive.DialogPortalProps & DropdownMenuPrimitive.DropdownMenuPortalProps & React.RefAttributes<unknown>>;
declare const DropdownMenuLabel: React.ForwardRefExoticComponent<Omit<React.HTMLAttributes<HTMLDivElement> & Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean;
} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;

declare const Form: <TFieldValues extends FieldValues, TContext = any, TTransformedValues extends FieldValues | undefined = undefined>(props: react_hook_form.FormProviderProps<TFieldValues, TContext, TTransformedValues>) => React.JSX.Element;
declare const FormField: <TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ ...props }: ControllerProps<TFieldValues, TName>) => React.JSX.Element;
declare const useFormField: () => {
    invalid: boolean;
    isDirty: boolean;
    isTouched: boolean;
    isValidating: boolean;
    error?: react_hook_form.FieldError;
    id: string;
    name: string;
    formItemId: string;
    formDescriptionId: string;
    formMessageId: string;
};
declare const FormItem: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
declare const FormLabel: React.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React.RefAttributes<HTMLLabelElement>, "ref"> & React.RefAttributes<HTMLLabelElement>>;
declare const FormControl: React.ForwardRefExoticComponent<Omit<_radix_ui_react_slot.SlotProps & React.RefAttributes<HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
declare const FormDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
declare const FormMessage: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;

declare const HoverCard: React.FC<HoverCardPrimitive.HoverCardProps>;
declare const HoverCardTrigger: React.ForwardRefExoticComponent<HoverCardPrimitive.HoverCardTriggerProps & React.RefAttributes<HTMLAnchorElement>>;
declare const HoverCardContent: React.ForwardRefExoticComponent<Omit<HoverCardPrimitive.HoverCardContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;

declare const InputOTP: React.ForwardRefExoticComponent<(Omit<Omit<React.InputHTMLAttributes<HTMLInputElement>, "value" | "onChange" | "maxLength" | "textAlign" | "onComplete" | "pushPasswordManagerStrategy" | "pasteTransformer" | "containerClassName" | "noScriptCSSFallback"> & {
    value?: string;
    onChange?: (newValue: string) => unknown;
    maxLength: number;
    textAlign?: "left" | "center" | "right";
    onComplete?: (...args: any[]) => unknown;
    pushPasswordManagerStrategy?: "increase-width" | "none";
    pasteTransformer?: (pasted: string) => string;
    containerClassName?: string;
    noScriptCSSFallback?: string | null;
} & {
    render: (props: input_otp.RenderProps) => React.ReactNode;
    children?: never;
} & React.RefAttributes<HTMLInputElement>, "ref"> | Omit<Omit<React.InputHTMLAttributes<HTMLInputElement>, "value" | "onChange" | "maxLength" | "textAlign" | "onComplete" | "pushPasswordManagerStrategy" | "pasteTransformer" | "containerClassName" | "noScriptCSSFallback"> & {
    value?: string;
    onChange?: (newValue: string) => unknown;
    maxLength: number;
    textAlign?: "left" | "center" | "right";
    onComplete?: (...args: any[]) => unknown;
    pushPasswordManagerStrategy?: "increase-width" | "none";
    pasteTransformer?: (pasted: string) => string;
    containerClassName?: string;
    noScriptCSSFallback?: string | null;
} & {
    render?: never;
    children: React.ReactNode;
} & React.RefAttributes<HTMLInputElement>, "ref">) & React.RefAttributes<HTMLInputElement>>;
declare const InputOTPGroup: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const InputOTPSlot: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
    index: number;
} & React.RefAttributes<HTMLDivElement>>;
declare const InputOTPSeparator: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;

declare const Label: React.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React.RefAttributes<HTMLLabelElement>, "ref"> & VariantProps<(props?: ({
    class?: cva.ClassValue;
    className?: never;
} | {
    class?: never;
    className?: cva.ClassValue;
}) | undefined) => string> & React.RefAttributes<HTMLLabelElement>>;

declare const LineBlock: React.FC<React.PropsWithChildren<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>>>;

interface MessagePagePartProps {
    type?: "info" | "success" | "warning" | "error";
    title?: string;
    close?: () => void;
    icon?: React.ReactElement;
}
declare const MessagePagePart: React.FC<React.PropsWithChildren<MessagePagePartProps>>;

declare const NavigationMenu: React.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuProps & React.RefAttributes<HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
declare const NavigationMenuList: React.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuListProps & React.RefAttributes<HTMLUListElement>, "ref"> & React.RefAttributes<HTMLUListElement>>;
declare const NavigationMenuItem: React.ForwardRefExoticComponent<NavigationMenuPrimitive.NavigationMenuItemProps & React.RefAttributes<HTMLLIElement>>;
declare const navigationMenuTriggerStyle: (props?: ({
    class?: cva.ClassValue;
    className?: never;
} | {
    class?: never;
    className?: cva.ClassValue;
}) | undefined) => string;
declare const NavigationMenuTrigger: React.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
declare const NavigationMenuContent: React.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const NavigationMenuLink: React.ForwardRefExoticComponent<NavigationMenuPrimitive.NavigationMenuLinkProps & React.RefAttributes<HTMLAnchorElement>>;
declare const NavigationMenuViewport: React.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuViewportProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const NavigationMenuIndicator: React.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuIndicatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;

interface NavigatorType extends FC<PropsWithChildren> {
    Button: FC<PropsWithChildren<{
        action: MouseEventHandler;
        Icon?: Iconable;
        IconRender?: React__default.FC;
        iconClassName?: string;
        className?: string;
        isActive?: boolean;
    }>>;
    ButtonNoAdaptive: FC<PropsWithChildren<{
        action: MouseEventHandler;
        Icon?: Iconable;
        IconRender?: React__default.FC;
        iconClassName?: string;
        className?: string;
        isActive?: boolean;
    }>>;
    Header: FC<PropsWithChildren>;
    ButtonContainer: FC<PropsWithChildren>;
    Separator: FC;
}
declare const Navigator: NavigatorType;

declare const PageBlock: React.FC<React.PropsWithChildren<{
    error?: boolean;
    className?: string;
}>>;

declare const PopoverNonResponsibility: React.FC<PopoverPrimitive.PopoverProps>;
declare const PopoverTriggerNonResponsibility: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
declare const PopoverContentNonResponsibility: React.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const PopoverContent: React.ForwardRefExoticComponent<Omit<Omit<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & {
    autoClose?: boolean;
    noScroll?: boolean;
} & React.RefAttributes<HTMLDivElement> & Omit<PopoverPrimitive.PopoverContentProps & React.RefAttributes<HTMLDivElement>, "ref">, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const PopoverTrigger: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement> & PopoverPrimitive.PopoverTriggerProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
declare const Popover: React.FC<PopoverPrimitive.PopoverProps & DrawerProps>;

interface ProfileAccountType {
    backgroundUrl?: string;
    avatarUrl?: string;
    displayname: string;
    tag: string;
}
interface ProfileBlockProps {
    account?: ProfileAccountType;
    skeletonLoad?: boolean;
    noFullWidth?: boolean;
    setAvatar?: OnUpload;
    setBg?: OnUpload;
    className?: ClassNameValue;
    infoClassName?: ClassNameValue;
    avatarClassName?: ClassNameValue;
    displaynameClassName?: ClassNameValue;
    tagClassName?: ClassNameValue;
    nameBlockClassName?: ClassNameValue;
    mobileForce?: boolean;
}
declare const ProfileBlockBackground: React.FC<React.PropsWithChildren<Pick<ProfileBlockProps, "className" | "setBg" | "skeletonLoad" | "noFullWidth" | "mobileForce"> & {
    backgroundUrl?: string;
}>>;
declare const ProfileInfoBlock: React.FC<{
    displaynameClassName?: ClassNameValue;
    tagClassName?: ClassNameValue;
    nameBlockClassName?: ClassNameValue;
    avatarClassName?: ClassNameValue;
    account?: ProfileAccountType;
    setAvatar?: OnUpload;
    className?: ClassNameValue;
}>;
declare const ProfileBlock: React.FC<ProfileBlockProps>;

declare const QrCode: React.FC<{
    text: string;
    suffix?: string;
    logo?: string;
}>;

declare const ScrollArea: React.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
    viewPortClassName?: string;
} & React.RefAttributes<HTMLDivElement>>;
declare const ScrollBar: React.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;

declare const Separator: React.ForwardRefExoticComponent<Omit<SeparatorPrimitive.SeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;

declare function Skeleton({ className, children, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;

declare const Slider: React.ForwardRefExoticComponent<Omit<SliderPrimitive.SliderProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;

type ToasterProps = React__default.ComponentProps<typeof Toaster$1>;
declare const AlternativeToaster: React__default.FC<ToasterProps>;

declare const Switch: React__default.ForwardRefExoticComponent<Omit<SwitchPrimitives.SwitchProps & React__default.RefAttributes<HTMLButtonElement>, "ref"> & React__default.RefAttributes<HTMLButtonElement>>;

declare const Table: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableElement> & React.RefAttributes<HTMLTableElement>>;
declare const TableHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
declare const TableBody: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
declare const TableFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
declare const TableRow: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableRowElement> & React.RefAttributes<HTMLTableRowElement>>;
declare const TableHead: React.ForwardRefExoticComponent<React.ThHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
declare const TableCell: React.ForwardRefExoticComponent<React.TdHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
declare const TableCaption: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableCaptionElement> & React.RefAttributes<HTMLTableCaptionElement>>;

interface TextareaProps extends TextareaAutosizeProps {
}
declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;

type Props = {
    value: string;
    valueLength: number;
    onChange: (value: string) => void;
};
declare const TF2CodeInput: React.FC<Props>;

declare const ToastProvider: React.FC<ToastPrimitives.ToastProviderProps>;
declare const ToastViewport: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastViewportProps & React.RefAttributes<HTMLOListElement>, "ref"> & React.RefAttributes<HTMLOListElement>>;
declare const Toast$1: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastProps & React.RefAttributes<HTMLLIElement>, "ref"> & VariantProps<(props?: ({
    variant?: "default" | "destructive" | undefined;
} & ({
    class?: cva.ClassValue;
    className?: never;
} | {
    class?: never;
    className?: cva.ClassValue;
})) | undefined) => string> & React.RefAttributes<HTMLLIElement>>;
declare const ToastAction: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
declare const ToastClose: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastCloseProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
declare const ToastTitle: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastTitleProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const ToastDescription: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastDescriptionProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
type ToastProps = React.ComponentPropsWithoutRef<typeof Toast$1>;
type ToastActionElement = React.ReactElement<typeof ToastAction>;

declare function Toaster(): React.JSX.Element;

declare const TooltipProvider: React.FC<TooltipPrimitive.TooltipProviderProps>;
declare const Tooltip: React.FC<TooltipPrimitive.TooltipProps>;
declare const TooltipTrigger: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>>;
declare const TooltipContent: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;

type ToasterToast = ToastProps & {
    id: string;
    title?: React.ReactNode;
    description?: React.ReactNode;
    action?: ToastActionElement;
};
declare const actionTypes: {
    readonly ADD_TOAST: "ADD_TOAST";
    readonly UPDATE_TOAST: "UPDATE_TOAST";
    readonly DISMISS_TOAST: "DISMISS_TOAST";
    readonly REMOVE_TOAST: "REMOVE_TOAST";
};
type ActionType = typeof actionTypes;
type Action = {
    type: ActionType["ADD_TOAST"];
    toast: ToasterToast;
} | {
    type: ActionType["UPDATE_TOAST"];
    toast: Partial<ToasterToast>;
} | {
    type: ActionType["DISMISS_TOAST"];
    toastId?: ToasterToast["id"];
} | {
    type: ActionType["REMOVE_TOAST"];
    toastId?: ToasterToast["id"];
};
interface State {
    toasts: ToasterToast[];
}
declare const reducer: (state: State, action: Action) => State;
type Toast = Omit<ToasterToast, "id">;
declare function toast({ ...props }: Toast): {
    id: string;
    dismiss: () => void;
    update: (props: ToasterToast) => void;
};
declare function useToast(): {
    toast: typeof toast;
    dismiss: (toastId?: string) => void;
    toasts: ToasterToast[];
};

declare const VKAuthButton: React.FC<{
    IsLoading?: boolean;
    className?: string;
    actionType?: "login" | "register";
    type?: "button" | "submit";
    onClick?: VoidFunction;
}>;

declare const VKIcon: React.FC<LucideProps>;

declare function ResponsibilityHOC<ThenProps = {}, ElseThenProps = {}, ThenRef = unknown, ElseThenRef = unknown>(query: string, Then: FunctionComponent<ThenProps> | Component<ThenProps> | ExoticComponent<ThenProps> | ForwardRefRenderFunction<PropsWithoutRef<ThenProps> & RefAttributes<ThenRef>> | ForwardRefExoticComponent<PropsWithoutRef<ThenProps> & RefAttributes<ThenRef>>, ElseThen?: FunctionComponent<ElseThenProps> | Component<ElseThenProps> | ExoticComponent<ElseThenProps> | ForwardRefRenderFunction<PropsWithoutRef<ElseThenProps> & RefAttributes<ElseThenRef>> | ForwardRefExoticComponent<PropsWithoutRef<ElseThenProps> & RefAttributes<ElseThenRef>> | null): ForwardRefExoticComponent<PropsWithoutRef<ElseThenProps & ThenProps> & RefAttributes<ThenRef & ElseThenRef>>;

declare function cn(...inputs: ClassValue[]): string;
declare const useIsomorphicLayoutEffect: typeof useLayoutEffect;
type UseMediaQueryOptions = {
    defaultValue?: boolean;
    initializeWithValue?: boolean;
};
declare function useMediaQuery(query: string, { defaultValue, initializeWithValue, }?: UseMediaQueryOptions): boolean;
declare function nFormatter(num: number, digits?: number): string;
declare function usernameFirstLiterals(username: string): string;
declare function dateFormat(date: Date, miniYear?: boolean): string;
declare const createImage: (url: string) => Promise<HTMLImageElement>;
declare function getRadianAngle(degreeValue: number): number;
/**
 * Returns the new bounding area of a rotated rectangle.
 */
declare function rotateSize(width: number, height: number, rotation: number): {
    width: number;
    height: number;
};
/**
 * This function was adapted from the one in the ReadMe of https://github.com/DominicTobias/react-image-crop
 */
declare function getPreviewPhoto(imageSrc: string, pixelCrop: Area, rotation?: number, flip?: {
    horizontal: boolean;
    vertical: boolean;
}): Promise<string | null>;
declare function range(startOrEnd: number, end?: number, step?: number): Generator<number, void, unknown>;
declare function generateRangeArray(startOrEnd: number, end?: number, step?: number): number[];

export { AlternativeToaster, Avatar, AvatarFallback, AvatarImage, BackButton, Badge, type BadgeProps, Button, type ButtonProps, type ButtonVariants, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, ComboBox, ComboBoxGroup, ComboBoxItem, type ComboBoxProps, Command, CommandDialog, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator, CommandShortcut, type CropArea, type CropAreaAspectType, CropperControls, CropperDialogContent, DatePicker, Dialog, DialogContent, DialogContentNonResponsibility, DialogDescription, DialogDescriptionNonResponsibility, DialogFooter, DialogFooterNonResponsibility, DialogHeader, DialogHeaderNonResponsibility, DialogNonResponsibility, DialogTitle, DialogTitleNonResponsibility, DialogTrigger, DialogTriggerNonResponsibility, Drawer, DrawerClose, DrawerContent, DrawerDescription, DrawerFooter, DrawerHeader, DrawerOverlay, DrawerPortal, type DrawerProps, DrawerTitle, DrawerTrigger, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuContentNonResponsibility, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuLabelNonResponsibility, DropdownMenuNonResponsibility, DropdownMenuPortal, DropdownMenuPortalNonResponsibility, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubContentNonResponsibility, DropdownMenuSubNonResponsibility, DropdownMenuSubTrigger, DropdownMenuSubTriggerNonResponsibility, DropdownMenuTrigger, DropdownMenuTriggerNonResponsibility, Footer, Form, FormControl, FormDescription, FormField, FormItem, FormLabel, FormMessage, Header, HoverCard, HoverCardContent, HoverCardTrigger, Input, InputFormField, type InputFormFieldProps, InputOTP, InputOTPGroup, InputOTPSeparator, InputOTPSlot, type InputProps, Label, Layout, LineBlock, LoadingDialog, Logotype, type LogotypeProps, MessagePagePart, MultiselectComboBox, NavigationLayout, type NavigationLayoutType, NavigationMenu, NavigationMenuContent, NavigationMenuIndicator, NavigationMenuItem, NavigationMenuLink, NavigationMenuList, NavigationMenuTrigger, NavigationMenuViewport, Navigator, type NavigatorType, NestedDrawer, type OnUpload, type OptionType, PageBlock, PageBlockError, Popover, PopoverContent, PopoverContentNonResponsibility, PopoverNonResponsibility, PopoverTrigger, PopoverTriggerNonResponsibility, ProfileBlock, ProfileBlockBackground, type ProfileBlockProps, ProfileInfoBlock, type Props, QrCode, ResponsibilityHOC, ScrollArea, ScrollBar, Separator, Skeleton, Slider, StandardAvatar, Switch, TF2CodeInput, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow, Textarea, type TextareaProps, Toast$1 as Toast, ToastAction, type ToastActionElement, ToastClose, ToastDescription, type ToastProps, ToastProvider, ToastTitle, ToastViewport, Toaster, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, VKAuthButton, VKAuthRequireDialog, VKIcon, badgeVariants, buttonVariants, cn, createImage, dateFormat, generateRangeArray, getPreviewPhoto, getRadianAngle, nFormatter, navigationMenuTriggerStyle, range, reducer, rotateSize, toast, useFormField, useIsomorphicLayoutEffect, useMediaQuery, useToast, usernameFirstLiterals };