@databrainhq/plugin 0.15.33 → 0.15.34

package/dist/containers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Dashboard';
+export * from './PluginProvider';
+export * from './Metric';

package/dist/helpers/adaptiveFormatter.d.ts

@@ -0,0 +1,6 @@
+/**
+ *  @name adaptiveFormatter - helps in formatting the data in adaptive format (eg. k, M, B etc)
+ *  @params - takes the value that needs to be formatted and a flag that tells if the value is in decimals or not
+ *  @returns - value in adaptive format
+ */
+export declare const adaptiveFormatter: (val: any, isDecimal: boolean, hasDecimalNums?: boolean) => string;

package/dist/helpers/areArraysEqual.d.ts

@@ -0,0 +1 @@
+export declare const areArraysEqual: (arr1: any, arr2: any) => any;

package/dist/helpers/autoCompleteHelpers.d.ts

@@ -0,0 +1,95 @@
+import { ChartSettingsType, FilteredOptionResult, FloatingDropDownOption, KeywordFilteredResult, SearchColumn, SelectedColumn, SqlColumns, TableObjectType } from '@/types';
+export declare const getSearchKeywordList: (searchString: string) => string[];
+export declare const getFilteredKeywords: (keywordList: string[], isNumberFilter: boolean) => KeywordFilteredResult;
+export declare const parseNumberName: (keywords: string[]) => number;
+export declare const isLikeFilterColumn: (column: SelectedColumn) => boolean;
+export declare const getOptionLabel: ({ column, keywords, likeOperationMatch, }: {
+    column: SelectedColumn;
+    keywords: string[];
+    likeOperationMatch: RegExpMatchArray | null;
+}) => string;
+export declare const getSortLimitAppliedColumnOptions: ({ columnOptions, limit, sortType, }: {
+    columnOptions: SelectedColumn[];
+    sortType: string | undefined;
+    limit: number;
+}) => SelectedColumn[];
+export declare const isSynonymPatternMatching: (opt: SelectedColumn, searchString: string, isLike: boolean) => boolean;
+export declare const getPrimaryFilteredOptions: (options: SelectedColumn[], searchString: string, isLike: boolean) => FilteredOptionResult;
+export declare const getRemainingFilterOption: ({ isLike, isQuestion, keywordList, options, isGroupBy, }: {
+    options: SelectedColumn[];
+    keywordList: string[];
+    isLike: boolean;
+    isQuestion: boolean;
+    isGroupBy: boolean;
+}) => SelectedColumn[];
+export declare const getFinalFilteredList: ({ keywordList, limit, options, isLikeFilter, isLikeOperation, isNumberFilter, isEnforceLikeFilter, isEndWith, isStartWith, sortType, }: {
+    options: SelectedColumn[];
+    limit: number;
+    keywordList: string[];
+    isLikeOperation: RegExpMatchArray | null;
+    isLikeFilter: RegExpMatchArray | null;
+    isNumberFilter: RegExpMatchArray | null;
+    isEnforceLikeFilter: boolean;
+    isStartWith: boolean;
+    isEndWith: boolean;
+    sortType: string | undefined;
+}) => SelectedColumn[];
+export declare const getColumnDataType: (datatype: string) => "NUMBER" | "STRING" | "DATE" | "ARRAY" | "BOOLEAN" | undefined;
+export declare const getHelperFunctions: (datatype: 'NUMBER' | 'STRING' | 'DATE' | 'ARRAY' | 'BOOLEAN' | undefined, isElasticSearch: boolean) => FloatingDropDownOption[];
+export declare const getLastWordBeforeSpace: (value: string) => string;
+export declare const isSearchKeywordIncluded: (field: keyof SearchColumn, opt: SearchColumn, keyword: string) => boolean;
+export declare const isValidOption: (options: SearchColumn[], keyword: string) => boolean;
+export declare const getEnableCharts: (data: Record<string, any>[], groupByList: string[]) => string[];
+export declare const chartDimensions: (data: Record<string, any>[], groupByColumnList: string[], chartType: string) => {
+    yAxisList: string[];
+    xAxis: string;
+    singleValue: string;
+};
+export declare const getChartDimensions: (columns: SqlColumns, chartType: string) => {
+    yAxisList: string[];
+    xAxis: string;
+    singleValue: string;
+    progressData: string;
+    progressMaxData: string;
+    progressMinData: string;
+};
+export declare const getEnabledCharts: (data: Record<string, any>[], columns: SqlColumns) => string[];
+export declare const getColumns: ({ columns, data, dbName, }: {
+    data: Record<string, any>[];
+    columns: SqlColumns;
+    dbName: string;
+}) => {
+    resDataColumns: string[];
+    dimensions: string[];
+    measures: string[];
+};
+export declare const combineFollowUpQuestions: (searchState: any) => string[];
+export declare const determineChartType: ({ isProgressiveDimension, orderBy, dimensionCount, measureCount, dataLength, isCountryDimension, isDifferentMeasureScales, isNullValue, questionType, }: {
+    orderBy?: "ASC" | "DESC" | undefined;
+    isTimeSeries?: boolean | undefined;
+    isProgressiveDimension?: boolean | undefined;
+    dimensionCount?: number | undefined;
+    measureCount?: number | undefined;
+    dataLength?: number | undefined;
+    isCountryDimension?: boolean | undefined;
+    isDifferentMeasureScales?: boolean | undefined;
+    isNullValue?: boolean | undefined;
+    questionType?: string | undefined;
+}) => string;
+export declare const getChartSettings: ({ chartType, dimensions, measures, chartSettings, columns, displayText, sqlMetadata, tableList, isRepeatedValue, dimensionMetadata, measureMetadata, isMultiSeries, }: {
+    chartType: ChartSettingsType['chartType'];
+    dimensions: string[];
+    measures: string[];
+    chartSettings: ChartSettingsType;
+    columns: string[];
+    displayText?: string | undefined;
+    sqlMetadata: Record<string, any>[];
+    dimensionMetadata: Record<string, any>[];
+    measureMetadata: Record<string, any>[];
+    tableList: TableObjectType[];
+    isRepeatedValue: boolean;
+    isMultiSeries: boolean;
+}) => ChartSettingsType;
+export declare const hasRepeatedValue: (arr: Record<string, any>[], key: string) => boolean;
+export declare const getValidJsonArray: (json: string) => any[];
+export declare const getValidJsonObject: (json: string) => any;

