elseware-ui 2.27.2 → 2.27.5

package/dist/index.d.mts

@@ -0,0 +1,1537 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React$1, { HTMLAttributes, ReactNode, JSX, FC, MouseEvent, MutableRefObject } from 'react';
+import { ChartData, ChartOptions } from 'chart.js';
+import * as d3 from 'd3';
+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;
+}
+
+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 Vertical = "top" | "bottom";
+type Horizontal = "left" | "right";
+type CardinalPosition = Vertical | Horizontal;
+type CornerPosition = `${Vertical}-${Horizontal}`;
+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";
+
+interface AvatarProps extends BaseComponentProps {
+    alt?: string;
+    icon?: ReactNode;
+    variant?: Variant$1;
+    shape?: Shape$1;
+    size?: Size$1;
+    src?: string;
+    borderVariant?: boolean;
+    children?: ReactNode;
+}
+declare const Avatar: ({ alt, icon, children, variant, shape, size, src, borderVariant, className, ...rest }: AvatarProps) => react_jsx_runtime.JSX.Element;
+
+interface BadgeProps extends BaseComponentProps {
+    offset?: [number, number];
+    dot?: boolean;
+    count?: number;
+    variant?: Variant$1;
+    shape?: Shape$1;
+    size?: Size$1;
+    showZero?: boolean;
+    position?: OctilePosition;
+    children?: ReactNode;
+}
+declare const Badge: ({ children, offset, dot, count, variant, shape, size, showZero, position, className, ...rest }: BadgeProps) => react_jsx_runtime.JSX.Element;
+
+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;
+}
+declare function Brand({ src, alt, className, ...rest }: BrandProps): react_jsx_runtime.JSX.Element;
+
+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">;
+}
+declare const LineChart: React$1.FC<LineChartProps>;
+
+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;
+    shape?: Shape$1;
+    ghost?: boolean;
+    size?: Size$1;
+}
+declare const Chip: ({ label, variant, shape, ghost, 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;
+};
+
+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;
+};
+declare function DataViewHeader({ children }: DataViewHeaderProps): react_jsx_runtime.JSX.Element;
+
+type DataViewSidebarProps = {
+    children: ReactNode;
+};
+declare function DataViewSidebar({ children }: DataViewSidebarProps): react_jsx_runtime.JSX.Element;
+
+type DataViewContentProps<T = any> = {
+    children: ReactNode | ((data: T[]) => ReactNode);
+};
+declare function DataViewContent<T = any>({ children, }: DataViewContentProps<T>): JSX.Element;
+
+type DataViewFooterProps = {
+    children: ReactNode;
+};
+declare function DataViewFooter({ children }: DataViewFooterProps): react_jsx_runtime.JSX.Element;
+
+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;
+};
+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;
+};
+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;
+};
+declare function DataViewPageSize({ pageSizeOptions, shape, }: Props$4): react_jsx_runtime.JSX.Element;
+
+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;
+};
+
+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;
+}
+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>;
+}
+declare const GraphEdge: React$1.FC<Props$2>;
+
+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;
+}
+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 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;
+declare const getLayout: (type: GraphLayoutType) => LayoutExecutor;
+
+interface CloudinaryImageProps extends BaseComponentProps {
+    publicId?: string;
+    cloudName?: string;
+    secure?: boolean;
+    alt?: string;
+}
+declare function CloudinaryImage({ publicId, cloudName, secure, alt, className, ...rest }: CloudinaryImageProps): react_jsx_runtime.JSX.Element;
+
+interface CloudinaryConfig {
+    cloudName: string;
+}
+declare const CloudinaryProvider: ({ cloudName, children, }: CloudinaryConfig & {
+    children: React.ReactNode;
+}) => react_jsx_runtime.JSX.Element;
+declare const useCloudinaryConfig: () => CloudinaryConfig;
+
+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;
+}
+declare function Info({ children, className, variant, appearance, shape, ...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;
+}
+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;
+}
+declare const ListItem: ({ content, TypographyComponent, bulletType, renderBullet, index, align, className, }: ListItemProps) => react_jsx_runtime.JSX.Element;
+
+interface PriceTagProps {
+    discount?: number;
+    price: number;
+    code?: string;
+    styles?: string;
+}
+declare function PriceTag({ discount, price, code, styles }: PriceTagProps): react_jsx_runtime.JSX.Element | undefined;
+
+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"
+}
+
+interface ProgressBarProps {
+    value: number;
+    variant?: keyof typeof Variant;
+    size?: keyof typeof Size;
+    showLabel?: boolean;
+    label?: string;
+    labelPlacement?: "top" | "overlay";
+    styles?: string;
+}
+declare const ProgressBar: ({ value, variant, size, showLabel, label, labelPlacement, styles, }: ProgressBarProps) => react_jsx_runtime.JSX.Element;
+
+interface StarRatingProps {
+    rating: number;
+    isNumericRatingEnabled?: boolean;
+    reviewAmount?: number;
+    isReviewAmountEnabled?: boolean;
+    styles?: string;
+}
+declare function StarRating({ rating, reviewAmount, isNumericRatingEnabled, isReviewAmountEnabled, styles }: StarRatingProps): react_jsx_runtime.JSX.Element;
+
+declare function StarRatingDistribution({ numericRating, progressBarsRating, ratingDistribution, }: {
+    numericRating?: boolean | undefined;
+    progressBarsRating?: boolean | undefined;
+    ratingDistribution?: {
+        star: number;
+        count: number;
+    }[] | undefined;
+}): react_jsx_runtime.JSX.Element;
+
+interface SliderProps {
+    isLoading?: boolean;
+    isSuccess?: boolean;
+    coverArt: string;
+    screenshots: string[];
+}
+declare function Slider({ isLoading, isSuccess, coverArt, screenshots }: SliderProps): 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;
+}
+declare function Table<T extends Record<string, any>>({ title, columns, data, shape, }: TableProps<T>): react_jsx_runtime.JSX.Element;
+
+interface TagProps {
+    text: string;
+    styles?: string;
+}
+declare function Tag({ text, styles }: TagProps): react_jsx_runtime.JSX.Element;
+
+interface TooltipProps {
+    content: ReactNode;
+    show: boolean;
+    offsetX?: number;
+    offsetY?: number;
+    className?: string;
+}
+/**
+ * A generalized tooltip that automatically follows the mouse cursor.
+ */
+declare function Tooltip({ content, show, offsetX, offsetY, className, }: TooltipProps): react_jsx_runtime.JSX.Element | null;
+
+interface QuoteProps {
+    children?: string;
+    styles?: string;
+}
+declare const Quote: ({ children, styles }: QuoteProps) => react_jsx_runtime.JSX.Element;
+
+interface ParagraphProps {
+    level: 1 | 2 | 3;
+    children?: string;
+    variant?: keyof typeof TextVariant;
+    styles?: string;
+    decoration?: keyof typeof Decoration;
+    bold?: boolean;
+    italic?: boolean;
+    onClick?: () => void;
+}
+declare const Paragraph: ({ level, children, variant, decoration, bold, italic, styles, onClick, }: ParagraphProps) => react_jsx_runtime.JSX.Element;
+
+interface SectionProps {
+    level: 1 | 2 | 3;
+    children?: string;
+    variant?: keyof typeof TextVariant;
+    styles?: string;
+    decoration?: keyof typeof Decoration;
+    bold?: boolean;
+    italic?: boolean;
+    onClick?: () => void;
+}
+declare const Section: ({ level, children, variant, decoration, bold, italic, styles, onClick, }: SectionProps) => react_jsx_runtime.JSX.Element;
+
+interface ChapterProps {
+    level: 1 | 2 | 3;
+    children?: string;
+    variant?: keyof typeof TextVariant;
+    styles?: string;
+    decoration?: keyof typeof Decoration;
+    bold?: boolean;
+    italic?: boolean;
+    onClick?: () => void;
+}
+declare const Chapter: ({ level, children, variant, decoration, bold, italic, styles, onClick, }: ChapterProps) => react_jsx_runtime.JSX.Element;
+
+declare const Typography: {
+    Chapter: ({ level, children, variant, decoration, bold, italic, styles, onClick, }: ChapterProps) => react_jsx_runtime.JSX.Element;
+    Section: ({ level, children, variant, decoration, bold, italic, styles, onClick, }: SectionProps) => react_jsx_runtime.JSX.Element;
+    Paragraph: ({ level, children, variant, decoration, bold, italic, styles, onClick, }: ParagraphProps) => react_jsx_runtime.JSX.Element;
+    Quote: ({ children, styles }: QuoteProps) => 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;
+}
+declare const ValueBadge: ({ value, tiers, lowerBound, upperBound, formatValue, className, noBackground, }: ValueBadgeProps) => react_jsx_runtime.JSX.Element;
+
+declare function CloudinaryVideo(): react_jsx_runtime.JSX.Element;
+
+interface YoutubeVideoPlayerProps {
+    videoUrl: string;
+    width?: number;
+    height?: number;
+}
+declare function YoutubeVideoPlayer({ videoUrl, width, height, }: YoutubeVideoPlayerProps): react_jsx_runtime.JSX.Element;
+
+interface WorldMapPoint {
+    code: string;
+    value: number;
+}
+interface WorldMapProps {
+    data: WorldMapPoint[];
+    title?: string;
+    bubbleColor?: string;
+    bubbleStroke?: string;
+    bubbleScale?: number;
+    minBubble?: number;
+    styles?: string;
+    disableCountryHover?: boolean;
+    disableCountrySelect?: boolean;
+}
+declare function WorldMap({ data, title, bubbleColor, bubbleStroke, bubbleScale, minBubble, styles, disableCountryHover, disableCountrySelect, }: WorldMapProps): react_jsx_runtime.JSX.Element;
+
+interface ButtonProps {
+    type?: "button" | "submit";
+    icon?: ReactNode;
+    text?: string;
+    children?: ReactNode;
+    loading?: boolean;
+    disabled?: boolean;
+    ghost?: boolean;
+    block?: boolean;
+    variant?: keyof typeof Variant;
+    shape?: keyof typeof Shape;
+    size?: keyof typeof Size;
+    styles?: string;
+    onClick?: () => void;
+}
+declare const Button: ({ type, icon, text, children, loading, disabled, ghost, block, variant, shape, size, styles, onClick, }: ButtonProps) => react_jsx_runtime.JSX.Element;
+
+interface CheckboxOption {
+    label: string;
+    value: string;
+}
+interface BaseCheckboxProps {
+    placeholder: string;
+}
+interface SingleCheckboxProps extends BaseCheckboxProps {
+    options?: never;
+}
+interface MultiCheckboxProps extends BaseCheckboxProps {
+    options: CheckboxOption[];
+}
+type CheckboxProps = (SingleCheckboxProps & FieldHookConfig<boolean>) | (MultiCheckboxProps & FieldHookConfig<string[]>);
+declare const Checkbox: React$1.FC<CheckboxProps>;
+
+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;
+}
+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;
+}
+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;
+}
+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;
+};
+declare const Input: ({ type, placeholder, styles, step, shape, ...props }: InputProps) => react_jsx_runtime.JSX.Element;
+
+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;
+}
+declare function InputLabel({ text, children, styles }: FormDataEntryLabelProps): react_jsx_runtime.JSX.Element;
+
+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;
+}
+declare const InputListGroup: ({ name, placeholder, shape, }: InputListGroupProps) => react_jsx_runtime.JSX.Element;
+
+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;
+}
+declare function MultiImageInput({ title, uploadDir, ...props }: FieldHookConfig<string[]> & MultiImageInputProps): react_jsx_runtime.JSX.Element;
+
+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;
+}
+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;
+};
+declare function Select({ placeholder, options, styles, shape, ...props }: SelectProps): react_jsx_runtime.JSX.Element;
+
+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;
+}
+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;
+};
+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;
+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;
+}
+declare const Backdrop: ({ children, styles }: BackdropProps) => react_jsx_runtime.JSX.Element;
+
+interface SkeletonProps {
+    children?: React$1.ReactNode;
+    styles?: string;
+}
+declare const Skeleton: ({ children, styles }: SkeletonProps) => react_jsx_runtime.JSX.Element;
+
+declare function sendToast(data?: {
+    status: string;
+    message: string;
+}): void;
+declare function Toast(): react_jsx_runtime.JSX.Element;
+
+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;
+}
+declare function TransitionFadeIn({ visibility, children }: TransitionDropdownProps): react_jsx_runtime.JSX.Element;
+
+declare const Transition: {
+    TransitionDropdown: typeof TransitionDropdown;
+    TransitionFadeIn: typeof TransitionFadeIn;
+};
+
+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;
+}
+declare function FlexCol({ children, gap, styles }: FlexColProps$1): react_jsx_runtime.JSX.Element;
+
+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;
+};
+
+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;
+}
+declare const Layout: ({ flexDirection, children, styles, }: LayoutProps) => react_jsx_runtime.JSX.Element;
+
+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;
+}
+declare const Content: ({ sidebarVisible, overlayedSidebar, children, styles, }: ContentProps) => react_jsx_runtime.JSX.Element;
+
+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;
+}
+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;
+}
+declare function BlockGroup({ title, description, children, noDivider, className, ...rest }: BlockGroupProps): react_jsx_runtime.JSX.Element;
+
+interface MarkdownEditorProps {
+    placeholder?: string;
+    styles?: string;
+}
+declare function MarkdownEditor({ styles, ...props }: MarkdownEditorProps & FieldHookConfig<string>): react_jsx_runtime.JSX.Element;
+
+interface MarkdownTOCProps {
+    title?: string;
+}
+declare function MarkdownTOC({ title }: MarkdownTOCProps): react_jsx_runtime.JSX.Element | null;
+
+interface MarkdownViewerProps {
+    value?: string;
+}
+declare function MarkdownViewer({ value }: MarkdownViewerProps): react_jsx_runtime.JSX.Element;
+
+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;
+}
+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;
+}
+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;
+}
+declare const Drawer: ({ children, visibility, side, handleClose, styles, }: DrawerProps) => react_jsx_runtime.JSX.Element;
+
+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;
+}
+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;
+}
+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;
+}
+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;
+}
+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;
+}
+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;
+}
+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;
+}
+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;
+}
+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;
+}
+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;
+}
+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;
+}
+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;
+}
+
+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;
+}
+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;
+}
+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;
+}
+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;
+}
+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;
+}
+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;
+}
+declare function Modal({ title, show, handleOnClose, children, isLoading, isSuccess, isError, error, styles, enableCloseOnClickOutside, shape, }: ModalProps): react_jsx_runtime.JSX.Element;
+
+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;
+}
+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;
+};
+
+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;
+}
+declare function CardHeader({ icon, title, description, className }: CardHeaderProps): react_jsx_runtime.JSX.Element;
+
+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;
+}
+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>;
+}
+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;
+}
+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;
+}
+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;
+}
+declare const GlowWrapper: FC<GlowWrapperProps>;
+
+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;
+}
+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 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;
+}
+
+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;
+}
+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;
+}
+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;
+}
+
+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;
+}
+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;
+}
+declare const TNDropdownItem: ({ icon, name, badge, to, navigate, onClick, className, }: TNDropdownItemProps) => react_jsx_runtime.JSX.Element;
+
+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;
+}
+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 useModal: () => {
+    show: boolean;
+    handleOpenModal: () => void;
+    handleCloseModal: () => void;
+};
+
+type ClickOutsideCallback = () => void;
+declare function useClickOutside(ref: MutableRefObject<HTMLElement | null>, fun?: ClickOutsideCallback): void;
+
+declare const useIsMobile: (breakpoint?: number) => boolean;
+
+declare const useCurrentTheme: () => "light" | "dark";
+
+declare const useTheme: () => any;
+
+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;
+}
+declare function DefaultLayout({ children, header, footer, }: DefaultLayoutProps): react_jsx_runtime.JSX.Element;
+
+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;
+}
+declare function SidebarLayout({ children, header, footer, }: SidebarLayoutProps): react_jsx_runtime.JSX.Element;
+
+interface SidemenuLayoutProps {
+    data?: any;
+    children?: ReactNode;
+}
+declare function SidemenuLayout({ data, children }: SidemenuLayoutProps): react_jsx_runtime.JSX.Element;
+
+interface DocumentationLayoutProps {
+    value: string;
+    toc?: boolean;
+}
+declare function DocumentationLayout({ value, toc }: DocumentationLayoutProps): react_jsx_runtime.JSX.Element;
+
+interface EUIDevLayoutProps {
+    children?: ReactNode;
+    header?: ReactNode;
+    footer?: ReactNode;
+}
+declare function EUIDevLayout({ children, header, footer, }: EUIDevLayoutProps): react_jsx_runtime.JSX.Element;
+
+declare function cn(...inputs: ClassValue[]): string;
+
+declare const getCurrencySymbol: (code: string) => string | null;
+
+declare function isRenderFn(children: ReactNode | ((activeTab: string) => ReactNode)): children is (activeTab: string) => ReactNode;
+
+declare const normalize: (path?: string) => string;
+declare const isMatch: (itemPath?: string, currentPath?: string) => boolean;
+
+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, Card, CardContent, CardFooter, CardHeader, type CardinalPosition, Chapter, Checkbox, Chip, CloudinaryImage, CloudinaryProvider, CloudinaryVideo, Content, ContentArea, type CornerPosition, DataView, DataViewTable, DateSelector, DefaultLayout, type DefaultMenuElements, DocumentationLayout, 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 HyperRefTarget, Image, ImageInput, Info, Input, InputFile, InputLabel, InputList, InputListGroup, InputResponse, Layout, type LayoutContext, type LayoutExecutor, 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, type OctilePosition, type OverlayVariant, Paragraph, PieChart, PriceTag, ProgressBar, type ProgressBarProps, Quote, Radio, RouteTab, type RouteTabMode, RouteTabs, 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, WorldMap, WorldMapCountryTable, YoutubeVideoPlayer, cn, createForceLayout, createGridLayout, createTreeLayout, getCurrencySymbol, getLayout, isMatch, isRenderFn, normalize, registerLayout, resolveWithGlobal, sendToast, useClickOutside, useCloudinaryConfig, useCurrentTheme, useDrawer, useEUIConfig, useIsMobile, useModal, useTheme };