import { MUIDataTableMeta, MUIDataTableColumn, MUIDataTableOptions } from 'mui-datatables';
import * as axios from 'axios';
import React$1, { FC, ReactNode, ReactElement, ChangeEvent, HTMLAttributes, VFC } from 'react';
import { ButtonProps, StandardTextFieldProps, MenuProps, SelectProps, BoxProps, CheckboxProps, InputProps, DialogProps, DialogContentProps, PopperProps, TooltipProps, SwitchProps, FormControlLabelProps } from '@material-ui/core';
import { LinkProps } from 'react-router-dom';
import * as _material_ui_core_styles_withStyles from '@material-ui/core/styles/withStyles';
import { FieldValues, UseControllerProps } from 'react-hook-form';
import { FetchNextPageOptions, InfiniteQueryObserverResult } from 'react-query';

interface Universe {
    creationDate: string;
    name: string;
    ashEnabled: boolean;
    ashSupported: boolean;
    resources: Resources;
    universeConfig: UniverseConfig;
    universeDetails: any;
    universeUUID: string;
    version: number;
}
declare enum NodeState {
    ToBeAdded = "ToBeAdded",
    Provisioned = "Provisioned",
    SoftwareInstalled = "SoftwareInstalled",
    UpgradeSoftware = "UpgradeSoftware",
    UpdateGFlags = "UpdateGFlags",
    Live = "Live",
    Stopping = "Stopping",
    Starting = "Starting",
    Stopped = "Stopped",
    Unreachable = "Unreachable",
    ToBeRemoved = "ToBeRemoved",
    Removing = "Removing",
    Removed = "Removed",
    Adding = "Adding",
    BeingDecommissioned = "BeingDecommissioned",
    Decommissioned = "Decommissioned"
}
interface NodeDetails {
    nodeIdx: number;
    nodeName: string | null;
    nodeUuid: string | null;
    placementUuid: string;
    state: NodeState;
}
interface NodeDataCloudInfo {
    region: string;
    zone: string;
}
interface NodeDataMetrics {
    memory_used_bytes: number;
    total_sst_file_size_bytes: number;
    uncompressed_sst_file_size_bytes: number;
    read_ops_per_sec: number;
    write_ops_per_sec: number;
    user_tablets_total?: number;
    user_tablets_leaders?: number;
    system_tablets_total?: number;
    system_tablets_leaders?: number;
}
interface NodeData {
    name: string;
    is_node_up: boolean;
    is_master: boolean;
    is_tserver: boolean;
    is_leader?: boolean;
    is_read_replica?: boolean;
    metrics: NodeDataMetrics;
    cloud_info: NodeDataCloudInfo;
}
interface ClusterNodeListMetadata {
    active_tablet_peers?: number;
    tablet_peer_limit?: number;
}
interface ClusterNodeInfo {
    data: NodeData[];
    metadata?: ClusterNodeListMetadata;
}
interface Resources {
    azList: string[];
    ebsPricePerHour: number;
    memSizeGB: number;
    numCores: number;
    numNodes: number;
    pricePerHour: number;
    volumeCount: number;
    volumeSizeGB: number;
}
interface UniverseConfig {
    disableAlertsUntilSecs: string;
    takeBackups: string;
}
declare enum MetricMeasure {
    OVERALL = "Overall",
    OUTLIER = "Outlier",
    OUTLIER_TABLES = "Outlier_Tables",
    OUTLIER_DB = "Outlier_Databases"
}
interface Anomaly {
    uuid: string;
    metadataUuid: string;
    category: AnomalyCategory;
    type: AnomalyType;
    universeUuid: string;
    affectedNodes: NodeInfo[];
    graphStartTime?: Date | string;
    graphEndTime?: Date | string;
    affectedTables?: TableInfo[] | [];
    title: string;
    summary: string;
    detectionTime: Date | string;
    startTime: Date;
    endTime?: Date;
    groupId: string;
    mainGraphs: GraphMetadata[];
    defaultSettings: GraphSettings;
    rcaGuidelines: RCAGuideline[];
    isResolved?: boolean;
}
declare enum AnomalyCategory {
    SQL = "SQL",
    APP = "APP",
    NODE = "NODE",
    INFRA = "INFRA",
    DB = "DB"
}
declare enum AnomalyType {
    SQL_QUERY_LATENCY_INCREASE = "SQL_QUERY_LATENCY_INCREASE",
    HOT_NODE_READS_WRITES = "HOT_NODE_READS_WRITES",
    HOT_NODE_CPU = "HOT_NODE_CPU",
    HOT_NODE_QUERIES = "HOT_NODE_QUERIES",
    HOT_NODE_DATA = "HOT_NODE_DATA",
    SLOW_DISKS = "SLOW_DISKS"
}
interface NodeInfo {
    name: string;
    uuid: string;
}
interface TableInfo {
    databaseName: string;
    tableName: string;
    tableId: string;
}
interface RCAGuideline {
    possibleCause: string;
    possibleCauseDescription: string;
    troubleshootingRecommendations: TroubleshootingRecommendations[];
}
interface TroubleshootingRecommendations {
    recommendation: string;
    supportingGraphs: GraphMetadata[];
}
interface GraphMetadata {
    name: string;
    filters: GraphFilters;
    groupBy?: WaitEventClassification[];
    groupByControl: boolean;
    displayName?: string;
    aggregatedLineSettings?: AggregatedLineSettings;
}
interface GraphRequestParams {
    start: Date | string;
    end: Date | string;
    name: string;
    filters: GraphFilters;
    settings: GraphSettings;
    groupBy?: WaitEventClassification[];
    aggregatedLineSettings?: AggregatedLineSettings;
    stepSeconds?: number;
}
declare enum WaitEventClassification {
    WAIT_EVENT_COMPONENT = "waitEventComponent",
    WAIT_EVENT_CLASS = "waitEventClass",
    WAIT_EVENT_TYPE = "waitEventType",
    WAIT_EVENT = "waitEvent",
    CLIENT_NODE_IP = "clientNodeIp",
    QUERY_ID = "queryId",
    TABLET_ID = "tabletId",
    DB_ID = "dbId"
}
declare const GroupEventsParam: {
    waitEventType: string;
    waitEvent: string;
};
interface AggregatedLineSettings {
    aggregateBy: GraphFilters;
    excludeFiltered: boolean;
    aggregation: Aggregation;
}
interface GraphFilters {
    universeUuid: string[];
    queryId?: string[];
    userId?: string[];
    dbId?: string[];
    tableId?: string[];
    instanceName?: string[];
    clusterUuid?: string[];
    regionCode?: string[];
    azCode?: string[];
    waitEvent?: string[];
    waitEventComponent?: string[];
    waitEventClass?: string[];
    waitEventType?: string[];
    clientNodeIp?: string[];
    tabletId?: string[];
    metricName?: string[];
    namespace?: string[];
    dbName?: string[];
    tableName?: string[];
    schemaName?: string[];
}
interface AnomalyDetectionStatus {
    detectionEndTime: string;
    lastSuccessTime: string;
    status: AnomalyDetectionStatusText;
    statusTime: string;
    universeUuid: string;
}
interface GraphSettings {
    splitMode: SplitMode;
    splitType: SplitType;
    splitCount: number;
    returnAggregatedValue: boolean;
    aggregatedValueFunction: Aggregation;
}
declare const SplitMode: {
    readonly NONE: "NONE";
    readonly TOP: "TOP";
    readonly BOTTOM: "BOTTOM";
};
type SplitMode = typeof SplitMode[keyof typeof SplitMode];
declare const SplitType: {
    readonly NONE: "NONE";
    readonly NODE: "NODE";
    readonly TABLE: "TABLE";
    readonly NAMESPACE: "NAMESPACE";
};
type SplitType = typeof SplitType[keyof typeof SplitType];
declare const QueryTypeMode: {
    readonly ALL: "All";
    readonly SQL: "SQL";
    readonly CQL: "CQL";
    readonly BACKGROUND: "Background";
};
type QueryTypeMode = typeof QueryTypeMode[keyof typeof QueryTypeMode];
declare const Aggregation: {
    readonly AVERAGE: "AVG";
    readonly MAX: "MAX";
    readonly MIN: "MIN";
    readonly SUM: "SUM";
};
type Aggregation = typeof Aggregation[keyof typeof Aggregation];
interface GraphResponse {
    successful: boolean;
    errorMessage: string;
    layout: any;
    data: any;
    name: string;
}
declare enum AppName {
    YBA = "YBA",
    YBM = "YBM",
    YBD = "YBD",
    WEB = "WEB"
}
declare enum QueryType {
    SQL = "SQL",
    CQL = "CQL",
    BACKGROUND = "BACKGROUND"
}
declare enum GraphType {
    SINGLE_SUPPORTING = "SINGLE_SUPPORTING",
    MULTI_SUPPORTING = "MULTI_SUPPORTING",
    MAIN_RCA = "MAIN_RCA"
}
interface QueryWaitEvents {
    eps: number;
    waitEventType: string;
    waitEvent: string;
}
declare const WAIT_EVENT_MAPPING: {
    readonly waitEventType: "Wait Event Type";
    readonly waitEvent: "Wait Event";
};
declare const GROUP_BY_OPERATIONS: readonly [WaitEventClassification.WAIT_EVENT_TYPE, WaitEventClassification.WAIT_EVENT];
interface UrlParams {
    queryId: string | undefined;
    startTime?: string | null;
    endTime?: string | null;
    duration?: string | null;
    dbId?: string | null;
    universeId: string | null;
    userId?: string | null;
    type?: QueryType | null;
}
interface MetadataFields {
    id: string;
    name?: string;
    customerId: string;
    apiToken: string;
    platformUrl: string;
    metricsUrl: string;
    metricsScrapePeriodSec: number;
    dataMountPoints: string[];
    otherMountPoints: string[];
    lastSyncError?: string | null;
}
interface AuthDetails {
    authType: string;
    password: string;
    setUpAuth: boolean;
    username: string;
}
interface UniverseMetadataFields {
    authDetails: AuthDetails;
    customerId: string;
    dataMountPoints: string[];
    id: string;
    otherMountPoints: string[];
}
interface AttachUniversePayload {
    id: string;
    customerId: string;
    dataMountPoints: string[];
    otherMountPoints: string[];
}
interface UpdateMetadataFormFields {
    apiToken: string;
    metricsScrapePeriodSec: number;
}
declare enum SortDirection {
    ASC = "ASC",
    DESC = "DESC"
}
declare enum PrimaryDashboardViewTabs {
    ANOMALY = "Anomaly",
    QUERY = "Query"
}
interface QueryPageParams extends PAUrlParams {
    dbId?: string | null;
    queryId?: string | null;
    universeId?: string | null;
    userId?: string | null;
    type: QueryType | null;
}
interface PAUrlParams {
    duration?: string | null;
    startTime?: string | null;
    endTime?: string | null;
}
interface TablePageParams {
    schemaName: string;
    namespaceName: string;
    tableId: string;
    universeId: string;
    startDateTime?: string;
    endDateTime?: string;
}
interface UniverseQueryData {
    dbName: string;
    id: QueryPageParams;
    lastHourCalls?: number;
    lastHourTotalTime?: number;
    lastHourLatencyAvg?: number;
    lastHourLatencyP90?: number;
    lastHourLatencyP99?: number;
    lastHourRowsAvg?: number;
    lastHourRps?: number;
    lastHourStatsTimestamp?: string;
    query: string;
    userName?: string;
    scheduledTimestamp: string;
}
interface Events {
    eps: number;
    waitEventType: string;
}
interface UniverseQueryStatsData {
    databaseId: string;
    eps: number;
    events: Events[];
    query: string;
    queryId: string;
    queryType: QueryType;
    rowsAvg: number;
    rps: number;
    totalTime: number;
    universeId: string;
    namespaceName: string;
    firstActive: string;
    lastActive: string;
    latencyAvg: string;
    latencyP90: string;
    latencyP99: string;
}
interface RowItemClasses$1 {
    rowTableCell: string;
    queryTableCell: string;
    queryCodeElement: string;
    queryPreBlock: string;
    queryContainerCode: string;
    overrideExpandBtn: string;
}
declare enum TPFeatureFlags {
    SHOW_QUERY_STATS_TIMESTAMP = "showStatsTimestamp",
    SHOW_CLEANUP_HISTORICAL_DATA = "showCleanupHistoricalData"
}
declare enum AnomalyDetectionStatusText {
    EMPTY = "EMPTY",
    SCHEDULED = "SCHEDULED",
    IN_PROGRESS = "IN_PROGRESS",
    SUCCESS = "SUCCESS",
    FAILURE = "FAILURE"
}
interface RuntimeConfigData {
    description: string;
    overriden: boolean;
    path: string;
    type: string;
    value: string;
}
interface UpdateRuntimeConfigFormFields {
    configValue: string | boolean;
}
declare enum RuntimeConfigType {
    TEXT = "TEXT",
    INT = "INT",
    FLOAT = "FLOAT",
    BOOL = "BOOL",
    DURATION = "DURATION"
}
interface AnomalyInstance {
    detectionTime: string;
    endTime: string;
    entityDisplayName: string;
    entityId: string;
    graphEndTime: string;
    graphStartTime: string;
    groupId: string;
    lastUpdateTime: string;
    category: string;
    title: string;
    type: string;
    startTime: string;
    summary: string;
    universeUuid: string;
    uuid: string;
    metadataUuid: string;
    affectedNodes: NodeInfo[];
    affectedTables?: TableInfo[] | [];
    mainGraphs: GraphMetadata[];
    defaultSettings: GraphSettings;
    rcaGuidelines: RCAGuideline[];
    isResolved?: boolean;
}
interface Interval {
    startTime: string;
    endTime: string;
}
interface AnomalyGroup {
    lastInstance: AnomalyInstance;
    anomalyIntervals: Interval[];
}
interface FormattedAnomalyRca {
    cause: string;
    name: string[];
    title: string;
    groupByControl: boolean[];
    description: string;
    index: number[];
    rcaRecommendation?: string;
}
interface AnomalyDetails {
    groups: AnomalyGroup[];
    hasMore: boolean;
    totalCount: number;
}
interface AnomalyResponse {
    [category: string]: {
        [type: string]: AnomalyDetails;
    };
}
declare enum InsightsTabs {
    CLUSTER_LOAD = "Cluster Load",
    INSIGHTS = "Insights",
    METRICS = "Metrics",
    CLUSTER_LOAD_DB = "Load by Database"
}
declare enum ClusterLoadTabs {
    ANOMALIES = "Anomalies",
    QUERIES = "Queries"
}
declare const URL_TAB_PATH: {
    ANOMALIES: string;
    QUERIES: string;
    METRICS: string;
    INSIGHTS: string;
    CLUSTER_LOAD: string;
    CLUSTER_LOAD_DB: string;
};
declare enum AnomalyTypeFilter {
    PERF_ANOMALY = "PERF_ANOMALY",
    INSIGHT = "INSIGHT"
}
interface ColumnOptions {
    sort?: boolean;
    display?: boolean;
    filter?: boolean;
    setCellHeaderProps?: () => {
        style: React.CSSProperties;
        className: string;
    };
    customBodyRender?: (value: any, tableMeta: MUIDataTableMeta) => React.ReactNode;
    customHeadLabelRender?: (header: any) => React.ReactNode;
}
interface Column {
    label: string;
    name: string;
    options?: ColumnOptions;
}
interface GraphAxisData {
    labels: Record<string, string>;
    name: string;
    type: string;
    waitEventType: string;
    x: number[] | string[];
    y: string[];
}
interface SupportedGroupBy {
    label: string;
    name: string;
}
interface GraphLayoutData {
    title: string;
    metadata: {
        currentGroupBy: string[];
        supportedGroupBy: SupportedGroupBy[];
    };
    type: string;
    xaxis: {
        type: string;
    };
}
interface ClusterLoadResponseData {
    data: GraphAxisData[];
    layout: GraphLayoutData;
    name: string;
    stepSeconds: number;
    successful: boolean;
}
declare enum ChartType {
    LINE = "line",
    BAR = "bar"
}