package/dist/helpers/cardActions.d.ts

@@ -0,0 +1,5 @@
+import { ClickActionsConfig } from '@/types';
+export declare const handleChartRoute: (route: string, isOpenInNewTab?: boolean) => void;
+export declare const handleRoute: (routeType: string, route: string) => void;
+export declare const handleCardClick: (clickActionsConfig: ClickActionsConfig, metricId: string, id: string) => void;
+export declare const handleChartClickRouting: (clickActionsConfig: ClickActionsConfig['chart'], value: string | number) => void;

package/dist/helpers/chartOptions.d.ts

@@ -0,0 +1,93 @@
+import { CustomSettings, LabelSettings } from '@/types';
+type DataRow = Record<string, any>;
+type GetXaxisDataParams = {
+    data: DataRow[];
+    xAxis: string;
+    isGroupBy: boolean;
+    isGroupXAxis: boolean;
+};
+type GetDatasetParams = {
+    data: DataRow[];
+    yAxisList: string[];
+    seriesField: string;
+    xAxisData: string[];
+    isGroupBy: boolean;
+    xAxis: string;
+    groupByColumnUniqueValue: string[];
+    isShowPercentageFullStack: boolean;
+    groupXAxis: {
+        isGroupXAxis: boolean;
+        Aggregate: 'SUM' | 'AVG' | 'MAX' | 'MIN';
+    };
+};
+export type Dataset = {
+    label: string;
+    data: (number | null)[];
+};
+type GetSeriesDataParams = {
+    labelSettings: LabelSettings;
+    customSettings: CustomSettings;
+    datasets: Dataset[];
+    isShowPercentageFullStack: boolean;
+    type: string;
+    isShowSymbol: boolean;
+    barChartSettings?: Record<string, any>;
+    lineChartSettings?: Record<string, any>;
+    isShowCumulativeBar: boolean;
+    stackChartSettings?: Record<string, any>;
+    isEnableValueSummation?: boolean;
+    colorPalette?: string[];
+    axisPosition?: string;
+    chartLabelPosition?: 'hidden' | 'top' | 'left' | 'right' | 'bottom' | 'outside' | 'inside';
+};
+type GetChartLengendDataParams = {
+    isGroupBy: boolean;
+    yAxisList: string[];
+    groupByColumnUniqueValue: string[];
+    isShowPercentageFullStack: boolean;
+};
+export declare const getXaxisData: ({ data, isGroupBy, xAxis, isGroupXAxis, }: GetXaxisDataParams) => string[];
+export declare const getChartDataset: ({ data, isGroupBy, seriesField, xAxis, xAxisData, yAxisList, groupByColumnUniqueValue, isShowPercentageFullStack, groupXAxis, }: GetDatasetParams) => Dataset[];
+export declare const getPercentageData: (datasets: Dataset[]) => Record<string, (string | null)[]>;
+export declare const getCumulativeBarData: (datasets: Dataset[], isShowCumulativeBar: boolean) => Dataset[];
+export declare const getSummationLabelValue: (datasets: Dataset[], isShowPercentageFullStack: boolean) => any[];
+export declare const getChartSeriesData: ({ labelSettings, customSettings, datasets, isShowPercentageFullStack, type, isShowSymbol, barChartSettings, isShowCumulativeBar, stackChartSettings, isEnableValueSummation, lineChartSettings, colorPalette, axisPosition, chartLabelPosition, }: GetSeriesDataParams) => {
+    emphasis: {
+        focus: string;
+    };
+    type: string;
+    showSymbol: boolean;
+    markArea?: {
+        silent: boolean;
+        label: {
+            position: string;
+        };
+        data: ({
+            name: string;
+            yAxis: number;
+            itemStyle: {
+                borderColor: string | undefined;
+                borderWidth: number;
+                color: string;
+            };
+        } | {
+            yAxis: number;
+            name?: undefined;
+            itemStyle?: undefined;
+        })[][];
+    } | undefined;
+    data: (number | null)[] | (string | null)[];
+    name: string;
+    label: {
+        show: boolean | undefined;
+        position: string | undefined;
+        formatter(d: {
+            data: any;
+            name: string;
+            seriesIndex: number;
+            dataIndex: number;
+        }): string;
+    };
+}[];
+export declare const getChartLengendData: ({ groupByColumnUniqueValue, isGroupBy, isShowPercentageFullStack, yAxisList, }: GetChartLengendDataParams) => string[];
+export {};

