@yugabytedb/perf-advisor-ui 1.0.134 → 1.0.136

package/dist/components/PrimaryDashboard/HistoricalQueryData.d.ts

@@ -0,0 +1,25 @@
+import { AppName, ClusterDetails, QueryPageParams, WaitEventClassification, QueryTypeMode, PaFeatureRuntimeConfigs } from '../../helpers/dtos';
+export interface QueryRowEntry {
+    id: string;
+    query: string;
+    [key: string]: string | number | undefined;
+}
+interface HistoricalQueryDataProps {
+    universeUuid: string;
+    apiUrl: string;
+    startTime: string | null;
+    endTime: string | null;
+    appName: AppName;
+    groupByOperation: WaitEventClassification;
+    filteredLegends: string[];
+    shouldShowSystemQueries?: boolean;
+    getClusterDetails: () => ClusterDetails;
+    queryType: QueryTypeMode;
+    qpmEnabled: boolean;
+    qpmSupported: boolean;
+    runtimeConfigs?: PaFeatureRuntimeConfigs;
+    onSelectedQuery?: (queryId: string, params: QueryPageParams) => void;
+    onNavigateToUrl?: (url: string) => void;
+}
+export declare const HistoricalQueryData: ({ universeUuid, apiUrl, startTime, endTime, appName, groupByOperation, filteredLegends, shouldShowSystemQueries, qpmEnabled, qpmSupported, runtimeConfigs, getClusterDetails, onSelectedQuery, onNavigateToUrl }: HistoricalQueryDataProps) => JSX.Element;
+export {};

package/dist/components/PrimaryDashboard/PerfAdvisorBanner.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+interface PerfAdvisorBannerProps {
+    isAshBanner: boolean;
+    isAshViewSupported?: boolean;
+    isPgssRpcStatsViewSupported?: boolean;
+}
+export declare const PerfAdvisorBanner: ({ isAshBanner, isAshViewSupported, isPgssRpcStatsViewSupported }: PerfAdvisorBannerProps) => JSX.Element;
+export {};

package/dist/components/PrimaryDashboard/PerfAdvisorEntry.d.ts

@@ -0,0 +1,14 @@
+import { AppName, QueryPageParams, PAUrlParams, PaFeatureRuntimeConfigs } from '../../helpers/dtos';
+interface PerfAdvisorEntryProps {
+    universeUuid: string;
+    appName: AppName;
+    apiUrl: string;
+    showStandaloneAnomalies?: boolean;
+    runtimeConfigs?: PaFeatureRuntimeConfigs;
+    onSelectedIssue?: (troubleshootUuid: string, params?: PAUrlParams) => void;
+    onSelectedQuery?: (queryId: string, params?: QueryPageParams) => void;
+    onNavigateToUrl?: (url: string) => void;
+    backgroundTasksMappingFunc?: (value: string) => string;
+}
+export declare const PerfAdvisorEntry: ({ universeUuid, appName, apiUrl, runtimeConfigs, showStandaloneAnomalies, onSelectedIssue, onSelectedQuery, onNavigateToUrl, backgroundTasksMappingFunc }: PerfAdvisorEntryProps) => JSX.Element;
+export {};

package/dist/components/PrimaryDashboard/PerfAdvisorTabs.d.ts

@@ -0,0 +1,30 @@
+import { AppName, QueryPageParams, PAUrlParams, InsightsTabs, PaFeatureRuntimeConfigs } from '../../helpers/dtos';
+interface PerfAdvisorTabsProps {
+    startTime: Date | null;
+    endTime: Date | null;
+    universeUuid: string;
+    appName: AppName;
+    isAshEnabled: boolean;
+    isAshSupported: boolean;
+    isK8sUniverse?: boolean;
+    qpmEnabled: boolean;
+    qpmSupported: boolean;
+    apiUrl: string;
+    filterDuration: string;
+    showStandaloneAnomalies: boolean;
+    runtimeConfigs?: PaFeatureRuntimeConfigs;
+    onClickShowMoreAnomalies: (category: string) => void;
+    backgroundTasksMappingFunc?: (value: string) => string;
+    onEChartsDateSelect: (start: number, end: number) => void;
+    onSelectedIssue?: (troubleshootUuid: string, params?: PAUrlParams) => void;
+    onSelectedQuery?: (queryId: string, params?: QueryPageParams) => void;
+    notifyTabChange: (tab: InsightsTabs) => void;
+    onStartDateChange: (value: Date | string | null) => void;
+    onEndDateChange: (value: Date | string | null) => void;
+    onRefresh: () => void;
+    onSelectedFilterDuration: (filterDuration: string) => void;
+    onNavigateToUrl?: (url: string) => void;
+    onTimezoneChange?: (timezone: string) => void;
+}
+export declare const PerfAdvisorTabs: ({ startTime, endTime, universeUuid, appName, filterDuration, apiUrl, isAshEnabled, isAshSupported, isK8sUniverse, qpmEnabled, qpmSupported, showStandaloneAnomalies, runtimeConfigs, onClickShowMoreAnomalies, onEChartsDateSelect, onSelectedIssue, onSelectedQuery, notifyTabChange, onStartDateChange, onEndDateChange, onRefresh, onSelectedFilterDuration, onNavigateToUrl, onTimezoneChange, backgroundTasksMappingFunc }: PerfAdvisorTabsProps) => JSX.Element;
+export {};

