@databrainhq/plugin 0.15.25 → 0.15.27

package/dist/helpers/timeseries.d.ts

@@ -0,0 +1,35 @@
+import { BackgroundSettings, CustomSettings, LabelSettings, TimeSeriesGroupType, TimeSeriesType } from '@/types';
+interface TimeSeriesData {
+    timeStampKey: string;
+    data: Record<string, any>[];
+    values?: string[];
+}
+type GetTimeSeriesData = {
+    dataArray: Record<string, any>[];
+    timeStampKey: string;
+    valuekeys: string[];
+    type: TimeSeriesType;
+    groupBy: TimeSeriesGroupType;
+    labelSettings: LabelSettings;
+    customSettings: CustomSettings;
+    backGroundColor: BackgroundSettings;
+    fillXAxis: boolean;
+    isCumulativeBar: boolean;
+    customData: any;
+    yAxisList: string[];
+    hasPercentSymbol: boolean;
+    colorPalette?: string[];
+    markerData?: any[];
+    labelFormatting?: any;
+    chartAppearanceLabelPosition?: string;
+};
+export declare const groupByMap: {
+    yearly: (date: Date) => string;
+    monthly: (date: Date) => string;
+    weekly: (date: Date) => string;
+    daily: (date: Date) => string;
+    quarterly: (date: Date) => string;
+};
+export declare const getTimeSeriesData: ({ dataArray, timeStampKey, type, valuekeys, groupBy, labelSettings, customSettings, backGroundColor, fillXAxis, isCumulativeBar, customData, yAxisList, hasPercentSymbol, colorPalette, markerData, labelFormatting, chartAppearanceLabelPosition, }: GetTimeSeriesData) => any[];
+export declare const isTimeSeriesDataValid: ({ data, timeStampKey, }: TimeSeriesData) => boolean;
+export {};

package/dist/helpers/timeseriesOption.d.ts

@@ -0,0 +1,72 @@
+import { BackgroundSettings, ChartSettingsType, CustomSettings, FloatingDropDownOption, LabelSettings, LegendSettings } from '@/types';
+type DataRow = Record<string, any>;
+type AxisSettings = {
+    axis?: string | undefined;
+};
+type GetSeriesOptionParams = {
+    chartOptions: ChartSettingsType;
+    data: DataRow[];
+    labelSettings: LabelSettings;
+    backGroundColor: BackgroundSettings;
+    customSettings: CustomSettings;
+    colorOptions: Record<string, any>;
+    defaultOptions: Record<string, any>;
+    legendSettings: LegendSettings;
+    axisSettings: AxisSettings;
+    legendPosition: Record<string, any>;
+    markerData?: any[];
+    labelFormatting: any;
+    chartAppearanceLabelPosition?: string;
+    horizontalAxisSettings?: any;
+    horizontalAxisLabelSettings?: any;
+    verticalAxisSettings?: any;
+    verticalAxisLabelSettings?: any;
+    chartLegendSettings?: any;
+    chartTooltip?: {
+        labelStyle?: {
+            size?: number;
+            family?: string;
+            weight?: number;
+            color?: string;
+        };
+        valueStyle?: {
+            size?: number;
+            family?: string;
+            weight?: number;
+            color?: string;
+        };
+        tooltipHeader?: {
+            size?: number;
+            family?: string;
+            weight?: number;
+            color?: string;
+        };
+    };
+};
+export declare const getSeriesOption: ({ chartOptions, data, backGroundColor, customSettings, labelSettings, colorOptions, defaultOptions, axisSettings, markerData, labelFormatting, chartAppearanceLabelPosition, horizontalAxisSettings, horizontalAxisLabelSettings, verticalAxisSettings, verticalAxisLabelSettings, chartLegendSettings, chartTooltip, }: GetSeriesOptionParams) => {
+    axisLine: {
+        show: boolean | undefined;
+    };
+    axisLabel: {
+        show: boolean | undefined;
+    };
+    tooltip: {
+        trigger: string;
+        backgroundColor: string;
+        borderRadius: number;
+        padding: number;
+        axisPointer: {
+            type: string;
+        };
+        className: string;
+        enterable: boolean;
+        valueFormatter: (value: any) => string;
+        formatter: (params: any) => string;
+    };
+    xAxis: any;
+    yAxis: any;
+    legend: any;
+    series: any[];
+};
+export declare const getFormat: (value: FloatingDropDownOption, dbName: string) => "yyyy-MM-dd" | "%b - %Y" | "MMM - yyyy" | "Mon - yyyy" | "%Y" | "yyyy" | "%Q QUARTER" | "%Q %Y" | "Q yyyy" | "%Y-%m-%d" | "yyyy-mm-dd" | "%Y-%m-%U" | "%Y-%m-%W" | "yyyy-MM-WEEKOFYEAR" | "yyyy-mm-WW";
+export {};

