drizzle-cube 0.6.0 → 0.6.2

package/dist/cjs/client/components/RowManagedLayout.d.ts

@@ -0,0 +1,19 @@
+import { HTMLAttributes, ReactNode, MouseEvent, DragEvent } from 'react';
+import { DashboardGridSettings, PortletConfig, RowLayout } from '../types.js';
+interface RowManagedLayoutProps {
+    rows: RowLayout[];
+    portlets: PortletConfig[];
+    gridSettings: DashboardGridSettings;
+    gridWidth: number;
+    canEdit: boolean;
+    isDragging: boolean;
+    onRowResize: (rowIndex: number, event: MouseEvent<HTMLDivElement>) => void;
+    onColumnResize: (rowIndex: number, columnIndex: number, event: MouseEvent<HTMLDivElement>) => void;
+    onPortletDragStart: (rowIndex: number, columnIndex: number, portletId: string, event: DragEvent<HTMLDivElement>) => void;
+    onPortletDragEnd: () => void;
+    onRowDrop: (rowIndex: number, insertIndex: number | null) => void;
+    onNewRowDrop: (insertIndex: number) => void;
+    renderPortlet: (portlet: PortletConfig, containerProps?: HTMLAttributes<HTMLDivElement>, headerProps?: HTMLAttributes<HTMLDivElement>) => ReactNode;
+}
+export default function RowManagedLayout({ rows, portlets, gridSettings, gridWidth, canEdit, isDragging, onRowResize, onColumnResize, onPortletDragStart, onPortletDragEnd, onRowDrop, onNewRowDrop, renderPortlet }: RowManagedLayoutProps): import("react").JSX.Element;
+export {};

package/dist/cjs/client/components/ScaledGridWrapper.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+interface ScaledGridWrapperProps {
+    scaleFactor: number;
+    designWidth: number;
+    children: React.ReactNode;
+}
+/**
+ * Wrapper component that scales the grid using CSS transform
+ * Handles height compensation to prevent overflow/whitespace issues
+ */
+export default function ScaledGridWrapper({ scaleFactor, designWidth, children }: ScaledGridWrapperProps): React.JSX.Element;
+export {};

package/dist/cjs/client/components/SchemaVisualization/CubeNode.d.ts

@@ -0,0 +1,25 @@
+import { CubeMetaCube } from '../../types.js';
+interface CubeNodeData {
+    cube: CubeMetaCube;
+    onFieldClick?: (cubeName: string, fieldName: string, fieldType: 'measure' | 'dimension', pos?: {
+        x: number;
+        y: number;
+    }) => void;
+    onCubeClick?: (cubeName: string, pos?: {
+        x: number;
+        y: number;
+    }) => void;
+    isHighlighted: boolean;
+    highlightedFields: string[];
+    searchTerm?: string;
+    selectedField?: {
+        cubeName: string;
+        fieldName: string | null;
+    } | null;
+    [key: string]: unknown;
+}
+interface CubeNodeProps {
+    data: CubeNodeData;
+}
+export declare function CubeNode({ data }: CubeNodeProps): import("react").JSX.Element;
+export {};

package/dist/cjs/client/components/SchemaVisualization/FieldDetailPanel.d.ts

@@ -0,0 +1,15 @@
+import { CubeMetaCube } from '../../types.js';
+export interface FieldSelection {
+    cubeName: string;
+    fieldName: string | null;
+    fieldType: 'measure' | 'dimension' | 'cube';
+}
+interface FieldDetailPanelProps {
+    selection: FieldSelection;
+    meta: {
+        cubes: CubeMetaCube[];
+    };
+    onClose: () => void;
+}
+export declare function FieldDetailPanel({ selection, meta, onClose }: FieldDetailPanelProps): import("react").JSX.Element | null;
+export {};

package/dist/cjs/client/components/SchemaVisualization/RelationshipEdge.d.ts

@@ -0,0 +1,13 @@
+import { Edge, EdgeProps } from '@xyflow/react';
+import { CubeMetaRelationship } from '../../types.js';
+interface RelationshipEdgeData {
+    relationship: CubeMetaRelationship;
+    joinFields: Array<{
+        sourceField: string;
+        targetField: string;
+    }>;
+    [key: string]: unknown;
+}
+export type RelationshipEdgeType = Edge<RelationshipEdgeData, 'relationshipEdge'>;
+export declare function RelationshipEdge({ sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, style, data, markerEnd, }: EdgeProps<RelationshipEdgeType>): import("react").JSX.Element | null;
+export {};

