drizzle-cube 0.6.1 → 0.6.2

package/dist/cjs/client/components/AnalysisBuilder/utils/axisConfigUtils.d.ts

@@ -0,0 +1,23 @@
+import { ChartAxisConfig } from '../../../types.js';
+interface DropZoneShape {
+    key: string;
+    maxItems?: number;
+    enableDualAxis?: boolean;
+}
+/**
+ * Compute the new config after dropping `field` onto `toAxis` (optionally moving
+ * it from `fromAxis`). Applies the default left/right yAxisAssignment for dual-axis
+ * drop zones.
+ */
+export declare function applyAxisDrop(chartConfig: ChartAxisConfig, field: string, fromAxis: string, toAxis: string, dropZoneConfig: DropZoneShape | undefined): ChartAxisConfig;
+/**
+ * Compute the new config after removing `field` from `fromAxis`, cleaning up any
+ * yAxisAssignment entry.
+ */
+export declare function applyAxisRemove(chartConfig: ChartAxisConfig, field: string, fromAxis: string): ChartAxisConfig;
+/**
+ * Compute the new config after reordering items within `axisKey`. Returns null
+ * when no reorder is applicable (non-array, single item, or no-op move).
+ */
+export declare function applyAxisReorder(chartConfig: ChartAxisConfig, fromIndex: number, toIndex: number, axisKey: string): ChartAxisConfig | null;
+export {};

package/dist/cjs/client/components/AnalysisBuilder/utils/executionPlanMarkdown.d.ts

@@ -0,0 +1,8 @@
+import { CubeQuery } from '../../../types.js';
+import { QueryAnalysis } from '../../../shared/types.js';
+/**
+ * Generate markdown representation of query execution plan.
+ */
+export declare function generateExecutionPlanMarkdown(analysis: QueryAnalysis, query: CubeQuery | null, sql?: {
+    sql: string;
+} | null): string;

package/dist/cjs/client/components/AnalysisBuilder/utils/fieldUtils.d.ts

@@ -0,0 +1,69 @@
+import { FieldOption, FieldType } from '../types.js';
+import { MetaResponse, MetaField } from '../../../shared/types.js';
+/**
+ * Get cube name from a field name (e.g., "Employees.count" -> "Employees")
+ */
+export declare function getCubeNameFromField(fieldName: string): string;
+/**
+ * Get field short name from full name (e.g., "Employees.count" -> "count")
+ */
+export declare function getFieldShortName(fieldName: string): string;
+/**
+ * Find field metadata from schema
+ */
+export declare function findFieldInSchema(fieldName: string, schema: MetaResponse | null): {
+    field: MetaField;
+    cubeName: string;
+    fieldType: FieldType;
+} | null;
+/**
+ * Get display title for a field
+ */
+export declare function getFieldTitle(fieldName: string, schema: MetaResponse | null): string;
+/**
+ * Determine field type from metadata
+ */
+export declare function getFieldType(field: MetaField): FieldType;
+/**
+ * Convert schema to flat list of field options
+ *
+ * - 'metrics': measures only
+ * - 'breakdown' / 'dimensionFilter': dimensions only ('dimensionFilter' is used
+ *   for funnel step filters where measures don't work)
+ * - 'filter': both measures and dimensions
+ */
+export declare function schemaToFieldOptions(schema: MetaResponse | null, mode: 'metrics' | 'breakdown' | 'filter' | 'dimensionFilter'): FieldOption[];
+/**
+ * Filter field options by search term
+ */
+export declare function filterFieldOptions(options: FieldOption[], searchTerm: string, selectedCube?: string | null): FieldOption[];
+/**
+ * Group field options by cube
+ */
+export declare function groupFieldsByCube(options: FieldOption[]): Map<string, FieldOption[]>;
+/**
+ * Get list of cube names from schema
+ */
+export declare function getCubeNames(schema: MetaResponse | null): string[];
+/**
+ * Get cube title by name
+ */
+export declare function getCubeTitle(cubeName: string, schema: MetaResponse | null): string;
+/**
+ * Get all cubes reachable from a source cube via join relationships
+ * Includes the source cube itself plus all cubes it has joins to
+ *
+ * @param sourceCube - Name of the cube to find related cubes for
+ * @param schema - Full schema with all cubes
+ * @returns Set of cube names that are reachable from the source
+ */
+export declare function getRelatedCubeNames(sourceCube: string, schema: MetaResponse | null): Set<string>;
+/**
+ * Filter schema to include only cubes reachable from a source cube
+ * This is used for funnel step filters where cross-cube filtering is supported
+ *
+ * @param sourceCube - Name of the cube to find related cubes for
+ * @param schema - Full schema with all cubes
+ * @returns Filtered schema containing only reachable cubes
+ */
+export declare function getRelatedCubesSchema(sourceCube: string, schema: MetaResponse | null): MetaResponse | null;