package/dist/helpers/tooltipFormatter.d.ts

@@ -0,0 +1,27 @@
+import { ChartSettingsType } from '@/types';
+export declare const tooltipFormatter: (params: any, chartOptions: ChartSettingsType, options?: {
+    hasPercentSymbol?: boolean;
+    isEnableDateFormat?: boolean;
+    dateFormat?: string;
+    isNoAxisChart?: boolean;
+    tooltipFormatting?: {
+        labelStyle?: {
+            size?: number;
+            family?: string;
+            weight?: number;
+            color?: string;
+        };
+        valueStyle?: {
+            size?: number;
+            family?: string;
+            weight?: number;
+            color?: string;
+        };
+        tooltipHeader?: {
+            size?: number;
+            family?: string;
+            weight?: number;
+            color?: string;
+        };
+    };
+}) => string;

package/dist/helpers/treeMap.d.ts

@@ -0,0 +1,6 @@
+declare const createNestedArray: (data: Record<string, any>[], selectedRoots: string[], selectedColumns: string[]) => {
+    name: string;
+    value: number;
+    children: never[];
+}[];
+export default createNestedArray;

package/dist/hooks/index.d.ts

@@ -0,0 +1,12 @@
+export * from './useExternalMetric';
+export * from './useGenerateDatasetMetrics';
+export * from './useOutsideAlerter';
+export * from './useClientDashboardLayout';
+export * from './useUnderlyingData';
+export * from './useMetricCard';
+export * from './useArchiveMetric';
+export * from './useEmbeddedMetric';
+export * from './useDrag';
+export * from './useDrop';
+export * from './usePythonResults';
+export * from './useAutoCompleteOptions';

package/dist/hooks/useArchiveMetric.d.ts

@@ -0,0 +1,10 @@
+type UseArchiveMetricProps = {
+    metricId: string;
+    onSuccess: () => void;
+    token: string;
+};
+export declare const useArchiveMetric: ({ metricId, onSuccess, token, }: UseArchiveMetricProps) => {
+    handleArchiveMetric: () => Promise<void>;
+    isLoading: boolean;
+};
+export {};

package/dist/hooks/useAutoCompleteOptions.d.ts

@@ -0,0 +1,4 @@
+import { SearchColumn, TableObjectType } from '@/types';
+export declare const useAutoCompleteOptions: (isEnable: boolean, tableList: TableObjectType[], isElasticSearch: boolean) => {
+    autoCompleteDropdownOptions: SearchColumn[];
+};

package/dist/hooks/useClientDashboardLayout.d.ts

@@ -0,0 +1,21 @@
+import { Layout } from 'react-grid-layout';
+export type UseClientDashboardLayoutProps = {
+    externalDashboardId: string;
+    clientId: string;
+};
+export declare const useClientDashboardLayout: ({ externalDashboardId, clientId, }: UseClientDashboardLayoutProps) => {
+    saveLayout: (data: {
+        newLayout: Layout[];
+        filtersLayout: string[];
+        isChangedByClient?: boolean | undefined;
+        gridMargin?: {
+            verticalMargin?: number | undefined;
+            horizontalMargin?: number | undefined;
+        } | undefined;
+    }) => Promise<void>;
+    layout: Layout[];
+    dashboardFiltersLayout: string[];
+    gridMargin: any;
+    isLayoutLocked: boolean;
+    isLoadingLayout: boolean;
+};

