elseware-ui 2.31.0 → 2.31.1

package/dist/index.d.mts

@@ -6,456 +6,456 @@ import * as formik from 'formik';
 import { FieldHookConfig } from 'formik';
 import { ClassValue } from 'clsx';
 
-/**
- * Contains ReactElements such as "children" using HTMLAttributes
- *
- * Contains DOMAttributes such as "onClick" using HTMLAttributes
- *
- * Define the custom types as follows for the custom DOM elements
- *  BaseComponentProps<HTMLDivElement>     // default
- *  BaseComponentProps<HTMLButtonElement>  // buttons
- *  BaseComponentProps<HTMLAnchorElement>  // links
- */
-interface BaseComponentProps<T extends HTMLElement = HTMLDivElement> extends Omit<HTMLAttributes<T>, "children"> {
-    className?: string;
-}
-
-declare const CURRENCIES: {
-    name: string;
-    symbol: string;
-    code: string;
+/**
+ * Contains ReactElements such as "children" using HTMLAttributes
+ *
+ * Contains DOMAttributes such as "onClick" using HTMLAttributes
+ *
+ * Define the custom types as follows for the custom DOM elements
+ *  BaseComponentProps<HTMLDivElement>     // default
+ *  BaseComponentProps<HTMLButtonElement>  // buttons
+ *  BaseComponentProps<HTMLAnchorElement>  // links
+ */
+interface BaseComponentProps<T extends HTMLElement = HTMLDivElement> extends Omit<HTMLAttributes<T>, "children"> {
+    className?: string;
+}
+
+declare const CURRENCIES: {
+    name: string;
+    symbol: string;
+    code: string;
 }[];
 
-type Variant$1 = "default" | "primary" | "secondary" | "success" | "danger" | "warning" | "info" | "light" | "dark";
-type Shape$1 = "circle" | "roundedSquare" | "softRoundedSquare" | "square";
-type Size$1 = "xs" | "sm" | "md" | "lg" | "xl";
-type Appearance = "solid" | "lite" | "ghost";
-type TextDecoration = "underline" | "overline" | "lineThrough" | "noUnderline";
-type HyperRefTarget = "blank" | "self" | "parent" | "top";
-type VerticalPosition = "top" | "bottom";
-type HorizontalPosition = "left" | "right";
-type CardinalPosition = VerticalPosition | HorizontalPosition;
-type CornerPosition = `${VerticalPosition}-${HorizontalPosition}`;
-type OctilePosition = CardinalPosition | CornerPosition;
-type TitleBannerLevel = 1 | 2;
-type ListBulletType = "dot" | "diamond" | "number" | "none";
-type ListAlign = "start" | "center";
-type ListDirection = "vertical" | "horizontal";
-type RouteTabMode = "route" | "state";
+type Variant$1 = "default" | "primary" | "secondary" | "success" | "danger" | "warning" | "info" | "light" | "dark";
+type Shape$1 = "circle" | "roundedSquare" | "softRoundedSquare" | "square";
+type Size$1 = "xs" | "sm" | "md" | "lg" | "xl";
+type Appearance = "solid" | "lite" | "ghost";
+type TextDecoration = "underline" | "overline" | "lineThrough" | "noUnderline";
+type HyperRefTarget = "blank" | "self" | "parent" | "top";
+type VerticalPosition = "top" | "bottom";
+type HorizontalPosition = "left" | "right";
+type CardinalPosition = VerticalPosition | HorizontalPosition;
+type CornerPosition = `${VerticalPosition}-${HorizontalPosition}`;
+type OctilePosition = CardinalPosition | CornerPosition;
+type TitleBannerLevel = 1 | 2;
+type ListBulletType = "dot" | "diamond" | "number" | "none";
+type ListAlign = "start" | "center";
+type ListDirection = "vertical" | "horizontal";
+type RouteTabMode = "route" | "state";
 type CurrencyCode = (typeof CURRENCIES)[number]["code"];
 
-interface AvatarProps extends BaseComponentProps {
-    alt?: string;
-    icon?: ReactNode;
-    variant?: Variant$1;
-    appearance?: Appearance;
-    shape?: Shape$1;
-    size?: Size$1;
-    src?: string;
-    children?: ReactNode;
-}
+interface AvatarProps extends BaseComponentProps {
+    alt?: string;
+    icon?: ReactNode;
+    variant?: Variant$1;
+    appearance?: Appearance;
+    shape?: Shape$1;
+    size?: Size$1;
+    src?: string;
+    children?: ReactNode;
+}
 declare const Avatar: ({ alt, icon, children, variant, appearance, shape, size, src, className, ...rest }: AvatarProps) => react_jsx_runtime.JSX.Element;
 
-interface BadgeProps extends BaseComponentProps {
-    offset?: [number, number];
-    dot?: boolean;
-    count?: number;
-    variant?: Variant$1;
-    appearance?: Appearance;
-    shape?: Shape$1;
-    size?: Size$1;
-    showZero?: boolean;
-    position?: OctilePosition;
-    children?: ReactNode;
-}
+interface BadgeProps extends BaseComponentProps {
+    offset?: [number, number];
+    dot?: boolean;
+    count?: number;
+    variant?: Variant$1;
+    appearance?: Appearance;
+    shape?: Shape$1;
+    size?: Size$1;
+    showZero?: boolean;
+    position?: OctilePosition;
+    children?: ReactNode;
+}
 declare const Badge: ({ children, offset, dot, count, variant, appearance, shape, size, showZero, position, className, ...rest }: BadgeProps) => react_jsx_runtime.JSX.Element;
 
-interface TitleBannerProps extends BaseComponentProps {
-    title: string;
-    level?: TitleBannerLevel;
-    rightSection?: ReactNode;
-}
+interface TitleBannerProps extends BaseComponentProps {
+    title: string;
+    level?: TitleBannerLevel;
+    rightSection?: ReactNode;
+}
 declare const TitleBanner: ({ title, level, rightSection, className, ...rest }: TitleBannerProps) => react_jsx_runtime.JSX.Element;
 
-interface BrandProps extends BaseComponentProps {
-    src?: string;
-    alt?: string;
-}
+interface BrandProps extends BaseComponentProps {
+    src?: string;
+    alt?: string;
+}
 declare function Brand({ src, alt, className, ...rest }: BrandProps): react_jsx_runtime.JSX.Element;
 
-interface BarChartProps extends BaseComponentProps {
-    data: ChartData<"bar">;
-    options: ChartOptions<"bar">;
-}
+interface BarChartProps extends BaseComponentProps {
+    data: ChartData<"bar">;
+    options: ChartOptions<"bar">;
+}
 declare const BarChart: React$1.FC<BarChartProps>;
 
-interface LineChartProps extends BaseComponentProps {
-    data: ChartData<"line">;
-    options?: ChartOptions<"line">;
-}
+interface LineChartProps extends BaseComponentProps {
+    data: ChartData<"line">;
+    options?: ChartOptions<"line">;
+}
 declare const LineChart: React$1.FC<LineChartProps>;
 
-interface PieChartProps extends BaseComponentProps {
-    data: ChartData<"pie">;
-    options: ChartOptions<"pie">;
-}
+interface PieChartProps extends BaseComponentProps {
+    data: ChartData<"pie">;
+    options: ChartOptions<"pie">;
+}
 declare const PieChart: React$1.FC<PieChartProps>;
 
-interface ChipProps extends BaseComponentProps {
-    label?: string;
-    variant?: Variant$1;
-    appearance?: Appearance;
-    shape?: Shape$1;
-    size?: Size$1;
-}
+interface ChipProps extends BaseComponentProps {
+    label?: string;
+    variant?: Variant$1;
+    appearance?: Appearance;
+    shape?: Shape$1;
+    size?: Size$1;
+}
 declare const Chip: ({ label, variant, appearance, shape, size, className, ...rest }: ChipProps) => react_jsx_runtime.JSX.Element;
 
-type SortConfig<T, K extends keyof T = keyof T> = {
-    key: K;
-    direction?: "asc" | "desc";
-    transform?: (value: T[K]) => number | string;
+type SortConfig<T, K extends keyof T = keyof T> = {
+    key: K;
+    direction?: "asc" | "desc";
+    transform?: (value: T[K]) => number | string;
 };
 
-interface Props$5<T> {
-    data: T[];
-    children: ReactNode;
-    defaultPageSize?: number;
-    sortConfig?: Record<string, SortConfig<T>>;
-}
+interface Props$5<T> {
+    data: T[];
+    children: ReactNode;
+    defaultPageSize?: number;
+    sortConfig?: Record<string, SortConfig<T>>;
+}
 declare function DataViewProvider<T extends Record<string, any>>({ data, children, defaultPageSize, sortConfig, }: Props$5<T>): react_jsx_runtime.JSX.Element;
 
-type DataViewHeaderProps = {
-    children: ReactNode;
-};
+type DataViewHeaderProps = {
+    children: ReactNode;
+};
 declare function DataViewHeader({ children }: DataViewHeaderProps): react_jsx_runtime.JSX.Element;
 
-type DataViewSidebarProps = {
-    children: ReactNode;
-};
+type DataViewSidebarProps = {
+    children: ReactNode;
+};
 declare function DataViewSidebar({ children }: DataViewSidebarProps): react_jsx_runtime.JSX.Element;
 
-type DataViewContentProps<T = any> = {
-    children: ReactNode | ((data: T[]) => ReactNode);
-};
+type DataViewContentProps<T = any> = {
+    children: ReactNode | ((data: T[]) => ReactNode);
+};
 declare function DataViewContent<T = any>({ children, }: DataViewContentProps<T>): JSX.Element;
 
-type DataViewFooterProps = {
-    children: ReactNode;
-};
+type DataViewFooterProps = {
+    children: ReactNode;
+};
 declare function DataViewFooter({ children }: DataViewFooterProps): react_jsx_runtime.JSX.Element;
 
-type DataViewSearchProps = {
-    placeholder?: string;
-    shape?: Shape$1;
-};
+type DataViewSearchProps = {
+    placeholder?: string;
+    shape?: Shape$1;
+};
 declare function DataViewSearch({ placeholder, shape, }: DataViewSearchProps): react_jsx_runtime.JSX.Element;
 
-type SortOption$1 = {
-    value: string;
-    label: string;
-};
-type DataViewSortProps = {
-    options: SortOption$1[];
-    shape?: Shape$1;
-};
+type SortOption$1 = {
+    value: string;
+    label: string;
+};
+type DataViewSortProps = {
+    options: SortOption$1[];
+    shape?: Shape$1;
+};
 declare function DataViewSort({ options, shape }: DataViewSortProps): react_jsx_runtime.JSX.Element;
 
-type FilterOption = {
-    value: string;
-    label: string;
-    dotClass?: string;
-};
-type DataViewFilterGroupProps<T = any> = {
-    filterKey: keyof T;
-    options: FilterOption[];
-    title?: string;
-};
+type FilterOption = {
+    value: string;
+    label: string;
+    dotClass?: string;
+};
+type DataViewFilterGroupProps<T = any> = {
+    filterKey: keyof T;
+    options: FilterOption[];
+    title?: string;
+};
 declare function DataViewFilterGroup<T extends Record<string, any>>({ filterKey, options, title, }: DataViewFilterGroupProps<T>): react_jsx_runtime.JSX.Element;
 
-type Props$4 = {
-    pageSizeOptions?: (number | "All")[];
-    shape?: Shape$1;
-};
+type Props$4 = {
+    pageSizeOptions?: (number | "All")[];
+    shape?: Shape$1;
+};
 declare function DataViewPageSize({ pageSizeOptions, shape, }: Props$4): react_jsx_runtime.JSX.Element;
 
-type Props$3 = {
-    shape?: Shape$1;
-};
+type Props$3 = {
+    shape?: Shape$1;
+};
 declare function DataViewPagination({ shape }: Props$3): react_jsx_runtime.JSX.Element | null;
 
-declare const DataView: typeof DataViewProvider & {
-    Header: typeof DataViewHeader;
-    Sidebar: typeof DataViewSidebar;
-    Content: typeof DataViewContent;
-    Footer: typeof DataViewFooter;
-    Pagination: typeof DataViewPagination;
-    Search: typeof DataViewSearch;
-    Sort: typeof DataViewSort;
-    FilterGroup: typeof DataViewFilterGroup;
-    PageSize: typeof DataViewPageSize;
+declare const DataView: typeof DataViewProvider & {
+    Header: typeof DataViewHeader;
+    Sidebar: typeof DataViewSidebar;
+    Content: typeof DataViewContent;
+    Footer: typeof DataViewFooter;
+    Pagination: typeof DataViewPagination;
+    Search: typeof DataViewSearch;
+    Sort: typeof DataViewSort;
+    FilterGroup: typeof DataViewFilterGroup;
+    PageSize: typeof DataViewPageSize;
 };
 
-interface FlagProps extends BaseComponentProps {
-    code: string;
-    width?: number | string;
-    height?: number | string;
-}
+interface FlagProps extends BaseComponentProps {
+    code: string;
+    width?: number | string;
+    height?: number | string;
+}
 declare const Flag: ({ code, width, height, className, ...rest }: FlagProps) => react_jsx_runtime.JSX.Element;
 
-type GraphLayoutType = "force" | "grid" | "tree" | (string & {});
-interface GraphData {
-    nodes: GraphNodeType[];
-    edges: GraphEdgeType[];
-}
-interface GraphNodeType {
-    id: string;
-    label?: string;
-    type?: "default" | "avatar" | "custom";
-    data?: any;
-    x?: number;
-    y?: number;
-    vx?: number;
-    vy?: number;
-    fx?: number | null;
-    fy?: number | null;
-    size?: number;
-    color?: string;
-}
-interface GraphEdgeType {
-    id?: string;
-    from: string | GraphNodeType;
-    to: string | GraphNodeType;
-    weight?: string;
-    color?: string;
-    width?: number;
-}
-
-interface GraphProps extends BaseComponentProps {
-    data: GraphData;
-    layout?: string;
-    nodeRenderer?: (node: any) => React$1.ReactNode;
-    width?: number;
-    height?: number;
-}
+type GraphLayoutType = "force" | "grid" | "tree" | (string & {});
+interface GraphData {
+    nodes: GraphNodeType[];
+    edges: GraphEdgeType[];
+}
+interface GraphNodeType {
+    id: string;
+    label?: string;
+    type?: "default" | "avatar" | "custom";
+    data?: any;
+    x?: number;
+    y?: number;
+    vx?: number;
+    vy?: number;
+    fx?: number | null;
+    fy?: number | null;
+    size?: number;
+    color?: string;
+}
+interface GraphEdgeType {
+    id?: string;
+    from: string | GraphNodeType;
+    to: string | GraphNodeType;
+    weight?: string;
+    color?: string;
+    width?: number;
+}
+
+interface GraphProps extends BaseComponentProps {
+    data: GraphData;
+    layout?: string;
+    nodeRenderer?: (node: any) => React$1.ReactNode;
+    width?: number;
+    height?: number;
+}
 declare const Graph: ({ data, layout, nodeRenderer, width, height, className, ...rest }: GraphProps) => react_jsx_runtime.JSX.Element;
 
-interface Props$2 {
-    edge: GraphEdgeType;
-    nodeMap: Map<string, GraphNodeType>;
-}
+interface Props$2 {
+    edge: GraphEdgeType;
+    nodeMap: Map<string, GraphNodeType>;
+}
 declare const GraphEdge: React$1.FC<Props$2>;
 
-interface Props$1 {
-    node: GraphNodeType;
-    renderCustom?: (node: GraphNodeType) => React$1.ReactNode;
-}
+interface Props$1 {
+    node: GraphNodeType;
+    renderCustom?: (node: GraphNodeType) => React$1.ReactNode;
+}
 declare const GraphNode: React$1.FC<Props$1>;
 
-interface Props {
-    data: GraphData;
-    layout?: string;
-    nodeRenderer?: (node: GraphNodeType) => React$1.ReactNode;
-    width?: number;
-    height?: number;
-}
+interface Props {
+    data: GraphData;
+    layout?: string;
+    nodeRenderer?: (node: GraphNodeType) => React$1.ReactNode;
+    width?: number;
+    height?: number;
+}
 declare const GraphRenderer: React$1.FC<Props>;
 
 declare const createForceLayout: (nodes: GraphNodeType[], edges: GraphEdgeType[], width: number, height: number) => d3.Simulation<GraphNodeType, undefined>;
 
-declare function createGridLayout(nodes: GraphNodeType[], width: number, height: number): {
-    x: number;
-    y: number;
-    id: string;
-    label?: string | undefined;
-    type?: "default" | "custom" | "avatar" | undefined;
-    data?: any;
-    vx?: number | undefined;
-    vy?: number | undefined;
-    fx?: number | null | undefined;
-    fy?: number | null | undefined;
-    size?: number | undefined;
-    color?: string | undefined;
+declare function createGridLayout(nodes: GraphNodeType[], width: number, height: number): {
+    x: number;
+    y: number;
+    id: string;
+    label?: string | undefined;
+    type?: "default" | "custom" | "avatar" | undefined;
+    data?: any;
+    vx?: number | undefined;
+    vy?: number | undefined;
+    fx?: number | null | undefined;
+    fy?: number | null | undefined;
+    size?: number | undefined;
+    color?: string | undefined;
 }[];
 
 declare function createTreeLayout(nodes: GraphNodeType[], edges: GraphEdgeType[], width: number, height: number): GraphNodeType[];
 
-interface LayoutContext {
-    nodes: GraphNodeType[];
-    edges: GraphEdgeType[];
-    width: number;
-    height: number;
-    onTick?: (nodes: GraphNodeType[]) => void;
-}
-type LayoutExecutor = (ctx: LayoutContext) => {
-    type: "static" | "simulation";
-    stop?: () => void;
-};
-declare const registerLayout: (type: GraphLayoutType, executor: LayoutExecutor) => void;
+interface LayoutContext {
+    nodes: GraphNodeType[];
+    edges: GraphEdgeType[];
+    width: number;
+    height: number;
+    onTick?: (nodes: GraphNodeType[]) => void;
+}
+type LayoutExecutor = (ctx: LayoutContext) => {
+    type: "static" | "simulation";
+    stop?: () => void;
+};
+declare const registerLayout: (type: GraphLayoutType, executor: LayoutExecutor) => void;
 declare const getLayout: (type: GraphLayoutType) => LayoutExecutor;
 
-interface CloudinaryImageProps extends BaseComponentProps<HTMLImageElement> {
-    publicId?: string;
-    cloudName?: string;
-    secure?: boolean;
-    alt?: string;
-    fallbackSrc?: string;
-    loading?: "lazy" | "eager";
-}
+interface CloudinaryImageProps extends BaseComponentProps<HTMLImageElement> {
+    publicId?: string;
+    cloudName?: string;
+    secure?: boolean;
+    alt?: string;
+    fallbackSrc?: string;
+    loading?: "lazy" | "eager";
+}
 declare function CloudinaryImage({ publicId, cloudName, secure, alt, fallbackSrc, loading, className, ...rest }: CloudinaryImageProps): react_jsx_runtime.JSX.Element;
 
-interface ImageProps extends BaseComponentProps {
-    alt?: string;
-    src?: string;
-    height?: number;
-    width?: number;
-}
+interface ImageProps extends BaseComponentProps {
+    alt?: string;
+    src?: string;
+    height?: number;
+    width?: number;
+}
 declare const Image: ({ alt, src, height, width, className, ...rest }: ImageProps) => react_jsx_runtime.JSX.Element;
 
-interface InfoProps extends BaseComponentProps {
-    variant?: Variant$1;
-    appearance?: Appearance;
-    shape?: Shape$1;
-    children?: ReactNode;
-}
+interface InfoProps extends BaseComponentProps {
+    variant?: Variant$1;
+    appearance?: Appearance;
+    shape?: Shape$1;
+    children?: ReactNode;
+}
 declare function Info({ children, variant, appearance, shape, className, ...rest }: InfoProps): react_jsx_runtime.JSX.Element;
 
-interface ListItemData {
-    content: React$1.ReactNode;
-    bulletType?: ListBulletType;
-    renderBullet?: (index?: number) => React$1.ReactNode;
-    TypographyComponent?: React$1.ReactNode;
-    className?: string;
-}
-interface ListProps extends BaseComponentProps {
-    title?: string;
-    items: (string | React$1.ReactNode | ListItemData)[];
-    direction?: ListDirection;
-    gap?: 1 | 2 | 3 | 4;
-    columns?: 1 | 2 | 3 | 4;
-    align?: ListAlign;
-    wrap?: boolean;
-    bulletType?: ListBulletType;
-}
+interface ListItemData {
+    content: React$1.ReactNode;
+    bulletType?: ListBulletType;
+    renderBullet?: (index?: number) => React$1.ReactNode;
+    TypographyComponent?: React$1.ReactNode;
+    className?: string;
+}
+interface ListProps extends BaseComponentProps {
+    title?: string;
+    items: (string | React$1.ReactNode | ListItemData)[];
+    direction?: ListDirection;
+    gap?: 1 | 2 | 3 | 4;
+    columns?: 1 | 2 | 3 | 4;
+    align?: ListAlign;
+    wrap?: boolean;
+    bulletType?: ListBulletType;
+}
 declare function List({ title, items, direction, gap, columns, align, wrap, bulletType, className, ...rest }: ListProps): react_jsx_runtime.JSX.Element;
 
-interface ListItemProps {
-    content: React$1.ReactNode;
-    index?: number;
-    TypographyComponent?: React$1.ReactNode;
-    bulletType?: ListBulletType;
-    renderBullet?: (index?: number) => React$1.ReactNode;
-    align?: ListAlign;
-    className?: string;
-}
+interface ListItemProps {
+    content: React$1.ReactNode;
+    index?: number;
+    TypographyComponent?: React$1.ReactNode;
+    bulletType?: ListBulletType;
+    renderBullet?: (index?: number) => React$1.ReactNode;
+    align?: ListAlign;
+    className?: string;
+}
 declare const ListItem: ({ content, TypographyComponent, bulletType, renderBullet, index, align, className, }: ListItemProps) => react_jsx_runtime.JSX.Element;
 
-interface PriceTagProps extends BaseComponentProps {
-    price: number;
-    discount?: number;
-    code?: CurrencyCode;
-    variant?: Variant$1;
-    appearance?: Appearance;
-    shape?: Shape$1;
-    size?: Size$1;
-    decimals?: number;
-    showCurrencyCode?: boolean;
-    currencyAsSubscript?: boolean;
-    showFreeLabel?: boolean;
-}
+interface PriceTagProps extends BaseComponentProps {
+    price: number;
+    discount?: number;
+    code?: CurrencyCode;
+    variant?: Variant$1;
+    appearance?: Appearance;
+    shape?: Shape$1;
+    size?: Size$1;
+    decimals?: number;
+    showCurrencyCode?: boolean;
+    currencyAsSubscript?: boolean;
+    showFreeLabel?: boolean;
+}
 declare function PriceTag({ price, discount, code, variant, appearance, shape, size, decimals, showCurrencyCode, currencyAsSubscript, showFreeLabel, className, ...rest }: PriceTagProps): react_jsx_runtime.JSX.Element;
 
-interface ProgressBarProps extends BaseComponentProps {
-    value: number;
-    max?: number;
-    min?: number;
-    variant?: Variant$1;
-    appearance?: Appearance;
-    size?: Size$1;
-    shape?: Shape$1;
-    striped?: boolean;
-    animated?: boolean;
-    showLabel?: boolean;
-    label?: string;
-    labelPlacement?: "top" | "overlay" | "bottom";
-    showPercentage?: boolean;
-    startContent?: ReactNode;
-    endContent?: ReactNode;
-    trackClassName?: string;
-    barClassName?: string;
-}
+interface ProgressBarProps extends BaseComponentProps {
+    value: number;
+    max?: number;
+    min?: number;
+    variant?: Variant$1;
+    appearance?: Appearance;
+    size?: Size$1;
+    shape?: Shape$1;
+    striped?: boolean;
+    animated?: boolean;
+    showLabel?: boolean;
+    label?: string;
+    labelPlacement?: "top" | "overlay" | "bottom";
+    showPercentage?: boolean;
+    startContent?: ReactNode;
+    endContent?: ReactNode;
+    trackClassName?: string;
+    barClassName?: string;
+}
 declare function ProgressBar({ value, min, max, variant, appearance, size, shape, striped, animated, showLabel, label, labelPlacement, showPercentage, startContent, endContent, trackClassName, barClassName, className, ...rest }: ProgressBarProps): react_jsx_runtime.JSX.Element;
 
-interface NumericRatingProps extends BaseComponentProps {
-    rating: number;
-    totalReviews?: number;
-    size?: Size$1;
-    showStars?: boolean;
-    showReviewCount?: boolean;
-    reviewLabel?: string;
-}
+interface NumericRatingProps extends BaseComponentProps {
+    rating: number;
+    totalReviews?: number;
+    size?: Size$1;
+    showStars?: boolean;
+    showReviewCount?: boolean;
+    reviewLabel?: string;
+}
 declare function NumericRating({ rating, totalReviews, size, showStars, showReviewCount, reviewLabel, className, ...rest }: NumericRatingProps): react_jsx_runtime.JSX.Element;
 
-interface ProgressBarRatingProps extends BaseComponentProps {
-    star: number;
-    percentage: number;
-    variant?: Variant$1;
-    appearance?: Appearance;
-    shape?: Shape$1;
-    size?: Size$1;
-    animated?: boolean;
-    striped?: boolean;
-}
+interface ProgressBarRatingProps extends BaseComponentProps {
+    star: number;
+    percentage: number;
+    variant?: Variant$1;
+    appearance?: Appearance;
+    shape?: Shape$1;
+    size?: Size$1;
+    animated?: boolean;
+    striped?: boolean;
+}
 declare function ProgressBarRating({ star, percentage, variant, appearance, shape, size, animated, striped, className, ...rest }: ProgressBarRatingProps): react_jsx_runtime.JSX.Element;
 
-interface StarRatingProps extends BaseComponentProps {
-    rating: number;
-    max?: number;
-    size?: Size$1;
-    showValue?: boolean;
-    valuePosition?: "start" | "end";
-    iconClassName?: string;
-}
+interface StarRatingProps extends BaseComponentProps {
+    rating: number;
+    max?: number;
+    size?: Size$1;
+    showValue?: boolean;
+    valuePosition?: "start" | "end";
+    iconClassName?: string;
+}
 declare function StarRating({ rating, max, size, showValue, valuePosition, iconClassName, className, ...rest }: StarRatingProps): react_jsx_runtime.JSX.Element;
 
-interface TableColumnConfig<T> {
-    key: keyof T | string;
-    header: string;
-    sortable?: boolean;
-    render?: (value: any, row: T) => ReactNode;
-}
-interface TableProps<T> {
-    title?: string;
-    columns: TableColumnConfig<T>[];
-    data: T[];
-    shape?: Shape$1;
-}
+interface TableColumnConfig<T> {
+    key: keyof T | string;
+    header: string;
+    sortable?: boolean;
+    render?: (value: any, row: T) => ReactNode;
+}
+interface TableProps<T> {
+    title?: string;
+    columns: TableColumnConfig<T>[];
+    data: T[];
+    shape?: Shape$1;
+}
 declare function Table<T extends Record<string, any>>({ title, columns, data, shape, }: TableProps<T>): react_jsx_runtime.JSX.Element;
 
-interface TagProps extends BaseComponentProps {
-    text: string;
-}
+interface TagProps extends BaseComponentProps {
+    text: string;
+}
 declare function Tag({ text, className, ...rest }: TagProps): react_jsx_runtime.JSX.Element;
 
-interface TooltipProps extends BaseComponentProps {
-    children: ReactNode;
-    show: boolean;
-    offsetX?: number;
-    offsetY?: number;
-}
+interface TooltipProps extends BaseComponentProps {
+    children: ReactNode;
+    show: boolean;
+    offsetX?: number;
+    offsetY?: number;
+}
 declare function Tooltip({ children, show, offsetX, offsetY, className, ...rest }: TooltipProps): react_jsx_runtime.JSX.Element | null;
 
-interface TypographyProps extends BaseComponentProps {
-    children?: ReactNode;
-    level?: 1 | 2 | 3;
-    variant?: Variant$1;
-    decoration?: TextDecoration;
-    bold?: boolean;
-    italic?: boolean;
+interface TypographyProps extends BaseComponentProps {
+    children?: ReactNode;
+    level?: 1 | 2 | 3;
+    variant?: Variant$1;
+    decoration?: TextDecoration;
+    bold?: boolean;
+    italic?: boolean;
 }
 
-interface DisplayProps extends TypographyProps {
-    level?: 1 | 2 | 3;
-}
+interface DisplayProps extends TypographyProps {
+    level?: 1 | 2 | 3;
+}
 declare const Display: ({ level, children, variant, decoration, bold, italic, className, ...rest }: DisplayProps) => react_jsx_runtime.JSX.Element;
 
 declare const Chapter: ({ level, children, variant, decoration, bold, italic, className, ...rest }: TypographyProps) => react_jsx_runtime.JSX.Element;
@@ -476,1063 +476,1103 @@ declare const Lead: ({ children, variant, decoration, bold, italic, className, .
 
 declare const Overline: ({ children, variant, decoration, bold, italic, className, ...rest }: TypographyProps) => react_jsx_runtime.JSX.Element;
 
-declare const Typography: {
-    Display: ({ level, children, variant, decoration, bold, italic, className, ...rest }: DisplayProps) => react_jsx_runtime.JSX.Element;
-    Chapter: ({ level, children, variant, decoration, bold, italic, className, ...rest }: TypographyProps) => react_jsx_runtime.JSX.Element;
-    Section: ({ level, children, variant, decoration, bold, italic, className, ...rest }: TypographyProps) => react_jsx_runtime.JSX.Element;
-    Paragraph: ({ level, children, variant, decoration, bold, italic, className, ...rest }: TypographyProps) => react_jsx_runtime.JSX.Element;
-    Quote: ({ level, children, variant, decoration, bold, italic, className, ...rest }: TypographyProps) => react_jsx_runtime.JSX.Element;
-    Lead: ({ children, variant, decoration, bold, italic, className, ...rest }: TypographyProps) => react_jsx_runtime.JSX.Element;
-    Caption: ({ children, variant, decoration, bold, italic, className, ...rest }: TypographyProps) => react_jsx_runtime.JSX.Element;
-    Label: ({ children, variant, decoration, bold, italic, className, ...rest }: TypographyProps) => react_jsx_runtime.JSX.Element;
-    Code: ({ children, className, ...rest }: TypographyProps) => react_jsx_runtime.JSX.Element;
-    Overline: ({ children, variant, decoration, bold, italic, className, ...rest }: TypographyProps) => react_jsx_runtime.JSX.Element;
+declare const Typography: {
+    Display: ({ level, children, variant, decoration, bold, italic, className, ...rest }: DisplayProps) => react_jsx_runtime.JSX.Element;
+    Chapter: ({ level, children, variant, decoration, bold, italic, className, ...rest }: TypographyProps) => react_jsx_runtime.JSX.Element;
+    Section: ({ level, children, variant, decoration, bold, italic, className, ...rest }: TypographyProps) => react_jsx_runtime.JSX.Element;
+    Paragraph: ({ level, children, variant, decoration, bold, italic, className, ...rest }: TypographyProps) => react_jsx_runtime.JSX.Element;
+    Quote: ({ level, children, variant, decoration, bold, italic, className, ...rest }: TypographyProps) => react_jsx_runtime.JSX.Element;
+    Lead: ({ children, variant, decoration, bold, italic, className, ...rest }: TypographyProps) => react_jsx_runtime.JSX.Element;
+    Caption: ({ children, variant, decoration, bold, italic, className, ...rest }: TypographyProps) => react_jsx_runtime.JSX.Element;
+    Label: ({ children, variant, decoration, bold, italic, className, ...rest }: TypographyProps) => react_jsx_runtime.JSX.Element;
+    Code: ({ children, className, ...rest }: TypographyProps) => react_jsx_runtime.JSX.Element;
+    Overline: ({ children, variant, decoration, bold, italic, className, ...rest }: TypographyProps) => react_jsx_runtime.JSX.Element;
 };
 
-interface Tier {
-    condition: (percent: number) => boolean;
-    style: {
-        bg: string;
-        color: string;
-    };
-}
-interface ValueBadgeProps {
-    value: number;
-    tiers?: Tier[];
-    lowerBound?: number;
-    upperBound?: number;
-    formatValue?: (value: number) => string | number;
-    className?: string;
-    noBackground?: boolean;
-}
+interface Tier {
+    condition: (percent: number) => boolean;
+    style: {
+        bg: string;
+        color: string;
+    };
+}
+interface ValueBadgeProps {
+    value: number;
+    tiers?: Tier[];
+    lowerBound?: number;
+    upperBound?: number;
+    formatValue?: (value: number) => string | number;
+    className?: string;
+    noBackground?: boolean;
+}
 declare const ValueBadge: ({ value, tiers, lowerBound, upperBound, formatValue, className, noBackground, }: ValueBadgeProps) => react_jsx_runtime.JSX.Element;
 
-interface CloudinaryVideoProps extends BaseComponentProps<HTMLVideoElement> {
-    publicId?: string;
-    cloudName?: string;
-    secure?: boolean;
-    controls?: boolean;
-    autoPlay?: boolean;
-    muted?: boolean;
-    loop?: boolean;
-    playsInline?: boolean;
-    poster?: string;
-    preload?: "none" | "metadata" | "auto";
-}
+interface CloudinaryVideoProps extends BaseComponentProps<HTMLVideoElement> {
+    publicId?: string;
+    cloudName?: string;
+    secure?: boolean;
+    controls?: boolean;
+    autoPlay?: boolean;
+    muted?: boolean;
+    loop?: boolean;
+    playsInline?: boolean;
+    poster?: string;
+    preload?: "none" | "metadata" | "auto";
+}
 declare function CloudinaryVideo({ publicId, cloudName, secure, controls, autoPlay, muted, loop, playsInline, poster, preload, className, ...rest }: CloudinaryVideoProps): react_jsx_runtime.JSX.Element;
 
-interface YoutubeVideoProps extends BaseComponentProps<HTMLIFrameElement> {
-    videoUrl: string;
-    width?: number;
-    height?: number;
-    autoPlay?: boolean;
-    muted?: boolean;
-    controls?: boolean;
-    loop?: boolean;
-    privacyMode?: boolean;
-}
+interface YoutubeVideoProps extends BaseComponentProps<HTMLIFrameElement> {
+    videoUrl: string;
+    width?: number;
+    height?: number;
+    autoPlay?: boolean;
+    muted?: boolean;
+    controls?: boolean;
+    loop?: boolean;
+    privacyMode?: boolean;
+}
 declare function YoutubeVideo({ videoUrl, width, height, autoPlay, muted, controls, className, ...rest }: YoutubeVideoProps): react_jsx_runtime.JSX.Element;
 
-interface WorldMapPoint {
-    code: string;
-    value: number;
-}
-interface WorldMapProps extends BaseComponentProps {
-    data: WorldMapPoint[];
-    title?: string;
-    bubbleColor?: string;
-    bubbleStroke?: string;
-    bubbleScale?: number;
-    minBubble?: number;
-    disableCountryHover?: boolean;
-    disableCountrySelect?: boolean;
-}
+interface WorldMapPoint {
+    code: string;
+    value: number;
+}
+interface WorldMapProps extends BaseComponentProps {
+    data: WorldMapPoint[];
+    title?: string;
+    bubbleColor?: string;
+    bubbleStroke?: string;
+    bubbleScale?: number;
+    minBubble?: number;
+    disableCountryHover?: boolean;
+    disableCountrySelect?: boolean;
+}
 declare function WorldMap({ data, title, bubbleColor, bubbleStroke, bubbleScale, minBubble, disableCountryHover, disableCountrySelect, className, ...rest }: WorldMapProps): react_jsx_runtime.JSX.Element;
 
-interface ButtonProps extends BaseComponentProps<HTMLButtonElement> {
-    type?: "button" | "submit" | "reset";
-    icon?: ReactNode;
-    text?: string;
-    children?: ReactNode;
-    loading?: boolean;
-    disabled?: boolean;
-    block?: boolean;
-    variant?: Variant$1;
-    appearance?: Appearance;
-    shape?: Shape$1;
-    size?: Size$1;
-}
+interface ButtonProps extends BaseComponentProps<HTMLButtonElement> {
+    type?: "button" | "submit" | "reset";
+    icon?: ReactNode;
+    text?: string;
+    children?: ReactNode;
+    loading?: boolean;
+    disabled?: boolean;
+    block?: boolean;
+    variant?: Variant$1;
+    appearance?: Appearance;
+    shape?: Shape$1;
+    size?: Size$1;
+}
 declare function Button({ type, icon, text, children, loading, disabled, block, variant, appearance, shape, size, className, onMouseMove, ...rest }: ButtonProps): react_jsx_runtime.JSX.Element;
 
-interface CheckboxOption {
-    label: string;
-    value: string;
-}
-interface BaseCheckboxProps extends BaseComponentProps {
-    placeholder?: string;
-    variant?: Variant$1;
-    shape?: Shape$1;
-}
-interface SingleCheckboxProps extends BaseCheckboxProps {
-    options?: never;
-}
-interface MultiCheckboxProps extends BaseCheckboxProps {
-    options: CheckboxOption[];
-}
-type CheckboxProps = (SingleCheckboxProps & FieldHookConfig<boolean>) | (MultiCheckboxProps & FieldHookConfig<string[]>);
+interface CheckboxOption {
+    label: string;
+    value: string;
+}
+interface BaseCheckboxProps extends BaseComponentProps {
+    placeholder?: string;
+    variant?: Variant$1;
+    shape?: Shape$1;
+}
+interface SingleCheckboxProps extends BaseCheckboxProps {
+    options?: never;
+}
+interface MultiCheckboxProps extends BaseCheckboxProps {
+    options: CheckboxOption[];
+}
+type CheckboxProps = (SingleCheckboxProps & FieldHookConfig<boolean>) | (MultiCheckboxProps & FieldHookConfig<string[]>);
 declare function Checkbox({ placeholder, variant, shape, className, ...props }: CheckboxProps): react_jsx_runtime.JSX.Element;
 
-declare enum Variant {
-    default = "default",
-    primary = "primary",
-    secondary = "secondary",
-    success = "success",
-    danger = "danger",
-    warning = "warning",
-    info = "info",
-    light = "light",
-    dark = "dark"
-}
-declare enum TextVariant {
-    default = "default",
-    primary = "primary",
-    secondary = "secondary",
-    success = "success",
-    danger = "danger",
-    warning = "warning",
-    info = "info",
-    light = "light",
-    dark = "dark"
-}
-declare enum Shape {
-    circle = "circle",
-    roundedSquare = "roundedSquare",
-    softRoundedSquare = "softRoundedSquare",
-    square = "square"
-}
-declare enum Size {
-    xs = "xs",
-    sm = "sm",
-    md = "md",
-    lg = "lg",
-    xl = "xl"
-}
-declare enum Decoration {
-    underline = "underline",
-    overline = "overline",
-    lineThrough = "lineThrough",
-    noUnderline = "noUnderline"
-}
-declare enum Target {
-    blank = "blank",
-    self = "self",
-    parent = "parent",
-    top = "top"
-}
-
-type DateSelectorProps = FieldHookConfig<string> & {
-    name: string;
-    placeholder: string;
-    styles?: string;
-    shape?: keyof typeof Shape;
-};
+declare enum Variant {
+    default = "default",
+    primary = "primary",
+    secondary = "secondary",
+    success = "success",
+    danger = "danger",
+    warning = "warning",
+    info = "info",
+    light = "light",
+    dark = "dark"
+}
+declare enum TextVariant {
+    default = "default",
+    primary = "primary",
+    secondary = "secondary",
+    success = "success",
+    danger = "danger",
+    warning = "warning",
+    info = "info",
+    light = "light",
+    dark = "dark"
+}
+declare enum Shape {
+    circle = "circle",
+    roundedSquare = "roundedSquare",
+    softRoundedSquare = "softRoundedSquare",
+    square = "square"
+}
+declare enum Size {
+    xs = "xs",
+    sm = "sm",
+    md = "md",
+    lg = "lg",
+    xl = "xl"
+}
+declare enum Decoration {
+    underline = "underline",
+    overline = "overline",
+    lineThrough = "lineThrough",
+    noUnderline = "noUnderline"
+}
+declare enum Target {
+    blank = "blank",
+    self = "self",
+    parent = "parent",
+    top = "top"
+}
+
+type DateSelectorProps = FieldHookConfig<string> & {
+    name: string;
+    placeholder: string;
+    styles?: string;
+    shape?: keyof typeof Shape;
+};
 declare const DateSelector: ({ placeholder, styles, shape, ...props }: DateSelectorProps) => react_jsx_runtime.JSX.Element;
 
-interface FormProps {
-    initialValues?: Record<string, any>;
-    validationSchema?: object;
-    enableReinitialize?: boolean;
-    children?: React$1.ReactNode;
-    styles?: string;
-    onSubmit: (values: any, helpers?: any) => void;
-    onChange?: (values: Record<string, any>, meta?: {
-        changed: Record<string, any>;
-    }) => void;
-    warnOnUnsavedChanges?: boolean;
-    onDirtyChange?: (dirty: boolean) => void;
-}
+interface FormProps {
+    initialValues?: Record<string, any>;
+    validationSchema?: object;
+    enableReinitialize?: boolean;
+    children?: React$1.ReactNode;
+    styles?: string;
+    onSubmit: (values: any, helpers?: any) => void;
+    onChange?: (values: Record<string, any>, meta?: {
+        changed: Record<string, any>;
+    }) => void;
+    warnOnUnsavedChanges?: boolean;
+    onDirtyChange?: (dirty: boolean) => void;
+}
 declare const Form: ({ initialValues, validationSchema, enableReinitialize, children, styles, onSubmit, onChange, warnOnUnsavedChanges, onDirtyChange, }: FormProps) => react_jsx_runtime.JSX.Element;
 
-interface FormResponseProps {
-    text: string | undefined;
-    variant?: keyof typeof Variant;
-    shape?: keyof typeof Shape;
-    size?: keyof typeof Size;
-    styles?: string;
-}
+interface FormResponseProps {
+    text: string | undefined;
+    variant?: keyof typeof Variant;
+    shape?: keyof typeof Shape;
+    size?: keyof typeof Size;
+    styles?: string;
+}
 declare function FormResponse({ text, variant, shape, size, styles, }: FormResponseProps): react_jsx_runtime.JSX.Element;
 
-interface ImageInputProps {
-    title?: string;
-    uploadDir?: string;
-    onValueChanged?: (imageUrl: string) => void;
-    disableSetValue?: boolean;
-}
-interface ImageInputRef {
-    handleResetClick: () => void;
-}
+interface ImageInputProps {
+    title?: string;
+    uploadDir?: string;
+    onValueChanged?: (imageUrl: string) => void;
+    disableSetValue?: boolean;
+}
+interface ImageInputRef {
+    handleResetClick: () => void;
+}
 declare const ImageInput: React$1.ForwardRefExoticComponent<(Omit<React$1.ClassAttributes<HTMLInputElement> & React$1.InputHTMLAttributes<HTMLInputElement> & formik.FieldConfig<string> & ImageInputProps, "ref"> | Omit<React$1.ClassAttributes<HTMLSelectElement> & React$1.SelectHTMLAttributes<HTMLSelectElement> & formik.FieldConfig<string> & ImageInputProps, "ref"> | Omit<React$1.ClassAttributes<HTMLTextAreaElement> & React$1.TextareaHTMLAttributes<HTMLTextAreaElement> & formik.FieldConfig<string> & ImageInputProps, "ref">) & React$1.RefAttributes<ImageInputRef>>;
 
-type InputProps = FieldHookConfig<string> & {
-    type: "text" | "password" | "number";
-    name: string;
-    placeholder: string;
-    styles?: string;
-    step?: string;
-    shape?: keyof typeof Shape;
-};
+type InputProps = FieldHookConfig<string> & {
+    type: "text" | "password" | "number";
+    name: string;
+    placeholder: string;
+    styles?: string;
+    step?: string;
+    shape?: keyof typeof Shape;
+};
 declare const Input: ({ type, placeholder, styles, step, shape, ...props }: InputProps) => react_jsx_runtime.JSX.Element;
 
-interface InputFileProps {
-    placeholder: string;
-    accept?: string;
-    styles?: string;
-}
+interface InputFileProps {
+    placeholder: string;
+    accept?: string;
+    styles?: string;
+}
 declare const InputFile: ({ placeholder, accept, styles, ...props }: FieldHookConfig<File | null> & InputFileProps) => react_jsx_runtime.JSX.Element;
 
-interface FormDataEntryLabelProps {
-    text?: string;
-    children?: React$1.ReactNode;
-    styles?: string;
-}
+interface FormDataEntryLabelProps {
+    text?: string;
+    children?: React$1.ReactNode;
+    styles?: string;
+}
 declare function InputLabel({ text, children, styles }: FormDataEntryLabelProps): react_jsx_runtime.JSX.Element;
 
-interface InputListProps {
-    name: string;
-    placeholder?: string;
-    shape?: keyof typeof Shape;
-}
+interface InputListProps {
+    name: string;
+    placeholder?: string;
+    shape?: keyof typeof Shape;
+}
 declare const InputList: ({ name, placeholder, shape }: InputListProps) => react_jsx_runtime.JSX.Element;
 
-interface InputListGroupProps {
-    name: string;
-    placeholder?: string;
-    shape?: keyof typeof Shape;
-}
+interface InputListGroupProps {
+    name: string;
+    placeholder?: string;
+    shape?: keyof typeof Shape;
+}
 declare const InputListGroup: ({ name, placeholder, shape, }: InputListGroupProps) => react_jsx_runtime.JSX.Element;
 
-interface InputResponseProps {
-    name: string;
-    visibility?: boolean;
-    variant?: keyof typeof TextVariant;
-    styles?: string;
-}
+interface InputResponseProps {
+    name: string;
+    visibility?: boolean;
+    variant?: keyof typeof TextVariant;
+    styles?: string;
+}
 declare function InputResponse({ name, visibility, variant, styles, }: InputResponseProps): react_jsx_runtime.JSX.Element;
 
-interface MultiImageInputProps {
-    title?: string;
-    uploadDir?: string;
-    name: string;
-}
+interface MultiImageInputProps {
+    title?: string;
+    uploadDir?: string;
+    name: string;
+}
 declare function MultiImageInput({ title, uploadDir, ...props }: FieldHookConfig<string[]> & MultiImageInputProps): react_jsx_runtime.JSX.Element;
 
-interface RadioProps {
-    placeholder: string;
-    options: any[];
-}
+interface RadioProps {
+    placeholder: string;
+    options: any[];
+}
 declare function Radio({ placeholder, options, ...props }: FieldHookConfig<string> & RadioProps): react_jsx_runtime.JSX.Element;
 
-interface StarRatingInputProps {
-    starAmount?: number;
-    styles?: string;
-}
+interface StarRatingInputProps {
+    starAmount?: number;
+    styles?: string;
+}
 declare function StarRatingInput({ starAmount, styles, ...props }: FieldHookConfig<string> & StarRatingInputProps): react_jsx_runtime.JSX.Element;
 
-type SelectProps = FieldHookConfig<string> & {
-    name: string;
-    placeholder: string;
-    options: any[];
-    styles?: string;
-    shape?: keyof typeof Shape;
-};
+type SelectProps = FieldHookConfig<string> & {
+    name: string;
+    placeholder: string;
+    options: any[];
+    styles?: string;
+    shape?: keyof typeof Shape;
+};
 declare function Select({ placeholder, options, styles, shape, ...props }: SelectProps): react_jsx_runtime.JSX.Element;
 
-interface SwitchProps {
-    name: string;
-    label?: string;
-    description?: string;
-    showStatus?: boolean;
-}
+interface SwitchProps {
+    name: string;
+    label?: string;
+    description?: string;
+    showStatus?: boolean;
+}
 declare function Switch({ label, description, showStatus, ...props }: FieldHookConfig<boolean> & SwitchProps): react_jsx_runtime.JSX.Element;
 
-interface TagsProps {
-    placeholder: string;
-    styles?: string;
-    limit?: number;
-}
+interface TagsProps {
+    placeholder: string;
+    styles?: string;
+    limit?: number;
+}
 declare function Tags({ placeholder, styles, limit, ...props }: TagsProps & FieldHookConfig<string[]>): react_jsx_runtime.JSX.Element;
 
-type TextAreaProps = FieldHookConfig<string> & {
-    name: string;
-    placeholder: string;
-    limit: number;
-    styles?: string;
-    shape?: keyof typeof Shape;
-};
+type TextAreaProps = FieldHookConfig<string> & {
+    name: string;
+    placeholder: string;
+    limit?: number;
+    styles?: string;
+    shape?: keyof typeof Shape;
+};
 declare function TextArea({ placeholder, limit, styles, shape, ...props }: TextAreaProps): react_jsx_runtime.JSX.Element;
 
-interface EUIComponentDefaults {
-    variant?: keyof typeof Variant;
-    size?: keyof typeof Size;
-    shape?: keyof typeof Shape;
-    styles?: string;
-}
-interface EUIRoute {
-    path: string;
-    name: string;
-}
-interface EUIConfigs {
-    global?: EUIComponentDefaults;
-    routes?: EUIRoute[];
-}
-
-interface EUIContextValue {
-    config: EUIConfigs;
-    setConfig: React$1.Dispatch<React$1.SetStateAction<EUIConfigs>>;
-}
-declare const EUIProvider: ({ config, children, }: {
-    config: EUIConfigs;
-    children: React$1.ReactNode;
-}) => react_jsx_runtime.JSX.Element;
+interface EUIComponentDefaults {
+    variant?: keyof typeof Variant;
+    size?: keyof typeof Size;
+    shape?: keyof typeof Shape;
+    styles?: string;
+}
+interface EUIRoute {
+    path: string;
+    name: string;
+}
+interface EUIConfigs {
+    global?: EUIComponentDefaults;
+    routes?: EUIRoute[];
+}
+
+interface EUIContextValue {
+    config: EUIConfigs;
+    setConfig: React$1.Dispatch<React$1.SetStateAction<EUIConfigs>>;
+}
+declare const EUIProvider: ({ config, children, }: {
+    config: EUIConfigs;
+    children: React$1.ReactNode;
+}) => react_jsx_runtime.JSX.Element;
 declare const useEUIConfig: () => EUIContextValue;
 
 declare function resolveWithGlobal<T>(config: EUIConfigs | null, props: T, defaults: Partial<T>): T;
 
-interface BackdropProps {
-    children?: React$1.ReactNode;
-    styles?: string;
-}
+interface BackdropProps {
+    children?: React$1.ReactNode;
+    styles?: string;
+}
 declare const Backdrop: ({ children, styles }: BackdropProps) => react_jsx_runtime.JSX.Element;
 
-interface SkeletonProps extends BaseComponentProps {
-    children?: React$1.ReactNode;
-}
+interface SkeletonProps extends BaseComponentProps {
+    children?: React$1.ReactNode;
+}
 declare const Skeleton: ({ children, className, ...rest }: SkeletonProps) => react_jsx_runtime.JSX.Element;
 
-declare function sendToast(data?: {
-    status: string;
-    message: string;
-}): void;
+declare function sendToast(data?: {
+    status: string;
+    message: string;
+}): void;
 declare function Toast(): react_jsx_runtime.JSX.Element;
 
-interface TransitionDropdownProps$1 {
-    visibility: any;
-    children?: ReactNode;
-}
+interface TransitionDropdownProps$1 {
+    visibility: any;
+    children?: ReactNode;
+}
 declare function TransitionDropdown({ visibility, children }: TransitionDropdownProps$1): react_jsx_runtime.JSX.Element;
 
-interface TransitionDropdownProps {
-    visibility: any;
-    children?: ReactNode;
-}
+interface TransitionDropdownProps {
+    visibility: any;
+    children?: ReactNode;
+}
 declare function TransitionFadeIn({ visibility, children }: TransitionDropdownProps): react_jsx_runtime.JSX.Element;
 
-declare const Transition: {
-    TransitionDropdown: typeof TransitionDropdown;
-    TransitionFadeIn: typeof TransitionFadeIn;
+declare const Transition: {
+    TransitionDropdown: typeof TransitionDropdown;
+    TransitionFadeIn: typeof TransitionFadeIn;
 };
 
-interface ContentAreaProps {
-    children?: ReactNode;
-    styles?: string;
-    enablePadding?: boolean;
-}
+interface ContentAreaProps {
+    children?: ReactNode;
+    styles?: string;
+    enablePadding?: boolean;
+}
 declare function ContentArea({ children, styles, enablePadding, }: ContentAreaProps): react_jsx_runtime.JSX.Element;
 
-interface FlexColProps$1 {
-    children?: React$1.ReactNode;
-    gap?: number;
-    styles?: string;
-}
+interface FlexColProps$1 {
+    children?: React$1.ReactNode;
+    gap?: number;
+    styles?: string;
+}
 declare function FlexCol({ children, gap, styles }: FlexColProps$1): react_jsx_runtime.JSX.Element;
 
-interface FlexColProps {
-    children?: React$1.ReactNode;
-    gap?: number;
-    styles?: string;
-}
+interface FlexColProps {
+    children?: React$1.ReactNode;
+    gap?: number;
+    styles?: string;
+}
 declare function FlexRow({ children, gap, styles }: FlexColProps): react_jsx_runtime.JSX.Element;
 
-declare const Flex: {
-    FlexCol: typeof FlexCol;
-    FlexRow: typeof FlexRow;
+declare const Flex: {
+    FlexCol: typeof FlexCol;
+    FlexRow: typeof FlexRow;
 };
 
-interface GridProps {
-    children?: React$1.ReactNode;
-    styles?: string;
-}
+interface GridProps {
+    children?: React$1.ReactNode;
+    styles?: string;
+}
 declare function Grid({ children, styles }: GridProps): react_jsx_runtime.JSX.Element;
 
-interface LayoutProps {
-    flexDirection?: "vertical" | "horizontal";
-    children?: React$1.ReactNode;
-    styles?: string;
-}
+interface LayoutProps {
+    flexDirection?: "vertical" | "horizontal";
+    children?: React$1.ReactNode;
+    styles?: string;
+}
 declare const Layout: ({ flexDirection, children, styles, }: LayoutProps) => react_jsx_runtime.JSX.Element;
 
-interface HeaderProps {
-    position?: "static" | "fixed" | "sticky";
-    children?: React$1.ReactNode;
-    styles?: string;
-}
+interface HeaderProps {
+    position?: "static" | "fixed" | "sticky";
+    children?: React$1.ReactNode;
+    styles?: string;
+}
 declare const Header: ({ position, children, styles, }: HeaderProps) => react_jsx_runtime.JSX.Element;
 
-interface ContentProps {
-    children?: React$1.ReactNode;
-    overlayedSidebar?: boolean;
-    sidebarVisible?: boolean;
-    styles?: string;
-}
+interface ContentProps {
+    children?: React$1.ReactNode;
+    overlayedSidebar?: boolean;
+    sidebarVisible?: boolean;
+    styles?: string;
+}
 declare const Content: ({ sidebarVisible, overlayedSidebar, children, styles, }: ContentProps) => react_jsx_runtime.JSX.Element;
 
-interface FooterProps {
-    children?: React$1.ReactNode;
-    styles?: string;
-}
+interface FooterProps {
+    children?: React$1.ReactNode;
+    styles?: string;
+}
 declare const Footer: ({ children, styles }: FooterProps) => react_jsx_runtime.JSX.Element;
 
-interface BlockProps extends BaseComponentProps {
-    title?: string;
-    description?: string;
-    required?: boolean;
-    layout?: ListDirection;
-    labelWidth?: string;
-    children: React$1.ReactNode;
-}
+interface BlockProps extends BaseComponentProps {
+    title?: string;
+    description?: string;
+    required?: boolean;
+    layout?: ListDirection;
+    labelWidth?: string;
+    children: React$1.ReactNode;
+}
 declare function Block({ title, description, required, layout, labelWidth, children, className, ...rest }: BlockProps): react_jsx_runtime.JSX.Element;
 
-interface BlockGroupProps extends BaseComponentProps {
-    title?: string;
-    description?: string;
-    children: React$1.ReactNode;
-    noDivider?: boolean;
-}
+interface BlockGroupProps extends BaseComponentProps {
+    title?: string;
+    description?: string;
+    children: React$1.ReactNode;
+    noDivider?: boolean;
+}
 declare function BlockGroup({ title, description, children, noDivider, className, ...rest }: BlockGroupProps): react_jsx_runtime.JSX.Element;
 
-interface MarkdownEditorProps {
-    placeholder?: string;
-    styles?: string;
-}
+interface MarkdownEditorProps {
+    placeholder?: string;
+    styles?: string;
+}
 declare function MarkdownEditor({ styles, ...props }: MarkdownEditorProps & FieldHookConfig<string>): react_jsx_runtime.JSX.Element;
 
-interface MarkdownTOCProps {
-    title?: string;
-}
+interface MarkdownTOCProps {
+    title?: string;
+}
 declare function MarkdownTOC({ title }: MarkdownTOCProps): react_jsx_runtime.JSX.Element | null;
 
-interface MarkdownViewerProps {
-    value?: string;
-}
+interface MarkdownViewerProps {
+    value?: string;
+}
 declare function MarkdownViewer({ value }: MarkdownViewerProps): react_jsx_runtime.JSX.Element;
 
-interface MarkdownProviderProps {
-    markdown: string;
-    children: React$1.ReactNode;
-}
+interface MarkdownProviderProps {
+    markdown: string;
+    children: React$1.ReactNode;
+}
 declare function MarkdownProvider({ markdown, children }: MarkdownProviderProps): react_jsx_runtime.JSX.Element;
 
-interface I_ItemType {
-    title: string;
-    href: string;
-}
-interface RouteConfig {
-    path: string;
-    name: string;
-}
-interface BreadcrumbProps {
-    gap?: number;
-    seperator?: string;
-    data?: I_ItemType[];
-    routes?: RouteConfig[];
-    currentPath?: string;
-    navigate?: (path: string) => void;
-    styles?: string;
-}
+interface I_ItemType {
+    title: string;
+    href: string;
+}
+interface RouteConfig {
+    path: string;
+    name: string;
+}
+interface BreadcrumbProps {
+    gap?: number;
+    seperator?: string;
+    data?: I_ItemType[];
+    routes?: RouteConfig[];
+    currentPath?: string;
+    navigate?: (path: string) => void;
+    styles?: string;
+}
 declare const Breadcrumb: ({ gap, seperator, data, routes, currentPath, navigate, styles, }: BreadcrumbProps) => react_jsx_runtime.JSX.Element;
 
-interface BreadcrumbItemProps {
-    title: string;
-    href: string;
-    active: boolean;
-    onClick?: (e: React$1.MouseEvent<HTMLAnchorElement>) => void;
-}
+interface BreadcrumbItemProps {
+    title: string;
+    href: string;
+    active: boolean;
+    onClick?: (e: React$1.MouseEvent<HTMLAnchorElement>) => void;
+}
 declare function BreadcrumbItem({ title, href, active, onClick, }: BreadcrumbItemProps): react_jsx_runtime.JSX.Element;
 
-interface DrawerProps {
-    children?: React$1.ReactNode;
-    visibility: boolean;
-    side?: "left" | "right" | "top" | "bottom";
-    handleClose: () => void;
-    styles?: string;
-}
+interface DrawerProps {
+    children?: React$1.ReactNode;
+    visibility: boolean;
+    side?: "left" | "right" | "top" | "bottom";
+    handleClose: () => void;
+    styles?: string;
+}
 declare const Drawer: ({ children, visibility, side, handleClose, styles, }: DrawerProps) => react_jsx_runtime.JSX.Element;
 
-interface DrawerTogglerProps {
-    icon?: ReactNode;
-    toggleDrawer?: () => void;
-    styles?: string;
-}
+interface DrawerTogglerProps {
+    icon?: ReactNode;
+    toggleDrawer?: () => void;
+    styles?: string;
+}
 declare function DrawerToggler({ icon, toggleDrawer, styles, }: DrawerTogglerProps): react_jsx_runtime.JSX.Element;
 
-interface I_FooterNavItem {
-    component: any;
-    icon?: React$1.ReactNode;
-    name: string;
-    badge?: React$1.ReactNode;
-    to?: string;
-    onClick?: () => void;
-}
-interface I_FooterNavGroup {
-    component: any;
-    icon?: React$1.ReactNode;
-    name: string;
-    badge?: React$1.ReactNode;
-    to?: string;
-    items: I_FooterNavItem[];
-}
-type FooterDataItemProps = I_FooterNavItem | I_FooterNavGroup;
-interface FooterNavProps {
-    data: FooterDataItemProps[];
-    styles?: string;
-}
+interface I_FooterNavItem {
+    component: any;
+    icon?: React$1.ReactNode;
+    name: string;
+    badge?: React$1.ReactNode;
+    to?: string;
+    onClick?: () => void;
+}
+interface I_FooterNavGroup {
+    component: any;
+    icon?: React$1.ReactNode;
+    name: string;
+    badge?: React$1.ReactNode;
+    to?: string;
+    items: I_FooterNavItem[];
+}
+type FooterDataItemProps = I_FooterNavItem | I_FooterNavGroup;
+interface FooterNavProps {
+    data: FooterDataItemProps[];
+    styles?: string;
+}
 declare function FooterNav({ data, styles }: FooterNavProps): react_jsx_runtime.JSX.Element;
 
-interface FooterNavGroupProps {
-    icon?: React$1.ReactNode;
-    name: string;
-    description: string;
-    badge?: React$1.ReactNode;
-    to?: string;
-    children: React$1.ReactNode;
-    styles?: string;
-}
+interface FooterNavGroupProps {
+    icon?: React$1.ReactNode;
+    name: string;
+    description: string;
+    badge?: React$1.ReactNode;
+    to?: string;
+    children: React$1.ReactNode;
+    styles?: string;
+}
 declare const FooterNavGroup: ({ icon, name, description, badge, to, styles, children, }: FooterNavGroupProps) => react_jsx_runtime.JSX.Element;
 
-interface FooterNavItemProps {
-    icon?: React$1.ReactNode;
-    name: string;
-    description: string;
-    badge?: React$1.ReactNode;
-    to?: string;
-    onClick?: () => void;
-    styles?: string;
-}
+interface FooterNavItemProps {
+    icon?: React$1.ReactNode;
+    name: string;
+    description: string;
+    badge?: React$1.ReactNode;
+    to?: string;
+    onClick?: () => void;
+    styles?: string;
+}
 declare const FooterNavItem: ({ icon, name, description, badge, to, onClick, styles, }: FooterNavItemProps) => react_jsx_runtime.JSX.Element;
 
-interface FooterNavItemTitleProps {
-    icon?: React$1.ReactNode;
-    name: string;
-    description: string;
-    badge?: React$1.ReactNode;
-    styles?: string;
-}
+interface FooterNavItemTitleProps {
+    icon?: React$1.ReactNode;
+    name: string;
+    description: string;
+    badge?: React$1.ReactNode;
+    styles?: string;
+}
 declare const FooterNavItemTitle: ({ icon, name, description, badge, styles, }: FooterNavItemTitleProps) => react_jsx_runtime.JSX.Element;
 
-interface FooterNavItemContextProps {
-    icon?: React$1.ReactNode;
-    name: string;
-    description: string;
-    badge?: React$1.ReactNode;
-}
+interface FooterNavItemContextProps {
+    icon?: React$1.ReactNode;
+    name: string;
+    description: string;
+    badge?: React$1.ReactNode;
+}
 declare const FooterNavItemContext: ({ icon, name, description, badge, }: FooterNavItemContextProps) => react_jsx_runtime.JSX.Element;
 
-interface I_HeaderNavItem {
-    component: any;
-    icon?: React$1.ReactNode;
-    name: string;
-    badge?: React$1.ReactNode;
-    to?: string;
-    onClick?: () => void;
-}
-interface I_HeaderNavGroup {
-    component: any;
-    icon?: React$1.ReactNode;
-    name: string;
-    badge?: React$1.ReactNode;
-    to?: string;
-    items: I_HeaderNavItem[];
-}
-type HeaderDataItemProps = I_HeaderNavItem | I_HeaderNavGroup;
-interface HeaderNavProps {
-    data: HeaderDataItemProps[];
-    styles?: string;
-}
+interface I_HeaderNavItem {
+    component: any;
+    icon?: React$1.ReactNode;
+    name: string;
+    badge?: React$1.ReactNode;
+    to?: string;
+    onClick?: () => void;
+}
+interface I_HeaderNavGroup {
+    component: any;
+    icon?: React$1.ReactNode;
+    name: string;
+    badge?: React$1.ReactNode;
+    to?: string;
+    items: I_HeaderNavItem[];
+}
+type HeaderDataItemProps = I_HeaderNavItem | I_HeaderNavGroup;
+interface HeaderNavProps {
+    data: HeaderDataItemProps[];
+    styles?: string;
+}
 declare function HeaderNav({ data, styles }: HeaderNavProps): react_jsx_runtime.JSX.Element;
 
-interface HeaderNavGroupProps {
-    icon?: React$1.ReactNode;
-    name: string;
-    description: string;
-    badge?: React$1.ReactNode;
-    to?: string;
-    children: React$1.ReactNode;
-    styles?: string;
-}
+interface HeaderNavGroupProps {
+    icon?: React$1.ReactNode;
+    name: string;
+    description: string;
+    badge?: React$1.ReactNode;
+    to?: string;
+    children: React$1.ReactNode;
+    styles?: string;
+}
 declare const HeaderNavGroup: ({ icon, name, description, badge, to, styles, children, }: HeaderNavGroupProps) => react_jsx_runtime.JSX.Element;
 
-interface HeaderNavItemProps {
-    icon?: React$1.ReactNode;
-    name: string;
-    description: string;
-    badge?: React$1.ReactNode;
-    to?: string;
-    onClick?: () => void;
-    styles?: string;
-}
+interface HeaderNavItemProps {
+    icon?: React$1.ReactNode;
+    name: string;
+    description: string;
+    badge?: React$1.ReactNode;
+    to?: string;
+    onClick?: () => void;
+    styles?: string;
+}
 declare const HeaderNavItem: ({ icon, name, description, badge, to, onClick, styles, }: HeaderNavItemProps) => react_jsx_runtime.JSX.Element;
 
-interface HeaderNavItemTitleProps {
-    icon?: React$1.ReactNode;
-    name: string;
-    description: string;
-    badge?: React$1.ReactNode;
-    styles?: string;
-}
+interface HeaderNavItemTitleProps {
+    icon?: React$1.ReactNode;
+    name: string;
+    description: string;
+    badge?: React$1.ReactNode;
+    styles?: string;
+}
 declare const HeaderNavItemTitle: ({ icon, name, description, badge, styles, }: HeaderNavItemTitleProps) => react_jsx_runtime.JSX.Element;
 
-interface HeaderNavItemContextProps {
-    icon?: React$1.ReactNode;
-    name: string;
-    description: string;
-    badge?: React$1.ReactNode;
-}
+interface HeaderNavItemContextProps {
+    icon?: React$1.ReactNode;
+    name: string;
+    description: string;
+    badge?: React$1.ReactNode;
+}
 declare const HeaderNavItemContext: ({ icon, name, description, badge, }: HeaderNavItemContextProps) => react_jsx_runtime.JSX.Element;
 
-interface LinkProps {
-    children?: string;
-    href?: string;
-    target?: keyof typeof Target;
-    variant?: keyof typeof TextVariant;
-    styles?: string;
-    decoration?: keyof typeof Decoration;
-    bold?: boolean;
-    italic?: boolean;
-    onClick?: () => void;
-}
+interface LinkProps {
+    children?: string;
+    href?: string;
+    target?: keyof typeof Target;
+    variant?: keyof typeof TextVariant;
+    styles?: string;
+    decoration?: keyof typeof Decoration;
+    bold?: boolean;
+    italic?: boolean;
+    onClick?: () => void;
+}
 declare const Link: ({ children, href, target, variant, decoration, bold, italic, styles, onClick, }: LinkProps) => react_jsx_runtime.JSX.Element;
 
-type MenuElementType = "item" | "group" | "title";
-interface BaseMenuNode {
-    key?: string;
-    name: string;
-    icon?: React$1.ReactNode;
-    badge?: React$1.ReactNode;
-    className?: string;
-    component?: React$1.ElementType;
-}
-interface MenuItemNode extends BaseMenuNode {
-    type: "item";
-    to?: string;
-    navigate?: (to: string) => void;
-    onClick?: (e: React$1.MouseEvent<HTMLDivElement>) => void;
-}
-interface MenuGroupNode extends BaseMenuNode {
-    type: "group";
-    items: MenuNode[];
-}
-interface MenuTitleNode extends BaseMenuNode {
-    type: "title";
-}
-type MenuNode = MenuItemNode | MenuGroupNode | MenuTitleNode;
-interface DefaultMenuElements {
-    item?: React$1.ElementType;
-    group?: React$1.ElementType;
-    title?: React$1.ElementType;
-}
-interface MenuProps {
-    items: MenuNode[];
-    defaultMenuElements?: DefaultMenuElements;
-    className?: string;
-    navigate?: (to: string) => void;
-    currentPath?: string;
+type MenuElementType = "item" | "group" | "title";
+interface BaseMenuNode {
+    key?: string;
+    name: string;
+    icon?: React$1.ReactNode;
+    badge?: React$1.ReactNode;
+    className?: string;
+    component?: React$1.ElementType;
+}
+interface MenuItemNode extends BaseMenuNode {
+    type: "item";
+    to?: string;
+    navigate?: (to: string) => void;
+    onClick?: (e: React$1.MouseEvent<HTMLDivElement>) => void;
+}
+interface MenuGroupNode extends BaseMenuNode {
+    type: "group";
+    items: MenuNode[];
+}
+interface MenuTitleNode extends BaseMenuNode {
+    type: "title";
+}
+type MenuNode = MenuItemNode | MenuGroupNode | MenuTitleNode;
+interface DefaultMenuElements {
+    item?: React$1.ElementType;
+    group?: React$1.ElementType;
+    title?: React$1.ElementType;
+}
+interface MenuProps {
+    items: MenuNode[];
+    defaultMenuElements?: DefaultMenuElements;
+    className?: string;
+    navigate?: (to: string) => void;
+    currentPath?: string;
 }
 
 declare const Menu: ({ items, className, navigate, defaultMenuElements, currentPath, }: MenuProps) => react_jsx_runtime.JSX.Element;
 
-interface MenuGroupProps extends BaseComponentProps {
-    icon?: React$1.ReactNode;
-    name: string;
-    badge?: React$1.ReactNode;
-    to?: string;
-    children: React$1.ReactNode;
-    defaultOpen?: boolean;
-}
+interface MenuGroupProps extends BaseComponentProps {
+    icon?: React$1.ReactNode;
+    name: string;
+    badge?: React$1.ReactNode;
+    to?: string;
+    children: React$1.ReactNode;
+    defaultOpen?: boolean;
+}
 declare const MenuGroup: ({ icon, name, badge, children, defaultOpen, className, style, ...rest }: MenuGroupProps) => react_jsx_runtime.JSX.Element;
 
-interface MenuItemProps extends BaseComponentProps {
-    icon?: React$1.ReactNode;
-    name: string;
-    badge?: React$1.ReactNode;
-    to?: string;
-    navigate?: (to: string) => void;
-}
+interface MenuItemProps extends BaseComponentProps {
+    icon?: React$1.ReactNode;
+    name: string;
+    badge?: React$1.ReactNode;
+    to?: string;
+    navigate?: (to: string) => void;
+}
 declare const MenuItem: ({ icon, name, badge, to, navigate, className, onClick, ...rest }: MenuItemProps) => react_jsx_runtime.JSX.Element;
 
-interface MenuItemTitleProps extends BaseComponentProps {
-    icon?: React$1.ReactNode;
-    name: string;
-    badge?: React$1.ReactNode;
-}
+interface MenuItemTitleProps extends BaseComponentProps {
+    icon?: React$1.ReactNode;
+    name: string;
+    badge?: React$1.ReactNode;
+}
 declare const MenuItemTitle: ({ icon, name, badge, className, style, ...rest }: MenuItemTitleProps) => react_jsx_runtime.JSX.Element;
 
-interface RouteTabProps extends BaseComponentProps {
-    title: string;
-    selected?: boolean;
-    onClick?: () => void;
-}
+interface RouteTabProps extends BaseComponentProps {
+    title: string;
+    selected?: boolean;
+    onClick?: () => void;
+}
 declare function RouteTab({ title, onClick, selected, className, ...rest }: RouteTabProps): react_jsx_runtime.JSX.Element;
 
-interface RouteTabsNavItem {
-    name: string;
-    to: string;
-    selected?: boolean;
-}
-interface RouteTabsProps extends BaseComponentProps {
-    navData: RouteTabsNavItem[];
-    children: React.ReactNode | ((activeTab: string) => React.ReactNode);
-    onTabClick?: (to: string) => void;
-    mode?: RouteTabMode;
-    defaultActive?: string;
-    animated?: boolean;
-}
+interface RouteTabsNavItem {
+    name: string;
+    to: string;
+    selected?: boolean;
+}
+interface RouteTabsProps extends BaseComponentProps {
+    navData: RouteTabsNavItem[];
+    children: React.ReactNode | ((activeTab: string) => React.ReactNode);
+    onTabClick?: (to: string) => void;
+    mode?: RouteTabMode;
+    defaultActive?: string;
+    animated?: boolean;
+}
 declare function RouteTabs({ navData, children, onTabClick, mode, defaultActive, animated, className, ...rest }: RouteTabsProps): react_jsx_runtime.JSX.Element;
 
-interface ModalProps {
-    title: string;
-    show: boolean;
-    handleOnClose?: () => void;
-    children?: React$1.ReactNode;
-    enableCloseOnClickOutside: boolean;
-    isLoading?: boolean;
-    isSuccess?: boolean;
-    isError?: boolean;
-    error?: unknown;
-    styles?: string;
-    shape?: keyof typeof Shape;
-}
+interface ModalProps {
+    title: string;
+    show: boolean;
+    handleOnClose?: () => void;
+    children?: React$1.ReactNode;
+    enableCloseOnClickOutside?: boolean;
+    isLoading?: boolean;
+    isSuccess?: boolean;
+    isError?: boolean;
+    error?: unknown;
+    styles?: string;
+    shape?: keyof typeof Shape;
+}
 declare function Modal({ title, show, handleOnClose, children, isLoading, isSuccess, isError, error, styles, enableCloseOnClickOutside, shape, }: ModalProps): react_jsx_runtime.JSX.Element;
 
-interface UnderConstructionBannerProps {
-    text?: string;
-}
+interface UnderConstructionBannerProps {
+    text?: string;
+}
 declare function UnderConstructionBanner({ text, }: UnderConstructionBannerProps): react_jsx_runtime.JSX.Element;
 
-interface AccordionProps {
-    summary?: ReactNode | string;
-    children?: ReactNode;
-    lhsActions?: ReactNode;
-    rhsActions?: ReactNode;
-    defaultCollapse?: boolean;
-    toggleOnSummaryClick?: boolean;
-    enableChildrenPadding?: boolean;
-}
+interface AccordionProps {
+    summary?: ReactNode | string;
+    children?: ReactNode;
+    lhsActions?: ReactNode;
+    rhsActions?: ReactNode;
+    defaultCollapse?: boolean;
+    toggleOnSummaryClick?: boolean;
+    enableChildrenPadding?: boolean;
+}
 declare function Accordion({ summary, children, lhsActions, rhsActions, defaultCollapse, toggleOnSummaryClick, enableChildrenPadding, }: AccordionProps): react_jsx_runtime.JSX.Element;
 
-declare const hoverAnimations: {
-    none: string;
-    lift: string;
-    scale: string;
-    glow: string;
-    borderGlow: string;
-    softLift: string;
+declare const hoverAnimations: {
+    none: string;
+    lift: string;
+    scale: string;
+    glow: string;
+    borderGlow: string;
+    softLift: string;
 };
 
-interface CardProps {
-    children?: ReactNode;
-    styles?: string;
-    bgVariant?: keyof typeof Variant;
-    borderVariant?: keyof typeof Variant;
-    interactive?: boolean;
-    ghost?: boolean;
-    shape?: keyof typeof Shape;
-    hoverAnimation?: keyof typeof hoverAnimations;
-}
+interface CardProps {
+    children?: ReactNode;
+    styles?: string;
+    bgVariant?: keyof typeof Variant;
+    borderVariant?: keyof typeof Variant;
+    interactive?: boolean;
+    ghost?: boolean;
+    shape?: keyof typeof Shape;
+    hoverAnimation?: keyof typeof hoverAnimations;
+}
 declare function Card({ children, styles, bgVariant, borderVariant, interactive, ghost, shape, hoverAnimation, }: CardProps): react_jsx_runtime.JSX.Element;
 
-interface CardHeaderProps {
-    icon?: React$1.ReactNode;
-    title?: string;
-    description?: string;
-    className?: string;
-}
+interface CardHeaderProps {
+    icon?: React$1.ReactNode;
+    title?: string;
+    description?: string;
+    className?: string;
+}
 declare function CardHeader({ icon, title, description, className }: CardHeaderProps): react_jsx_runtime.JSX.Element;
 
-interface CardContentProps {
-    children?: React$1.ReactNode;
-    className?: string;
-}
+interface CardContentProps {
+    children?: React$1.ReactNode;
+    className?: string;
+}
 declare function CardContent({ children, className }: CardContentProps): react_jsx_runtime.JSX.Element;
 
-interface CardFooterProps {
-    children?: React$1.ReactNode;
-    className?: string;
-}
+interface CardFooterProps {
+    children?: React$1.ReactNode;
+    className?: string;
+}
 declare function CardFooter({ children, className }: CardFooterProps): react_jsx_runtime.JSX.Element;
 
-type AnimationVariant = "none" | "gradient" | "blobs" | "mesh" | "custom";
-interface BaseAnimationConfig {
-    duration: number;
-    ease?: string;
-    opacity?: number;
-    colors?: string[];
-}
-interface BlobAnimationConfig extends BaseAnimationConfig {
-    size?: number;
-    blur?: number;
-    count?: number;
-}
-interface GradientAnimationConfig extends BaseAnimationConfig {
-    angle?: number;
-    backgroundSize?: string;
-}
-interface MeshAnimationConfig extends BaseAnimationConfig {
-    density?: number;
-    backgroundSize?: string;
-}
-interface AnimationComponentProps<T = BaseAnimationConfig> {
-    config?: T;
-    animated?: boolean;
-}
-
-type OverlayVariant = "none" | "noise" | "grid" | "dots" | "custom";
-interface BaseOverlayConfig {
-    opacity?: number;
-    size?: number;
-    color?: string;
-}
-
-interface MotionSurfaceProps {
-    children?: ReactNode;
-    animationVariant?: AnimationVariant;
-    animationConfig?: BaseAnimationConfig;
-    animated?: boolean;
-    overlay?: OverlayVariant;
-    overlayConfig?: BaseOverlayConfig;
-    className?: string;
-    customAnimation?: React$1.ComponentType<any>;
-    customOverlay?: React$1.ComponentType<any>;
-}
+type AnimationVariant = "none" | "gradient" | "blobs" | "mesh" | "custom";
+interface BaseAnimationConfig {
+    duration: number;
+    ease?: string;
+    opacity?: number;
+    colors?: string[];
+}
+interface BlobAnimationConfig extends BaseAnimationConfig {
+    size?: number;
+    blur?: number;
+    count?: number;
+}
+interface GradientAnimationConfig extends BaseAnimationConfig {
+    angle?: number;
+    backgroundSize?: string;
+}
+interface MeshAnimationConfig extends BaseAnimationConfig {
+    density?: number;
+    backgroundSize?: string;
+}
+interface AnimationComponentProps<T = BaseAnimationConfig> {
+    config?: T;
+    animated?: boolean;
+}
+
+type OverlayVariant = "none" | "noise" | "grid" | "dots" | "custom";
+interface BaseOverlayConfig {
+    opacity?: number;
+    size?: number;
+    color?: string;
+}
+
+interface MotionSurfaceProps {
+    children?: ReactNode;
+    animationVariant?: AnimationVariant;
+    animationConfig?: BaseAnimationConfig;
+    animated?: boolean;
+    overlay?: OverlayVariant;
+    overlayConfig?: BaseOverlayConfig;
+    className?: string;
+    customAnimation?: React$1.ComponentType<any>;
+    customOverlay?: React$1.ComponentType<any>;
+}
 declare function MotionSurface({ children, animationVariant, animationConfig, animated, overlay, overlayConfig, className, customAnimation: CustomAnimation, customOverlay: CustomOverlay, }: MotionSurfaceProps): react_jsx_runtime.JSX.Element;
 
-interface ThemeContextProps {
-    theme: "light" | "dark";
-    setTheme: (theme: "light" | "dark") => void;
-    toggleTheme: () => void;
-}
-declare const ThemeContext: React$1.Context<ThemeContextProps | undefined>;
-interface ThemeProviderProps {
-    defaultTheme?: "light" | "dark";
-    children: ReactNode;
-}
+interface ThemeContextProps {
+    theme: "light" | "dark";
+    setTheme: (theme: "light" | "dark") => void;
+    toggleTheme: () => void;
+}
+declare const ThemeContext: React$1.Context<ThemeContextProps | undefined>;
+interface ThemeProviderProps {
+    defaultTheme?: "light" | "dark";
+    children: ReactNode;
+}
 declare const ThemeProvider: ({ defaultTheme, children, }: ThemeProviderProps) => react_jsx_runtime.JSX.Element;
 
 declare const ThemeSwitch: () => react_jsx_runtime.JSX.Element | null;
 
 declare const ShapeSwitch: () => react_jsx_runtime.JSX.Element;
 
-interface AsyncComponentWrapperProps {
-    children: React$1.ReactNode;
-    isLoading?: boolean;
-    isSuccess?: boolean;
-    isError?: boolean;
-    error?: unknown;
-    /**
-     * Optional custom formatter if you want full control
-     */
-    errorFormatter?: (error: unknown) => string;
-}
+interface AsyncComponentWrapperProps {
+    children: React$1.ReactNode;
+    isLoading?: boolean;
+    isSuccess?: boolean;
+    isError?: boolean;
+    error?: unknown;
+    /**
+     * Optional custom formatter if you want full control
+     */
+    errorFormatter?: (error: unknown) => string;
+}
 declare function AsyncComponentWrapper({ children, isLoading, isSuccess, isError, error, errorFormatter, }: AsyncComponentWrapperProps): react_jsx_runtime.JSX.Element;
 
-interface GlowWrapperProps {
-    children: ReactNode;
-    glowSize?: number;
-    glowColor?: string;
-    className?: string;
-    /** optional: when true, glow hides while mouse is outside */
-    hideOnLeave?: boolean;
-}
+interface GlowWrapperProps {
+    children: ReactNode;
+    glowSize?: number;
+    glowColor?: string;
+    className?: string;
+    /** optional: when true, glow hides while mouse is outside */
+    hideOnLeave?: boolean;
+}
 declare const GlowWrapper: FC<GlowWrapperProps>;
 
-interface ShowMoreProps {
-    text: string;
-    limit: number;
-}
+interface ShowMoreProps {
+    text: string;
+    limit: number;
+}
 declare function ShowMore({ text, limit }: ShowMoreProps): react_jsx_runtime.JSX.Element;
 
-type SortOption = {
-    value: string;
-    label: string;
-};
-interface DataViewTableProps<T> {
-    title?: string;
-    columns: TableColumnConfig<T>[];
-    data: T[];
-    sortOptions?: SortOption[];
-    sortConfig?: Record<string, SortConfig<T>>;
-    searchPlaceholder?: string;
-    defaultPageSize?: number;
-    isLoading?: boolean;
-    isSuccess?: boolean;
-    isError?: boolean;
-    error?: unknown;
-}
+interface CommentAuthor {
+    id: string;
+    username: string;
+    avatar?: string;
+}
+interface CommentPermissions {
+    canEdit?: boolean;
+    canDelete?: boolean;
+    canReply?: boolean;
+    canReport?: boolean;
+}
+interface CommentEntity {
+    id: string;
+    parentId?: string | null;
+    content: string;
+    createdAt: string;
+    updatedAt?: string;
+    edited?: boolean;
+    likes: number;
+    dislikes: number;
+    viewerReaction?: "like" | "dislike" | null;
+    replies?: CommentEntity[];
+    repliesCount?: number;
+    isCollapsed?: boolean;
+    author: CommentAuthor;
+    permissions?: CommentPermissions;
+}
+
+interface CommentThreadProps {
+    comments?: CommentEntity[];
+    onCommentCreate?: (content: string) => Promise<void> | void;
+    onLike?: (comment: CommentEntity) => void;
+    onDislike?: (comment: CommentEntity) => void;
+    onReply?: (comment: CommentEntity) => void;
+    onEdit?: (comment: CommentEntity) => void;
+    onDelete?: (comment: CommentEntity) => void;
+    onReport?: (comment: CommentEntity) => void;
+}
+declare function CommentThread({ comments: initialComments, onCommentCreate, onLike, onDislike, onReply, onEdit, onDelete, onReport, }: CommentThreadProps): react_jsx_runtime.JSX.Element;
+
+type SortOption = {
+    value: string;
+    label: string;
+};
+interface DataViewTableProps<T> {
+    title?: string;
+    columns: TableColumnConfig<T>[];
+    data: T[];
+    sortOptions?: SortOption[];
+    sortConfig?: Record<string, SortConfig<T>>;
+    searchPlaceholder?: string;
+    defaultPageSize?: number;
+    isLoading?: boolean;
+    isSuccess?: boolean;
+    isError?: boolean;
+    error?: unknown;
+}
 declare function DataViewTable<T extends Record<string, any>>({ title, columns, data, sortOptions, sortConfig, searchPlaceholder, defaultPageSize, isLoading, isSuccess, isError, error, }: DataViewTableProps<T>): react_jsx_runtime.JSX.Element;
 
-interface DocumentationPanelProps {
-    value: string;
-    toc?: boolean;
-}
+interface DocumentationPanelProps {
+    value: string;
+    toc?: boolean;
+}
 declare function DocumentationPanel({ value, toc }: DocumentationPanelProps): react_jsx_runtime.JSX.Element;
 
-interface SliderProps {
-    isLoading?: boolean;
-    isSuccess?: boolean;
-    coverArt: string;
-    screenshots: string[];
-}
+interface SliderProps {
+    isLoading?: boolean;
+    isSuccess?: boolean;
+    coverArt: string;
+    screenshots: string[];
+}
 declare function Slider({ isLoading, isSuccess, coverArt, screenshots }: SliderProps): react_jsx_runtime.JSX.Element;
 
-interface RatingDistributionItem {
-    star: number;
-    count: number;
-}
-interface StarRatingDistributionProps extends BaseComponentProps {
-    numericRating?: boolean;
-    progressBarsRating?: boolean;
-    ratingDistribution?: RatingDistributionItem[];
-    variant?: Variant$1;
-    appearance?: Appearance;
-    shape?: Shape$1;
-    size?: Size$1;
-    animated?: boolean;
-    striped?: boolean;
-    showReviewCount?: boolean;
-}
+interface RatingDistributionItem {
+    star: number;
+    count: number;
+}
+interface StarRatingDistributionProps extends BaseComponentProps {
+    numericRating?: boolean;
+    progressBarsRating?: boolean;
+    ratingDistribution?: RatingDistributionItem[];
+    variant?: Variant$1;
+    appearance?: Appearance;
+    shape?: Shape$1;
+    size?: Size$1;
+    animated?: boolean;
+    striped?: boolean;
+    showReviewCount?: boolean;
+}
 declare function StarRatingDistribution({ numericRating, progressBarsRating, ratingDistribution, variant, appearance, shape, size, animated, striped, showReviewCount, className, ...rest }: StarRatingDistributionProps): react_jsx_runtime.JSX.Element;
 
-interface WorldMapCountryTableProps {
-    title?: string;
-    data: WorldMapPoint[];
-}
+interface WorldMapCountryTableProps {
+    title?: string;
+    data: WorldMapPoint[];
+}
 declare function WorldMapCountryTable({ title, data, }: WorldMapCountryTableProps): react_jsx_runtime.JSX.Element;
 
-interface NavItem {
-    icon: React$1.ReactNode;
-    name: string;
-    to: string;
-    selected?: boolean;
-}
-interface BoxNavProps {
-    data?: NavItem[];
-    currentPath?: string;
-    onNavigate?: (to: string) => void;
-    navigate?: (to: string) => void;
+interface NavItem {
+    icon: React$1.ReactNode;
+    name: string;
+    to: string;
+    selected?: boolean;
+}
+interface BoxNavProps {
+    data?: NavItem[];
+    currentPath?: string;
+    onNavigate?: (to: string) => void;
+    navigate?: (to: string) => void;
 }
 
 declare function BoxNav({ data, currentPath, onNavigate, navigate }: BoxNavProps): react_jsx_runtime.JSX.Element;
 
-interface BoxNavItemProps {
-    icon: React$1.ReactNode;
-    name: string;
-    to: string;
-    selected?: boolean;
-    onClick?: (event: React$1.MouseEvent<HTMLButtonElement>, to: string) => void;
-}
+interface BoxNavItemProps {
+    icon: React$1.ReactNode;
+    name: string;
+    to: string;
+    selected?: boolean;
+    onClick?: (event: React$1.MouseEvent<HTMLButtonElement>, to: string) => void;
+}
 declare function BoxNavItem({ icon, name, to, selected, onClick }: BoxNavItemProps): react_jsx_runtime.JSX.Element;
 
-interface SidebarProps extends BaseComponentProps {
-    items?: MenuNode[];
-    navigate?: (to: string) => void;
-    currentPath?: string;
-}
+interface SidebarProps extends BaseComponentProps {
+    items?: MenuNode[];
+    navigate?: (to: string) => void;
+    currentPath?: string;
+}
 declare function Sidebar({ items, navigate, currentPath, className, ...rest }: SidebarProps): react_jsx_runtime.JSX.Element;
 
-interface TopNavComponents {
-    item?: React.ElementType;
-    group?: React.ElementType;
-    dropdown?: React.ElementType;
-    dropdownItem?: React.ElementType;
-    dropdownGroup?: React.ElementType;
-    dropdownTitle?: React.ElementType;
-}
-interface BaseTopNavNode {
-    key?: string;
-    name: string;
-    icon?: React.ReactNode;
-    badge?: React.ReactNode;
-    className?: string;
-    component?: React.ElementType;
-}
-interface TopNavItemNode extends BaseTopNavNode {
-    type: "item";
-    to?: string;
-    onClick?: () => void;
-}
-interface TopNavGroupNode extends BaseTopNavNode {
-    type: "group";
-    items: TopNavNode[];
-    columns?: number;
-}
-interface TopNavTitleNode extends BaseTopNavNode {
-    type: "title";
-}
-type TopNavNode = TopNavItemNode | TopNavGroupNode | TopNavTitleNode;
-interface TopNavProps {
-    items: TopNavNode[];
-    currentPath?: string;
-    navigate?: (to: string) => void;
-    components?: TopNavComponents;
+interface TopNavComponents {
+    item?: React.ElementType;
+    group?: React.ElementType;
+    dropdown?: React.ElementType;
+    dropdownItem?: React.ElementType;
+    dropdownGroup?: React.ElementType;
+    dropdownTitle?: React.ElementType;
+}
+interface BaseTopNavNode {
+    key?: string;
+    name: string;
+    icon?: React.ReactNode;
+    badge?: React.ReactNode;
+    className?: string;
+    component?: React.ElementType;
+}
+interface TopNavItemNode extends BaseTopNavNode {
+    type: "item";
+    to?: string;
+    onClick?: () => void;
+}
+interface TopNavGroupNode extends BaseTopNavNode {
+    type: "group";
+    items: TopNavNode[];
+    columns?: number;
+}
+interface TopNavTitleNode extends BaseTopNavNode {
+    type: "title";
+}
+type TopNavNode = TopNavItemNode | TopNavGroupNode | TopNavTitleNode;
+interface TopNavProps {
+    items: TopNavNode[];
+    currentPath?: string;
+    navigate?: (to: string) => void;
+    components?: TopNavComponents;
 }
 
 declare const TopNav: ({ items, currentPath, navigate, components, }: TopNavProps) => react_jsx_runtime.JSX.Element;
 
-interface TNDropdownProps extends BaseComponentProps {
-    items: TopNavNode[];
-    navigate?: (to: string) => void;
-    components?: any;
-}
+interface TNDropdownProps extends BaseComponentProps {
+    items: TopNavNode[];
+    navigate?: (to: string) => void;
+    components?: any;
+}
 declare const TNDropdown: ({ items, navigate, components, }: TNDropdownProps) => react_jsx_runtime.JSX.Element;
 
-interface TNDropdownItemProps extends BaseComponentProps {
-    icon?: React.ReactNode;
-    name: string;
-    badge?: React.ReactNode;
-    to?: string;
-    navigate?: (to: string) => void;
-    onClick?: (e: MouseEvent<HTMLDivElement>) => void;
-}
+interface TNDropdownItemProps extends BaseComponentProps {
+    icon?: React.ReactNode;
+    name: string;
+    badge?: React.ReactNode;
+    to?: string;
+    navigate?: (to: string) => void;
+    onClick?: (e: MouseEvent<HTMLDivElement>) => void;
+}
 declare const TNDropdownItem: ({ icon, name, badge, to, navigate, onClick, className, }: TNDropdownItemProps) => react_jsx_runtime.JSX.Element;
 
-interface TNDropdownTitleProps extends BaseComponentProps {
-    name: string;
-}
+interface TNDropdownTitleProps extends BaseComponentProps {
+    name: string;
+}
 declare const TNDropdownTitle: ({ name, className }: TNDropdownTitleProps) => react_jsx_runtime.JSX.Element;
 
-interface TNGroupProps extends BaseComponentProps {
-    icon?: React.ReactNode;
-    name: string;
-    items: TopNavNode[];
-    navigate?: (to: string) => void;
-    columns?: number;
-    components?: any;
-    selected?: boolean;
-}
+interface TNGroupProps extends BaseComponentProps {
+    icon?: React.ReactNode;
+    name: string;
+    items: TopNavNode[];
+    navigate?: (to: string) => void;
+    columns?: number;
+    components?: any;
+    selected?: boolean;
+}
 declare const TNGroup: ({ icon, name, items, navigate, columns, components, selected, }: TNGroupProps) => react_jsx_runtime.JSX.Element;
 
-declare const useDrawer: (defaultVisibility?: boolean) => {
-    show: boolean;
-    openDrawer: () => void;
-    closeDrawer: () => void;
+declare const useDrawer: (defaultVisibility?: boolean) => {
+    show: boolean;
+    openDrawer: () => void;
+    closeDrawer: () => void;
 };
 
-declare const useModal: () => {
-    show: boolean;
-    handleOpenModal: () => void;
-    handleCloseModal: () => void;
+declare const useModal: () => {
+    show: boolean;
+    handleOpenModal: () => void;
+    handleCloseModal: () => void;
 };
 
-type ClickOutsideCallback = () => void;
+type ClickOutsideCallback = () => void;
 declare function useClickOutside(ref: MutableRefObject<HTMLElement | null>, fun?: ClickOutsideCallback): void;
 
 declare const useIsMobile: (breakpoint?: number) => boolean;
@@ -1541,63 +1581,63 @@ declare const useCurrentTheme: () => "light" | "dark";
 
 declare const useTheme: () => any;
 
-interface GenericLayoutProps {
-    children?: ReactNode;
-    styles?: string;
-    defaultTheme?: "light" | "dark";
-}
+interface GenericLayoutProps {
+    children?: ReactNode;
+    styles?: string;
+    defaultTheme?: "light" | "dark";
+}
 declare function GenericLayout({ children, styles, defaultTheme, }: GenericLayoutProps): react_jsx_runtime.JSX.Element;
 
-interface DefaultLayoutProps {
-    children?: ReactNode;
-    header?: ReactNode;
-    footer?: ReactNode;
-}
+interface DefaultLayoutProps {
+    children?: ReactNode;
+    header?: ReactNode;
+    footer?: ReactNode;
+}
 declare function DefaultLayout({ children, header, footer, }: DefaultLayoutProps): react_jsx_runtime.JSX.Element;
 
-interface HomeLayoutProps {
-    children?: ReactNode;
-    header?: ReactNode;
-    footer?: ReactNode;
-}
+interface HomeLayoutProps {
+    children?: ReactNode;
+    header?: ReactNode;
+    footer?: ReactNode;
+}
 declare function HomeLayout({ children, header, footer, }: HomeLayoutProps): react_jsx_runtime.JSX.Element;
 
-interface SidebarLayoutProps {
-    children?: ReactNode;
-    header?: ReactNode;
-    footer?: ReactNode;
-}
+interface SidebarLayoutProps {
+    children?: ReactNode;
+    header?: ReactNode;
+    footer?: ReactNode;
+}
 declare function SidebarLayout({ children, header, footer, }: SidebarLayoutProps): react_jsx_runtime.JSX.Element;
 
-interface SidemenuLayoutProps {
-    data?: any;
-    children?: ReactNode;
-}
+interface SidemenuLayoutProps {
+    data?: any;
+    children?: ReactNode;
+}
 declare function SidemenuLayout({ data, children }: SidemenuLayoutProps): react_jsx_runtime.JSX.Element;
 
-interface EUIDevLayoutProps {
-    children?: ReactNode;
-    header?: ReactNode;
-    footer?: ReactNode;
-}
+interface EUIDevLayoutProps {
+    children?: ReactNode;
+    header?: ReactNode;
+    footer?: ReactNode;
+}
 declare function EUIDevLayout({ children, header, footer, }: EUIDevLayoutProps): react_jsx_runtime.JSX.Element;
 
-interface CloudinaryConfig {
-    cloudName: string;
-}
-interface CloudinaryProviderProps extends CloudinaryConfig {
-    children: ReactNode;
+interface CloudinaryConfig {
+    cloudName: string;
+}
+interface CloudinaryProviderProps extends CloudinaryConfig {
+    children: ReactNode;
 }
 
 declare const CloudinaryProvider: ({ cloudName, children, }: CloudinaryProviderProps) => react_jsx_runtime.JSX.Element;
 
 declare const useCloudinaryConfig: () => CloudinaryConfig;
 
-interface ScrollToTopProps {
-    trigger?: any;
-    behavior?: ScrollBehavior;
-    target?: HTMLElement | null;
-}
+interface ScrollToTopProps {
+    trigger?: any;
+    behavior?: ScrollBehavior;
+    target?: HTMLElement | null;
+}
 declare function ScrollToTop({ trigger, behavior, target, }: ScrollToTopProps): null;
 
 declare function cn(...inputs: ClassValue[]): string;
@@ -1608,16 +1648,16 @@ declare const getCurrencySymbol: (code: CurrencyCode) => string | null;
 
 declare const enumValues: <T extends Record<string, string>>(enumObject: T) => string[];
 
-declare const normalize: (path?: string) => string;
+declare const normalize: (path?: string) => string;
 declare const isMatch: (itemPath?: string, currentPath?: string) => boolean;
 
-interface ResolveAppearanceStylesProps {
-    appearance?: Appearance;
-    variant: Variant$1;
-    solid: Record<string, string>;
-    lite: Record<string, string>;
-    ghost: Record<string, string>;
-}
+interface ResolveAppearanceStylesProps {
+    appearance?: Appearance;
+    variant: Variant$1;
+    solid: Record<string, string>;
+    lite: Record<string, string>;
+    ghost: Record<string, string>;
+}
 declare function resolveAppearanceStyles({ appearance, variant, solid, lite, ghost, }: ResolveAppearanceStylesProps): string;
 
-export { Accordion, type AnimationComponentProps, type AnimationVariant, type Appearance, AsyncComponentWrapper, Avatar, Backdrop, Badge, BarChart, type BaseAnimationConfig, type BaseComponentProps, type BaseMenuNode, type BaseOverlayConfig, type BaseTopNavNode, type BlobAnimationConfig, Block, BlockGroup, BoxNav, BoxNavItem, Brand, Breadcrumb, BreadcrumbItem, Button, Caption, Card, CardContent, CardFooter, CardHeader, type CardinalPosition, Chapter, Checkbox, Chip, type CloudinaryConfig, CloudinaryImage, CloudinaryProvider, type CloudinaryProviderProps, CloudinaryVideo, Code, Content, ContentArea, type CornerPosition, type CurrencyCode, DataView, DataViewTable, DateSelector, DefaultLayout, type DefaultMenuElements, Display, DocumentationPanel, Drawer, DrawerToggler, type EUIComponentDefaults, type EUIConfigs, EUIDevLayout, EUIProvider, type EUIRoute, Flag, Flex, FlexCol, FlexRow, Footer, FooterNav, FooterNavGroup, FooterNavItem, FooterNavItemContext, FooterNavItemTitle, Form, FormResponse, GenericLayout, GlowWrapper, type GradientAnimationConfig, Graph, type GraphData, GraphEdge, type GraphEdgeType, type GraphLayoutType, GraphNode, type GraphNodeType, type GraphProps, GraphRenderer, Grid, Header, HeaderNav, HeaderNavGroup, HeaderNavItem, HeaderNavItemContext, HeaderNavItemTitle, HomeLayout, type HorizontalPosition, type HyperRefTarget, Image, ImageInput, Info, Input, InputFile, InputLabel, InputList, InputListGroup, InputResponse, Label, Layout, type LayoutContext, type LayoutExecutor, Lead, LineChart, Link, List, type ListAlign, type ListBulletType, type ListDirection, ListItem, type ListItemData, MarkdownEditor, MarkdownProvider, MarkdownTOC, MarkdownViewer, Menu, type MenuElementType, MenuGroup, type MenuGroupNode, MenuItem, type MenuItemNode, MenuItemTitle, type MenuNode, type MenuProps, type MenuTitleNode, type MeshAnimationConfig, Modal, MotionSurface, MultiImageInput, type NavItem, NumericRating, type OctilePosition, type OverlayVariant, Overline, Paragraph, PieChart, PriceTag, ProgressBar, type ProgressBarProps, ProgressBarRating, Quote, Radio, RouteTab, type RouteTabMode, RouteTabs, ScrollToTop, Section, Select, type Shape$1 as Shape, ShapeSwitch, ShowMore, Sidebar, SidebarLayout, SidemenuLayout, type Size$1 as Size, Skeleton, Slider, StarRating, StarRatingDistribution, StarRatingInput, Switch, TNDropdown, TNDropdownItem, TNDropdownTitle, TNGroup, Table, Tag, Tags, TextArea, type TextDecoration, ThemeContext, ThemeProvider, ThemeSwitch, TitleBanner, type TitleBannerLevel, Toast, Tooltip, TopNav, type TopNavComponents, type TopNavGroupNode, type TopNavItemNode, type TopNavNode, type TopNavProps, type TopNavTitleNode, Transition, TransitionDropdown, TransitionFadeIn, Typography, UnderConstructionBanner, ValueBadge, type Variant$1 as Variant, type VerticalPosition, WorldMap, WorldMapCountryTable, YoutubeVideo as YoutubeVideoPlayer, cn, createForceLayout, createGridLayout, createTreeLayout, enumValues, getCurrencySymbol, getLayout, isMatch, isRenderFn, normalize, registerLayout, resolveAppearanceStyles, resolveWithGlobal, sendToast, useClickOutside, useCloudinaryConfig, useCurrentTheme, useDrawer, useEUIConfig, useIsMobile, useModal, useTheme };
+export { Accordion, type AnimationComponentProps, type AnimationVariant, type Appearance, AsyncComponentWrapper, Avatar, Backdrop, Badge, BarChart, type BaseAnimationConfig, type BaseComponentProps, type BaseMenuNode, type BaseOverlayConfig, type BaseTopNavNode, type BlobAnimationConfig, Block, BlockGroup, BoxNav, BoxNavItem, Brand, Breadcrumb, BreadcrumbItem, Button, Caption, Card, CardContent, CardFooter, CardHeader, type CardinalPosition, Chapter, Checkbox, Chip, type CloudinaryConfig, CloudinaryImage, CloudinaryProvider, type CloudinaryProviderProps, CloudinaryVideo, Code, CommentThread, Content, ContentArea, type CornerPosition, type CurrencyCode, DataView, DataViewTable, DateSelector, DefaultLayout, type DefaultMenuElements, Display, DocumentationPanel, Drawer, DrawerToggler, type EUIComponentDefaults, type EUIConfigs, EUIDevLayout, EUIProvider, type EUIRoute, Flag, Flex, FlexCol, FlexRow, Footer, FooterNav, FooterNavGroup, FooterNavItem, FooterNavItemContext, FooterNavItemTitle, Form, FormResponse, GenericLayout, GlowWrapper, type GradientAnimationConfig, Graph, type GraphData, GraphEdge, type GraphEdgeType, type GraphLayoutType, GraphNode, type GraphNodeType, type GraphProps, GraphRenderer, Grid, Header, HeaderNav, HeaderNavGroup, HeaderNavItem, HeaderNavItemContext, HeaderNavItemTitle, HomeLayout, type HorizontalPosition, type HyperRefTarget, Image, ImageInput, Info, Input, InputFile, InputLabel, InputList, InputListGroup, InputResponse, Label, Layout, type LayoutContext, type LayoutExecutor, Lead, LineChart, Link, List, type ListAlign, type ListBulletType, type ListDirection, ListItem, type ListItemData, MarkdownEditor, MarkdownProvider, MarkdownTOC, MarkdownViewer, Menu, type MenuElementType, MenuGroup, type MenuGroupNode, MenuItem, type MenuItemNode, MenuItemTitle, type MenuNode, type MenuProps, type MenuTitleNode, type MeshAnimationConfig, Modal, MotionSurface, MultiImageInput, type NavItem, NumericRating, type OctilePosition, type OverlayVariant, Overline, Paragraph, PieChart, PriceTag, ProgressBar, type ProgressBarProps, ProgressBarRating, Quote, Radio, RouteTab, type RouteTabMode, RouteTabs, ScrollToTop, Section, Select, type Shape$1 as Shape, ShapeSwitch, ShowMore, Sidebar, SidebarLayout, SidemenuLayout, type Size$1 as Size, Skeleton, Slider, StarRating, StarRatingDistribution, StarRatingInput, Switch, TNDropdown, TNDropdownItem, TNDropdownTitle, TNGroup, Table, Tag, Tags, TextArea, type TextDecoration, ThemeContext, ThemeProvider, ThemeSwitch, TitleBanner, type TitleBannerLevel, Toast, Tooltip, TopNav, type TopNavComponents, type TopNavGroupNode, type TopNavItemNode, type TopNavNode, type TopNavProps, type TopNavTitleNode, Transition, TransitionDropdown, TransitionFadeIn, Typography, UnderConstructionBanner, ValueBadge, type Variant$1 as Variant, type VerticalPosition, WorldMap, WorldMapCountryTable, YoutubeVideo as YoutubeVideoPlayer, cn, createForceLayout, createGridLayout, createTreeLayout, enumValues, getCurrencySymbol, getLayout, isMatch, isRenderFn, normalize, registerLayout, resolveAppearanceStyles, resolveWithGlobal, sendToast, useClickOutside, useCloudinaryConfig, useCurrentTheme, useDrawer, useEUIConfig, useIsMobile, useModal, useTheme };