package/dist/helpers/checkIsElementInViewport.d.ts

@@ -0,0 +1 @@
+export declare const isInViewport: (element: any) => boolean;

package/dist/helpers/conditionalFormatting.d.ts

@@ -0,0 +1,3 @@
+import { ConditionalFormattingParam } from '@/types';
+declare const conditionalFormattingStyles: ({ rules, value: columnValue, }: ConditionalFormattingParam) => any;
+export default conditionalFormattingStyles;

package/dist/helpers/copyToClipboard.d.ts

@@ -0,0 +1,4 @@
+declare const copyToClipboard: (textToCopy: string) => void;
+export default copyToClipboard;
+export declare const onCopy: (text: string) => void;
+export declare const copyTextAndCallback: (text: string, onComplete: () => void) => void;

package/dist/helpers/createMetric.d.ts

@@ -0,0 +1,26 @@
+import { Aggregate, ChartSettingsType, DatasetMetricCreationConfiguration, Dimension, FloatingDropDownOption, RlsCondition, SelectedColumn, SetChartFieldParams } from '@/types';
+export declare const functionOptions: (col?: SelectedColumn, dataType?: string) => FloatingDropDownOption[];
+export declare const getColumnType: (column: SelectedColumn) => "custom" | "default" | "arithmetic_column";
+export declare const getGroupedColumnList: (data: any[]) => string[];
+export declare const getDimensionsAndAggregates: (columns: SelectedColumn[]) => {
+    dimensions: Dimension[];
+    aggregates: Aggregate[];
+};
+export declare const getChartFields: (colList: SelectedColumn[], dbName: string) => string[];
+export declare const getAppliedFilters: (filterList: RlsCondition[], companyTenancyType: string, clientId: string) => RlsCondition[];
+export declare const getChartType: ({ aggregates, dimensions, }: DatasetMetricCreationConfiguration) => ChartSettingsType['chartType'];
+export declare const getSchemaNameAlias: (schemaName: string, dbName: string) => string;
+export declare const isDateStringValid: (dateString: string) => boolean;
+export declare const getSavedChartFields: (optionList: string[], newData?: any[]) => string[];
+export declare const setChartFields: ({ chartType, chartDimensions, chartMetrics, chartAggregateColumns, resultData, configAggregates, pivotHeaderColumns, chartTimeColumns, setChartSettings, chartSettings, configuration, }: SetChartFieldParams) => void;
+export declare const getDatabaseName: (name: string) => "bigquery" | "mysql" | "postgresql";
+export declare const getWordCount: (text: string) => number;
+export declare const generateRandomId: (length?: number) => string;
+export declare const enableSaveToDashboardButton: ({ chartSettings, dimensions, isCustomTable, metrics, }: {
+    chartSettings: ChartSettingsType;
+    dimensions: SelectedColumn[];
+    metrics: SelectedColumn[];
+    isCustomTable: boolean;
+}) => number | undefined;
+export declare const deepEqual: (obj1: Record<string, any> | undefined, obj2: Record<string, any> | undefined) => boolean;
+export declare const sqlGuideLines: (dbName: string, isDatabaseTenancy: boolean) => string[];