package/dist/cjs/client/components/SchemaVisualization/SchemaVisualizationLazy.d.ts

@@ -0,0 +1,3 @@
+import { SchemaVisualizationProps } from './index.js';
+export declare function SchemaVisualizationLazy(props: SchemaVisualizationProps): import("react").JSX.Element;
+export declare function isSchemaVisualizationAvailable(): boolean;

package/dist/cjs/client/components/SchemaVisualization/index.d.ts

@@ -0,0 +1,10 @@
+export interface SchemaVisualizationProps {
+    className?: string;
+    onFieldClick?: (cubeName: string, fieldName: string, fieldType: 'measure' | 'dimension') => void;
+    highlightedCubes?: string[];
+    highlightedFields?: string[];
+    searchTerm?: string;
+    height?: string | number;
+}
+export declare function SchemaVisualization({ className, onFieldClick, highlightedCubes, highlightedFields, searchTerm, height, }: SchemaVisualizationProps): import("react").JSX.Element;
+export default SchemaVisualization;

package/dist/cjs/client/components/SchemaVisualization/useERDLayout.d.ts

@@ -0,0 +1,39 @@
+import { Node, Edge } from '@xyflow/react';
+export interface LayoutOptions {
+    direction: 'TB' | 'LR';
+    nodeWidth: number;
+    nodeSep: number;
+    rankSep: number;
+}
+export declare const defaultLayoutOptions: LayoutOptions;
+/**
+ * Layout state machine phases:
+ *  waiting   → ELK not loaded yet, nothing to show
+ *  computing → ELK loaded, running layout algorithm
+ *  ready     → layout complete, node positions available
+ */
+export type LayoutPhase = 'waiting' | 'computing' | 'ready';
+interface ELKInstance {
+    layout(graph: unknown): Promise<unknown>;
+}
+declare function loadElk(): Promise<ELKInstance | null>;
+export { loadElk as _elkLoadPromise };
+export interface ElkLayoutResult {
+    nodes: Node[];
+    edges: Edge[];
+}
+/**
+ * Layout hook with explicit state machine.
+ *
+ * - Waits for ELK to load (phase: 'waiting')
+ * - Runs layout once per unique node/edge structure (phase: 'computing')
+ * - Returns stable result (phase: 'ready')
+ *
+ * The effect only depends on a string structure key, NOT object references.
+ * This prevents re-renders from cancelling in-flight computations.
+ */
+export declare function useERDLayout(nodes: Node[], edges: Edge[], options?: Partial<LayoutOptions>): {
+    nodes: Node[];
+    edges: Edge[];
+    phase: LayoutPhase;
+};

package/dist/cjs/client/components/SchemaVisualization/xyflowContext.d.ts

@@ -0,0 +1,11 @@
+/**
+ * React context for @xyflow/react modules.
+ *
+ * All xyflow imports are dynamic (via SchemaVisualizationLazy) so that
+ * the built schema-visualization chunk has NO static imports from
+ * @xyflow/react. This prevents consuming projects from failing at
+ * build time when @xyflow/react is not installed.
+ */
+export type XyflowModule = typeof import('@xyflow/react');
+export declare const XyflowProvider: import('react').Provider<typeof import("@xyflow/react") | null>;
+export declare function useXyflow(): XyflowModule;

package/dist/cjs/client/components/TextPortletModal.d.ts

@@ -0,0 +1,12 @@
+import { PortletConfig } from '../types.js';
+import { ColorPalette } from '../utils/colorPalettes.js';
+interface TextPortletModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onSave: (portlet: PortletConfig | Omit<PortletConfig, 'id' | 'x' | 'y'>) => void;
+    portlet?: PortletConfig | null;
+    colorPalette?: ColorPalette;
+    existingTitles?: string[];
+}
+export default function TextPortletModal({ isOpen, onClose, onSave, portlet, colorPalette, existingTitles, }: TextPortletModalProps): import("react").JSX.Element | null;
+export {};

package/dist/cjs/client/components/analyticsPortlet/PortletChart.d.ts

