@yugabytedb/perf-advisor-ui 1.0.133 → 1.0.135

package/dist/components/Header/metadata/sqlMetadataFields.d.ts

@@ -0,0 +1,4 @@
+import { QueryPlanData } from '../../../helpers/dtos';
+import { MetadataFieldConfig } from './MetadataField';
+/** Builds the shared SQL metadata trio (DATABASE / QUERY TYPE / QUERY ID). */
+export declare const buildSqlMetadataFields: (query: QueryPlanData | undefined, variant: 'anomaly' | 'historical') => MetadataFieldConfig[];

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

@@ -0,0 +1,7 @@
+import { ReactNode } from 'react';
+export interface AshGateProps {
+    isAshEnabled: boolean;
+    isAshSupported: boolean;
+    children: ReactNode;
+}
+export declare const AshGate: ({ isAshEnabled, isAshSupported, children }: AshGateProps) => JSX.Element;

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

@@ -0,0 +1,15 @@
+import { AppName, PAUrlParams, InsightsTabs } from '../../helpers/dtos';
+interface BackgroundJobsProps {
+    apiUrl: string;
+    universeUuid: string;
+    startTime: string | null;
+    endTime: string | null;
+    appName: AppName;
+    currentTab?: InsightsTabs;
+    onClickShowMoreAnomalies?: (category: string) => void;
+    backgroundTasksMappingFunc?: (value: string) => string;
+    onSelectedIssue?: (troubleshootUuid: string, params?: PAUrlParams) => void;
+    onTimeRangeSelect?: (start: number, end: number) => void;
+}
+export declare const BackgroundJobs: ({ apiUrl, endTime, appName, startTime, currentTab, universeUuid, onSelectedIssue, onClickShowMoreAnomalies, backgroundTasksMappingFunc, onTimeRangeSelect }: BackgroundJobsProps) => JSX.Element;
+export {};

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

@@ -0,0 +1,22 @@
+import { AnomalyGroup, AppName, ClusterDetails, WaitEventClassification } from '../../helpers/dtos';
+interface ClusterOverallLoadChartProps {
+    anomalyData?: AnomalyGroup | null;
+    appName: AppName;
+    metricKey?: string;
+    shouldAbbreviateTraceName?: boolean;
+    groupByOperation: WaitEventClassification;
+    timezone?: string;
+    startTime: string | null;
+    endTime: string | null;
+    universeUuid: string;
+    isAshEnabled: boolean;
+    isAshSupported: boolean;
+    apiUrl: string;
+    dbWaitEventType: string;
+    onEChartsDateSelect: (start: number, end: number) => void;
+    onFilterBarData: (data: string[]) => void;
+    onSetGroupByOperation: (operation: WaitEventClassification) => void;
+    getClusterDetails: () => ClusterDetails;
+}
+export declare const ClusterOverallLoadChart: ({ anomalyData, appName, metricKey, shouldAbbreviateTraceName, groupByOperation, timezone, startTime, endTime, universeUuid, isAshEnabled, isAshSupported, apiUrl, dbWaitEventType, onEChartsDateSelect, onFilterBarData, onSetGroupByOperation, getClusterDetails }: ClusterOverallLoadChartProps) => JSX.Element;
+export {};

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

@@ -0,0 +1,10 @@
+import { Column } from '../../helpers/dtos';
+interface ColumnSelectorDrawerProps {
+    hiddenColumns: string[];
+    close: () => void;
+    columns: Column[];
+    onApply: (visibility: Record<string, boolean>) => void;
+    visibleStorageKey: string;
+}
+export declare const ColumnSelectorDrawer: ({ columns, hiddenColumns, visibleStorageKey, onApply, close }: ColumnSelectorDrawerProps) => JSX.Element;
+export {};

package/dist/components/PrimaryDashboard/DbCPUActivity/CPUByDatabaseChart.d.ts

