import * as React$1 from 'react';
import React__default, { FC, RefObject, ReactNode, ChangeEvent, InputHTMLAttributes, useEffect } from 'react';
import * as TooltipPrimitive from '@radix-ui/react-tooltip';
import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
import * as AccordionPrimitive from '@radix-ui/react-accordion';
import * as class_variance_authority_types from 'class-variance-authority/types';
import * as NavigationMenuPrimitive from '@radix-ui/react-navigation-menu';
import * as SheetPrimitive from '@radix-ui/react-dialog';
import { DialogProps } from '@radix-ui/react-dialog';
import { VariantProps } from 'class-variance-authority';
import { RowData, ColumnDef } from '@tanstack/react-table';
export { ColumnDef } from '@tanstack/react-table';
import * as PopoverPrimitive from '@radix-ui/react-popover';
import { PopoverContentProps } from '@radix-ui/react-popover';
import { Command as Command$1 } from 'cmdk';
import * as TabsPrimitive from '@radix-ui/react-tabs';
import * as SwitchPrimitives from '@radix-ui/react-switch';
import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
import * as ProgressPrimitive from '@radix-ui/react-progress';
import * as input_otp from 'input-otp';
import { OTPInputProps } from 'input-otp';
import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
import * as SliderPrimitive from '@radix-ui/react-slider';
import { HighlightProps } from 'prism-react-renderer';
import { EmblaOptionsType } from 'embla-carousel';
import * as ToastPrimitives from '@radix-ui/react-toast';
import * as MenubarPrimitive from '@radix-ui/react-menubar';
export { Portal as DropdownMenuPortal } from '@headlessui/react';

interface CardProps extends React$1.HTMLAttributes<HTMLDivElement> {
    clickable?: boolean;
    variant?: "default" | "neoBrutalism";
    asContainer?: boolean;
}
declare const Card: React$1.ForwardRefExoticComponent<CardProps & React$1.RefAttributes<HTMLDivElement>>;
declare const CardHeader: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & {
    actions?: React$1.ReactNode;
} & React$1.RefAttributes<HTMLDivElement>>;
declare const CardTitle: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLHeadingElement> & React$1.RefAttributes<HTMLParagraphElement>>;
declare const CardDescription: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLParagraphElement> & React$1.RefAttributes<HTMLParagraphElement>>;
declare const CardContent: React$1.ForwardRefExoticComponent<{
    headless?: boolean;
    noPadding?: boolean;
} & React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
declare const CardFooter: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & {
    noPadding?: boolean;
} & React$1.RefAttributes<HTMLDivElement>>;

type LoadingTypes = {
    /** Specifies the size of the loading component.*/
    size?: "button" | "xs" | "sm" | "normal" | "lg" | "xl";
    /** Determines the design of the loading animation.*/
    design?: "spinner" | "dots-bounce" | "dots-pulse" | "pulse" | "spinner-dots" | "squircle" | "square" | "progress" | "orbit";
    /** Specifies the color of the loading component. By default it will inherit the value of --primary global CSS variable*/
    color?: string;
    classNames?: {
        container?: string;
        track?: string;
        car?: string;
    };
    themeMode?: "dark" | "light";
};
declare const Loading: FC<LoadingTypes>;

type DirectionType = "rtl" | "ltr";
type PositionType = "top" | "bottom" | "right" | "left";
type SeverityType = "info" | "warning" | "error" | "success" | "none";
type OrientationType = "vertical" | "horizontal";
type RadiusType = "full" | "inherit" | "none";
type RadioOptionType = {
    label: string;
    value: string;
};

type TooltipTypes = {
    /** Controls the open state of the tooltip. */
    open?: any;
    /** Specifies the side where the tooltip will appear. */
    side?: PositionType;
    /** Content to be displayed within the tooltip. */
    content?: any;
    /** Elements to which the tooltip is anchored. */
    children?: any;
    /** Sets the default open state of the tooltip. */
    defaultOpen?: any;
    /** Event handler for open state changes. */
    onOpenChange?: any;
    /** Duration of the delay before the tooltip appears. */
    delayDuration?: any;
    /** Size of the tooltip. */
    size?: "default" | "small" | "large";
    /** Disables the tooltip. */
    disabled?: boolean;
    triggerProps?: TooltipPrimitive.TooltipTriggerProps;
    contentProps?: TooltipPrimitive.TooltipContentProps;
    providerProps?: TooltipPrimitive.TooltipProps;
};
declare const Tooltip: React__default.FunctionComponent<TooltipTypes>;

interface SkeletonProps extends React__default.HTMLAttributes<HTMLDivElement> {
    className?: string;
    animation?: "none" | "pulse" | "shimmer";
    content?: any;
    fade?: "top" | "bottom" | "left" | "right";
}
declare function Skeleton({ className, content, animation, fade, ...props }: SkeletonProps): React__default.JSX.Element;

declare const DropdownMenuRoot: React$1.FC<DropdownMenuPrimitive.DropdownMenuProps>;
declare const DropdownMenuTrigger: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
declare const DropdownMenuGroup: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React$1.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuSub: React$1.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
declare const DropdownMenuRadioGroup: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React$1.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuSubTrigger: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean;
} & React$1.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuSubContent: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuContent: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean;
    end?: any;
    shortcut?: React$1.ReactNode;
    badged?: boolean;
    slug?: string;
    LinkComponent?: any;
} & React$1.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuCheckboxItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuRadioItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuLabel: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean;
} & React$1.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuSeparator: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuShortcut: {
    ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): React$1.JSX.Element;
    displayName: string;
};
type ExtendedDropdownMenuContentProps = Partial<React$1.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Content>> & {};
type ExtendedDropdownMenuTriggerProps = Partial<React$1.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Trigger>> & {};
type SubItem$1 = {
    label?: string;
    value?: any;
    icon?: any;
    action?: () => void;
    onMiddleClick?: (e: any) => void;
    highlighted?: boolean;
    disabled?: boolean;
    slug?: string;
};
type MenuItemType = {
    icon?: React$1.ReactNode;
    label?: string;
    shortcut?: React$1.ReactNode;
    badged?: boolean;
    value?: any;
    content?: any;
    slug?: string;
    end?: any;
    presist?: boolean;
    itemType?: "separator" | "label" | "custom" | "radio";
    action?: () => void;
    highlighted?: boolean;
    subitems?: SubItem$1[];
    options?: RadioOptionType[];
    currentOption?: string;
    onOptionChange?: (value: string) => void;
    disabled?: boolean;
    onMiddleClick?: (e: any) => void;
    onClick?: any;
};
interface DropdownMenuProps {
    trigger?: any;
    items: MenuItemType[];
    direction?: DirectionType;
    classNames?: {
        trigger?: string;
        content?: string;
        item?: string;
        separator?: string;
    };
    className?: ExtendedDropdownMenuContentProps["className"];
    triggerClassname?: ExtendedDropdownMenuTriggerProps["className"];
    triggerProps?: DropdownMenuPrimitive.DropdownMenuTriggerProps;
    sideOffset?: ExtendedDropdownMenuContentProps["sideOffset"];
    side?: ExtendedDropdownMenuContentProps["side"];
    align?: ExtendedDropdownMenuContentProps["align"];
    alignOffset?: ExtendedDropdownMenuContentProps["alignOffset"];
    contentProps?: ExtendedDropdownMenuContentProps;
    width?: "default" | "sm" | "lg" | "parent";
    size?: "default" | "sm";
    onItemSelect?: any;
    onOpenChange?: any;
    header?: React$1.ReactNode;
    open?: any;
    LinkComponent?: any;
}
declare const DropdownMenu: React$1.FC<DropdownMenuProps>;
interface DropdownMenuRadioOptionType extends RadioOptionType {
    props?: Omit<DropdownMenuPrimitive.DropdownMenuItemProps, "value" | "label">;
}
interface DropdownMenuRadioProps {
    trigger?: React$1.ReactNode;
    side?: ExtendedDropdownMenuContentProps["side"];
    align?: ExtendedDropdownMenuContentProps["align"];
    options: DropdownMenuRadioOptionType[];
    value: string;
    onValueChange: any;
    label?: string;
    contentProps?: ExtendedDropdownMenuContentProps;
    radioGroupProps?: React$1.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.RadioGroup>;
}
declare const DropdownMenuRadio: React$1.FC<DropdownMenuRadioProps>;

type ChipColors = "green" | "blue" | "red" | "yellow" | "orange" | "purple" | "cyan" | "hyper" | "oceanic";
type ChipTypes = React__default.HTMLAttributes<HTMLSpanElement> & {
    /** The text inside the chip */
    label: string;
    /** The small icon before the chip label  */
    icon?: JSX.Element;
    /** The color of the chip, must be a tailwind color */
    color?: ChipColors;
    /** The size of the chip */
    size?: "small" | "normal" | "large";
    /** Enable/Disable the dot before the label of the chip */
    dot?: boolean;
    /** Red/Green dot next to the label of the chip indicating online/offline or available/unavailable */
    dotStatus?: "available" | "unavailable" | "none";
    radius?: RadiusType;
};
declare const Chip: React__default.ForwardRefExoticComponent<React__default.HTMLAttributes<HTMLSpanElement> & {
    /** The text inside the chip */
    label: string;
    /** The small icon before the chip label  */
    icon?: JSX.Element;
    /** The color of the chip, must be a tailwind color */
    color?: ChipColors;
    /** The size of the chip */
    size?: "small" | "normal" | "large";
    /** Enable/Disable the dot before the label of the chip */
    dot?: boolean;
    /** Red/Green dot next to the label of the chip indicating online/offline or available/unavailable */
    dotStatus?: "available" | "unavailable" | "none";
    radius?: RadiusType;
} & React__default.RefAttributes<HTMLSpanElement>>;

type AccordionItemProps = {
    trigger: React$1.ReactNode;
    content: React$1.ReactNode;
    disabled?: boolean;
    chip?: ChipTypes;
};
type AccordionProps = {
    items: AccordionItemProps[];
    itemClassNames?: string;
    triggerclassNames?: string;
    contentclassNames?: string;
    className?: string;
    design?: "default" | "separated";
    type: "single" | "multiple";
    collapsible?: boolean;
};
declare const Accordion: React$1.ForwardRefExoticComponent<AccordionProps & React$1.RefAttributes<HTMLDivElement>>;

declare const AccordionItem: React$1.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;

declare const AccordionTrigger: React$1.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & {
    unstyled?: boolean;
    hideArrow?: boolean;
} & React$1.RefAttributes<HTMLButtonElement>>;

