tawuniya 0.6.0

package/dist/components.d.ts

@@ -0,0 +1,1055 @@
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+import { ClassProp } from 'class-variance-authority/types';
+import { Column } from '@tanstack/react-table';
+import { ColumnDef } from '@tanstack/react-table';
+import { CurveType } from 'recharts/types/shape/Curve';
+import { default as default_2 } from 'react';
+import { Dispatch } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { HTMLAttributeAnchorTarget } from 'react';
+import { JSX } from 'react';
+import { LabelPosition } from 'recharts/types/component/Label';
+import { Margin } from 'recharts';
+import * as React_2 from 'react';
+import { ReactNode } from 'react';
+import { RefAttributes } from 'react';
+import { Row } from '@tanstack/react-table';
+import { SetStateAction } from 'react';
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import { TypedDataKey } from 'recharts/types/util/typedDataKey';
+import { VariantProps } from 'class-variance-authority';
+
+export declare const Accordion: <S extends boolean = false>({ items, single, toggleIcon, defaultOpen, classNames, }: AccordionProps<S>) => JSX.Element;
+
+declare interface AccordionClassNames {
+    wrapperClassName?: string;
+    itemClassName?: string;
+    titleClassName?: string;
+    descriptionClassName?: string;
+    iconClassName?: string;
+    toggleIconClassName?: string;
+}
+
+declare interface AccordionProps<S extends boolean = false> {
+    items: ExpandableSectionItemType[];
+    toggleIcon?: string | ReactNode;
+    single?: S;
+    defaultOpen?: S extends true ? number : number[];
+    classNames?: AccordionClassNames;
+}
+
+export declare const Alert: ({ title, description, variant, icon, action, className, children, hideIcon, hideBorder, }: AlertProps) => JSX.Element;
+
+export declare const AlertDialog: ({ title, description, trigger, cancelButtonText, actionButtonText, actionButtonProps, cancelButtonProps, actionButtonIcon, cancelButtonIcon, buttonsAlignment, buttonsFullWidth, centered, className, titleClassName, descriptionClassName, open, isLoading, onOpenChange, onActionClick, }: AlertDialogProps) => JSX.Element;
+
+declare interface AlertDialogProps {
+    title: string;
+    description?: string;
+    trigger: React.ReactNode;
+    cancelButtonText?: string;
+    actionButtonText?: string;
+    actionButtonProps?: Partial<ButtonProps>;
+    cancelButtonProps?: Partial<ButtonProps>;
+    actionButtonIcon?: React.ReactNode;
+    cancelButtonIcon?: React.ReactNode;
+    buttonsAlignment?: "start" | "center" | "end";
+    buttonsFullWidth?: boolean;
+    centered?: boolean;
+    className?: string;
+    titleClassName?: string;
+    descriptionClassName?: string;
+    open?: boolean;
+    isLoading?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    onActionClick?: () => void;
+}
+
+declare interface AlertProps {
+    title?: string;
+    description?: string;
+    variant?: "default" | "primary" | "destructive" | "warning" | "info" | "success";
+    icon?: React.ReactNode;
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
+    hideBorder?: boolean;
+    className?: string;
+    children?: React.ReactNode;
+    hideIcon?: boolean;
+}
+
+declare type AlignContent = {
+    x?: aligns;
+    y?: aligns;
+};
+
+declare type aligns = "start" | "center" | "end";
+
+export declare const AreaChart: <T extends object>({ data, series, type, dataKey, showCursor, hideXAxis, hideYAxis, hideTooltipLabel, showTickLine, showAxisLine, showCartesianGrid, showLegend, tickMargin, margin, strokeWidth, fillOpacity, stacked, gradient, dot, labelList, className, wrapperClassName, tickFormatter, }: AreaChartProps<T>) => JSX.Element;
+
+declare interface AreaChartProps<T extends object> {
+    data: T[];
+    series: ChartConfig;
+    type?: CurveType;
+    dataKey: TypedDataKey<T, unknown>;
+    showCursor?: boolean;
+    hideXAxis?: boolean;
+    hideYAxis?: boolean;
+    hideTooltipLabel?: boolean;
+    showTickLine?: boolean;
+    showAxisLine?: boolean;
+    showCartesianGrid?: boolean;
+    showLegend?: boolean;
+    tickMargin?: number;
+    margin?: Partial<Margin>;
+    strokeWidth?: number;
+    fillOpacity?: number;
+    stacked?: boolean;
+    gradient?: boolean | GradientConfig;
+    dot?: DotConfig_2;
+    labelList?: LabelListConfig_3;
+    className?: string;
+    wrapperClassName?: string;
+    tickFormatter?: (value: unknown) => string;
+}
+
+export declare function Badge({ className, variant, asChild, size, rounded, shadow, ...props }: React_2.ComponentProps<"span"> & VariantProps<typeof badgeVariants> & {
+    asChild?: boolean;
+}): React_2.JSX.Element;
+
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "primary" | "secondary" | "success" | "info" | "warning" | "destructive" | "plain" | "outline" | "ghost" | null | undefined;
+    size?: "sm" | "md" | "lg" | "xl" | null | undefined;
+    rounded?: "sm" | "md" | "lg" | "full" | null | undefined;
+    shadow?: "sm" | "md" | "lg" | "none" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export declare const BarChart: <T extends object>({ data, series, categoryKey, horizontal, showCartesianGrid, tickMargin, showXAxis, showYAxis, hideTooltipLabel, showCursor, stacked, labelList, withLegend, borderRadius, margin, className, wrapperClassName, }: BarChartProps<T>) => JSX.Element;
+
+declare interface BarChartProps<T extends object> {
+    data: T[];
+    series: ChartConfig;
+    categoryKey: TypedDataKey<T | never>;
+    horizontal?: boolean;
+    showCartesianGrid?: boolean;
+    tickMargin?: number;
+    showXAxis?: boolean;
+    showYAxis?: boolean;
+    hideTooltipLabel?: boolean;
+    showCursor?: boolean;
+    stacked?: boolean;
+    labelList?: LabelListItem[];
+    withLegend?: boolean;
+    borderRadius?: BorderRadius;
+    margin?: Partial<Margin>;
+    className?: string;
+    wrapperClassName?: string;
+}
+
+declare interface BaseProps extends VariantProps<typeof checkboxButtonVariants> {
+    description?: string;
+    size?: "sm" | "md" | "lg";
+    rounded?: rounded;
+    fullWidth?: boolean;
+    info?: default_2.ReactNode;
+    disabled?: boolean;
+    className?: string;
+    error?: string;
+    form?: {
+        controller: any;
+        control: any;
+        name: string;
+    };
+}
+
+declare type BorderRadius = number | [number, number, number, number];
+
+export declare const Button: React_2.ForwardRefExoticComponent<ButtonProps & React_2.RefAttributes<HTMLButtonElement>>;
+
+declare interface ButtonProps extends React_2.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+    shadow?: shadow;
+    rounded?: rounded;
+    fullWidth?: boolean;
+    badge?: React_2.ReactNode;
+    badgeClassName?: string;
+    wrapperClassName?: string;
+    loading?: boolean;
+}
+
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "primary" | "secondary" | "success" | "info" | "warning" | "destructive" | "plain" | "outline" | "outline_muted" | "ghost" | "smooth" | "smooth_destructive" | "solid_smooth" | "solid_smooth_destructive" | null | undefined;
+    shadow?: "sm" | "md" | "lg" | "xl" | null | undefined;
+    rounded?: "sm" | "md" | "lg" | "xl" | "full" | null | undefined;
+    fullWidth?: boolean | null | undefined;
+    size?: "default" | "sm" | "md" | "lg" | "xl" | "icon" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+declare type CaptionLayout = "dropdown" | "label" | "dropdown-months" | "dropdown-years";
+
+export declare const CardButton: ({ title, icon, active, features, subText, href, target, badgeText, classNames, }: CardButtonProps) => JSX.Element;
+
+declare interface CardButtonProps {
+    title: string;
+    icon: ReactNode;
+    active?: boolean;
+    features?: FeatureItem[];
+    subText?: ReactNode;
+    href: string;
+    target?: HTMLAttributeAnchorTarget | undefined;
+    badgeText?: string;
+    classNames?: {
+        mainWrapper?: string;
+        contentWrapper?: string;
+        featuresWrapper?: string;
+        iconWrapper?: string;
+        title?: string;
+        badge?: {
+            wrapper?: string;
+            badgeItem?: string;
+        };
+        feature?: {
+            wrapper?: string;
+            icon?: string;
+            text?: string;
+        };
+    };
+}
+
+export declare const Carousel: ({ slides, title, description, alignContent, nextIcon, prevIcon, options, onClick, classNames, children, }: CarouselProps) => JSX.Element;
+
+declare interface CarouselProps {
+    slides: SlideItem[];
+    title?: string;
+    description?: string;
+    alignContent?: AlignContent;
+    nextIcon?: React.ReactNode;
+    prevIcon?: React.ReactNode;
+    options?: options;
+    onClick?: (slideId: string, slide: SlideItem) => void;
+    classNames?: ClassNames;
+    children?: React.ReactNode;
+}
+
+declare type ChartConfig = Record<string, {
+    label?: React_2.ReactNode;
+    icon?: React_2.ComponentType;
+} & ({
+    color?: string;
+    theme?: never;
+} | {
+    color?: never;
+    theme: Record<keyof typeof THEMES, string>;
+})>;
+
+export declare const Checkbox: React_2.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;
+
+export declare const CheckboxButton: {
+    (props: CheckboxButtonProps): default_2.JSX.Element | null;
+    displayName: string;
+};
+
+declare interface CheckboxButtonMultipleProps extends BaseProps {
+    multiple: true;
+    items: CheckboxItem[];
+    checked?: string[];
+    onChange?: (checked: string[]) => void;
+}
+
+declare type CheckboxButtonProps = CheckboxButtonSingleProps | CheckboxButtonMultipleProps;
+
+declare interface CheckboxButtonSingleProps extends BaseProps {
+    multiple?: false;
+    label?: string;
+    id?: string;
+    checked?: boolean;
+    onChange?: (checked: boolean) => void;
+}
+
+declare const checkboxButtonVariants: (props?: ({
+    rounded?: "sm" | "md" | "lg" | "xl" | "full" | null | undefined;
+    fullWidth?: boolean | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+declare interface CheckboxItem {
+    id: string;
+    label: string;
+    description?: string;
+}
+
+export declare const CircleProgress: ({ size, percentage, className, }: CircleProgressProps) => JSX.Element;
+
+declare interface CircleProgressProps {
+    className?: string;
+    size?: "sm" | "md" | "lg" | "xl" | "xxl" | "xxxl";
+    percentage: number;
+}
+
+declare type ClassNames = {
+    className?: string;
+    containerClassName?: string;
+    backdropClassName?: string;
+    slideWrapperClassName?: string;
+    slideClassName?: string;
+    titleClassName?: string;
+    descriptionClassName?: string;
+    actionWrapperClassName?: string;
+    actionButtonClassName?: string;
+};
+
+declare interface classNames {
+    wrapperClassName?: string;
+    itemWrapperClassName?: string;
+    titleClassNames?: string;
+    tooltipIconClassName?: string;
+    tooltipTitleClassName?: string;
+    tooltipWrapperClassName?: string;
+    optionsWrapperClassName?: string;
+    optionsClassName?: string;
+}
+
+export declare const DataOverview: ({ items, type, classNames, }: DataOverviewProps) => JSX.Element;
+
+declare interface DataOverviewClassNames {
+    wrapperClassName?: string;
+    titleClassName?: string;
+    valueClassName?: string;
+    iconClassName?: string;
+    itemWrapperClassName?: string;
+}
+
+declare interface DataOverviewItem {
+    id: string;
+    title: string;
+    value: string | ReactNode;
+    icon?: string | ReactNode;
+}
+
+declare const DataOverviewItem: ({ id, title, value, icon, isStacked, itemWrapperClassName, iconClassName, titleClassName, valueClassName, }: DataOverviewItemProps) => JSX.Element;
+
+declare interface DataOverviewItemProps extends DataOverviewItem, Omit<DataOverviewClassNames, "wrapperClassName"> {
+    isStacked: boolean;
+}
+
+declare interface DataOverviewProps {
+    items: DataOverviewItem[];
+    type?: DataOverviewType;
+    classNames?: DataOverviewClassNames;
+}
+
+declare type DataOverviewType = "inline" | "stacked";
+
+export declare const DataTable: <TData, TValue>({ columns, data, loading, classNameWrapper, classNameHeadRow, classNameHeadCell, classNameBodyRow, classNameBodyCell, classNamePagination, hidePagination, skeleton, empty, paginationTotal, onSelectedRowsChange, resetSelection, onRowClick, }: DataTableProps<TData, TValue>) => JSX.Element;
+
+export declare const DataTableColumnHeader: <TData, TValue>({ column, title, className, }: DataTableColumnHeaderProps<TData, TValue>) => JSX.Element;
+
+declare interface DataTableColumnHeaderProps<TData, TValue> extends React.HTMLAttributes<HTMLDivElement> {
+    column: Column<TData, TValue>;
+    title: string;
+}
+
+declare interface DataTableProps<TData, TValue> {
+    columns: ColumnDef<TData, TValue>[];
+    data: TData[];
+    loading?: boolean;
+    classNameWrapper?: string;
+    classNameHeadRow?: string;
+    classNameHeadCell?: string;
+    classNameBodyRow?: string;
+    classNameBodyCell?: string;
+    classNamePagination?: string;
+    hidePagination?: boolean;
+    skeleton?: {
+        rowSpan?: number;
+        colSpan?: number;
+    };
+    empty?: {
+        icon?: React.ReactNode;
+        title?: string;
+        description?: string;
+    };
+    paginationTotal?: number;
+    onSelectedRowsChange?: Dispatch<SetStateAction<TData[]>>;
+    resetSelection?: object | null;
+    onRowClick?: (rowTable: Row<TData>, rowItem: TData) => void;
+}
+
+declare type DataWithFill<T> = T & {
+    fill?: string;
+};
+
+export declare const DatePicker: ForwardRefExoticComponent<DatePickerProps & RefAttributes<HTMLButtonElement>>;
+
+declare interface DatePickerProps {
+    label: string;
+    id: string;
+    error?: string;
+    className?: string;
+    disabled?: boolean;
+    value?: string;
+    modal?: boolean;
+    icon?: React.ReactNode;
+    captionLayout?: CaptionLayout;
+    views?: ("Day" | "Month" | "Year")[];
+    onChange?: (date: string) => void;
+    form?: {
+        controller: any;
+        control: any;
+        name: string;
+    };
+    min?: string;
+    max?: string;
+    format?: string;
+    wrapperClassName?: string;
+}
+
+export declare const DateSelector: ForwardRefExoticComponent<DateSelectorProps & RefAttributes<HTMLButtonElement>>;
+
+declare interface DateSelectorProps {
+    label?: string;
+    views?: ("Day" | "Month" | "Year")[];
+    outputDate?: "hijri" | "gregorian";
+    isHijri?: boolean;
+    format?: string;
+    value?: string | Date;
+    className?: string;
+    error?: string;
+    min?: string;
+    max?: string;
+    hideToggle?: boolean;
+    onChange?: (value: string) => void;
+    onDateChange?: (gregorianDate: string, hijriDate: string) => void;
+    form?: {
+        controller: any;
+        control: any;
+        name: string;
+    };
+    disabled?: boolean;
+}
+
+declare interface DeclarationItem {
+    id: string;
+    title: string;
+    tooltipIcon?: string | ReactNode;
+    tooltipTitle?: string;
+    tooltipContent?: ReactNode;
+    options: OptionItem[];
+    selectedItem: string;
+    allowedOption?: string;
+}
+
+export declare const DeclarationOfExposure: ({ items, classNames, alertTitle, alertDescription, value, error, onChange, form, }: DeclarationOfExposureProps) => JSX.Element;
+
+declare interface DeclarationOfExposureProps {
+    items?: DeclarationItem[];
+    classNames?: classNames;
+    alertTitle?: string;
+    alertDescription?: string;
+    value?: boolean;
+    error?: string;
+    onChange?: (value: boolean) => void;
+    form?: {
+        controller: any;
+        control: any;
+        name: string;
+    };
+}
+
+export declare const Divider: React_2.ForwardRefExoticComponent<DividerProps & React_2.RefAttributes<HTMLDivElement>>;
+
+declare interface DividerProps extends React_2.HTMLAttributes<HTMLDivElement>, VariantProps<typeof dividerVariants> {
+    thickness?: number;
+    children?: React_2.ReactNode;
+}
+
+declare const dividerVariants: (props?: ({
+    orientation?: "horizontal" | "vertical" | null | undefined;
+    variant?: "full" | "inset" | "middle" | null | undefined;
+    tone?: "strong" | "soft" | null | undefined;
+    flexItem?: boolean | null | undefined;
+} & ClassProp) | undefined) => string;
+
+declare interface Doc {
+    fileName: string;
+    fileType: string;
+    url: string;
+}
+
+declare interface DonutConfig {
+    value: number;
+    label?: DonutLabelConfig;
+}
+
+declare interface DonutLabelConfig {
+    show?: boolean;
+    valueClassName?: string;
+    labelClassName?: string;
+    labelY?: number;
+}
+
+declare interface DotConfig {
+    show?: boolean;
+    fill?: string;
+    strokeWidth?: number;
+    activeRadius?: number;
+}
+
+declare interface DotConfig_2 {
+    show?: boolean;
+    fill?: string;
+    strokeWidth?: number;
+    activeRadius?: number;
+}
+
+export declare const EmptyMessage: ({ icon, title, description }: EmptyProps) => JSX.Element;
+
+declare interface EmptyProps {
+    icon?: React.ReactNode;
+    title?: string;
+    description?: string;
+}
+
+export declare const ExpandableSection: ({ icon, title, description, additional, content, open, onToggle, toggleIcon, classNames, }: ExpandableSectionProps) => JSX.Element;
+
+declare type ExpandableSectionItemType = {
+    icon: ReactNode | string;
+    title: string;
+    description?: string;
+    additional?: ReactNode;
+    content: ReactNode;
+};
+
+declare interface ExpandableSectionProps extends ExpandableSectionItemType, Pick<AccordionProps, "toggleIcon"> {
+    open?: boolean;
+    onToggle?: () => void;
+    classNames?: Omit<AccordionClassNames, "wrapperClassName">;
+}
+
+declare type FeatureItem = {
+    key: string;
+    text: string;
+};
+
+declare interface FileData {
+    id: string;
+    file: string;
+    fileName: string;
+    fileType: string;
+    size: number;
+}
+
+export declare const FileUpload: default_2.FC<FileUploadProps>;
+
+declare interface FileUploadProps {
+    label?: string;
+    placeholder?: string;
+    id?: string;
+    error?: string;
+    maxSize?: number;
+    maxFiles?: number;
+    className?: string;
+    wrapperClassName?: string;
+    value?: FileData[];
+    defaultValue?: FileData[];
+    onChange?: (files: FileData[]) => void;
+    form?: {
+        controller: any;
+        control: any;
+        name: string;
+    };
+    render?: default_2.ReactNode;
+    accept?: string;
+    disabled?: boolean;
+}
+
+declare interface GradientConfig {
+    startOpacity?: number;
+    endOpacity?: number;
+    startOffset?: string;
+    endOffset?: string;
+}
+
+export declare const HeaderPaper: ({ icon, title, description, additional, children, classNames, }: HeaderPaperProps) => JSX.Element;
+
+declare interface HeaderPaperProps {
+    icon?: ReactNode | string;
+    title: string;
+    description?: string;
+    additional?: ReactNode;
+    children: ReactNode;
+    classNames?: {
+        wrapperClassName?: string;
+        titleClassName?: string;
+        descriptionClassName?: string;
+        iconWrapperClassName?: string;
+        iconClassName?: string;
+    };
+}
+
+export declare function Icon({ name, className }: Icon): JSX.Element | null;
+
+export declare interface Icon {
+    name: string;
+    className?: string;
+}
+
+declare type IconName = "tawuniya-small" | "document-upload" | "down-arrow" | "checkbox-circle-fill" | "empty-state" | "absher" | "home" | "tawuniya-logo" | "document-download" | "tawuniya-library-symble-new";
+
+export declare const IconText: ({ icon, text, align, gap, iconSize, textSize, classNames, }: IconTextProps) => JSX.Element;
+
+declare type IconTextBase = (VariantProps<typeof iconTextVariants> & {
+    icon: React.ReactNode;
+    text: React.ReactNode;
+    classNames?: {
+        container?: string;
+        icon?: string;
+        text?: never;
+    };
+}) | (VariantProps<typeof iconTextVariants> & {
+    icon: React.ReactNode;
+    text: string;
+    classNames?: {
+        container?: string;
+        icon?: string;
+        text?: string;
+    };
+});
+
+declare type IconTextProps = IconTextBase;
+
+declare const iconTextVariants: (props?: ({
+    align?: "center" | "start" | "end" | null | undefined;
+    gap?: "sm" | "md" | "lg" | "xs" | "none" | null | undefined;
+    iconSize?: "sm" | "md" | "lg" | "xl" | "xs" | null | undefined;
+    textSize?: "sm" | "md" | "lg" | "xl" | "xs" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export declare const ImagePicker: ForwardRefExoticComponent<ImagePickerProps & RefAttributes<HTMLInputElement>>;
+
+declare interface ImagePickerProps {
+    maxSize?: number;
+    maxFiles?: number;
+    id?: string;
+    error?: string;
+    viewOnly?: boolean;
+    className?: string;
+    value?: FileData[];
+    images?: {
+        fileName: string;
+        fileType: string;
+        url: string;
+    }[];
+    onChange?: (files: FileData[]) => void;
+    form?: {
+        controller: any;
+        control: any;
+        name: string;
+    };
+}
+
+export declare const Input: ({ className, type, color, label, value, id, error, suffix, suffixClass, prefix, prefixClass, register, disabled, name, size, labelSize, placeholder, info, onChange, ...props }: InputProps) => default_2.JSX.Element;
+
+declare type InputColor = "default" | "primary" | "secondary" | "success" | "info" | "warning" | "destructive";
+
+declare interface InputProps extends Omit<default_2.InputHTMLAttributes<HTMLInputElement>, "prefix" | "size" | "onChange">, VariantProps<typeof inputVariants> {
+    label?: string;
+    prefix?: string | default_2.ReactNode;
+    prefixClass?: string;
+    suffix?: string | default_2.ReactNode;
+    suffixClass?: string;
+    error?: string;
+    color?: InputColor;
+    size?: Size;
+    labelSize?: Size;
+    register?: any;
+    info?: string;
+    onChange?: (value: string) => void;
+}
+
+declare const inputVariants: (props?: ({
+    color?: "default" | "primary" | "secondary" | "success" | "info" | "warning" | "destructive" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+declare interface Item {
+    stageName: string | null;
+    description?: string | null;
+    sideNode?: React.ReactNode | string;
+    stageStatus?: React.ReactNode;
+    isComplete?: boolean;
+}
+
+declare interface LabelListConfig<T> {
+    show?: boolean;
+    dataKey?: keyof T & string;
+    fontSize?: number;
+    fontWeight?: "regular" | "medium" | "semibold" | "bold";
+    fontStyle?: "normal" | "italic";
+    className?: string;
+}
+
+declare interface LabelListConfig_2 {
+    show?: boolean;
+    position?: LabelPosition;
+    offset?: number;
+    fontSize?: number;
+    fontWeight?: 'regular' | 'medium' | 'semibold' | 'bold';
+    fontStyle?: 'normal' | 'italic';
+    className?: string;
+}
+
+declare interface LabelListConfig_3 {
+    show?: boolean;
+    position?: LabelPosition;
+    offset?: number;
+    fontSize?: number;
+    fontWeight?: 'regular' | 'medium' | 'semibold' | 'bold';
+    fontStyle?: 'normal' | 'italic';
+    className?: string;
+}
+
+declare type LabelListItem = {
+    dataKey?: string;
+    position?: LabelPosition;
+    offset?: number;
+    fontSize?: number;
+    className?: string;
+};
+
+export declare const LineChart: <T extends object>({ data, series, type, dataKey, showCursor, hideXAxis, hideYAxis, hideTooltipLabel, showTickLine, showAxisLine, showCartesianGrid, showLegend, tickMargin, margin, strokeWidth, dot, labelList, className, wrapperClassName, tickFormatter, }: LineChartProps<T>) => JSX.Element;
+
+declare interface LineChartProps<T extends object> {
+    data: T[];
+    series: ChartConfig;
+    type?: CurveType;
+    dataKey: TypedDataKey<T, unknown>;
+    showCursor?: boolean;
+    hideXAxis?: boolean;
+    hideYAxis?: boolean;
+    hideTooltipLabel?: boolean;
+    showTickLine?: boolean;
+    showAxisLine?: boolean;
+    showCartesianGrid?: boolean;
+    showLegend?: boolean;
+    tickMargin?: number;
+    margin?: Partial<Margin>;
+    strokeWidth?: number;
+    dot?: DotConfig;
+    labelList?: LabelListConfig_2;
+    className?: string;
+    wrapperClassName?: string;
+    tickFormatter?: (value: unknown) => string;
+}
+
+declare type LinkComponentType = React.ComponentType<any>;
+
+export declare const Loader: ({ loading, icon, text, size, className, }: LoaderProps) => JSX.Element | null;
+
+declare interface LoaderProps extends VariantProps<typeof loaderVariants> {
+    text?: string;
+    icon?: string;
+    loading: boolean;
+    className?: string;
+}
+
+declare const loaderVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export declare const MainProvider: ({ children, showAccessibility, accessibilityPosition, }: MainProviderProps) => JSX.Element;
+
+declare interface MainProviderProps extends Children {
+    showAccessibility?: boolean;
+    accessibilityPosition?: AccessibilityPositionType;
+}
+
+declare interface Option_2 {
+    label: string;
+    value: string;
+}
+
+declare interface OptionItem {
+    value: string;
+    label: string;
+}
+
+declare type options = {
+    loop?: boolean;
+    fade?: boolean;
+    autoPlay?: boolean;
+    delay?: number;
+    startIndex?: number;
+    hideDots?: boolean;
+    hideArrows?: boolean;
+};
+
+export declare const OTP: ({ title, description, channel, initialSeconds, initialMinutes, isAbsher, hideIcon, centered, disabled, className, disableAutoSubmitting, viewType, verifyOTP, resendOTP, openModal, onOpenModal, }: OTPProps) => JSX.Element;
+
+declare interface OTPProps {
+    title?: string;
+    description?: string;
+    channel?: string;
+    initialMinutes?: number;
+    initialSeconds?: number;
+    isAbsher?: boolean;
+    hideIcon?: boolean;
+    centered?: boolean;
+    disabled?: boolean;
+    className?: string;
+    disableAutoSubmitting?: boolean;
+    viewType?: "normal" | "modal";
+    verifyOTP?: (otp: string) => void;
+    resendOTP?: () => void;
+    openModal?: boolean;
+    onOpenModal?: Dispatch<SetStateAction<boolean>>;
+}
+
+export declare const Pagination: ({ paginationTotal, firstButtonLabel, lastButtonLabel, prevButtonLabel, nextButtonLabel, className, }: PaginationProps) => JSX.Element;
+
+declare interface PaginationProps {
+    paginationTotal: number;
+    firstButtonLabel?: string;
+    lastButtonLabel?: string;
+    prevButtonLabel?: string;
+    nextButtonLabel?: string;
+    className?: string;
+}
+
+export declare const PieChart: <T extends object>({ data, nameKey, dataKey, hideTooltipLabel, showLegend, margin, donut, activeIndex, labelList, gap, cornerRadius, className, legendClassName, wrapperClassName, }: PieChartProps<T>) => JSX.Element;
+
+declare interface PieChartProps<T extends object> {
+    data: DataWithFill<T>[];
+    nameKey: keyof T & string;
+    dataKey: keyof T & string;
+    hideTooltipLabel?: boolean;
+    showLegend?: boolean;
+    margin?: Partial<Margin>;
+    activeIndex?: number;
+    labelList?: LabelListConfig<T>;
+    donut?: DonutConfig;
+    gap?: number;
+    cornerRadius?: string | number;
+    className?: string;
+    legendClassName?: string;
+    wrapperClassName?: string;
+}
+
+export declare const ProgressBar: ({ progress, isReadOnly, className, classNameTrack, hideThumb, onProgressChange, }: ProgressBarProps) => JSX.Element;
+
+declare interface ProgressBarProps {
+    progress: number;
+    isReadOnly?: boolean;
+    className?: string;
+    classNameTrack?: string;
+    hideThumb?: boolean;
+    onProgressChange?: (value: number) => void;
+}
+
+export declare const RadioButton: default_2.ForwardRefExoticComponent<RadioButtonProps & default_2.RefAttributes<HTMLButtonElement>>;
+
+declare interface RadioButtonProps {
+    options: Option_2[];
+    value?: string | null;
+    error?: string;
+    disabled?: boolean;
+    className?: string;
+    wrapperClassName?: string;
+    selectedClassName?: string;
+    radioCircleClassName?: string;
+    onChange?: (val: string | null) => void;
+    form?: {
+        controller: any;
+        control: any;
+        name: string;
+    };
+}
+
+declare type rounded = "sm" | "md" | "lg" | "xl" | "full";
+
+export declare const Select: default_2.ForwardRefExoticComponent<Omit<SelectProps, "ref"> & default_2.RefAttributes<HTMLButtonElement>>;
+
+declare interface SelectProps {
+    label?: string;
+    options: {
+        [key: string]: any;
+    }[];
+    value?: any;
+    size?: "sm" | "md" | "lg";
+    searchable?: boolean;
+    searchText?: string;
+    ref?: default_2.Ref<HTMLButtonElement>;
+    emptyText?: string;
+    error?: string;
+    embedded?: boolean;
+    disabled?: boolean;
+    modal?: boolean;
+    className?: string;
+    bodyClass?: string;
+    wrapperClassName?: string;
+    itemClassName?: string;
+    onChange?: (value: any) => void;
+    form?: {
+        controller: any;
+        control: any;
+        name: string;
+    };
+    getOptionsLabel?: string;
+    getOptionsValue?: string;
+    displayValue?: boolean;
+}
+
+declare type shadow = "sm" | "md" | "lg" | "xl";
+
+export declare const Sidebar: (props: SidebarProps) => JSX.Element;
+
+declare type SidebarItem = {
+    id: string;
+    href: string;
+    label: string;
+    icon: IconName | string;
+    active?: boolean;
+    isLocatedAtEnd?: boolean;
+    subItems?: SidebarItem[];
+    clickable?: boolean;
+    allowedPrivileges?: string[];
+};
+
+declare interface SidebarProps {
+    items?: SidebarItem[];
+    logo?: {
+        expanded?: React.ReactNode;
+        collapsed?: React.ReactNode;
+    };
+    itemVariants?: Partial<ButtonProps>;
+    activeVariants?: Partial<Pick<ButtonProps, "variant" | "className">>;
+    breakpoint?: number;
+    defaultCollapsed?: boolean;
+    header?: React.ReactNode;
+    footer?: React.ReactNode;
+    showHeaderWhenCollapsed?: boolean;
+    showFooterWhenCollapsed?: boolean;
+    linkComponent?: LinkComponentType;
+    sidebarCollapsed?: boolean;
+    privileges?: string[];
+    className?: string;
+    onClick?: (id: string) => void;
+}
+
+declare type Size = "sm" | "md" | "lg";
+
+export declare function Skeleton({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): JSX.Element;
+
+export declare const SlideGallery: ({ documents, open, onOpenChange }: SlideGalleryProps) => JSX.Element;
+
+declare interface SlideGalleryProps {
+    documents: Doc[];
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+}
+
+declare type SlideItem = {
+    id: string;
+    title?: string;
+    description?: string;
+    image: string;
+};
+
+export declare const Stepper: ({ steps, stepValue, markComplete, className, }: StepperProps) => JSX.Element;
+
+declare type StepperProps = {
+    steps: {
+        id: string;
+        title: React.ReactNode;
+        description: React.ReactNode;
+        status: string;
+    }[];
+    stepValue: string;
+    markComplete?: boolean;
+    className?: string;
+};
+
+export declare const Switch: default_2.ForwardRefExoticComponent<SwitchProps & default_2.RefAttributes<HTMLInputElement>>;
+
+declare interface SwitchProps extends VariantProps<typeof toggleVariants>, Omit<default_2.InputHTMLAttributes<HTMLInputElement>, "onChange" | "size" | "value"> {
+    label?: string;
+    error?: string;
+    size?: "sm" | "md" | "lg";
+    name?: string;
+    register?: any;
+    value?: boolean;
+    className?: string;
+    wrapperClassName?: string;
+    onChange?: (status: boolean) => void;
+}
+
+export declare const Tabs: ({ tabs, defaultTab, value, variant, unmount, wrapperClassName, className, children, onValueChange, }: TabsProps) => JSX.Element;
+
+export declare function TabsContent({ className, ...props }: React_2.ComponentProps<typeof TabsPrimitive.Content>): React_2.JSX.Element;
+
+declare interface TabsProps {
+    tabs: {
+        label: string;
+        key: string;
+        icon?: React.ReactNode;
+    }[];
+    defaultTab: string;
+    value?: string;
+    variant?: "default" | "filled" | "filled_primary" | "underlined";
+    unmount?: boolean;
+    wrapperClassName?: string;
+    className?: string;
+    children: React.ReactNode;
+    onValueChange?: (value: string) => void;
+}
+
+export declare const Textarea: ForwardRefExoticComponent<Omit<TextAreaProps, "ref"> & RefAttributes<HTMLTextAreaElement>>;
+
+declare interface TextAreaProps extends VariantProps<typeof textareaVariants> {
+    label?: string;
+    placeholder?: string;
+    name: string;
+    maxLength?: number;
+    register?: any;
+    error?: string;
+    disabled?: boolean;
+    value?: string;
+    ref?: React.RefObject<HTMLTextAreaElement>;
+    className?: string;
+    onChange?: (value: string) => void;
+}
+
+declare const textareaVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+declare const THEMES: {
+    readonly light: "";
+    readonly dark: ".dark";
+};
+
+declare const toggleVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export declare const Typography: ({ as: Comp, className, size, weight, color, htmlFor, ...props }: TypographyProps) => JSX.Element;
+
+declare interface TypographyProps extends Omit<React.HTMLAttributes<HTMLElement>, "color">, VariantProps<typeof typographyVariants> {
+    as?: "p" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "span" | "label" | "div";
+    htmlFor?: string;
+}
+
+declare const typographyVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | "xl" | "xs" | "xxl" | "xxxl" | null | undefined;
+    weight?: "thin" | "light" | "normal" | "medium" | "semibold" | "bold" | null | undefined;
+    color?: "default" | "primary" | "success" | "warning" | "destructive" | "muted_foreground" | "error" | "white" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export declare const VerticalStepper: ({ items }: VerticalStepperProps) => JSX.Element;
+
+declare interface VerticalStepperProps {
+    items: Item[];
+}
+
+export { }