package/dist/components/PrimaryDashboard/ProcessTopKData.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+import { AppName, ClusterDetails } from '../../helpers/dtos';
+export interface ProcessGraphDataProps {
+    universeUuid: string;
+    appName: AppName;
+    apiUrl: string;
+    isK8sUniverse?: boolean;
+    onEChartsDateSelect: (start: number, end: number) => void;
+    getClusterDetails: () => ClusterDetails;
+}
+export declare const ProcessTopKData: React.MemoExoticComponent<({ universeUuid, appName, apiUrl, isK8sUniverse, onEChartsDateSelect, getClusterDetails }: ProcessGraphDataProps) => JSX.Element>;

package/dist/components/PrimaryDashboard/QueryEventsChart.d.ts

@@ -0,0 +1,7 @@
+import { QueryWaitEvents, WaitEventClassification } from '../../helpers/dtos';
+export declare const QueryEventsChart: ({ data, maxEPS, groupByOperation, isTabletAnomaly }: {
+    data: QueryWaitEvents[];
+    maxEPS: number;
+    groupByOperation: WaitEventClassification;
+    isTabletAnomaly?: boolean | undefined;
+}) => JSX.Element;

package/dist/components/PrimaryDashboard/QueryExportDropdown.d.ts

@@ -0,0 +1,13 @@
+import { AppName } from '../../helpers/dtos';
+interface QueryExportDropdownProps {
+    isSelectMode: boolean;
+    selectedCount: number;
+    isFetching: boolean;
+    totalSize: number;
+    appName: AppName;
+    onOpenModal: () => void;
+    onEnterSelectMode: () => void;
+    onExitSelectMode: () => void;
+}
+export declare const QueryExportDropdown: ({ isSelectMode, selectedCount, isFetching, totalSize, appName, onOpenModal, onEnterSelectMode, onExitSelectMode }: QueryExportDropdownProps) => JSX.Element;
+export {};

package/dist/components/PrimaryDashboard/ShowMoreAnomalies.d.ts

@@ -0,0 +1,22 @@
+import { AppName, InsightsTabs, PAUrlParams } from '../../helpers/dtos';
+interface ShowMoreAnomaliesProps {
+    onClickShowMoreAnomalies: (category: string | null) => void;
+    selectedTab: InsightsTabs;
+    showMoreAnomalyCategory: string | null;
+    startTime: string | null;
+    endTime: string | null;
+    apiUrl: string;
+    universeUuid: string;
+    appName: AppName;
+    filterDuration: string;
+    onSelectedFilterDuration: (filterDuration: string) => void;
+    onStartDateChange: (value: Date | string | null) => void;
+    onEndDateChange: (value: Date | string | null) => void;
+    onRefresh: () => void;
+    onTimezoneChange?: (tz: string) => void;
+    onSelectedIssue?: (troubleshootUuid: string, params?: PAUrlParams) => void;
+    onNavigateToUrl?: (url: string) => void;
+    onTimeRangeSelect?: (start: number, end: number) => void;
+}
+export declare const ShowMoreAnomalies: ({ showMoreAnomalyCategory, selectedTab, startTime, endTime, apiUrl, universeUuid, appName, filterDuration, onSelectedFilterDuration, onStartDateChange, onEndDateChange, onRefresh, onTimezoneChange, onClickShowMoreAnomalies, onSelectedIssue, onNavigateToUrl, onTimeRangeSelect }: ShowMoreAnomaliesProps) => JSX.Element;
+export {};

package/dist/components/PrimaryDashboard/chartConfigs/clusterLoadConfig.d.ts

@@ -0,0 +1,8 @@
+import { ChartConfig } from '../../../common/ChartCard';
+import { AnomalyGroup, WaitEventClassification } from '../../../helpers/dtos';
+export interface ClusterLoadConfigOptions {
+    anomalyData?: AnomalyGroup | null;
+    groupByOperation: WaitEventClassification;
+    shouldAbbreviateTraceName?: boolean;
+}
+export declare const makeClusterLoadConfig: ({ anomalyData, groupByOperation, shouldAbbreviateTraceName }: ClusterLoadConfigOptions) => ChartConfig;