@@ -0,0 +1,21 @@
+import { ChartConfig } from '../../../common/ChartCard';
+import { CPU_THROTTLED_BY_DATABASE, CPU_USAGE_BY_DATABASE } from '../../../helpers/constants';
+import { AppName, SplitMode } from '../../../helpers/dtos';
+export type CPUByDatabaseMetric = typeof CPU_USAGE_BY_DATABASE | typeof CPU_THROTTLED_BY_DATABASE;
+export interface CPUByDatabaseChartProps {
+    apiUrl: string;
+    universeUuid: string;
+    appName: AppName;
+    startTime: string | null;
+    endTime: string | null;
+    timezone?: string;
+    metric: CPUByDatabaseMetric;
+    splitMode: SplitMode;
+    splitCount: number;
+    shouldAbbreviateTraceName?: boolean;
+    metricKey?: string;
+    configOverride?: Partial<ChartConfig>;
+    onEChartsDateSelect?: (start: number, end: number) => void;
+    onFilterBarData?: (data: string[]) => void;
+}
+export declare const CPUByDatabaseChart: ({ apiUrl, universeUuid, appName, startTime, endTime, timezone, metric, splitMode, splitCount, shouldAbbreviateTraceName, metricKey, configOverride, onEChartsDateSelect, onFilterBarData }: CPUByDatabaseChartProps) => JSX.Element;

package/dist/components/PrimaryDashboard/DbCPUActivity/CPUByDatabaseMetadata.d.ts

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

package/dist/components/PrimaryDashboard/DbCPUActivity/DbCPUActivityDashboard.d.ts

@@ -0,0 +1,13 @@
+import { AppName, QueryPageParams } from '../../../helpers/dtos';
+export interface DbCPUActivityDashboardProps {
+    apiUrl: string;
+    universeUuid: string;
+    appName: AppName;
+    initialFilterDuration?: string;
+    initialStartTime?: string;
+    initialEndTime?: string;
+    showTimezoneSelector?: boolean;
+    onSelectedQuery?: (queryId: string, params?: QueryPageParams) => void;
+    onNavigateToUrl?: (url: string) => void;
+}
+export declare const DbCPUActivityDashboard: ({ apiUrl, universeUuid, appName, initialFilterDuration, initialStartTime, initialEndTime, showTimezoneSelector, onSelectedQuery, onNavigateToUrl }: DbCPUActivityDashboardProps) => JSX.Element;

package/dist/components/PrimaryDashboard/DbCPUActivity/DbCPUActivityView.d.ts

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

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

@@ -0,0 +1,22 @@
+import { AppName, QueryPageParams, UniverseDatabaseStatsData } from '../../helpers/dtos';
+export interface DbLoadMetadataProps {
+    dbWaitEventType: string;
+    universeUuid: string;
+    apiUrl: string;
+    appName: AppName;
+    startTime: string | null;
+    endTime: string | null;
+    timezone?: string;
+    showTimezoneSelector?: boolean;
+    onSelectedQuery?: (queryId: string, params?: QueryPageParams) => void;
+    onNavigateToUrl?: (url: string) => void;
+}
+export interface DatabaseStatsPagedResponse {
+    data: {
+        entities: UniverseDatabaseStatsData[];
+        hasNext: boolean;
+        hasPrev: boolean;
+        totalCount: number;
+    };
+}
+export declare const DbLoadMetadata: ({ dbWaitEventType, universeUuid, apiUrl, appName, startTime, endTime, onSelectedQuery, onNavigateToUrl }: DbLoadMetadataProps) => JSX.Element;

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

