@vizzly/services 0.15.0-dev-a9cfd8f38d3df28a319ca965d6e9d29e227fe3fe → 0.15.0-dev-89f22e757a24a3586c300b3ebb6b29827e8cc0e8

package/dist/types/shared-logic/src/BubbleChart/getScaleAndTicks.d.ts

@@ -0,0 +1,42 @@
+import { KeyId, GoalLine } from './types';
+import { QueryAttributes } from '../QueryAttributes/types';
+import { DataType } from '../Field/types';
+import { FormattedResult } from '../Result/types';
+import { Tick } from '../ChartsV2/types';
+type FormattingFunction = (value: any, nullValueAlias?: string) => string;
+interface getScaleAndTicksArgs {
+    data: FormattedResult['contentMapped'];
+    xKey: string | null;
+    xScaleDataType: DataType;
+    yKeys: string[];
+    nullValue: string | undefined;
+    tickCountYAxis: number;
+    formattingFunctionX: FormattingFunction;
+    formattingFunctionY: FormattingFunction;
+    order: QueryAttributes.Order[];
+    goalLines: GoalLine[];
+}
+interface getScaleAndTicksReturn {
+    x: {
+        ticks: Array<Tick<Date | string | number>>;
+        scale: {
+            max: number | Date | null;
+            min: number | Date | null;
+            key: KeyId | null;
+            ordering: 'asc' | 'desc' | null;
+            dataType: DataType;
+        };
+    };
+    y: {
+        ticks: Array<Tick<number>>;
+        scale: {
+            max: number;
+            min: number;
+            key: null;
+            ordering: 'asc' | 'desc';
+            dataType: 'number';
+        };
+    };
+}
+export declare const getScaleAndTicks: ({ data, xKey, yKeys, xScaleDataType, nullValue, tickCountYAxis, formattingFunctionX, formattingFunctionY, order, goalLines, }: getScaleAndTicksArgs) => getScaleAndTicksReturn;
+export {};

package/dist/types/shared-logic/src/BubbleChart/getStyleDefinition.d.ts

@@ -0,0 +1,8 @@
+import { CSSProperties } from 'react';
+import { LegendItem } from './types';
+interface getStyleDefinitionArgs {
+    colors: CSSProperties['color'][];
+    yKeys: string[];
+}
+export declare const getStyleDefinition: ({ colors, yKeys }: getStyleDefinitionArgs) => LegendItem[];
+export {};

package/dist/types/shared-logic/src/BubbleChart/index.d.ts

@@ -0,0 +1,4 @@
+import { Component } from '../Component/types';
+import { LoadComponentInterface } from '../ComponentInterface/types';
+declare const BubbleChart: LoadComponentInterface<Component.BubbleChartAttributes, Component.BubbleChartAttributes>;
+export default BubbleChart;

package/dist/types/shared-logic/src/BubbleChart/setAttributes.d.ts

@@ -0,0 +1,4 @@
+import { Component } from '../Component/types';
+import { ComponentInterfaceConfig } from '../ComponentInterface/types';
+declare const _default: (config: ComponentInterfaceConfig) => (bubbleChart: Component.BubbleChartAttributes, partial: Partial<Component.BubbleChartAttributes>) => Component.BubbleChartAttributes;
+export default _default;

package/dist/types/shared-logic/src/BubbleChart/types.d.ts