declare const AccordionRoot: React$1.ForwardRefExoticComponent<(AccordionPrimitive.AccordionSingleProps | AccordionPrimitive.AccordionMultipleProps) & React$1.RefAttributes<HTMLDivElement>>;

declare const AccordionContent: React$1.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
    unstyled?: boolean;
} & React$1.RefAttributes<HTMLDivElement>>;

type IconProps = React__default.HTMLAttributes<SVGElement>;
declare const Logos: {
    metamask: (props: IconProps) => React__default.JSX.Element;
    nafath: (props: IconProps) => React__default.JSX.Element;
    hawa: (props: IconProps) => React__default.JSX.Element;
    sikka: (props: IconProps) => React__default.JSX.Element;
    mail: (props: IconProps) => React__default.JSX.Element;
    phone: (props: IconProps) => React__default.JSX.Element;
    twitter: (props: IconProps) => React__default.JSX.Element;
    x: (props: IconProps) => React__default.JSX.Element;
    instagram: (props: IconProps) => React__default.JSX.Element;
    telegram: (props: IconProps) => React__default.JSX.Element;
    youtube: (props: IconProps) => React__default.JSX.Element;
    tiktok: (props: IconProps) => React__default.JSX.Element;
    linkedin: (props: IconProps) => React__default.JSX.Element;
    behance: (props: IconProps) => React__default.JSX.Element;
    microsoft: (props: IconProps) => React__default.JSX.Element;
    github: (props: IconProps) => React__default.JSX.Element;
    radix: (props: IconProps) => React__default.JSX.Element;
    aria: (props: IconProps) => React__default.JSX.Element;
    npm: (props: IconProps) => React__default.JSX.Element;
    yarn: (props: IconProps) => React__default.JSX.Element;
    pnpm: (props: IconProps) => React__default.JSX.Element;
    react: (props: IconProps) => React__default.JSX.Element;
    tailwind: (props: IconProps) => React__default.JSX.Element;
    google: (props: IconProps) => React__default.JSX.Element;
    googleplay: (props: IconProps) => React__default.JSX.Element;
    apple: (props: IconProps) => React__default.JSX.Element;
    applestore: (props: IconProps) => React__default.JSX.Element;
    paypal: (props: IconProps) => React__default.JSX.Element;
    spinner: (props: IconProps) => React__default.JSX.Element;
    whatsapp: (props: IconProps) => React__default.JSX.Element;
    visa: (props: IconProps) => React__default.JSX.Element;
    mastercard: (props: IconProps) => React__default.JSX.Element;
};

declare const navigationMenuTriggerStyle: (props?: class_variance_authority_types.ClassProp | undefined) => string;
type StandardNavigationMenuItemProps = {
    icon?: React$1.ReactNode;
    title: string;
    subtitle?: string;
};
type NavigationMenuItemProps = {
    trigger: any;
    content?: any;
    action?: any;
    path?: string;
};
type NavigationMenuTypes = {
    items: NavigationMenuItemProps[];
    rootClassNames?: string;
    viewportClassNames?: string;
    triggerClassNames?: string;
    actionFirst?: boolean;
    direction?: DirectionType;
};
declare const NavigationMenuRoot: React$1.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuProps & React$1.RefAttributes<HTMLElement>, "ref"> & {
    viewportClassNames?: string;
} & React$1.RefAttributes<HTMLElement>>;
declare const NavigationMenuList: React$1.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuListProps & React$1.RefAttributes<HTMLUListElement>, "ref"> & React$1.RefAttributes<HTMLUListElement>>;
declare const NavigationMenuTrigger: React$1.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
declare const NavigationMenuContent: React$1.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const StandardNavigationMenuItem: React$1.FC<StandardNavigationMenuItemProps & React$1.ComponentProps<typeof NavigationMenuPrimitive.Link>>;
declare const NavigationMenuViewport: React$1.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuViewportProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const NavigationMenuIndicator: React$1.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuIndicatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const NavigationMenu: React$1.FC<NavigationMenuTypes>;
declare const NavigationMenuItem$1: React$1.ForwardRefExoticComponent<NavigationMenuPrimitive.NavigationMenuItemProps & React$1.RefAttributes<HTMLLIElement>>;
declare const NavigationMenuLink: React$1.ForwardRefExoticComponent<NavigationMenuPrimitive.NavigationMenuLinkProps & React$1.RefAttributes<HTMLAnchorElement>>;

declare const Sheet: React$1.FC<SheetPrimitive.DialogProps>;
declare const SheetTrigger: React$1.ForwardRefExoticComponent<SheetPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
declare const SheetClose: React$1.ForwardRefExoticComponent<SheetPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
declare const SheetPortal: React$1.FC<SheetPrimitive.DialogPortalProps>;
declare const SheetOverlay: React$1.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const sheetVariants: (props?: ({
    side?: "top" | "bottom" | "right" | "left" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;
interface SheetContentProps extends React$1.ComponentPropsWithoutRef<typeof SheetPrimitive.Content>, VariantProps<typeof sheetVariants> {
    hideCloseButton?: boolean;
    persist?: boolean;
}
declare const SheetContent: React$1.ForwardRefExoticComponent<SheetContentProps & React$1.RefAttributes<HTMLDivElement>>;
declare const SheetHeader: {
    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): React$1.JSX.Element;
    displayName: string;
};
declare const SheetFooter: {
    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): React$1.JSX.Element;
    displayName: string;
};
declare const SheetTitle: React$1.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
declare const SheetDescription: React$1.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;

declare const Dialog: React$1.FC<SheetPrimitive.DialogProps>;
declare const DialogTrigger: React$1.ForwardRefExoticComponent<SheetPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
declare const DialogPortal: {
    ({ ...props }: SheetPrimitive.DialogPortalProps): React$1.JSX.Element;
    displayName: string | undefined;
};
declare const DialogOverlay: React$1.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const DialogContent: React$1.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
    persist?: boolean;
    hideCloseButton?: boolean;
    container?: HTMLElement;
    overlayProps?: React$1.ComponentPropsWithoutRef<typeof DialogOverlay>;
    classNames?: {
        content?: string;
        overlay?: string;
        closeButton?: string;
    };
    ids?: {
        overlay?: string;
        closeButton?: string;
        closeIcon?: string;
    };
} & React$1.RefAttributes<HTMLDivElement>>;
declare const DialogCarouselContent: React$1.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
    hideCloseButton?: boolean;
    hidePrevButton?: boolean;
    persist?: boolean;
    onPrev?: () => void;
} & React$1.RefAttributes<HTMLDivElement>>;
declare const DialogHeader: {
    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): React$1.JSX.Element;
    displayName: string;
};
declare const DialogTitle: React$1.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
declare const DialogDescription: React$1.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
declare const DialogFooter: {
    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): React$1.JSX.Element;
    displayName: string;
};
interface DialogCarouselProps {
    children: React$1.ReactNode;
    stepsApi?: any;
    stepsRef?: any;
    direction?: DirectionType;
}
declare const DialogCarousel: React$1.FC<DialogCarouselProps>;
interface DialogStepsProps {
    currentStep: string;
    visibleStepRef: React$1.RefObject<HTMLDivElement>;
    children: React$1.ReactNode;
}
declare const DialogSteps: React$1.FC<DialogStepsProps>;
interface DialogStepProps {
    id: string;
    children: React$1.ReactNode;
    className?: string;
    stepRef?: any;
}
declare const DialogStep: React$1.FC<DialogStepProps>;
interface DialogBodyProps {
    children: React$1.ReactNode;
    className?: string;
}
declare const DialogBody: React$1.FC<DialogBodyProps>;

type AlertTypes = {
    severity?: SeverityType | "hyper" | "oceanic";
    /** The title of the alert placed above the text of the alert. Can be used alone */
    title?: React__default.ReactNode;
    /** The text of the alert placed below the title of the alert. Can be used alone */
    text: React__default.ReactNode;
    /** The duration for the alert to stay on the screen */
    duration?: number;
    direction?: DirectionType;
    actions?: [
        {
            label: string;
            onClick: any;
            variant: "outline" | "link" | "default" | "destructive" | "secondary" | "ghost";
        }
    ];
    /** Removes the close button */
    persistent?: boolean;
    icon?: any;
    className?: string;
    onAlertClosed?: () => void;
    noDestroy?: boolean;
};
declare const Alert: React__default.FunctionComponent<AlertTypes>;

interface AvatarProps {
    isUploadable?: boolean;
    src?: string;
    alt?: string;
    size?: "2xs" | "xs" | "sm" | "default" | "lg" | "xl" | "2xl" | "3xl" | "4xl" | "5xl" | "6xl";
    radius?: RadiusType;
    className?: string;
    icon?: React__default.ReactNode;
    hideIcon?: boolean;
}
declare const Avatar: React__default.FC<AvatarProps>;

type LabelProps = {
    hint?: React$1.ReactNode;
    hintSide?: PositionType;
    htmlFor?: string;
    required?: boolean;
};
declare const Label: React$1.ForwardRefExoticComponent<React$1.LabelHTMLAttributes<HTMLLabelElement> & LabelProps & React$1.RefAttributes<HTMLLabelElement>>;