package/dist/components/PrimaryDashboard/chartConfigs/cpuByDatabaseConfig.d.ts

@@ -0,0 +1,9 @@
+import { ChartConfig } from '../../../common/ChartCard';
+import { AnomalyGroup } from '../../../helpers/dtos';
+export interface CpuByDatabaseConfigOptions {
+    anomalyData?: AnomalyGroup | null;
+    shouldAbbreviateTraceName?: boolean;
+    thresholdValuesMap?: Record<string | number, number>;
+}
+export declare const makeCpuByDatabaseConfig: ({ anomalyData, shouldAbbreviateTraceName, thresholdValuesMap }?: CpuByDatabaseConfigOptions) => ChartConfig;
+export declare const cpuByDatabaseConfig: ChartConfig;

package/dist/components/PrimaryDashboard/chartConfigs/dbNodeLoadConfig.d.ts

@@ -0,0 +1,9 @@
+import { ChartConfig } from '../../../common/ChartCard';
+import { AnomalyGroup, ChartViewMode } from '../../../helpers/dtos';
+export type DbNodeLoadView = typeof ChartViewMode.DB | typeof ChartViewMode.NODE;
+export interface DbNodeLoadConfigOptions {
+    view: DbNodeLoadView;
+    anomalyData?: AnomalyGroup | null;
+    shouldAbbreviateTraceName?: boolean;
+}
+export declare const makeDbNodeLoadConfig: ({ view, anomalyData, shouldAbbreviateTraceName }: DbNodeLoadConfigOptions) => ChartConfig;

package/dist/components/PrimaryDashboard/chartConfigs/index.d.ts

@@ -0,0 +1,7 @@
+export { makeClusterLoadConfig } from './clusterLoadConfig';
+export type { ClusterLoadConfigOptions } from './clusterLoadConfig';
+export { cpuByDatabaseConfig, makeCpuByDatabaseConfig } from './cpuByDatabaseConfig';
+export type { CpuByDatabaseConfigOptions } from './cpuByDatabaseConfig';
+export { makeDbNodeLoadConfig } from './dbNodeLoadConfig';
+export type { DbNodeLoadConfigOptions, DbNodeLoadView } from './dbNodeLoadConfig';
+export { makeYbHostRenderError, DASHED_LINE_RICH, toPoints } from './shared';

package/dist/components/PrimaryDashboard/chartConfigs/shared.d.ts

@@ -0,0 +1,8 @@
+import { ReactNode } from 'react';
+import { EChartsPoint, RichTextFragment, SeriesDataItem } from '../../../common/ChartCard';
+import { AppName } from '../../../helpers/dtos';
+export declare const DASHED_LINE_RICH: RichTextFragment;
+export declare const THRESHOLD_LINE_RICH: RichTextFragment;
+export declare const THICK_LINE_RICH: RichTextFragment;
+export declare const toPoints: (item: SeriesDataItem) => EChartsPoint[];
+export declare const makeYbHostRenderError: (appName: AppName) => (errorText?: string) => ReactNode;

package/dist/components/PrimaryDashboard/chartTitles.d.ts

@@ -0,0 +1,2 @@
+import { ChartViewMode, DbWaitEventType } from '../../helpers/dtos';
+export declare const getChartTitleText: (dbWaitEventType: DbWaitEventType, view: ChartViewMode) => string;

package/dist/components/PrimaryDashboard/useChartData.d.ts

@@ -0,0 +1,29 @@
+import { Aggregation, ClusterLoadResponseData, GraphFilters, SplitMode, SplitType, WaitEventClassification } from '../../helpers/dtos';
+export interface ChartMetricRequest {
+    name: string;
+    groupBy?: WaitEventClassification[];
+    splitMode?: SplitMode;
+    splitType?: SplitType;
+    splitCount?: number;
+}
+export interface UseChartDataArgs {
+    apiUrl: string;
+    universeUuid: string;
+    startTime: string | null;
+    endTime: string | null;
+    isAshEnabled: boolean;
+    metrics: ChartMetricRequest[];
+    filters: GraphFilters;
+    splitType: SplitType;
+    splitMode: SplitMode;
+    splitCount: number;
+    aggregation: Aggregation;
+    deps: unknown[];
+}
+export interface UseChartDataResult {
+    data: ClusterLoadResponseData[] | null;
+    isLoading: boolean;
+    isError: boolean;
+    errorText: string | undefined;
+}
+export declare const useChartData: ({ apiUrl, universeUuid, startTime, endTime, isAshEnabled, metrics, filters, splitType, splitMode, splitCount, aggregation, deps }: UseChartDataArgs) => UseChartDataResult;