interface MetricsAnalysisEntryProps {
    universeUuid: string;
    troubleshootUuid: string | null;
    universeData: Universe | ClusterNodeInfo;
    appName: AppName;
    timezone?: string;
    apiUrl: string;
    onSelectedIssue?: (troubleshootUuid: string | null, params?: PAUrlParams) => void;
    onSelectedQuery?: (queryId: string | null, params?: QueryPageParams) => void;
}
declare const MetricsAnalysisEntry: ({ universeUuid, troubleshootUuid, appName, timezone, apiUrl, onSelectedIssue, onSelectedQuery }: MetricsAnalysisEntryProps) => JSX.Element;

interface PerfAdvisorEntryProps {
    timezone?: string;
    universeUuid: string;
    appName: AppName;
    apiUrl: string;
    onSelectedIssue?: (troubleshootUuid: string, params?: PAUrlParams) => void;
    onSelectedQuery?: (queryId: string, params?: QueryPageParams) => void;
}
declare const PerfAdvisorEntry: ({ timezone, universeUuid, appName, apiUrl, onSelectedIssue, onSelectedQuery }: PerfAdvisorEntryProps) => JSX.Element;

interface TroubleshootConfigurationProps {
    apiUrl: string;
    customerUuid: string;
    appName: AppName;
}
declare const ConfigureUniverseMetadata: ({ apiUrl, customerUuid, appName }: TroubleshootConfigurationProps) => JSX.Element;