package/dist/cjs/client/components/AnalysisBuilder/utils/filterUtils.d.ts

@@ -0,0 +1,19 @@
+import { Filter } from '../../../types.js';
+/**
+ * Find date filter for a specific time dimension field
+ * Recursively searches filters (including nested and/or groups)
+ * Handles both UI format ({type: 'and'/'or', filters: [...]}) and simple filters
+ */
+export declare function findDateFilterForField(filters: Filter[], field: string): {
+    dateRange: string | string[];
+} | undefined;
+/**
+ * Build compareDateRange for a time dimension based on its date filter
+ * When comparison is enabled, returns [[currentStart, currentEnd], [priorStart, priorEnd]]
+ */
+export declare function buildCompareDateRangeFromFilter(timeDimensionField: string, filters: Filter[]): [string, string][] | undefined;
+/**
+ * Remove date filter for a specific field from filters array
+ * Returns a new array with the filter removed (immutable)
+ */
+export declare function removeComparisonDateFilter(filters: Filter[], field: string): Filter[];

package/dist/cjs/client/components/AnalysisBuilder/utils/idUtils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * ID Generation Utilities for AnalysisBuilder
+ */
+/**
+ * Generate a unique ID for items
+ */
+export declare function generateId(): string;
+/**
+ * Generate letter label for metrics (A, B, C, ..., AA, AB, ...)
+ */
+export declare function generateMetricLabel(index: number): string;

package/dist/cjs/client/components/AnalysisBuilder/utils/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * AnalysisBuilder Utilities - Barrel Export
+ *
+ * Re-exports all utility functions for convenient imports.
+ */
+export { generateId, generateMetricLabel } from './idUtils.js';
+export { findDateFilterForField, buildCompareDateRangeFromFilter, removeComparisonDateFilter } from './filterUtils.js';
+export { buildCubeQuery, hasQueryContent } from './queryUtils.js';
+export { STORAGE_KEY, createInitialState, loadInitialStateFromStorage, saveStateToStorage, loadStateFromStorage, clearStateFromStorage } from './storageUtils.js';
+export { getCubeNameFromField, getFieldShortName, findFieldInSchema, getFieldTitle, getFieldType, schemaToFieldOptions, filterFieldOptions, groupFieldsByCube, getCubeNames, getCubeTitle } from './fieldUtils.js';
+export { getRecentFields, addRecentField, getRecentFieldOptions } from './recentFieldsUtils.js';

package/dist/cjs/client/components/AnalysisBuilder/utils/queryUtils.d.ts

@@ -0,0 +1,11 @@
+import { CubeQuery, Filter } from '../../../types.js';
+import { MetricItem, BreakdownItem } from '../types.js';
+/**
+ * Convert metrics and breakdowns to CubeQuery format
+ * Handles comparison mode by building compareDateRange for time dimensions
+ */
+export declare function buildCubeQuery(metrics: MetricItem[], breakdowns: BreakdownItem[], filters: Filter[], order?: Record<string, 'asc' | 'desc'>, preserveComparisonFilters?: boolean, limit?: number): CubeQuery;
+/**
+ * Check if a query has any content
+ */
+export declare function hasQueryContent(metrics: MetricItem[], breakdowns: BreakdownItem[], filters: Filter[]): boolean;