declare const buttonVariants: (props?: ({
    variant?: "default" | "neoBrutalism" | "link" | "combobox" | "light" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
    size?: "default" | "xs" | "sm" | "lg" | "xl" | "icon" | "heightless" | "smallIcon" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;
interface ButtonProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
    asChild?: boolean;
    centered?: boolean;
    isLoading?: boolean;
    label?: string;
    labelProps?: LabelProps;
    /** The small red text under the input field to show validation.   */
    helperText?: any;
    showHelperText?: boolean;
    /**
     * If true, the button will include a label and helper text. This is useful for forms where the button is part of the form.
     */
    asInput?: boolean;
}
declare const Button: React$1.ForwardRefExoticComponent<ButtonProps & React$1.RefAttributes<HTMLButtonElement>>;

type DataTableProps<DataProps = {}> = {
    direction?: DirectionType;
    columns: ColumnDef<DataProps>[];
    enableSearch?: boolean;
    enableHideColumns?: boolean;
    enableGoTo?: boolean;
    enableSelection?: boolean;
    enableFiltering?: boolean;
    resetSelection?: boolean;
    filters?: {
        accessorKey: string;
        value: string;
        label: string;
    }[];
    hideHeader?: boolean;
    data: DataProps[];
    itemsPerPage?: any[];
    showCount?: boolean;
    showSelectionCount?: boolean;
    paginationPosition?: "top" | "bottom";
    condensed?: boolean;
    isLoading?: boolean;
    defaultSort?: string;
    translateFn?: any;
    bulkActions?: any[];
    texts?: {
        columns?: string;
        searchPlaceholder?: string;
        item?: string;
        noData?: any;
        page?: string;
        filter?: string;
        of?: string;
        total?: string;
        goTo?: string;
        selectedRows?: string;
        bulkAction?: string;
    };
};
declare module "@tanstack/table-core" {
    interface ColumnMeta<TData extends RowData, TValue> {
        padding?: "condensed" | "default" | "noPadding";
        sortable?: boolean;
        hidden?: boolean;
        i18nKey?: string;
    }
}
declare const DataTable: <DataProps extends {}>({ columns, data, paginationPosition, translateFn, resetSelection, enableHideColumns, enableSelection, enableFiltering, enableSearch, enableGoTo, ...props }: DataTableProps<DataProps>) => React$1.JSX.Element;

type BackToTopTypes = {
    /** Horizontal padding relative to the attached corner */
    paddingX?: number;
    /** Vertical padding relative to the attached corner */
    paddingY?: number;
    /** Increase to the threshold of the scroll value that has to be passed for the button to appear */
    paddingThreshold?: number;
    corner?: "top-left" | "top-right" | "bottom-left" | "bottom-right";
    anchor: RefObject<HTMLInputElement>;
};
declare const BackToTop: FC<BackToTopTypes>;

type RadioOptionsTypes = {
    value: any;
    label: any;
    disabled?: any;
    sublabel?: any;
    icon?: any;
    tooltip?: string;
    tooltipContentProps?: PopoverContentProps;
};
type RadioTypes = {
    /** Required to enable selection and differentiate between different Radio instances. */
    name: string;
    disabled?: boolean;
    orientation?: OrientationType;
    design?: "default" | "tabs" | "cards" | "bordered";
    width?: "default" | "full" | "none";
    size?: "default" | "lg" | "sm" | "xs";
    options: RadioOptionsTypes[];
    onChange?: any;
    defaultValue?: any;
    value?: any;
    direction?: DirectionType;
    helperText?: any;
    labelProps?: LabelProps;
    label?: string;
    tabsContainerClassName?: string;
    forceHideHelperText?: boolean;
    containerClassNames?: {
        bordered?: string;
        tabs?: string;
        cards?: string;
        default?: string;
    };
};
declare const Radio: React__default.ForwardRefExoticComponent<RadioTypes & React__default.RefAttributes<HTMLInputElement>>;

interface TableHeadProps extends React$1.ThHTMLAttributes<HTMLTableCellElement> {
    clickable?: boolean;
    condensed?: boolean;
}
interface TableCellProps extends React$1.TdHTMLAttributes<HTMLTableCellElement> {
    condensed?: boolean;
    enablePadding?: boolean;
    padding?: "condensed" | "default" | "noPadding";
}
declare const Table: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableElement> & React$1.RefAttributes<HTMLTableElement>>;
declare const TableHeader: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
declare const TableHead: React$1.ForwardRefExoticComponent<TableHeadProps & React$1.RefAttributes<HTMLTableCellElement>>;
declare const TableBody: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
declare const TableFooter: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
declare const TableRow: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableRowElement> & React$1.RefAttributes<HTMLTableRowElement>>;
declare const TableCell: React$1.ForwardRefExoticComponent<TableCellProps & React$1.RefAttributes<HTMLTableCellElement>>;
declare const TableCaption: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableCaptionElement> & React$1.RefAttributes<HTMLTableCaptionElement>>;

interface CommandProps extends React$1.ComponentPropsWithoutRef<typeof Command$1> {
}
interface CommandDialogProps extends DialogProps {
}
interface CommandInputProps extends React$1.ComponentPropsWithoutRef<typeof Command$1.Input> {
}
interface CommandListProps extends React$1.ComponentPropsWithoutRef<typeof Command$1.List> {
}
interface CommandEmptyProps extends React$1.ComponentPropsWithoutRef<typeof Command$1.Empty> {
}
interface CommandGroupProps extends React$1.ComponentPropsWithoutRef<typeof Command$1.Group> {
}
interface CommandSeparatorProps extends React$1.ComponentPropsWithoutRef<typeof Command$1.Separator> {
}
interface CommandItemProps extends React$1.ComponentPropsWithoutRef<typeof Command$1.Item> {
}
interface CommandShortcutProps extends React$1.HTMLAttributes<HTMLSpanElement> {
}
declare const Command: React$1.ForwardRefExoticComponent<CommandProps & React$1.RefAttributes<HTMLDivElement>>;
declare const CommandDialog: ({ children, ...props }: CommandDialogProps) => React$1.JSX.Element;
declare const CommandInput: React$1.ForwardRefExoticComponent<CommandInputProps & React$1.RefAttributes<HTMLInputElement>>;
declare const CommandList: React$1.ForwardRefExoticComponent<CommandListProps & React$1.RefAttributes<HTMLDivElement>>;
declare const CommandEmpty: React$1.ForwardRefExoticComponent<CommandEmptyProps & React$1.RefAttributes<HTMLDivElement>>;
declare const CommandGroup: React$1.ForwardRefExoticComponent<CommandGroupProps & React$1.RefAttributes<HTMLDivElement>>;
declare const CommandSeparator: React$1.ForwardRefExoticComponent<CommandSeparatorProps & React$1.RefAttributes<HTMLDivElement>>;
declare const CommandItem: React$1.ForwardRefExoticComponent<CommandItemProps & React$1.RefAttributes<HTMLDivElement>>;
declare const CommandShortcut: {
    ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement> & CommandShortcutProps): React$1.JSX.Element;
    displayName: string;
};
type FullCommandItem = {
    type: "group" | "separator";
    heading?: string;
    items?: {
        icon: React$1.ElementType;
        label: string | React$1.ReactNode;
        action: () => void;
        shortcut?: string;
    }[];
};
type FullCommandProps = {
    items: FullCommandItem[];
    direction?: DirectionType;
    onActionClick?: () => void;
    texts?: {
        searchPlaceholder?: string;
        emptyText?: string;
    };
};
declare const FullCommand: ({ items, direction, texts, onActionClick, }: FullCommandProps) => React$1.JSX.Element;
type AppCommandProps = {
    commandProps: Omit<FullCommandProps, "onActionClick">;
    dialogProps: DialogProps;
    onActionClick?: () => void;
};
declare const AppCommand: ({ commandProps, dialogProps, onActionClick, }: AppCommandProps) => React$1.JSX.Element;

type ComboboxTypes<T> = {
    labelKey?: keyof T | any;
    valueKey?: keyof T | any;
    data: T[];
    width?: string;
    texts?: {
        noItems?: string;
        placeholder?: string;
        searchPlaceholder?: string;
    };
    isLoading?: boolean;
    helperText?: any;
    popoverClassName?: string;
    /** This the same value as the one with the key valueKey */
    defaultValue?: string;
    preview?: boolean;
    hideInput?: boolean;
    direction?: DirectionType;
    inputProps?: CommandInputProps;
    id?: string;
    /** The label of the input field   */
    label?: any;
    labelProps?: LabelProps;
    /** If true, it will show a red asterisk next to the label*/
    isRequired?: boolean;
    onChange?: (e: any) => void;
    renderOption?: (item: T) => React$1.ReactNode;
    renderSelected?: (item: T) => React$1.ReactNode;
};
declare const Combobox: React$1.ForwardRefExoticComponent<ComboboxTypes<any> & React$1.RefAttributes<HTMLDivElement>>;

interface TextareaProps extends React$1.TextareaHTMLAttributes<HTMLTextAreaElement> {
    helperText?: any;
    isLoading?: boolean;
    /** The label of the input field   */
    label?: any;
    labelProps?: LabelProps;
    forceHideHelperText?: boolean;
    textareaProps?: React$1.TextareaHTMLAttributes<HTMLTextAreaElement>;
    showCount?: boolean;
    countPosition?: "top" | "bottom";
    classNames?: {
        textarea?: string;
    };
}
declare const Textarea: React$1.ForwardRefExoticComponent<TextareaProps & React$1.RefAttributes<HTMLTextAreaElement>>;

type FileDropzoneTypes = {
    /**  The text label above the component. Consistant with the other form input fields   */
    label?: string;
    files: [File];
    setFiles: any;
    setDeletedFiles: any;
    maxFiles: number;
    accept: any;
    onAcceptedFiles: any;
    showPreview: any;
    onDeleteFile: any;
    onClearFiles: any;
    maxSize: number;
    errorMessages: string;
    disclaimer?: boolean;
    termsLink?: string;
    privacyLink?: string;
    /** The translation object, use this to replace the default text with any translated text you want.*/
    texts: {
        errorUploading: any;
        clickHereToUpload: any;
        maxFileSize: any;
        tooManyFiles: any;
        fileTooLarge: any;
        acceptedFileTypes: any;
        invalidFileType: any;
        terms?: string;
        privacyPolicy?: string;
        disclaimer?: string;
        and?: string;
    };
};
declare const FileDropzone: React__default.FunctionComponent<FileDropzoneTypes>;

type SortButtonProps = {
    onSort: () => void;
    label: string;
    condensed?: boolean;
};
declare const SortButton: React__default.FC<SortButtonProps>;

type TabsVariants = "default" | "underlined" | "underlined_tabs";
declare const Tabs: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
    variant?: TabsVariants;
    scrollable?: boolean;
} & React$1.RefAttributes<HTMLDivElement>>;
declare const TabsList: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
    classNames?: {
        scrollArea?: string;
    };
} & React$1.RefAttributes<HTMLDivElement>>;
declare const TabsTrigger: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & {
    chipProps?: ChipTypes;
    className?: string;
    showPopover?: boolean;
    popoverContent?: React$1.ReactNode;
    withPopover?: boolean;
    onPopoverClick?: () => void;
} & React$1.RefAttributes<HTMLButtonElement>>;
declare const TabsContent: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;