interface RuntimeConfigsProps {
    apiUrl: string;
    appName: AppName;
    toast: {
        success: (message: string) => void;
        error: (message: string) => void;
    };
}
declare const RuntimeConfigs: ({ apiUrl, appName, toast }: RuntimeConfigsProps) => JSX.Element;

declare enum QUERY_KEY {
    fetchAnomalies = "fetchAnomalies",
    fetchGraphs = "fetchGraphs",
    fetchQueries = "fetchQueries",
    fetchUniverseMetadataList = "fetchUniverseMetadataList",
    deleteUniverseMetadata = "deleteUniverseMetadata",
    updateUniverseMetadata = "updateUniverseMetadata",
    fetchUniverseListDetails = "fetchUniverseListDetails",
    fetchUniverseById = "fetchUniverseById",
    fetchAnomalyDetectionStatus = "fetchAnomalyDetectionStatus",
    scheduleAnomalyDetectionStatus = "scheduleAnomalyDetectionStatus",
    fetchAnomaliesPage = "fetchAnomaliesPage",
    fetchQueriesPage = "fetchQueriesPage",
    fetchQueriesStatsPage = "fetchQueriesStatsPage",
    fetchQueriesDatabases = "fetchQueriesDatabases",
    fetchCustomerMetadataList = "fetchCustomerMetadataList",
    fetchQueryStats = "fetchQueryStats",
    fetchTablesPage = "fetchTablesPage",
    fetchNamespaces = "fetchNamespaces",
    deleteRuntimeConfig = "deleteRuntimeConfig",
    fetchRuntimeConfigs = "fetchRuntimeConfigs",
    fetchSpecificRuntimeConfigs = "fetchSpecificRuntimeConfigs",
    fetchSpecificRuntimeConfigsKey = "fetchSpecificRuntimeConfigsKey",
    updateRuntimeConfig = "updateRuntimeConfig",
    fetchAnomalyGroups = "fetchAnomalyGroups",
    fetchAnomalyGroupsByType = "fetchAnomalyGroupsByType",
    fetchAnomalyGroupsById = "fetchAnomalyGroupsById",
    getUniverseMetadata = "getUniverseMetadata",
    fetchMetricsGraphs = "fetchMetricsGraphs"
}
declare class ApiService {
    fetchAnomalies: (universeUuid: string, startTime?: Date | null, endTime?: Date | null, apiUrl?: string) => Promise<Anomaly[]>;
    fetchAnomaliesPage: (universeUuid: string, pageno: number, apiUrl?: string, records_to_fetch?: number, startTime?: Date | null, endTime?: Date | null, category?: any, searchInput?: string) => Promise<axios.AxiosResponse<Anomaly[]>>;
    fetchQueriesPage: (universeUuid: string, payload: any) => Promise<axios.AxiosResponse<GraphRequestParams[]>>;
    fetchQueriesStatsPage: (universeUuid: string, payload: any, getClusterDetails: () => any, filteredLegends: string[]) => Promise<axios.AxiosResponse<GraphRequestParams[]>>;
    fetchNamespaceSchemas: (universeUuid: string, namespaceName: string, apiUrl?: string) => Promise<string[]>;
    fetchQueryStats: (universeUuid: string, payload: any, apiUrl?: string) => Promise<string[]>;
    fetchTablesPage: (universeUuid: string, payload: any) => Promise<axios.AxiosResponse<any[]>>;
    fetchNamespaces: (universeUuid: string, apiUrl?: string) => Promise<string[]>;
    fetchQueriesDatabases: (universeUuid: string, apiUrl?: string) => Promise<string[]>;
    fetchAnomaliesById: (universeUuid: string, anomalyUuid: string, apiUrl?: string) => Promise<Anomaly>;
    fetchGraphs: (universeUuid: String, data: any, apiUrl?: string) => Promise<ClusterLoadResponseData[]>;
    fetchQueries: (universeUuid: string, apiUrl?: string, queryParams?: QueryPageParams | null) => Promise<GraphRequestParams[]>;
    fetchCustomerMetadataList: (apiUrl?: string) => Promise<MetadataFields[]>;
    fetchCustomerMetadataById: (customerUuid: string, apiUrl?: string) => Promise<any>;
    updateCustomerMetadata: (customerUuid: string, data: any, apiUrl?: string) => Promise<any>;
    deleteCustomerMetadataById: (customerUuid: string, apiUrl?: string) => Promise<any>;
    fetchUniverseMetadataList: (apiUrl?: string, customerUuid?: string, universeUuid?: string) => Promise<MetadataFields[]>;
    getUniverseMetadata: (universeUuid: string, apiUrl?: string) => Promise<any>;
    updateUniverseMetadata: (universeUuid: string, data: any, apiUrl?: string) => Promise<any>;
    deleteUniverseMetadata: (universeUuid: string, apiUrl?: string) => Promise<any>;
    fetchUniverseListDetails: (apiUrl?: string, customerUuid?: string, universeUuid?: string) => Promise<any>;
    fetchUniverseById: (universeUuid: string, apiUrl?: string) => Promise<any>;
    fetchAnomalyDetectionStatus: (universeUuid: string, apiUrl?: string) => Promise<AnomalyDetectionStatus>;
    scheduleAnomalyDetectionStatus: (universeUuid: string, apiUrl?: string) => Promise<AnomalyDetectionStatus>;
    fetchRuntimeConfigs: (scopeUuid?: string, apiUrl?: string) => Promise<string[]>;
    fetchSpecificRuntimeConfigs: (scopeUuid: string | undefined, keys: string[], apiUrl?: string) => Promise<string[]>;
    updateRuntimeConfig: (scopeUuid: string | undefined, configKey: string, configValue: string, apiUrl?: string) => Promise<any>;
    deleteRuntimeConfig: (scopeUuid: string | undefined, configKey: string, apiUrl?: string) => Promise<any>;
    fetchAnomalyGroups: (universeUuid: string, startTime: string | null, endTime: string | null, anomalyType: string | undefined, getClusterDetails: () => {
        cluster: string;
        region: string;
        zone: string;
        node: string;
    }, apiUrl?: string) => {};
    fetchAnomalyGroupsByType: (universeUuid: string, startTime: string, endTime: string, anomalyType: string, apiUrl?: string) => Promise<AnomalyGroup[]>;
    fetchAnomalyGroupById: (universeUuid: string, anomalyGroupId: string, startTime: string, endTime: string, apiUrl?: string) => {};
}
declare const PerfAdvisorAPI: ApiService;