package/dist/cjs/client/components/AnalysisBuilder/utils/recentFieldsUtils.d.ts

@@ -0,0 +1,14 @@
+import { FieldOption, RecentFieldsStorage } from '../types.js';
+import { MetaResponse } from '../../../shared/types.js';
+/**
+ * Get recent fields from localStorage
+ */
+export declare function getRecentFields(): RecentFieldsStorage;
+/**
+ * Add a field to recent fields
+ */
+export declare function addRecentField(fieldName: string, mode: 'metrics' | 'breakdowns'): void;
+/**
+ * Get recent field options from schema
+ */
+export declare function getRecentFieldOptions(schema: MetaResponse | null, mode: 'metrics' | 'breakdown' | 'filter' | 'dimensionFilter', recentFieldNames: string[]): FieldOption[];

package/dist/cjs/client/components/AnalysisBuilder/utils/resultsPanelDerive.d.ts

@@ -0,0 +1,68 @@
+/**
+ * resultsPanelDerive
+ *
+ * Small pure helpers for AnalysisResultsPanel derived values, extracted to keep
+ * the component body flat. Behaviour is identical to the previous inline logic.
+ */
+export interface DebugDataEntry {
+    sql: unknown;
+    analysis: unknown;
+    mode: unknown;
+    queryType: unknown;
+    joinType: unknown;
+    cubesUsed: unknown[];
+    modeMetadata: unknown;
+    loading: boolean;
+    error: unknown;
+}
+/**
+ * Resolve the active debug entry, falling back to an empty placeholder.
+ * The fallback is cast to the element type so callers keep their precise typing.
+ */
+export declare function resolveDebugData<T>(debugDataPerQuery: T[], activeDebugIndex: number): T;
+interface ChartViewParams {
+    isCurrentChartRenderable: boolean;
+    isFlowMode: boolean;
+    isFunnelMode: boolean;
+    isRetentionMode: boolean;
+}
+/** Whether the chart view toggle should be enabled. */
+export declare function isChartViewEnabled({ isCurrentChartRenderable, isFlowMode, isFunnelMode, isRetentionMode }: ChartViewParams): boolean;
+/**
+ * Whether the panel has meaningful results to display, accounting for the
+ * different data shapes per analysis mode.
+ */
+export declare function computeHasResults(executionResults: unknown[] | null | undefined, isFlowMode: boolean, isRetentionMode: boolean, retentionChartData: {
+    rows: unknown[];
+} | null | undefined): boolean;
+interface TableSelectionParams<Q, R> {
+    tableIndex: number | undefined;
+    isMultiQuery: unknown;
+    allQueries: Q[] | null | undefined;
+    perQueryResults: R[] | null | undefined;
+    executionResults: R | null | undefined;
+    combinedQueryForChart: Q | undefined;
+}
+/**
+ * Resolve the data + query object for a table view given the requested index.
+ * tableIndex: undefined = single query, -1 = merged view, 0+ = per-query view.
+ */
+export declare function selectTableData<Q, R>({ tableIndex, isMultiQuery, allQueries, perQueryResults, executionResults, combinedQueryForChart }: TableSelectionParams<Q, R>): {
+    tableData: R | null;
+    tableQuery: Q | undefined;
+};
+/**
+ * Resolve the display source/target event names for a flow Sankey link, handling
+ * both transformed (`source`/`target`) and raw (`source_id`/`target_id`) shapes.
+ */
+export declare function flowLinkNames(link: Record<string, unknown>): {
+    sourceName: string;
+    targetName: string;
+};
+/**
+ * Multi-query mode (but NOT funnel mode — funnels always show unified results).
+ */
+export declare function computeIsMultiQuery(isFunnelMode: boolean, queryCount: number, perQueryResults: unknown[] | null | undefined): boolean;
+/** Title/tooltip for the chart view toggle button. */
+export declare function chartViewButtonTitle(chartViewEnabled: boolean, chartViewUnavailableReason: string | undefined, t: (key: string) => string): string;
+export {};

package/dist/cjs/client/components/AnalysisBuilder/utils/shareStateUtils.d.ts

