@asymmetric-effort/specifyjs 0.2.97 → 0.2.100

package/dist/types/components/viz/calendar-heat-map/src/CalendarHeatMap.d.ts

@@ -0,0 +1,29 @@
+export interface CalendarDatum {
+    /** Date string in 'YYYY-MM-DD' format */
+    date: string;
+    /** Numeric value for this date */
+    value: number;
+}
+export interface CalendarHeatMapProps {
+    /** Array of date/value pairs */
+    data: CalendarDatum[];
+    /** SVG width in pixels (default: 800) */
+    width?: number;
+    /** SVG height in pixels (default: 160) */
+    height?: number;
+    /** Color gradient from low to high */
+    colorScale?: string[];
+    /** Size of each day cell in px (default: 12) */
+    cellSize?: number;
+    /** Gap between cells in px (default: 2) */
+    cellGap?: number;
+    /** Show month labels above the calendar (default: true) */
+    showMonthLabels?: boolean;
+    /** Show day-of-week labels on the left (default: true) */
+    showDayLabels?: boolean;
+    /** Color for days with no data (default: '#ebedf0') */
+    emptyColor?: string;
+    /** Chart title */
+    title?: string;
+}
+export declare function CalendarHeatMap(props: CalendarHeatMapProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/viz/calendar-heat-map/src/index.d.ts

@@ -0,0 +1,2 @@
+export { CalendarHeatMap } from './CalendarHeatMap';
+export type { CalendarHeatMapProps, CalendarDatum } from './CalendarHeatMap';

package/dist/types/components/viz/chord/src/ChordDiagram.d.ts

@@ -0,0 +1,25 @@
+export interface ChordDiagramProps {
+    /** Square matrix where matrix[i][j] = flow from group i to group j */
+    matrix: number[][];
+    /** Labels for each group (must match matrix dimensions) */
+    labels: string[];
+    /** SVG width in pixels (default: 600) */
+    width?: number;
+    /** SVG height in pixels (default: 600) */
+    height?: number;
+    /** Color palette for groups */
+    colors?: string[];
+    /** Angular padding between arcs in radians (default: 0.05) */
+    padAngle?: number;
+    /** Show group labels (default: true) */
+    showLabels?: boolean;
+    /** Show flow values on hover/annotation (default: false) */
+    showValues?: boolean;
+    /** Ribbon fill opacity 0..1 (default: 0.5) */
+    ribbonOpacity?: number;
+    /** Inner radius as ratio of outer radius (default: 0.9) */
+    innerRadiusRatio?: number;
+    /** Chart title */
+    title?: string;
+}
+export declare function ChordDiagram(props: ChordDiagramProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/viz/chord/src/index.d.ts

@@ -0,0 +1,2 @@
+export { ChordDiagram } from './ChordDiagram';
+export type { ChordDiagramProps } from './ChordDiagram';

package/dist/types/components/viz/decomposition-tree/src/DecompositionTree.d.ts

@@ -0,0 +1,33 @@
+export interface DecompNode {
+    label: string;
+    value?: number | string;
+    color?: string;
+    children?: DecompNode[];
+}
+export interface DecompositionTreeProps {
+    /** Root node of the tree */
+    data: DecompNode;
+    /** SVG width in pixels (default: 800) */
+    width?: number;
+    /** SVG height in pixels (default: 500) */
+    height?: number;
+    /** Layout orientation (default: 'horizontal') */
+    orientation?: 'horizontal' | 'vertical';
+    /** Width of each node rectangle (default: 120) */
+    nodeWidth?: number;
+    /** Height of each node rectangle (default: 40) */
+    nodeHeight?: number;
+    /** Show value inside nodes (default: true) */
+    showValues?: boolean;
+    /** Show connector lines between nodes (default: true) */
+    showConnectors?: boolean;
+    /** Connector line color (default: '#94a3b8') */
+    connectorColor?: string;
+    /** Color palette for nodes by depth */
+    colors?: string[];
+    /** Chart title */
+    title?: string;
+    /** Padding around chart area in px (default: 40) */
+    padding?: number;
+}
+export declare function DecompositionTree(props: DecompositionTreeProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/viz/decomposition-tree/src/index.d.ts

@@ -0,0 +1,2 @@
+export { DecompositionTree } from './DecompositionTree';
+export type { DecompositionTreeProps, DecompNode } from './DecompositionTree';

package/dist/types/components/viz/earth-globe/src/EarthGlobe.d.ts

@@ -0,0 +1,62 @@
+export interface EarthGlobeProps {
+    /** SVG width in pixels (default: 400) */
+    width?: number;
+    /** SVG height in pixels (default: 400) */
+    height?: number;
+    /** Initial rotation: longitude and latitude of center point */
+    rotation?: {
+        longitude: number;
+        latitude: number;
+    };
+    /** Land fill color (default: '#22c55e') */
+    fillColor?: string;
+    /** Ocean/background color (default: '#3b82f6') */
+    oceanColor?: string;
+    /** Country border stroke color (default: '#ffffff') */
+    strokeColor?: string;
+    /** Country border stroke width (default: 0.5) */
+    strokeWidth?: number;
+    /** Show latitude/longitude grid lines (default: true) */
+    showGraticule?: boolean;
+    /** Graticule line color (default: 'rgba(255,255,255,0.2)') */
+    graticuleColor?: string;
+    /** Allow drag-to-rotate interaction (default: true) */
+    interactive?: boolean;
+    /** Callback when a country is clicked */
+    onCountryClick?: (countryId: string) => void;
+    /** Callback when a country is hovered (null when leaving) */
+    onCountryHover?: (countryId: string | null) => void;
+    /** Country hover color (default: '#16a34a') */
+    hoverColor?: string;
+    /** Accessible title (default: 'Earth Globe') */
+    title?: string;
+    /** Map of country ID to highlight color */
+    highlightCountries?: Record<string, string>;
+}
+/** Convert degrees to radians. */
+export declare function toRad(deg: number): number;
+/** Convert radians to degrees. */
+export declare function toDeg(rad: number): number;
+/**
+ * Orthographic projection: project a [lon, lat] point onto a 2D plane
+ * centered at [centerLon, centerLat].
+ *
+ * Returns { x, y, visible } where x,y are in [-1,1] range and visible
+ * indicates whether the point is on the near side of the globe.
+ */
+export declare function orthographicProject(lon: number, lat: number, centerLon: number, centerLat: number): {
+    x: number;
+    y: number;
+    visible: boolean;
+};
+/**
+ * Project a polygon ring onto the SVG coordinate system, returning an SVG
+ * path string. Only draws segments where both endpoints are visible.
+ */
+export declare function projectPolygonToPath(ring: [number, number][], centerLon: number, centerLat: number, cx: number, cy: number, radius: number): string;
+/**
+ * Generate graticule paths (lat/lon grid lines).
+ * Returns an array of SVG path strings.
+ */
+export declare function buildGraticuleLines(centerLon: number, centerLat: number, cx: number, cy: number, radius: number, step: number): string[];
+export declare function EarthGlobe(props: EarthGlobeProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/viz/earth-globe/src/globe-data.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Simplified world country/continent outline data for orthographic globe
+ * projection. Each country is defined by one or more polygon rings of
+ * [longitude, latitude] coordinate pairs.
+ *
+ * Data is intentionally simplified (fewer vertices) to keep bundle size
+ * reasonable while still producing recognizable continental shapes.
+ */
+export interface CountryData {
+    /** ISO-like identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Polygon rings — each ring is an array of [lon, lat] pairs */
+    polygons: [number, number][][];
+}
+/**
+ * Simplified world country outlines.
+ *
+ * Coordinates are [longitude, latitude] in degrees.
+ * Polygons are intentionally low-resolution for performance.
+ */
+export declare const COUNTRIES: CountryData[];

package/dist/types/components/viz/earth-globe/src/index.d.ts

@@ -0,0 +1,5 @@
+export { EarthGlobe } from "./EarthGlobe";
+export type { EarthGlobeProps } from "./EarthGlobe";
+export { orthographicProject, projectPolygonToPath, buildGraticuleLines, toRad, toDeg, } from "./EarthGlobe";
+export type { CountryData } from "./globe-data";
+export { COUNTRIES } from "./globe-data";

package/dist/types/components/viz/force-graph/src/ForceGraph.d.ts

@@ -0,0 +1,99 @@
+export interface ForceNode {
+    id: string;
+    label?: string;
+    color?: string;
+    x?: number;
+    y?: number;
+    fixed?: boolean;
+    /** If true (default), this node cannot overlap other solid nodes.
+     *  Collisions produce elastic bounce consistent with Newtonian physics.
+     *  Set to false to allow nodes to pass through each other. */
+    solid?: boolean;
+}
+export interface ForceEdge {
+    source: string;
+    target: string;
+    weight?: number;
+    color?: string;
+}
+/** Simulation node state — exported so custom force functions can use it */
+export interface ForceSimNode {
+    id: string;
+    label: string;
+    color: string;
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    fixed: boolean;
+    /** Whether this node collides with other solid nodes (default: true) */
+    solid: boolean;
+}
+/** Mouse position in viewBox coordinates (null if mouse is outside the SVG) */
+export interface MousePosition {
+    x: number;
+    y: number;
+}
+/**
+ * Custom force function signature.
+ * Receives current node states, edges, viewport dimensions, and mouse position.
+ * Must return the updated node states (new positions/velocities).
+ * Called once per animation frame.
+ */
+export type CustomForceFunction = (nodes: ForceSimNode[], edges: ForceEdge[], width: number, height: number, mouse: MousePosition | null) => ForceSimNode[];
+/** Trail configuration for a specific node */
+export interface TrailConfig {
+    /** Node ID to trail */
+    nodeId: string;
+    /** Trail color */
+    color?: string;
+    /** Max number of trail points (default: 200) */
+    maxPoints?: number;
+    /** Trail line width (default: 1) */
+    width?: number;
+    /** Trail opacity (default: 0.5) */
+    opacity?: number;
+}
+export interface ForceGraphProps {
+    /** Array of nodes to render */
+    nodes: ForceNode[];
+    /** Array of edges connecting nodes */
+    edges: ForceEdge[];
+    /** SVG width in pixels (default: 600) */
+    width?: number;
+    /** SVG height in pixels (default: 400) */
+    height?: number;
+    /** Node circle radius in pixels (default: 12) */
+    nodeRadius?: number;
+    /** Node border stroke width in pixels (default: 2, set to 0 for no border) */
+    nodeStrokeWidth?: number;
+    /** Show node labels (default: true) */
+    showLabels?: boolean;
+    /** Show arrowheads on edges (default: false) */
+    showArrows?: boolean;
+    /** Repulsion force between nodes (default: 300) */
+    repulsionForce?: number;
+    /** Attraction force along edges (default: 0.01) */
+    attractionForce?: number;
+    /** Velocity damping factor 0..1 (default: 0.9) */
+    damping?: number;
+    /** Ideal edge length in pixels (default: 100) */
+    edgeLength?: number;
+    /** Default edge stroke color (default: '#94a3b8') */
+    edgeColor?: string;
+    /** Default edge stroke width (default: 1.5) */
+    edgeWidth?: number;
+    /** Chart title */
+    title?: string;
+    /** Whether nodes are solid by default — solid nodes cannot overlap and
+     *  bounce off each other via elastic collision. Per-node `solid` prop
+     *  overrides this. (default: true) */
+    solidNodes?: boolean;
+    /** Custom force function — replaces the default spring/repulsion physics.
+     *  When provided, repulsionForce/attractionForce/damping/edgeLength are ignored.
+     *  The function is called once per animation frame and must return updated nodes. */
+    customForce?: CustomForceFunction;
+    /** Trail configurations — render fading path trails for specific nodes */
+    trails?: TrailConfig[];
+}
+export declare function ForceGraph(props: ForceGraphProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/viz/force-graph/src/index.d.ts

@@ -0,0 +1,2 @@
+export { ForceGraph } from './ForceGraph';
+export type { ForceGraphProps, ForceNode, ForceEdge, ForceSimNode, CustomForceFunction, TrailConfig, MousePosition } from './ForceGraph';

package/dist/types/components/viz/funnel/src/FunnelChart.d.ts

@@ -0,0 +1,28 @@
+export interface FunnelDatum {
+    label: string;
+    value: number;
+    color?: string;
+}
+export interface FunnelChartProps {
+    /** Data sections to render (in funnel order, largest first typically) */
+    data: FunnelDatum[];
+    /** SVG width in pixels (default: 600) */
+    width?: number;
+    /** SVG height in pixels (default: 400) */
+    height?: number;
+    /** Funnel orientation (default: 'vertical') */
+    orientation?: 'vertical' | 'horizontal';
+    /** Show labels on sections (default: true) */
+    showLabels?: boolean;
+    /** Show values on sections (default: true) */
+    showValues?: boolean;
+    /** Show percentage of first item (default: true) */
+    showPercentage?: boolean;
+    /** Gap between sections in px (default: 2) */
+    gapSize?: number;
+    /** Color palette (cycles through when per-datum color is absent) */
+    colors?: string[];
+    /** Chart title */
+    title?: string;
+}
+export declare function FunnelChart(props: FunnelChartProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/viz/funnel/src/index.d.ts

@@ -0,0 +1,2 @@
+export { FunnelChart } from './FunnelChart';
+export type { FunnelChartProps, FunnelDatum } from './FunnelChart';

package/dist/types/components/viz/gantt-chart/src/GanttChart.d.ts

@@ -0,0 +1,33 @@
+export interface GanttTask {
+    id: string;
+    label: string;
+    start: number;
+    duration: number;
+    color?: string;
+    group?: string;
+}
+export interface GanttChartProps {
+    /** Array of tasks to render */
+    tasks: GanttTask[];
+    /** SVG width in pixels (default: 800) */
+    width?: number;
+    /** SVG height in pixels (default: 400) */
+    height?: number;
+    /** Height of each task bar in px (default: 24) */
+    barHeight?: number;
+    /** Vertical gap between task bars in px (default: 8) */
+    barGap?: number;
+    /** Show vertical grid lines (default: true) */
+    showGrid?: boolean;
+    /** Show task labels on the left (default: true) */
+    showLabels?: boolean;
+    /** Show progress text on bars (default: false) */
+    showProgress?: boolean;
+    /** Label for the time unit displayed on axis (default: 'days') */
+    timeUnit?: string;
+    /** Chart title */
+    title?: string;
+    /** Padding around chart area in px (default: 50) */
+    padding?: number;
+}
+export declare function GanttChart(props: GanttChartProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/viz/gantt-chart/src/index.d.ts

@@ -0,0 +1,2 @@
+export { GanttChart } from './GanttChart';
+export type { GanttChartProps, GanttTask } from './GanttChart';

package/dist/types/components/viz/gauge/src/Gauge.d.ts

@@ -0,0 +1,37 @@
+export interface GaugeProps {
+    /** Current gauge value */
+    value: number;
+    /** Minimum value (default: 0) */
+    min?: number;
+    /** Maximum value (default: 100) */
+    max?: number;
+    /** SVG width in pixels (default: 300) */
+    width?: number;
+    /** SVG height in pixels (default: 200) */
+    height?: number;
+    /** Arc start angle in degrees (default: -135) */
+    startAngle?: number;
+    /** Arc end angle in degrees (default: 135) */
+    endAngle?: number;
+    /** Arc stroke width (default: 20) */
+    arcWidth?: number;
+    /** Show the numeric value (default: true) */
+    showValue?: boolean;
+    /** Show min/max labels (default: true) */
+    showMinMax?: boolean;
+    /** Show tick marks (default: true) */
+    showTicks?: boolean;
+    /** Number of tick divisions (default: 10) */
+    tickCount?: number;
+    /** Label text below the value */
+    label?: string;
+    /** Unit text after the value (e.g. 'rpm', '%') */
+    unit?: string;
+    /** Colors for arc segments — evenly distributed (default: ['#22c55e', '#f59e0b', '#ef4444']) */
+    colors?: string[];
+    /** Needle color (default: '#374151') */
+    needleColor?: string;
+    /** Background arc color (default: '#e5e7eb') */
+    backgroundColor?: string;
+}
+export declare function Gauge(props: GaugeProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/viz/gauge/src/index.d.ts

@@ -0,0 +1,2 @@
+export { Gauge } from './Gauge';
+export type { GaugeProps } from './Gauge';

package/dist/types/components/viz/graph/src/HypercubeGraph.d.ts

@@ -0,0 +1,43 @@
+import { type HypercubeData } from './hypercube';
+export interface HypercubeGraphProps {
+    /** Number of dimensions (default: 4) */
+    dimension?: number;
+    /** SVG width in pixels (default: 600) */
+    width?: number;
+    /** SVG height in pixels (default: 600) */
+    height?: number;
+    /** Vertex radius in pixels (default: 10) */
+    vertexRadius?: number;
+    /** Edge stroke width (default: 3) */
+    edgeWidth?: number;
+    /** Edge color (default: '#111') */
+    edgeColor?: string;
+    /** Array of vertex colors, or 'auto' for generated palette (default: 'auto') */
+    vertexColors?: string[] | 'auto';
+    /** Perspective strength, 0 = orthographic (default: 0.25) */
+    perspective?: number;
+    /** Auto-rotation speed (radians/frame). 0 = no rotation (default: 0.008) */
+    rotationSpeed?: number;
+    /** Whether to show vertex labels (default: false) */
+    showLabels?: boolean;
+    /** Background color (default: 'transparent') */
+    backgroundColor?: string;
+    /** Scale factor (default: auto-fit) */
+    scale?: number;
+}
+export declare function HypercubeGraph(props: HypercubeGraphProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;
+export interface UseHypercubeOptions {
+    dimension?: number;
+    rotationSpeed?: number;
+    perspective?: number;
+    scale?: number;
+}
+/**
+ * Hook that provides hypercube data with auto-animated rotation angles.
+ * Useful for headless rendering or custom SVG layouts.
+ */
+export declare function useHypercube(opts?: UseHypercubeOptions): {
+    data: HypercubeData;
+    angles: number[];
+    setAngles: (action: number[] | ((prev: number[]) => number[])) => void;
+};

package/dist/types/components/viz/graph/src/hypercube.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Hypercube math engine.
+ *
+ * Generates vertices and edges for an N-dimensional hypercube and projects
+ * them to 2D via configurable rotation + orthographic projection.
+ */
+export interface Vec {
+    /** N-dimensional coordinates */
+    coords: number[];
+}
+export interface Vertex {
+    id: number;
+    /** Original N-dimensional position (each coord 0 or 1) */
+    position: Vec;
+    /** Projected 2D position after rotation */
+    x: number;
+    y: number;
+    /** Projected depth for z-ordering */
+    depth: number;
+}
+export interface Edge {
+    source: number;
+    target: number;
+}
+export interface HypercubeData {
+    vertices: Vertex[];
+    edges: Edge[];
+    dimension: number;
+}
+/**
+ * Generate all 2^n vertices of an n-dimensional hypercube.
+ * Each vertex is a binary vector of length n, centered at the origin
+ * (coords mapped from {0,1} to {-1,+1}).
+ */
+export declare function generateVertices(dimension: number): Vec[];
+/**
+ * Generate edges connecting vertices that differ in exactly one coordinate
+ * (Hamming distance 1).
+ */
+export declare function generateEdges(dimension: number): Edge[];
+/**
+ * Build an N×N rotation matrix that applies rotations in each pair of
+ * coordinate planes. `angles` is an array of rotation angles (radians),
+ * one per plane pair: (0,1), (0,2), (1,2), (0,3), (1,3), (2,3), ...
+ */
+export declare function buildRotationMatrix(dimension: number, angles: number[]): number[][];
+/**
+ * Apply an N×N matrix to an N-dimensional vector.
+ */
+export declare function transformVec(matrix: number[][], v: Vec): number[];
+/**
+ * Project an N-dimensional point to 2D using orthographic projection
+ * (just take the first two coordinates) with optional perspective scaling
+ * based on depth (average of remaining coordinates).
+ */
+export declare function projectTo2D(transformed: number[], perspective?: number): {
+    x: number;
+    y: number;
+    depth: number;
+};
+/**
+ * Generate a complete projected hypercube.
+ *
+ * @param dimension   Number of dimensions (2 = square, 3 = cube, 4 = tesseract, ...)
+ * @param angles      Rotation angles for each plane pair
+ * @param perspective Perspective strength (0 = orthographic)
+ * @param scale       Scaling factor for output coordinates
+ */
+export declare function generateHypercube(dimension: number, angles?: number[], perspective?: number, scale?: number): HypercubeData;
+/**
+ * Number of rotation plane-pairs for a given dimension.
+ * This is C(n,2) = n*(n-1)/2.
+ */
+export declare function numRotationAngles(dimension: number): number;
+/**
+ * Generate a palette of distinct colors for vertices.
+ */
+export declare function generatePalette(count: number, saturation?: number, lightness?: number): string[];

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

@@ -0,0 +1,4 @@
+export { HypercubeGraph, useHypercube } from './HypercubeGraph';
+export type { HypercubeGraphProps, UseHypercubeOptions } from './HypercubeGraph';
+export { generateVertices, generateEdges, generateHypercube, buildRotationMatrix, transformVec, projectTo2D, numRotationAngles, generatePalette, } from './hypercube';
+export type { Vec, Vertex, Edge, HypercubeData } from './hypercube';

package/dist/types/components/viz/heat-map/src/HeatMap.d.ts

@@ -0,0 +1,29 @@
+export interface HeatMapProps {
+    /** 2D grid of values — data[row][col] */
+    data: number[][];
+    /** Labels for rows (Y axis) */
+    rowLabels?: string[];
+    /** Labels for columns (X axis) */
+    columnLabels?: string[];
+    /** SVG width in pixels (default: 600) */
+    width?: number;
+    /** SVG height in pixels (default: 400) */
+    height?: number;
+    /** Color gradient from low to high (default: blue to red) */
+    colorScale?: string[];
+    /** Minimum value for color mapping (auto-detected if omitted) */
+    minValue?: number;
+    /** Maximum value for color mapping (auto-detected if omitted) */
+    maxValue?: number;
+    /** Show numeric value in each cell (default: false) */
+    showValues?: boolean;
+    /** Cell border color (default: '#fff') */
+    cellBorderColor?: string;
+    /** Cell border width (default: 1) */
+    cellBorderWidth?: number;
+    /** Chart title */
+    title?: string;
+    /** Padding around the chart in px (default: 60) */
+    padding?: number;
+}
+export declare function HeatMap(props: HeatMapProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/viz/heat-map/src/index.d.ts

@@ -0,0 +1,2 @@
+export { HeatMap } from './HeatMap';
+export type { HeatMapProps } from './HeatMap';

package/dist/types/components/viz/histogram/src/Histogram.d.ts

@@ -0,0 +1,27 @@
+export interface HistogramProps {
+    /** Raw data values to bin */
+    data: number[];
+    /** Number of bins (default: 10) */
+    bins?: number;
+    /** SVG width in pixels (default: 600) */
+    width?: number;
+    /** SVG height in pixels (default: 400) */
+    height?: number;
+    /** Bar fill color (default: '#3b82f6') */
+    barColor?: string;
+    /** Gap between bars in px (default: 2) */
+    barGap?: number;
+    /** Show grid lines (default: true) */
+    showGrid?: boolean;
+    /** Show count values above bars (default: true) */
+    showValues?: boolean;
+    /** Chart title */
+    title?: string;
+    /** X-axis label */
+    xLabel?: string;
+    /** Y-axis label */
+    yLabel?: string;
+    /** Padding around chart area in px (default: 60) */
+    padding?: number;
+}
+export declare function Histogram(props: HistogramProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/viz/histogram/src/index.d.ts

@@ -0,0 +1,2 @@
+export { Histogram } from './Histogram';
+export type { HistogramProps } from './Histogram';

package/dist/types/components/viz/lollipop/src/LollipopChart.d.ts

@@ -0,0 +1,32 @@
+export interface LollipopDatum {
+    label: string;
+    value: number;
+    color?: string;
+}
+export interface LollipopChartProps {
+    /** Data points to render */
+    data: LollipopDatum[];
+    /** SVG width in pixels (default: 600) */
+    width?: number;
+    /** SVG height in pixels (default: 400) */
+    height?: number;
+    /** Chart orientation (default: 'vertical') */
+    orientation?: "horizontal" | "vertical";
+    /** Stem line color (default: '#94a3b8') */
+    stemColor?: string;
+    /** Stem line width in px (default: 2) */
+    stemWidth?: number;
+    /** Dot radius in px (default: 6) */
+    dotRadius?: number;
+    /** Dot fill color (default: '#3b82f6') */
+    dotColor?: string;
+    /** Show grid lines (default: true) */
+    showGrid?: boolean;
+    /** Show value labels (default: true) */
+    showValues?: boolean;
+    /** Chart title */
+    title?: string;
+    /** Padding around chart area in px (default: 60) */
+    padding?: number;
+}
+export declare function LollipopChart(props: LollipopChartProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/viz/lollipop/src/index.d.ts

@@ -0,0 +1,2 @@
+export { LollipopChart } from './LollipopChart';
+export type { LollipopChartProps, LollipopDatum } from './LollipopChart';