type MUIButtonProps = ButtonProps & Partial<LinkProps>;
interface YBButtonProps extends Omit<MUIButtonProps, 'variant' | 'color' | 'classes'> {
    variant?: 'primary' | 'secondary' | 'ghost' | 'gradient' | 'pill';
    showSpinner?: boolean;
    selected?: boolean;
}
declare const YBButton: FC<YBButtonProps>;

interface CodeBlockProps {
    showCopyButton?: boolean;
    multiBlock?: boolean;
    codeClassName?: string;
    preClassName?: string;
    lang?: string;
    containerClassName?: string;
    text: string | string[] | React$1.ReactElement | React$1.ReactElement[];
    dataTestId?: string;
    enabledExpandCollapse?: boolean;
    collapseHeight?: number;
    copyLabel?: string;
    showAllLabel?: string;
    collapseLabel?: string;
    onCopySuccess?: () => void;
}
declare const YBCodeBlock: FC<CodeBlockProps>;

declare const useCodeBlockStyles: (props?: any) => _material_ui_core_styles_withStyles.ClassNameMap<"codeClassName" | "preClassName" | "containerClassName" | "searchBox" | "refreshBtn" | "codeBlock" | "codeBlockSqlView" | "tableHeaderCell" | "rowTableCell" | "tableContainer" | "tableRow" | "queryTableRow" | "queryTableCell" | "queryPreBlock" | "queryPreBlockWeb" | "queryPreBlockFull" | "queryCodeElement" | "queryCodeElementWeb" | "queryContainerCode" | "defaultActions" | "overrideExpandBtn" | "preQueryBlock">;

interface YBErrorIndicatorProps {
    type?: string;
    uuid?: string;
    customErrorMessage?: string;
}
declare const YBErrorIndicator: ({ type, uuid, customErrorMessage }: YBErrorIndicatorProps) => JSX.Element;

interface YBLabelProps {
    className?: string;
    dataTestId?: string;
    width?: string;
}
declare const YBLabel: FC<YBLabelProps>;

type YBInputProps = {
    tooltip?: ReactNode;
} & Omit<StandardTextFieldProps, 'variant' | 'color' | 'classes' | 'size' | 'select' | 'FormHelperTextProps' | 'SelectProps'>;
declare const YBInput: FC<YBInputProps>;

type YBInputFieldProps$1<T extends FieldValues> = UseControllerProps<T> & YBInputProps;
declare const YBInputField: <T extends FieldValues>(props: YBInputFieldProps$1<T>) => ReactElement;

type YBSelectProps = {
    tooltip?: ReactNode;
    renderValue?: (value: unknown) => ReactNode;
    menuProps?: Partial<MenuProps>;
    selectProps?: Partial<SelectProps>;
} & Omit<StandardTextFieldProps, 'variant' | 'color' | 'classes' | 'select' | 'size' | 'placeholder' | 'FormHelperTextProps' | 'SelectProps'>;
declare const YBSelect: FC<YBSelectProps>;

interface GenericFailureProps extends BoxProps {
    text?: string;
}
declare const GenericFailure: FC<GenericFailureProps>;

declare enum AlertVariant {
    Info = "info",
    Warning = "warning",
    Error = "error",
    Success = "success",
    InProgress = "inProgress"
}
interface TransitionProps {
    appear?: number;
    enter?: number;
    exit?: number;
}
interface AlertProps {
    open: boolean;
    text: string | ReactNode;
    icon?: ReactNode;
    onClose?: () => void;
    autoDismiss?: number;
    width?: number;
    isToast?: boolean;
    variant?: AlertVariant;
    key?: string | number;
    position?: number;
    className?: string;
    dataTestId?: string;
    transitionTimeout?: number | TransitionProps;
}
declare const YBAlert: FC<AlertProps>;

interface YBCheckboxProps extends CheckboxProps {
    label: React$1.ReactNode;
    labelClassName?: string;
    showCheckedIcon?: boolean;
    inputProps?: InputProps['inputProps'];
}
declare const YBCheckbox: FC<YBCheckboxProps>;

interface YBDateTimePickerProps {
    defaultDateTimeValue?: string;
    dateTimeLabel: string;
    value: string;
    className?: any;
    errorMsg?: string;
    onChange: (selectedValue: ChangeEvent<HTMLInputElement>) => void;
    disabled?: boolean;
    isReadOnly?: boolean;
}
declare const YBDateTimePicker: ({ defaultDateTimeValue, dateTimeLabel, value, errorMsg, onChange, className, disabled, isReadOnly }: YBDateTimePickerProps) => JSX.Element;

interface OverrideButtonProps {
    primary?: YBButtonProps;
    secondary?: YBButtonProps;
}
interface YBModalProps extends DialogProps {
    title?: string;
    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
    overrideHeight?: string | number;
    overrideWidth?: string | number;
    isSidePanel?: boolean;
    titleSeparator?: boolean;
    titleIcon?: React$1.ReactNode;
    actionsInfo?: React$1.ReactNode;
    onClose?: () => void;
    onSubmit?: () => void;
    enableBackdropDismiss?: boolean;
    submitLabel?: string;
    submitButtonTooltip?: string | ReactElement;
    submitTestId?: string;
    customSubmitButton?: React$1.ReactNode;
    cancelLabel?: React$1.ReactNode;
    cancelButtonTooltip?: string;
    cancelTestId?: string;
    buttonProps?: OverrideButtonProps;
    customTitle?: React$1.ReactNode;
    hideCloseBtn?: boolean;
    dialogContentProps?: DialogContentProps;
    formProps?: React$1.HTMLProps<HTMLFormElement>;
    gradientTag?: string;
}
declare const YBModal: FC<YBModalProps>;

interface YBInfinitePaginationProps<T> {
    dataPrefetchFn: (options?: FetchNextPageOptions | undefined) => Promise<InfiniteQueryObserverResult<T, unknown>>;
    page: number;
    rowsPerPage?: number;
    rowsPerPageOptions?: number[];
    total: number;
    showRecordsPerPage?: boolean;
    recordsPerPageCaption?: string | React$1.ReactNode;
    onPageChange: (newPage: number) => void;
    onPageSizeChange: (newSize: string | number) => void;
    hasMoreData?: boolean;
}
declare const YBInfinitePagination: <T>({ dataPrefetchFn, page, onPageChange, onPageSizeChange, hasMoreData, total, rowsPerPageOptions, rowsPerPage, showRecordsPerPage, recordsPerPageCaption }: YBInfinitePaginationProps<T>) => React$1.ReactElement;

interface PaginationProps {
    onPageSelect: (pageNo: number) => void;
    pageSize?: number;
    currentPage?: number;
    hasMore?: boolean;
}
/**
 * Note that pagination for this component corresponds to the page number and is one-indexed
 */