package/dist/components/RuntimeConfigs/ResetRuntimeConfig.d.ts

@@ -0,0 +1,14 @@
+import { RuntimeConfigData } from '../../helpers/dtos';
+interface ResetRuntimeConfigProps {
+    data: RuntimeConfigData;
+    open: boolean;
+    onClose: () => void;
+    onActionPerformed: () => void;
+    apiUrl: string;
+    toast: {
+        success: (message: string) => void;
+        error: (message: string) => void;
+    };
+}
+export declare const ResetRuntimeConfig: ({ data, open, apiUrl, onClose, onActionPerformed, toast }: ResetRuntimeConfigProps) => JSX.Element;
+export {};

package/dist/components/RuntimeConfigs/RuntimeConfigs.d.ts

@@ -0,0 +1,11 @@
+import { AppName } from '../../helpers/dtos';
+interface RuntimeConfigsProps {
+    apiUrl: string;
+    appName: AppName;
+    toast: {
+        success: (message: string) => void;
+        error: (message: string) => void;
+    };
+}
+export declare const RuntimeConfigs: ({ apiUrl, appName, toast }: RuntimeConfigsProps) => JSX.Element;
+export {};

package/dist/components/RuntimeConfigs/UpdateRuntimeConfig.d.ts

@@ -0,0 +1,14 @@
+import { RuntimeConfigData } from '../../helpers/dtos';
+interface UpdateRuntimeConfigProps {
+    data: RuntimeConfigData;
+    open: boolean;
+    onClose: () => void;
+    onActionPerformed: () => void;
+    apiUrl: string;
+    toast: {
+        success: (message: string) => void;
+        error: (message: string) => void;
+    };
+}
+export declare const UpdateRuntimeConfig: ({ data, open, apiUrl, onClose, onActionPerformed, toast }: UpdateRuntimeConfigProps) => JSX.Element;
+export {};

package/dist/components/SecondaryDashboard/AnomalyPossibleCause.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+import { AnomalyGroup } from '../../helpers/dtos';
+export interface AnomalyPossibleCauseProps {
+    accordianExpanded?: boolean;
+    anomalyGroupData: AnomalyGroup | null;
+}
+export declare const AnomalyPossibleCause: React.FC<AnomalyPossibleCauseProps>;

package/dist/components/SecondaryDashboard/AnomalyRouter.d.ts

@@ -0,0 +1,30 @@
+import { AnomalyGroup, AppName, ClusterDetails, GraphRequestParams, PAUrlParams, QueryPageParams, SqlTabs, SplitMode, TabletTabs, UrlParams, Universe } from '../../helpers/dtos';
+interface AnomalyRouterProps {
+    metricMeasure: string;
+    appName: AppName;
+    timezone?: string;
+    showTimezoneSelector?: boolean;
+    showPgssRpcStats?: boolean;
+    universeDetails: Universe;
+    universeQueryStatsData: any;
+    amomalyGraphRequestParams: GraphRequestParams[] | null;
+    anomalyData: AnomalyGroup | null;
+    gantChartData: any;
+    urlParams: UrlParams;
+    dateTimeRange: {
+        startDateTime: Date;
+        endDateTime: Date;
+    };
+    apiUrl: string;
+    sqlTab: SqlTabs;
+    tabletTab: TabletTabs;
+    getClusterDetails: () => ClusterDetails;
+    onOutlierTypeSelected: (outlierType: SplitMode) => void;
+    onNumNodesChanged: (numNodes: number) => void;
+    onEChartsDateSelect: (startDateTime: number, endDateTime: number) => void;
+    onSelectedIssue?: (troubleshootUuid: string | null, params?: PAUrlParams) => void;
+    onSelectedQuery?: (queryId: string | null, params?: QueryPageParams) => void;
+    onNavigateToUrl?: (url: string) => void;
+}
+export declare const AnomalyRouter: ({ metricMeasure, appName, universeQueryStatsData, amomalyGraphRequestParams, showPgssRpcStats, anomalyData, universeDetails, gantChartData, dateTimeRange, urlParams, apiUrl, sqlTab, tabletTab, getClusterDetails, onEChartsDateSelect, onSelectedIssue, onSelectedQuery, onOutlierTypeSelected, onNumNodesChanged, onNavigateToUrl }: AnomalyRouterProps) => JSX.Element;
+export {};