type TextFieldTypes = React__default.InputHTMLAttributes<HTMLInputElement> & {
    isLoading?: boolean;
    isLoadingError?: boolean;
    containerClassName?: string;
    margin?: "none" | "normal" | "large";
    width?: "small" | "normal" | "full" | "auto";
    /** The label of the input field   */
    label?: any;
    labelProps?: LabelProps;
    hideSeparator?: boolean;
    /** The small red text under the input field to show validation.   */
    helperText?: any;
    prefixText?: any;
    forceHideHelperText?: boolean;
    inputProps?: React__default.InputHTMLAttributes<HTMLInputElement>;
    /** The icon inside the input field */
    icon?: any;
    /** Boolean to enable/disable editing the input field and using it as a text field   */
    preview?: boolean;
    iconInside?: React__default.ReactNode;
    endIcon?: React__default.ReactNode;
    endIconProps?: {
        className?: string;
    };
    startIcon?: React__default.ReactNode;
    placeholder?: React__default.ReactNode;
    /** Show the count of characters left in the input field. Works along with maxLength prop.   */
    showCount?: boolean;
    countPosition?: "top" | "bottom" | "center";
    popup?: boolean;
    popupContent?: React__default.ReactNode;
    outsidePrefix?: any;
    loadingErrorMesssage?: string;
};
declare const Input: React__default.ForwardRefExoticComponent<React__default.InputHTMLAttributes<HTMLInputElement> & {
    isLoading?: boolean;
    isLoadingError?: boolean;
    containerClassName?: string;
    margin?: "none" | "normal" | "large";
    width?: "small" | "normal" | "full" | "auto";
    /** The label of the input field   */
    label?: any;
    labelProps?: LabelProps;
    hideSeparator?: boolean;
    /** The small red text under the input field to show validation.   */
    helperText?: any;
    prefixText?: any;
    forceHideHelperText?: boolean;
    inputProps?: React__default.InputHTMLAttributes<HTMLInputElement>;
    /** The icon inside the input field */
    icon?: any;
    /** Boolean to enable/disable editing the input field and using it as a text field   */
    preview?: boolean;
    iconInside?: React__default.ReactNode;
    endIcon?: React__default.ReactNode;
    endIconProps?: {
        className?: string;
    };
    startIcon?: React__default.ReactNode;
    placeholder?: React__default.ReactNode;
    /** Show the count of characters left in the input field. Works along with maxLength prop.   */
    showCount?: boolean;
    countPosition?: "top" | "bottom" | "center";
    popup?: boolean;
    popupContent?: React__default.ReactNode;
    outsidePrefix?: any;
    loadingErrorMesssage?: string;
} & React__default.RefAttributes<HTMLInputElement>>;

declare const PopoverContent: React$1.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
    container?: HTMLElement | null;
} & React$1.RefAttributes<HTMLDivElement>>;
interface PopoverProps {
    side?: PositionType;
    align?: "start" | "center" | "end";
    trigger?: React$1.ReactNode;
    children: React$1.ReactNode;
    className?: string;
    sideOffset?: number;
    disableTrigger?: any;
    width?: "trigger" | "default";
    open?: boolean;
    contentProps?: PopoverPrimitive.PopoverContentProps;
    triggerProps?: PopoverPrimitive.PopoverTriggerProps;
}
type HawaPopoverTypes = PopoverProps & React$1.ComponentProps<typeof PopoverPrimitive.Root>;
declare const Popover: React$1.FC<HawaPopoverTypes>;
declare const PopoverTrigger: React$1.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
declare const PopoverPortal: React$1.FC<PopoverPrimitive.PopoverPortalProps>;
declare const PopoverRoot: React$1.FC<PopoverPrimitive.PopoverProps>;

type SelectOptionProps = {
    value: any;
    label: any;
};
type SelectTypes = {
    label?: string;
    hideHelperText?: boolean;
    options: SelectOptionProps[];
    labelKey?: string;
    isCreatable?: boolean;
    isClearable?: boolean;
    isMulti?: boolean;
    isSearchable?: boolean;
    controlClassNames?: string;
    containerClassNames?: string;
    onChange: any;
    helperText?: any;
    onInputChange?: any;
    native?: any;
    width?: "full" | "small" | "fit";
    value?: any;
    children?: any;
    getOptionLabel?: any;
    disabled?: boolean;
    defaultValue?: any;
    handleCreateOption?: () => void;
    placeholder?: string;
    hideIndicator?: boolean;
    phoneCode?: boolean;
    isLoading?: any;
    labelProps?: LabelProps;
    texts?: {
        noOptions?: string;
        createLabel?: string;
    };
};
declare const Select: FC<SelectTypes>;

interface SwitchProps extends React$1.ComponentPropsWithoutRef<typeof SwitchPrimitives.Root> {
    size?: "default" | "sm" | "lg";
    label?: string;
    roundedness?: RadiusType;
}
declare const Switch: React$1.ForwardRefExoticComponent<SwitchProps & React$1.RefAttributes<HTMLButtonElement>>;

type CheckBoxTypes = {
    id: string;
    label?: React$1.ReactNode;
    sublabel?: React$1.ReactNode;
    helperText?: any;
    size?: "xs" | "sm" | "default" | "md" | "lg" | "xl";
    radius?: RadiusType;
};
type CheckboxProps = CheckBoxTypes & React$1.ComponentProps<typeof CheckboxElement>;
declare const Checkbox: React$1.FC<CheckboxProps>;
declare const CheckboxElement: React$1.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & {
    size?: "xs" | "sm" | "default" | "md" | "lg" | "xl";
    radius?: RadiusType;
} & React$1.RefAttributes<HTMLButtonElement>>;

declare const Progress: React$1.ForwardRefExoticComponent<Omit<ProgressPrimitive.ProgressProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
    label?: string;
    labelProps?: LabelProps;
} & React$1.RefAttributes<HTMLDivElement>>;

type BreadcrumbItemProps = {
    label: string;
    href: string;
};
interface BCTypes {
    /** The array of crumbs, each one with a label and a href link */
    breadcrumbLinks: BreadcrumbItemProps[];
    /** The separator between each crumb, can be character or React Node. The default is ">" */
    separator?: string | ReactNode;
    size?: "normal" | "small" | "xs";
}
declare const Breadcrumb: FC<BCTypes>;

type StoreButtonsTypes = {
    store: "apple" | "google";
};
declare const AppStores: FC<StoreButtonsTypes>;

type BadgeTypes = {
    position: "right" | "left";
    anchor: RefObject<HTMLElement>;
    size?: "small" | "default" | "large";
    text?: string | number;
    className?: string;
};
declare const Badge: FC<BadgeTypes>;
declare const BadgedComponent: ({ children, className, hideBadge, position, size, text, }: any) => React__default.JSX.Element;

type PhoneInputProps = {
    preferredCountry?: {
        label: string;
    };
    helperText?: any;
    label?: string;
    labelProps?: LabelProps;
    placeholder?: string;
    handleChange?: (value: string) => void;
    inputProps?: React__default.InputHTMLAttributes<HTMLInputElement>;
    countryCodes?: {
        label: string;
    }[];
};
declare const PhoneInput: FC<PhoneInputProps>;

declare const PinInputRoot: React$1.ForwardRefExoticComponent<(Omit<Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "onChange" | "value" | "maxLength" | "containerClassName" | "textAlign" | "onComplete" | "pushPasswordManagerStrategy" | "noScriptCSSFallback"> & {
    value?: string;
    onChange?: (newValue: string) => unknown;
    maxLength: number;
    textAlign?: "left" | "center" | "right";
    onComplete?: (...args: any[]) => unknown;
    pushPasswordManagerStrategy?: "increase-width" | "none";
    containerClassName?: string;
    noScriptCSSFallback?: string | null;
} & {
    render: (props: input_otp.RenderProps) => React$1.ReactNode;
    children?: never;
} & React$1.RefAttributes<HTMLInputElement>, "ref"> | Omit<Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "onChange" | "value" | "maxLength" | "containerClassName" | "textAlign" | "onComplete" | "pushPasswordManagerStrategy" | "noScriptCSSFallback"> & {
    value?: string;
    onChange?: (newValue: string) => unknown;
    maxLength: number;
    textAlign?: "left" | "center" | "right";
    onComplete?: (...args: any[]) => unknown;
    pushPasswordManagerStrategy?: "increase-width" | "none";
    containerClassName?: string;
    noScriptCSSFallback?: string | null;
} & {
    render?: never;
    children: React$1.ReactNode;
} & React$1.RefAttributes<HTMLInputElement>, "ref">) & React$1.RefAttributes<HTMLInputElement>>;
declare const PinInputGroup: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const PinInputSlot: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
    index: number;
} & React$1.RefAttributes<HTMLDivElement>>;
declare const PinInputSeperator: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
type PinInputProps = Omit<OTPInputProps, "render"> & {
    separatorPosition?: number;
    helperText?: any;
};
declare const PinInput: React$1.FC<PinInputProps>;

declare const StopPropagationWrapper: (props: any) => React__default.JSX.Element;

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

type ColorPickerTypes = {
    label?: string;
    id?: string;
    isLoading?: boolean;
    labelProps?: LabelProps;
    helperText?: any;
    forceHideHelperText?: boolean;
    /** Boolean to enable/disable editing the input field and using it as a text field   */
    preview?: boolean;
    /** The hex code for the color */
    color?: any;
    /** Fires everytime the color changes */
    handleChange?: (e: ChangeEvent<HTMLInputElement>) => void;
    colorPickerClassNames?: string;
    colorTextClassNames?: string;
    colorPickerProps?: InputHTMLAttributes<HTMLInputElement>;
    textInputProps?: InputHTMLAttributes<HTMLInputElement>;
    containerProps?: InputHTMLAttributes<HTMLDivElement>;
};
declare const ColorPicker: FC<ColorPickerTypes>;

type Size = "xs" | "sm" | "md" | "lg" | "xl";
interface ProgressCircleProps extends React__default.HTMLAttributes<HTMLDivElement> {
    value: number;
    size?: Size;
    color?: any;
    showAnimation?: boolean;
    tooltip?: string;
    radius?: number;
    strokeWidth?: number;
    children?: React__default.ReactNode;
}
declare const ProgressCircle: React__default.ForwardRefExoticComponent<ProgressCircleProps & React__default.RefAttributes<HTMLDivElement>>;

type PaginationProps = {
    direction?: DirectionType;
    totalPages: number;
    currentPage?: number;
};
declare const Pagination: React__default.FC<PaginationProps>;

type PasswordInputIndicatorProps = {
    strength?: any;
};
declare const PasswordStrengthIndicator: React__default.FC<PasswordInputIndicatorProps>;
type PasswordInputType$1 = {
    onChange?: (e: React__default.ChangeEvent<HTMLInputElement>) => void;
    hidePopover?: boolean;
};
declare const PasswordInput: React__default.FC<PasswordInputType$1>;

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