@@ -0,0 +1,86 @@
+import { Tick } from '../ChartsV2/types';
+import { DataType } from '../Field/types';
+export type KeyId = string;
+export type Operator = string;
+export type ConditionalFormattingRule = {
+    operator: Operator;
+    value: any;
+    color: string;
+    yKey: KeyId;
+};
+export type Axis<SupportedVizzlyDataTypes, AxisKeys> = {
+    ticks: Tick<SupportedVizzlyDataTypes>[];
+    scale: {
+        dataType: DataType;
+        key: KeyId | null;
+        ordering: 'asc' | 'desc' | null;
+        min: SupportedVizzlyDataTypes | null;
+        max: SupportedVizzlyDataTypes | null;
+    };
+    postfix: string;
+    prefix: string;
+    title: string | null;
+} & AxisKeys;
+export type LegendItemStyleLine = {
+    type: 'line';
+    strokeDasharray: string | number | null;
+    strokeWidth: number;
+};
+export type LegendItem = {
+    yKey: KeyId;
+    color: string;
+    style: LegendItemStyleLine;
+};
+export type Key = {
+    key: KeyId;
+    keyFormatted: string;
+    dataType: DataType;
+};
+export type BubbleChartRepresentation = {
+    keys: {
+        [key: KeyId]: Key;
+    };
+    x: Axis<Date | string | number, {
+        key: KeyId;
+    }>;
+    y: Axis<number, {
+        keys: KeyId[];
+    }>;
+    z: string;
+    conditionalFormattingRules: ConditionalFormattingRule[];
+    goalLines: GoalLine[];
+    data: {
+        [keyId: string]: DataItem;
+    }[];
+    lines: LegendItem[];
+    groupByKey: string;
+    legend: {
+        keys: {
+            [keyId: string]: Key;
+        };
+        items: LegendItem[];
+    };
+};
+export type DataItem = {
+    value: number | string | null;
+    formattedValue: string | null;
+};
+export type GoalLine = {
+    value: number;
+    formattedValue: string | null;
+    color: string;
+    strokeStyle?: 'dashed' | 'solid';
+    strokeWidth: number;
+};
+export type DateTimeFormatter = {
+    formatter: (date: Date) => string;
+    description: string;
+};
+export type NumberFormatter = {
+    formatter: (number: number | undefined | null, noValueReplacement?: string) => string;
+    description: string;
+};
+export type BubbleStyles = {
+    type: 'bubble';
+    bubbleSize: number;
+};

package/dist/types/shared-logic/src/BubbleChartV2/attributesSchema.d.ts

@@ -0,0 +1,3 @@
+import Joi from '@vizzly/joi';
+import { ComponentInterfaceConfig } from '../ComponentInterface/types';
+export declare const attributesSchema: (config: ComponentInterfaceConfig) => Joi.ObjectSchema<any>;

package/dist/types/shared-logic/src/BubbleChartV2/buildBubbleChartRepresentation.d.ts

@@ -0,0 +1,38 @@
+import { CSSProperties } from 'react';
+import { BubbleChartRepresentation, DateTimeFormatter, NumberFormatter } from './types';
+import { ValueAlias } from '../ValueAlias/types';
+import { Result } from '../Result/types';
+import { PivotConfig } from '../PivotConfig/types';
+import { QueryAttributes } from '../QueryAttributes/types';
+import { ApproxAxisLabelCount, Component, FormatType } from '../Component/types';
+interface buildBubbleChartRepresentationArgs {
+    axisTitles?: Component.AxisTitles;
+    colors: CSSProperties['color'][];
+    conditionalFormattingAttributes: Component.ConditionalFormatting.Rule[];
+    dateTimeFormatOptions: {
+        [id: string]: DateTimeFormatter;
+    };
+    defaultFormats: () => {
+        [functionId: string]: string;
+    };
+    goalLineAttributes: Component.GoalLine.Rule[];
+    nullValue?: string;
+    numberFormatOptions: {
+        [id: string]: NumberFormatter;
+    };
+    order: QueryAttributes.Order[];
+    pivotConfig: PivotConfig;
+    result: Result;
+    valueAlias?: ValueAlias;
+    xAxisFormat: FormatType;
+    xAxisPostfix: string;
+    xAxisPrefix: string;
+    yAxisFormat: FormatType;
+    yAxisPostfix: string;
+    yAxisPrefix: string;
+    approxYAxisLabelCount: ApproxAxisLabelCount;
+    zFieldId: string;
+    quadrantsAttributes?: Component.Quadrant.Rule;
+}
+export declare const buildBubbleChartRepresentation: ({ axisTitles, colors, conditionalFormattingAttributes, dateTimeFormatOptions, defaultFormats, goalLineAttributes, nullValue, numberFormatOptions, order, pivotConfig, result, xAxisFormat, xAxisPostfix, xAxisPrefix, yAxisFormat, yAxisPostfix, yAxisPrefix, approxYAxisLabelCount, valueAlias, zFieldId, quadrantsAttributes, }: buildBubbleChartRepresentationArgs) => BubbleChartRepresentation;
+export {};