package/dist/components/SecondaryDashboard/DrilldownView/CpuSaturationDrilldown.d.ts

@@ -0,0 +1,17 @@
+import { AnomalyGroup, AppName, ClusterDetails, QueryPageParams } from '../../../helpers/dtos';
+interface CpuSaturationDrilldownProps {
+    appName: AppName;
+    apiUrl: string;
+    anomalyData: AnomalyGroup | null;
+    dateTimeRange: {
+        startDateTime: Date;
+        endDateTime: Date;
+    };
+    metricMeasure: string;
+    getClusterDetails: () => ClusterDetails;
+    onEChartsDateSelect: (startDateTime: number, endDateTime: number) => void;
+    onSelectedQuery?: (queryId: string | null, params?: QueryPageParams) => void;
+    onNavigateToUrl?: (url: string) => void;
+}
+export declare const CpuSaturationDrilldown: ({ appName, apiUrl, anomalyData, dateTimeRange, metricMeasure, getClusterDetails, onEChartsDateSelect, onSelectedQuery, onNavigateToUrl }: CpuSaturationDrilldownProps) => JSX.Element;
+export {};

package/dist/components/SecondaryDashboard/DrilldownView/HistoricalQueryMetricGraphGrid.d.ts

@@ -0,0 +1,22 @@
+import { AppName, GraphRequestParams, GraphResponse, UniverseQueryData } from '../../../helpers/dtos';
+/// <reference types="react" />
+import * as echarts from 'echarts/core';
+export interface HistoricalQueryMetricGraphGridProps {
+    chartRowKeyPrefix: string;
+    gridClassName: string;
+    isLoading: boolean;
+    loadingPlaceholders: GraphResponse[];
+    queryGraphData: GraphResponse[] | null;
+    metricMeasure: string;
+    dateTimeRange: {
+        startDateTime: Date;
+        endDateTime: Date;
+    };
+    historicalQueryRequestParams: GraphRequestParams[] | [];
+    appName: AppName;
+    universeQueryStatsData?: UniverseQueryData[];
+    onSelectAshLabel: (groupByLabel: string, metricData: GraphResponse, isHistoricalQueryView?: boolean) => void;
+    onEChartsDateSelect: (startDateTime: number, endDateTime: number) => void;
+    registerChartInstance: (instance: echarts.ECharts, index: number) => void;
+}
+export declare function HistoricalQueryMetricGraphGrid({ chartRowKeyPrefix, gridClassName, isLoading, loadingPlaceholders, queryGraphData, metricMeasure, dateTimeRange, historicalQueryRequestParams, appName, universeQueryStatsData, onSelectAshLabel, onEChartsDateSelect, registerChartInstance }: HistoricalQueryMetricGraphGridProps): JSX.Element;

package/dist/components/SecondaryDashboard/DrilldownView/NodeDrilldown.d.ts

@@ -0,0 +1,23 @@
+import { AnomalyGroup, AppName, ClusterDetails, QueryPageParams, SplitMode, WaitEventClassification } from '../../../helpers/dtos';
+interface NodeDrilldownProps {
+    appName: AppName;
+    dbWaitEventType: string;
+    apiUrl: string;
+    dateTimeRange: {
+        startDateTime: Date;
+        endDateTime: Date;
+    };
+    groupByOperation: WaitEventClassification;
+    anomalyData: AnomalyGroup | null;
+    onFilterBarData: (data: string[]) => void;
+    onChangeDbWaitEventType: (waitEventType: string) => void;
+    getClusterDetails: () => ClusterDetails;
+    onSelectedQuery?: (queryId: string | null, params?: QueryPageParams) => void;
+    onSetGroupByOperation: (operation: WaitEventClassification) => void;
+    onOutlierTypeSelected: (selectedOption: SplitMode) => void;
+    onNumNodesChanged: (numNodes: number) => void;
+    onEChartsDateSelect: (startDateTime: number, endDateTime: number) => void;
+    onNavigateToUrl?: (url: string) => void;
+}
+export declare const NodeDrilldown: ({ appName, anomalyData, dbWaitEventType, apiUrl, dateTimeRange, onFilterBarData, onChangeDbWaitEventType, getClusterDetails, onOutlierTypeSelected, onNumNodesChanged, onEChartsDateSelect, onSelectedQuery, onNavigateToUrl }: NodeDrilldownProps) => JSX.Element;
+export {};

package/dist/components/SecondaryDashboard/DrilldownView/OtherDrilldown.d.ts

