@gearbox-protocol/ui-kit 2.1.0-next.1

package/dist/types/components/filter/index.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Filter Components
+ *
+ * A comprehensive set of filter components for building complex filter interfaces.
+ * These components work together with DropdownMenu components from dropdown-menu
+ * to create filter dropdowns similar to CreditSessionsListFilter.
+ *
+ * @example Building a complex filter dropdown:
+ * ```tsx
+ * import {
+ *   DropdownMenu,
+ *   DropdownMenuContent,
+ *   DropdownMenuTrigger,
+ *   DropdownMenuRadioGroup,
+ * } from "@/components/dropdown-menu";
+ * import {
+ *   FilterButton,
+ * } from "@/components/buttons/filter-button";
+ * import {
+ *   FilterLabel,
+ *   FilterSeparator,
+ *   FilterCheckboxItem,
+ *   FilterRadioItem,
+ *   FilterGroup,
+ *   FilterChips,
+ * } from "./filter";
+ *
+ * function CreditSessionsListFilter() {
+ *   const [status, setStatus] = React.useState<string[]>([]);
+ *   const [type, setType] = React.useState<string>("all");
+ *
+ *   const activeFilters = [
+ *     ...(status.length > 0 ? status.map(s => ({ id: `status-${s}`, label: `Status: ${s}` })) : []),
+ *     ...(type !== "all" ? [{ id: "type", label: `Type: ${type}` }] : []),
+ *   ];
+ *
+ *   return (
+ *     <>
+ *       <DropdownMenu>
+ *         <DropdownMenuTrigger asChild>
+ *           <FilterButton />
+ *         </DropdownMenuTrigger>
+ *         <DropdownMenuContent>
+ *           <FilterGroup>
+ *             <FilterLabel>Status</FilterLabel>
+ *             <FilterCheckboxItem
+ *               checked={status.includes("active")}
+ *               onCheckedChange={(checked) =>
+ *                 setStatus(checked
+ *                   ? [...status, "active"]
+ *                   : status.filter(s => s !== "active"))
+ *               }
+ *             >
+ *               Active
+ *             </FilterCheckboxItem>
+ *             <FilterCheckboxItem
+ *               checked={status.includes("inactive")}
+ *               onCheckedChange={(checked) =>
+ *                 setStatus(checked
+ *                   ? [...status, "inactive"]
+ *                   : status.filter(s => s !== "inactive"))
+ *               }
+ *             >
+ *               Inactive
+ *             </FilterCheckboxItem>
+ *           </FilterGroup>
+ *           <FilterSeparator />
+ *           <FilterGroup>
+ *             <FilterLabel>Type</FilterLabel>
+ *             <DropdownMenuRadioGroup value={type} onValueChange={setType}>
+ *               <FilterRadioItem value="all">All</FilterRadioItem>
+ *               <FilterRadioItem value="credit">Credit</FilterRadioItem>
+ *               <FilterRadioItem value="debit">Debit</FilterRadioItem>
+ *             </DropdownMenuRadioGroup>
+ *           </FilterGroup>
+ *         </DropdownMenuContent>
+ *       </DropdownMenu>
+ *       <FilterChips
+ *         filters={activeFilters}
+ *         onRemoveFilter={(id) => {
+ *           if (id.startsWith("status-")) {
+ *             setStatus(status.filter(s => `status-${s}` !== id));
+ *           } else if (id === "type") {
+ *             setType("all");
+ *           }
+ *         }}
+ *         onClearAll={() => {
+ *           setStatus([]);
+ *           setType("all");
+ *         }}
+ *       />
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+export * from './filter-block';
+export * from './filter-checkbox-item';
+export * from './filter-chip';
+export * from './filter-chips';
+export * from './filter-dropdown-item';
+export * from './filter-group';
+export * from './filter-label';
+export * from './filter-modal';
+export * from './filter-modal-item';
+export * from './filter-radio-item';
+export * from './filter-separator';
+export type { FilterModalSelectList } from './interface';
+export * from './variants';

package/dist/types/components/filter/interface.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Type representing a list of selected filter values for FilterModal component
+ * Can be a Set or Array of values
+ */
+export type FilterModalSelectList<T> = Set<T> | T[];
+/**
+ * @deprecated Use FilterModalSelectList instead
+ * This type is kept for backward compatibility
+ */
+export type SelectFilterList<T> = FilterModalSelectList<T>;
+/**
+ * Type representing a filter range with from and to values
+ * Used for range-based filtering (e.g., date ranges, number ranges)
+ */
+export type FilterRange<T = number> = {
+    /**
+     * The starting value of the range
+     */
+    from: T;
+    /**
+     * The ending value of the range
+     */
+    to: T;
+};

package/dist/types/components/filter/variants.d.ts

@@ -0,0 +1,3 @@
+export declare const filterBlockVariants: (props?: ({
+    variant?: "default" | "ghost" | "outlined" | "elevated" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;

package/dist/types/components/form/form-field.d.ts

@@ -0,0 +1,38 @@
+import { Input } from '../input';
+import type * as React from "react";
+interface FormFieldProps {
+    label: string;
+    error?: string;
+    required?: boolean;
+    helperText?: string;
+    inputProps?: React.ComponentProps<typeof Input>;
+    className?: string;
+}
+/**
+ * FormField component - Composition of Label and Input with error handling
+ *
+ * Automatically manages ARIA attributes for accessibility
+ *
+ * @example
+ * ```tsx
+ * <FormField
+ *   label="Email"
+ *   required
+ *   inputProps={{ type: "email", placeholder: "Enter your email" }}
+ * />
+ *
+ * <FormField
+ *   label="Username"
+ *   error="Username is already taken"
+ *   inputProps={{ value: username, onChange: handleChange }}
+ * />
+ *
+ * <FormField
+ *   label="Password"
+ *   helperText="Must be at least 8 characters"
+ *   inputProps={{ type: "password" }}
+ * />
+ * ```
+ */
+export declare function FormField({ label, error, required, helperText, inputProps, className, }: FormFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/form/index.d.ts

@@ -0,0 +1 @@
+export * from './form-field';

package/dist/types/components/formatted-number/formatted-number.d.ts

@@ -0,0 +1,21 @@
+import { ParseSmallNumberResult } from '../../utils';
+import type * as React from "react";
+export interface FormattedNumberStringProps extends React.HTMLAttributes<HTMLSpanElement> {
+    /**
+     * Maximum length for decimal part in tooltip (trimmed)
+     */
+    decimalPartLength?: number;
+    /**
+     * When repeat (leading zeros in decimal) exceeds this, show "0" + repeat count
+     */
+    hideZerosIfMore?: number;
+    /**
+     * The value to display (string, or parsed small number result)
+     */
+    value: string | ParseSmallNumberResult | undefined;
+}
+/**
+ * FormattedNumberString — displays a number with optional compact decimal (zeros as repeat count) and tooltip with full value.
+ * Matches interface FormattedNumber structure and styles.
+ */
+export declare function FormattedNumberString({ value, decimalPartLength, hideZerosIfMore, className, ...props }: FormattedNumberStringProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/formatted-number/index.d.ts

@@ -0,0 +1 @@
+export * from './formatted-number';

package/dist/types/components/graph/default-config.d.ts

@@ -0,0 +1,20 @@
+import { AreaSeriesPartialOptions, ChartOptions, DeepPartial } from 'lightweight-charts';
+import { VertLineOptions } from './plugins/vertical-line';
+export declare const DEFAULT_AREA_SERIES: AreaSeriesPartialOptions;
+export declare const DEFAULT_VERTICAL_LINE: Partial<VertLineOptions>;
+/**
+ * Gets the default chart options with resolved CSS colors
+ * Call this at runtime to ensure CSS variables are properly resolved
+ */
+export declare function getDefaultOptions(): DeepPartial<ChartOptions>;
+/**
+ * Gets the default series options with resolved CSS colors
+ * Call this at runtime to ensure CSS variables are properly resolved
+ */
+export declare function getDefaultSeries(): AreaSeriesPartialOptions;
+/**
+ * Gets the default vertical line options with resolved CSS colors
+ * Call this at runtime to ensure CSS variables are properly resolved
+ */
+export declare function getDefaultVerticalLine(): Partial<VertLineOptions>;
+export declare const DEFAULT_OPTIONS: DeepPartial<ChartOptions>;

package/dist/types/components/graph/formatters.d.ts

@@ -0,0 +1,48 @@
+import { Time, TickMarkType } from 'lightweight-charts';
+export interface Point {
+    time: Time | number;
+    value: number;
+}
+interface Flavoring<FlavorT> {
+    _type?: FlavorT;
+}
+type Flavor<T, FlavorT> = T & Flavoring<FlavorT>;
+export type YMeasureUnits = "$" | "%" | "none" | Flavor<string, "token">;
+type YFormatter = (v: number, symbol: YMeasureUnits | undefined, format?: "full" | "short") => string;
+export declare const getYFormatter: (unit: YMeasureUnits) => YFormatter;
+/**
+ * Format a number with full precision, only removing trailing zeros
+ * Used for displaying exact current values on graphs
+ */
+export declare function formatExactValue(value: number, symbol?: string, maxDecimals?: number): string;
+export interface AdaptiveYAxisFormatterOptions {
+    /**
+     * When set (same as chart yScaleMin floor), axis tick labels with price strictly
+     * below this value are hidden (e.g. 0 hides negative tick labels).
+     */
+    yScaleMin?: number;
+}
+/**
+ * Creates an adaptive Y-axis formatter that determines precision dynamically
+ * based on visible range to ensure unique labels on the axis.
+ * Data point values (like current price label) are shown with full precision.
+ * Returns both the formatter and update functions.
+ */
+export declare function createAdaptiveYAxisFormatter(initialValues: number[], _unit: YMeasureUnits, options?: AdaptiveYAxisFormatterOptions): {
+    formatter: (price: number) => string;
+    tickmarksFormatter: (prices: number[]) => string[];
+    updateVisibleRange: (visibleValues: number[]) => void;
+    updateLastValues: (lastValues: number[]) => void;
+};
+export type XMeasureUnits = "time" | "%";
+type XFormatter = (time: Time, symbol: XMeasureUnits | undefined) => string;
+export interface XFormatters {
+    /** Used for crosshair tooltip / localization.timeFormatter */
+    timeFormatter: XFormatter;
+    /** Used for timeScale.tickMarkFormatter — receives TickMarkType */
+    tickMarkFormatter: (time: Time, tickMarkType: TickMarkType, locale: string) => string;
+}
+export declare const getXFormatters: (unit: XMeasureUnits, points?: Point[]) => XFormatters;
+/** @deprecated Use getXFormatters instead */
+export declare const getXFormatter: (unit: XMeasureUnits, points?: Point[]) => XFormatter;
+export {};

package/dist/types/components/graph/graph-current-value.d.ts

@@ -0,0 +1,18 @@
+import { Point, XMeasureUnits, YMeasureUnits } from './formatters';
+import type * as React from "react";
+export interface GraphCurrentValueProps {
+    point: Point;
+    xMeasureUnit: XMeasureUnits;
+    yMeasureUnit: YMeasureUnits;
+    className?: string;
+    /**
+     * Number of decimal places for current value display.
+     * If 0, rounds to whole numbers. Default is 4.
+     */
+    decimals?: number;
+}
+/**
+ * GraphCurrentValue component displays the current value in single mode
+ * without background, border, or legend - just date and value
+ */
+export declare function GraphCurrentValue({ point, xMeasureUnit, yMeasureUnit, className, decimals, }: GraphCurrentValueProps): React.ReactElement;

package/dist/types/components/graph/graph-tooltip.d.ts

@@ -0,0 +1,29 @@
+import { Point, XMeasureUnits, YMeasureUnits } from './formatters';
+import { SeriesConfig } from './graph';
+import type * as React from "react";
+export interface GraphTooltipProps {
+    /** Points by series label */
+    points: Map<string, Point>;
+    /** Series configuration */
+    series: Array<SeriesConfig>;
+    xMeasureUnit: XMeasureUnits;
+    yMeasureUnit: YMeasureUnits;
+    className?: string;
+    /** Position of the tooltip (x, y coordinates relative to the chart container) */
+    position?: {
+        x: number;
+        y: number;
+    };
+    /** Container element to constrain tooltip within bounds */
+    containerRef?: React.RefObject<HTMLElement | null>;
+    /**
+     * Number of decimal places for value display.
+     * If 0, rounds to whole numbers. Default is 4.
+     */
+    decimals?: number;
+}
+/**
+ * GraphTooltip component displays the current value and time on the graph
+ * Supports single or multiple series
+ */
+export declare function GraphTooltip({ points, series, xMeasureUnit, yMeasureUnit, className, position, containerRef, decimals, }: GraphTooltipProps): React.ReactElement | null;

package/dist/types/components/graph/graph-view.d.ts

@@ -0,0 +1,224 @@
+import { VariantProps } from 'class-variance-authority';
+import { GraphProps } from './graph';
+import * as React from "react";
+declare const graphViewVariants: (props?: ({
+    variant?: "default" | "ghost" | "outlined" | "elevated" | null | undefined;
+    size?: "full" | "default" | "sm" | "lg" | "xl" | null | undefined;
+    padding?: "none" | "default" | "sm" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+/**
+ * GraphView component props
+ */
+export interface GraphViewProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof graphViewVariants> {
+    /**
+     * Optional title to display above the graph
+     */
+    title?: string;
+    /**
+     * Optional description or subtitle
+     */
+    description?: string;
+    /**
+     * Optional toolbar or actions to display in the header
+     */
+    toolbar?: React.ReactNode;
+    /**
+     * Optional loading state
+     */
+    loading?: boolean;
+    /**
+     * Optional empty state message
+     */
+    emptyMessage?: string;
+    /**
+     * Optional error message
+     */
+    error?: string;
+}
+/**
+ * Point type for legacy API compatibility
+ */
+export interface GraphPoint {
+    time: number | string;
+    value: number;
+}
+/**
+ * GraphViewWithData props - extends GraphView with actual chart data
+ */
+export interface GraphViewWithDataProps extends Omit<GraphProps, "series">, Pick<GraphViewProps, "title" | "description" | "toolbar" | "emptyMessage" | "error"> {
+    /** Series configuration - can be single or multiple series (new API) */
+    series?: GraphProps["series"];
+    /**
+     * Direct data array (legacy API from interface)
+     * If provided without series, will be converted to single series
+     */
+    data?: GraphPoint[];
+    /**
+     * Line color for legacy single-series `data` (same as SeriesConfig.lineColor / color)
+     */
+    lineColor?: string;
+    /** Alias for lineColor when using legacy `data` */
+    color?: string;
+    /** Area fill gradient top when using legacy `data` */
+    topColor?: string;
+    /** Area fill gradient bottom when using legacy `data` */
+    bottomColor?: string;
+    /**
+     * Graph ID for DOM element (legacy API from interface)
+     */
+    graphId?: string;
+    /** Function to call when series is unselected from legend */
+    onUnselectSeries?: GraphProps["onUnselectSeries"];
+    loading: boolean;
+    containerClassName?: string;
+    variant?: GraphViewProps["variant"];
+    size?: GraphViewProps["size"];
+    padding?: GraphViewProps["padding"];
+}
+/**
+ * GraphView component for displaying graphs, charts, and visualizations
+ *
+ * This is a container component that provides layout, loading states, and error handling
+ * for chart content. Use GraphViewWithData for a complete chart with data integration.
+ *
+ * @example
+ * ```tsx
+ * // Basic usage
+ * <GraphView>
+ *   <YourGraphComponent />
+ * </GraphView>
+ *
+ * // With title and description
+ * <GraphView
+ *   title="Network Activity"
+ *   description="Last 24 hours"
+ * >
+ *   <NetworkGraph />
+ * </GraphView>
+ *
+ * // With toolbar
+ * <GraphView
+ *   title="Performance Metrics"
+ *   toolbar={
+ *     <div className="flex gap-2">
+ *       <Button size="sm">Refresh</Button>
+ *       <Button size="sm" variant="outline">Export</Button>
+ *     </div>
+ *   }
+ * >
+ *   <PerformanceChart />
+ * </GraphView>
+ *
+ * // Different sizes
+ * <GraphView size="lg">
+ *   <LargeGraph />
+ * </GraphView>
+ *
+ * // Loading state
+ * <GraphView loading title="Loading...">
+ *   <GraphSkeleton />
+ * </GraphView>
+ *
+ * // Empty state
+ * <GraphView emptyMessage="No data available">
+ *   {null}
+ * </GraphView>
+ *
+ * // Error state
+ * <GraphView error="Failed to load data">
+ *   {null}
+ * </GraphView>
+ * ```
+ */
+declare const GraphView: React.ForwardRefExoticComponent<GraphViewProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * GraphViewWithData component integrates GraphView container with Graph chart
+ *
+ * This component combines the container features of GraphView with the charting
+ * capabilities of Graph, providing a complete solution for data visualization.
+ *
+ * @example
+ * ```tsx
+ * // Basic usage with single series
+ * <GraphViewWithData
+ *   series={[{ data: chartData, label: "Price" }]}
+ *   loading={isLoading}
+ *   graphId="my-chart"
+ *   title="Price History"
+ *   description="Last 30 days"
+ *   yMeasureUnit="$"
+ *   xMeasureUnit="time"
+ * />
+ *
+ * // Multiple series with legend
+ * <GraphViewWithData
+ *   series={[
+ *     { data: series1, label: "Series 1" },
+ *     { data: series2, label: "Series 2" },
+ *     { data: series3, label: "Series 3" }
+ *   ]}
+ *   loading={isLoading}
+ *   graphId="my-chart"
+ *   showLegend={true}
+ *   title="Multiple Metrics"
+ * />
+ *
+ * // With vertical line markers
+ * <GraphViewWithData
+ *   series={[{ data: chartData, label: "Price" }]}
+ *   loading={false}
+ *   graphId="my-chart"
+ *   verticalLineOptions={[
+ *     {
+ *       xCoordinate: someTimestamp,
+ *       options: {
+ *         labelText: "Important Event",
+ *         color: "hsl(var(--primary))",
+ *       }
+ *     }
+ *   ]}
+ * />
+ *
+ * // Empty state
+ * <GraphViewWithData
+ *   series={[]}
+ *   loading={false}
+ *   graphId="my-chart"
+ *   emptyMessage="No data available"
+ * />
+ * ```
+ */
+export declare function GraphViewWithData({ series, data, lineColor, color, topColor, bottomColor, graphId, onUnselectSeries, loading, title, description, toolbar, emptyMessage, error, containerClassName, variant, size, padding, yMeasureUnit, showCurrentValue, ...restProps }: GraphViewWithDataProps): React.ReactElement;
+/**
+ * Custom hook to manage graph sizing with an aside element
+ *
+ * This hook helps calculate the available width for a graph when there's
+ * an aside element (like a legend or info panel) next to it.
+ *
+ * @param gap - The gap in pixels between the graph and aside element
+ * @returns Object containing graphWidth, parentRef, and asideRef
+ *
+ * @example
+ * ```tsx
+ * function MyChart() {
+ *   const { graphWidth, parentRef, asideRef } = useGraphAside(16);
+ *
+ *   return (
+ *     <div ref={parentRef} className="flex gap-4">
+ *       <div style={{ width: graphWidth }}>
+ *         <GraphViewWithData {...props} />
+ *       </div>
+ *       <aside ref={asideRef}>
+ *         Legend content
+ *       </aside>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useGraphAside(gap?: number): {
+    graphWidth: number | null;
+    parentRef: React.RefObject<HTMLDivElement | null>;
+    asideRef: React.RefObject<HTMLDivElement | null>;
+};
+export { GraphView, graphViewVariants };

package/dist/types/components/graph/graph.d.ts

@@ -0,0 +1,104 @@
+import { ChartOptions, DeepPartial, Time } from 'lightweight-charts';
+import { Point, YMeasureUnits } from './formatters';
+import { GraphTooltipProps } from './graph-tooltip';
+import * as React from "react";
+export interface SeriesConfig {
+    data: Array<Point>;
+    label: string;
+    /** Line color (area stroke). Alias: prefer `lineColor` for clarity; if both set, `lineColor` wins. */
+    color?: string;
+    /** Line color — same as `color`; use for explicit line-only color. */
+    lineColor?: string;
+    /** Upper gradient of the area fill */
+    topColor?: string;
+    /** Lower gradient of the area fill */
+    bottomColor?: string;
+    yMeasureUnit?: YMeasureUnits;
+}
+export type VerticalLineOptions = Partial<{
+    color: string;
+    labelText: string;
+    value?: string | number;
+    width: number;
+    labelBackgroundColor: string;
+    labelTextColor: string;
+    showLabel: boolean;
+}>;
+/**
+ * Returns formatted label and value strings for a vertical line tooltip.
+ * Used by Graph and by tests.
+ */
+export declare function getVerticalLineTooltipContent(opts: VerticalLineOptions, yMeasureUnit: YMeasureUnits, currentValueDecimals: number | undefined): {
+    labelText: string;
+    valueStr: string;
+};
+/**
+ * Palette ordered for maximum contrast; first color is the original teal.
+ * Greens/teals are spread out so that when only a subset of series is visible,
+ * similar colors are not repeated.
+ */
+export declare const DEFAULT_SERIES_COLORS: {
+    line: string;
+    top: string;
+    bottom: string;
+}[];
+export type SeriesColorPalette = (typeof DEFAULT_SERIES_COLORS)[number];
+/**
+ * Returns a color palette for a series by index. Uses predefined palette for
+ * the first N series; generates distinct colors for additional series so they
+ * never repeat.
+ */
+export declare function getSeriesColorPalette(index: number): SeriesColorPalette;
+export interface GraphProps {
+    /** Series configuration - can be single or multiple series */
+    series: Array<SeriesConfig>;
+    className?: string;
+    /** Show legend */
+    showLegend?: boolean;
+    /** Function to call when series is unselected from legend */
+    onUnselectSeries?: (label: string) => void;
+    yMeasureUnit?: GraphTooltipProps["yMeasureUnit"];
+    xMeasureUnit?: GraphTooltipProps["xMeasureUnit"];
+    optionsOverrides?: DeepPartial<ChartOptions>;
+    verticalLineOptions?: Array<{
+        xCoordinate: Time;
+        options?: VerticalLineOptions;
+    }>;
+    /**
+     * Number of decimal places for current value display.
+     * If 0, rounds to whole numbers. Default is 4.
+     */
+    currentValueDecimals?: number;
+    /**
+     * When true, all series use a single Y axis (shared scale).
+     * Use when series are comparable (e.g. "part" vs "whole") so vertical position
+     * reflects actual relative values. When false (default), each series has its
+     * own scale and fills the chart independently.
+     */
+    useSharedPriceScale?: boolean;
+    /**
+     * When true (default), shows the current value and date in the top-left corner
+     * in single-series mode. Set to false to hide.
+     */
+    showCurrentValue?: boolean;
+    /**
+     * When set, renders in the top-left overlay instead of the current value + date.
+     * Only for single-series; hidden when multiple series are shown (legend occupies the area).
+     */
+    graphTitle?: React.ReactNode;
+    /**
+     * Y-axis floor when a single series has data. If omitted, default chart scaling (no floor).
+     */
+    yScaleMin?: number;
+    /**
+     * Y-axis floor when more than one series has data. If omitted, default chart scaling.
+     * Which prop applies is chosen by how many series actually have points (empty series are ignored).
+     */
+    yScaleMinMultiple?: number;
+}
+/**
+ * Graph component that renders a chart using lightweight-charts library
+ * with support for area series, custom tooltips, and vertical line annotations
+ * Supports single or multiple series with different colors and legends
+ */
+export declare function Graph({ series, className, showLegend, onUnselectSeries, xMeasureUnit, yMeasureUnit, optionsOverrides, verticalLineOptions, currentValueDecimals, useSharedPriceScale, showCurrentValue, graphTitle, yScaleMin, yScaleMinMultiple, }: GraphProps): React.ReactElement;

package/dist/types/components/graph/index.d.ts

@@ -0,0 +1,7 @@
+export * from './default-config';
+export { getXFormatter, getXFormatters, getYFormatter, type Point as GraphPoint, type XFormatters, type XMeasureUnits, type YMeasureUnits, } from './formatters';
+export { DEFAULT_SERIES_COLORS, Graph, type GraphProps, getSeriesColorPalette, getVerticalLineTooltipContent, type SeriesColorPalette, type SeriesConfig, type VerticalLineOptions, } from './graph';
+export * from './graph-current-value';
+export * from './graph-tooltip';
+export * from './graph-view';
+export { VertLine } from './plugins/vertical-line';