@@ -0,0 +1,31 @@
+import { ChartAxisConfig, ChartDisplayConfig, ChartType, CubeQuery } from '../../types.js';
+import { FlowChartData } from '../../types/flow.js';
+import { RetentionChartData } from '../../types/retention.js';
+import { ColorPalette } from '../../utils/colorPalettes.js';
+type Height = string | number;
+interface ResultSetLike {
+    tablePivot: () => unknown;
+    rawData: () => unknown;
+}
+export interface PortletChartProps {
+    chartType: ChartType;
+    height: Height;
+    shouldSkipQuery: boolean;
+    isMultiQuery: boolean;
+    isFunnelMode: boolean;
+    isFlowMode: boolean;
+    isRetentionMode: boolean;
+    resultSet: ResultSetLike | null;
+    multiQueryData: unknown[] | null;
+    flowChartData: FlowChartData | null;
+    retentionChartData: RetentionChartData | null;
+    chartConfig?: ChartAxisConfig;
+    displayConfig?: ChartDisplayConfig;
+    activeQuery: CubeQuery | null;
+    colorPalette?: ColorPalette;
+    drillEnabled: boolean;
+    currentChartConfig?: ChartAxisConfig | null;
+    onDataPointClick?: (...args: any[]) => void;
+}
+export declare function PortletChart(props: PortletChartProps): import("react").JSX.Element;
+export {};

package/dist/cjs/client/components/analyticsPortlet/PortletChartView.d.ts

@@ -0,0 +1,35 @@
+import { ChartAxisConfig, ChartDisplayConfig, ChartType, CubeQuery } from '../../types.js';
+import { FlowChartData } from '../../types/flow.js';
+import { RetentionChartData } from '../../types/retention.js';
+import { ColorPalette } from '../../utils/colorPalettes.js';
+import { DrillInteraction } from '../../types/drill.js';
+type Height = string | number;
+interface ResultSetLike {
+    tablePivot: () => unknown;
+    rawData: () => unknown;
+}
+export interface PortletChartViewProps {
+    title?: string;
+    query: string;
+    chartType: ChartType;
+    height: Height;
+    chartConfig?: ChartAxisConfig;
+    displayConfig?: ChartDisplayConfig;
+    colorPalette?: ColorPalette;
+    shouldSkipQuery: boolean;
+    isMultiQuery: boolean;
+    isFunnelMode: boolean;
+    isFlowMode: boolean;
+    isRetentionMode: boolean;
+    resultSet: ResultSetLike | null;
+    multiQueryData: unknown[] | null;
+    flowChartData: FlowChartData | null;
+    retentionChartData: RetentionChartData | null;
+    activeQuery: CubeQuery | null;
+    drill: DrillInteraction;
+    isDrillEnabled: boolean;
+    onNavigateBack: () => void;
+    onNavigateToLevel: (index: number) => void;
+}
+export declare function PortletChartView(props: PortletChartViewProps): import("react").JSX.Element;
+export {};

package/dist/cjs/client/components/analyticsPortlet/PortletStates.d.ts

@@ -0,0 +1,65 @@
+import { ReactNode, Ref } from 'react';
+import { ChartType } from '../../types.js';
+import { DrillPathEntry } from '../../types/drill.js';
+type Height = string | number;
+export declare function PortletConfigRequired({ inViewRef, height }: {
+    inViewRef: Ref<HTMLDivElement>;
+    height: Height;
+}): import("react").JSX.Element;
+export declare function PortletLazyPlaceholder({ inViewRef, height }: {
+    inViewRef: Ref<HTMLDivElement>;
+    height: Height;
+}): import("react").JSX.Element;
+export declare function PortletLoading({ inViewRef, height, loadingComponent }: {
+    inViewRef: Ref<HTMLDivElement>;
+    height: Height;
+    loadingComponent?: ReactNode;
+}): import("react").JSX.Element;
+interface PortletErrorProps {
+    inViewRef: Ref<HTMLDivElement>;
+    height: Height;
+    error: {
+        message?: string;
+        toString: () => string;
+    };
+    onRetry: () => void;
+    activeQuery: unknown;
+    query: string;
+    chartType: ChartType;
+    chartConfig: unknown;
+    displayConfig: unknown;
+}
+export declare function PortletError({ inViewRef, height, error, onRetry, activeQuery, query, chartType, chartConfig, displayConfig }: PortletErrorProps): import("react").JSX.Element;
+interface PortletNoDataProps {
+    inViewRef: Ref<HTMLDivElement>;
+    height: Height;
+    drillPath: DrillPathEntry[];
+    onNavigateBack: () => void;
+    onNavigateToLevel: (index: number) => void;
+}
+export declare function PortletNoData({ inViewRef, height, drillPath, onNavigateBack, onNavigateToLevel }: PortletNoDataProps): import("react").JSX.Element;
+export type PortletStateKind = 'config-required' | 'lazy-placeholder' | 'loading' | 'error';
+interface PortletStateViewProps {
+    kind: PortletStateKind | 'no-data';
+    inViewRef: Ref<HTMLDivElement>;
+    height: Height;
+    loadingComponent?: ReactNode;
+    error: {
+        message?: string;
+        toString: () => string;
+    } | null;
+    onRetry: () => void;
+    activeQuery: unknown;
+    query: string;
+    chartType: ChartType;
+    chartConfig: unknown;
+    displayConfig: unknown;
+    drillPath: DrillPathEntry[];
+    onNavigateBack: () => void;
+    onNavigateToLevel: (index: number) => void;
+}
+/**
+ * Renders the appropriate non-chart state view for the given render kind.
+ */
+export declare function PortletStateView(props: PortletStateViewProps): import("react").JSX.Element;
+export {};