package/dist/types/shared-logic/src/BubbleChartV2/buildTrendAndForecast.d.ts

@@ -0,0 +1,25 @@
+import { DataItem, KeyId } from '../BubbleChart/types';
+export type AcceptedTrendTimeUnit = 'week' | 'quarter' | 'year' | 'month';
+interface getTrendArgs {
+    data: Array<{
+        [key: KeyId]: DataItem;
+    }>;
+    forecastUnits: number;
+    xKey: string;
+    yKey: string;
+    timeUnit: AcceptedTrendTimeUnit;
+    includeForecast: boolean;
+}
+export declare const buildTrendAndForecast: ({ data, forecastUnits, xKey, yKey, timeUnit, includeForecast }: getTrendArgs) => {
+    trendData: {
+        date: string;
+        value: number;
+    }[];
+    trendKey: string;
+    forecastData: {
+        date: string;
+        value: number;
+    }[];
+    forecastKey: string;
+};
+export {};

package/dist/types/shared-logic/src/BubbleChartV2/constants.d.ts

@@ -0,0 +1,3 @@
+import { ViewConstants } from '../ComponentInterface/types/namespaces.types';
+declare const CONSTANTS: ViewConstants;
+export default CONSTANTS;

package/dist/types/shared-logic/src/BubbleChartV2/getConditionalFormatting.d.ts

@@ -0,0 +1,7 @@
+import { ConditionalFormattingRule } from './types';
+import { Component } from '../Component/types';
+interface getConditionalFormattingArgs {
+    conditionalFormattingAttributes: Component.ConditionalFormatting.Rule[];
+}
+export declare const getConditionalFormatting: ({ conditionalFormattingAttributes, }: getConditionalFormattingArgs) => ConditionalFormattingRule[];
+export {};

package/dist/types/shared-logic/src/BubbleChartV2/getGoalLines.d.ts

@@ -0,0 +1,8 @@
+import { GoalLine } from './types';
+import { Component } from '../Component/types';
+interface getGoalLinesArgs {
+    goalLineAttributes: Component.GoalLine.Rule[];
+    formattingFunctionY: (value: any) => string;
+}
+export declare const getGoalLines: ({ goalLineAttributes, formattingFunctionY }: getGoalLinesArgs) => GoalLine[];
+export {};

package/dist/types/shared-logic/src/BubbleChartV2/getMinAndMax.d.ts

@@ -0,0 +1,15 @@
+import { DataType } from '../Field/types';
+import { FormattedResult } from '../Result/types';
+import { GoalLine } from './types';
+export declare const getMinAndMax: ({ data, keys, dataType, goalLines, }: {
+    data: FormattedResult["contentMapped"];
+    keys: Array<string>;
+    dataType: DataType;
+    goalLines?: GoalLine[];
+}) => {
+    max: null;
+    min: null;
+} | {
+    max: number;
+    min: number;
+};

package/dist/types/shared-logic/src/BubbleChartV2/getScaleAndTicks.d.ts