@@ -0,0 +1,68 @@
+import { AnalysisConfig } from '../../../types/analysisConfig.js';
+/**
+ * Extract funnel initial state from a shared AnalysisConfig.
+ *
+ * Phase 3: funnel config is in query.funnel, chart config is in charts.funnel.
+ */
+export declare function extractFunnelStateFromShare(sharedState: AnalysisConfig | null): {
+    funnelCube: null;
+    funnelSteps: never[];
+    funnelTimeDimension: string | null;
+    funnelBindingKey: {
+        dimension: string | {
+            cube: string;
+            dimension: string;
+        }[];
+    } | null;
+    funnelChartType: import('../../../types.js').ChartType;
+    funnelChartConfig: import('../../../types.js').ChartAxisConfig;
+    funnelDisplayConfig: import('../../../types.js').ChartDisplayConfig;
+} | undefined;
+/**
+ * Extract flow initial state from a shared AnalysisConfig.
+ */
+export declare function extractFlowStateFromShare(sharedState: AnalysisConfig | null): {
+    flowCube: null;
+    flowBindingKey: {
+        dimension: string;
+    } | null;
+    flowTimeDimension: string | null;
+    startingStep: {
+        name: string;
+        filters: import('../../../types.js').Filter[];
+    };
+    stepsBefore: number;
+    stepsAfter: number;
+    eventDimension: string | null;
+    flowChartType: import('../../../types.js').ChartType;
+    flowChartConfig: import('../../../types.js').ChartAxisConfig;
+    flowDisplayConfig: import('../../../types.js').ChartDisplayConfig;
+} | undefined;
+/**
+ * Extract retention initial state from a shared AnalysisConfig.
+ */
+export declare function extractRetentionStateFromShare(sharedState: AnalysisConfig | null): {
+    retentionCube: null;
+    retentionBindingKey: {
+        dimension: string;
+    } | {
+        dimension: {
+            cube: string;
+            dimension: string;
+        }[];
+    } | null;
+    retentionTimeDimension: string | null;
+    retentionDateRange: import('../../../types/retention.js').DateRange;
+    retentionCohortFilters: import('../../../types.js').Filter[];
+    retentionActivityFilters: import('../../../types.js').Filter[];
+    retentionBreakdowns: {
+        field: string;
+        label: string;
+    }[];
+    retentionViewGranularity: import('../../../types/retention.js').RetentionGranularity;
+    retentionPeriods: number;
+    retentionType: import('../../../types/retention.js').RetentionType;
+    retentionChartType: import('../../../types.js').ChartType;
+    retentionChartConfig: import('../../../types.js').ChartAxisConfig;
+    retentionDisplayConfig: import('../../../types.js').ChartDisplayConfig;
+} | undefined;

package/dist/cjs/client/components/AnalysisBuilder/utils/sortUtils.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Sort direction cycle helper shared by query section components.
+ */
+/**
+ * Get next sort direction in the cycle: null -> asc -> desc -> null
+ */
+export declare function getNextSortDirection(current: 'asc' | 'desc' | null): 'asc' | 'desc' | null;

package/dist/cjs/client/components/AnalysisBuilder/utils/storageUtils.d.ts

@@ -0,0 +1,44 @@
+import { Filter } from '../../../types.js';
+import { MetricItem, BreakdownItem, AnalysisBuilderState, AnalysisBuilderStorageState } from '../types.js';
+export declare const STORAGE_KEY = "drizzle-cube-analysis-builder-v3";
+/** @deprecated Use STORAGE_KEY instead */
+export declare const STORAGE_KEY_V2 = "drizzle-cube-analysis-builder-v2";
+/**
+ * Create initial empty state for AnalysisBuilder
+ *
+ * Note: Only client-side configuration state is stored.
+ * Server state (execution results, loading, errors) is managed by TanStack Query.
+ */
+export declare function createInitialState(): AnalysisBuilderState;
+/**
+ * Load all state from localStorage once (to avoid repeated parsing)
+ */
+export declare function loadInitialStateFromStorage(disableLocalStorage: boolean): AnalysisBuilderStorageState | null;
+/**
+ * Save state to localStorage
+ */
+export declare function saveStateToStorage(state: {
+    metrics: MetricItem[];
+    breakdowns: BreakdownItem[];
+    filters: Filter[];
+    chartType: string;
+    chartConfig: object;
+    displayConfig: object;
+    activeView: string;
+}): void;
+/**
+ * Load state from localStorage (legacy format for backward compatibility)
+ */
+export declare function loadStateFromStorage(): {
+    metrics: MetricItem[];
+    breakdowns: BreakdownItem[];
+    filters: Filter[];
+    chartType: string;
+    chartConfig: object;
+    displayConfig: object;
+    activeView: string;
+} | null;
+/**
+ * Clear state from localStorage
+ */
+export declare function clearStateFromStorage(): void;

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

