drizzle-cube 0.5.8 → 0.6.0

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

@@ -0,0 +1,26 @@
+import { RefObject } from 'react';
+import { DashboardFilter, CubeMeta } from '../../types';
+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/client/components/DashboardFilters/DashboardFilterConfigModalParts.d.ts

@@ -0,0 +1,27 @@
+import { MetaResponse } from '../../shared/types';
+import { SimpleFilter, FilterOperator } from '../../types';
+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/DashboardFilterValueInput.d.ts

@@ -0,0 +1,39 @@
+import { ChangeEvent } from 'react';
+import { SimpleFilter } from '../../types';
+import { DateRangeType } from '../../shared/types';
+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/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';
+export { deriveRangeFromDateRange } from '../shared/dateRangeUtils';
+/**
+ * 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';
+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';
+import { MetaResponse, MetaField } from '../../shared/types';
+import { FieldType } from '../AnalysisBuilder/types';
+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').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').DateRangeType;
+        numberValue: number;
+        handleRangeTypeChange: (newRangeType: import('../shared/types').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';
+import { DateRangeType } from '../../shared/types';
+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';
+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/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';
 declare const DashboardPortletCard: React.NamedExoticComponent<DashboardPortletCardProps>;
 export default DashboardPortletCard;

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

@@ -0,0 +1,31 @@
+import { ChartAxisConfig, ChartDisplayConfig, ChartType, CubeQuery } from '../../types';
+import { FlowChartData } from '../../types/flow';
+import { RetentionChartData } from '../../types/retention';
+import { ColorPalette } from '../../utils/colorPalettes';
+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';
+import { FlowChartData } from '../../types/flow';
+import { RetentionChartData } from '../../types/retention';
+import { ColorPalette } from '../../utils/colorPalettes';
+import { DrillInteraction } from '../../types/drill';
+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';
+import { DrillPathEntry } from '../../types/drill';
+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';
+import { ServerFlowQuery } from '../../types/flow';
+import { ServerRetentionQuery } from '../../types/retention';
+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/client/components/analyticsPortlet/portletRenderState.d.ts

@@ -0,0 +1,31 @@
+import { FlowChartData, ServerFlowQuery } from '../../types/flow';
+import { RetentionChartData, ServerRetentionQuery } from '../../types/retention';
+import { CubeQuery, MultiQueryConfig, ServerFunnelQuery } from '../../types';
+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/client/components/analyticsPortlet/usePortletDebugData.d.ts

@@ -0,0 +1,37 @@
+import { AnalyticsPortletProps, ChartAxisConfig, ChartDisplayConfig, ChartType, CubeQuery, ServerFunnelQuery } from '../../types';
+import { FlowChartData, ServerFlowQuery } from '../../types/flow';
+import { RetentionChartData, ServerRetentionQuery } from '../../types/retention';
+import { DrillPathEntry } from '../../types/drill';
+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/client/components/analyticsPortlet/usePortletDrillState.d.ts

@@ -0,0 +1,17 @@
+import { ChartAxisConfig, CubeQuery, DashboardFilter, DashboardFilterMapping } from '../../types';
+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').DrillInteraction;
+    activeQuery: CubeQuery | null;
+    handleNavigateBack: () => void;
+    handleNavigateToLevel: (index: number) => void;
+};

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

@@ -0,0 +1,37 @@
+import { useCubeLoadQuery, useFunnelQuery, useFlowQuery, useRetentionQuery } from '../../hooks/queries';
+import { CubeQuery, MultiQueryConfig, ServerFunnelQuery } from '../../types';
+import { FlowChartData, ServerFlowQuery } from '../../types/flow';
+import { RetentionChartData, ServerRetentionQuery } from '../../types/retention';
+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/client/components/charts/ActivityGridChart.helpers.d.ts

@@ -0,0 +1,33 @@
+import { CubeQuery } from '../../types';
+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[];