@@ -0,0 +1,43 @@
+import { KeyId, GoalLine } from './types';
+import { QueryAttributes } from '../QueryAttributes/types';
+import { DataType } from '../Field/types';
+import { FormattedResult } from '../Result/types';
+import { Tick } from '../ChartsV2/types';
+import { ApproxAxisLabelCount } from '../../../shared-logic/src/Component/types';
+type FormattingFunction = (value: any, nullValueAlias?: string) => string;
+interface getScaleAndTicksArgs {
+    data: FormattedResult['contentMapped'];
+    xKey: string | null;
+    xScaleDataType: DataType;
+    yKeys: string[];
+    nullValue: string | undefined;
+    approxYAxisLabelCount: ApproxAxisLabelCount;
+    formattingFunctionX: FormattingFunction;
+    formattingFunctionY: FormattingFunction;
+    order: QueryAttributes.Order[];
+    goalLines: GoalLine[];
+}
+interface getScaleAndTicksReturn {
+    x: {
+        ticks: Array<Tick<Date | string | number>>;
+        scale: {
+            max: number | Date | null;
+            min: number | Date | null;
+            key: KeyId | null;
+            ordering: 'asc' | 'desc' | null;
+            dataType: DataType;
+        };
+    };
+    y: {
+        ticks: Array<Tick<number>>;
+        scale: {
+            max: number;
+            min: number;
+            key: string | null;
+            ordering: 'asc' | 'desc';
+            dataType: 'number';
+        };
+    };
+}
+export declare const getScaleAndTicks: ({ data, xKey, yKeys, xScaleDataType, nullValue, approxYAxisLabelCount, formattingFunctionX, formattingFunctionY, order, goalLines, }: getScaleAndTicksArgs) => getScaleAndTicksReturn;
+export {};

package/dist/types/shared-logic/src/BubbleChartV2/getStyleDefinition.d.ts

@@ -0,0 +1,8 @@
+import { CSSProperties } from 'react';
+import { LegendItem } from './types';
+interface getStyleDefinitionArgs {
+    colors: CSSProperties['color'][];
+    yKeys: string[];
+}
+export declare const getStyleDefinition: ({ colors, yKeys }: getStyleDefinitionArgs) => LegendItem[];
+export {};

package/dist/types/shared-logic/src/BubbleChartV2/getTrendsAndForecastsData.d.ts

@@ -0,0 +1,41 @@
+import { DataItem, KeyId, Key } from '../BubbleChart/types';
+import { Component } from '../Component/types';
+import { DataType } from '../Field/types';
+interface getTrendsAndForecastsDataArgs {
+    chartData: {
+        [keyId: string]: DataItem;
+    }[];
+    keys: {
+        [keyId: string]: Key;
+    };
+    xKey: KeyId;
+    yKeys: KeyId[];
+    formattingFunctionX: (value: any, noValueReplacement?: string) => string;
+    formattingFunctionY: (value: any, noValueReplacement?: string) => string;
+    nullValue: string | undefined;
+    trendsAndForecasts?: Component.Trends[];
+    xAxisPostfix: string;
+    xAxisPrefix: string;
+    yAxisPostfix: string;
+    yAxisPrefix: string;
+    xScaleDataType: DataType;
+    orderFunction: string | undefined;
+}
+export declare const getTrendsAndForecastsData: ({ chartData, formattingFunctionX, formattingFunctionY, keys, nullValue, orderFunction, trendsAndForecasts, xAxisPostfix, xAxisPrefix, xKey, xScaleDataType, yAxisPostfix, yAxisPrefix, yKeys, }: getTrendsAndForecastsDataArgs) => {
+    chartData: {
+        [keyId: string]: DataItem;
+    }[];
+    newChartData?: undefined;
+    newYKeys?: undefined;
+    newKeys?: undefined;
+} | {
+    newChartData: ({
+        [x: string]: DataItem;
+    } | null)[];
+    newYKeys: string[];
+    newKeys: {
+        [keyId: string]: Key;
+    };
+    chartData?: undefined;
+};
+export {};

package/dist/types/shared-logic/src/BubbleChartV2/index.d.ts