package/dist/hooks/useDashboardContext.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="react" />
+import { ClientColumnType } from '@/types';
+interface DashboardContextType {
+    isLoading: boolean | undefined;
+    token: string | undefined;
+    error?: string;
+    data: {
+        token: string;
+        companyId: string;
+        sharingSettingsId: string | undefined;
+        clientId: string | undefined;
+        externalDashboardMetrics: any[];
+        externalDashboard: any;
+        rlsSettings: any | undefined;
+        appFilters: any | undefined;
+        dashboardAppFilters: any | undefined;
+        companyTenancyType: any;
+        isAllowedToCreateMetrics: boolean | undefined;
+        isAllowedToDeleteMetrics: boolean | undefined;
+        isAllowedToUpdateMetrics: boolean | undefined;
+        isAllowedManageMetrics: boolean | undefined;
+        isAllowedToChangeLayout: boolean | undefined;
+        isAllowedToEmailReports: boolean | undefined;
+        isShowUnderlyingData: boolean | undefined;
+        workspace: any;
+        adminTheme: any;
+        clientSubsetData?: any | undefined;
+        clientColumnType: ClientColumnType;
+        isEnableMetricSummary: boolean;
+        refreshTime?: number | null;
+        isAllClient: boolean;
+        metricCreationMode: string;
+    } | undefined;
+}
+export declare const DashboardContext: import("react").Context<DashboardContextType>;
+export declare const useDashboardContext: () => DashboardContextType;
+export {};

package/dist/hooks/useDatasetMetric.d.ts

@@ -0,0 +1,50 @@
+/// <reference types="react" />
+import ReactAce from 'react-ace/lib/ace';
+import { ChartSettingsType, CreateNewFilter, CreateNewSort, DatasetConfig, DatasetMetricCreationConfiguration, FloatingDropDownOption, Modifiers, OnChangeAliasParams, OnChangeHelperFunctionParams, OnDrillPivotTableParams, OnDropColumnParams, OnRemoveColumnParams, PivotDrillState, SelectedColumn, SetChartFieldParams, TableObjectType } from '@/types';
+declare const useDatasetMetric: ({ clientId, clientSubsetData, setChartSettings, setError, dbName, chartSettings, setData, setQuery, setLoading, setGroupByList, data, limit, setDatasetSettings, token, workspaceId, isDatabaseTenancy, clientColumnType, setDrillDownSettings, drillDownSettings, }: DatasetConfig) => {
+    selectedMainTable: TableObjectType | undefined;
+    companySubsetTableList: TableObjectType[];
+    setSelectedMainTable: import("react").Dispatch<import("react").SetStateAction<TableObjectType | undefined>>;
+    pivotDrillState: PivotDrillState;
+    setPivotDrillState: import("react").Dispatch<import("react").SetStateAction<PivotDrillState>>;
+    configuration: DatasetMetricCreationConfiguration;
+    selectedDims: SelectedColumn[];
+    selectedMetrics: SelectedColumn[];
+    onDropColumn: ({ column, table, sorting, type, identifier, }: OnDropColumnParams) => void;
+    functionOptions: (col?: SelectedColumn, dataType?: string) => FloatingDropDownOption[];
+    dimModifiers: Modifiers;
+    metricModifiers: Modifiers;
+    isTimeSeries: boolean;
+    editorRef: import("react").RefObject<ReactAce>;
+    onChangeAlias: ({ alias, column, type, cast, isColumnCasted, }: OnChangeAliasParams) => void;
+    onChangeHelperFunction: ({ column, helperFunction, type, functionConfiguration, }: OnChangeHelperFunctionParams) => void;
+    onRemoveColumn: ({ column, type }: OnRemoveColumnParams) => void;
+    selectedTable: FloatingDropDownOption;
+    createdSorts: CreateNewSort[];
+    setCreatedSorts: import("react").Dispatch<import("react").SetStateAction<CreateNewSort[]>>;
+    onApplyFilter: (onComplete: () => void, isClear?: boolean, index?: number) => void;
+    onApplySort: (onComplete: () => void, isClear?: boolean, index?: number) => void;
+    sortColumnOptions: FloatingDropDownOption[];
+    filterColumnOptions: FloatingDropDownOption[];
+    createdFilters: CreateNewFilter[];
+    setCreatedFilters: import("react").Dispatch<import("react").SetStateAction<CreateNewFilter[]>>;
+    getFilterDropDownType: ({ datatype, operator, }: {
+        datatype: string;
+        operator: string;
+    }) => "DATE_PICKER" | "NULL" | "DATE_RANGE" | "TIME_FILTER" | "MULTI_FILTER_DROPDOWN" | "INPUT_NUMBER_FIELD" | "INPUT_TEXT_FIELD" | "FILTER_DROPDOWN";
+    onSelectTimeSeries: (chartType: ChartSettingsType['chartType']) => void;
+    setChartFields: ({ chartType, chartDimensions, chartMetrics, chartAggregateColumns, resultData, configAggregates, pivotHeaderColumns, chartTimeColumns, }: SetChartFieldParams) => void;
+    resetCharSettings: (chartType: ChartSettingsType['chartType']) => void;
+    onDrillPivotTable: ({ filters, nextLevel, currentValue, }: OnDrillPivotTableParams) => void;
+    onSelectPivotTable: (chartType: ChartSettingsType['chartType'], headers: string[]) => void;
+    onChangeChartGroupByValue: (seriesName: string) => void;
+    onChangeTimeseriesFormat: (value: FloatingDropDownOption, seriesName?: string) => void;
+    isDisableChartDrillDown: boolean;
+    isAllowDrillDown: boolean;
+    onChangeDrillDown: (params: any, isEnable?: boolean, isChange?: boolean, index?: number) => void;
+    drillFilters: {
+        columnName: string;
+        value: string | number;
+    }[];
+};
+export default useDatasetMetric;