package/dist/helpers/darkColorIdentifier.d.ts

@@ -0,0 +1,2 @@
+export declare const darkColorIdentifier: (color: string) => boolean;
+export declare const adjustColor: (hexColor: string) => string;

package/dist/helpers/dateFormatter.d.ts

@@ -0,0 +1 @@
+export declare const dateFormatter: (date: string, timeFormat: string) => string;

package/dist/helpers/generateColorPalette.d.ts

@@ -0,0 +1 @@
+export declare const generateColorPalette: (originalColors: string[], numberOfRecords: number) => string[];

package/dist/helpers/generateTimeRangeWhereClause.d.ts

@@ -0,0 +1,13 @@
+export declare const isValidDate: (date: any) => boolean;
+declare const generateTimeRangeWhereClause: ({ isTimeColumn, timeColumnName, timeCount, timeGrain, timeRangeIndicator, databaseType, endDate, startDate, comparsionOperator, }: {
+    timeColumnName: string;
+    timeRangeIndicator: string;
+    timeCount: number;
+    timeGrain: string;
+    isTimeColumn: boolean;
+    startDate?: Date | undefined;
+    endDate?: Date | undefined;
+    databaseType?: string | undefined;
+    comparsionOperator?: string | undefined;
+}) => string;
+export default generateTimeRangeWhereClause;

package/dist/helpers/getColumnType.d.ts

@@ -0,0 +1,2 @@
+export declare const getColumnTypes: (data: Record<string, any>[]) => Record<string, string>;
+export default getColumnTypes;

package/dist/helpers/getComboRangeLabel.d.ts

@@ -0,0 +1,5 @@
+export declare const getComboRangeLabel: (value: any, formatter: {
+    upperLimit: number;
+    lowerLimit: number;
+    label: string;
+}[]) => any;

package/dist/helpers/getFilterAppliedQuery.d.ts