@@ -0,0 +1,4 @@
+import { Component } from '../Component/types';
+import { LoadComponentInterface } from '../ComponentInterface/types';
+declare const BubbleChartV2: LoadComponentInterface<Component.BubbleChartV2Attributes, Component.BubbleChartV2Attributes>;
+export default BubbleChartV2;

package/dist/types/shared-logic/src/BubbleChartV2/setAttributes.d.ts

@@ -0,0 +1,4 @@
+import { Component } from '../Component/types';
+import { ComponentInterfaceConfig } from '../ComponentInterface/types';
+declare const _default: (config: ComponentInterfaceConfig) => (bubbleChart: Component.BubbleChartV2Attributes, partial: Partial<Component.BubbleChartV2Attributes>) => Component.BubbleChartV2Attributes;
+export default _default;

package/dist/types/shared-logic/src/BubbleChartV2/types.d.ts

@@ -0,0 +1,89 @@
+import { Component } from '../../../shared-logic/src/Component/types';
+import { Tick } from '../ChartsV2/types';
+import { DataType } from '../Field/types';
+export type KeyId = string;
+export type Operator = string;
+export type ConditionalFormattingRule = {
+    operator: Operator;
+    value: any;
+    color: string;
+    yKey: KeyId;
+};
+export type Axis<SupportedVizzlyDataTypes, AxisKeys> = {
+    ticks: Tick<SupportedVizzlyDataTypes>[];
+    scale: {
+        dataType: DataType;
+        key: KeyId | null;
+        ordering: 'asc' | 'desc' | null;
+        min: SupportedVizzlyDataTypes | null;
+        max: SupportedVizzlyDataTypes | null;
+    };
+    postfix: string;
+    prefix: string;
+    title: string | null;
+} & AxisKeys;
+export type LegendItemStyleLine = {
+    type: 'line';
+    strokeDasharray: string | number | null;
+    strokeWidth: number;
+};
+export type LegendItem = {
+    yKey: KeyId;
+    color: string;
+    style: LegendItemStyleLine;
+};
+export type Key = {
+    key: KeyId;
+    keyFormatted: string;
+    dataType: DataType;
+};
+export type Legend = {
+    keys: {
+        [key: KeyId]: Key;
+    };
+    items: LegendItem[];
+};
+export type BubbleChartRepresentation = {
+    keys: {
+        [key: KeyId]: Key;
+    };
+    x: Axis<Date | string | number, {
+        key: KeyId;
+    }>;
+    y: Axis<number, {
+        keys: KeyId[];
+    }>;
+    z: string;
+    quadrants: Component.Quadrant.Rule;
+    conditionalFormattingRules: ConditionalFormattingRule[];
+    goalLines: GoalLine[];
+    data: {
+        [keyId: string]: DataItem;
+    }[];
+    lines: LegendItem[];
+    groupByKey: string;
+    legend: Legend;
+};
+export type DataItem = {
+    value: number | string | null;
+    formattedValue: string | null;
+};
+export type GoalLine = {
+    value: number;
+    formattedValue: string | null;
+    color: string;
+    strokeStyle?: 'dashed' | 'solid';
+    strokeWidth: number;
+};
+export type DateTimeFormatter = {
+    formatter: (date: Date) => string;
+    description: string;
+};
+export type NumberFormatter = {
+    formatter: (number: number | undefined | null, noValueReplacement?: string) => string;
+    description: string;
+};
+export type BubbleStyles = {
+    type: 'bubble';
+    bubbleSize: number;
+};

package/dist/types/shared-logic/src/Callbacks/cell.funcs.d.ts