package/dist/hooks/useDebounce.d.ts

@@ -0,0 +1,2 @@
+declare const useDebounce: <T>(value: T, delay?: number) => T;
+export default useDebounce;

package/dist/hooks/useDownloadRawCsv.d.ts

@@ -0,0 +1,21 @@
+import { FieldValues } from 'react-hook-form';
+declare const useDownloadRawCsv: ({ onCloseModal, sharingSettingsId, metricItem, workspaceId, }: {
+    onCloseModal?: ((value: boolean) => void) | undefined;
+    metricItem?: Record<string, any> | undefined;
+    sharingSettingsId?: string | undefined;
+    workspaceId: string;
+}) => {
+    onSumbitSendCsvUrl: ({ values, query, }: {
+        values: FieldValues;
+        query: string;
+    }) => void;
+    isDisableDownloadSettings: boolean;
+    downloadCsvError: string;
+    handleSubmit: import("react-hook-form").UseFormHandleSubmit<FieldValues>;
+    isLoading: boolean;
+    register: import("react-hook-form").UseFormRegister<FieldValues>;
+    control: import("react-hook-form").Control<FieldValues, any>;
+    setValue: import("react-hook-form").UseFormSetValue<FieldValues>;
+    errors: import("react-hook-form").FieldErrors<FieldValues>;
+};
+export default useDownloadRawCsv;

package/dist/hooks/useDrag.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { UseDragProps } from '@/types';
+declare const useDrag: ({ identifier, data, modifiers, events, CustomDragPreview, }: UseDragProps) => {
+    isDragging: boolean;
+    isEnableDrag: boolean;
+    setIsEnableDrag: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    DragNodeRef: import("react").MutableRefObject<any>;
+};
+export default useDrag;
+export { useDrag };

package/dist/hooks/useDragAndDropState.d.ts

@@ -0,0 +1,10 @@
+import { DndStateProp } from '@/types';
+declare const useDragAndDropState: () => {
+    dndState: DndStateProp;
+    setActive: (active: DndStateProp['active']) => void;
+    setOver: (over: DndStateProp['over']) => void;
+    setDraggables: (draggable: DndStateProp['active']) => void;
+    setDropables: (droppable: DndStateProp['over']) => void;
+    setDndState: (update: DndStateProp | ((prev: DndStateProp) => DndStateProp)) => void;
+};
+export default useDragAndDropState;

package/dist/hooks/useDrop.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import { UseDropProps } from '@/types';
+declare const useDrop: ({ identifier, events, modifiers }: UseDropProps) => {
+    dragStatus: {
+        isDragOver: boolean;
+        isDrop: boolean;
+    };
+    isEnableDrop: boolean;
+    setIsEnableDrop: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    setDropNodeRef: import("react").MutableRefObject<any>;
+};
+export default useDrop;
+export { useDrop };

package/dist/hooks/useEmbeddedMetric.d.ts

@@ -0,0 +1,24 @@
+import { ClientColumnType } from '@/types';
+export interface UseEmbeddedMetricProps {
+    token: string;
+    metricId: string;
+}
+export declare const useEmbeddedMetric: ({ token, metricId, }: UseEmbeddedMetricProps) => {
+    externalMetric: any;
+    sharingSettingsId: string;
+    companyId: string;
+    clientId: string;
+    rlsSettings: {
+        metricId: string;
+        values: Record<string, any>;
+    } | undefined;
+    tenancyLevel: any;
+    isLoading: boolean;
+    errorMsg: any;
+    adminTheme: any;
+    workspaceId: any;
+    clientColumnType: ClientColumnType;
+    isEnableMetricSummary: boolean;
+    isAllClient: boolean;
+    isShowUnderlyingData: boolean;
+};