@@ -0,0 +1,20 @@
+import { AnomalyGroup, AppName, GraphRequestParams, PAUrlParams, UniverseQueryData, UrlParams, ClusterDetails } from '../../../helpers/dtos';
+interface OtherDrilldownProps {
+    metricMeasure: string;
+    appName: AppName;
+    universeQueryData: UniverseQueryData[];
+    amomalyGraphRequestParams: GraphRequestParams[] | null;
+    anomalyData: AnomalyGroup | null;
+    gantChartData: any;
+    urlParams: UrlParams;
+    dateTimeRange: {
+        startDateTime: Date;
+        endDateTime: Date;
+    };
+    apiUrl: string;
+    getClusterDetails: () => ClusterDetails;
+    onEChartsDateSelect: (startDateTime: number, endDateTime: number) => void;
+    onSelectedIssue?: (troubleshootUuid: string | null, params?: PAUrlParams) => void;
+}
+export declare const OtherDrilldown: ({ metricMeasure, appName, universeQueryData, amomalyGraphRequestParams, anomalyData, gantChartData, dateTimeRange, urlParams, apiUrl, getClusterDetails, onEChartsDateSelect, onSelectedIssue }: OtherDrilldownProps) => JSX.Element;
+export {};

package/dist/components/SecondaryDashboard/DrilldownView/QPMExportButton.d.ts

@@ -0,0 +1,8 @@
+import { QueryPlanData, QueryPlanEntry } from '../../../helpers/dtos';
+interface QPMExportButtonProps {
+    queryPlanData: QueryPlanData | undefined;
+    plans: QueryPlanEntry[];
+    disabled?: boolean;
+}
+export declare const QPMExportButton: ({ queryPlanData, plans, disabled }: QPMExportButtonProps) => JSX.Element;
+export {};

package/dist/components/SecondaryDashboard/DrilldownView/QPMPlanSelector.d.ts

@@ -0,0 +1,9 @@
+import { ProcessedQueryPlan } from '../../../helpers/utils';
+interface QPMPlanSelectorProps {
+    plans: ProcessedQueryPlan[];
+    selectedIndex: number;
+    loading?: boolean;
+    onChange: (index: number) => void;
+}
+export declare const QPMPlanSelector: ({ plans, loading, onChange, selectedIndex }: QPMPlanSelectorProps) => JSX.Element;
+export {};

package/dist/components/SecondaryDashboard/DrilldownView/QueryPlanManagement.d.ts

@@ -0,0 +1,16 @@
+import { AppName, QueryPlanData, Universe } from '../../../helpers/dtos';
+interface QueryPlanManagementProps {
+    queryPlanData: QueryPlanData | undefined;
+    dateTimeRange: {
+        startDateTime: Date;
+        endDateTime: Date;
+    };
+    isLoading: boolean;
+    isRefetching?: boolean;
+    universeDetails: Universe;
+    appName: AppName;
+    showQueriesExport?: boolean;
+    onEChartsDateSelect?: (start: number, end: number) => void;
+}
+export declare const QueryPlanManagement: ({ universeDetails, queryPlanData, dateTimeRange, isLoading, isRefetching, appName, showQueriesExport, onEChartsDateSelect }: QueryPlanManagementProps) => JSX.Element;
+export {};

package/dist/components/SecondaryDashboard/DrilldownView/SqlDrilldown.d.ts

@@ -0,0 +1,20 @@
+import { AnomalyGroup, AppName, ClusterDetails, SqlTabs, Universe, UrlParams } from '../../../helpers/dtos';
+interface SqlDrilldownProps {
+    universeDetails: Universe;
+    metricMeasure: string;
+    showPgssRpcStats?: boolean;
+    apiUrl: string;
+    universeQueryStatsData: any;
+    appName: AppName;
+    urlParams: UrlParams;
+    dateTimeRange: {
+        startDateTime: Date;
+        endDateTime: Date;
+    };
+    sqlTab: SqlTabs;
+    anomalyData: AnomalyGroup | null;
+    getClusterDetails: () => ClusterDetails;
+    onEChartsDateSelect: (startDateTime: number, endDateTime: number) => void;
+}
+export declare const SqlDrilldown: ({ universeDetails, metricMeasure, showPgssRpcStats, anomalyData, apiUrl, universeQueryStatsData, appName, sqlTab, urlParams, dateTimeRange, getClusterDetails, onEChartsDateSelect }: SqlDrilldownProps) => JSX.Element;
+export {};

package/dist/components/SecondaryDashboard/DrilldownView/TabletDrilldown.d.ts