@@ -0,0 +1,72 @@
+import { Component } from '../Component/types';
+import { QueryAttributes } from '../QueryAttributes/types';
+import * as Field from '../Field';
+import { Result } from '../Result/types';
+import { SupportedAggregates } from '../Aggregate/types';
+import { TableContent, TableFields, TableFieldsV2 } from '../DataTable/types';
+import * as Drilldown from '../Drilldown/Drilldown';
+import { DataSet } from '../DataSet/types';
+export type BuildViewClick = {
+    onViewClick: (data: Component.ChartOnViewClick, query: Component.OnViewClickQuery) => void;
+    dimension: QueryAttributes.Dimension[] | undefined;
+    measure: QueryAttributes.Measure[] | undefined;
+    viewId: string;
+    type: 'barChart' | 'horizontalBarChart';
+    timeDimension: QueryAttributes.TimeDimension | null;
+    dataSet: DataSet;
+};
+export type runViewClickQueryType = (queries: Partial<QueryAttributes>, existingField: Drilldown.DrilldownField[]) => Promise<any | null>;
+export declare function buildOnViewClick(clickedValue: Datum | undefined, nearestDatum: DatumByKey | undefined, params: BuildViewClick, runViewClickQuery: runViewClickQueryType): void;
+export type BuildTableViewClick = {
+    viewId: string;
+    supportedAggregates: SupportedAggregates;
+    result: Result | null | undefined;
+    onViewClick: ((data: Component.TableOnViewClick) => void) | undefined;
+    type: 'dataTable' | 'basicTable';
+    dimension: QueryAttributes.Dimension[];
+    dataSet: DataSet;
+};
+export type TableOnViewClick = (rowIndex: number, cellIndex: number, value: string | number, fieldV2?: TableFieldsV2[], additionalAttributes?: AddtionalOnClickAttributes) => void;
+export type TableCellRender = (rowIndex: number, cellIndex: number, value: string | number, fieldV2?: TableFieldsV2[], additionalAttributes?: AddtionalOnClickAttributes) => React.ReactNode | string;
+export type AddtionalOnClickAttributes = {
+    grouping?: Component.ReturnedField[];
+    value?: Component.ReturnedField;
+};
+export declare function buildTableOnViewClick(params: BuildTableViewClick, cellIndex: number, rowIndex: number, value: string | number, fieldsV2?: TableFieldsV2[], additionalAttributes?: AddtionalOnClickAttributes): void;
+export declare function buildFieldsV2(fields: TableFields[], functionsToCheck: Field.DecodingFunctionsToCheck, row: TableContent[], subsetFields?: TableFields[], drilldown?: Component.TableDrilldown): TableFieldsV2[];
+export declare const transformToObject: (dataObjects: Result.Field[], valuesArray: number[]) => {
+    [key: string]: number;
+};
+export declare const hasProtectedFields: (protectedFields?: Component.ProtectedFields) => boolean;
+export type Datum = {
+    [key: string]: any;
+};
+export type DatumByKey = Record<Datum['key'], Datum>;
+export type BuildTableCellRender = {
+    viewId: string;
+    supportedAggregates: SupportedAggregates;
+    result: Result | null | undefined;
+    renderTableCell: ((data: Component.RenderTableCell) => void) | undefined;
+    type: 'dataTable' | 'basicTable';
+    dimension: QueryAttributes.Dimension[];
+    protectedFields?: Component.ProtectedFields;
+};
+export declare const buildTableCell: (props: BuildTableCellRender, cellIndex: number, rowIndex: number, value: string | number, fields?: TableFieldsV2[], additionalAttributes?: AddtionalOnClickAttributes) => React.ReactNode | string;
+export declare function getCellAttributes(result: Result, rowIndex: number, cellIndex: number, type: string, value: string | number, dimension: QueryAttributes.Dimension[], additionalAttributes: AddtionalOnClickAttributes | undefined, supportedAggregates: SupportedAggregates): {
+    activeFieldsWithValues: {
+        [key: string]: number;
+    };
+    cell: {
+        grouping: Component.ReturnedField[];
+        value: Component.ReturnedField;
+        fieldId?: undefined;
+        function?: undefined;
+        aggregate?: undefined;
+    } | {
+        fieldId: string;
+        value: string | number;
+        function: string;
+        aggregate: string;
+        grouping?: undefined;
+    };
+};

package/dist/types/shared-logic/src/Callbacks/index.d.ts