package/dist/hooks/useExternalMetric.d.ts

@@ -0,0 +1,55 @@
+import { FieldValues } from 'react-hook-form';
+import { DashboardType, GroupBy, RlsFilterObjectType, SelectedColumns, ChartSettingsType } from '@/types/app';
+import { DatasetSettings, DrillDownSettings } from '@/types';
+type Params = {
+    onSuccess?: () => void;
+    companyIntegrationId: string | undefined;
+    selectedColumns: SelectedColumns[] | undefined;
+    query?: string;
+    metricQuery: string | undefined;
+    outputColumns: string | undefined;
+    id?: string;
+    chartSettings?: ChartSettingsType;
+    integrationName: string | undefined;
+    clientId?: string | null;
+    isEmbedded?: boolean;
+    rlsFilters?: RlsFilterObjectType[];
+    companyId: string;
+    isLiveMode?: boolean;
+    timeGrain?: string;
+    dashboardIds?: DashboardType['id'][];
+    userProvidedDashboardId?: string;
+    isEnableGroupBy?: boolean;
+    selectedGroupBy?: string[];
+    groupBy?: GroupBy | undefined;
+    metric?: Record<string, any>;
+    datasetMetricSettings?: DatasetSettings;
+    drillDownSettings?: DrillDownSettings;
+};
+export declare const useExternalMetric: ({ onSuccess, companyIntegrationId, selectedColumns, query, metricQuery, integrationName, outputColumns, chartSettings, clientId, companyId, isLiveMode, timeGrain, dashboardIds, isEnableGroupBy, groupBy, selectedGroupBy, metric, datasetMetricSettings, drillDownSettings, }: Params) => {
+    createExternalMetric: (data: FieldValues) => void;
+    updateExternalMetric: (data: FieldValues, isElement?: boolean) => void;
+    error: string;
+    isLoading: boolean;
+    clientSubsetData: any;
+    previewTable: import("react-query").UseMutateFunction<{
+        data: unknown;
+    }, unknown, {
+        data: import("../types/queryTypes").UsePreviewTableMutationInputType;
+        token: string;
+    }, unknown>;
+    token: string | undefined;
+    workspaceId: any;
+    dashboardOptions: {
+        value: any;
+        label: any;
+    }[];
+    isDatabaseTenancy: boolean;
+    register: import("react-hook-form").UseFormRegister<FieldValues>;
+    setValue: import("react-hook-form").UseFormSetValue<FieldValues>;
+    watch: import("react-hook-form").UseFormWatch<FieldValues>;
+    handleSubmit: import("react-hook-form").UseFormHandleSubmit<FieldValues>;
+    control: import("react-hook-form").Control<FieldValues, any>;
+    reset: import("react-hook-form").UseFormReset<FieldValues>;
+};
+export {};

package/dist/hooks/useGenerateDatasetMetrics.d.ts

@@ -0,0 +1,13 @@
+export declare const useGenerateDatasetMetrics: () => {
+    generateDatasetMetric: import("react-query").UseMutateFunction<{
+        data: unknown;
+    }, unknown, {
+        data: import("../types/queryTypes").UseGenerateMetricMutationInputType;
+        token: string;
+    }, unknown>;
+    isGeneratingDataset: boolean;
+    generateError: unknown;
+    fetchColumnValues: import("react-query").UseMutateFunction<{
+        data: unknown;
+    }, unknown, import("../types/queryTypes").UseMetricColumnMutationInputType, unknown>;
+};

package/dist/hooks/useGenerateMetric.d.ts