type SimpleTableProps<DataProps = {}> = {
    direction?: DirectionType;
    columns: ColumnDef<DataProps>[];
    headerless?: boolean;
    data: DataProps[];
    condensed?: boolean;
    isLoading?: boolean;
    defaultSort?: string;
    classNames?: string;
    extra?: React$1.ReactNode;
    texts?: {
        searchPlaceholder?: string;
        noData?: any;
        page?: string;
        filter?: string;
        of?: string;
        total?: string;
    };
};
declare module "@tanstack/table-core" {
    interface ColumnMeta<TData extends RowData, TValue> {
        padding?: "condensed" | "default" | "noPadding";
        sortable?: boolean;
        hidden?: boolean;
    }
}
declare const SimpleTable: <DataProps extends {}>({ columns, data, classNames, headerless, ...props }: SimpleTableProps<DataProps>) => React$1.JSX.Element;

type SeparatorProps = {
    className?: string;
    orientation?: OrientationType;
};
declare const Separator: React$1.FC<SeparatorProps>;

type ScrollIndicatorProps = {
    anchor: RefObject<HTMLInputElement>;
    inContainer?: boolean;
};
declare const ScrollIndicator: FC<ScrollIndicatorProps>;

type CodeBlockTypesBase = {
    /** Specifies the programming language for syntax highlighting.*/
    language?: HighlightProps["language"];
    /** Defines the width of the code block.*/
    width?: "full" | "md" | "sm";
    /** Name of the file being displayed.   */
    fileName?: string;
    /** line numbers for code block   */
    lineNumbers?: boolean;
    /** Wrap text in code block */
    wrapText?: boolean;
    /** Custom class names for the code block */
    classNames?: {
        root?: string;
        tabs?: string;
        tab?: string;
        code?: string;
        fileName?: string;
        codeBlockContainer?: string;
    };
};
/**
 * Type for when tabs are provided. In this case, the code property is optional.
 * Do not provide the "code" prop if "tabs" exists.
 */
type CodeBlockTypesWithTabs = CodeBlockTypesBase & {
    /** Array of tabs each containing a title and code content.*/
    tabs: {
        title: string;
        code: string;
    }[];
    /** Code content to be displayed within the code block.*/
    code?: string;
};
/**
 * Type for when tabs are not provided. In this case, the code property is required.
 * You must provide the "code" prop if "tabs" does not exist.
 */
type CodeBlockTypesWithoutTabs = CodeBlockTypesBase & {
    /** Array of tabs each containing a title and code content.*/
    tabs?: never;
    /** Code content to be displayed within the code block.*/
    code: string;
};
/**
 * Either provide "tabs" prop (in which case "code" is optional),
 * or do not provide "tabs" (in which case "code" is required).
 */
type CodeBlockTypes = CodeBlockTypesWithTabs | CodeBlockTypesWithoutTabs;
declare const CodeBlock: FC<CodeBlockTypes>;

type CarouselProps = {
    items: React__default.ReactNode[];
    showArrows?: boolean;
    autoplay?: boolean;
    autoplayInterval?: number;
    options?: EmblaOptionsType;
    direction?: DirectionType;
};
declare const Carousel: React__default.FC<CarouselProps>;

type IconCountTypes = {
    /** The icon of the counter */
    icon: JSX.Element;
    /** The text next to the icon */
    count?: string;
};
declare const Count: FC<IconCountTypes>;

declare const ToastProvider: React$1.FC<ToastPrimitives.ToastProviderProps>;
declare const ToastViewport: React$1.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastViewportProps & React$1.RefAttributes<HTMLOListElement>, "ref"> & React$1.RefAttributes<HTMLOListElement>>;
declare const Toast$1: React$1.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastProps & React$1.RefAttributes<HTMLLIElement>, "ref"> & VariantProps<(props?: ({
    variant?: "default" | "destructive" | null | undefined;
    severity?: "none" | "info" | "warning" | "error" | "success" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string> & {
    direction?: DirectionType;
} & React$1.RefAttributes<HTMLLIElement>>;
declare const ToastAction: React$1.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastActionProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
declare const ToastClose: React$1.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastCloseProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
declare const ToastTitle: React$1.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastTitleProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
    size: "default" | "sm";
} & React$1.RefAttributes<HTMLDivElement>>;
declare const ToastDescription: React$1.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastDescriptionProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
    size: "default" | "sm";
} & React$1.RefAttributes<HTMLDivElement>>;
type ToastProps = React$1.ComponentPropsWithoutRef<typeof Toast$1>;
type ToastActionElement = React$1.ReactElement<typeof ToastAction>;
type ToasterToastProps = ToastProps & {
    id: string;
    title?: React$1.ReactNode;
    description?: React$1.ReactNode;
    severity?: "info" | "warning" | "error" | "success" | "none";
    action?: ToastActionElement;
    size?: "default" | "sm";
};

type ToasterProps = {
    direction?: DirectionType;
    toasts?: ToasterToastProps[];
};
declare function Toaster(props: ToasterProps): React__default.JSX.Element;

type DestroyableCard = {
    position?: "bottom-right" | "bottom-left";
    direction?: DirectionType;
    fixed?: boolean;
    children?: any;
};
declare const DestroyableCard: FC<DestroyableCard>;

type TypographyTypes = {
    /** Function to handle language change.   */
    handleLanguage?: (e: any) => void;
    /** Current selected language.   */
    currentLanguage?: string;
    /** Function to handle theme color mode change.   */
    handleColorMode?: (e: any) => void;
    /** Current selected theme color mode.   */
    currentColorMode?: "light" | "dark";
    orientation?: OrientationType;
    width?: "default" | "full";
};
declare const InterfaceSettings: FC<TypographyTypes>;

declare const FileUploader: ({ handleFile, className }: any) => React__default.JSX.Element;

type PhoneMockupProps = {
    children?: any;
    upperOverlayGradiant?: boolean;
    lowerOverlayGradiant?: boolean;
    phone?: "iphone" | "android" | "default";
    hideButtons?: boolean;
};
declare const PhoneMockup: React__default.FC<PhoneMockupProps>;

interface StatTypes extends React__default.HTMLAttributes<HTMLDivElement> {
    label?: string;
    color?: string;
    number?: string;
    helperText?: any;
    helperTextColor?: "default" | "positive" | "negative" | "muted";
    chart?: any;
    icon?: React__default.ReactNode;
    variant?: "default" | "plain" | "contained" | "outlined" | "brutalist" | "dropshadow";
    width?: "full" | "min" | "normal";
    isLoading?: boolean;
    className?: string;
    clickable?: boolean;
}
declare const Stats: FC<StatTypes>;

type AppSidebarItemProps = {
    value: string;
    slug?: string;
    label: string;
    badge?: {
        label: string;
        color?: ChipColors;
    };
    icon?: any;
    subitems?: SubItem[];
    onClick?: (e: React$1.MouseEvent) => void;
    onMouseDown?: (e: React$1.MouseEvent) => void;
};
type SubItem = {
    value: string;
    label: string;
    slug?: string;
    badge?: {
        label: string;
        color?: ChipColors;
    };
    icon?: any;
    onMouseDown?: (e: React$1.MouseEvent) => void;
    onClick?: (e: React$1.MouseEvent) => void;
};
interface SidebarGroupProps {
    title?: string;
    items: AppSidebarItemProps[];
    openedItem?: any;
    setOpenedItem?: any;
    selectedItem?: any;
    isOpen?: boolean;
    onItemClick?: (value: string[]) => void;
    onSubItemClick?: (values: string[]) => void;
    direction?: DirectionType;
    LinkComponent?: any;
}
declare const SidebarGroup: React$1.FC<SidebarGroupProps>;
declare const SidebarItem: React$1.FC<{
    item: AppSidebarItemProps;
    selectedItem?: any;
    direction?: DirectionType;
    onItemClick?: (value: string[]) => void;
    onSubItemClick?: (values: string[]) => void;
    isOpen?: boolean;
    LinkComponent?: any;
}>;

type CopyRightsTypes = {
    /** A text used as the version of the app, for example: v1.0.0 */
    version?: string;
    /** Credit to the creator of the app, for example: Sikka Software */
    credits?: string;
    /** The URL of the logo in the copyrights */
    logoURL?: string;
    /** Enable/Disable the existance of the logo */
    withLogo?: boolean;
    /** Fires when the logo is clicked, usually goes to the website of the creator of the app */
    onLogoClicked?: any;
};
declare const Copyrights: FC<CopyRightsTypes>;

type NavigationMenuItem = {
    label: string;
    action: () => void;
    trigger?: any;
};
type NavbarType = {
    logo?: any;
    buttons?: any;
    menuItems?: NavigationMenuItem[];
    handleLogoClick?: () => void;
    backgroundColor?: string;
};
declare const Navbar: React__default.FC<NavbarType>;

type AppLayoutTypes$1 = {
    /** a custom header to replace the logoLink & logoSymbol */
    header?: React__default.ReactNode;
    design?: "default";
    bordered?: boolean;
    /** The pages of the side drawer */
    drawerItems: AppSidebarItemProps[];
    /** The direction of the layout */
    direction?: DirectionType;
    /** The title of the current selected page, make sure it's the same as the drawerItem slug */
    currentPage: string;
    /** Specifies the title of the page. */
    pageTitle?: string;
    /** Specifies the symbol for the logo. */
    logoSymbol?: any;
    /** Specifies the link for the logo. */
    logoLink?: string;
    /** Specifies the text for the logo. */
    logoText?: any;
    /** Specifies the content to be displayed in the layout. */
    children?: any;
    /** Specifies whether to display the top bar. */
    topBar?: boolean;
    /** Specifies the username to be displayed. */
    username?: string;
    /** Specifies the user email to be displayed. */
    email?: string;
    /** Specifies the image for the avatar. */
    avatarImage?: any;
    /**
     * Specifies the size of the drawer.
     * - 'sm': Small.
     * - 'md': Medium.
     * - 'large': Large.
     */
    drawerSize?: "sm" | "md" | "large";
    /** Specifies the menu items for the profile menu. */
    profileMenuItems?: MenuItemType[];
    onAvatarClick?: () => void;
    /**
     * Specifies the width of the profile menu.
     * - 'default': Default width.
     * - 'sm': Small width.
     * - 'lg': Large width.
     * - 'parent': Inherits width from parent element.
     */
    profileMenuWidth?: "default" | "sm" | "lg" | "parent";
    /** Specifies additional actions for the drawer footer. */
    DrawerFooterActions?: any;
    /** Specifies the item that was clicked. */
    clickedItem?: any;
    /** Event handler for logo button click. */
    onLogoClick?: () => void;
    /** Event handler for drawer expanded. */
    onDrawerExpanded?: (isExpanded: boolean) => void;
    /** Text labels for various UI elements. */
    texts?: {
        /** Label for expand sidebar button. */
        expandSidebar?: string;
        /** Label for collapse sidebar button. */
        collapseSidebar?: string;
    };
    classNames?: {
        fullLogoImg?: string;
        symbolLogoImg?: string;
        logoContainer?: string;
    };
    DrawerLinkComponent?: any;
    MenuLinkComponent?: any;
};
declare const AppLayout: React__default.FunctionComponent<AppLayoutTypes$1>;

type AppTopbarType = {
    direction?: DirectionType;
    size?: number;
    username?: string;
    email?: string;
    profileMenuItems?: MenuItemType[];
    avatarImage?: string;
};
declare const AppTopbar: React__default.FC<AppTopbarType>;

declare const MenubarMenu: React$1.FC<React$1.ComponentPropsWithoutRef<typeof MenubarPrimitive.Menu>>;
declare const MenubarGroup: React$1.FC<React$1.ComponentPropsWithoutRef<typeof MenubarPrimitive.Group>>;
declare const MenubarPortal: React$1.FC<React$1.ComponentPropsWithoutRef<typeof MenubarPrimitive.Portal>>;
declare const MenubarSub: React$1.FC<React$1.ComponentPropsWithoutRef<typeof MenubarPrimitive.Sub>>;
declare const MenubarRadioGroup: React$1.FC<React$1.ComponentPropsWithoutRef<typeof MenubarPrimitive.RadioGroup>>;
declare const Menubar: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const MenubarTrigger: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
declare const MenubarSubTrigger: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarSubTriggerProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean;
} & React$1.RefAttributes<HTMLDivElement>>;
declare const MenubarSubContent: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarSubContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const MenubarContent: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const MenubarItem: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean;
} & React$1.RefAttributes<HTMLDivElement>>;
declare const MenubarCheckboxItem: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarCheckboxItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const MenubarRadioItem: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarRadioItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const MenubarLabel: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean;
} & React$1.RefAttributes<HTMLDivElement>>;
declare const MenubarSeparator: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const MenubarShortcut: {
    ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): React$1.JSX.Element;
    displayname: string;
};