@@ -0,0 +1,4 @@
+import { ForwardRefExoticComponent, RefAttributes } from 'react';
+import { AnalysisBuilderProps, AnalysisBuilderRef } from './AnalysisBuilder/types.js';
+declare const AnalysisBuilder: ForwardRefExoticComponent<AnalysisBuilderProps & RefAttributes<AnalysisBuilderRef>>;
+export default AnalysisBuilder;

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

@@ -0,0 +1,2 @@
+import { AnalyticsDashboardProps } from '../types.js';
+export default function AnalyticsDashboard({ config, editable, dashboardFilters: propDashboardFilters, loadingComponent, onConfigChange, onSave, onSaveThumbnail, onDirtyStateChange }: AnalyticsDashboardProps): import("react").JSX.Element;

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

@@ -0,0 +1 @@
+export declare function AnalyticsPage(): import("react").JSX.Element;

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

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+import { AnalyticsPortletProps } from '../types.js';
+interface RefreshOptions {
+    bustCache?: boolean;
+}
+interface AnalyticsPortletRef {
+    refresh: (options?: RefreshOptions) => void;
+}
+declare const AnalyticsPortlet: React.MemoExoticComponent<React.ForwardRefExoticComponent<AnalyticsPortletProps & React.RefAttributes<AnalyticsPortletRef>>>;
+export default AnalyticsPortlet;

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

@@ -0,0 +1,21 @@
+import { default as React, Component, ReactNode } from 'react';
+interface Props {
+    children: ReactNode;
+    fallback?: ReactNode;
+    portletTitle?: string;
+    portletConfig?: any;
+    cubeQuery?: string;
+}
+interface State {
+    hasError: boolean;
+    error: Error | null;
+    errorInfo: string | null;
+}
+export default class ChartErrorBoundary extends Component<Props, State> {
+    constructor(props: Props);
+    static getDerivedStateFromError(error: Error): State;
+    componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void;
+    handleReset: () => void;
+    render(): string | number | boolean | Iterable<React.ReactNode> | React.JSX.Element | null | undefined;
+}
+export {};

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