@@ -0,0 +1,64 @@
+/// <reference types="react" />
+import { FieldValues } from 'react-hook-form';
+import EChartsReact from 'echarts-for-react';
+import { ColumnSizingState } from '@tanstack/react-table';
+import { ChartSettingsType, ConfigType, FloatingDropDownOption, GenerateMetricState, OnChangeAliasParams, OnChangeHelperFunctionParams, PivotDrillState, SelectedColumn, SetChartFieldParams, TableObjectType } from '@/types';
+declare const useGenerateMetric: (config: ConfigType) => {
+    isDisableSaveBtn: boolean;
+    setChartSettings: import("react").Dispatch<import("react").SetStateAction<ChartSettingsType>>;
+    setShowSaveMetricModal: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    isShowSaveMetricModal: boolean;
+    register: import("react-hook-form").UseFormRegister<FieldValues>;
+    errors: import("react-hook-form").FieldErrors<FieldValues>;
+    onSubmitQuery: (e?: import("react").BaseSyntheticEvent<object, any, any> | undefined) => Promise<void>;
+    generateMetricState: GenerateMetricState;
+    chartTabType: "CHART" | "ERROR" | "LOADING" | "INIT";
+    chartSettings: ChartSettingsType;
+    chartRef: import("react").RefObject<EChartsReact>;
+    onColumnSizingChange: (columnSizing: ColumnSizingState) => void;
+    watch: import("react-hook-form").UseFormWatch<FieldValues>;
+    createExternalMetric: (data: FieldValues) => void;
+    saveError: string;
+    updateExternalMetric: (data: FieldValues, isElement?: boolean | undefined) => void;
+    clientSubsetData: any;
+    previewTable: import("react-query").UseMutateFunction<{
+        data: unknown;
+    }, unknown, {
+        data: import("@/types/queryTypes").UsePreviewTableMutationInputType;
+        token: string;
+    }, unknown>;
+    token: string | undefined;
+    dashboardOptions: {
+        value: any;
+        label: any;
+    }[];
+    isCreatingMetric: boolean;
+    tableList: TableObjectType[];
+    selectedMainTable: TableObjectType | undefined;
+    setSelectedMainTable: import("react").Dispatch<import("react").SetStateAction<TableObjectType | undefined>>;
+    aiResponseState: {
+        isLoading: boolean;
+        error: string;
+    };
+    onAiQuery: () => void;
+    autoCompleteDropdownOptions: SelectedColumn[];
+    selectedColumns: SelectedColumn[];
+    setSelectedColumns: import("react").Dispatch<import("react").SetStateAction<SelectedColumn[]>>;
+    functionOptions: (col?: SelectedColumn, colDatatype?: string) => FloatingDropDownOption[];
+    setChartFields: ({ chartType, chartDimensions, chartMetrics, chartAggregateColumns, configAggregates, }: SetChartFieldParams) => void;
+    onSubmitSearch: () => void;
+    onChangeHelperFunction: ({ column, helperFunction, functionConfiguration, }: OnChangeHelperFunctionParams) => void;
+    onChangeAlias: ({ alias, column }: OnChangeAliasParams) => void;
+    chartOptions: FloatingDropDownOption[];
+    isShowChartType: boolean;
+    setShowChartType: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    enabledCharts: string[];
+    stringColumnValues: {
+        column: string;
+        values: string[];
+    }[];
+    isRef: boolean;
+    setRef: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    pivotDrillState: PivotDrillState;
+};
+export default useGenerateMetric;

package/dist/hooks/useMetricCard.d.ts