declare const YBPagination: FC<PaginationProps>;

interface YBPanelItemProps {
    noBackground?: boolean;
    className?: any;
    bodyClassName?: any;
    children?: any;
    header?: any;
    body: any;
    title?: string;
}
declare const YBPanelItem: ({ noBackground, className, bodyClassName, children, body, header, title }: YBPanelItemProps) => JSX.Element;

interface CustomTableOptions extends MUIDataTableOptions {
    customHeader?: ReactNode;
}
interface YBTableProps extends HTMLAttributes<unknown> {
    tableTitle?: ReactNode;
    selectableRows?: 'single' | 'multiple' | 'none';
    data: (Record<any, any> | number[] | string[])[];
    columns: MUIDataTableColumn[];
    options?: CustomTableOptions;
    withBorder?: boolean;
    dataTestId?: string;
}
declare const YBTable: ({ tableTitle, selectableRows, withBorder, data, columns, options, className, dataTestId }: YBTableProps) => ReactElement;

type CustomFooterFunction = (count: number, page: number, rowsPerPage: number, changeRowsPerPage: (newPage: string | number) => void, changePage: (newPage: number) => void) => ReactNode;
declare const getCustomFooterComponent: <T>(fetchNextPage: (options?: FetchNextPageOptions) => Promise<InfiniteQueryObserverResult<T, unknown>>, pageSizeCaptionText: string, dataLength: number, hasNextPage?: boolean) => CustomFooterFunction | undefined;

interface RowItemClasses {
    rowTableCell: string;
    queryTableCell: string;
    queryCodeElement: string;
    queryPreBlock: string;
    queryContainerCode: string;
    overrideExpandBtn: string;
}
declare const getRowCellComponent: (appName: AppName, currentTablePage: number, displayedRows: any[], classes: any & RowItemClasses, showQuery: boolean, tableColumns: MUIDataTableColumn[], ignoredColumns: string[], startTime: string | null, endTime: string | null, expandedRowIndex: number | null, handleExpandedRowIndex: (index: number | null) => void, onSelectedQuery?: ((queryId: string, params: QueryPageParams) => void) | undefined) => (data: any[], dataIndex: number) => ReactNode;

type YBTooltipProps = {
    children?: ReactElement;
    dark?: boolean;
    PopperProps?: Partial<PopperProps> & {
        'data-testid'?: string;
    };
} & Omit<TooltipProps, 'children'>;
declare const YBTooltip: VFC<YBTooltipProps>;

interface YBToggleProps extends SwitchProps {
    label?: string;
    formControlLabelProps?: Partial<FormControlLabelProps>;
    inputProps?: InputProps['inputProps'];
}
declare const YBToggle: FC<YBToggleProps>;

type YBInputFieldProps<T extends FieldValues> = UseControllerProps<T> & YBToggleProps;
declare const YBToggleField: <T extends FieldValues>(props: YBInputFieldProps<T>) => ReactElement;

interface MetricSplitSelectorProps {
    metricSplitSelectors: any;
    anomalyData?: AnomalyGroup | null;
    onSplitTypeSelected: (selectedOption: MetricMeasure) => void;
}
declare const MetricSplitSelector: ({ metricSplitSelectors, onSplitTypeSelected, anomalyData }: MetricSplitSelectorProps) => JSX.Element;

interface OutlierSelectorProps {
    metricOutlierSelectors: any;
    selectedNumNodes: number;
    outlierType: SplitMode;
    onOutlierTypeSelected: (selectedOption: SplitMode) => void;
    onNumNodesChanged: (numNodes: number) => void;
}
declare const OutlierSelector: ({ metricOutlierSelectors, selectedNumNodes, outlierType, onOutlierTypeSelected, onNumNodesChanged }: OutlierSelectorProps) => JSX.Element;

interface ClusterRegionSelectorProps$1 {
    selectedItem: string;
    primaryZoneToNodesMap: any;
    asyncZoneToNodesMap: any;
    onZoneNodeSelected: (isZone: boolean, isNode: boolean, selectedOption: string) => void;
}
declare const ZoneNodeSelector: ({ selectedItem, primaryZoneToNodesMap, asyncZoneToNodesMap, onZoneNodeSelected }: ClusterRegionSelectorProps$1) => JSX.Element;

interface ClusterRegionSelectorProps {
    selectedItem: string;
    primaryClusterToRegionMap: any;
    asyncClusterToRegionMap: any;
    onClusterRegionSelected: (isCluster: boolean, isRegion: boolean, selectedOption: string, isPrimaryCluster: boolean) => void;
}
declare const ClusterRegionSelector: ({ selectedItem, primaryClusterToRegionMap, asyncClusterToRegionMap, onClusterRegionSelected }: ClusterRegionSelectorProps) => JSX.Element;

type YBCheckboxFieldProps<T extends FieldValues> = UseControllerProps<T> & YBCheckboxProps;
declare const YBCheckboxField: <T extends FieldValues>(props: YBCheckboxFieldProps<T>) => ReactElement;

declare const IN_DEVELOPMENT_MODE: boolean;
declare const REACT_APP_API_URL: string;