package/dist/cjs/client/components/analyticsPortlet/parsePortletQuery.d.ts

@@ -0,0 +1,22 @@
+import { CubeQuery, DashboardFilter, DashboardFilterMapping, MultiQueryConfig, ServerFunnelQuery } from '../../types.js';
+import { ServerFlowQuery } from '../../types/flow.js';
+import { ServerRetentionQuery } from '../../types/retention.js';
+export interface ParsedPortletQuery {
+    queryObject: CubeQuery | null;
+    multiQueryConfig: MultiQueryConfig | null;
+    serverFunnelQuery: ServerFunnelQuery | null;
+    serverFlowQuery: ServerFlowQuery | null;
+    serverRetentionQuery: ServerRetentionQuery | null;
+}
+export interface ParsePortletQueryParams {
+    query: string;
+    shouldSkipQuery: boolean;
+    regularFilters?: DashboardFilter[];
+    dashboardFilters?: DashboardFilter[];
+    dashboardFilterMapping?: DashboardFilterMapping;
+}
+/**
+ * Parse the portlet query string and merge applicable dashboard filters.
+ * Returns a discriminated set of possible query shapes (only one non-null).
+ */
+export declare function parsePortletQuery(params: ParsePortletQueryParams): ParsedPortletQuery;

package/dist/cjs/client/components/analyticsPortlet/portletRenderState.d.ts

@@ -0,0 +1,31 @@
+import { FlowChartData, ServerFlowQuery } from '../../types/flow.js';
+import { RetentionChartData, ServerRetentionQuery } from '../../types/retention.js';
+import { CubeQuery, MultiQueryConfig, ServerFunnelQuery } from '../../types.js';
+export type PortletRenderKind = 'config-required' | 'lazy-placeholder' | 'loading' | 'error' | 'no-data' | 'chart';
+export interface PortletRenderStateParams {
+    hasChartConfig: boolean;
+    hasMandatoryFields: boolean;
+    shouldSkipQuery: boolean;
+    eagerLoad: boolean;
+    isVisible: boolean;
+    isLoading: boolean;
+    isFetching: boolean;
+    error: unknown;
+    isMultiQuery: boolean;
+    isFunnelMode: boolean;
+    isFlowMode: boolean;
+    isRetentionMode: boolean;
+    queryObject: CubeQuery | null;
+    multiQueryConfig: MultiQueryConfig | null;
+    serverFunnelQuery: ServerFunnelQuery | null;
+    serverFlowQuery: ServerFlowQuery | null;
+    serverRetentionQuery: ServerRetentionQuery | null;
+    resultSet: unknown;
+    multiQueryData: unknown[] | null;
+    flowChartData: FlowChartData | null;
+    retentionChartData: RetentionChartData | null;
+}
+/**
+ * Resolve which view the portlet should render.
+ */
+export declare function resolvePortletRenderKind(p: PortletRenderStateParams): PortletRenderKind;

package/dist/cjs/client/components/analyticsPortlet/usePortletDebugData.d.ts

