elseware-ui 2.32.0 → 2.33.0

package/dist/index.d.mts

@@ -1,461 +1,1095 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import React$1, { HTMLAttributes, ReactNode, JSX, FC, ComponentType, MouseEvent, MutableRefObject } from 'react';
+import * as React$1 from 'react';
+import React__default, { HTMLAttributes, ReactNode, JSX, FC, ComponentType, 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;
-}
-
-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">;
-}
-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;
-    appearance?: Appearance;
-    shape?: Shape$1;
-    size?: Size$1;
-}
+interface BarChartProps extends BaseComponentProps {
+    data: ChartData<"bar">;
+    options: ChartOptions<"bar">;
+}
+declare const BarChart: React__default.FC<BarChartProps>;
+
+interface LineChartProps extends BaseComponentProps {
+    data: ChartData<"line">;
+    options?: ChartOptions<"line">;
+}
+declare const LineChart: React__default.FC<LineChartProps>;
+
+interface PieChartProps extends BaseComponentProps {
+    data: ChartData<"pie">;
+    options: ChartOptions<"pie">;
+}
+declare const PieChart: React__default.FC<PieChartProps>;
+
+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>>;
-}
-declare function DataViewProvider<T extends Record<string, any>>({ data, children, defaultPageSize, sortConfig, }: Props$5<T>): react_jsx_runtime.JSX.Element;
-
-type DataViewHeaderProps = {
-    children: ReactNode;
-};
+interface Props$2<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$2<T>): react_jsx_runtime.JSX.Element;
+
+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;
-};
-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;
+type Props$1 = {
+    pageSizeOptions?: (number | "All")[];
+    shape?: Shape$1;
 };
+declare function DataViewPageSize({ pageSizeOptions, shape, }: Props$1): react_jsx_runtime.JSX.Element;
 