@@ -0,0 +1,71 @@
+import { DataMartRelationShip } from './getModifiedQuery';
+export declare const getTableName: (table: string, isElasticSearch: boolean) => string;
+export declare const removeComments: (sql: string) => string;
+export declare const getTableNameWithQuotes: (tableName: string, isDatabricks: boolean, dbName: string) => string;
+export declare const getTableNameWithSchemaQuotes: ({ dbName, isDatabricks, schemaName, tableName, }: {
+    schemaName: string;
+    isDatabricks: boolean;
+    dbName: string;
+    tableName: string;
+}) => string;
+export declare const buildJoinQuery: ({ dbName, relationShip, schemaName, tableName, }: {
+    relationShip?: DataMartRelationShip | undefined;
+    schemaName: string;
+    dbName: string;
+    tableName: string;
+}) => string;
+export declare const injectWhereCondition: ({ condition, matchedTableName, query, isAsscociatedQuery, joinString, associatedTableNameWithQuotes, }: {
+    query: string;
+    matchedTableName: string;
+    matchedTableRegex: RegExp;
+    tableName: string;
+    condition: string;
+    dbName: string;
+    isAsscociatedQuery?: boolean | undefined;
+    joinString?: string | undefined;
+    associatedTableNameWithQuotes?: string | undefined;
+}) => string;
+export declare const injectWhereConditionOld: ({ condition, matchedTableName, matchedTableRegex, query, tableName, dbName, isAsscociatedQuery, joinString, associatedTableNameWithQuotes, }: {
+    query: string;
+    matchedTableName: string;
+    matchedTableRegex: RegExp;
+    tableName: string;
+    condition: string;
+    dbName: string;
+    isAsscociatedQuery?: boolean | undefined;
+    joinString?: string | undefined;
+    associatedTableNameWithQuotes?: string | undefined;
+}) => string;
+export declare const getReplacedQuery: (table: {
+    tableName: string;
+    condition: string;
+    dataMartRelationships?: DataMartRelationShip[] | undefined;
+}, query: string, dbName: string) => string;
+interface Condition {
+    condition: string;
+    tableName: string;
+}
+interface GroupedTables {
+    parentTable: string;
+    childTables: {
+        tableName: string;
+        condition: string;
+        join: string;
+        columnName: string;
+        parentColumn: string;
+        filterTableName: string;
+    }[];
+}
+export declare const groupChildTablesByParent: (conditions: Condition[], relationships: DataMartRelationShip[]) => GroupedTables[];
+export declare const buildJoinQueryWithChildTable: ({ dbName, schemaName, parentTableName, childTables, }: {
+    schemaName: string;
+    dbName: string;
+    parentTableName: string;
+    childTables: GroupedTables['childTables'];
+}) => string;
+export declare const getReplacedParentTableQuery: ({ dbName, parentTables, query, }: {
+    parentTables: GroupedTables;
+    dbName: string;
+    query: string;
+}) => string;
+export {};

package/dist/helpers/getModifiedQuery.d.ts