@@ -0,0 +1,15 @@
+import { ChartType } from '../types.js';
+import { ChartAvailabilityMap } from '../shared/chartDefaults.js';
+interface ChartTypeSelectorProps {
+    selectedType: ChartType;
+    onTypeChange: (type: ChartType) => void;
+    className?: string;
+    /** Compact mode for narrow containers - uses 2 columns and constrains width */
+    compact?: boolean;
+    /** Map of chart type availability - when provided, unavailable charts are disabled */
+    availability?: ChartAvailabilityMap;
+    /** Chart types to exclude from the list (e.g., ['funnel'] to hide funnel in query mode) */
+    excludeTypes?: ChartType[];
+}
+export default function ChartTypeSelector({ selectedType, onTypeChange, className, compact, availability, excludeTypes }: ChartTypeSelectorProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,11 @@
+/**
+ * Color Palette Selector Component
+ * Allows users to select from predefined color palettes for their dashboard
+ */
+interface ColorPaletteSelectorProps {
+    currentPalette?: string;
+    onPaletteChange: (paletteName: string) => void;
+    className?: string;
+}
+export default function ColorPaletteSelector({ currentPalette, onPaletteChange, className }: ColorPaletteSelectorProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,30 @@
+import { default as React } from 'react';
+export interface ConfirmModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onConfirm: () => void | Promise<void>;
+    title?: string;
+    message: React.ReactNode;
+    confirmText?: string;
+    cancelText?: string;
+    confirmVariant?: 'danger' | 'primary' | 'warning';
+    isLoading?: boolean;
+}
+/**
+ * A reusable confirmation modal component.
+ *
+ * Usage:
+ * ```tsx
+ * <ConfirmModal
+ *   isOpen={showConfirm}
+ *   onClose={() => setShowConfirm(false)}
+ *   onConfirm={handleDelete}
+ *   title="Delete Portlet"
+ *   message="Are you sure you want to delete this portlet? This action cannot be undone."
+ *   confirmText="Delete"
+ *   confirmVariant="danger"
+ * />
+ * ```
+ */
+declare const ConfirmModal: React.FC<ConfirmModalProps>;
+export default ConfirmModal;

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

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+interface DashboardEditModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onSave: (data: {
+        name: string;
+        description?: string;
+    }) => Promise<void> | void;
+    title: string;
+    submitText: string;
+    initialName?: string;
+    initialDescription?: string;
+}
+export default function DashboardEditModal({ isOpen, onClose, onSave, title, submitText, initialName, initialDescription }: DashboardEditModalProps): React.JSX.Element;
+export {};

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

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+import { DashboardFilter, CubeMeta, DashboardConfig } from '../types.js';
+interface DashboardFilterPanelProps {
+    dashboardFilters: DashboardFilter[];
+    editable: boolean;
+    schema: CubeMeta | null;
+    dashboardConfig: DashboardConfig;
+    onDashboardFiltersChange: (filters: DashboardFilter[]) => void;
+    onSaveFilters?: (filters: DashboardFilter[]) => void | Promise<void>;
+    selectedFilterId?: string | null;
+    onFilterSelect?: (filterId: string) => void;
+    isEditMode?: boolean;
+}
+declare const DashboardFilterPanel: React.FC<DashboardFilterPanelProps>;
+export default DashboardFilterPanel;

package/dist/cjs/client/components/DashboardFilters/CompactFilterBar.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+import { DashboardFilter, CubeMeta } from '../../types.js';
+interface CompactFilterBarProps {
+    dashboardFilters: DashboardFilter[];
+    schema: CubeMeta | null;
+    isEditMode: boolean;
+    onDashboardFiltersChange: (filters: DashboardFilter[]) => void;
+    onAddFilter?: () => void;
+    onEditFilter?: (filterId: string) => void;
+    onRemoveFilter?: (filterId: string) => void;
+}
+declare const CompactFilterBar: React.FC<CompactFilterBarProps>;
+export default CompactFilterBar;

package/dist/cjs/client/components/DashboardFilters/CompactFilterBarParts.d.ts

@@ -0,0 +1,26 @@
+import { RefObject } from 'react';
+import { DashboardFilter, CubeMeta } from '../../types.js';
+export interface CompactFilterBarViewProps {
+    schema: CubeMeta | null;
+    isEditMode: boolean;
+    onAddFilter?: () => void;
+    onEditFilter?: (filterId: string) => void;
+    onRemoveFilter?: (filterId: string) => void;
+    currentDateRange: string | string[] | null;
+    activePresetId: string | null;
+    activeXTDId: string | null;
+    nonDateFilters: DashboardFilter[];
+    dateRangeTooltip: string | null;
+    showCustomDropdown: boolean;
+    setShowCustomDropdown: (next: boolean) => void;
+    showXTDDropdown: boolean;
+    setShowXTDDropdown: (next: boolean) => void;
+    customButtonRef: RefObject<HTMLButtonElement>;
+    xtdButtonRef: RefObject<HTMLButtonElement>;
+    handlePresetSelect: (presetValue: string) => void;
+    handleXTDSelect: (xtdValue: string) => void;
+    handleCustomDateSelect: (dateRange: string | string[]) => void;
+    handleFilterChange: (filterId: string, updatedFilter: DashboardFilter) => void;
+}
+export declare function DesktopLayout(props: CompactFilterBarViewProps): import("react").JSX.Element;
+export declare function MobileLayout(props: CompactFilterBarViewProps): import("react").JSX.Element;