@@ -0,0 +1,37 @@
+import { AnalyticsPortletProps, ChartAxisConfig, ChartDisplayConfig, ChartType, CubeQuery, ServerFunnelQuery } from '../../types.js';
+import { FlowChartData, ServerFlowQuery } from '../../types/flow.js';
+import { RetentionChartData, ServerRetentionQuery } from '../../types/retention.js';
+import { DrillPathEntry } from '../../types/drill.js';
+type DebugEntry = Parameters<NonNullable<AnalyticsPortletProps['onDebugDataReady']>>[0];
+type CacheInfo = DebugEntry['cacheInfo'];
+interface ResultSetLike {
+    tablePivot: () => unknown;
+    rawData: () => unknown;
+    cacheInfo?: () => CacheInfo;
+}
+export interface UsePortletDebugDataParams {
+    onDebugDataReady?: AnalyticsPortletProps['onDebugDataReady'];
+    error: unknown;
+    chartType: ChartType;
+    chartConfig?: ChartAxisConfig;
+    displayConfig?: ChartDisplayConfig;
+    isFunnelMode: boolean;
+    isFlowMode: boolean;
+    isRetentionMode: boolean;
+    queryObject: CubeQuery | null;
+    activeQuery: CubeQuery | null;
+    serverFunnelQuery: ServerFunnelQuery | null;
+    serverFlowQuery: ServerFlowQuery | null;
+    serverRetentionQuery: ServerRetentionQuery | null;
+    resultSet: ResultSetLike | null;
+    multiQueryData: unknown[] | null;
+    flowChartData: FlowChartData | null;
+    retentionChartData: RetentionChartData | null;
+    funnelCacheInfo?: CacheInfo;
+    flowCacheInfo?: CacheInfo;
+    retentionCacheInfo?: CacheInfo;
+    drillPath: DrillPathEntry[];
+    currentChartConfig?: ChartAxisConfig | null;
+}
+export declare function usePortletDebugData(params: UsePortletDebugDataParams): void;
+export {};

package/dist/cjs/client/components/analyticsPortlet/usePortletDrillState.d.ts

@@ -0,0 +1,17 @@
+import { ChartAxisConfig, CubeQuery, DashboardFilter, DashboardFilterMapping } from '../../types.js';
+export interface UsePortletDrillStateParams {
+    queryObject: CubeQuery | null;
+    chartConfig?: ChartAxisConfig;
+    dashboardFilters?: DashboardFilter[];
+    dashboardFilterMapping?: DashboardFilterMapping;
+    isMultiQuery: boolean;
+    isFunnelMode: boolean;
+    isFlowMode: boolean;
+    isRetentionMode: boolean;
+}
+export declare function usePortletDrillState(params: UsePortletDrillStateParams): {
+    drill: import('../../types.js').DrillInteraction;
+    activeQuery: CubeQuery | null;
+    handleNavigateBack: () => void;
+    handleNavigateToLevel: (index: number) => void;
+};

package/dist/cjs/client/components/analyticsPortlet/usePortletQueryResults.d.ts

@@ -0,0 +1,37 @@
+import { useCubeLoadQuery, useFunnelQuery, useFlowQuery, useRetentionQuery } from '../../hooks/queries/index.js';
+import { CubeQuery, MultiQueryConfig, ServerFunnelQuery } from '../../types.js';
+import { FlowChartData, ServerFlowQuery } from '../../types/flow.js';
+import { RetentionChartData, ServerRetentionQuery } from '../../types/retention.js';
+interface RefreshOptions {
+    bustCache?: boolean;
+}
+export interface UsePortletQueryResultsParams {
+    activeQuery: CubeQuery | null;
+    multiQueryConfig: MultiQueryConfig | null;
+    serverFunnelQuery: ServerFunnelQuery | null;
+    serverFlowQuery: ServerFlowQuery | null;
+    serverRetentionQuery: ServerRetentionQuery | null;
+    isMultiQuery: boolean;
+    isFunnelMode: boolean;
+    isFlowMode: boolean;
+    isRetentionMode: boolean;
+    shouldSkipQuery: boolean;
+    eagerLoad: boolean;
+    isVisible: boolean;
+}
+export interface PortletQueryResults {
+    resultSet: ReturnType<typeof useCubeLoadQuery>['resultSet'];
+    isLoading: boolean;
+    isFetching: boolean;
+    error: unknown;
+    multiQueryData: unknown[] | null;
+    flowChartData: FlowChartData | null;
+    retentionChartData: RetentionChartData | null;
+    funnelCacheInfo: ReturnType<typeof useFunnelQuery>['cacheInfo'];
+    flowCacheInfo: ReturnType<typeof useFlowQuery>['cacheInfo'];
+    retentionCacheInfo: ReturnType<typeof useRetentionQuery>['cacheInfo'];
+    refresh: (options?: RefreshOptions) => void;
+    retry: () => void;
+}
+export declare function usePortletQueryResults(params: UsePortletQueryResultsParams): PortletQueryResults;
+export {};