@@ -0,0 +1,15 @@
+import { AnomalyGroup, AppName, ClusterDetails, QueryPageParams, TabletTabs } from '../../../helpers/dtos';
+interface TabletDrilldownProps {
+    appName: AppName;
+    getClusterDetails: () => ClusterDetails;
+    tabletTab: TabletTabs;
+    apiUrl: string;
+    startTime: string;
+    endTime: string;
+    isHotTablet: boolean;
+    anomalyData: AnomalyGroup;
+    onSelectedQuery?: (queryId: string | null, params?: QueryPageParams) => void;
+    onNavigateToUrl?: (url: string) => void;
+}
+export declare const TabletDrilldown: ({ appName, getClusterDetails, apiUrl, tabletTab, startTime, endTime, isHotTablet, anomalyData, onSelectedQuery, onNavigateToUrl }: TabletDrilldownProps) => JSX.Element;
+export {};

package/dist/components/SecondaryDashboard/GraphView.d.ts

@@ -0,0 +1,39 @@
+import { default as React } from 'react';
+import { GraphResponse, GraphType, UniverseQueryData, AppName, AnomalyGroup } from '../../helpers/dtos';
+import * as echarts from 'echarts/core';
+interface GraphViewProps {
+    metricData: GraphResponse;
+    appName: AppName;
+    metricKey: string;
+    containerWidth: number | null;
+    metricMeasure: string;
+    graphType: GraphType;
+    operations: string[];
+    anomalyData?: AnomalyGroup | null;
+    groupByOperations: string[];
+    height?: number;
+    width?: number;
+    timezone?: string;
+    graphTitle?: string;
+    queryData?: UniverseQueryData[];
+    isHistoricalQueryView?: boolean;
+    showTitle?: boolean;
+    loading?: boolean;
+    dateTimeRange: {
+        startDateTime: Date;
+        endDateTime: Date;
+    };
+    isRecommendationGraph?: boolean;
+    /**
+     * Render non-reference series as stacked bars instead of lines (e.g. for the
+     * CPU saturation Overall view, where wait-event-grouped events are easier to
+     * compare as stacked bars). Reference series like the CPU cores line still
+     * render as a dashed line.
+     */
+    useStackedBars?: boolean;
+    registerChartInstance?: (instance: echarts.ECharts) => void;
+    onEChartsDateSelect: (startDateTime: number, endDateTime: number) => void;
+    onSelectAshLabel?: (groupBy: string, metricData: GraphResponse, isHistoricalQueryView?: boolean) => void;
+}
+export declare const GraphView: React.MemoExoticComponent<({ metricData, appName, metricKey, metricMeasure, operations, groupByOperations, anomalyData, height, isRecommendationGraph, timezone, graphTitle, graphType, queryData, dateTimeRange, isHistoricalQueryView, showTitle, loading, useStackedBars, onEChartsDateSelect, onSelectAshLabel, registerChartInstance }: GraphViewProps) => JSX.Element>;
+export {};

package/dist/components/SecondaryDashboard/Metadata/AnomalyRCAGraphs.d.ts

@@ -0,0 +1,25 @@
+import { AnomalyGroup, AppName, ClusterDetails, GraphRequestParams, UrlParams } from '../../../helpers/dtos';
+interface AnomalyRCAGraphsProps {
+    appName: AppName;
+    metricMeasure: string;
+    startTime: string;
+    endTime: string;
+    anomalyData: AnomalyGroup;
+    apiUrl: string;
+    amomalyGraphRequestParams: GraphRequestParams[] | null;
+    formattedMainGraphs: {
+        name: string;
+        index: number;
+        groupByControl: boolean;
+        displayName?: string;
+    }[];
+    urlParams: UrlParams;
+    dateTimeRange: {
+        startDateTime: Date;
+        endDateTime: Date;
+    };
+    getClusterDetails: () => ClusterDetails;
+    onEChartsDateSelect: (startDateTime: number, endDateTime: number) => void;
+}
+export declare const AnomalyRCAGraphs: ({ appName, startTime, endTime, dateTimeRange, metricMeasure, anomalyData, getClusterDetails, apiUrl, amomalyGraphRequestParams, formattedMainGraphs, urlParams, onEChartsDateSelect }: AnomalyRCAGraphsProps) => JSX.Element | null;
+export {};

package/dist/components/SecondaryDashboard/Metadata/NodeLoadMetadata.d.ts

@@ -0,0 +1,13 @@
+import { AppName, QueryPageParams } from '../../../helpers/dtos';
+interface NodeLoadMetadataProps {
+    appName: AppName;
+    dbWaitEventType: string;
+    universeUuid: string;
+    apiUrl: string;
+    startTime: string;
+    endTime: string;
+    onSelectedQuery?: (queryId: string | null, params?: QueryPageParams) => void;
+    onNavigateToUrl?: (url: string) => void;
+}
+export declare const NodeLoadMetadata: ({ universeUuid, appName, apiUrl, startTime, endTime, dbWaitEventType, onSelectedQuery, onNavigateToUrl }: NodeLoadMetadataProps) => JSX.Element;
+export {};