@@ -0,0 +1,22 @@
+import { DbNodeLoadView } from './chartConfigs';
+import { AnomalyGroup, AppName, ClusterDetails } from '../../helpers/dtos';
+export type { DbNodeLoadView };
+export interface DbNodeLoadChartProps {
+    view: DbNodeLoadView;
+    apiUrl: string;
+    universeUuid: string;
+    appName: AppName;
+    startTime: string | null;
+    endTime: string | null;
+    isAshEnabled: boolean;
+    isAshSupported: boolean;
+    timezone?: string;
+    dbWaitEventType: string;
+    shouldAbbreviateTraceName?: boolean;
+    metricKey?: string;
+    anomalyData?: AnomalyGroup | null;
+    onEChartsDateSelect: (start: number, end: number) => void;
+    onFilterBarData?: (data: string[]) => void;
+    getClusterDetails: () => ClusterDetails;
+}
+export declare const DbNodeLoadChart: ({ view, apiUrl, universeUuid, appName, startTime, endTime, isAshEnabled, isAshSupported, timezone, dbWaitEventType, shouldAbbreviateTraceName, metricKey, anomalyData, onEChartsDateSelect, onFilterBarData, getClusterDetails }: DbNodeLoadChartProps) => JSX.Element;

package/dist/components/PrimaryDashboard/DbStatsTable/databaseStatsColumns.d.ts

@@ -0,0 +1,51 @@
+import { AppName, Column } from '../../../helpers/dtos';
+export declare const formatPercentFromRatio: (value: unknown) => string;
+export declare const formatSizeGB: (value: unknown) => string;
+export declare const formatMs: (value: unknown) => string;
+interface ColumnBaseCtx {
+    appName: AppName;
+    helperClasses: Record<string, string>;
+    display: boolean;
+}
+export declare const makeUniverseIdColumn: () => Column;
+export declare const makeDatabaseNameColumn: ({ appName, helperClasses, display, minWidth, maxWidth }: ColumnBaseCtx & {
+    minWidth?: string | undefined;
+    maxWidth?: string | undefined;
+}) => Column;
+export declare const makeConnectionsColumn: ({ appName, helperClasses, display, width, maxWidth }: ColumnBaseCtx & {
+    width?: string | undefined;
+    maxWidth?: string | undefined;
+}) => Column;
+export declare const makeWaitEventsColumn: ({ appName, helperClasses, display, maxEPS, label, width, maxWidth }: ColumnBaseCtx & {
+    maxEPS: number;
+    label?: string | undefined;
+    width?: string | undefined;
+    maxWidth?: string | undefined;
+}) => Column;
+export declare const makeTypeColumn: ({ appName, helperClasses, display }: ColumnBaseCtx) => Column;
+export declare const makeCPURatioColumn: ({ appName, helperClasses, display }: ColumnBaseCtx) => Column;
+export declare const makeCallsPerSecColumn: ({ appName, helperClasses, display, width }: ColumnBaseCtx & {
+    width?: string | undefined;
+}) => Column;
+export declare const makeEpsColumn: ({ appName, helperClasses, display }: ColumnBaseCtx) => Column;
+export declare const makeAvgCPUColumn: ({ appName, helperClasses, display, width }: ColumnBaseCtx & {
+    width?: string | undefined;
+}) => Column;
+export declare const makePeakCPUColumn: ({ appName, helperClasses, display, width }: ColumnBaseCtx & {
+    width?: string | undefined;
+}) => Column;
+export declare const makeCPUThrottledColumn: ({ appName, helperClasses, display, width }: ColumnBaseCtx & {
+    width?: string | undefined;
+}) => Column;
+export declare const makeSizeColumn: ({ appName, helperClasses, display, width }: ColumnBaseCtx & {
+    width?: string | undefined;
+}) => Column;
+interface BuildColumnsCtx {
+    appName: AppName;
+    helperClasses: Record<string, string>;
+}
+export declare const buildDbLoadColumns: ({ appName, helperClasses }: BuildColumnsCtx, maxEPS: number) => Column[];
+export declare const buildCpuByDatabaseColumns: ({ appName, helperClasses }: BuildColumnsCtx, maxEPS: number) => Column[];
+export declare const patchEventsColumnMaxEPS: (columns: Column[], maxEPS: number) => Column[];
+export declare const applyVisibilityPrefs: (columns: Column[], storageKey: string) => Column[];
+export {};