@@ -0,0 +1,78 @@
+import React from 'react';
+import { FilterFieldType, MetricCardProps } from '@/components';
+import { ClientColumnType, GlobalFilterColumn, RlsCondition } from '@/types/app';
+export type DataMartRelationShip = {
+    join?: string | undefined;
+    childColumnName: string;
+    parentColumnName: string;
+    childTableName: string;
+    parentTableName: string;
+};
+type OnChangeGlobalFilterParams = {
+    value: any;
+    setAppliedFilters: React.Dispatch<React.SetStateAction<FilterFieldType[]>>;
+    column: GlobalFilterColumn;
+    operator: string;
+    type: string;
+};
+type GetSqlStatement = {
+    query: string;
+    clientId?: string;
+    rlsConditions: RlsCondition[];
+    globalFilters?: MetricCardProps['globalFilters'];
+    dbName: string;
+    tenancyLevel: string;
+    values?: Record<string, string>;
+    isAllClient?: boolean;
+    clientColumnType: ClientColumnType;
+    dataMartRelationships?: DataMartRelationShip[];
+};
+export type ReplaceVariable = {
+    query: string;
+    clientId?: string;
+    rlsConditions: RlsCondition[];
+    tenancyLevel: string;
+    values?: Record<string, string>;
+    isAllClient?: boolean;
+    globalFilters?: MetricCardProps['globalFilters'];
+    clientColumnType: ClientColumnType;
+};
+type ReplaceClientVariableParams = {
+    query: string;
+    clientId?: string | number | null;
+    tenancyLevel: string;
+    isAllClient?: boolean;
+    clientColumnType: ClientColumnType;
+};
+export declare const replaceClientVariable: ({ clientId, query, tenancyLevel, isAllClient, clientColumnType, }: ReplaceClientVariableParams) => string;
+export declare const replaceVariable: ({ query, rlsConditions, tenancyLevel, clientId, values, isAllClient, globalFilters, clientColumnType, }: ReplaceVariable) => string;
+export declare const nameSpace: (name: string, dbName: string) => string;
+export declare const nameSpaceSpecification: (parentAlias: string, columnName: string, dbName: string) => string;
+export declare const dateWhereClause: (condition: RlsCondition, dbName: string) => string;
+export declare const otherWhereClause: (condition: RlsCondition, dbName: string) => string;
+export declare const stringClause: (condition: RlsCondition, dbName: string) => string | undefined;
+export declare const replaceWhereClauses: (queryStr: string, groupedConditions: Record<string, RlsCondition[]>, dbName: string) => string;
+export declare const getModifiedQuery: ({ rlsConditions, dbName, query, }: {
+    rlsConditions: RlsCondition[];
+    dbName: string;
+    query: string;
+}) => string;
+export declare const getGroupedConditions: (rlsConditions: RlsCondition[], group: string) => RlsCondition[];
+export declare const getFilters: ({ rlsConditions, dbName, }: {
+    rlsConditions: RlsCondition[];
+    dbName: string;
+}) => string;
+export declare const getGlobalFilterCondition: ({ as, column, value, dbName, isCustomSql, operator, }: {
+    as: string;
+    value: any;
+    column: string;
+    isCustomSql?: boolean | undefined;
+    dbName: string;
+    operator: string;
+}) => string;
+export declare const getSqlStatement: ({ query, clientId, rlsConditions, globalFilters, dbName, tenancyLevel, values, isAllClient, clientColumnType, dataMartRelationships, }: GetSqlStatement) => string;
+export declare const isAppliedFilter: (filter: RlsCondition) => number | boolean | Date | undefined;
+export declare const onChangeGlobalFilter: ({ column, setAppliedFilters, value, operator, type, }: OnChangeGlobalFilterParams) => void;
+export declare const getColumnNameKeyString: (columnName: string, dbName: string) => string;
+export declare const getExecuteSqlResponseData: (data: any) => any;
+export {};

package/dist/helpers/getNextScheduledTime.d.ts

@@ -0,0 +1,13 @@
+interface ScheduleParams {
+    frequency: string;
+    weekDays: Record<string, boolean>;
+    date: {
+        value: string;
+        label: string;
+    }[];
+    hours: string;
+    time: string;
+    timezone: string;
+}
+declare const getNextScheduledTime: (params: ScheduleParams) => string;
+export default getNextScheduledTime;

package/dist/helpers/getTimeFilterValue.d.ts

@@ -0,0 +1,12 @@
+type Params = {
+    timeGrainValue: string;
+    isTimeStamp: boolean;
+    col: string;
+    database: string;
+};
+export declare const getTimeFilterValue: ({ timeGrainValue, isTimeStamp, col, database, }: Params) => string;
+export declare const handleTimeGrainValue: (label: string) => {
+    start: Date;
+    end: Date;
+} | undefined;
+export {};

package/dist/helpers/getValidRlsConditionOptions.d.ts

@@ -0,0 +1,16 @@
+import { MetricFilterOptionsType, RlsCondition } from '@/types';
+/**
+ * @name getValidRlsConditionOptions - Filters out invalid options and return valid options and value;
+ * @param {RlsCondition} rlsCondition (required) - A metric filter object.
+ * @param {MetricFilterOptionsType} filterOptions (required) - Metric filter options prop object.
+ * @returns value - A valid value or undefined.
+ * @returns options - A valid options or undefined.
+ * @returns 'undefined' - If not a valid props or options or value.
+ */
+export declare const getValidRlsConditionOptions: (rlsCondition: RlsCondition, filterOptions: MetricFilterOptionsType) => {
+    value: string | undefined;
+    options: string[] | number[] | {
+        value: string | number;
+        label: string;
+    }[] | import("@/types").DateTypeOptionType[];
+};