@@ -0,0 +1 @@
+export * from './cell.funcs';

package/dist/types/shared-logic/src/Callbacks/labelFormat.d.ts

@@ -0,0 +1,3 @@
+import { Component } from '../Component/types';
+export declare function validateLabelFormat(labelFormatFunc?: (options: Component.LabelFormatOptions) => string | undefined): (options: Component.LabelFormatOptions) => string | undefined;
+export declare const prepareLabelFormatValues: (dimensionKeys?: string[] | undefined, dimensionValues?: (string | number | string[] | null)[] | undefined) => Component.LabelFormatOptionsValues;

package/dist/types/shared-logic/src/Callbacks/onViewClickGrouping.d.ts

@@ -0,0 +1,6 @@
+import { Component } from '../Component/types';
+import { QueryAttributes } from '../QueryAttributes/types';
+import { AddtionalOnClickAttributes } from './cell.funcs';
+export declare function buildGrouping(dimension: QueryAttributes.Dimension[], activeFieldsWithValues: {
+    [key: string]: number;
+}, additionalAttributes: AddtionalOnClickAttributes | undefined): Component.ReturnedField[];

package/dist/types/shared-logic/src/Callbacks/types.d.ts

@@ -0,0 +1,18 @@
+import { SaveableDashboardDefinition } from '../Dashboard/types';
+import { DataSet } from '../DataSet/types';
+import { IdentityConfig } from '../IdentityConfig/types';
+import { DataMap } from '../JSQueryEngine/types';
+import { QueryEngineConfig } from '../QueryEngineConfig/types';
+type CallbackError = null;
+export type programmaticDashboardCallback = (dataSets: DataSet[]) => Promise<Array<Partial<SaveableDashboardDefinition>>>;
+export type loadDataSetsCallback<Ds = DataSet<DataSet.PreUpcastField>> = (identityConfig: IdentityConfig, queryEngineConfig: QueryEngineConfig) => Promise<Array<Ds>>;
+export type IdentityTokens = {
+    dashboardAccessToken: string;
+    dataAccessToken?: string;
+    queryEngineAccessToken?: string;
+    projectAccessToken?: string | undefined;
+};
+export type identityCallback = () => Promise<IdentityTokens | CallbackError>;
+export type loadQueryEngineConfigCallback = () => Promise<Omit<QueryEngineConfig, 'supportedTransformationFunctions'> | null>;
+export type loadDataCallback = (dataSet: DataSet) => Promise<DataMap[] | CallbackError>;
+export {};

package/dist/types/shared-logic/src/ChartsV2/adjustTicks.d.ts

@@ -0,0 +1,12 @@
+import { HorizontalBarChartRepresentation } from '../HorizontalBarChartV2/types';
+import { Result } from '../Result/types';
+import { BaseChartRepresentation, Tick } from './types';
+export declare const ASSUMED_AVERAGE_CHAR_WIDTH = 7.1;
+export declare const ASSUMED_AVERAGE_CHAR_HEIGHT = 24;
+export declare function howManyTicksFitInWidth(ticks: Tick<string | number | Date>[], maxWidth: number, avgCharWidth?: number): number;
+export declare function howManyTicksFitInHeight(ticks: Tick<string | number | Date>[], maxHeight: number, avgCharHeight?: number): number;
+export declare function determineYTicks(ticks: Tick<number>[], height: number): Tick<number>[];
+export declare function pickEquallySpaced<T>(arr: Tick<T>[], numPicks: number): Tick<T>[];
+export declare function adjustTicks<T extends BaseChartRepresentation>(representation: T, width: number, height: number, xKeyField?: Result.Field): T;
+export declare function adjustTicksForHorizontalChart(representation: HorizontalBarChartRepresentation, width: number, height: number, yKeyField?: Result.Field): HorizontalBarChartRepresentation;
+export declare function getEvenlySpacedTicks<DataType extends string | number | Date>(ticks: Tick<DataType>[], count: number, xKeyField: Result.Field | undefined): Tick<DataType>[];