@@ -0,0 +1,121 @@
+/// <reference types="react" />
+import { ChartSettingsType, FloatingDropDownOption, RlsCondition, DatasetSettings, MetricFilterOptionsType, PivotDrillState, OnDrillPivotTableParams, ChartReportStateType } from '@/types';
+import { MetricCardProps } from '@/components';
+type UseMetricCardProps = {
+    metric: Record<string, any>;
+    clientId: string;
+    encryptedClientId?: string;
+    tenancyLevel: string;
+    globalFilters?: MetricCardProps['globalFilters'];
+    rlsFilters?: any;
+    appFilters?: any;
+    datasetSettings?: DatasetSettings;
+    setDatasetSettings?: React.Dispatch<React.SetStateAction<DatasetSettings>>;
+    isInternalApp?: boolean;
+    setCrossDashboardFilters?: React.Dispatch<React.SetStateAction<RlsCondition[]>>;
+    crossDashboardFilters?: RlsCondition[];
+    metricFilterOptions?: MetricFilterOptionsType;
+    isAllClient?: boolean;
+    isFrontendApp: boolean;
+    guestToken?: string;
+    workspaceId: string;
+    metricStore?: Map<string, {
+        data: any;
+        isLoading: boolean;
+        key: string;
+    }>;
+    setMetricStore?: React.Dispatch<React.SetStateAction<Map<string, {
+        data: any;
+        isLoading: boolean;
+        key: string;
+    }>>>;
+};
+export declare const useMetricCard: ({ metric, globalFilters, rlsFilters, clientId, tenancyLevel, isInternalApp, appFilters, setCrossDashboardFilters, crossDashboardFilters, metricFilterOptions, isAllClient, isFrontendApp, guestToken, encryptedClientId, workspaceId, metricStore, setMetricStore, }: UseMetricCardProps) => {
+    elementSummary: string;
+    isLoadingSummary: boolean;
+    isMetricListLoading: () => boolean;
+    onDrillLevelClick: (index: number) => void;
+    onDrillDown: (params: any, rowFilters?: {
+        columnName: string;
+        value: any;
+    }[] | undefined) => void;
+    handleChartClick: (params: any) => void;
+    dataDb: Record<string, any>[];
+    getUnderlyingData: ({ columnName, value, setData, setLoading, isSingleValueChart, clientColumnType, }: {
+        columnName: string | undefined;
+        value: any;
+        isSingleValueChart: boolean;
+        setData: import("react").Dispatch<import("react").SetStateAction<any[]>>;
+        setLoading: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+        clientColumnType: import("@/types").ClientColumnType;
+    }) => void;
+    onChangeFilterValue: (name: string, value: string, labelValue?: string, customValue?: Record<string, Date>, stringValues?: FloatingDropDownOption[]) => void;
+    isShowChartPopup: boolean;
+    setShowChartPopup: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    columnName: string | undefined;
+    chartParams: any;
+    isQueryLoading: boolean;
+    isSingleValueNull: boolean;
+    dynamicOptions: any;
+    chartSettings: ChartSettingsType;
+    setChartSettings: import("react").Dispatch<import("react").SetStateAction<ChartSettingsType>>;
+    isEnableZoom: boolean;
+    filterValues: Record<string, any>;
+    containerRef: import("react").RefObject<HTMLDivElement>;
+    drilledLevel: number;
+    dimensions: any;
+    rlsConditions: RlsCondition[];
+    setRlsConditions: import("react").Dispatch<import("react").SetStateAction<RlsCondition[]>>;
+    setTableLimit: import("react").Dispatch<import("react").SetStateAction<{
+        limit: number;
+        offset: number;
+    }>>;
+    isEnableNextBtn: boolean;
+    isEnablePrevBtn: boolean;
+    paginationInfo: {
+        limit: number;
+        offset: number;
+        totalRecords: number;
+    };
+    onChangePage: (isPrev: boolean, resetValue?: number, nextOffset?: number) => void;
+    isExternalChart: boolean | undefined;
+    isEnablePivotTable: boolean;
+    groupByList: any[];
+    hasNumberKeys: boolean;
+    isEnableGauge: boolean;
+    updateFilter: (filter: RlsCondition) => void;
+    metricFilters: RlsCondition[];
+    leftPositionedMetricFilters: RlsCondition[];
+    rightPositionedMetricFilters: RlsCondition[];
+    drillFilters: {
+        columnName: string;
+        value: string | number;
+    }[];
+    drillType: any;
+    tableResultsDownloadData: Record<string, any>[];
+    appliedMetricFilters: RlsCondition[];
+    pivotHeaderOptions: FloatingDropDownOption[];
+    pivotDrillState: PivotDrillState;
+    onDrillPivotTable: ({ filters, nextLevel, currentValue, }: OnDrillPivotTableParams) => void;
+    legendData: any;
+    timeseriesDimension: any;
+    isPythonMode: boolean;
+    sortOrder: string;
+    setSortOrder: import("react").Dispatch<import("react").SetStateAction<string>>;
+    isNotFirstRender: boolean;
+    setNotFirstRender: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    isSorted: boolean;
+    isInavlidForSort: boolean | undefined;
+    onAddComparison: (isRemove?: boolean) => void;
+    groupedRlsConditions: Record<string | undefined, RlsCondition[]>;
+    onGenerateMetricSummary: () => void;
+    summary: ChartReportStateType;
+    setSummary: import("react").Dispatch<import("react").SetStateAction<ChartReportStateType>>;
+    dataMartRelationships: any;
+    onChartChange: (chartType: ChartSettingsType['chartType']) => void;
+    isCompareValue: boolean;
+    isShowChartPropertyPanel: boolean;
+    setShowChartPropertyPanel: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    columnList: string[];
+};
+export {};