package/dist/components/SecondaryDashboard/Metadata/QueriesMetadata.d.ts

@@ -0,0 +1,20 @@
+import { AppName, QueryPageParams, WaitEventClassification } from '../../../helpers/dtos';
+interface QueriesMetadataProps {
+    groupByOperation?: WaitEventClassification;
+    dbWaitEventType: string;
+    universeUuid: string;
+    name: string;
+    apiUrl: string;
+    appName: AppName;
+    startTime: string | null;
+    endTime: string | null;
+    withBorder?: boolean;
+    onSelectedQuery?: (queryId: string, params?: QueryPageParams) => void;
+    onSetGroupByOperation?: (groupByOperation: WaitEventClassification) => void;
+    onNavigateToUrl?: (url: string) => void;
+    isDbLoadMetadata?: boolean;
+    isNodeLoadMetadata?: boolean;
+    isTabletLoadMetadata?: boolean;
+}
+export declare const QueriesMetadata: ({ dbWaitEventType, name, apiUrl, appName, startTime, endTime, universeUuid, withBorder, groupByOperation, isDbLoadMetadata, isNodeLoadMetadata, isTabletLoadMetadata, onSelectedQuery, onSetGroupByOperation, onNavigateToUrl }: QueriesMetadataProps) => JSX.Element;
+export {};

package/dist/components/SecondaryDashboard/Metadata/QueryLevelTabletMetadata.d.ts

@@ -0,0 +1,14 @@
+import { AppName, ClusterDetails, GroupEventsBy } from '../../../helpers/dtos';
+interface QueryLevelTabletMetadataProps {
+    appName: AppName;
+    getClusterDetails: () => ClusterDetails;
+    universeUuid: string;
+    apiUrl: string;
+    dbId: string | null;
+    queryId: string | null;
+    startTime: string;
+    endTime: string;
+    groupBy: GroupEventsBy;
+}
+export declare const QueryLevelTabletMetadata: ({ universeUuid, appName, apiUrl, startTime, endTime, getClusterDetails, queryId, dbId, groupBy }: QueryLevelTabletMetadataProps) => JSX.Element;
+export {};

package/dist/components/SecondaryDashboard/Metadata/SizeBarChart.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+export declare const SizeBarChart: ({ size, maxSize, isHotTablet }: {
+    size: number;
+    maxSize: number;
+    isHotTablet: boolean;
+}) => JSX.Element;

package/dist/components/SecondaryDashboard/Metadata/TabletLevelQueryMetadata.d.ts

@@ -0,0 +1,14 @@
+import { AppName, QueryPageParams, TabletResponseMetadata } from '../../../helpers/dtos';
+interface TabletLevelQueryMetadataProps {
+    anomalyTabletData: TabletResponseMetadata;
+    isHotTablet: boolean;
+    universeUuid: string;
+    apiUrl: string;
+    appName: AppName;
+    startTime: string;
+    endTime: string;
+    onSelectedQuery?: (queryId: string | null, params?: QueryPageParams) => void;
+    onNavigateToUrl?: (url: string) => void;
+}
+export declare const TabletLevelQueryMetadata: ({ anomalyTabletData, isHotTablet, universeUuid, apiUrl, appName, startTime, endTime, onSelectedQuery, onNavigateToUrl }: TabletLevelQueryMetadataProps) => JSX.Element;
+export {};

package/dist/components/SecondaryDashboard/Metadata/TabletMetadata.d.ts

@@ -0,0 +1,18 @@
+import { AppName, ClusterDetails, QueryPageParams } from '../../../helpers/dtos';
+interface TabletMetadataProps {
+    appName: AppName;
+    getClusterDetails: () => ClusterDetails;
+    universeUuid: string;
+    apiUrl: string;
+    tableName: string | null;
+    dbName: string | null;
+    schemaName: string | null;
+    tabletId: string | null;
+    startTime: string;
+    endTime: string;
+    isHotTablet: boolean;
+    onSelectedQuery?: (queryId: string | null, params?: QueryPageParams) => void;
+    onNavigateToUrl?: (url: string) => void;
+}
+export declare const TabletMetadata: ({ universeUuid, appName, apiUrl, startTime, endTime, getClusterDetails, tableName, dbName, schemaName, tabletId, isHotTablet, onSelectedQuery, onNavigateToUrl }: TabletMetadataProps) => JSX.Element;
+export {};