-interface FlagProps extends BaseComponentProps {
-    code: string;
-    width?: number | string;
-    height?: number | string;
-}
+type Props = {
+    shape?: Shape$1;
+};
+declare function DataViewPagination({ shape }: Props): 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;
-}[];
+type GraphUnsubscribe = () => void;
+type GraphDataHandler<TData extends GraphDataPoint = GraphDataPoint> = (data: TData | TData[]) => void;
+type GraphErrorHandler = (error: Error) => void;
+interface GraphDataSource<TData extends GraphDataPoint = GraphDataPoint> {
+    mode: GraphDataMode;
+    getInitialData?: () => Promise<TData[]> | TData[];
+    refresh?: () => Promise<TData[]> | TData[];
+    subscribe?: (onData: GraphDataHandler<TData>, onError?: GraphErrorHandler) => GraphUnsubscribe;
+}
+interface StaticGraphDataSourceOptions<TData extends GraphDataPoint = GraphDataPoint> {
+    data: TData[];
+}
+interface PollingGraphDataSourceOptions<TData extends GraphDataPoint = GraphDataPoint> {
+    interval?: number;
+    immediate?: boolean;
+    fetcher: () => Promise<TData[]> | TData[];
+}
+interface RealtimeGraphDataSourceOptions<TData extends GraphDataPoint = GraphDataPoint> {
+    connect: (onData: GraphDataHandler<TData>, onError?: GraphErrorHandler) => GraphUnsubscribe;
+    getInitialData?: () => Promise<TData[]> | TData[];
+    refresh?: () => Promise<TData[]> | TData[];
+}
+interface UseGraphPollingOptions<TData extends GraphDataPoint = GraphDataPoint> {
+    enabled?: boolean;
+    interval?: number;
+    immediate?: boolean;
+    normalize?: boolean;
+    fetcher: () => Promise<TData[]> | TData[];
+    onData?: (data: TData[]) => void;
+    onError?: GraphErrorHandler;
+}
+interface UseGraphRealtimeOptions<TData extends GraphDataPoint = GraphDataPoint> {
+    enabled?: boolean;
+    maxDataPoints?: number;
+    normalize?: boolean;
+    connect: (onData: GraphDataHandler<TData>, onError?: GraphErrorHandler) => GraphUnsubscribe;
+    onData?: (data: TData[]) => void;
+    onError?: GraphErrorHandler;
+}
+
+type GraphSeriesType = "line" | "area" | "bar" | "scatter";
+type GraphSeriesColor = "primary" | "secondary" | "success" | "warning" | "danger" | "info" | "muted" | string;
+interface GraphSeries {
+    key: string;
+    label?: string;
+    type?: GraphSeriesType;
+    color?: GraphSeriesColor;
+    unit?: string;
+    visible?: boolean;
+    strokeWidth?: number;
+    radius?: number;
+    format?: GraphValueFormat;
+    prefix?: string;
+    suffix?: string;
+    yAxisId?: string | number;
+}
+interface ResolvedGraphSeries extends Required<Pick<GraphSeries, "key">> {
+    label: string;
+    type: GraphSeriesType;
+    color: string;
+    unit?: string;
+    visible: boolean;
+    strokeWidth: number;
+    radius: number;
+    format?: GraphValueFormat;
+    prefix?: string;
+    suffix?: string;
+    yAxisId?: string | number;
+}
+interface UseGraphSeriesOptions<TData extends GraphDataPoint = GraphDataPoint> {
+    data?: TData[];
+    series?: GraphSeries[];
+    excludeKeys?: string[];
+    xKey?: string;
+}
+
+interface GraphThemePanel {
+    background: string;
+    border: string;
+    radius: string;
+    shadow: string;
+}
+interface GraphThemeText {
+    title: string;
+    description: string;
+    muted: string;
+}
+interface GraphThemeChart {
+    grid: string;
+    axis: string;
+    cursor: string;
+}
+interface GraphThemeTooltip {
+    background: string;
+    border: string;
+    text: string;
+    muted: string;
+}
+interface GraphTheme {
+    panel: GraphThemePanel;
+    text: GraphThemeText;
+    chart: GraphThemeChart;
+    tooltip: GraphThemeTooltip;
+    colors: string[];
+}
+type GraphThemeMode = "dark" | "light";
+interface UseGraphThemeOptions {
+    mode?: GraphThemeMode;
+    theme?: Partial<GraphTheme>;
+}
+
+type GraphPrimitive = string | number | boolean | Date | null | undefined;
+type GraphDataPoint = Record<string, GraphPrimitive>;
+type GraphStatus = "idle" | "loading" | "success" | "error" | "streaming";
+type GraphDataMode = "static" | "polling" | "realtime";
+type GraphChartType = "line" | "area" | "bar" | "pie" | "scatter" | "gauge" | "stat";
+type GraphValueFormat = "raw" | "number" | "integer" | "compact" | "percent" | "currency" | "bytes" | "duration";
+interface GraphState<TData extends GraphDataPoint = GraphDataPoint> {
+    data: TData[];
+    loading: boolean;
+    error: Error | null;
+    status: GraphStatus;
+    lastUpdatedAt?: Date;
+}
+interface GraphContextValue<TData extends GraphDataPoint = GraphDataPoint> extends GraphState<TData> {
+    mode?: GraphDataMode;
+    maxDataPoints: number;
+    refresh: () => Promise<void>;
+    replaceData: (data: TData[]) => void;
+    appendData: (data: TData | TData[]) => void;
+    clearData: () => void;
+}
+interface GraphProviderProps<TData extends GraphDataPoint = GraphDataPoint> {
+    children: ReactNode;
+    data?: TData[];
+    dataSource?: GraphDataSource<TData>;
+    maxDataPoints?: number;
+    autoLoad?: boolean;
+    theme?: Partial<GraphTheme>;
+    onDataChange?: (data: TData[]) => void;
+    onError?: (error: Error) => void;
+}
+interface BaseGraphProps<TData extends GraphDataPoint = GraphDataPoint> {
+    data?: TData[];
+    xKey?: keyof TData | string;
+    series?: GraphSeries[];
+    height?: number;
+    loading?: boolean;
+    error?: Error | null;
+    className?: string;
+    showGrid?: boolean;
+    showTooltip?: boolean;
+    showLegend?: boolean;
+    animated?: boolean;
+}
+interface GraphTooltipPayload {
+    name?: string;
+    value?: unknown;
+    color?: string;
+    dataKey?: string;
+    payload?: GraphDataPoint;
+}
+
+interface GraphPanelConfig {
+    title?: ReactNode;
+    description?: ReactNode;
+    actions?: ReactNode;
+    toolbar?: ReactNode;
+    withPanel?: boolean;
+    showToolbar?: boolean;
+    showRefresh?: boolean;
+    showLastUpdated?: boolean;
+    emptyMessage?: ReactNode;
+    emptyDescription?: ReactNode;
+    onRetry?: () => void | Promise<void>;
+}
+interface GraphPieConfig<TData extends GraphDataPoint = GraphDataPoint> {
+    nameKey?: keyof TData | string;
+    valueKey?: keyof TData | string;
+    innerRadius?: number | string;
+    outerRadius?: number | string;
+    valueFormat?: GraphValueFormat;
+    unit?: string;
+}
+interface GraphGaugeConfig<TData extends GraphDataPoint = GraphDataPoint> {
+    valueKey?: keyof TData | string;
+    /**
+     * Shared with StatGraph.
+     * GaugeGraph uses only number values at runtime.
+     */
+    value?: number | string;
+    label?: string;
+    min?: number;
+    max?: number;
+    color?: string;
+    unit?: string;
+    format?: GraphValueFormat;
+}
+interface GraphStatConfig<TData extends GraphDataPoint = GraphDataPoint> {
+    valueKey?: keyof TData | string;
+    value?: number | string;
+    previousValue?: number;
+    label?: string;
+    format?: GraphValueFormat;
+    prefix?: string;
+    suffix?: string;
+    unit?: string;
+    showTrend?: boolean;
+}
+interface GraphBarConfig {
+    layout?: "horizontal" | "vertical";
+}
+interface GraphProps<TData extends GraphDataPoint = GraphDataPoint> extends Omit<BaseGraphProps<TData>, "data">, GraphPanelConfig, GraphPieConfig<TData>, GraphGaugeConfig<TData>, GraphStatConfig<TData>, GraphBarConfig {
+    children?: ReactNode;
+    type?: GraphChartType;
+    data?: TData[];
+    dataSource?: GraphDataSource<TData>;
+    autoLoad?: GraphProviderProps<TData>["autoLoad"];
+    maxDataPoints?: GraphProviderProps<TData>["maxDataPoints"];
+    theme?: Partial<GraphTheme>;
+    themeMode?: GraphThemeMode;
+    chartClassName?: string;
+    contentClassName?: string;
+    onDataChange?: GraphProviderProps<TData>["onDataChange"];
+    onError?: GraphProviderProps<TData>["onError"];
+}
+interface GraphRenderChartProps<TData extends GraphDataPoint = GraphDataPoint> extends GraphProps<TData> {
+    series?: GraphSeries[];
+}
+
+declare function Graph<TData extends GraphDataPoint = GraphDataPoint>(props: GraphProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface GraphPanelProps {
+    title?: ReactNode;
+    description?: ReactNode;
+    actions?: ReactNode;
+    toolbar?: ReactNode;
+    children: ReactNode;
+    className?: string;
+    contentClassName?: string;
+    height?: number;
+    loading?: boolean;
+    error?: Error | null;
+    empty?: boolean;
+    emptyMessage?: ReactNode;
+    emptyDescription?: ReactNode;
+    showToolbar?: boolean;
+    showRefresh?: boolean;
+    showLastUpdated?: boolean;
+    onRetry?: () => void | Promise<void>;
+}
+declare function GraphPanel({ title, description, actions, toolbar, children, className, contentClassName, height, loading, error, empty, emptyMessage, emptyDescription, showToolbar, showRefresh, showLastUpdated, onRetry, }: GraphPanelProps): react_jsx_runtime.JSX.Element;
+
+interface GraphHeaderProps {
+    title?: ReactNode;
+    description?: ReactNode;
+    actions?: ReactNode;
+    className?: string;
+}
+declare function GraphHeader({ title, description, actions, className, }: GraphHeaderProps): react_jsx_runtime.JSX.Element | null;
+
+interface GraphToolbarProps {
+    children?: ReactNode;
+    className?: string;
+    showRefresh?: boolean;
+    showLastUpdated?: boolean;
+    refreshLabel?: ReactNode;
+    onRefresh?: () => void | Promise<void>;
+}
+declare function GraphToolbar({ children, className, showRefresh, showLastUpdated, refreshLabel, onRefresh, }: GraphToolbarProps): react_jsx_runtime.JSX.Element | null;
+
+interface GraphLegendItem {
+    key: string;
+    label?: string;
+    color?: string;
+    value?: unknown;
+    unit?: string;
+    format?: GraphValueFormat;
+    prefix?: string;
+    suffix?: string;
+    active?: boolean;
+}
+interface GraphLegendProps<TData extends GraphDataPoint = GraphDataPoint> {
+    items?: GraphLegendItem[];
+    series?: GraphSeries[];
+    data?: TData[];
+    className?: string;
+    showValues?: boolean;
+    valueSource?: "latest" | "none";
+    onItemClick?: (item: GraphLegendItem) => void;
+}
+declare function GraphLegend<TData extends GraphDataPoint = GraphDataPoint>({ items, series, data, className, showValues, valueSource, onItemClick, }: GraphLegendProps<TData>): react_jsx_runtime.JSX.Element | null;
+
+interface GraphTooltipFormatterOptions {
+    format?: GraphValueFormat;
+    prefix?: string;
+    suffix?: string;
+    unit?: string;
+}
+interface GraphTooltipProps {
+    active?: boolean;
+    label?: string | number;
+    payload?: GraphTooltipPayload[];
+    className?: string;
+    labelFormatter?: (label: string | number) => string;
+    valueFormatter?: (value: unknown, name?: string, payload?: GraphTooltipPayload) => string;
+    seriesFormatters?: Record<string, GraphTooltipFormatterOptions>;
+}
+declare function GraphTooltip({ active, label, payload, className, labelFormatter, valueFormatter, seriesFormatters, }: GraphTooltipProps): react_jsx_runtime.JSX.Element | null;
+
+interface GraphEmptyStateProps {
+    height?: number;
+    message?: ReactNode;
+    description?: ReactNode;
+    className?: string;
+}
+declare function GraphEmptyState({ height, message, description, className, }: GraphEmptyStateProps): react_jsx_runtime.JSX.Element;
+
+interface GraphErrorStateProps {
+    error?: Error | null;
+    height?: number;
+    title?: ReactNode;
+    message?: ReactNode;
+    className?: string;
+    onRetry?: () => void | Promise<void>;
+    retryLabel?: ReactNode;
+}
+declare function GraphErrorState({ error, height, title, message, className, onRetry, retryLabel, }: GraphErrorStateProps): react_jsx_runtime.JSX.Element;
+
+interface GraphLoadingStateProps {
+    height?: number;
+    message?: ReactNode;
+    className?: string;
+    showMessage?: boolean;
+}
+declare function GraphLoadingState({ height, message, className, showMessage, }: GraphLoadingStateProps): react_jsx_runtime.JSX.Element;
 
-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<HTMLImageElement> {
-    publicId?: string;
-    cloudName?: string;
-    secure?: boolean;
-    alt?: string;
-    fallbackSrc?: string;
-    loading?: "lazy" | "eager";
-}
+interface GraphContainerProps {
+    children: ReactNode;
+    height?: number;
+    className?: string;
+    contentClassName?: string;
+}
+declare function GraphContainer({ children, height, className, contentClassName, }: GraphContainerProps): react_jsx_runtime.JSX.Element;
+
+declare function LineGraph<TData extends GraphDataPoint = GraphDataPoint>({ data, xKey, series, height, loading, error, className, showGrid, showTooltip, showLegend, animated, }: BaseGraphProps<TData>): react_jsx_runtime.JSX.Element;
+
+declare function AreaGraph<TData extends GraphDataPoint = GraphDataPoint>({ data, xKey, series, height, loading, error, className, showGrid, showTooltip, showLegend, animated, }: BaseGraphProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface BarGraphProps<TData extends GraphDataPoint = GraphDataPoint> extends BaseGraphProps<TData> {
+    layout?: "horizontal" | "vertical";
+}
+declare function BarGraph<TData extends GraphDataPoint = GraphDataPoint>({ data, xKey, series, height, loading, error, className, showGrid, showTooltip, showLegend, animated, layout, }: BarGraphProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface PieGraphProps<TData extends GraphDataPoint = GraphDataPoint> extends Omit<BaseGraphProps<TData>, "xKey" | "series"> {
+    nameKey?: keyof TData | string;
+    valueKey?: keyof TData | string;
+    innerRadius?: number | string;
+    outerRadius?: number | string;
+    valueFormat?: GraphValueFormat;
+    unit?: string;
+}
+declare function PieGraph<TData extends GraphDataPoint = GraphDataPoint>({ data, nameKey, valueKey, height, loading, error, className, showTooltip, showLegend, animated, innerRadius, outerRadius, valueFormat, unit, }: PieGraphProps<TData>): react_jsx_runtime.JSX.Element;
+
+declare function ScatterGraph<TData extends GraphDataPoint = GraphDataPoint>({ data, xKey, series, height, loading, error, className, showGrid, showTooltip, showLegend, animated, }: BaseGraphProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface GaugeGraphProps<TData extends GraphDataPoint = GraphDataPoint> {
+    data?: TData[];
+    valueKey?: keyof TData | string;
+    label?: string;
+    value?: number;
+    min?: number;
+    max?: number;
+    height?: number;
+    color?: string;
+    unit?: string;
+    format?: GraphValueFormat;
+    loading?: boolean;
+    error?: Error | null;
+    className?: string;
+}
+declare function GaugeGraph<TData extends GraphDataPoint = GraphDataPoint>({ data, valueKey, label, value, min, max, height, color, unit, format, loading, error, className, }: GaugeGraphProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface StatGraphProps<TData extends GraphDataPoint = GraphDataPoint> {
+    data?: TData[];
+    valueKey?: keyof TData | string;
+    label?: string;
+    value?: number | string;
+    previousValue?: number;
+    format?: GraphValueFormat;
+    prefix?: string;
+    suffix?: string;
+    unit?: string;
+    loading?: boolean;
+    error?: Error | null;
+    className?: string;
+    showTrend?: boolean;
+}
+declare function StatGraph<TData extends GraphDataPoint = GraphDataPoint>({ data, valueKey, label, value, previousValue, format, prefix, suffix, unit, loading, error, className, showTrend, }: StatGraphProps<TData>): react_jsx_runtime.JSX.Element;
+
+declare function GraphProvider<TData extends GraphDataPoint = GraphDataPoint>({ children, data, dataSource, maxDataPoints, autoLoad, onDataChange, onError, }: GraphProviderProps<TData>): react_jsx_runtime.JSX.Element;
+
+declare const GraphContext: React$1.Context<GraphContextValue<GraphDataPoint>>;
+
+declare function useGraphContext<TData extends GraphDataPoint = GraphDataPoint>(): GraphContextValue<TData>;
+
+type GraphAction<TData extends GraphDataPoint = GraphDataPoint> = {
+    type: "SET_LOADING";
+    payload?: boolean;
+} | {
+    type: "SET_ERROR";
+    payload: Error | null;
+} | {
+    type: "SET_DATA";
+    payload: TData[];
+} | {
+    type: "APPEND_DATA";
+    payload: {
+        data: TData | TData[];
+        maxDataPoints?: number;
+    };
+} | {
+    type: "CLEAR_DATA";
+} | {
+    type: "SET_STREAMING";
+    payload?: boolean;
+};
+declare function createInitialGraphState<TData extends GraphDataPoint = GraphDataPoint>(data?: TData[]): GraphState<TData>;
+declare function graphReducer<TData extends GraphDataPoint = GraphDataPoint>(state: GraphState<TData>, action: GraphAction<TData>): GraphState<TData>;
+
+declare abstract class BaseGraphDataSource<TData extends GraphDataPoint = GraphDataPoint> implements GraphDataSource<TData> {
+    abstract readonly mode: GraphDataMode;
+    getInitialData?(): Promise<TData[]> | TData[];
+    refresh?(): Promise<TData[]> | TData[];
+    subscribe?(onData: GraphDataHandler<TData>, onError?: GraphErrorHandler): GraphUnsubscribe;
+    protected normalizeError(error: unknown): Error;
+    protected ensureArray(data: TData | TData[] | null | undefined): TData[];
+    protected safeExecute<TResult>(executor: () => Promise<TResult> | TResult): Promise<TResult>;
+}
+
+interface StaticGraphDataSourceConfig<TData extends GraphDataPoint = GraphDataPoint> {
+    data?: TData[];
+}
+declare class StaticGraphDataSource<TData extends GraphDataPoint = GraphDataPoint> extends BaseGraphDataSource<TData> {
+    readonly mode: GraphDataMode;
+    private data;
+    constructor(config?: StaticGraphDataSourceConfig<TData> | TData[]);
+    getInitialData(): TData[];
+    refresh(): TData[];
+    setData(data: TData[]): void;
+    appendData(data: TData | TData[]): void;
+    clearData(): void;
+}
+
+interface PollingGraphDataSourceConfig<TData extends GraphDataPoint = GraphDataPoint> {
+    fetcher: () => Promise<TData[]> | TData[];
+    interval?: number;
+    immediate?: boolean;
+}
+declare class PollingGraphDataSource<TData extends GraphDataPoint = GraphDataPoint> extends BaseGraphDataSource<TData> {
+    readonly mode: GraphDataMode;
+    private readonly fetcher;
+    private readonly interval;
+    private readonly immediate;
+    constructor(config: PollingGraphDataSourceConfig<TData>);
+    getInitialData(): Promise<TData[]>;
+    refresh(): Promise<TData[]>;
+    subscribe(onData: GraphDataHandler<TData>, onError?: GraphErrorHandler): GraphUnsubscribe;
+}
+
+interface RealtimeGraphDataSourceConfig<TData extends GraphDataPoint = GraphDataPoint> {
+    connect: (onData: GraphDataHandler<TData>, onError?: GraphErrorHandler) => GraphUnsubscribe;
+    getInitialData?: () => Promise<TData[]> | TData[];
+    refresh?: () => Promise<TData[]> | TData[];
+}
+declare class RealtimeGraphDataSource<TData extends GraphDataPoint = GraphDataPoint> extends BaseGraphDataSource<TData> {
+    readonly mode: GraphDataMode;
+    private readonly connect;
+    private readonly initialDataLoader?;
+    private readonly refreshHandler?;
+    constructor(config: RealtimeGraphDataSourceConfig<TData>);
+    getInitialData(): Promise<TData[]> | TData[];
+    refresh(): Promise<TData[]> | TData[];
+    subscribe(onData: GraphDataHandler<TData>, onError?: GraphErrorHandler): GraphUnsubscribe;
+}
+
+interface UseGraphDataOptions<TData extends GraphDataPoint = GraphDataPoint> {
+    data?: TData[];
+    dataSource?: GraphDataSource<TData>;
+    autoLoad?: boolean;
+    maxDataPoints?: number;
+    normalize?: boolean;
+    onDataChange?: (data: TData[]) => void;
+    onError?: (error: Error) => void;
+}
+interface UseGraphDataReturn<TData extends GraphDataPoint = GraphDataPoint> extends GraphState<TData> {
+    refresh: () => Promise<void>;
+    replaceData: (data: TData[]) => void;
+    appendData: (data: TData | TData[]) => void;
+    clearData: () => void;
+}
+declare function useGraphData<TData extends GraphDataPoint = GraphDataPoint>({ data, dataSource, autoLoad, maxDataPoints, normalize, onDataChange, onError, }?: UseGraphDataOptions<TData>): UseGraphDataReturn<TData>;
+
+declare function useGraphRealtime<TData extends GraphDataPoint = GraphDataPoint>({ enabled, maxDataPoints, normalize, connect, onData, onError, }: UseGraphRealtimeOptions<TData>): {
+    data: TData[];
+    error: Error | null;
+    connected: boolean;
+    loading: boolean;
+    status: string;
+    lastUpdatedAt: Date | undefined;
+    clearData: () => void;
+};
+
+declare function useGraphPolling<TData extends GraphDataPoint = GraphDataPoint>({ enabled, interval, immediate, normalize, fetcher, onData, onError, }: UseGraphPollingOptions<TData>): {
+    data: TData[];
+    error: Error | null;
+    loading: boolean;
+    status: string;
+    lastUpdatedAt: Date | undefined;
+    refresh: () => Promise<void>;
+};
+
+declare function useGraphSeries<TData extends GraphDataPoint = GraphDataPoint>({ data, series, xKey, excludeKeys, }: UseGraphSeriesOptions<TData>): ResolvedGraphSeries[];
+
+declare function useGraphTheme({ mode, theme, }?: UseGraphThemeOptions): GraphTheme;
+
+type RawGraphDataPoint = Record<string, unknown>;
+type NormalizedGraphDataPoint = Record<string, GraphPrimitive>;
+interface NormalizeGraphDataOptions {
+    /**
+     * Converts Date values to ISO strings.
+     *
+     * Default: true
+     */
+    serializeDates?: boolean;
+    /**
+     * Converts numeric strings such as "42" or "12.5" to numbers.
+     *
+     * Default: true
+     */
+    parseNumericStrings?: boolean;
+    /**
+     * Converts invalid values such as NaN and Infinity to null.
+     *
+     * Default: true
+     */
+    sanitizeInvalidNumbers?: boolean;
+    /**
+     * Keeps only the selected keys.
+     */
+    keys?: string[];
+    /**
+     * Removes keys with undefined values.
+     *
+     * Default: true
+     */
+    removeUndefined?: boolean;
+}
+declare function normalizeGraphData<TData extends RawGraphDataPoint>(data: TData[] | null | undefined, options?: NormalizeGraphDataOptions): NormalizedGraphDataPoint[];
+declare function normalizeGraphDataPoint<TData extends RawGraphDataPoint>(dataPoint: TData, options?: NormalizeGraphDataOptions): NormalizedGraphDataPoint;
+
+interface FormatGraphValueOptions {
+    format?: GraphValueFormat;
+    locale?: string;
+    prefix?: string;
+    suffix?: string;
+    currency?: string;
+    minimumFractionDigits?: number;
+    maximumFractionDigits?: number;
+    fallback?: string;
+}
+declare function formatGraphValue(value: unknown, options?: FormatGraphValueOptions): string;
+
+type GraphColorName = "primary" | "secondary" | "success" | "warning" | "danger" | "info" | "muted";
+interface ResolveGraphColorOptions {
+    index?: number;
+    fallback?: string;
+    palette?: string[];
+}
+declare function resolveGraphColor(color?: string, options?: ResolveGraphColorOptions): string;
+declare function resolveGraphColors(count: number, options?: ResolveGraphColorOptions): string[];
+
+interface LimitRealtimePointsOptions {
+    /**
+     * Maximum number of points to keep.
+     *
+     * Default: 100
+     */
+    maxPoints?: number;
+    /**
+     * Whether new data should be added to the end or beginning.
+     *
+     * Default: "end"
+     */
+    appendDirection?: "start" | "end";
+}
+declare function limitRealtimePoints<TData>(currentData: TData[] | undefined, nextData: TData | TData[], options?: LimitRealtimePointsOptions): TData[];
+declare function replaceRealtimePoints<TData>(nextData?: TData[], options?: Pick<LimitRealtimePointsOptions, "maxPoints">): TData[];
+
+declare const GRAPH_DEFAULT_HEIGHT = 320;
+declare const GRAPH_DEFAULT_MAX_REALTIME_POINTS = 100;
+declare const GRAPH_DEFAULT_POLLING_INTERVAL = 5000;
+declare const GRAPH_DEFAULT_ANIMATION_DURATION = 350;
+declare const GRAPH_DEFAULT_MARGIN: {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+declare const GRAPH_DEFAULT_STROKE_WIDTH = 2;
+declare const GRAPH_DEFAULT_DOT_RADIUS = 3;
+declare const GRAPH_DEFAULT_ACTIVE_DOT_RADIUS = 5;
+declare const GRAPH_DEFAULT_BAR_RADIUS: [number, number, number, number];
+declare const GRAPH_STATUSES: {
+    readonly IDLE: "idle";
+    readonly LOADING: "loading";
+    readonly SUCCESS: "success";
+    readonly ERROR: "error";
+    readonly STREAMING: "streaming";
+};
+declare const GRAPH_DATA_MODES: {
+    readonly STATIC: "static";
+    readonly POLLING: "polling";
+    readonly REALTIME: "realtime";
+};
+declare const GRAPH_VALUE_FORMATS: {
+    readonly RAW: "raw";
+    readonly NUMBER: "number";
+    readonly INTEGER: "integer";
+    readonly COMPACT: "compact";
+    readonly PERCENT: "percent";
+    readonly CURRENCY: "currency";
+    readonly BYTES: "bytes";
+    readonly DURATION: "duration";
+};
+declare const GRAPH_EMPTY_MESSAGE = "No graph data available";
+declare const GRAPH_ERROR_MESSAGE = "Unable to load graph data";
+declare const GRAPH_LOADING_MESSAGE = "Loading graph data...";
+
+declare const GRAPH_COLOR_PALETTE: string[];
+declare const GRAPH_STATUS_COLORS: {
+    primary: string;
+    secondary: string;
+    success: string;
+    warning: string;
+    danger: string;
+    info: string;
+    muted: string;
+};
+declare const GRAPH_DARK_THEME: {
+    panel: {
+        background: string;
+        border: string;
+        radius: string;
+        shadow: string;
+    };
+    text: {
+        title: string;
+        description: string;
+        muted: string;
+    };
+    chart: {
+        grid: string;
+        axis: string;
+        cursor: string;
+    };
+    tooltip: {
+        background: string;
+        border: string;
+        text: string;
+        muted: string;
+    };
+    colors: string[];
+};
+declare const GRAPH_LIGHT_THEME: {
+    panel: {
+        background: string;
+        border: string;
+        radius: string;
+        shadow: string;
+    };
+    text: {
+        title: string;
+        description: string;
+        muted: string;
+    };
+    chart: {
+        grid: string;
+        axis: string;
+        cursor: string;
+    };
+    tooltip: {
+        background: string;
+        border: string;
+        text: string;
+        muted: string;
+    };
+    colors: string[];
+};
+declare const DEFAULT_GRAPH_THEME: {
+    panel: {
+        background: string;
+        border: string;
+        radius: string;
+        shadow: string;
+    };
+    text: {
+        title: string;
+        description: string;
+        muted: string;
+    };
+    chart: {
+        grid: string;
+        axis: string;
+        cursor: string;
+    };
+    tooltip: {
+        background: string;
+        border: string;
+        text: string;
+        muted: string;
+    };
+    colors: string[];
+};
+
+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__default.ReactNode;
+    bulletType?: ListBulletType;
+    renderBullet?: (index?: number) => React__default.ReactNode;
+    TypographyComponent?: React__default.ReactNode;
+    className?: string;
+}
+interface ListProps extends BaseComponentProps {
+    title?: string;
+    items: (string | React__default.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__default.ReactNode;
+    index?: number;
+    TypographyComponent?: React__default.ReactNode;
+    bulletType?: ListBulletType;
+    renderBullet?: (index?: number) => React__default.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,1309 +1110,1309 @@ 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__default.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;
-}
-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;
-};
+interface ImageInputProps {
+    title?: string;
+    uploadDir?: string;
+    onValueChanged?: (imageUrl: string) => void;
+    disableSetValue?: boolean;
+}
+interface ImageInputRef {
+    handleResetClick: () => void;
+}
+declare const ImageInput: React__default.ForwardRefExoticComponent<(Omit<React__default.ClassAttributes<HTMLInputElement> & React__default.InputHTMLAttributes<HTMLInputElement> & formik.FieldConfig<string> & ImageInputProps, "ref"> | Omit<React__default.ClassAttributes<HTMLSelectElement> & React__default.SelectHTMLAttributes<HTMLSelectElement> & formik.FieldConfig<string> & ImageInputProps, "ref"> | Omit<React__default.ClassAttributes<HTMLTextAreaElement> & React__default.TextareaHTMLAttributes<HTMLTextAreaElement> & formik.FieldConfig<string> & ImageInputProps, "ref">) & React__default.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;
-}
+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__default.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__default.Dispatch<React__default.SetStateAction<EUIConfigs>>;
+}
+declare const EUIProvider: ({ config, children, }: {
+    config: EUIConfigs;
+    children: React__default.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__default.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__default.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__default.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__default.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__default.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__default.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__default.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__default.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__default.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__default.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__default.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__default.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__default.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__default.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__default.ReactNode;
+    name: string;
+    badge?: React__default.ReactNode;
+    to?: string;
+    onClick?: () => void;
+}
+interface I_FooterNavGroup {
+    component: any;
+    icon?: React__default.ReactNode;
+    name: string;
+    badge?: React__default.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__default.ReactNode;
+    name: string;
+    description: string;
+    badge?: React__default.ReactNode;
+    to?: string;
+    children: React__default.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__default.ReactNode;
+    name: string;
+    description: string;
+    badge?: React__default.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__default.ReactNode;
+    name: string;
+    description: string;
+    badge?: React__default.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__default.ReactNode;
+    name: string;
+    description: string;
+    badge?: React__default.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__default.ReactNode;
+    name: string;
+    badge?: React__default.ReactNode;
+    to?: string;
+    onClick?: () => void;
+}
+interface I_HeaderNavGroup {
+    component: any;
+    icon?: React__default.ReactNode;
+    name: string;
+    badge?: React__default.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__default.ReactNode;
+    name: string;
+    description: string;
+    badge?: React__default.ReactNode;
+    to?: string;
+    children: React__default.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__default.ReactNode;
+    name: string;
+    description: string;
+    badge?: React__default.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__default.ReactNode;
+    name: string;
+    description: string;
+    badge?: React__default.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__default.ReactNode;
+    name: string;
+    description: string;
+    badge?: React__default.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__default.ReactNode;
+    badge?: React__default.ReactNode;
+    className?: string;
+    component?: React__default.ElementType;
+}
+interface MenuItemNode extends BaseMenuNode {
+    type: "item";
+    to?: string;
+    navigate?: (to: string) => void;
+    onClick?: (e: React__default.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__default.ElementType;
+    group?: React__default.ElementType;
+    title?: React__default.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__default.ReactNode;
+    name: string;
+    badge?: React__default.ReactNode;
+    to?: string;
+    children: React__default.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__default.ReactNode;
+    name: string;
+    badge?: React__default.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__default.ReactNode;
+    name: string;
+    badge?: React__default.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__default.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__default.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__default.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__default.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__default.ComponentType<any>;
+    customOverlay?: React__default.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__default.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__default.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 InfiniteScrollTriggerProps extends BaseComponentProps {
-    children?: ReactNode;
-    hasMore?: boolean;
-    isLoading?: boolean;
-    rootMargin?: string;
-    threshold?: number;
-    onLoadMore?: () => void;
-}
+interface InfiniteScrollTriggerProps extends BaseComponentProps {
+    children?: ReactNode;
+    hasMore?: boolean;
+    isLoading?: boolean;
+    rootMargin?: string;
+    threshold?: number;
+    onLoadMore?: () => void;
+}
 declare function InfiniteScrollTrigger({ children, className, hasMore, isLoading, rootMargin, threshold, onLoadMore, }: InfiniteScrollTriggerProps): react_jsx_runtime.JSX.Element;
 
-interface ShowMoreProps {
-    text: string;
-    limit: number;
-}
+interface ShowMoreProps {
+    text: string;
+    limit: number;
+}
 declare function ShowMore({ text, limit }: ShowMoreProps): react_jsx_runtime.JSX.Element;
 
-interface CommentAuthor {
-    id: string;
-    username: string;
-    avatar?: string;
-    firstName?: string;
-    lastName?: string;
-}
-interface CommentPermissions {
-    canEdit?: boolean;
-    canDelete?: boolean;
-    canReply?: boolean;
-    canReport?: boolean;
-}
-interface CommentEntity {
-    id: string;
-    postId: string;
-    parentCommentId: string | null;
-    content: string;
-    edited: boolean;
-    likes: number;
-    dislikes: number;
-    liked: boolean;
-    disliked: boolean;
-    replyCount: number;
-    createdAt: string;
-    updatedAt: string;
-    author: CommentAuthor | null;
-    permissions?: CommentPermissions;
-}
-
-interface CreateCommentInput {
-    content: string;
-    parentCommentId?: string | null;
-}
-interface UpdateCommentInput {
-    id: string;
-    content: string;
-}
-interface ToggleReactionResult {
-    likes: number;
-    dislikes: number;
-    liked: boolean;
-    disliked: boolean;
-}
-interface CommentQueryOptions {
-    parentCommentId?: string | null;
-    limit?: number;
-    cursor?: string;
-    sort?: "newest" | "oldest" | "top";
-}
-interface CommentPageResult {
-    items: CommentEntity[];
-    nextCursor?: string | null;
-    hasMore: boolean;
-}
-interface CommentDataSource {
-    /**
-     * Load root comments
-     */
-    getComments(options?: CommentQueryOptions): Promise<CommentPageResult>;
-    /**
-     * Load replies for a specific comment
-     */
-    getReplies(commentId: string, options?: Omit<CommentQueryOptions, "parentCommentId">): Promise<CommentPageResult>;
-    /**
-     * Create root comment or reply
-     */
-    createComment(input: CreateCommentInput): Promise<CommentEntity>;
-    /**
-     * Update comment
-     */
-    updateComment(input: UpdateCommentInput): Promise<CommentEntity>;
-    /**
-     * Delete comment
-     */
-    deleteComment(commentId: string): Promise<void>;
-    /**
-     * Toggle like
-     */
-    toggleLike(commentId: string): Promise<ToggleReactionResult>;
-    /**
-     * Toggle dislike
-     */
-    toggleDislike(commentId: string): Promise<ToggleReactionResult>;
-    /**
-     * Report comment
-     */
-    reportComment?(commentId: string, reason: string, description?: string): Promise<void>;
-}
-
-interface CommentHeaderProps {
-    comment: CommentEntity;
-    config: Required<CommentThreadConfig>;
-}
-interface CommentContentProps {
-    comment: CommentEntity;
-}
-interface CommentActionsProps {
-    comment: CommentEntity;
-    onLike?: () => void;
-    onDislike?: () => void;
-    onReply?: () => void;
-}
-interface CommentMenuProps {
-    comment: CommentEntity;
-    open: boolean;
-    setOpen: (open: boolean) => void;
-    canEdit?: boolean;
-    canDelete?: boolean;
-    canReport?: boolean;
-    onEdit?: () => void;
-    onDelete?: () => void;
-    onReport?: () => void;
-}
-interface CommentComposerProps {
-    avatar?: string;
-    placeholder?: string;
-    submitLabel?: string;
-    disabled?: boolean;
-    loading?: boolean;
-    onSubmit: (content: string) => Promise<void> | void;
-}
-interface ReplyComposerProps {
-    avatar?: string;
-    username?: string;
-    placeholder?: string;
-    submitLabel?: string;
-    disabled?: boolean;
-    loading?: boolean;
-    onSubmit: (content: string) => Promise<void> | void;
-}
-interface CommentRepliesToggleProps {
-    collapsed: boolean;
-    repliesCount: number;
-    loading?: boolean;
-    onToggle: () => void;
-}
-interface CommentItemProps {
-    comment: CommentEntity;
-    replies?: CommentEntity[];
-    allReplies?: Record<string, CommentEntity[]>;
-    depth?: number;
-    config: Required<CommentThreadConfig>;
-    components?: CommentComponents;
-    onLike?: (comment: CommentEntity) => void;
-    onDislike?: (comment: CommentEntity) => void;
-    onReply?: (comment: CommentEntity, content: string) => Promise<void> | void;
-    onLoadReplies?: (comment: CommentEntity) => Promise<void> | void;
-    onEdit?: (comment: CommentEntity) => CommentEntity | void | Promise<CommentEntity | void>;
-    onDelete?: (comment: CommentEntity) => void;
-    onReport?: (comment: CommentEntity) => void;
-}
-interface CommentListProps {
-    comments: CommentEntity[];
-    replies?: Record<string, CommentEntity[]>;
-    depth?: number;
-    config: Required<CommentThreadConfig>;
-    components?: CommentComponents;
-    onLike?: (comment: CommentEntity) => void;
-    onDislike?: (comment: CommentEntity) => void;
-    onReply?: (comment: CommentEntity, content: string) => Promise<void> | void;
-    onLoadReplies?: (comment: CommentEntity) => Promise<void> | void;
-    onEdit?: (comment: CommentEntity) => CommentEntity | void | Promise<CommentEntity | void>;
-    onDelete?: (comment: CommentEntity) => void;
-    onReport?: (comment: CommentEntity) => void;
-}
-interface CommentThreadProps {
-    postId: string;
-    currentUser: CommentAuthor;
-    dataSource: CommentDataSource;
-    loading?: boolean;
-    components?: CommentComponents;
-    config?: CommentThreadConfig;
-    updatedComment?: CommentEntity | null;
-    deletedComment?: CommentEntity | null;
-    onEdit?: (comment: CommentEntity) => CommentEntity | void | Promise<CommentEntity | void>;
-    onDelete?: (comment: CommentEntity) => void;
-    onReport?: (comment: CommentEntity) => void;
-}
-interface CommentThreadConfig {
-    maxDepth?: number;
-    indentation?: number;
-    dateFormat?: "relative" | "absolute";
-    commentsPerPage?: number;
-    repliesPerPage?: number;
-}
-interface CommentComponents {
-    /**
-     * Root comment composer
-     */
-    Composer?: ComponentType<CommentComposerProps>;
-    /**
-     * Comment header section
-     */
-    Header?: ComponentType<CommentHeaderProps>;
-    /**
-     * Comment content renderer
-     */
-    Content?: ComponentType<CommentContentProps>;
-    /**
-     * Like / Dislike / Reply actions
-     */
-    Actions?: ComponentType<CommentActionsProps>;
-    /**
-     * Comment menu (Edit/Delete/Report)
-     */
-    Menu?: ComponentType<CommentMenuProps>;
-    /**
-     * Reply composer shown below a comment
-     */
-    ReplyComposer?: ComponentType<ReplyComposerProps>;
-    /**
-     * Replies expand/collapse component
-     */
-    RepliesToggle?: ComponentType<CommentRepliesToggleProps>;
+interface CommentAuthor {
+    id: string;
+    username: string;
+    avatar?: string;
+    firstName?: string;
+    lastName?: string;
+}
+interface CommentPermissions {
+    canEdit?: boolean;
+    canDelete?: boolean;
+    canReply?: boolean;
+    canReport?: boolean;
+}
+interface CommentEntity {
+    id: string;
+    postId: string;
+    parentCommentId: string | null;
+    content: string;
+    edited: boolean;
+    likes: number;
+    dislikes: number;
+    liked: boolean;
+    disliked: boolean;
+    replyCount: number;
+    createdAt: string;
+    updatedAt: string;
+    author: CommentAuthor | null;
+    permissions?: CommentPermissions;
+}
+
+interface CreateCommentInput {
+    content: string;
+    parentCommentId?: string | null;
+}
+interface UpdateCommentInput {
+    id: string;
+    content: string;
+}
+interface ToggleReactionResult {
+    likes: number;
+    dislikes: number;
+    liked: boolean;
+    disliked: boolean;
+}
+interface CommentQueryOptions {
+    parentCommentId?: string | null;
+    limit?: number;
+    cursor?: string;
+    sort?: "newest" | "oldest" | "top";
+}
+interface CommentPageResult {
+    items: CommentEntity[];
+    nextCursor?: string | null;
+    hasMore: boolean;
+}
+interface CommentDataSource {
+    /**
+     * Load root comments
+     */
+    getComments(options?: CommentQueryOptions): Promise<CommentPageResult>;
+    /**
+     * Load replies for a specific comment
+     */
+    getReplies(commentId: string, options?: Omit<CommentQueryOptions, "parentCommentId">): Promise<CommentPageResult>;
+    /**
+     * Create root comment or reply
+     */
+    createComment(input: CreateCommentInput): Promise<CommentEntity>;
+    /**
+     * Update comment
+     */
+    updateComment(input: UpdateCommentInput): Promise<CommentEntity>;
+    /**
+     * Delete comment
+     */
+    deleteComment(commentId: string): Promise<void>;
+    /**
+     * Toggle like
+     */
+    toggleLike(commentId: string): Promise<ToggleReactionResult>;
+    /**
+     * Toggle dislike
+     */
+    toggleDislike(commentId: string): Promise<ToggleReactionResult>;
+    /**
+     * Report comment
+     */
+    reportComment?(commentId: string, reason: string, description?: string): Promise<void>;
+}
+
+interface CommentHeaderProps {
+    comment: CommentEntity;
+    config: Required<CommentThreadConfig>;
+}
+interface CommentContentProps {
+    comment: CommentEntity;
+}
+interface CommentActionsProps {
+    comment: CommentEntity;
+    onLike?: () => void;
+    onDislike?: () => void;
+    onReply?: () => void;
+}
+interface CommentMenuProps {
+    comment: CommentEntity;
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    canEdit?: boolean;
+    canDelete?: boolean;
+    canReport?: boolean;
+    onEdit?: () => void;
+    onDelete?: () => void;
+    onReport?: () => void;
+}
+interface CommentComposerProps {
+    avatar?: string;
+    placeholder?: string;
+    submitLabel?: string;
+    disabled?: boolean;
+    loading?: boolean;
+    onSubmit: (content: string) => Promise<void> | void;
+}
+interface ReplyComposerProps {
+    avatar?: string;
+    username?: string;
+    placeholder?: string;
+    submitLabel?: string;
+    disabled?: boolean;
+    loading?: boolean;
+    onSubmit: (content: string) => Promise<void> | void;
+}
+interface CommentRepliesToggleProps {
+    collapsed: boolean;
+    repliesCount: number;
+    loading?: boolean;
+    onToggle: () => void;
+}
+interface CommentItemProps {
+    comment: CommentEntity;
+    replies?: CommentEntity[];
+    allReplies?: Record<string, CommentEntity[]>;
+    depth?: number;
+    config: Required<CommentThreadConfig>;
+    components?: CommentComponents;
+    onLike?: (comment: CommentEntity) => void;
+    onDislike?: (comment: CommentEntity) => void;
+    onReply?: (comment: CommentEntity, content: string) => Promise<void> | void;
+    onLoadReplies?: (comment: CommentEntity) => Promise<void> | void;
+    onEdit?: (comment: CommentEntity) => CommentEntity | void | Promise<CommentEntity | void>;
+    onDelete?: (comment: CommentEntity) => void;
+    onReport?: (comment: CommentEntity) => void;
+}
+interface CommentListProps {
+    comments: CommentEntity[];
+    replies?: Record<string, CommentEntity[]>;
+    depth?: number;
+    config: Required<CommentThreadConfig>;
+    components?: CommentComponents;
+    onLike?: (comment: CommentEntity) => void;
+    onDislike?: (comment: CommentEntity) => void;
+    onReply?: (comment: CommentEntity, content: string) => Promise<void> | void;
+    onLoadReplies?: (comment: CommentEntity) => Promise<void> | void;
+    onEdit?: (comment: CommentEntity) => CommentEntity | void | Promise<CommentEntity | void>;
+    onDelete?: (comment: CommentEntity) => void;
+    onReport?: (comment: CommentEntity) => void;
+}
+interface CommentThreadProps {
+    postId: string;
+    currentUser: CommentAuthor;
+    dataSource: CommentDataSource;
+    loading?: boolean;
+    components?: CommentComponents;
+    config?: CommentThreadConfig;
+    updatedComment?: CommentEntity | null;
+    deletedComment?: CommentEntity | null;
+    onEdit?: (comment: CommentEntity) => CommentEntity | void | Promise<CommentEntity | void>;
+    onDelete?: (comment: CommentEntity) => void;
+    onReport?: (comment: CommentEntity) => void;
+}
+interface CommentThreadConfig {
+    maxDepth?: number;
+    indentation?: number;
+    dateFormat?: "relative" | "absolute";
+    commentsPerPage?: number;
+    repliesPerPage?: number;
+}
+interface CommentComponents {
+    /**
+     * Root comment composer
+     */
+    Composer?: ComponentType<CommentComposerProps>;
+    /**
+     * Comment header section
+     */
+    Header?: ComponentType<CommentHeaderProps>;
+    /**
+     * Comment content renderer
+     */
+    Content?: ComponentType<CommentContentProps>;
+    /**
+     * Like / Dislike / Reply actions
+     */
+    Actions?: ComponentType<CommentActionsProps>;
+    /**
+     * Comment menu (Edit/Delete/Report)
+     */
+    Menu?: ComponentType<CommentMenuProps>;
+    /**
+     * Reply composer shown below a comment
+     */
+    ReplyComposer?: ComponentType<ReplyComposerProps>;
+    /**
+     * Replies expand/collapse component
+     */
+    RepliesToggle?: ComponentType<CommentRepliesToggleProps>;
 }
 
 declare function CommentThread({ currentUser, dataSource, loading, components, config, updatedComment, deletedComment, onEdit, onDelete, onReport, }: CommentThreadProps): react_jsx_runtime.JSX.Element;
 
-declare function getOptimisticLikeState(comment: CommentEntity): ToggleReactionResult;
-declare function getOptimisticDislikeState(comment: CommentEntity): ToggleReactionResult;
+declare function getOptimisticLikeState(comment: CommentEntity): ToggleReactionResult;
+declare function getOptimisticDislikeState(comment: CommentEntity): ToggleReactionResult;
 declare function applyReactionState(comment: CommentEntity, reaction: ToggleReactionResult): CommentEntity;
 
 declare function formatCommentDate(date: string, format?: "relative" | "absolute"): string;
 
-declare function removeComment(comments: CommentEntity[], commentId: string): CommentEntity[];
-declare function incrementReplyCount(comments: CommentEntity[], commentId: string): CommentEntity[];
+declare function removeComment(comments: CommentEntity[], commentId: string): CommentEntity[];
+declare function incrementReplyCount(comments: CommentEntity[], commentId: string): CommentEntity[];
 declare function decrementReplyCount(comments: CommentEntity[], commentId: string): CommentEntity[];
 
-type CommentReplyCache = Record<string, CommentEntity[]>;
-declare function addReplyToCache(cache: CommentReplyCache, parentCommentId: string, reply: CommentEntity): CommentReplyCache;
-declare function updateReplyCacheComment(cache: CommentReplyCache, commentId: string, updater: (comment: CommentEntity) => CommentEntity): CommentReplyCache;
+type CommentReplyCache = Record<string, CommentEntity[]>;
+declare function addReplyToCache(cache: CommentReplyCache, parentCommentId: string, reply: CommentEntity): CommentReplyCache;
+declare function updateReplyCacheComment(cache: CommentReplyCache, commentId: string, updater: (comment: CommentEntity) => CommentEntity): CommentReplyCache;
 declare function removeCommentTreeFromCache(cache: CommentReplyCache, commentId: string): CommentReplyCache;
 
 declare function updateComment(comments: CommentEntity[], commentId: string, updater: (comment: CommentEntity) => CommentEntity): CommentEntity[];
 
-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;
-}
+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__default.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__default.ReactNode;
+    name: string;
+    to: string;
+    selected?: boolean;
+    onClick?: (event: React__default.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;
@@ -1787,63 +2421,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;
@@ -1854,16 +2488,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, type CommentActionsProps, type CommentAuthor, type CommentComponents, type CommentComposerProps, type CommentContentProps, type CommentDataSource, type CommentEntity, type CommentHeaderProps, type CommentItemProps, type CommentListProps, type CommentMenuProps, type CommentPageResult, type CommentPermissions, type CommentQueryOptions, type CommentRepliesToggleProps, type CommentReplyCache, CommentThread, type CommentThreadConfig, type CommentThreadProps, Content, ContentArea, type CornerPosition, type CreateCommentInput, 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, InfiniteScrollTrigger, 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, type ReplyComposerProps, 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, type ToggleReactionResult, Tooltip, TopNav, type TopNavComponents, type TopNavGroupNode, type TopNavItemNode, type TopNavNode, type TopNavProps, type TopNavTitleNode, Transition, TransitionDropdown, TransitionFadeIn, Typography, UnderConstructionBanner, type UpdateCommentInput, ValueBadge, type Variant$1 as Variant, type VerticalPosition, WorldMap, WorldMapCountryTable, YoutubeVideo as YoutubeVideoPlayer, addReplyToCache, applyReactionState, cn, createForceLayout, createGridLayout, createTreeLayout, decrementReplyCount, enumValues, formatCommentDate, getCurrencySymbol, getLayout, getOptimisticDislikeState, getOptimisticLikeState, incrementReplyCount, isMatch, isRenderFn, normalize, registerLayout, removeComment, removeCommentTreeFromCache, resolveAppearanceStyles, resolveWithGlobal, sendToast, updateComment, updateReplyCacheComment, useClickOutside, useCloudinaryConfig, useCurrentTheme, useDrawer, useEUIConfig, useIsMobile, useModal, useTheme };
+export { Accordion, type AnimationComponentProps, type AnimationVariant, type Appearance, AreaGraph, AsyncComponentWrapper, Avatar, Backdrop, Badge, BarChart, BarGraph, type BarGraphProps, type BaseAnimationConfig, type BaseComponentProps, BaseGraphDataSource, type BaseGraphProps, 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, type CommentActionsProps, type CommentAuthor, type CommentComponents, type CommentComposerProps, type CommentContentProps, type CommentDataSource, type CommentEntity, type CommentHeaderProps, type CommentItemProps, type CommentListProps, type CommentMenuProps, type CommentPageResult, type CommentPermissions, type CommentQueryOptions, type CommentRepliesToggleProps, type CommentReplyCache, CommentThread, type CommentThreadConfig, type CommentThreadProps, Content, ContentArea, type CornerPosition, type CreateCommentInput, type CurrencyCode, DEFAULT_GRAPH_THEME, 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, type FormatGraphValueOptions, GRAPH_COLOR_PALETTE, GRAPH_DARK_THEME, GRAPH_DATA_MODES, GRAPH_DEFAULT_ACTIVE_DOT_RADIUS, GRAPH_DEFAULT_ANIMATION_DURATION, GRAPH_DEFAULT_BAR_RADIUS, GRAPH_DEFAULT_DOT_RADIUS, GRAPH_DEFAULT_HEIGHT, GRAPH_DEFAULT_MARGIN, GRAPH_DEFAULT_MAX_REALTIME_POINTS, GRAPH_DEFAULT_POLLING_INTERVAL, GRAPH_DEFAULT_STROKE_WIDTH, GRAPH_EMPTY_MESSAGE, GRAPH_ERROR_MESSAGE, GRAPH_LIGHT_THEME, GRAPH_LOADING_MESSAGE, GRAPH_STATUSES, GRAPH_STATUS_COLORS, GRAPH_VALUE_FORMATS, GaugeGraph, type GaugeGraphProps, GenericLayout, GlowWrapper, type GradientAnimationConfig, Graph, type GraphAction, type GraphBarConfig, type GraphChartType, type GraphColorName, GraphContainer, type GraphContainerProps, GraphContext, type GraphContextValue, type GraphDataHandler, type GraphDataMode, type GraphDataPoint, type GraphDataSource, GraphEmptyState, type GraphEmptyStateProps, type GraphErrorHandler, GraphErrorState, type GraphErrorStateProps, type GraphGaugeConfig, GraphHeader, type GraphHeaderProps, GraphLegend, type GraphLegendItem, type GraphLegendProps, GraphLoadingState, type GraphLoadingStateProps, GraphPanel, type GraphPanelConfig, type GraphPanelProps, type GraphPieConfig, type GraphPrimitive, type GraphProps, GraphProvider, type GraphProviderProps, type GraphRenderChartProps, type GraphSeries, type GraphSeriesColor, type GraphSeriesType, type GraphStatConfig, type GraphState, type GraphStatus, type GraphTheme, type GraphThemeChart, type GraphThemeMode, type GraphThemePanel, type GraphThemeText, type GraphThemeTooltip, GraphToolbar, type GraphToolbarProps, GraphTooltip, type GraphTooltipFormatterOptions, type GraphTooltipPayload, type GraphTooltipProps, type GraphUnsubscribe, type GraphValueFormat, Grid, Header, HeaderNav, HeaderNavGroup, HeaderNavItem, HeaderNavItemContext, HeaderNavItemTitle, HomeLayout, type HorizontalPosition, type HyperRefTarget, Image, ImageInput, InfiniteScrollTrigger, Info, Input, InputFile, InputLabel, InputList, InputListGroup, InputResponse, Label, Layout, Lead, type LimitRealtimePointsOptions, LineChart, LineGraph, 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 NormalizeGraphDataOptions, type NormalizedGraphDataPoint, NumericRating, type OctilePosition, type OverlayVariant, Overline, Paragraph, PieChart, PieGraph, type PieGraphProps, PollingGraphDataSource, type PollingGraphDataSourceConfig, type PollingGraphDataSourceOptions, PriceTag, ProgressBar, type ProgressBarProps, ProgressBarRating, Quote, Radio, type RawGraphDataPoint, RealtimeGraphDataSource, type RealtimeGraphDataSourceConfig, type RealtimeGraphDataSourceOptions, type ReplyComposerProps, type ResolveGraphColorOptions, type ResolvedGraphSeries, RouteTab, type RouteTabMode, RouteTabs, ScatterGraph, ScrollToTop, Section, Select, type Shape$1 as Shape, ShapeSwitch, ShowMore, Sidebar, SidebarLayout, SidemenuLayout, type Size$1 as Size, Skeleton, Slider, StarRating, StarRatingDistribution, StarRatingInput, StatGraph, type StatGraphProps, StaticGraphDataSource, type StaticGraphDataSourceConfig, type StaticGraphDataSourceOptions, Switch, TNDropdown, TNDropdownItem, TNDropdownTitle, TNGroup, Table, Tag, Tags, TextArea, type TextDecoration, ThemeContext, ThemeProvider, ThemeSwitch, TitleBanner, type TitleBannerLevel, Toast, type ToggleReactionResult, Tooltip, TopNav, type TopNavComponents, type TopNavGroupNode, type TopNavItemNode, type TopNavNode, type TopNavProps, type TopNavTitleNode, Transition, TransitionDropdown, TransitionFadeIn, Typography, UnderConstructionBanner, type UpdateCommentInput, type UseGraphDataOptions, type UseGraphDataReturn, type UseGraphPollingOptions, type UseGraphRealtimeOptions, type UseGraphSeriesOptions, type UseGraphThemeOptions, ValueBadge, type Variant$1 as Variant, type VerticalPosition, WorldMap, WorldMapCountryTable, YoutubeVideo as YoutubeVideoPlayer, addReplyToCache, applyReactionState, cn, createInitialGraphState, decrementReplyCount, enumValues, formatCommentDate, formatGraphValue, getCurrencySymbol, getOptimisticDislikeState, getOptimisticLikeState, graphReducer, incrementReplyCount, isMatch, isRenderFn, limitRealtimePoints, normalize, normalizeGraphData, normalizeGraphDataPoint, removeComment, removeCommentTreeFromCache, replaceRealtimePoints, resolveAppearanceStyles, resolveGraphColor, resolveGraphColors, resolveWithGlobal, sendToast, updateComment, updateReplyCacheComment, useClickOutside, useCloudinaryConfig, useCurrentTheme, useDrawer, useEUIConfig, useGraphContext, useGraphData, useGraphPolling, useGraphRealtime, useGraphSeries, useGraphTheme, useIsMobile, useModal, useTheme };