package/dist/components/PrimaryDashboard/DbStatsTable/useDatabaseStatsTable.d.ts

@@ -0,0 +1,62 @@
+import { AxiosError } from 'axios';
+import { SortDirection, UniverseDatabaseStatsData } from '../../../helpers/dtos';
+export declare const defaultSortKeyMapper: (columnId: string) => string;
+export interface UseDatabaseStatsTableArgs<TData = any> {
+    universeUuid: string;
+    apiUrl: string;
+    startTime: string | null;
+    endTime: string | null;
+    /** Already-resolved wait-event-type filter. `[]` means no filter. */
+    dbWaitEventTypeFilter: string[];
+    defaultSortBy: string;
+    /** Discriminator added to the react-query key so two callers don't share a cache. */
+    queryKeyDiscriminator: string;
+    /** Maps a FE column id to the backend sortBy enum value. Defaults to {@link defaultSortKeyMapper}. */
+    sortKeyMapper?: (columnId: string) => string;
+    /** Optional projection over entities before they hit the table. */
+    transformData?: (entities: UniverseDatabaseStatsData[]) => TData[];
+    /** Column id whose top-of-page-zero value should drive maxEPS (defaults to 'eps'). */
+    epsColumnId?: string;
+    /** Pass `true` to filter out system DBs (e.g. system_platform, template0). Default `false`. */
+    excludeSystemDBs?: boolean;
+}
+export declare const useDatabaseStatsTable: <TData = any>({ universeUuid, apiUrl, startTime, endTime, dbWaitEventTypeFilter, defaultSortBy, queryKeyDiscriminator, sortKeyMapper, transformData, epsColumnId, excludeSystemDBs }: UseDatabaseStatsTableArgs<TData>) => {
+    rows: TData[];
+    totalSize: number;
+    maxEPS: number;
+    databaseList: string[];
+    database: string;
+    onDatabaseChange: (next: string | null) => void;
+    searchInputValue: string;
+    onSearchInputChange: (value: string) => void;
+    onSearchInputClear: () => void;
+    pageSize: number;
+    setPageSize: import('react').Dispatch<import('react').SetStateAction<number>>;
+    currentTablePage: number;
+    setCurrentTablePage: import('react').Dispatch<import('react').SetStateAction<number>>;
+    fetchNextPage: (options?: import('react-query').FetchNextPageOptions | undefined) => Promise<import('react-query').InfiniteQueryObserverResult<import('axios').AxiosResponse<import('../../../helpers/dtos').GraphRequestParams[]>, unknown>>;
+    hasNextPage: boolean | undefined;
+    sortBy: string;
+    sortDirection: SortDirection;
+    handleColumnSortChange: (updater: any) => void;
+    isFetching: boolean;
+    isError: boolean;
+    error: AxiosError<{
+        error?: string | undefined;
+    }> | null;
+    isDatabaseListError: boolean;
+    isCallLoading: boolean;
+    customFooter: import('../../../common/YBTable/AnomaliesTableFooter').CustomFooterFunction | undefined;
+    tableState: {
+        sorting: {
+            id: string;
+            desc: boolean;
+        }[];
+        pagination: {
+            pageIndex: number;
+            pageSize: number;
+        };
+        isLoading: boolean;
+        showProgressBars: boolean;
+    };
+};

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

@@ -0,0 +1,19 @@
+import { FC } from 'react';
+import { UseQueryResult } from 'react-query';
+import { AppName, PAUrlParams, InsightsTabs, AnomalyResponse } from '../../helpers/dtos';
+export interface IDetectedAnomalies {
+    apiUrl: string;
+    appName: AppName;
+    endTime: Date | null;
+    universeUuid: string;
+    startTime: Date | null;
+    currentTab?: InsightsTabs;
+    anomalyGroupsFetchError?: string;
+    anomalyGroups: AnomalyResponse | null;
+    onClickShowMoreAnomalies: (category: string) => void;
+    fetchAnomalyGroups: UseQueryResult<AnomalyResponse, unknown>;
+    onSelectedIssue?: (troubleshootUuid: string, params?: PAUrlParams) => void;
+    onNavigateToUrl?: (url: string) => void;
+    onTimeRangeSelect?: (start: number, end: number) => void;
+}
+export declare const DetectedAnomalies: FC<IDetectedAnomalies>;

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