package/dist/cjs/client/components/charts/ActivityGridChart.config.d.ts

@@ -0,0 +1,5 @@
+import { ChartTypeConfig } from '../../charts/chartConfigs.js';
+/**
+ * Configuration for the activity grid chart type
+ */
+export declare const activityGridChartConfig: ChartTypeConfig;

package/dist/cjs/client/components/charts/ActivityGridChart.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { ChartProps } from '../../types.js';
+declare const ActivityGridChart: React.NamedExoticComponent<ChartProps>;
+export default ActivityGridChart;

package/dist/cjs/client/components/charts/ActivityGridChart.helpers.d.ts

@@ -0,0 +1,33 @@
+import { CubeQuery } from '../../types.js';
+export interface GridCell {
+    x: number;
+    y: number;
+    value: number;
+    date: Date;
+    label: string;
+}
+export interface GridMapping {
+    extractX: (date: Date) => number;
+    extractY: (date: Date) => number;
+    xLabels: string[];
+    yLabels: string[];
+    xFormat: (value: number) => string;
+    yFormat: (value: number) => string;
+    cellWidth: number;
+    cellHeight: number;
+    hasHierarchicalLabels?: boolean;
+    getYearFromX?: (value: number) => number;
+}
+/** Week-of-year (1-53) with the ISO-aligned year for the given date. */
+export declare function getWeekOfYear(date: Date): {
+    year: number;
+    week: number;
+};
+/** Get the grid coordinate mapping for a granularity (null when unsupported). */
+export declare function getGridMapping(granularity: string): GridMapping | null;
+/** Resolve the first matching field (string | array) for a date config value. */
+export declare function firstDateField(value: string | string[] | undefined): string | undefined;
+/** Get the query granularity for the date field, falling back to 'day'. */
+export declare function getQueryGranularity(queryObject: CubeQuery | undefined, dateField: string): string;
+/** Transform query rows into grid cells, skipping invalid dates. */
+export declare function buildGridData(data: Record<string, any>[], dateField: string, valueField: string, gridMapping: GridMapping, granularity: string): GridCell[];

package/dist/cjs/client/components/charts/ActivityGridChart.render.d.ts

@@ -0,0 +1,31 @@
+import { GridCell, GridMapping } from './ActivityGridChart.helpers.js';
+import { ColorPalette } from '../../types.js';
+import { ChartDataPointClickEvent } from '../../types/drill.js';
+export interface ActivityGridSafeConfig {
+    showTooltip: boolean;
+    showLabels: boolean;
+    fitToWidth: boolean;
+}
+export interface ActivityGridRenderContext {
+    svgEl: SVGSVGElement;
+    gridData: GridCell[];
+    gridMapping: GridMapping;
+    granularity: string;
+    dimensions: {
+        width: number;
+        height: number;
+    };
+    safeDisplayConfig: ActivityGridSafeConfig;
+    colorPalette?: ColorPalette;
+    isDark: boolean;
+    valueField: string;
+    dateField: string;
+    getFieldLabel: (field: string) => string;
+    drillEnabled?: boolean;
+    onDataPointClick?: (event: ChartDataPointClickEvent) => void;
+}
+/**
+ * Render the activity grid into the given SVG element. Returns a cleanup
+ * function removing the tooltip, or undefined when there is nothing to draw.
+ */
+export declare function renderActivityGrid(ctx: ActivityGridRenderContext): (() => void) | undefined;

package/dist/cjs/client/components/charts/AngledXAxisTick.d.ts