declare const ALL_REGIONS = "All Regions and Clusters";
declare const ALL = "All";
declare const ALL_ZONES = "All Zones and Nodes";
declare const ASH = "ASH";
declare const TYPE = "type";
declare const CORES = "Cores";
declare const QUERIES = "Queries";
declare const MIN_OUTLIER_NUM_NODES = 3;
declare const MAX_OUTLIER_NUM_NODES = 10;
declare const METRIC_FONT = "Inter";
declare const CPU_CORES = "# vCPU";
declare const MetricConsts: {
    readonly NODE_AVERAGE: "Selected Nodes Average";
    readonly ALL: "all";
    readonly ALL_DATABASES: "All Databases";
    readonly TOP: "top";
    readonly PRIMARY: "PRIMARY";
};
declare const ACTIVE_SESSION_HISTORY_EPS_GLOBAL = "active_session_history_eps_global";
declare const ACTIVE_SESSION_HISTORY_QUERY_EVENTS = "active_session_history_query_events";
declare const ACTIVE_SESSION_HISOTRY_EPS_CLIENT_NODE = "active_session_history_eps_client_node";
declare const CPU_COUNT = "cpu_count";
declare const metricSplitSelectors: readonly [{
    readonly value: MetricMeasure.OVERALL;
    readonly label: "Overall";
}, {
    readonly value: MetricMeasure.OUTLIER;
    readonly label: "Outlier Nodes";
    readonly k8label: "Outlier Pods";
}, {
    readonly value: MetricMeasure.OUTLIER_TABLES;
    readonly label: "Outlier Tables";
}, {
    readonly value: MetricMeasure.OUTLIER_DB;
    readonly label: "Outlier Databases";
}];
declare const otherSplitSelectors: readonly [{
    readonly value: MetricMeasure.OVERALL;
    readonly label: "Overall";
}, {
    readonly value: MetricMeasure.OUTLIER;
    readonly label: "Outlier Nodes";
    readonly k8label: "Outlier Pods";
}];
declare const metricOutlierSelectors: readonly [{
    readonly value: "TOP";
    readonly label: "Top";
}, {
    readonly value: "BOTTOM";
    readonly label: "Bottom";
}];
declare const queryTypeSelectors: readonly [{
    readonly value: "All";
    readonly label: "All Queries";
}, {
    readonly value: "SQL";
    readonly label: "SQL";
}, {
    readonly value: "CQL";
    readonly label: "CQL";
}, {
    readonly value: "Background";
    readonly label: "Background";
}];
declare const TABLE_REQUEST_GRAPHS: string[];
declare const SQL_QUERY_REQUEST_GRAPHS: string[];
declare const CQL_QUERY_REQUEST_GRAPHS: string[];
declare const BACKGROUND_QUERY_REQUEST_GRAPHS: string[];
declare const CATALOG_READ_REQUEST_GRAPH = "ysql_connections_per_sec";
declare const ASH_GROUPBY_VALUES: {
    WAIT_EVENT_COMPONENT: string;
    WAIT_EVENT_CLASS: string;
    WAIT_EVENT_TYPE: string;
    WAIT_EVENT: string;
    CLIENT_NODE_IP: string;
    QUERY: string;
};
declare const DEFAULT_RECORDS_PER_PAGE: number[];
declare const ANOMALY_CATEGORY_LIST: AnomalyCategory[];
declare const GLOBAL_RUNTIME_CONFIG = "00000000-0000-0000-0000-000000000000";
declare const RUNTIME_CONFIG_KEYS: {
    SHOW_CLEANUP_HISTORICAL_DATA: string;
    SHOW_QUERIES_VIEW: string;
    SHOW_TOPK_METRICS_VIEW: string;
    SHOW_DB_CLUSTER_LOAD_VIEW: string;
};
declare const ANOMALY_TYPE_TO_NAME_MAP: Record<string, string>;
declare const MORE = "MORE";
declare const ELLIPSIS = "...";
declare const VIEW_MORE = "View More";
declare const TIME_FILTER_LABEL: {
    readonly ONE_HOUR: "Last 1 hour";
    readonly SIX_HOURS: "Last 6 hours";
    readonly ONE_DAY: "Last 1 day";
    readonly TWO_DAYS: "Last 2 days";
    readonly SEVEN_DAYS: "Last 7 days";
    readonly CUSTOM: "Custom";
};
declare const TIME_FILTER_VALUES: {
    readonly ONE_HOUR: "1h";
    readonly SIX_HOURS: "6h";
    readonly ONE_DAY: "1d";
    readonly TWO_DAYS: "2d";
    readonly SEVEN_DAYS: "7d";
    readonly CUSTOM: "Custom";
};
declare const ANOMALY_FILTER_DURATION_OPTIONS: readonly [{
    readonly label: "Last 1 hour";
    readonly value: "1h";
}, {
    readonly label: "Last 6 hours";
    readonly value: "6h";
}, {
    readonly label: "Last 1 day";
    readonly value: "1d";
}, {
    readonly label: "Last 2 days";
    readonly value: "2d";
}, {
    readonly label: "Last 7 days";
    readonly value: "7d";
}, {
    readonly label: "Custom";
    readonly value: "Custom";
}];
declare const filterDurations: readonly [{
    readonly label: "Custom";
    readonly value: "Custom";
}];
declare const CATEGORY_HEADER_DATA_MAP: Record<any, any>;
declare const QUERY_DETAILS = "QUERY DETAILS";
declare const QUERY_TAG = "QUERY";
declare const DB_CAPS_TAG_ = "DATABASE";
declare const QUERY_TYPE_TAG = "QUERY TYPE";
declare const DB_TAG = "Database";
declare const USER_TAG = "User";
declare const TABLE_TAG = "Table";
declare const TABLET_TAG = "Tablet Id";
declare const TABLET_ID_TAG = "TABLET ID";
declare const ANOMALY_TAG = "ANOMALY";
declare const REGION_ZONE_TAG = "REGION/ZONE";
declare const REGION_TAG = "Region";
declare const ZONE_TAG = "Zone";
declare const MetricOrigin: {
    readonly TABLE: "table";
    readonly CUSTOMER: "customer";
    readonly UNIVERSE: "universe";
};
declare const METRIC_TABS: readonly ["ysql_ops", "ycql_ops", "server", "per_process", "disk_io", "tserver", "master", "master_advanced", "lsmdb"];
declare const METRIC_TABS_TABLES: string[];
declare const METRIC_TABS_DATABASES: string[];
declare const METRIC_TABLES_RESOURCES_WITH_GRAPHS: {
    title: string;
    name: string;
    metrics: string[];
}[];
declare const METRIC_DB_RESOURCES_WITH_GRAPHS: {
    title: string;
    name: string;
    metrics: string[];
}[];
declare const METRIC_RESOURCES_WITH_GRAPHS: readonly [{
    readonly title: "YSQL";
    readonly name: "ysql_ops";
    readonly metrics: readonly ["ysql_server_rpc_per_second", "ysql_sql_latency", "ysql_connections", "ysql_connections_per_sec", "ysql_server_advanced_rpc_per_second", "ysql_sql_advanced_latency", "ysql_catalog_cache_misses", "ysql_conn_mgr_active_connections"];
}, {
    readonly title: "YCQL";
    readonly name: "ycql_ops";
    readonly metrics: readonly ["cql_server_rpc_per_second", "cql_sql_latency", "cql_server_rpc_p99", "cql_sql_latency_breakdown", "cql_yb_local_vs_remote", "cql_yb_latency", "cql_reactor_latency", "tserver_rpc_queue_size_cql", "cql_response_sizes", "cql_yb_transaction", "cql_yb_rpc_connections"];
}, {
    readonly title: "Resource";
    readonly name: "server";
    readonly metrics: readonly ["cpu_usage", "memory_usage", "disk_iops", "disk_usage_percent", "disk_used_size_total", "disk_volume_usage_percent", "disk_volume_used", "disk_bytes_per_second_per_node", "disk_io_time", "disk_io_queue_depth", "disk_io_read_latency", "disk_io_write_latency", "network_packets", "network_bytes", "network_errors", "system_load_over_time", "node_clock_skew"];
}, {
    readonly title: "Per Process";
    readonly name: "per_process";
    readonly metrics: readonly ["process_user_cpu_seconds", "process_system_cpu_seconds", "process_virtual_memory", "process_resident_memory", "process_proportional_memory", "process_io_read", "process_io_write", "process_open_files"];
}, {
    readonly title: "Disk I/O";
    readonly name: "disk_io";
    readonly metrics: readonly ["disk_iops", "disk_usage_percent", "disk_used_size_total", "disk_volume_usage_percent", "disk_volume_used", "disk_bytes_per_second_per_node", "lsm_rocksdb_flush_size", "lsm_rocksdb_compaction", "lsm_rocksdb_compaction_time", "tserver_log_bytes_read", "tserver_log_bytes_written"];
}, {
    readonly title: "Tablet Server";
    readonly name: "tserver";
    readonly metrics: readonly ["tserver_rpcs_per_sec_per_node", "tserver_ops_latency", "tserver_handler_latency", "tserver_threads_running", "tserver_threads_started", "tserver_uptime_min", "tserver_consensus_rpcs_per_sec", "tserver_change_config", "tserver_remote_bootstraps", "tserver_consensus_rpcs_latency", "tserver_change_config_latency", "tserver_context_switches", "tserver_spinlock_server", "tserver_log_latency", "tserver_log_bytes_written", "tserver_log_bytes_read", "tserver_log_ops_second", "tserver_write_lock_latency", "tserver_tc_malloc_stats", "tserver_log_stats", "tserver_cache_reader_num_ops", "tserver_glog_info_messages", "tserver_rpc_queue_size_tserver", "tserver_cpu_util_secs", "tserver_yb_rpc_connections", "tserver_live_tablet_peers", "raft_leader", "tserver_max_follower_lag"];
}, {
    readonly title: "Master Server";
    readonly name: "master";
    readonly metrics: readonly ["master_overall_rpc_rate", "master_latency", "master_uptime_min", "master_get_tablet_location", "master_tsservice_reads", "master_tsservice_reads_latency", "master_tsservice_writes", "master_tsservice_writes_latency", "master_ts_heartbeats", "tserver_rpc_queue_size_master", "master_consensus_update", "master_consensus_update_latency", "master_multiraft_consensus_update", "master_multiraft_consensus_update_latency", "master_table_ops", "master_cpu_util_secs", "master_yb_rpc_connections", "master_leaderless_and_underreplicated_tablets", "master_max_follower_lag", "master_load_balancer_stats"];
}, {
    readonly title: "Master Server Advanced";
    readonly name: "master_advanced";
    readonly metrics: readonly ["master_threads_running", "master_log_latency", "master_log_bytes_written", "master_log_bytes_read", "master_tc_malloc_stats", "master_glog_info_messages", "master_lsm_rocksdb_seek_next_prev", "master_lsm_rocksdb_num_seeks_per_node", "master_lsm_rocksdb_total_sst_per_node", "master_lsm_rocksdb_avg_num_sst_per_node", "master_lsm_rocksdb_block_cache_hit_miss", "master_lsm_rocksdb_block_cache_usage", "master_lsm_rocksdb_blooms_checked_and_useful", "master_lsm_rocksdb_flush_size", "master_lsm_rocksdb_compaction", "master_lsm_rocksdb_compaction_numfiles", "master_lsm_rocksdb_compaction_time"];
}, {
    readonly title: "DocDB";
    readonly name: "lsmdb";
    readonly metrics: readonly ["lsm_rocksdb_seek_next_prev", "lsm_rocksdb_total_sst_per_node", "lsm_rocksdb_avg_num_sst_per_node", "lsm_rocksdb_latencies_get", "lsm_rocksdb_latencies_write", "lsm_rocksdb_latencies_seek", "lsm_rocksdb_latencies_mutex", "lsm_rocksdb_block_cache_hit_miss", "lsm_rocksdb_block_cache_usage", "lsm_rocksdb_blooms_checked_and_useful", "lsm_rocksdb_stalls", "lsm_rocksdb_write_rejections", "lsm_rocksdb_memory_rejections", "lsm_rocksdb_flush_size", "lsm_rocksdb_compaction", "lsm_rocksdb_compaction_tasks", "lsm_rocksdb_compaction_time", "lsm_rocksdb_compaction_numfiles", "lsm_rocksdb_mem_tracker_db_memtable", "docdb_transaction", "docdb_transaction_pool_cache", "tablet_splitting_stats", "automatic_split_manager_time"];
}];
declare const RCA_GANT_CHART = "gant-chart-anomalies";
declare const METRIC_NAMES: {
    ysql_server_rpc_per_second: string;
    ysql_sql_latency: string;
    ysql_connections: string;
    ysql_connections_per_sec: string;
    ysql_server_advanced_rpc_per_second: string;
    ysql_sql_advanced_latency: string;
    ysql_catalog_cache_misses: string;
    ysql_conn_mgr_active_connections: string;
    cql_server_rpc_per_second: string;
    cql_sql_latency: string;
    cql_server_rpc_p99: string;
    cql_sql_latency_breakdown: string;
    cql_yb_local_vs_remote: string;
    cql_yb_latency: string;
    cql_reactor_latency: string;
    tserver_rpc_queue_size_cql: string;
    response_sizes: string;
    cql_yb_transaction: string;
    cql_yb_rpc_connections: string;
    cpu_usage: string;
    memory_usage: string;
    disk_iops: string;
    disk_usage_percent: string;
    disk_used_size_total: string;
    disk_volume_usage_percent: string;
    disk_volume_used: string;
    disk_bytes_per_second_per_node: string;
    disk_io_time: string;
    disk_io_queue_depth: string;
    disk_io_read_latency: string;
    disk_io_write_latency: string;
    network_packets: string;
    network_bytes: string;
    network_errors: string;
    system_load_over_time: string;
    node_clock_skew: string;
    process_user_cpu_seconds: string;
    process_system_cpu_seconds: string;
    process_virtual_memory: string;
    process_resident_memory: string;
    process_proportional_memory: string;
    process_io_read: string;
    process_io_write: string;
    process_open_files: string;
    tserver_rpcs_per_sec_per_node: string;
    tserver_ops_latency: string;
    tserver_handler_latency: string;
    tserver_threads_running: string;
    tserver_threads_started: string;
    tserver_uptime_min: string;
    tserver_consensus_rpcs_per_sec: string;
    tserver_change_config: string;
    tserver_remote_bootstraps: string;
    tserver_consensus_rpcs_latency: string;
    tserver_change_config_latency: string;
    tserver_context_switches: string;
    tserver_spinlock_server: string;
    tserver_log_latency: string;
    tserver_log_bytes_written: string;
    tserver_log_bytes_read: string;
    tserver_log_ops_second: string;
    tserver_write_lock_latency: string;
    tserver_tc_malloc_stats: string;
    tserver_log_stats: string;
    tserver_cache_reader_num_ops: string;
    tserver_glog_info_messages: string;
    tserver_rpc_queue_size_tserver: string;
    tserver_cpu_util_secs: string;
    tserver_yb_rpc_connections: string;
    tserver_live_tablet_peers: string;
    raft_leader: string;
    tserver_max_follower_lag: string;
    master_overall_rpc_rate: string;
    master_latency: string;
    master_uptime_min: string;
    master_get_tablet_location: string;
    master_tsservice_reads: string;
    master_tsservice_reads_latency: string;
    master_tsservice_writes: string;
    master_tsservice_writes_latency: string;
    master_ts_heartbeats: string;
    tserver_rpc_queue_size_master: string;
    master_consensus_update: string;
    master_consensus_update_latency: string;
    master_multiraft_consensus_update: string;
    master_multiraft_consensus_update_latency: string;
    master_table_ops: string;
    master_cpu_util_secs: string;
    master_yb_rpc_connections: string;
    master_leaderless_and_underreplicated_tablets: string;
    master_max_follower_lag: string;
    master_load_balancer_stats: string;
    master_threads_running: string;
    master_log_latency: string;
    master_log_bytes_written: string;
    master_log_bytes_read: string;
    master_tc_malloc_stats: string;
    master_glog_info_messages: string;
    master_lsm_rocksdb_seek_next_prev: string;
    master_lsm_rocksdb_num_seeks_per_node: string;
    master_lsm_rocksdb_total_sst_per_node: string;
    master_lsm_rocksdb_avg_num_sst_per_node: string;
    master_lsm_rocksdb_block_cache_hit_miss: string;
    master_lsm_rocksdb_block_cache_usage: string;
    master_lsm_rocksdb_blooms_checked_and_useful: string;
    master_lsm_rocksdb_flush_size: string;
    master_lsm_rocksdb_compaction: string;
    master_lsm_rocksdb_compaction_numfiles: string;
    master_lsm_rocksdb_compaction_time: string;
    lsm_rocksdb_seek_next_prev: string;
    lsm_rocksdb_total_sst_per_node: string;
    lsm_rocksdb_avg_num_sst_per_node: string;
    lsm_rocksdb_latencies_get: string;
    lsm_rocksdb_latencies_write: string;
    lsm_rocksdb_latencies_seek: string;
    lsm_rocksdb_latencies_mutex: string;
    lsm_rocksdb_block_cache_hit_miss: string;
    lsm_rocksdb_block_cache_usage: string;
    lsm_rocksdb_blooms_checked_and_useful: string;
    lsm_rocksdb_stalls: string;
    lsm_rocksdb_write_rejections: string;
    lsm_rocksdb_memory_rejections: string;
    lsm_rocksdb_flush_size: string;
    lsm_rocksdb_compaction: string;
    lsm_rocksdb_compaction_tasks: string;
    lsm_rocksdb_compaction_time: string;
    lsm_rocksdb_compaction_numfiles: string;
    lsm_rocksdb_mem_tracker_db_memtable: string;
    docdb_transaction: string;
    docdb_transaction_pool_cache: string;
    tablet_splitting_stats: string;
    automatic_split_manager_time: string;
    table_read_latency: string;
    table_read_rps: string;
    table_write_latency: string;
    table_write_rps: string;
    table_log_latency: string;
    table_log_ops_second: string;
    table_log_bytes_written: string;
    table_write_lock_latency: string;
    table_seek_next_prev: string;
    table_ops_in_flight: string;
    table_write_rejections: string;
    table_memory_rejections: string;
    table_compaction: string;
    table_block_cache_hit_miss: string;
    table_rocksdb_blooms_checked_and_useful: string;
    table_mem_tracker_db_memtable: string;
};
declare const METRICS_SESSION_STORAGE_KEY = "METRICS_NAMES";
declare const METRICS_OUTLIER_TABLES_STORAGE_KEY = "METRICS_OUTLIER_TABLES_NAMES";
declare const METRICS_OUTLIER_DATABASES_STORAGE_KEY = "METRICS_OUTLIER_DATABASES_NAMES";
declare const COLORS: string[];
declare const NAME_COLOR_MAPPING: {
    [key: string]: string;
};
declare const DEFAULT_ERROR_MESSAGES: {
    UNIVERSE_PA_STATUS_ERROR: string;
    UNIVERSE_DETAILS_ERROR: string;
    ANOMALIES_FETCH_ERROR: string;
    SHOW_MORE_ANOMALIES_FETCH_ERROR: string;
    ANOMALY_SCHEDULE_ERROR: string;
    RUNTIME_CONFIGS_ERROR: string;
    RCA_GRAPHS_FETCH_ERROR: string;
    GANTCHART_FETCH_ERROR: string;
    QUERIES_GRAPHS_FETCH_ERROR: string;
    METRICS_GRAPHS_FETCH_ERROR: string;
    HISTORICAL_QUERY_DATA_FETCH_ERROR: string;
    CLUSTER_LOAD_FETCH_ERROR: string;
    QUERY_STATS_FETCH_ERROR: string;
};