@@ -0,0 +1,208 @@
+import { AnomalyGroup, AppName, ChartType, WaitEventClassification } from '../../helpers/dtos';
+interface PlotGraphParams {
+    shouldAbbreviateTraceName: boolean;
+    appName: AppName;
+    timezone?: string;
+    metricKey: string;
+    groupByOperation: WaitEventClassification;
+}
+export declare const generateEChartsOptions: (overallMetrics: any[] | null, dbWaitEventType: string, isDbClusterLoadView: boolean, isNodeClusterLoadView: boolean, chartType: ChartType, params: PlotGraphParams, anomalyData?: AnomalyGroup | null) => {
+    options: {
+        series: {
+            name: string;
+            type: string;
+            data: number[][];
+            showSymbol: boolean;
+            lineStyle: {
+                color: string;
+                type: string;
+            };
+        }[];
+        xAxis: {
+            min: number;
+            max: number;
+        };
+        yAxis: {
+            min: number;
+            max: number;
+        };
+        title: {
+            text: string;
+            left: number;
+            top: number;
+            textStyle: {
+                fontWeight: number;
+                fontFamily: string;
+                fontSize: number;
+                color: string;
+            };
+            legend: {
+                data: never[];
+            };
+        };
+        graphic: {
+            type: string;
+            left: string;
+            top: string;
+            style: {
+                text: string;
+                fontSize: number;
+                fontWeight: number;
+                fill: string;
+            };
+        }[];
+    };
+    nameMapping: Record<string, string>;
+} | {
+    options: {
+        title: {
+            text: string;
+            left: number;
+            top: number;
+            textStyle: {
+                fontWeight: number;
+                fontFamily: string;
+                fontSize: number;
+                color: string;
+            };
+        };
+        tooltip: {
+            trigger: string;
+            appendToBody: boolean;
+            confine: boolean;
+            axisPointer: {
+                type: string;
+                shadowStyle: {
+                    color: string;
+                };
+                lineStyle: {
+                    color: string;
+                    width: number;
+                };
+            };
+            textStyle: {
+                fontFamily: string;
+                fontSize: number;
+                lineHeight: number;
+                color: string;
+                fontWeight: number;
+            };
+            extraCssText: string;
+            z: number;
+            formatter: (params: any) => string;
+        };
+        legend: {
+            textStyle: {
+                fontSize: string;
+                fontWeight: string;
+                color: string;
+                fontFamily: string;
+                rich: {
+                    dashedLine: {
+                        backgroundColor: {
+                            image: string;
+                        };
+                        width: number;
+                        height: number;
+                        padding: number[];
+                        lineHeight: number;
+                    };
+                    thickLine: {
+                        backgroundColor: string;
+                        width: number;
+                        height: number;
+                        borderWidth: number;
+                        borderColor: string;
+                        borderType: string;
+                        padding: number[];
+                        lineHeight: number;
+                    };
+                };
+            };
+            data: any;
+            formatter: (name: string) => string;
+            symbolSize: number;
+            itemStyle: {
+                borderColor: string;
+                borderWidth: number;
+            };
+            itemGap: number;
+            left?: string | undefined;
+            top?: string | undefined;
+            width?: string | undefined;
+            height?: string | undefined;
+            type: string;
+            tooltip: {
+                show: boolean;
+                formatter: (params: {
+                    name: string;
+                }) => string | null;
+            };
+            orient: string;
+            bottom: string | number;
+        };
+        grid: {
+            left: string;
+            right: string;
+            top: string;
+            bottom: string;
+            containLabel: boolean;
+        };
+        xAxis: {
+            type: string;
+            axisLabel: {
+                color: string;
+                textStyle: {
+                    fontFamily: string;
+                    fontSize: number;
+                };
+                formatter: (value: number) => string;
+            };
+            axisLine: {
+                lineStyle: {
+                    color: string;
+                };
+            };
+        };
+        yAxis: {
+            type: string;
+            name: string;
+            nameLocation: string;
+            nameGap: number;
+            nameTextStyle: {
+                fontWeight: string;
+                fontFamily: string;
+                fontSize: number;
+                color: string;
+                rotate: number;
+                align: string;
+            };
+            axisLine: {
+                lineStyle: {
+                    color: string;
+                };
+            };
+            axisLabel: {
+                color: string;
+                textStyle: {
+                    fontFamily: string;
+                    fontSize: number;
+                };
+                precision: number;
+            };
+            splitNumber: number;
+            max: number;
+        };
+        series: any;
+        toolbox: {
+            show: boolean;
+        };
+        brush: {
+            toolbox: string[];
+            xAxisIndex: number;
+            yAxisIndex: number;
+        };
+    };
+    nameMapping: Record<string, string>;
+};
+export {};