type SingleAppTab = {
    label: string;
    value?: string;
    icon?: React__default.ReactNode;
    path?: string;
    action?: any;
    onMouseDown?: any;
    onClick?: any;
};
type AppTabsType = {
    className?: string;
    tabs: SingleAppTab[];
};
declare const AppTabs: React__default.FC<AppTabsType>;

type AppLayoutTypes = {
    pages?: any[];
    /** The direction of the layout */
    direction?: DirectionType;
    /** Specifies the title of the page. */
    pageTitle?: string;
    /** Specifies the symbol for the logo. */
    logoSymbol?: any;
    /** Specifies the link for the logo. */
    logoLink?: string;
    /** Specifies the content to be displayed in the layout. */
    children?: any;
    /** Specifies the image for the avatar. */
    avatarImage?: any;
    /**
     * Specifies the size of the drawer.
     * - 'sm': Small.
     * - 'md': Medium.
     * - 'large': Large.
     */
    drawerSize?: "sm" | "md" | "large";
    /** Specifies whether to keep the drawer open. */
    keepOpen: boolean;
    setKeepOpen: (value: boolean) => void;
    /** Specifies additional actions for the drawer footer. */
    DrawerFooterActions?: any;
    /** Specifies the item that was clicked. */
    clickedItem?: any;
    /** Event handler for logo button click. */
    onLogoClick?: () => void;
};
declare const DocsLayout: React__default.FunctionComponent<AppLayoutTypes>;

type DocsSidebarType = {
    pages: any[];
    currentPage?: string;
    direction?: DirectionType;
};
declare const DocsSidebar: React__default.FC<DocsSidebarType>;

type PricingPlanTexts = {
    title?: string;
    subtitle?: string;
    buttonText?: string;
    cycleText?: string;
    currencyText?: string;
    soon?: string;
    recommended?: string;
    priceless?: string;
};
type ThirdPartyAuthTextsTypes = {
    continueWithGoogle?: string;
    continueWithTwitter?: string;
    continueWithApple?: string;
    continueWithMicrosoft?: string;
    continueWithGithub?: string;
    continueWithEmail?: string;
    continueWithPhone?: string;
    continueWithNafath?: string;
    continueWithMetamask?: string;
};
type BaseInputType = {
    label?: string;
    placeholder?: string;
};
type ValidationTexts = {
    required?: string;
    invalid?: string;
};
type TextInputType = ValidationTexts & {
    label?: string;
    placeholder?: string;
};
type PasswordInputType = BaseInputType & {
    required?: string;
    tooShort?: string;
};
type UsernameInputType = TextInputType & {
    tooShort?: string;
    tooLong?: string;
};
type ConfirmInputType = BaseInputType & {
    required?: string;
    dontMatch?: string;
};
type LoginFormTextsTypes = ThirdPartyAuthTextsTypes & {
    email?: TextInputType;
    username?: UsernameInputType;
    phone?: TextInputType;
    password?: PasswordInputType;
    forgotPassword?: string;
    newUserText?: string;
    createAccount?: string;
    loginText?: string;
};
type RegisterFormTextsTypes = ThirdPartyAuthTextsTypes & {
    fullName?: BaseInputType;
    email?: TextInputType;
    username?: UsernameInputType;
    password?: PasswordInputType;
    confirm?: ConfirmInputType;
    userReference?: BaseInputType;
    subscribeToNewsletter?: string;
    termsRequired?: string;
    refCode?: string;
    refCodePlaceholder?: string;
    existingUserText?: string;
    termsText?: string;
    iAcceptText?: string;
    registerText?: string;
    loginText?: string;
};
type ResetPasswordTextsTypes = {
    email?: TextInputType;
    emailSentText?: string;
    registerText?: string;
    resetPassword?: string;
    dontHaveAccount?: string;
    headTitle?: string;
    headDescription?: string;
};
type NewPasswordTextsTypes = {
    password?: PasswordInputType;
    confirm?: ConfirmInputType;
    updatePassword?: string;
    passwordChanged?: string;
    dontHaveAccount?: string;
    registerText?: string;
};

type AuthButtonsType = {
    texts?: ThirdPartyAuthTextsTypes;
    viaMetamask?: boolean;
    viaNafath?: boolean;
    viaGoogle?: boolean;
    viaTwitter?: boolean;
    viaGithub?: boolean;
    viaMicrosoft?: boolean;
    viaEmail?: boolean;
    viaPhone?: boolean;
    viaApple?: boolean;
    isMetamaskLoading?: boolean;
    isNafathLoading?: boolean;
    isGoogleLoading?: boolean;
    isGithubLoading?: boolean;
    isTwitterLoading?: boolean;
    isMicrosoftLoading?: boolean;
    isEmailLoading?: boolean;
    isPhoneLoading?: boolean;
    isAppleLoading?: boolean;
    handleMetamask?: () => void;
    handleNafath?: () => void;
    handleGoogle?: () => void;
    handleTwitter?: () => void;
    handleApple?: () => void;
    handleMicrosoft?: () => void;
    handleGithub?: () => void;
    handleEmail?: () => void;
    handlePhone?: () => void;
};
declare const AuthButtons: React__default.FC<AuthButtonsType>;

type PlanFeature = {
    soon?: boolean;
    included?: boolean;
    text: string;
    hint?: string;
    hintSide?: PositionType;
};
type PricingCardProps = {
    direction?: DirectionType;
    features: PlanFeature[];
    endButton?: boolean;
    price: number;
    oldPrice?: number;
    noPrice?: boolean;
    id?: string;
    discount?: string;
    onPlanClicked?: () => void;
    currentPlan?: boolean;
    recommended?: boolean;
    size?: "small" | "medium" | "large";
    isLoadingPrice?: boolean;
    isLoadingCard?: boolean;
    texts: PricingPlanTexts;
};

type LoginFormTypes = {
    /** Object containing text labels used throughout the form. */
    texts?: LoginFormTextsTypes;
    /** If true, only logos are displayed in third-party auth buttons.*/
    logosOnly?: boolean;
    /** Direction of text and UI elements, either left-to-right or right-to-left.   */
    direction?: DirectionType;
    /** If true, an error alert is displayed at the top of the form.   */
    showError?: boolean;
    /** Callback function triggered when the error alert is dismissed. */
    onErrorDismissed?: () => void;
    /** Title text of error alert.*/
    errorTitle?: string;
    /** Description text of error alert.   */
    errorText?: string;
    /** Login identifier type user will use to log in.   */
    loginType?: "email" | "username" | "phone" | "link";
    /** If true, the reset password option is hidden.   */
    withResetPassword?: boolean;
    /** If true, the register option is hidden.   */
    allowRegister?: boolean;
    /** If true, a loading spinner is displayed within the main form submit button.   */
    isLoading?: boolean;
    /** If true, a loading spinner is displayed within the Google login button.   */
    isGoogleLoading?: boolean;
    /** If true, a loading spinner is displayed within the Twitter login button.   */
    isTwitterLoading?: boolean;
    /** If true, a loading spinner is displayed within the Github login button.   */
    isGithubLoading?: boolean;
    /** If true, Google login option is displayed.   */
    viaGoogle?: boolean;
    /** If true, Github login option is displayed.   */
    viaGithub?: boolean;
    /** If true, Twitter login option is displayed.   */
    viaTwitter?: boolean;
    /** Function to handle form submission.   */
    onLogin: (e: any) => void;
    /** Function to route user to the register page.   */
    onRouteToRegister?: () => void;
    /** Function to handle forgotten password case.   */
    onForgotPassword?: () => void;
    /** Function to handle Google login.   */
    onGoogleLogin?: () => void;
    /** Function to handle Github login.   */
    onGithubLogin?: () => void;
    /** Function to handle Twitter login.   */
    onTwitterLogin?: () => void;
    /** Additional buttons to add under the login button */
    additionalButtons?: any;
    /** The minimum length of the password input field */
    minPasswordLength?: number;
    /** If true, the form is displayed without a card container styling.*/
    cardless?: boolean;
    /** Props to pass to the PhoneInput component */
    phoneInputProps?: PhoneInputProps;
};
declare const LoginForm: FC<LoginFormTypes>;

