@6thbridge/hexa 0.0.0-pr32-13

package/dist/index.d.mts

@@ -0,0 +1,601 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React$1 from 'react';
+import React__default, { DetailedHTMLProps, ButtonHTMLAttributes, ReactNode } from 'react';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import * as LabelPrimitive from '@radix-ui/react-label';
+import * as class_variance_authority_dist_types from 'class-variance-authority/dist/types';
+import { VariantProps } from 'class-variance-authority';
+import * as RPNInput from 'react-phone-number-input';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+import { DialogCloseProps } from '@radix-ui/react-dialog';
+import { OTPInputProps as OTPInputProps$1 } from 'react-otp-input';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+import { Drawer as Drawer$1 } from 'vaul';
+import { RowData, Row, Table as Table$1 } from '@tanstack/react-table';
+import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
+import dayjs from 'dayjs';
+import { ClassValue } from 'clsx';
+
+declare const TooltipProvider: React$1.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const TooltipRoot: React$1.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: React$1.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const TooltipContent: React$1.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+type TooltipPropsType = {
+    trigger: React$1.ReactNode;
+    children: React$1.ReactNode;
+    contentClassName?: string;
+    triggerClassName?: string;
+    asChild?: boolean;
+    side?: TooltipPrimitive.TooltipContentProps["side"];
+    sideOffset?: number;
+    align?: TooltipPrimitive.TooltipContentProps["align"];
+    alignOffset?: number;
+    delayDuration?: number;
+    hasArrow?: boolean;
+    arrowClassName?: string;
+};
+declare const Tooltip: {
+    ({ trigger, children, contentClassName, triggerClassName, asChild, side, sideOffset, align, alignOffset, delayDuration, hasArrow, arrowClassName, ...props }: TooltipPropsType & React$1.ComponentPropsWithoutRef<typeof TooltipPrimitive.Root>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+declare const FormLabel: React__default.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React__default.RefAttributes<HTMLLabelElement>, "ref"> & {
+    showAsterisk?: boolean;
+    error?: string;
+    formItemId?: string;
+} & React__default.RefAttributes<HTMLLabelElement>>;
+
+type Colours = "primary" | "secondary";
+declare const Loader: ({ size, colour, }: {
+    size?: number;
+    colour?: Colours;
+}) => react_jsx_runtime.JSX.Element;
+
+declare const buttonVariants: (props?: ({
+    variant?: "primary" | "danger" | "neutral" | "outlined" | "danger-outlined" | "light-outlined" | "dark-text" | "light" | null | undefined;
+    size?: "default" | "sm" | "lg" | "md" | "icon-sm" | "icon" | "icon-lg" | null | undefined;
+} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
+interface ButtonProps extends DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+    isLoading?: boolean;
+    leftNode?: React$1.ReactNode;
+    rightNode?: React$1.ReactNode;
+    LoaderSize?: number;
+}
+declare const Button: React$1.ForwardRefExoticComponent<Omit<ButtonProps, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+
+declare const inputVariants: (props?: ({
+    status?: "loading" | "default" | "error" | "neutral" | "prefilled" | null | undefined;
+} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
+interface BaseInnerInputProps extends React$1.InputHTMLAttributes<HTMLInputElement>, VariantProps<typeof inputVariants> {
+}
+declare const inputContainerVariants: (props?: ({
+    status?: "loading" | "default" | "error" | "neutral" | "prefilled" | null | undefined;
+} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
+interface InputProps extends BaseInnerInputProps, VariantProps<typeof inputContainerVariants> {
+    isLoading?: boolean;
+    error?: string;
+    leftNode?: React$1.ReactNode;
+    rightNode?: React$1.ReactNode;
+    sideNodeClassName?: string;
+    label?: string;
+    showAsterisk?: boolean;
+    description?: React$1.ReactNode;
+}
+declare const Input: React$1.ForwardRefExoticComponent<InputProps & React$1.RefAttributes<HTMLInputElement>>;
+
+type PasswordInputProps = InputProps & {
+    /**
+     * onValidate(validated: boolean, value: string) => void
+     * args - validated: this is boolean value that indicated that all validation options were met
+     * args - value: this is the string input value
+     */
+    onValidate?: (validated: boolean, value: string) => void;
+    disableValidation?: boolean;
+};
+declare const PasswordInput: {
+    ({ onValidate, onChange, disableValidation, ...props }: PasswordInputProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface TextareaProps extends DetailedHTMLProps<React$1.TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>, VariantProps<typeof inputContainerVariants> {
+    isLoading?: boolean;
+    error?: string;
+    label?: string;
+    showAsterisk?: boolean;
+    description?: React$1.ReactNode;
+}
+declare const Textarea: {
+    ({ className, status, disabled, error, isLoading, showAsterisk, label, description, ...props }: TextareaProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+type SearchableDataType = {
+    value: string;
+    label: string;
+} & {
+    [key: string]: any;
+};
+
+type CountryPropsStatus = VariantProps<typeof inputContainerVariants>["status"];
+interface CountryProps {
+    modal?: boolean;
+    hideSearch?: boolean;
+    loading?: boolean;
+    inputValue?: string;
+    onInputValueChange?: (arg: string) => void;
+    disabled?: boolean;
+    placeholder?: string;
+    value?: SearchableDataType;
+    optionComponent?: (arg: SearchableDataType) => React.ReactNode;
+    className?: string;
+    containerClassName?: string;
+    onChange: (value: SearchableDataType) => void;
+    status?: CountryPropsStatus;
+    label?: string;
+    showAsterisk?: boolean;
+    description?: React.ReactNode;
+    error?: string;
+}
+declare const Country: ({ hideSearch, showAsterisk, label, description, error, ...props }: CountryProps) => react_jsx_runtime.JSX.Element;
+
+type SelectPropsStatus = VariantProps<typeof inputContainerVariants>["status"];
+interface SelectProps {
+    modal?: boolean;
+    hideSearch?: boolean;
+    loading?: boolean;
+    inputValue?: string;
+    onInputValueChange?: (arg: string) => void;
+    disabled?: boolean;
+    placeholder?: string;
+    value?: SearchableDataType;
+    options: SearchableDataType[];
+    optionComponent?: (arg: SearchableDataType) => React.ReactNode;
+    className?: string;
+    containerClassName?: string;
+    onChange: (value: SearchableDataType) => void;
+    status?: SelectPropsStatus;
+    label?: string;
+    showAsterisk?: boolean;
+    description?: React.ReactNode;
+    error?: string;
+    id?: string;
+}
+declare const Select: ({ showAsterisk, label, description, error, hideSearch, status, ...props }: SelectProps) => react_jsx_runtime.JSX.Element;
+
+type PhoneInputProps = Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "onChange" | "value"> & Omit<RPNInput.Props<typeof RPNInput.default>, "onChange"> & {
+    onChange?: (value: RPNInput.Value) => void;
+} & {
+    status?: VariantProps<typeof inputContainerVariants>["status"];
+    defaultCountry?: RPNInput.Country;
+    modal?: boolean;
+    label?: string;
+    showAsterisk?: boolean;
+    description?: React$1.ReactNode;
+    error?: string;
+};
+declare const PhoneInput: React$1.ForwardRefExoticComponent<PhoneInputProps>;
+type FlagComponentProps = RPNInput.FlagProps & {
+    className?: string;
+};
+declare const FlagComponent: {
+    ({ country, countryName, className, }: FlagComponentProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+type DialogPropsType = {
+    trigger?: React$1.ReactNode;
+    children: React$1.ReactNode;
+    title?: React$1.ReactNode;
+    description?: React$1.ReactNode;
+    footer?: React$1.ReactNode;
+    hideCloseButton?: boolean;
+    contentClassName?: string;
+    headerClassName?: string;
+    titleClassName?: string;
+    descriptionClassName?: string;
+    footerClassName?: string;
+    asChild?: boolean;
+    onOpenAutoFocus?: (e: Event) => void;
+    onCloseAutoFocus?: (e: Event) => void;
+    onInteractOutside?: (e: Event) => void;
+    onPointerDownOutside?: (e: Event) => void;
+    onEscapeKeyDown?: (e: KeyboardEvent) => void;
+};
+declare const Dialog: {
+    ({ trigger, children, open, onOpenChange, hideCloseButton, footer, title, description, contentClassName, headerClassName, titleClassName, descriptionClassName, footerClassName, asChild, onOpenAutoFocus, onCloseAutoFocus, onEscapeKeyDown, onInteractOutside, onPointerDownOutside, ...props }: React$1.ComponentPropsWithoutRef<typeof DialogPrimitive.Root> & DialogPropsType): react_jsx_runtime.JSX.Element;
+    displayName: string | undefined;
+};
+
+declare const otpInputVariants: (props?: ({
+    status?: "loading" | "default" | "error" | null | undefined;
+} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
+type DefailtInputProps = Omit<OTPInputProps$1, "renderInput">;
+type OTPInputProps = DefailtInputProps & VariantProps<typeof otpInputVariants> & {};
+declare const OTPInput: ({ numInputs, inputStyle, containerStyle, placeholder, status, ...props }: OTPInputProps) => react_jsx_runtime.JSX.Element;
+
+declare const PopoverRoot: React$1.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: React$1.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const PopoverContent: React$1.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    portal?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+type PopoverPropsType = {
+    trigger: React$1.ReactNode;
+    children: React$1.ReactNode;
+    contentClassName?: string;
+    triggerClassName?: string;
+    asChild?: boolean;
+    align?: PopoverPrimitive.PopoverContentProps["align"];
+    side?: PopoverPrimitive.PopoverContentProps["side"];
+    alignOffset?: number | undefined;
+    sideOffset?: number | undefined;
+    onOpenAutoFocus?: (e: Event) => void;
+    onCloseAutoFocus?: (e: Event) => void;
+    portal?: boolean;
+    id?: string;
+};
+declare const Popover: {
+    ({ trigger, children, open, onOpenChange, contentClassName, asChild, align, side, alignOffset, triggerClassName, sideOffset, onOpenAutoFocus, onCloseAutoFocus, portal, id, ...props }: React$1.ComponentPropsWithoutRef<typeof PopoverPrimitive.Root> & PopoverPropsType): react_jsx_runtime.JSX.Element;
+    displayName: string | undefined;
+};
+
+interface BannerTypes {
+    type?: "gray" | "info" | "warning" | "success" | "danger";
+}
+interface BannerProps extends BannerTypes {
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    showIcon?: boolean;
+    showCloseButton?: boolean;
+    bottomNode?: React.ReactNode;
+    sideNode?: React.ReactNode;
+    open: boolean;
+    onClose?: () => void;
+}
+declare const Banner: ({ type, title, description, open, showCloseButton, bottomNode, sideNode, onClose, showIcon, }: BannerProps) => react_jsx_runtime.JSX.Element | null;
+
+interface CopyableLabelProps {
+    text: string;
+    textToCopy?: string;
+    onCopy?: () => void;
+    iconsPosition?: "left" | "right";
+    clampText?: boolean;
+    textClassName?: string;
+    clampMode?: "truncate" | "wrap";
+    isLink?: boolean;
+}
+declare const CopyableLabel: React.FC<CopyableLabelProps>;
+
+type DebouncedInputProps = {
+    value?: string;
+    onChange: (e: string) => void;
+    debounce?: number;
+    addon?: React__default.ReactNode;
+} & Omit<BaseInnerInputProps, "onChange" | "size">;
+declare const DebouncedInput: ({ value: initialValue, onChange, debounce, addon, ...props }: DebouncedInputProps) => react_jsx_runtime.JSX.Element;
+
+type Props = {
+    environment: "staging" | "sandbox" | "production";
+    branch: string;
+    version: string;
+    deployTime: string;
+    onClose: () => void;
+    showBanner: boolean;
+    initDefault: () => void;
+    removeFromStorage: () => void;
+    syncLocalStorageToState: () => void;
+};
+declare const DevBanner: (props: Props) => react_jsx_runtime.JSX.Element | null;
+
+type DrawerRootType = React$1.ComponentProps<typeof Drawer$1.Root> & {
+    id?: string;
+};
+declare const DrawerRoot: {
+    ({ shouldScaleBackground, ...props }: DrawerRootType): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const DrawerClose: React$1.ForwardRefExoticComponent<DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
+type DrawerPropsType = {
+    trigger?: React$1.ReactNode;
+    children: React$1.ReactNode;
+    title?: React$1.ReactNode;
+    description?: React$1.ReactNode;
+    footer?: React$1.ReactNode;
+    hideCloseButton?: boolean;
+    contentClassName?: string;
+    drawerContentClassName?: string;
+    headerClassName?: string;
+    titleClassName?: string;
+    descriptionClassName?: string;
+    footerClassName?: string;
+    asChild?: boolean;
+    onOpenAutoFocus?: (e: Event) => void;
+    onCloseAutoFocus?: (e: Event) => void;
+};
+declare const Drawer: ({ trigger, children, open, onOpenChange, hideCloseButton, footer, title, description, contentClassName, headerClassName, titleClassName, descriptionClassName, footerClassName, asChild, onOpenAutoFocus, drawerContentClassName, onCloseAutoFocus, id, }: Omit<DrawerRootType, "value"> & DrawerPropsType) => react_jsx_runtime.JSX.Element;
+
+type LocaleOption = {
+    key: string;
+    label: string;
+};
+declare const LocaleSelector: ({ locale, onChange, locales, }: {
+    locale?: string;
+    onChange?: (locale: string) => void;
+    locales?: LocaleOption[];
+}) => react_jsx_runtime.JSX.Element;
+
+type BusinessType = {
+    clientId?: string;
+    email?: string;
+    name?: string;
+    updatedAt?: string;
+    phoneNumber?: string;
+    logo?: string;
+    currencyCode?: string;
+    countryCode?: string;
+    currencyIcon?: string;
+    countryFlag?: string;
+    isKYCCompleted?: boolean;
+    parentClientId?: string;
+    supportedCountryCodes?: string[];
+    status?: string;
+    access?: string;
+};
+
+type SingleLinkType = {
+    to: string;
+    name: string;
+    isHidden?: boolean;
+    icon?: ReactNode;
+    badge?: ReactNode;
+    permission?: string;
+    key?: string;
+    id: string;
+};
+type BusinessProps = {
+    businessList: BusinessType[];
+    activeBusiness: BusinessType;
+    isBusinessDrawerActive: boolean;
+    toggleAddBusinessDrawer: () => void;
+    handleSetActiveBusiness: (clientId: string) => void;
+};
+type LinksType = {
+    children?: SingleLinkType[];
+} & SingleLinkType;
+type SidebarProps = {
+    isSidebarCollapsed: boolean;
+    collapseType: CollapseType;
+    links: LinksType[];
+    onToggleSideBar: (isOpen: boolean) => void;
+    isMobile: boolean;
+    businessProps: BusinessProps;
+    currentPath: string;
+    onNavigate: (path: string) => void;
+    appConfig?: IAppConfig & {
+        [key: string]: unknown;
+    };
+    onLogoutClick: () => void;
+    openSidebarIcon?: ReactNode;
+    closedSidebarIcon?: ReactNode;
+    nodeAfterSideBarLogo?: ReactNode;
+};
+interface IAppConfig {
+    appName: string;
+    hiddenRoutes?: string[];
+}
+type CollapseType = "icons" | "hidden";
+
+declare const Sidebar: ({ isSidebarCollapsed, onToggleSideBar, isMobile, links, businessProps, currentPath, onNavigate, appConfig, collapseType: propCollapseType, onLogoutClick, openSidebarIcon, closedSidebarIcon, nodeAfterSideBarLogo, }: SidebarProps) => react_jsx_runtime.JSX.Element;
+
+type Variant = "success" | "failed" | "pending" | "abandoned";
+declare const Status: ({ status, variant, className, }: {
+    status: string;
+    variant: Variant;
+    className?: string;
+}) => react_jsx_runtime.JSX.Element;
+
+type PaginationProps = {
+    currentPage?: number;
+    totalPages?: number;
+    onPageChange?: (page: number) => void;
+    totalItems?: number;
+    itemsPerPage?: number;
+    id?: string;
+};
+/**
+ * Pagination component for displaying pagination controls.
+ * @param {number} currentPage - The current page number.
+ * @param {number} totalPages - The total number of pages.
+ * @param {function} onPageChange - Callback function to handle page change.
+ * @param {number | undefined} itemsPerPage - The number of items per page.
+ */
+declare const Pagination: ({ currentPage, totalPages, onPageChange, itemsPerPage, totalItems, id, }: PaginationProps) => react_jsx_runtime.JSX.Element;
+
+type SelectOption = {
+    value: string;
+    label: string;
+};
+type Base = {
+    type: "input" | "drop-down" | "date-range" | "multi" | "date" | "radio";
+    key: string;
+    label: string;
+    placeholder?: string;
+};
+type FilterListOption = {
+    type: "input";
+} & Exclude<InputProps, "value" | "onChange">;
+type FilterListDate = {
+    type: "date";
+    date?: string | Date;
+};
+type FilterListInputDropDown = {
+    type: "drop-down" | "multi" | "radio";
+    options: SelectOption[];
+};
+type FilterListItem = Base & (FilterListOption | FilterListInputDropDown | FilterListDate);
+type FilterContentProps = {
+    filters: FilterListItem[];
+    values?: Record<string, any>;
+    setAppliedFilters?: (values: Record<string, any>) => void;
+    id?: string;
+};
+type FilterListOptions = FilterListItem[];
+
+type TableSearchProps = {
+    enabled: boolean;
+    debounceRate?: number;
+    onSearch?: (query: string) => void;
+};
+type TableDownloadProps = {
+    enabled: boolean;
+    buttonId?: string;
+    onDownload?: () => void;
+    buttonText?: string;
+};
+type TablePaginationProps = {
+    enabled: boolean;
+} & PaginationProps;
+type TableProps<T extends RowData> = {
+    ExtraNode?: ReactNode;
+    /**
+     * @deprecated Use the `filterListOptions` prop instead.
+     *
+     * The `FilterMenu` prop is deprecated in favor of `filterListOptions`, which provides a more flexible and structured way to define filter options for the table.
+     *
+     * To manage the state of applied filters, use the `setAppliedFilters` callback. This function can be used to collect and update the current filter state based on user interactions with the filter list options.
+     *
+     * The `filterListOptions` prop accepts an array of filter configuration objects, allowing you to define available filters, their types, and possible values. This approach enables dynamic filter rendering and better state management compared to the static `FilterMenu` node.
+     */
+    FilterMenu?: ReactNode;
+    setAppliedFilters?: (values: Record<string, any>) => void;
+    filterListOptions?: FilterListItem[];
+    buttonClassName?: string;
+    download?: TableDownloadProps;
+    id?: string;
+    isLoading?: boolean;
+    isMobile?: boolean;
+    isRefetching?: boolean;
+    onExport?: () => void;
+    onRefetch?: () => void;
+    onRowClick?: (row: Row<T>) => void;
+    pagination?: TablePaginationProps;
+    search?: TableSearchProps;
+    table: Table$1<T>;
+};
+declare const Table: <T extends RowData>({ table, isMobile, onRowClick, id, onRefetch, isRefetching, FilterMenu, ExtraNode, onExport, search, download, isLoading, pagination, filterListOptions, setAppliedFilters, }: TableProps<T>) => react_jsx_runtime.JSX.Element;
+
+type PageDataToolbarProps = {
+    onRefetch?: () => void;
+    search?: TableSearchProps;
+    FilterMenu?: ReactNode;
+    ExtraNode?: ReactNode;
+    onExport?: () => void;
+    download?: TableDownloadProps;
+    isRefetching?: boolean;
+    setAppliedFilters?: (values: Record<string, any>) => void;
+    filterListOptions?: FilterListItem[];
+    id?: string;
+};
+declare const PageDataToolbar: ({ onRefetch, search, FilterMenu, ExtraNode, onExport, download, isRefetching, filterListOptions, setAppliedFilters, id, }: PageDataToolbarProps) => react_jsx_runtime.JSX.Element;
+
+type ResourcePermission = {
+    resource: string;
+    action: string;
+};
+type ResourcePermissions = ResourcePermission[];
+type ResourcePermissionProps = {
+    permission?: {
+        resource?: string;
+        action?: string;
+    };
+    children: ReactNode;
+};
+
+declare const PermissionsContext: React$1.Context<ResourcePermissions | undefined>;
+declare const PermissionsProvider: ({ permissions, children, }: {
+    permissions: ResourcePermissions;
+    children: ReactNode;
+}) => react_jsx_runtime.JSX.Element;
+
+declare const usePermissions: () => ResourcePermissions | undefined;
+declare const useHasPermission: (permission: {
+    resource?: string;
+    action?: string;
+}) => {
+    hasPermission: boolean;
+    validatePermission: (permission: {
+        resource?: string;
+        action?: string;
+    }) => boolean;
+};
+
+declare const HasResourcePermission: ({ permission, children, }: ResourcePermissionProps) => react_jsx_runtime.JSX.Element;
+
+type CalendarInputProps = {
+    label?: string;
+    helpText?: string | React$1.ReactNode;
+    error?: string;
+    optional?: boolean;
+    onChange: (value: string | null) => void;
+    value?: string;
+};
+declare const CalendarInput: ({ label, optional, onChange, error, helpText, value, }: CalendarInputProps) => react_jsx_runtime.JSX.Element;
+
+declare const RadioGroup: React$1.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    className?: string;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const RadioGroupItem: React$1.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupItemProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & {
+    className?: string;
+} & React$1.RefAttributes<HTMLButtonElement>>;
+
+type FilterPopoverProps = FilterContentProps & {
+    isOpen?: boolean;
+    trigger?: ReactNode;
+    id?: string;
+};
+declare const FilterPopover: ({ filters, setAppliedFilters, isOpen, id, }: FilterPopoverProps) => react_jsx_runtime.JSX.Element | null;
+
+interface TextOverflowProps extends React__default.HTMLAttributes<HTMLElement> {
+    children: React__default.ReactNode;
+    mode?: "wrap" | "truncate" | "overflow";
+    as?: React__default.ElementType;
+    href?: string;
+}
+/**
+ * TextOverflow is a React component that controls how text overflows its container.
+ *
+ * Props:
+ * - children: ReactNode - The content to display.
+ * - mode: "truncate" | "wrap" | "overflow" (default: "truncate")
+ *      - "truncate": Single line, truncated with ellipsis.
+ *      - "wrap": Allows text to wrap onto multiple lines.
+ *      - "overflow": No special overflow handling.
+ * - as: React.ElementType - The HTML element or React component to render as the container (default: "div").
+ * - href: string (optional) - If provided and 'as' is an anchor, sets the link target to "_blank".
+ * - className: string (optional) - Additional CSS classes for the container.
+ * - ...rest: Other HTML attributes passed to the container.
+ */
+declare const TextOverflow: ({ children, mode, className, as: Component, ...rest }: TextOverflowProps) => react_jsx_runtime.JSX.Element;
+
+declare const CurrencySymbolMap: Record<string, string>;
+interface FormatCurrencyOptions {
+    convertToMajorCurrency?: boolean;
+    locale?: string;
+}
+declare class AmountAction {
+    static getCurrencyLocaleMap(currency: string): string;
+    static koboToNaira(amount: number | string): number;
+    static nairaToKobo(amount: number | string): number;
+    static getCurrencySymbol(currency: string): string;
+    static formatAmountAndCurrency: (currency: string, value: number | string, options: FormatCurrencyOptions) => string;
+}
+
+declare class DateAction {
+    static getDateLibrary(): dayjs.Dayjs;
+    static formatTimestampToDate(timestamp: number, dateFormat?: string): string;
+    static formatDateToTimestamp(date: string): number;
+}
+
+declare function cn(...inputs: ClassValue[]): string;
+
+export { AmountAction, Banner, Button, CalendarInput, CopyableLabel, Country, CurrencySymbolMap, DateAction, DebouncedInput, DevBanner, Dialog, Drawer, DrawerClose, type DrawerPropsType, DrawerRoot, type FilterListItem, type FilterListOptions, FilterPopover, FlagComponent, FormLabel, type FormatCurrencyOptions, HasResourcePermission, Input, Loader, LocaleSelector, OTPInput, PageDataToolbar, Pagination, PasswordInput, PermissionsContext, PermissionsProvider, PhoneInput, Popover, PopoverContent, PopoverRoot, PopoverTrigger, RadioGroup, RadioGroupItem, type ResourcePermission, type ResourcePermissionProps, type ResourcePermissions, Select, Sidebar, Status, Table, type TablePaginationProps, TextOverflow, type TextOverflowProps, Textarea, Tooltip, TooltipContent, TooltipProvider, TooltipRoot, TooltipTrigger, buttonVariants, cn, useHasPermission, usePermissions };