declare function isDefinedNotNull(obj: any): boolean;
declare function isEmptyArray(arr: any): boolean;
declare function isNonEmptyArray(arr: any): boolean;
declare function isNullOrEmpty(obj: any): boolean;
declare function isEmptyObject(obj: any): boolean;
declare function isNonEmptyObject(obj: any): boolean;
declare function isNonEmptyString(str: string): boolean;
declare function isEmptyString(str: string): boolean;
declare const isValidObject: typeof isDefinedNotNull;
declare function removeNullProperties(obj: any): void;
declare function isYAxisGreaterThanThousand(dataArray: any): boolean;

export { ACTIVE_SESSION_HISOTRY_EPS_CLIENT_NODE, ACTIVE_SESSION_HISTORY_EPS_GLOBAL, ACTIVE_SESSION_HISTORY_QUERY_EVENTS, ALL, ALL_REGIONS, ALL_ZONES, ANOMALY_CATEGORY_LIST, ANOMALY_FILTER_DURATION_OPTIONS, ANOMALY_TAG, ANOMALY_TYPE_TO_NAME_MAP, ASH, ASH_GROUPBY_VALUES, AggregatedLineSettings, Aggregation, AlertVariant, Anomaly, AnomalyCategory, AnomalyDetails, AnomalyDetectionStatus, AnomalyDetectionStatusText, AnomalyGroup, AnomalyInstance, AnomalyResponse, AnomalyType, AnomalyTypeFilter, AppName, AttachUniversePayload, AuthDetails, BACKGROUND_QUERY_REQUEST_GRAPHS, CATALOG_READ_REQUEST_GRAPH, CATEGORY_HEADER_DATA_MAP, COLORS, CORES, CPU_CORES, CPU_COUNT, CQL_QUERY_REQUEST_GRAPHS, ChartType, ClusterLoadResponseData, ClusterLoadTabs, ClusterNodeInfo, ClusterNodeListMetadata, ClusterRegionSelector, Column, ColumnOptions, ConfigureUniverseMetadata, DB_CAPS_TAG_, DB_TAG, DEFAULT_ERROR_MESSAGES, DEFAULT_RECORDS_PER_PAGE, ELLIPSIS, FormattedAnomalyRca, GLOBAL_RUNTIME_CONFIG, GROUP_BY_OPERATIONS, GenericFailure, GraphAxisData, GraphFilters, GraphMetadata, GraphRequestParams, GraphResponse, GraphSettings, GraphType, GroupEventsParam, IN_DEVELOPMENT_MODE, InsightsTabs, MAX_OUTLIER_NUM_NODES, METRICS_OUTLIER_DATABASES_STORAGE_KEY, METRICS_OUTLIER_TABLES_STORAGE_KEY, METRICS_SESSION_STORAGE_KEY, METRIC_DB_RESOURCES_WITH_GRAPHS, METRIC_FONT, METRIC_NAMES, METRIC_RESOURCES_WITH_GRAPHS, METRIC_TABLES_RESOURCES_WITH_GRAPHS, METRIC_TABS, METRIC_TABS_DATABASES, METRIC_TABS_TABLES, MIN_OUTLIER_NUM_NODES, MORE, MetadataFields, MetricConsts, MetricMeasure, MetricOrigin, MetricSplitSelector, MetricsAnalysisEntry, MetricsAnalysisEntryProps, NAME_COLOR_MAPPING, NodeData, NodeDataCloudInfo, NodeDataMetrics, NodeDetails, NodeInfo, NodeState, OutlierSelector, PAUrlParams, PerfAdvisorAPI, PerfAdvisorEntry, PrimaryDashboardViewTabs, QUERIES, QUERY_DETAILS, QUERY_KEY, QUERY_TAG, QUERY_TYPE_TAG, QueryPageParams, QueryType, QueryTypeMode, QueryWaitEvents, RCAGuideline, RCA_GANT_CHART, REACT_APP_API_URL, REGION_TAG, REGION_ZONE_TAG, RUNTIME_CONFIG_KEYS, Resources, RowItemClasses$1 as RowItemClasses, RuntimeConfigData, RuntimeConfigType, RuntimeConfigs, SQL_QUERY_REQUEST_GRAPHS, SortDirection, SplitMode, SplitType, TABLET_ID_TAG, TABLET_TAG, TABLE_REQUEST_GRAPHS, TABLE_TAG, TIME_FILTER_LABEL, TIME_FILTER_VALUES, TPFeatureFlags, TYPE, TableInfo, TablePageParams, TroubleshootingRecommendations, URL_TAB_PATH, USER_TAG, Universe, UniverseConfig, UniverseMetadataFields, UniverseQueryData, UniverseQueryStatsData, UpdateMetadataFormFields, UpdateRuntimeConfigFormFields, UrlParams, VIEW_MORE, WAIT_EVENT_MAPPING, WaitEventClassification, YBAlert, YBButton, YBCheckbox, YBCheckboxField, YBCodeBlock, YBDateTimePicker, YBErrorIndicator, YBInfinitePagination, YBInput, YBInputField, YBLabel, YBModal, YBPagination, YBPanelItem, YBSelect, YBTable, YBToggle, YBToggleField, YBTooltip, ZONE_TAG, ZoneNodeSelector, filterDurations, getCustomFooterComponent, getRowCellComponent, isDefinedNotNull, isEmptyArray, isEmptyObject, isEmptyString, isNonEmptyArray, isNonEmptyObject, isNonEmptyString, isNullOrEmpty, isValidObject, isYAxisGreaterThanThousand, metricOutlierSelectors, metricSplitSelectors, otherSplitSelectors, queryTypeSelectors, removeNullProperties, useCodeBlockStyles };