package/dist/helpers/groupArray.d.ts

@@ -0,0 +1 @@
+export declare const groupArray: <T extends Record<string, any>, K extends keyof T>(array: T[], key: K) => Record<T[K], T[]>;

package/dist/helpers/groupBy.d.ts

@@ -0,0 +1,25 @@
+import { ChartSettingsType, DrillDownSetting } from '@/types';
+export declare const groupByMultipleKeys: (rawData: any[] | undefined, keys: string[], measureKey: string) => any;
+export declare const groupMeasures: (rawData: any[] | undefined, dimensionKey: string, measureKeys: string[]) => any;
+export declare const updateGroupData: (data: any[] | undefined, keys: string[], selectedGroupBy: string[], setGroupedData: (value: React.SetStateAction<Record<string, any>[]>) => void) => void;
+export declare const updateDrilledData: (data: any[] | undefined, setGroupedData: (value: React.SetStateAction<Record<string, any>[]>) => void, measureKeys: string[], dimenstionKey: string) => void;
+export declare const findKeys: (arr: Record<string, any>[]) => {
+    numberKeys: string[];
+    stringKeys: string[];
+};
+export declare const indentifyKeys: (arr: Record<string, any>[]) => {
+    numberKeys: string[];
+    otherKeys: string[];
+};
+export declare const getEnabledChart: (data: any[]) => string[];
+export declare const autoDetectCharts: ({ data, setChartSettings, }: {
+    setChartSettings: React.Dispatch<React.SetStateAction<ChartSettingsType>>;
+    data: any[];
+}) => void;
+export declare const defaultChartProperties: ({ chartType, data, setChartSettings, groupbyList, }: {
+    data: any[];
+    chartType: string;
+    setChartSettings: React.Dispatch<React.SetStateAction<ChartSettingsType>>;
+    groupbyList: any[];
+}) => void;
+export declare const drilldown: (chartParams: any, drillDownSettings: DrillDownSetting | undefined, data: any[] | undefined, setDrilledLevel: React.Dispatch<React.SetStateAction<number>>, drilledLevel: number, setShowChartPopup: React.Dispatch<React.SetStateAction<boolean>>, setGroupedData: React.Dispatch<React.SetStateAction<Record<string, any>[]>>) => void;

package/dist/helpers/index.d.ts

@@ -0,0 +1,16 @@
+export * from './getModifiedQuery';
+export * from './getTimeFilterValue';
+export * from './groupArray';
+export * from './groupBy';
+export * from './getValidRlsConditionOptions';
+export * from './timeseries';
+export * from './checkIsElementInViewport';
+export * from './areArraysEqual';
+export * from './generateTimeRangeWhereClause';
+export * from './getColumnType';
+export * from './createMetric';
+export * from './timeseriesOption';
+export * from './chartOptions';
+export * from './autoCompleteHelpers';
+export * from './sqlMetadata';
+export * from './copyToClipboard';

package/dist/helpers/numberFormatter.d.ts

@@ -0,0 +1 @@
+export declare const numberFormatter: (val: any, formatter: any) => any;

package/dist/helpers/setOnDateChange.d.ts

@@ -0,0 +1,11 @@
+export declare const setOnDateChange: (start: Date | null | undefined, end: Date | null | undefined, timeGrain?: string) => {
+    value: string;
+    startDate: Date;
+    endDate: Date;
+    timeGrainValue: string;
+} | {
+    value?: undefined;
+    startDate?: undefined;
+    endDate?: undefined;
+    timeGrainValue?: undefined;
+};

package/dist/helpers/sqlMetadata.d.ts

@@ -0,0 +1,7 @@
+export declare const getOrderedByColumns: (query: string, databaseName: string) => any;
+export declare const getColumnList: (sqlQuery: string, databaseName: string) => string[];
+export declare const isColumnExistsInSql: ({ columnName, databaseName, sql, }: {
+    columnName: string;
+    sql: string;
+    databaseName: string;
+}) => boolean;

package/dist/helpers/timeseries.d.ts

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