package/dist/components/PrimaryDashboard/ExportQueriesModal/BundleColumnsPicker.d.ts

@@ -0,0 +1,9 @@
+import { BundleColumnKey, BundleColumnSelection } from '../../../helpers/downloadUtils';
+import { QpmDisabledReason } from '../../../helpers/qpmStatus';
+interface BundleColumnsPickerProps {
+    columns: BundleColumnSelection;
+    onToggle: (key: BundleColumnKey, checked: boolean) => void;
+    qpmDisabledReason: QpmDisabledReason | null;
+}
+export declare const BundleColumnsPicker: ({ columns, onToggle, qpmDisabledReason }: BundleColumnsPickerProps) => JSX.Element;
+export {};

package/dist/components/PrimaryDashboard/ExportQueriesModal/BundleDetailsPanel.d.ts

@@ -0,0 +1,6 @@
+import { ExportBundle } from '../../../contexts/ExportBundlesContext';
+interface BundleDetailsPanelProps {
+    bundle: ExportBundle;
+}
+export declare const BundleDetailsPanel: ({ bundle }: BundleDetailsPanelProps) => JSX.Element | null;
+export {};

package/dist/components/PrimaryDashboard/ExportQueriesModal/ExportFormTab.d.ts

@@ -0,0 +1,15 @@
+import { Dispatch, SetStateAction } from 'react';
+import { FormState } from './types';
+import { QpmDisabledReason } from '../../../helpers/qpmStatus';
+interface ExportFormTabProps {
+    form: FormState;
+    setForm: Dispatch<SetStateAction<FormState>>;
+    totalCount: number;
+    databaseList?: string[];
+    selectedQueryKeys: string[];
+    onClearSelection?: () => void;
+    isInvalid: boolean;
+    qpmDisabledReason: QpmDisabledReason | null;
+}
+export declare const ExportFormTab: ({ form, setForm, totalCount, databaseList, selectedQueryKeys, onClearSelection, isInvalid, qpmDisabledReason }: ExportFormTabProps) => JSX.Element;
+export {};

package/dist/components/PrimaryDashboard/ExportQueriesModal/RecentExportsTab.d.ts

@@ -0,0 +1,10 @@
+import { ExportBundle } from '../../../contexts/ExportBundlesContext';
+interface RecentExportsTabProps {
+    bundles: ExportBundle[];
+    onSave: (id: string) => void;
+    onCancel: (id: string) => void;
+    onRetry: (id: string) => void;
+    onRemove: (id: string) => void;
+}
+export declare const RecentExportsTab: ({ bundles, onSave, onCancel, onRetry, onRemove }: RecentExportsTabProps) => JSX.Element;
+export {};

