elseware-ui 2.32.0 → 2.34.0

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 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';
@@ -87,19 +87,19 @@ interface BarChartProps extends BaseComponentProps {
     data: ChartData<"bar">;
     options: ChartOptions<"bar">;
 }
-declare const BarChart: React$1.FC<BarChartProps>;
+declare const BarChart: React__default.FC<BarChartProps>;
 
 interface LineChartProps extends BaseComponentProps {
     data: ChartData<"line">;
     options?: ChartOptions<"line">;
 }
-declare const LineChart: React$1.FC<LineChartProps>;
+declare const LineChart: React__default.FC<LineChartProps>;
 
 interface PieChartProps extends BaseComponentProps {
     data: ChartData<"pie">;
     options: ChartOptions<"pie">;
 }
-declare const PieChart: React$1.FC<PieChartProps>;
+declare const PieChart: React__default.FC<PieChartProps>;
 
 interface ChipProps extends BaseComponentProps {
     label?: string;
@@ -116,13 +116,13 @@ type SortConfig<T, K extends keyof T = keyof T> = {
     transform?: (value: T[K]) => number | string;
 };
 
-interface Props$5<T> {
+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$5<T>): react_jsx_runtime.JSX.Element;
+declare function DataViewProvider<T extends Record<string, any>>({ data, children, defaultPageSize, sortConfig, }: Props$2<T>): react_jsx_runtime.JSX.Element;
 
 type DataViewHeaderProps = {
     children: ReactNode;
@@ -172,16 +172,16 @@ type DataViewFilterGroupProps<T = any> = {
 };
 declare function DataViewFilterGroup<T extends Record<string, any>>({ filterKey, options, title, }: DataViewFilterGroupProps<T>): react_jsx_runtime.JSX.Element;
 
-type Props$4 = {
+type Props$1 = {
     pageSizeOptions?: (number | "All")[];
     shape?: Shape$1;
 };
-declare function DataViewPageSize({ pageSizeOptions, shape, }: Props$4): react_jsx_runtime.JSX.Element;
+declare function DataViewPageSize({ pageSizeOptions, shape, }: Props$1): react_jsx_runtime.JSX.Element;
 
-type Props$3 = {
+type Props = {
     shape?: Shape$1;
 };
-declare function DataViewPagination({ shape }: Props$3): react_jsx_runtime.JSX.Element | null;
+declare function DataViewPagination({ shape }: Props): react_jsx_runtime.JSX.Element | null;
 
 declare const DataView: typeof DataViewProvider & {
     Header: typeof DataViewHeader;
@@ -202,96 +202,730 @@ interface FlagProps extends BaseComponentProps {
 }
 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[];
+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 GraphNodeType {
-    id: 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;
-    type?: "default" | "avatar" | "custom";
-    data?: any;
-    x?: number;
-    y?: number;
-    vx?: number;
-    vy?: number;
-    fx?: number | null;
-    fy?: number | null;
-    size?: number;
+    min?: number;
+    max?: number;
     color?: string;
+    unit?: string;
+    format?: GraphValueFormat;
 }
-interface GraphEdgeType {
-    id?: string;
-    from: string | GraphNodeType;
-    to: string | GraphNodeType;
-    weight?: string;
-    color?: string;
-    width?: number;
+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[];
 }
 
-interface GraphProps extends BaseComponentProps {
-    data: GraphData;
-    layout?: string;
-    nodeRenderer?: (node: any) => React$1.ReactNode;
-    width?: number;
+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 const Graph: ({ data, layout, nodeRenderer, width, height, className, ...rest }: GraphProps) => react_jsx_runtime.JSX.Element;
+declare function GraphEmptyState({ height, message, description, className, }: GraphEmptyStateProps): react_jsx_runtime.JSX.Element;
 
-interface Props$2 {
-    edge: GraphEdgeType;
-    nodeMap: Map<string, GraphNodeType>;
+interface GraphErrorStateProps {
+    error?: Error | null;
+    height?: number;
+    title?: ReactNode;
+    message?: ReactNode;
+    className?: string;
+    onRetry?: () => void | Promise<void>;
+    retryLabel?: ReactNode;
 }
-declare const GraphEdge: React$1.FC<Props$2>;
+declare function GraphErrorState({ error, height, title, message, className, onRetry, retryLabel, }: GraphErrorStateProps): react_jsx_runtime.JSX.Element;
 
-interface Props$1 {
-    node: GraphNodeType;
-    renderCustom?: (node: GraphNodeType) => React$1.ReactNode;
+interface GraphLoadingStateProps {
+    height?: number;
+    message?: ReactNode;
+    className?: string;
+    showMessage?: boolean;
 }
-declare const GraphNode: React$1.FC<Props$1>;
+declare function GraphLoadingState({ height, message, className, showMessage, }: GraphLoadingStateProps): react_jsx_runtime.JSX.Element;
 
-interface Props {
-    data: GraphData;
-    layout?: string;
-    nodeRenderer?: (node: GraphNodeType) => React$1.ReactNode;
-    width?: number;
+interface GraphContainerProps {
+    children: ReactNode;
     height?: number;
+    className?: string;
+    contentClassName?: string;
 }
-declare const GraphRenderer: React$1.FC<Props>;
+declare function GraphContainer({ children, height, className, contentClassName, }: GraphContainerProps): react_jsx_runtime.JSX.Element;
 
-declare const createForceLayout: (nodes: GraphNodeType[], edges: GraphEdgeType[], width: number, height: number) => d3.Simulation<GraphNodeType, undefined>;
+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 createGridLayout(nodes: GraphNodeType[], width: number, height: number): {
-    x: number;
-    y: number;
-    id: string;
-    label?: string | undefined;
-    type?: "default" | "custom" | "avatar" | undefined;
-    data?: any;
-    vx?: number | undefined;
-    vy?: number | undefined;
-    fx?: number | null | undefined;
-    fy?: number | null | undefined;
-    size?: number | undefined;
-    color?: string | undefined;
-}[];
+declare function 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>;
+}
 
-declare function createTreeLayout(nodes: GraphNodeType[], edges: GraphEdgeType[], width: number, height: number): GraphNodeType[];
+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 LayoutContext {
-    nodes: GraphNodeType[];
-    edges: GraphEdgeType[];
-    width: number;
-    height: number;
-    onTick?: (nodes: GraphNodeType[]) => 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[];
 }
-type LayoutExecutor = (ctx: LayoutContext) => {
-    type: "static" | "simulation";
-    stop?: () => void;
+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 registerLayout: (type: GraphLayoutType, executor: LayoutExecutor) => void;
-declare const getLayout: (type: GraphLayoutType) => LayoutExecutor;
+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;
@@ -320,15 +954,15 @@ interface InfoProps extends BaseComponentProps {
 declare function Info({ children, variant, appearance, shape, className, ...rest }: InfoProps): react_jsx_runtime.JSX.Element;
 
 interface ListItemData {
-    content: React$1.ReactNode;
+    content: React__default.ReactNode;
     bulletType?: ListBulletType;
-    renderBullet?: (index?: number) => React$1.ReactNode;
-    TypographyComponent?: React$1.ReactNode;
+    renderBullet?: (index?: number) => React__default.ReactNode;
+    TypographyComponent?: React__default.ReactNode;
     className?: string;
 }
 interface ListProps extends BaseComponentProps {
     title?: string;
-    items: (string | React$1.ReactNode | ListItemData)[];
+    items: (string | React__default.ReactNode | ListItemData)[];
     direction?: ListDirection;
     gap?: 1 | 2 | 3 | 4;
     columns?: 1 | 2 | 3 | 4;
@@ -339,11 +973,11 @@ interface ListProps extends BaseComponentProps {
 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;
+    content: React__default.ReactNode;
     index?: number;
-    TypographyComponent?: React$1.ReactNode;
+    TypographyComponent?: React__default.ReactNode;
     bulletType?: ListBulletType;
-    renderBullet?: (index?: number) => React$1.ReactNode;
+    renderBullet?: (index?: number) => React__default.ReactNode;
     align?: ListAlign;
     className?: string;
 }
@@ -642,7 +1276,7 @@ interface FormProps {
     initialValues?: Record<string, any>;
     validationSchema?: object;
     enableReinitialize?: boolean;
-    children?: React$1.ReactNode;
+    children?: React__default.ReactNode;
     styles?: string;
     onSubmit: (values: any, helpers?: any) => void;
     onChange?: (values: Record<string, any>, meta?: {
@@ -671,7 +1305,7 @@ interface ImageInputProps {
 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>>;
+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";
@@ -692,7 +1326,7 @@ declare const InputFile: ({ placeholder, accept, styles, ...props }: FieldHookCo
 
 interface FormDataEntryLabelProps {
     text?: string;
-    children?: React$1.ReactNode;
+    children?: React__default.ReactNode;
     styles?: string;
 }
 declare function InputLabel({ text, children, styles }: FormDataEntryLabelProps): react_jsx_runtime.JSX.Element;
@@ -788,24 +1422,24 @@ interface EUIConfigs {
 
 interface EUIContextValue {
     config: EUIConfigs;
-    setConfig: React$1.Dispatch<React$1.SetStateAction<EUIConfigs>>;
+    setConfig: React__default.Dispatch<React__default.SetStateAction<EUIConfigs>>;
 }
 declare const EUIProvider: ({ config, children, }: {
     config: EUIConfigs;
-    children: React$1.ReactNode;
+    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;
+    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;
+    children?: React__default.ReactNode;
 }
 declare const Skeleton: ({ children, className, ...rest }: SkeletonProps) => react_jsx_runtime.JSX.Element;
 
@@ -840,14 +1474,14 @@ interface ContentAreaProps {
 declare function ContentArea({ children, styles, enablePadding, }: ContentAreaProps): react_jsx_runtime.JSX.Element;
 
 interface FlexColProps$1 {
-    children?: React$1.ReactNode;
+    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;
+    children?: React__default.ReactNode;
     gap?: number;
     styles?: string;
 }
@@ -859,27 +1493,27 @@ declare const Flex: {
 };
 
 interface GridProps {
-    children?: React$1.ReactNode;
+    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;
+    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;
+    children?: React__default.ReactNode;
     styles?: string;
 }
 declare const Header: ({ position, children, styles, }: HeaderProps) => react_jsx_runtime.JSX.Element;
 
 interface ContentProps {
-    children?: React$1.ReactNode;
+    children?: React__default.ReactNode;
     overlayedSidebar?: boolean;
     sidebarVisible?: boolean;
     styles?: string;
@@ -887,7 +1521,7 @@ interface ContentProps {
 declare const Content: ({ sidebarVisible, overlayedSidebar, children, styles, }: ContentProps) => react_jsx_runtime.JSX.Element;
 
 interface FooterProps {
-    children?: React$1.ReactNode;
+    children?: React__default.ReactNode;
     styles?: string;
 }
 declare const Footer: ({ children, styles }: FooterProps) => react_jsx_runtime.JSX.Element;
@@ -898,14 +1532,14 @@ interface BlockProps extends BaseComponentProps {
     required?: boolean;
     layout?: ListDirection;
     labelWidth?: string;
-    children: React$1.ReactNode;
+    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;
+    children: React__default.ReactNode;
     noDivider?: boolean;
 }
 declare function BlockGroup({ title, description, children, noDivider, className, ...rest }: BlockGroupProps): react_jsx_runtime.JSX.Element;
@@ -928,7 +1562,7 @@ declare function MarkdownViewer({ value }: MarkdownViewerProps): react_jsx_runti
 
 interface MarkdownProviderProps {
     markdown: string;
-    children: React$1.ReactNode;
+    children: React__default.ReactNode;
 }
 declare function MarkdownProvider({ markdown, children }: MarkdownProviderProps): react_jsx_runtime.JSX.Element;
 
@@ -955,12 +1589,12 @@ interface BreadcrumbItemProps {
     title: string;
     href: string;
     active: boolean;
-    onClick?: (e: React$1.MouseEvent<HTMLAnchorElement>) => void;
+    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;
+    children?: React__default.ReactNode;
     visibility: boolean;
     side?: "left" | "right" | "top" | "bottom";
     handleClose: () => void;
@@ -977,17 +1611,17 @@ declare function DrawerToggler({ icon, toggleDrawer, styles, }: DrawerTogglerPro
 
 interface I_FooterNavItem {
     component: any;
-    icon?: React$1.ReactNode;
+    icon?: React__default.ReactNode;
     name: string;
-    badge?: React$1.ReactNode;
+    badge?: React__default.ReactNode;
     to?: string;
     onClick?: () => void;
 }
 interface I_FooterNavGroup {
     component: any;
-    icon?: React$1.ReactNode;
+    icon?: React__default.ReactNode;
     name: string;
-    badge?: React$1.ReactNode;
+    badge?: React__default.ReactNode;
     to?: string;
     items: I_FooterNavItem[];
 }
@@ -999,21 +1633,21 @@ interface FooterNavProps {
 declare function FooterNav({ data, styles }: FooterNavProps): react_jsx_runtime.JSX.Element;
 
 interface FooterNavGroupProps {
-    icon?: React$1.ReactNode;
+    icon?: React__default.ReactNode;
     name: string;
     description: string;
-    badge?: React$1.ReactNode;
+    badge?: React__default.ReactNode;
     to?: string;
-    children: React$1.ReactNode;
+    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;
+    icon?: React__default.ReactNode;
     name: string;
     description: string;
-    badge?: React$1.ReactNode;
+    badge?: React__default.ReactNode;
     to?: string;
     onClick?: () => void;
     styles?: string;
@@ -1021,35 +1655,35 @@ interface FooterNavItemProps {
 declare const FooterNavItem: ({ icon, name, description, badge, to, onClick, styles, }: FooterNavItemProps) => react_jsx_runtime.JSX.Element;
 
 interface FooterNavItemTitleProps {
-    icon?: React$1.ReactNode;
+    icon?: React__default.ReactNode;
     name: string;
     description: string;
-    badge?: React$1.ReactNode;
+    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;
+    icon?: React__default.ReactNode;
     name: string;
     description: string;
-    badge?: React$1.ReactNode;
+    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;
+    icon?: React__default.ReactNode;
     name: string;
-    badge?: React$1.ReactNode;
+    badge?: React__default.ReactNode;
     to?: string;
     onClick?: () => void;
 }
 interface I_HeaderNavGroup {
     component: any;
-    icon?: React$1.ReactNode;
+    icon?: React__default.ReactNode;
     name: string;
-    badge?: React$1.ReactNode;
+    badge?: React__default.ReactNode;
     to?: string;
     items: I_HeaderNavItem[];
 }
@@ -1061,21 +1695,21 @@ interface HeaderNavProps {
 declare function HeaderNav({ data, styles }: HeaderNavProps): react_jsx_runtime.JSX.Element;
 
 interface HeaderNavGroupProps {
-    icon?: React$1.ReactNode;
+    icon?: React__default.ReactNode;
     name: string;
     description: string;
-    badge?: React$1.ReactNode;
+    badge?: React__default.ReactNode;
     to?: string;
-    children: React$1.ReactNode;
+    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;
+    icon?: React__default.ReactNode;
     name: string;
     description: string;
-    badge?: React$1.ReactNode;
+    badge?: React__default.ReactNode;
     to?: string;
     onClick?: () => void;
     styles?: string;
@@ -1083,19 +1717,19 @@ interface HeaderNavItemProps {
 declare const HeaderNavItem: ({ icon, name, description, badge, to, onClick, styles, }: HeaderNavItemProps) => react_jsx_runtime.JSX.Element;
 
 interface HeaderNavItemTitleProps {
-    icon?: React$1.ReactNode;
+    icon?: React__default.ReactNode;
     name: string;
     description: string;
-    badge?: React$1.ReactNode;
+    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;
+    icon?: React__default.ReactNode;
     name: string;
     description: string;
-    badge?: React$1.ReactNode;
+    badge?: React__default.ReactNode;
 }
 declare const HeaderNavItemContext: ({ icon, name, description, badge, }: HeaderNavItemContextProps) => react_jsx_runtime.JSX.Element;
 
@@ -1116,16 +1750,16 @@ type MenuElementType = "item" | "group" | "title";
 interface BaseMenuNode {
     key?: string;
     name: string;
-    icon?: React$1.ReactNode;
-    badge?: React$1.ReactNode;
+    icon?: React__default.ReactNode;
+    badge?: React__default.ReactNode;
     className?: string;
-    component?: React$1.ElementType;
+    component?: React__default.ElementType;
 }
 interface MenuItemNode extends BaseMenuNode {
     type: "item";
     to?: string;
     navigate?: (to: string) => void;
-    onClick?: (e: React$1.MouseEvent<HTMLDivElement>) => void;
+    onClick?: (e: React__default.MouseEvent<HTMLDivElement>) => void;
 }
 interface MenuGroupNode extends BaseMenuNode {
     type: "group";
@@ -1136,9 +1770,9 @@ interface MenuTitleNode extends BaseMenuNode {
 }
 type MenuNode = MenuItemNode | MenuGroupNode | MenuTitleNode;
 interface DefaultMenuElements {
-    item?: React$1.ElementType;
-    group?: React$1.ElementType;
-    title?: React$1.ElementType;
+    item?: React__default.ElementType;
+    group?: React__default.ElementType;
+    title?: React__default.ElementType;
 }
 interface MenuProps {
     items: MenuNode[];
@@ -1151,28 +1785,28 @@ interface MenuProps {
 declare const Menu: ({ items, className, navigate, defaultMenuElements, currentPath, }: MenuProps) => react_jsx_runtime.JSX.Element;
 
 interface MenuGroupProps extends BaseComponentProps {
-    icon?: React$1.ReactNode;
+    icon?: React__default.ReactNode;
     name: string;
-    badge?: React$1.ReactNode;
+    badge?: React__default.ReactNode;
     to?: string;
-    children: React$1.ReactNode;
+    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;
+    icon?: React__default.ReactNode;
     name: string;
-    badge?: React$1.ReactNode;
+    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;
+    icon?: React__default.ReactNode;
     name: string;
-    badge?: React$1.ReactNode;
+    badge?: React__default.ReactNode;
 }
 declare const MenuItemTitle: ({ icon, name, badge, className, style, ...rest }: MenuItemTitleProps) => react_jsx_runtime.JSX.Element;
 
@@ -1202,7 +1836,7 @@ interface ModalProps {
     title: string;
     show: boolean;
     handleOnClose?: () => void;
-    children?: React$1.ReactNode;
+    children?: React__default.ReactNode;
     enableCloseOnClickOutside?: boolean;
     isLoading?: boolean;
     isSuccess?: boolean;
@@ -1251,7 +1885,7 @@ interface CardProps {
 declare function Card({ children, styles, bgVariant, borderVariant, interactive, ghost, shape, hoverAnimation, }: CardProps): react_jsx_runtime.JSX.Element;
 
 interface CardHeaderProps {
-    icon?: React$1.ReactNode;
+    icon?: React__default.ReactNode;
     title?: string;
     description?: string;
     className?: string;
@@ -1259,13 +1893,13 @@ interface CardHeaderProps {
 declare function CardHeader({ icon, title, description, className }: CardHeaderProps): react_jsx_runtime.JSX.Element;
 
 interface CardContentProps {
-    children?: React$1.ReactNode;
+    children?: React__default.ReactNode;
     className?: string;
 }
 declare function CardContent({ children, className }: CardContentProps): react_jsx_runtime.JSX.Element;
 
 interface CardFooterProps {
-    children?: React$1.ReactNode;
+    children?: React__default.ReactNode;
     className?: string;
 }
 declare function CardFooter({ children, className }: CardFooterProps): react_jsx_runtime.JSX.Element;
@@ -1310,8 +1944,8 @@ interface MotionSurfaceProps {
     overlay?: OverlayVariant;
     overlayConfig?: BaseOverlayConfig;
     className?: string;
-    customAnimation?: React$1.ComponentType<any>;
-    customOverlay?: React$1.ComponentType<any>;
+    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;
 
@@ -1320,7 +1954,7 @@ interface ThemeContextProps {
     setTheme: (theme: "light" | "dark") => void;
     toggleTheme: () => void;
 }
-declare const ThemeContext: React$1.Context<ThemeContextProps | undefined>;
+declare const ThemeContext: React__default.Context<ThemeContextProps | undefined>;
 interface ThemeProviderProps {
     defaultTheme?: "light" | "dark";
     children: ReactNode;
@@ -1332,7 +1966,7 @@ declare const ThemeSwitch: () => react_jsx_runtime.JSX.Element | null;
 declare const ShapeSwitch: () => react_jsx_runtime.JSX.Element;
 
 interface AsyncComponentWrapperProps {
-    children: React$1.ReactNode;
+    children: React__default.ReactNode;
     isLoading?: boolean;
     isSuccess?: boolean;
     isError?: boolean;
@@ -1664,7 +2298,7 @@ interface WorldMapCountryTableProps {
 declare function WorldMapCountryTable({ title, data, }: WorldMapCountryTableProps): react_jsx_runtime.JSX.Element;
 
 interface NavItem {
-    icon: React$1.ReactNode;
+    icon: React__default.ReactNode;
     name: string;
     to: string;
     selected?: boolean;
@@ -1679,11 +2313,11 @@ interface BoxNavProps {
 declare function BoxNav({ data, currentPath, onNavigate, navigate }: BoxNavProps): react_jsx_runtime.JSX.Element;
 
 interface BoxNavItemProps {
-    icon: React$1.ReactNode;
+    icon: React__default.ReactNode;
     name: string;
     to: string;
     selected?: boolean;
-    onClick?: (event: React$1.MouseEvent<HTMLButtonElement>, to: string) => void;
+    onClick?: (event: React__default.MouseEvent<HTMLButtonElement>, to: string) => void;
 }
 declare function BoxNavItem({ icon, name, to, selected, onClick }: BoxNavItemProps): react_jsx_runtime.JSX.Element;
 
@@ -1866,4 +2500,125 @@ interface ResolveAppearanceStylesProps {
 }
 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 };
+type ConfigSchemaSuccess<TData> = {
+    success: true;
+    data: TData;
+};
+type ConfigSchemaFailure = {
+    success: false;
+    error: unknown;
+};
+type ConfigSchemaResult<TData> = ConfigSchemaSuccess<TData> | ConfigSchemaFailure;
+/**
+ * Compatible with Zod's safeParse API.
+ *
+ * This avoids hard-coding zod as a direct dependency of the configurator core.
+ */
+type ConfigSchema<TData> = {
+    safeParse: (value: unknown) => ConfigSchemaResult<TData>;
+};
+type ConfigTransformContext = {
+    name: string;
+};
+type ConfigTransform<TParsed, TConfig> = (parsed: TParsed, context: ConfigTransformContext) => TConfig;
+type ConfiguratorOptions<TParsed, TConfig = TParsed> = {
+    name?: string;
+    env: Record<string, unknown>;
+    schema: ConfigSchema<TParsed>;
+    transform?: ConfigTransform<TParsed, TConfig>;
+    /**
+     * Default: true
+     *
+     * If true, config validation runs immediately.
+     */
+    validateOnCreate?: boolean;
+};
+type ConfiguratorSuccess<TConfig> = {
+    success: true;
+    config: TConfig;
+    error: null;
+};
+type ConfiguratorFailure = {
+    success: false;
+    config: null;
+    error: Error;
+};
+type ConfiguratorState<TConfig> = ConfiguratorSuccess<TConfig> | ConfiguratorFailure;
+
+declare class Configurator<TParsed, TConfig = TParsed> {
+    private readonly name;
+    private readonly schema;
+    private readonly transform?;
+    private source;
+    private initialized;
+    private config;
+    private configError;
+    constructor(options: ConfiguratorOptions<TParsed, TConfig>);
+    get isValid(): boolean;
+    get error(): Error | null;
+    get value(): TConfig;
+    get optionalValue(): TConfig | null;
+    reload(env?: Record<string, unknown>): ConfiguratorState<TConfig>;
+    get<TKey extends keyof TConfig>(key: TKey): TConfig[TKey] | undefined;
+    getRequired<TKey extends keyof TConfig>(key: TKey): TConfig[TKey];
+    getPath<TValue = unknown>(path: string, fallback?: TValue): TValue | undefined;
+    getPathRequired<TValue = unknown>(path: string): TValue;
+    private ensureInitialized;
+}
+
+declare function createConfigurator<TParsed, TConfig = TParsed>(options: ConfiguratorOptions<TParsed, TConfig>): Configurator<TParsed, TConfig>;
+
+declare class ConfiguratorError extends Error {
+    readonly cause?: unknown;
+    constructor(message: string, cause?: unknown);
+}
+declare function formatConfigError(error: unknown): string;
+declare function toConfiguratorError(error: unknown, fallbackMessage: string): ConfiguratorError;
+
+declare function getBrowserOrigin(): string;
+declare function getBrowserHref(): string;
+type BrowserRedirectURLOptions = {
+    queryParam?: string;
+    fallbackPath?: string;
+    currentHref?: string;
+    /**
+     * Default: "path"
+     *
+     * "path" returns only pathname/search/hash from document.referrer.
+     * "full" returns full referrer URL.
+     */
+    referrerMode?: "path" | "full";
+};
+declare function getBrowserRedirectURL(options?: BrowserRedirectURLOptions): string;
+
+declare function parseJson<TValue = unknown>(value: unknown, key?: string): TValue;
+declare function parseJsonRecord<TValue = unknown>(value: unknown, key?: string, validateValue?: (name: string, value: unknown) => TValue): Record<string, TValue>;
+
+type URLMap = Record<string, string>;
+type URLQueryValue = string | number | boolean | null | undefined;
+type URLQueryParams = Record<string, URLQueryValue>;
+declare function assertAbsoluteURL(value: unknown, key?: string): string;
+declare function parseUrlMap(value: unknown, key?: string): URLMap;
+declare function buildURL(base: string, path?: string, params?: URLQueryParams): string;
+type URLMapSource = URLMap | (() => URLMap | null | undefined);
+type CreateURLResolverOptions = {
+    label?: string;
+};
+declare function createURLResolver(source: URLMapSource, options?: CreateURLResolverOptions): (tag: string, path?: string, params?: URLQueryParams) => string;
+type GetAllowedOriginsOptions = {
+    urls?: string[];
+    maps?: Array<URLMap | null | undefined>;
+    includeCurrentOrigin?: boolean;
+    currentOrigin?: string;
+};
+declare function getAllowedOrigins(options?: GetAllowedOriginsOptions): string[];
+type SafeRedirectOptions = {
+    redirectUri?: string | null;
+    fallback?: string;
+    allowedOrigins?: string[];
+    currentOrigin?: string;
+    allowedProtocols?: string[];
+};
+declare function getSafeRedirect(options?: SafeRedirectOptions): string;
+
+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, type BrowserRedirectURLOptions, 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, type ConfigSchema, type ConfigSchemaFailure, type ConfigSchemaResult, type ConfigSchemaSuccess, type ConfigTransform, type ConfigTransformContext, Configurator, ConfiguratorError, type ConfiguratorFailure, type ConfiguratorOptions, type ConfiguratorState, type ConfiguratorSuccess, Content, ContentArea, type CornerPosition, type CreateCommentInput, type CreateURLResolverOptions, 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, type GetAllowedOriginsOptions, 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, type SafeRedirectOptions, 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, type URLMap, type URLMapSource, type URLQueryParams, type URLQueryValue, 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, assertAbsoluteURL, buildURL, cn, createConfigurator, createInitialGraphState, createURLResolver, decrementReplyCount, enumValues, formatCommentDate, formatConfigError, formatGraphValue, getAllowedOrigins, getBrowserHref, getBrowserOrigin, getBrowserRedirectURL, getCurrencySymbol, getOptimisticDislikeState, getOptimisticLikeState, getSafeRedirect, graphReducer, incrementReplyCount, isMatch, isRenderFn, limitRealtimePoints, normalize, normalizeGraphData, normalizeGraphDataPoint, parseJson, parseJsonRecord, parseUrlMap, removeComment, removeCommentTreeFromCache, replaceRealtimePoints, resolveAppearanceStyles, resolveGraphColor, resolveGraphColors, resolveWithGlobal, sendToast, toConfiguratorError, updateComment, updateReplyCacheComment, useClickOutside, useCloudinaryConfig, useCurrentTheme, useDrawer, useEUIConfig, useGraphContext, useGraphData, useGraphPolling, useGraphRealtime, useGraphSeries, useGraphTheme, useIsMobile, useModal, useTheme };