@@ -0,0 +1,19 @@
+import { default as React } from 'react';
+interface AngledXAxisTickProps {
+    x?: number;
+    y?: number;
+    payload?: {
+        value: string | number;
+    };
+    tickFormatter?: (value: string | number, index: number) => string;
+    index?: number;
+    visibleTicksCount?: number;
+    [key: string]: unknown;
+}
+/**
+ * Custom XAxis tick component for properly aligned angled labels.
+ * Fixes alignment issues in recharts 3.7+ where angled labels don't
+ * center properly under data points.
+ */
+declare const AngledXAxisTick: React.FC<AngledXAxisTickProps>;
+export default AngledXAxisTick;

package/dist/cjs/client/components/charts/AreaChart.config.d.ts

@@ -0,0 +1,5 @@
+import { ChartTypeConfig } from '../../charts/chartConfigs.js';
+/**
+ * Configuration for the area chart type
+ */
+export declare const areaChartConfig: ChartTypeConfig;

package/dist/cjs/client/components/charts/AreaChart.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { ChartProps } from '../../types.js';
+declare const AreaChart: React.NamedExoticComponent<ChartProps>;
+export default AreaChart;

package/dist/cjs/client/components/charts/AxisFormatControls.d.ts

@@ -0,0 +1,37 @@
+import { AxisFormatConfig } from '../../types.js';
+interface AxisFormatControlsProps {
+    value: AxisFormatConfig;
+    onChange: (config: AxisFormatConfig) => void;
+    axisLabel: string;
+    /** Sample value for preview (default: 1250000) */
+    previewValue?: number;
+}
+/**
+ * Single axis format control section
+ */
+export declare function AxisFormatControls({ value, onChange, axisLabel, previewValue }: AxisFormatControlsProps): import("react").JSX.Element;
+interface MultiAxisFormatControlsProps {
+    displayConfig: {
+        xAxisFormat?: AxisFormatConfig;
+        leftYAxisFormat?: AxisFormatConfig;
+        rightYAxisFormat?: AxisFormatConfig;
+    };
+    onChange: (updates: {
+        xAxisFormat?: AxisFormatConfig;
+        leftYAxisFormat?: AxisFormatConfig;
+        rightYAxisFormat?: AxisFormatConfig;
+    }) => void;
+    /** Which axes to show controls for */
+    showAxes?: {
+        xAxis?: boolean;
+        leftYAxis?: boolean;
+        rightYAxis?: boolean;
+    };
+}
+/**
+ * Container component for multiple axis format controls. Each configured axis
+ * renders an `AxisFormatControls`; the per-axis entries are data-driven so the
+ * three branches collapse into a single map.
+ */
+export declare function MultiAxisFormatControls({ displayConfig, onChange, showAxes }: MultiAxisFormatControlsProps): import("react").JSX.Element;
+export default AxisFormatControls;

package/dist/cjs/client/components/charts/BarChart.config.d.ts

@@ -0,0 +1,5 @@
+import { ChartTypeConfig } from '../../charts/chartConfigs.js';
+/**
+ * Configuration for the bar chart type
+ */
+export declare const barChartConfig: ChartTypeConfig;

package/dist/cjs/client/components/charts/BarChart.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { ChartProps } from '../../types.js';
+declare const BarChart: React.NamedExoticComponent<ChartProps>;
+export default BarChart;

package/dist/cjs/client/components/charts/BarChart.helpers.d.ts

@@ -0,0 +1,23 @@
+import { ChartDisplayConfig } from '../../types.js';
+export interface StackMode {
+    shouldStack: boolean;
+    isPercentStack: boolean;
+}
+/** Derive stacking flags from `stackType` (new) or `stacked` (legacy). */
+export declare function resolveStackMode(displayConfig: ChartDisplayConfig | undefined): StackMode;
+/**
+ * Filter out rows where every series value is null, returning the kept rows and
+ * the number skipped (used to render the "N hidden" footer note).
+ */
+export declare function filterEmptyRows(transformedData: Record<string, any>[], seriesKeys: string[]): {
+    chartData: Record<string, any>[];
+    skippedCount: number;
+};
+export interface BarColoringMode {
+    /** Single series with mixed positive/negative values → green/red bars. */
+    usePositiveNegativeColoring: boolean;
+    /** Single measure, no series dimension, multiple categories → colour per category. */
+    useColorByCategory: boolean;
+}
+/** Decide which special per-bar colouring mode (if any) applies. */
+export declare function resolveBarColoringMode(seriesKeys: string[], chartData: Record<string, any>[], seriesFieldsLength: number): BarColoringMode;