package/dist/components/PrimaryDashboard/ExportQueriesModal/constants.d.ts

@@ -0,0 +1,12 @@
+export declare const MAX_TOPN = 500;
+export declare const DEFAULT_TOPN = 10;
+export declare const ALL_DATABASES = "All";
+export declare const ALL_QUERY_TYPES = "ALL";
+export declare const QUERY_TYPE_OPTIONS: {
+    value: string;
+    label: string;
+}[];
+export declare const SORT_BY_OPTIONS: {
+    value: string;
+    label: string;
+}[];

package/dist/components/PrimaryDashboard/ExportQueriesModal/helpers.d.ts

@@ -0,0 +1,9 @@
+import { BundleStatus } from '../../../helpers/exportBundlesStorage';
+export interface StatusChipStyle {
+    bg: string;
+    fg: string;
+    label: string;
+}
+export declare const statusChipStyle: (status: BundleStatus) => StatusChipStyle;
+export declare const formatCreatedAt: (ts: number) => string;
+export declare const formatRange: (start: string | null, end: string | null) => string;

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

@@ -0,0 +1,2 @@
+import { ExportQueriesModalProps } from './types';
+export declare const ExportQueriesModal: ({ open, onClose, totalCount, currentSortBy, currentSortDirection, universeUuid, apiUrl, appName, startTime, endTime, searchInput, database, databaseList, queryType, showSystemQueries, selectedQueryKeys, onClearSelection, qpmSupported, qpmEnabled }: ExportQueriesModalProps) => JSX.Element;

package/dist/components/PrimaryDashboard/ExportQueriesModal/recentExportColumns.d.ts

@@ -0,0 +1,16 @@
+import { YBTableColumn } from '@yugabyte-ui-library/core';
+import { ExportBundle } from '../../../contexts/ExportBundlesContext';
+interface ColumnHeaderClasses {
+    headerBox: string;
+    headerText: string;
+}
+interface ColumnCallbacks {
+    bundles: ExportBundle[];
+    helperClasses: ColumnHeaderClasses;
+    onSave: (id: string) => void;
+    onCancel: (id: string) => void;
+    onRetry: (id: string) => void;
+    onRemove: (id: string) => void;
+}
+export declare const recentExportColumns: (cb: ColumnCallbacks) => YBTableColumn[];
+export {};

package/dist/components/PrimaryDashboard/ExportQueriesModal/types.d.ts

@@ -0,0 +1,43 @@
+import { AppName, SortDirection } from '../../../helpers/dtos';
+import { BundleColumnSelection, BundleFormat, SourceMode } from '../../../helpers/downloadUtils';
+export declare const TabKey: {
+    readonly NEW: "new";
+    readonly RECENT: "recent";
+};
+export type TabKey = typeof TabKey[keyof typeof TabKey];
+export interface FormState {
+    topN: number;
+    topNText: string;
+    format: BundleFormat;
+    columns: BundleColumnSelection;
+    source: SourceMode;
+    localStartTime: string | null;
+    localEndTime: string | null;
+    localSearch: string;
+    localDatabase: string;
+    localQueryType: string;
+    localSortBy: string;
+    localSortDirection: SortDirection;
+    localShowSystemQueries: boolean;
+}
+export interface ExportQueriesModalProps {
+    open: boolean;
+    onClose: () => void;
+    totalCount: number;
+    currentSortBy: string;
+    currentSortDirection: SortDirection;
+    universeUuid: string;
+    apiUrl: string;
+    appName: AppName;
+    startTime: string | null;
+    endTime: string | null;
+    searchInput: string;
+    database: string;
+    databaseList?: string[];
+    queryType: string | null;
+    showSystemQueries: boolean;
+    selectedQueryKeys: string[];
+    onClearSelection?: () => void;
+    qpmSupported: boolean;
+    qpmEnabled: boolean;
+}