package/dist/types/shared-logic/src/ChartsV2/buildFieldFormatMaps.d.ts

@@ -0,0 +1,12 @@
+import { FormatType } from '../Component/types';
+import { PivotConfig } from '../PivotConfig/types';
+import { Result } from '../Result/types';
+import { NumberFormatter } from './types';
+export declare function buildFieldFormatMaps(result: Result, pivotConfig: PivotConfig, xAxisPrefix: string, xAxisPostfix: string, xAxisFormat: FormatType, yAxisPrefix: string, yAxisPostfix: string, yAxisFormat: FormatType, nullValue: string | undefined, numberFormatOptions: {
+    [id: string]: NumberFormatter;
+}): {
+    allPrefixes: Record<string, string>;
+    allPostfixes: Record<string, string>;
+    nullValues: Record<string, string | undefined>;
+    activeNumberFormats: Record<string, string>;
+};

package/dist/types/shared-logic/src/ChartsV2/buildTrendAndForecast.d.ts

@@ -0,0 +1,25 @@
+import { DataItem, KeyId } from './types';
+export type AcceptedTrendTimeUnit = 'week' | 'quarter' | 'year' | 'month';
+interface getTrendArgs {
+    data: Array<{
+        [key: KeyId]: DataItem;
+    }>;
+    forecastUnits: number;
+    xKey: string;
+    yKey: string;
+    timeUnit: AcceptedTrendTimeUnit;
+    includeForecast: boolean;
+}
+export declare const buildTrendAndForecast: ({ data, forecastUnits, xKey, yKey, timeUnit, includeForecast }: getTrendArgs) => {
+    trendData: {
+        date: string;
+        value: number;
+    }[];
+    trendKey: string;
+    forecastData: {
+        date: string;
+        value: number;
+    }[];
+    forecastKey: string;
+};
+export {};

package/dist/types/shared-logic/src/ChartsV2/convertToStackedPercentages.d.ts

@@ -0,0 +1 @@
+export declare function convertToStackedPercentages(data: Record<string, any>[], yKeys: string[], xKey: string | null): Record<string, any>[];

package/dist/types/shared-logic/src/ChartsV2/fillMissingKeysForChartData.d.ts

@@ -0,0 +1,4 @@
+import { FormattedChartData } from '../Result/types';
+type DataRecord = Record<string, FormattedChartData>;
+export declare function fillMissingKeysForChartData(data: DataRecord[]): DataRecord[];
+export {};

package/dist/types/shared-logic/src/ChartsV2/formattingFunctionAxis.d.ts

@@ -0,0 +1,2 @@
+import { FormattedResult, Result } from '../Result/types';
+export declare const formattingFunctionX: (value: any, formattedResult: FormattedResult, xKeyField?: Result.Field) => string;

package/dist/types/shared-logic/src/ChartsV2/getConditionalFormatting.d.ts

@@ -0,0 +1,7 @@
+import { ConditionalFormattingRule } from '../ChartsV2/types';
+import { Component } from '../Component/types';
+interface getConditionalFormattingArgs {
+    conditionalFormattingAttributes: Component.ConditionalFormatting.Rule[];
+}
+export declare const getConditionalFormatting: ({ conditionalFormattingAttributes, }: getConditionalFormattingArgs) => ConditionalFormattingRule[];
+export {};

package/dist/types/shared-logic/src/ChartsV2/getGoalLines.d.ts

@@ -0,0 +1,8 @@
+import { GoalLine } from '../ChartsV2/types';
+import { Component } from '../Component/types';
+interface getGoalLinesArgs {
+    goalLineAttributes: Component.GoalLine.Rule[];
+    formattingFunctionY: (value: any) => string;
+}
+export declare const getGoalLines: ({ goalLineAttributes, formattingFunctionY }: getGoalLinesArgs) => GoalLine[];
+export {};