type RegisterFormTypes = {
    /** Object containing text labels used throughout the form. */
    texts?: RegisterFormTextsTypes;
    /** Direction of text and layout, either 'rtl' (right-to-left) or 'ltr' (left-to-right). */
    direction?: DirectionType;
    /** Determines whether to display logos only or with text in the social media registration section. */
    logosOnly?: boolean;
    /** Enables registration via Google when set to true. */
    viaGoogle?: boolean;
    /** Enables registration via Github when set to true. */
    viaGithub?: boolean;
    /** Enables registration via Twitter when set to true. */
    viaTwitter?: boolean;
    /** Determines whether to show the referral code field. */
    showRefCode?: boolean;
    /** Determines whether to show the user source selection. */
    showUserSource?: boolean;
    /** Determines whether to show the terms acceptance checkbox. */
    showTermsOption?: boolean;
    /** Determines whether to show the newsletter subscription checkbox. */
    showNewsletterOption?: boolean;
    /** Callback function triggered on form submission. */
    onRegister: (e: any) => void;
    /** Callback function triggered to route to the login page. */
    onRouteToLogin?: () => void;
    /** Callback function triggered to handle registration via Google. */
    onGoogleRegister?: () => void;
    /** Callback function triggered to handle registration via Github. */
    onGithubRegister?: () => void;
    /** Callback function triggered to handle registration via Twitter. */
    onTwitterRegister?: () => void;
    /** Callback function triggered to route to the Terms of Service page. */
    onRouteToTOS?: () => void;
    /** Determines whether to show an error alert. */
    showError?: boolean;
    /** Callback function triggered when the error alert is dismissed. */
    onErrorDismissed?: () => void;
    /** Title for the error alert. */
    errorTitle?: any;
    /** Text for the error alert. */
    errorText?: any;
    /** Array containing the fields to be included in the form. */
    registerFields?: string[];
    /** Indicates whether the form submission is in progress. */
    isLoading?: boolean;
    /** If true, a loading spinner is displayed within the Google login button.   */
    isGoogleLoading?: boolean;
    /** If true, a loading spinner is displayed within the Twitter login button.   */
    isTwitterLoading?: boolean;
    /** If true, a loading spinner is displayed within the Github login button.   */
    isGithubLoading?: boolean;
    /** The options of "How did you learn about us?" select field.   */
    userReferenceOptions?: SelectOptionProps[];
    /** To add more custom buttons under the register button.   */
    additionalButtons?: any;
    /** To add more custom input fields   */
    additionalInputs?: any;
    /** To customize the username input field   */
    usernameOptions?: {
        label?: LabelProps;
    };
    classNames?: {
        root?: string;
        form?: string;
        card?: string;
    };
    /** The minimum length of the password input field */
    minPasswordLength?: number;
    /** If true, the form is displayed without a card container styling.*/
    cardless?: boolean;
};
declare const RegisterForm: FC<RegisterFormTypes>;

type AppLandingTextsTypes = ThirdPartyAuthTextsTypes & {
    newUserText?: string;
    createAccount?: string;
};
type AppLandingTypes = {
    texts?: AppLandingTextsTypes;
    viaGoogle?: boolean;
    viaTwitter?: boolean;
    viaGithub?: boolean;
    viaMicrosoft?: boolean;
    viaEmail?: boolean;
    viaPhone?: boolean;
    viaApple?: boolean;
    allowRegister?: boolean;
    size?: "small" | "normal" | "full";
    direction?: DirectionType;
    handleRouteToRegister?: () => void;
    handleGoogle?: () => void;
    handleTwitter?: () => void;
    handleApple?: () => void;
    handleMicrosoft?: () => void;
    handleGithub?: () => void;
    handleEmail?: () => void;
    handlePhone?: () => void;
};
declare const AppLanding: FC<AppLandingTypes>;

type CheckEmailBlocks = {
    handleResend?: () => void;
    texts?: {
        checkEmail: string;
        resendEmail: string;
        pleaseVerify: string;
    };
};
declare const CheckEmail: FC<CheckEmailBlocks>;

type NewPasswordTypes = {
    handleNewPassword: (e: any) => void;
    handleRouteToRegister: () => void;
    isLoading: boolean;
    direction?: DirectionType;
    allowRegister?: boolean;
    showSuccess: boolean;
    texts: NewPasswordTextsTypes;
    /** If true, an error alert is displayed at the top of the form.   */
    showError?: boolean;
    /** Title text of error alert.   */
    errorTitle?: string;
    /** Description text of error alert.   */
    errorText?: string;
};
declare const NewPasswordForm: FC<NewPasswordTypes>;

type ResetPasswordType = {
    handleResetPassword: (e: any) => void;
    handleRouteToRegister: () => void;
    sent: any;
    isLoading: boolean;
    headless?: boolean;
    allowRegister?: boolean;
    direction?: DirectionType;
    texts?: ResetPasswordTextsTypes;
    /** If true, an error alert is displayed at the top of the form.   */
    showError?: boolean;
    /** Title text of error alert.   */
    errorTitle?: string;
    /** Description text of error alert.   */
    errorText?: string;
};
declare const ResetPasswordForm: FC<ResetPasswordType>;

type TConfirmation = {
    texts?: {
        checkYourPhone?: string;
        weSentCode?: string;
        didntGetCode?: string;
        resendCode?: string;
        resendCodeTimer?: string;
        codeRequiredText?: string;
        codeTooShort?: string;
        confirm?: string;
        cancel?: string;
        seconds?: string;
    };
    showError?: any;
    errorTitle?: any;
    errorText?: any;
    phoneNumber?: string;
    confirmLoading?: boolean;
    handleConfirm?: any;
    handleResend?: any;
    codeLength?: number;
};
declare const CodeConfirmation: FC<TConfirmation>;

type ComponentTypes$2 = {
    title?: string;
    question: string;
    description?: string;
    tag?: any;
    options?: RadioOptionsTypes[];
    position?: "bottom-right" | "bottom-left";
    direction?: DirectionType;
    onSubmitForm?: (e: any) => void;
    texts?: {
        pleaseSelectOption: string;
        textTooShort: string;
        submit?: string;
    };
};
declare const UserReferralSource: FC<ComponentTypes$2>;

type ComponentTypes$1 = {
    title?: string;
    question: string;
    banner?: boolean;
    options?: any[];
    position?: "bottom-right" | "bottom-left";
    onOptionClicked?: (option: any) => void;
    texts?: {
        least: string;
        most: string;
    };
};
declare const FeedbackRating: FC<ComponentTypes$1>;

type ComponentTypes = {
    handleSubmit: ({}: {}) => void;
    showSuccess?: boolean;
};
declare const FeedbackEmoji: FC<ComponentTypes>;

type FeedbackFormRequestTypeInputProps = BaseInputType & {
    required?: string;
    noOptions?: string;
};
type FeedbackFormDescriptionInputProps = BaseInputType & {
    required?: string;
    tooShort?: string;
};
type FeedbackFormType = {
    sent?: boolean;
    onSubmit: (e: any) => void;
    loadingSubmission?: boolean;
    requestTypes?: {
        label: string;
        value: any;
    }[];
    selectProps?: any;
    cardless?: boolean;
    texts: {
        requestType: FeedbackFormRequestTypeInputProps;
        description: FeedbackFormDescriptionInputProps;
        submit?: string;
        sentTitle?: string;
        sentSubtitle?: string;
    };
};
declare const FeedbackForm: React__default.FC<FeedbackFormType>;

type TabType = {
    title: string;
    content: string;
    value: string;
};
type LegalTextsType = {
    tabs: TabType[];
    activeTab?: any;
    handleTabChange?: any;
    direction?: any;
    defaultTab?: any;
    scrollAreaClassName?: string;
};
declare const LegalTexts: React__default.FC<LegalTextsType>;

type EmptyStateProps = {
    onActionClick: () => void;
    texts?: {
        youreCaughtUp?: string;
        actionText?: string;
    };
};
declare const EmptyState: FC<EmptyStateProps>;

type TestimonialProps = {
    variant?: "outlined" | "contained" | "neobrutalism";
};
declare const Testimonial: FC<TestimonialProps>;

type LGProps = {
    texts?: {
        title?: string;
        subtitle?: string;
        submit?: string;
        invalidEmail?: string;
    };
    submitHandler: (e: string) => void;
};
declare const LeadGenerator: FC<LGProps>;

type AnnouncementTypes = {
    onActionClick: () => void;
    actionText?: string;
    title?: string;
    subtitle?: string;
};
declare const Announcement: FC<AnnouncementTypes>;

type NotFoundTypes = {
    variant?: "outlined" | "contained" | "neobrutalism";
    texts?: {
        pageNotFound?: string;
        ifLost?: string;
        home?: string;
    };
};
declare const NotFound: FC<NotFoundTypes>;

type NoPermissionProps = {
    texts?: {
        title: string;
        subtitle: string;
    };
};
declare const NoPermission: FC<NoPermissionProps>;

type ContactFormData = {
    name: string;
    email: string;
    message: string;
} & {
    [key: string]: string;
};
type CustomField = {
    label: string;
    type: "text" | "number" | "select";
    name: string;
    placeholder?: string;
    options?: RadioOptionType[];
};
type ContactFormProps = {
    cardless?: boolean;
    formId?: string;
    formAutoComplete?: "on" | "off";
    size?: "sm" | "default";
    onSubmit: (e: ContactFormData) => void;
    customFields?: CustomField[];
    showSuccess?: boolean;
    classNames?: {
        submitButton?: string;
    };
    texts?: {
        submit: string;
        name: TextInputType;
        email: TextInputType;
        message: TextInputType;
        success?: {
            title?: string;
            description?: string;
        };
    };
};
declare const ContactForm: React__default.FC<ContactFormProps>;

type PricingPlansTypes = {
    loadingCards?: boolean;
    plans: PricingCardProps[];
    currencies: RadioOptionType[];
    billingCycles: RadioOptionType[];
    currentCycle: RadioOptionType;
    currentCurrency: RadioOptionType;
    onPlanClicked?: (e: any) => void;
    onCycleChange?: (e: any) => void;
    onCurrencyChange?: (e: any) => void;
    direction?: DirectionType;
    mainContainerProps?: InputHTMLAttributes<HTMLDivElement>;
    cardsContainerProps?: InputHTMLAttributes<HTMLDivElement>;
};
declare const PricingPlans: FC<PricingPlansTypes>;

type ComparingPlansTypes = {
    plans: {
        direction?: DirectionType;
        features: PlanFeature[];
        price?: number;
        texts?: PricingPlanTexts;
        size?: "small" | "medium" | "large";
    }[];
    currencies: RadioOptionType[];
    billingCycles: RadioOptionType[];
    currentCycle: RadioOptionType;
    currentCurrency: RadioOptionType;
    onCycleChange?: (e: any) => void;
    onCurrencyChange?: (e: any) => void;
    onPlanClicked?: (e: any) => void;
    direction?: DirectionType;
    showButtons?: boolean;
    topPosition?: number;
};
declare const ComparingPlans: FC<ComparingPlansTypes>;