package/dist/cjs/client/components/DashboardFilters/CustomDateDropdown.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+interface CustomDateDropdownProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onDateRangeChange: (dateRange: string | string[]) => void;
+    currentDateRange?: string | string[];
+    anchorRef: React.RefObject<HTMLElement>;
+}
+declare const CustomDateDropdown: React.FC<CustomDateDropdownProps>;
+export default CustomDateDropdown;

package/dist/cjs/client/components/DashboardFilters/DashboardFilterConfigModal.d.ts

@@ -0,0 +1,20 @@
+import { DashboardFilter } from '../../types.js';
+import { MetaResponse } from '../../shared/types.js';
+interface DashboardFilterConfigModalProps {
+    /** The dashboard filter being edited */
+    filter: DashboardFilter;
+    /** Full schema (unfiltered) */
+    fullSchema: MetaResponse | null;
+    /** Filtered schema (dashboard fields only) */
+    filteredSchema: MetaResponse | null;
+    /** Whether the modal is open */
+    isOpen: boolean;
+    /** Callback when user saves changes */
+    onSave: (filter: DashboardFilter) => void;
+    /** Callback when user deletes the filter */
+    onDelete: () => void;
+    /** Callback when user closes/cancels */
+    onClose: () => void;
+}
+export default function DashboardFilterConfigModal({ filter: initialFilter, fullSchema, filteredSchema, isOpen, onSave, onDelete, onClose }: DashboardFilterConfigModalProps): import("react").JSX.Element | null;
+export {};

package/dist/cjs/client/components/DashboardFilters/DashboardFilterConfigModalParts.d.ts

@@ -0,0 +1,27 @@
+import { MetaResponse } from '../../shared/types.js';
+import { SimpleFilter, FilterOperator } from '../../types.js';
+interface FieldSelectionSectionProps {
+    localFilter: SimpleFilter;
+    activeSchema: MetaResponse | null;
+    isTimeField: boolean;
+    isMeasureField: boolean;
+    showAllFields: boolean;
+    setShowAllFields: (next: boolean) => void;
+    setShowFieldSearch: (next: boolean) => void;
+}
+export declare function FieldSelectionSection({ localFilter, activeSchema, isTimeField, isMeasureField, showAllFields, setShowAllFields, setShowFieldSearch }: FieldSelectionSectionProps): import("react").JSX.Element;
+interface OperatorSectionProps {
+    localFilter: SimpleFilter;
+    operatorLabel: string;
+    availableOperators: {
+        operator: string;
+        label: string;
+    }[];
+    isOperatorDropdownOpen: boolean;
+    setIsOperatorDropdownOpen: (next: boolean) => void;
+    setIsValueDropdownOpen: (next: boolean) => void;
+    setIsDateRangeDropdownOpen: (next: boolean) => void;
+    handleOperatorChange: (operator: FilterOperator) => void;
+}
+export declare function OperatorSection({ localFilter, operatorLabel, availableOperators, isOperatorDropdownOpen, setIsOperatorDropdownOpen, setIsValueDropdownOpen, setIsDateRangeDropdownOpen, handleOperatorChange }: OperatorSectionProps): import("react").JSX.Element;
+export {};

package/dist/cjs/client/components/DashboardFilters/DashboardFilterItem.d.ts

@@ -0,0 +1,14 @@
+import { DashboardFilter } from '../../types.js';
+import { MetaResponse } from '../../shared/types.js';
+interface DashboardFilterItemProps {
+    /** The dashboard filter to display */
+    filter: DashboardFilter;
+    /** Schema for field metadata */
+    schema: MetaResponse | null;
+    /** Callback when filter chip is clicked (opens edit modal) */
+    onClick: () => void;
+    /** Callback to remove this filter */
+    onRemove: () => void;
+}
+export default function DashboardFilterItem({ filter, schema, onClick, onRemove }: DashboardFilterItemProps): import("react").JSX.Element;
+export {};