drizzle-cube 0.5.8 → 0.6.1

package/dist/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/client/components/DashboardFilters/DashboardFilterItem.d.ts

@@ -1,5 +1,5 @@
-import { DashboardFilter } from '../../types';
-import { MetaResponse } from '../../shared/types';
+import { DashboardFilter } from '../../types.js';
+import { MetaResponse } from '../../shared/types.js';
 interface DashboardFilterItemProps {
     /** The dashboard filter to display */
     filter: DashboardFilter;

package/dist/client/components/DashboardFilters/DashboardFilterValueInput.d.ts

@@ -0,0 +1,39 @@
+import { ChangeEvent } from 'react';
+import { SimpleFilter } from '../../types.js';
+import { DateRangeType } from '../../shared/types.js';
+type OperatorMeta = {
+    requiresValues?: boolean;
+    valueType?: string;
+    supportsMultipleValues?: boolean;
+} | undefined;
+export interface DashboardFilterValueInputProps {
+    filter: SimpleFilter;
+    operatorMeta: OperatorMeta;
+    shouldShowDateRange: boolean;
+    shouldShowComboBox: boolean;
+    rangeType: DateRangeType;
+    numberValue: number;
+    dateRangeLabel: string;
+    isDateRangeDropdownOpen: boolean;
+    setIsOperatorDropdownOpen: (open: boolean) => void;
+    setIsValueDropdownOpen: (open: boolean) => void;
+    setIsDateRangeDropdownOpen: (open: boolean) => void;
+    handleRangeTypeChange: (rangeType: DateRangeType) => void;
+    handleNumberValueChange: (value: number) => void;
+    handleCustomStartDate: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleCustomEndDate: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleBetweenStartInput: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleBetweenEndInput: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleDateInput: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleDirectInput: (e: ChangeEvent<HTMLInputElement>) => void;
+    isValueDropdownOpen: boolean;
+    distinctValues: unknown[];
+    valuesLoading: boolean;
+    valuesError: unknown;
+    searchText: string;
+    setSearchText: (text: string) => void;
+    handleValueSelect: (value: unknown) => void;
+    handleValueRemove: (value: unknown) => void;
+}
+export default function DashboardFilterValueInput(props: DashboardFilterValueInputProps): import("react").JSX.Element;
+export {};

package/dist/client/components/DashboardFilters/EditModeFilterList.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { DashboardFilter } from '../../types';
+import { DashboardFilter } from '../../types.js';
 interface EditModeFilterListProps {
     dashboardFilters: DashboardFilter[];
     onAddFilter: () => void;

package/dist/client/components/DashboardFilters/FilterChip.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { DashboardFilter, CubeMeta } from '../../types';
+import { DashboardFilter, CubeMeta } from '../../types.js';
 interface FilterChipProps {
     filter: DashboardFilter;
     schema: CubeMeta | null;

package/dist/client/components/DashboardFilters/FilterEditModal.d.ts

@@ -1,6 +1,6 @@
 import { default as React } from 'react';
-import { DashboardFilter, CubeMeta, DashboardConfig } from '../../types';
-import { MetaResponse } from '../../shared/types';
+import { DashboardFilter, CubeMeta, DashboardConfig } from '../../types.js';
+import { MetaResponse } from '../../shared/types.js';
 interface FilterEditModalProps {
     filter: DashboardFilter;
     schema: CubeMeta | null;

package/dist/client/components/DashboardFilters/FilterValuePopover.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { SimpleFilter, CubeMeta } from '../../types';
+import { SimpleFilter, CubeMeta } from '../../types.js';
 interface FilterValuePopoverProps {
     filter: SimpleFilter;
     schema: CubeMeta | null;

package/dist/client/components/DashboardFilters/ReadOnlyFilterList.d.ts

@@ -1,6 +1,6 @@
 import { default as React } from 'react';
-import { DashboardFilter, CubeMeta } from '../../types';
-import { MetaResponse } from '../../shared/types';
+import { DashboardFilter, CubeMeta } from '../../types.js';
+import { MetaResponse } from '../../shared/types.js';
 interface ReadOnlyFilterListProps {
     dashboardFilters: DashboardFilter[];
     schema: CubeMeta | null;

package/dist/client/components/DashboardFilters/dashboardFilterConfigModalUtils.d.ts

@@ -0,0 +1,21 @@
+/**
+ * dashboardFilterConfigModalUtils
+ *
+ * Pure helpers extracted from DashboardFilterConfigModal to keep the component's
+ * effects and handlers flat. Behaviour is identical to the previous inline logic.
+ *
+ * `deriveRangeFromDateRange` lives in the shared `dateRangeUtils` module and is
+ * re-exported here to keep existing import paths stable.
+ */
+export type { DerivedRange } from '../shared/dateRangeUtils.js';
+export { deriveRangeFromDateRange } from '../shared/dateRangeUtils.js';
+/**
+ * Compute the next filter `values` for a direct text/number input change.
+ * Mirrors the previous inline `handleDirectInput` logic exactly:
+ *  - For number-typed operators: keep numeric values, clear on empty/partial sign.
+ *  - For everything else: store the raw string (or clear when empty).
+ *
+ * Returns `null` when the current values should be left untouched (e.g. an
+ * unparseable number that is neither empty nor a lone "-").
+ */
+export declare function computeDirectInputValues(value: string, valueType: string | undefined): unknown[] | null;

package/dist/client/components/DashboardFilters/useCompactFilterBar.d.ts

@@ -0,0 +1,19 @@
+import { DashboardFilter } from '../../types.js';
+export declare function useCompactFilterBar(dashboardFilters: DashboardFilter[], onDashboardFiltersChange: (filters: DashboardFilter[]) => void): {
+    localFilters: DashboardFilter[];
+    showCustomDropdown: boolean;
+    setShowCustomDropdown: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    showXTDDropdown: boolean;
+    setShowXTDDropdown: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    customButtonRef: import('react').RefObject<HTMLButtonElement>;
+    xtdButtonRef: import('react').RefObject<HTMLButtonElement>;
+    currentDateRange: string | any[] | null;
+    activePresetId: string | null;
+    activeXTDId: string | null;
+    nonDateFilters: DashboardFilter[];
+    handlePresetSelect: (presetValue: string) => void;
+    handleXTDSelect: (xtdValue: string) => void;
+    handleCustomDateSelect: (dateRange: string | string[]) => void;
+    handleFilterChange: (filterId: string, updatedFilter: DashboardFilter) => void;
+    dateRangeTooltip: string | null;
+};

package/dist/client/components/DashboardFilters/useDashboardFilterConfigModal.d.ts

@@ -0,0 +1,69 @@
+import { ChangeEvent } from 'react';
+import { DashboardFilter, SimpleFilter, FilterOperator } from '../../types.js';
+import { MetaResponse, MetaField } from '../../shared/types.js';
+import { FieldType } from '../AnalysisBuilder/types.js';
+interface UseDashboardFilterConfigModalParams {
+    initialFilter: DashboardFilter;
+    fullSchema: MetaResponse | null;
+    filteredSchema: MetaResponse | null;
+    isOpen: boolean;
+    onSave: (filter: DashboardFilter) => void;
+}
+export declare function useDashboardFilterConfigModal({ initialFilter, fullSchema, filteredSchema, isOpen, onSave }: UseDashboardFilterConfigModalParams): {
+    localLabel: string;
+    setLocalLabel: import('react').Dispatch<import('react').SetStateAction<string>>;
+    localFilter: SimpleFilter;
+    showAllFields: boolean;
+    setShowAllFields: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    showFieldSearch: boolean;
+    setShowFieldSearch: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    field: {
+        activeSchema: MetaResponse | null;
+        isTimeField: boolean;
+        isMeasureField: boolean;
+        fieldTitle: string;
+        operatorMeta: import('../../shared/types.js').FilterOperatorMeta;
+        availableOperators: {
+            operator: string;
+            label: string;
+        }[];
+        operatorLabel: string;
+        shouldShowDateRange: boolean;
+        shouldShowComboBox: boolean;
+    };
+    dropdowns: {
+        containerRef: import('react').RefObject<HTMLDivElement>;
+        isOperatorDropdownOpen: boolean;
+        setIsOperatorDropdownOpen: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+        isValueDropdownOpen: boolean;
+        setIsValueDropdownOpen: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+        isDateRangeDropdownOpen: boolean;
+        setIsDateRangeDropdownOpen: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    };
+    values: {
+        searchText: string;
+        setSearchText: import('react').Dispatch<import('react').SetStateAction<string>>;
+        distinctValues: any[];
+        valuesLoading: boolean;
+        valuesError: string | null;
+        handleValueSelect: (value: unknown) => void;
+        handleValueRemove: (valueToRemove: unknown) => void;
+    };
+    dateRange: {
+        dateRangeLabel: string;
+        rangeType: import('../shared/types.js').DateRangeType;
+        numberValue: number;
+        handleRangeTypeChange: (newRangeType: import('../shared/types.js').DateRangeType) => void;
+        handleNumberValueChange: (value: number) => void;
+        handleCustomStartDate: (e: ChangeEvent<HTMLInputElement>) => void;
+        handleCustomEndDate: (e: ChangeEvent<HTMLInputElement>) => void;
+    };
+    handleFieldSelected: (field: MetaField, _fieldType: FieldType) => void;
+    handleOperatorChange: (operator: FilterOperator) => void;
+    handleDirectInput: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleBetweenStartInput: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleBetweenEndInput: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleDateInput: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleSave: () => void;
+};
+export {};

package/dist/client/components/DashboardFilters/useDateRangeState.d.ts

@@ -0,0 +1,19 @@
+import { ChangeEvent } from 'react';
+import { SimpleFilter } from '../../types.js';
+import { DateRangeType } from '../../shared/types.js';
+interface UseDateRangeStateParams {
+    localFilter: SimpleFilter;
+    setLocalFilter: (filter: SimpleFilter) => void;
+    shouldShowDateRange: boolean;
+    setIsDateRangeDropdownOpen: (open: boolean) => void;
+}
+export declare function useDateRangeState({ localFilter, setLocalFilter, shouldShowDateRange, setIsDateRangeDropdownOpen }: UseDateRangeStateParams): {
+    rangeType: DateRangeType;
+    numberValue: number;
+    handleRangeTypeChange: (newRangeType: DateRangeType) => void;
+    handleNumberValueChange: (value: number) => void;
+    handleCustomStartDate: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleCustomEndDate: (e: ChangeEvent<HTMLInputElement>) => void;
+};
+export type UseDateRangeState = ReturnType<typeof useDateRangeState>;
+export {};

package/dist/client/components/DashboardFilters/useFilterDropdowns.d.ts

@@ -0,0 +1,21 @@
+/**
+ * useFilterDropdowns
+ *
+ * Owns the open/closed state of the three mutually-exclusive popover dropdowns
+ * (operator, value, date-range) plus the click-outside effect that closes them
+ * all. This is the single "which dropdown is open" concern; it exposes the
+ * container ref the effect watches and the individual open flags/setters.
+ *
+ * Behaviour is identical to the previous inline implementation — same effect,
+ * same dependency array, same setters.
+ */
+export declare function useFilterDropdowns(): {
+    containerRef: import('react').RefObject<HTMLDivElement>;
+    isOperatorDropdownOpen: boolean;
+    setIsOperatorDropdownOpen: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    isValueDropdownOpen: boolean;
+    setIsValueDropdownOpen: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    isDateRangeDropdownOpen: boolean;
+    setIsDateRangeDropdownOpen: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+};
+export type UseFilterDropdowns = ReturnType<typeof useFilterDropdowns>;

package/dist/client/components/DashboardFilters/useFilterValueFetch.d.ts

@@ -0,0 +1,23 @@
+import { SimpleFilter } from '../../types.js';
+interface OperatorMetaLike {
+    supportsMultipleValues?: boolean;
+}
+interface UseFilterValueFetchParams {
+    localFilter: SimpleFilter;
+    setLocalFilter: (filter: SimpleFilter) => void;
+    operatorMeta: OperatorMetaLike | undefined;
+    shouldShowComboBox: boolean;
+    isValueDropdownOpen: boolean;
+    setIsValueDropdownOpen: (open: boolean) => void;
+}
+export declare function useFilterValueFetch({ localFilter, setLocalFilter, operatorMeta, shouldShowComboBox, isValueDropdownOpen, setIsValueDropdownOpen }: UseFilterValueFetchParams): {
+    searchText: string;
+    setSearchText: import('react').Dispatch<import('react').SetStateAction<string>>;
+    distinctValues: any[];
+    valuesLoading: boolean;
+    valuesError: string | null;
+    handleValueSelect: (value: unknown) => void;
+    handleValueRemove: (valueToRemove: unknown) => void;
+};
+export type UseFilterValueFetch = ReturnType<typeof useFilterValueFetch>;
+export {};

package/dist/client/components/DashboardGrid.d.ts

@@ -1,6 +1,6 @@
 import { ReactNode } from 'react';
-import { ColorPalette } from '../utils/colorPalettes';
-import { DashboardConfig, DashboardFilter, CubeMeta, DashboardLayoutMode } from '../types';
+import { ColorPalette } from '../utils/colorPalettes.js';
+import { DashboardConfig, DashboardFilter, CubeMeta, DashboardLayoutMode } from '../types.js';
 interface DashboardGridProps {
     config: DashboardConfig;
     editable?: boolean;

package/dist/client/components/DashboardPortletCard.d.ts

@@ -1,59 +1,4 @@
-import { default as React, HTMLAttributes, ReactNode, CSSProperties, ComponentType } from 'react';
-import { DashboardFilter, DashboardLayoutMode, PortletConfig } from '../types';
-import { ColorPalette } from '../utils/colorPalettes';
-/**
- * Simplified props interface after Zustand migration.
- * State (selectedFilterId, debugData) now comes from store.
- * Actions now come from callbacks prop or store.
- */
-interface DashboardPortletCardProps {
-    portlet: PortletConfig;
-    editable: boolean;
-    layoutMode?: DashboardLayoutMode;
-    dashboardFilters?: DashboardFilter[];
-    configEagerLoad?: boolean;
-    loadingComponent?: ReactNode;
-    colorPalette?: ColorPalette;
-    containerProps?: HTMLAttributes<HTMLDivElement>;
-    headerProps?: HTMLAttributes<HTMLDivElement>;
-    setPortletRef: (portletId: string, element: HTMLDivElement | null) => void;
-    setPortletComponentRef: (portletId: string, element: {
-        refresh: (options?: {
-            bustCache?: boolean;
-        }) => void;
-    } | null) => void;
-    callbacks: {
-        onToggleFilter: (portletId: string, filterId: string) => void;
-        onRefresh: (portletId: string, options?: {
-            bustCache?: boolean;
-        }) => void;
-        onDuplicate: (portletId: string) => void;
-        onEdit: (portlet: PortletConfig) => void;
-        onDelete: (portletId: string) => void;
-        onOpenFilterConfig: (portlet: PortletConfig) => void;
-    };
-    icons: {
-        RefreshIcon: ComponentType<{
-            className?: string;
-            style?: CSSProperties;
-        }>;
-        EditIcon: ComponentType<{
-            className?: string;
-            style?: CSSProperties;
-        }>;
-        DeleteIcon: ComponentType<{
-            className?: string;
-            style?: CSSProperties;
-        }>;
-        CopyIcon: ComponentType<{
-            className?: string;
-            style?: CSSProperties;
-        }>;
-        FilterIcon: ComponentType<{
-            className?: string;
-            style?: CSSProperties;
-        }>;
-    };
-}
+import { default as React } from 'react';
+import { DashboardPortletCardProps } from './dashboardPortletCard/propsEqual.js';
 declare const DashboardPortletCard: React.NamedExoticComponent<DashboardPortletCardProps>;
 export default DashboardPortletCard;

package/dist/client/components/DebugModal.d.ts

@@ -1,5 +1,5 @@
-import { FlowChartData } from '../types/flow';
-import { RetentionChartData } from '../types/retention';
+import { FlowChartData } from '../types/flow.js';
+import { RetentionChartData } from '../types/retention.js';
 interface DebugModalProps {
     chartConfig: any;
     displayConfig: any;

package/dist/client/components/DrillBreadcrumb.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { DrillBreadcrumbProps } from '../types/drill';
+import { DrillBreadcrumbProps } from '../types/drill.js';
 /**
  * DrillBreadcrumb component
  */

package/dist/client/components/DrillMenu.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { DrillMenuProps } from '../types/drill';
+import { DrillMenuProps } from '../types/drill.js';
 /**
  * DrillMenu component
  * Uses createPortal to render directly to document.body, avoiding stacking context issues

package/dist/client/components/FloatingEditToolbar.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { DashboardLayoutMode } from '../types';
+import { DashboardLayoutMode } from '../types.js';
 interface FloatingEditToolbarProps {
     /** Whether the static edit bar is visible (toolbar hidden when true) */
     isEditBarVisible: boolean;

package/dist/client/components/MobileStackedLayout.d.ts

@@ -1,5 +1,5 @@
-import { DashboardFilter, DashboardConfig } from '../types';
-import { ColorPalette } from '../utils/colorPalettes';
+import { DashboardFilter, DashboardConfig } from '../types.js';
+import { ColorPalette } from '../utils/colorPalettes.js';
 interface MobileStackedLayoutProps {
     config: DashboardConfig;
     colorPalette?: ColorPalette;

package/dist/client/components/PortletAnalysisModal.d.ts

@@ -1,4 +1,4 @@
-import { PortletConfig, ColorPalette, DashboardFilter } from '../types';
+import { PortletConfig, ColorPalette, DashboardFilter } from '../types.js';
 interface PortletAnalysisModalProps {
     isOpen: boolean;
     onClose: () => void;

package/dist/client/components/PortletContainer.d.ts

@@ -1,4 +1,4 @@
-import { PortletConfig } from '../types';
+import { PortletConfig } from '../types.js';
 interface PortletContainerProps {
     portlet: PortletConfig;
     editable?: boolean;

package/dist/client/components/PortletFilterConfigModal.d.ts

@@ -1,4 +1,4 @@
-import { DashboardFilter, DashboardFilterMapping, CubeMeta, PortletConfig } from '../types';
+import { DashboardFilter, DashboardFilterMapping, CubeMeta, PortletConfig } from '../types.js';
 interface PortletFilterConfigModalProps {
     isOpen: boolean;
     onClose: () => void;

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

@@ -1,5 +1,5 @@
 import { HTMLAttributes, ReactNode, MouseEvent, DragEvent } from 'react';
-import { DashboardGridSettings, PortletConfig, RowLayout } from '../types';
+import { DashboardGridSettings, PortletConfig, RowLayout } from '../types.js';
 interface RowManagedLayoutProps {
     rows: RowLayout[];
     portlets: PortletConfig[];

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

@@ -1,4 +1,4 @@
-import { CubeMetaCube } from '../../types';
+import { CubeMetaCube } from '../../types.js';
 interface CubeNodeData {
     cube: CubeMetaCube;
     onFieldClick?: (cubeName: string, fieldName: string, fieldType: 'measure' | 'dimension', pos?: {

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

@@ -1,4 +1,4 @@
-import { CubeMetaCube } from '../../types';
+import { CubeMetaCube } from '../../types.js';
 export interface FieldSelection {
     cubeName: string;
     fieldName: string | null;

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

@@ -1,5 +1,5 @@
 import { Edge, EdgeProps } from '@xyflow/react';
-import { CubeMetaRelationship } from '../../types';
+import { CubeMetaRelationship } from '../../types.js';
 interface RelationshipEdgeData {
     relationship: CubeMetaRelationship;
     joinFields: Array<{

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

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

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

@@ -1,5 +1,5 @@
-import { PortletConfig } from '../types';
-import { ColorPalette } from '../utils/colorPalettes';
+import { PortletConfig } from '../types.js';
+import { ColorPalette } from '../utils/colorPalettes.js';
 interface TextPortletModalProps {
     isOpen: boolean;
     onClose: () => void;

package/dist/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/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/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/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;