type HorizontalPricingTypes = {
    plans: {
        currentPlan?: boolean;
        direction?: DirectionType;
        currency?: string;
        cycleText?: string;
        features?: PlanFeature[];
        price?: number;
        texts?: PricingPlanTexts;
        size?: "small" | "medium" | "large";
    }[];
    currencies: {
        label: string;
        value: string;
    }[];
    billingCycles: {
        label: string;
        value: string;
    }[];
    currentCycle?: RadioOptionType;
    currentCurrency?: RadioOptionType;
    onPlanClicked?: (e: any) => void;
    onCycleChange?: (e: any) => void;
    onCurrencyChange?: (e: any) => void;
    direction?: DirectionType;
};
declare const HorizontalPricing: FC<HorizontalPricingTypes>;

type ImageCardTypes = {
    children: any;
    align?: any;
    bottomElement?: any;
    inCardActions?: any;
    cardImage?: string;
    title?: string;
    subtitle?: string;
    blank?: boolean;
};
declare const ActionCard: FC<ImageCardTypes>;

type AdCardTypes = {
    orientation: OrientationType;
    title: string;
    description: string;
    imageURL: string;
    handleHide?: any;
    handleCantHide?: () => void;
    handleClick?: (e: React__default.MouseEvent) => void;
    canHide: boolean;
    className?: string;
};
declare const AdCard: FC<AdCardTypes>;

declare const PricingCard: FC<PricingCardProps>;

interface ItemCardTypes {
    headerActions?: MenuItemType[];
    header?: any;
    content?: any;
    /** a URL for the image of the card */
    cardImage?: string;
    /** a function that fires when the card is clicked anywhere */
    onCardClick?: (event: React__default.MouseEvent<HTMLDivElement>) => void;
    /** a React node with HawaIconCount children to have counters at the bottom of the card */
    counts?: JSX.Element;
    /** The action buttons on the bottom right of the card */
    actions?: JSX.Element;
    /** The orientation of the card */
    orientation?: OrientationType;
    /** Enabling this blurs the image on hover and shows an action button */
    clickableImage?: boolean;
    /** The function of the action button on the image of the card */
    onImageClick?: () => void;
    /** The text of the action button on the image of the card */
    clickableImageActionText?: string;
    /** The icon of the action button on the image of the card */
    clickableImageActionIcon?: any;
    className?: string;
}
declare const ItemCard: FC<ItemCardTypes>;

interface LandingCardTypes {
    title?: string;
    subtitle?: string;
    icon?: any;
    className?: string;
}
declare const LandingCard: FC<LandingCardTypes>;

type UsageCardTypes = {
    tooltip?: any;
    title: any;
    percent: any;
    currentUsage: any;
};
declare const Usage: FC<UsageCardTypes>;

declare const useIsomorphicEffect: typeof useEffect;

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: ToasterToastProps;
} | {
    type: ActionType["UPDATE_TOAST"];
    toast: Partial<ToasterToastProps>;
} | {
    type: ActionType["DISMISS_TOAST"];
    toastId?: ToasterToastProps["id"];
} | {
    type: ActionType["REMOVE_TOAST"];
    toastId?: ToasterToastProps["id"];
};
interface State {
    toasts: ToasterToastProps[];
}
declare const reducer: (state: State, action: Action) => State;
type Toast = Omit<ToasterToastProps, "id">;
declare function toast({ ...props }: Toast): {
    id: string;
    dismiss: () => void;
    update: (props: ToasterToastProps) => void;
};
declare function useToast(): {
    toast: typeof toast;
    dismiss: (toastId?: string) => void;
    toasts: ToasterToastProps[];
};

type DialogCarouselType = {
    canScrollPrev?: any;
    emblaRef?: any;
    emblaApi?: any;
    nextStep?: any;
    prevStep?: any;
};
declare const useDialogCarousel: (options?: any) => DialogCarouselType;

declare const useMultiStepDialog: (initialStep: any, stepIds: any[], setOpenDialog: any) => {
    currentStep: any;
    dialogHeight: null;
    visibleStepRef: React__default.MutableRefObject<any>;
    handleNext: () => void;
    handleBack: () => void;
};

declare function useClipboard({ timeout }?: {
    timeout?: number | undefined;
}): {
    copy: (value: any) => void;
    reset: () => void;
    error: Error | null;
    copied: boolean;
};

declare const useBreakpoint: () => any;

interface WindowSize {
    width: number | undefined;
    height: number | undefined;
}
declare const useWindowSize: () => WindowSize;

interface UseFocusWithinOptions {
    onFocus?(event: FocusEvent): void;
    onBlur?(event: FocusEvent): void;
}
declare function useFocusWithin<T extends HTMLElement = any>({ onBlur, onFocus, }?: UseFocusWithinOptions): {
    ref: React.MutableRefObject<T>;
    focused: boolean;
};

interface UseMediaQueryOptions {
    getInitialValueInEffect: boolean;
}
declare function useMediaQuery(query: string, initialValue?: boolean, { getInitialValueInEffect }?: UseMediaQueryOptions): boolean | undefined;

declare function useTabs(initialTab?: string): {
    activeTab: string;
    handleTabChange: (index: any) => void;
};

interface ContentRect {
    width: number;
    height: number;
    top: number;
    right: number;
    left: number;
    bottom: number;
}
declare const useMeasureDirty: (ref: RefObject<HTMLElement>) => ContentRect;

declare function useClickOutside<T extends HTMLElement = any>(handler: () => void, events?: string[] | null, nodes?: (HTMLElement | null)[]): React$1.MutableRefObject<T | undefined>;

type KeyboardModifiers = {
    alt: boolean;
    ctrl: boolean;
    meta: boolean;
    mod: boolean;
    shift: boolean;
};
type Hotkey = KeyboardModifiers & {
    key?: string;
};
type CheckHotkeyMatch = (event: KeyboardEvent) => boolean;
declare function parseHotkey(hotkey: string): Hotkey;
declare function getHotkeyMatcher(hotkey: string): CheckHotkeyMatch;
interface HotkeyItemOptions {
    preventDefault?: boolean;
}
declare function getHotkeyHandler(hotkeys: HotkeyItem[]): (event: React.KeyboardEvent<HTMLElement> | KeyboardEvent) => void;
type HotkeyItem = [
    string,
    (event: KeyboardEvent) => void,
    HotkeyItemOptions?
];
declare function useShortcuts(hotkeys: HotkeyItem[], tagsToIgnore?: string[], triggerOnContentEditable?: boolean): void;

declare function useWindowEvent<K extends string>(type: K, listener: K extends keyof WindowEventMap ? (this: Window, ev: WindowEventMap[K]) => void : (this: Window, ev: CustomEvent) => void, options?: boolean | AddEventListenerOptions): void;

declare function useViewportSize(): {
    width: number;
    height: number;
};

export { Accordion, AccordionContent, AccordionItem, type AccordionItemProps, AccordionRoot, AccordionTrigger, ActionCard, AdCard, Alert, Announcement, AppCommand, AppLanding, AppLayout, type AppSidebarItemProps, AppStores, AppTabs, AppTopbar, AuthButtons, Avatar, BackToTop, Badge, BadgedComponent, Breadcrumb, type BreadcrumbItemProps, Button, type ButtonProps, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, Carousel, CheckEmail, Checkbox, Chip, type ChipColors, type ChipTypes, CodeBlock, CodeConfirmation, ColorPicker, Combobox, Command, CommandDialog, CommandEmpty, CommandGroup, CommandInput, type CommandInputProps, CommandItem, CommandList, CommandSeparator, CommandShortcut, ComparingPlans, ContactForm, type ContentRect, Copyrights, Count, DataTable, DestroyableCard, Dialog, DialogBody, DialogCarousel, DialogCarouselContent, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogPortal, DialogStep, DialogSteps, DialogTitle, DialogTrigger, DocsLayout, DocsSidebar, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuRadio, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuRoot, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, EmptyState, FeedbackEmoji, FeedbackForm, FeedbackRating, FileDropzone, FileUploader, FullCommand, type FullCommandItem, HorizontalPricing, type Hotkey, type HotkeyItem, type HotkeyItemOptions, Input, InterfaceSettings, ItemCard, type KeyboardModifiers, Label, type LabelProps, LandingCard, LeadGenerator, LegalTexts, Loading, LoginForm, Logos, type MenuItemType, Menubar, MenubarCheckboxItem, MenubarContent, MenubarGroup, MenubarItem, MenubarLabel, MenubarMenu, MenubarPortal, MenubarRadioGroup, MenubarRadioItem, MenubarSeparator, MenubarShortcut, MenubarSub, MenubarSubContent, MenubarSubTrigger, MenubarTrigger, Navbar, NavigationMenu, NavigationMenuContent, NavigationMenuIndicator, NavigationMenuItem$1 as NavigationMenuItem, NavigationMenuLink, NavigationMenuList, NavigationMenuRoot, NavigationMenuTrigger, NavigationMenuViewport, NewPasswordForm, NoPermission, NotFound, Pagination, PasswordInput, PasswordStrengthIndicator, PhoneInput, type PhoneInputProps, PhoneMockup, PinInput, PinInputGroup, PinInputRoot, PinInputSeperator, PinInputSlot, Popover, PopoverContent, PopoverPortal, PopoverRoot, PopoverTrigger, PricingCard, PricingPlans, Progress, ProgressCircle, Radio, type RadioOptionsTypes, RegisterForm, ResetPasswordForm, ScrollArea, ScrollBar, ScrollIndicator, Select, type SelectOptionProps, Separator, Sheet, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, SheetTitle, SheetTrigger, SidebarGroup, SidebarItem, SimpleTable, Skeleton, Slider, SortButton, StandardNavigationMenuItem, Stats, StopPropagationWrapper, type SubItem$1 as SubItem, Switch, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow, Tabs, TabsContent, TabsList, TabsTrigger, Testimonial, type TextFieldTypes, Textarea, type TextareaProps, Toast$1 as Toast, ToastAction, type ToastActionElement, ToastClose, ToastDescription, type ToastProps, ToastProvider, ToastTitle, ToastViewport, Toaster, type ToasterToastProps, Tooltip, Usage, type UseFocusWithinOptions, type UseMediaQueryOptions, UserReferralSource, buttonVariants, getHotkeyHandler, getHotkeyMatcher, navigationMenuTriggerStyle, parseHotkey, reducer, toast, useBreakpoint, useClickOutside, useClipboard, useDialogCarousel, useFocusWithin, useIsomorphicEffect, useMeasureDirty, useMediaQuery, useMultiStepDialog, useShortcuts, useTabs, useToast, useViewportSize, useWindowEvent, useWindowSize };