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

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

@@ -0,0 +1,25 @@
+import { Tick } from './types';
+type FormattingFunction = (value: any, nullValueAlias?: string) => string;
+export declare const DEFAULT_TICK_COUNT = 10;
+interface getMetricAxisTickValuesArgs {
+    min: number;
+    max: number;
+    interval: number;
+    stacked: boolean;
+}
+interface getMetricAxisTicksArgs {
+    min: number | null;
+    max: number | null;
+    tickCount: number;
+    nullValue: string | undefined;
+    formattingFunction: FormattingFunction;
+    stacked: boolean;
+}
+interface getMetricAxisTicksReturn {
+    ticks: Array<Tick<number>>;
+    minTickValue: number;
+    maxTickValue: number;
+}
+export declare const getMetricAxisTickValues: ({ min, max, interval, stacked }: getMetricAxisTickValuesArgs) => number[];
+export declare const getMetricAxisTicks: ({ min, max, tickCount, nullValue, formattingFunction, stacked, }: getMetricAxisTicksArgs) => getMetricAxisTicksReturn;
+export {};

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

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

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

@@ -0,0 +1,2 @@
+import { Tick } from '../ChartsV2/types';
+export declare function getStackedPercentageAxisTicks(convertedStackedPercentageData: Record<string, any>[], yKeys: string[], xKey: string | null): Tick<number>[];

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

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

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

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

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

@@ -0,0 +1,42 @@
+import { GoalLine, KeyId, Tick } from '../ChartsV2/types';
+import { DataType } from '../Field/types';
+import { QueryAttributes } from '../QueryAttributes/types';
+import { FormattedResult } from '../Result/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[];
+    stacked?: boolean;
+}
+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, stacked, }: getScaleAndTicksArgs) => getScaleAndTicksReturn;
+export {};

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

@@ -0,0 +1,9 @@
+import { CSSProperties } from 'react';
+import { ShapeDefinition } from './types';
+interface getStyleDefinitionArgs<T> {
+    colors: CSSProperties['color'][];
+    yKeys: string[];
+    style: T;
+}
+export declare function getStyleDefinition<T>({ colors, yKeys, style }: getStyleDefinitionArgs<T>): ShapeDefinition<T>[];
+export {};

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

@@ -0,0 +1,41 @@
+import { Component } from '../Component/types';
+import { DataType } from '../Field/types';
+import { DataItem, Key, KeyId } from './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/ChartsV2/getXKeyField.d.ts

@@ -0,0 +1,3 @@
+import { PivotConfig } from '../PivotConfig/types';
+import { Result } from '../Result/types';
+export declare function getXKeyField(pivotConfig: PivotConfig, fields: Result.Field[]): Result.Field | undefined;

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

@@ -0,0 +1,97 @@
+import { DataType } from '../Field/types';
+export type Scale<SupportedVizzlyDataTypes> = {
+    dataType: DataType;
+    key: KeyId | null;
+    ordering: 'asc' | 'desc' | null;
+    min: SupportedVizzlyDataTypes | null;
+    max: SupportedVizzlyDataTypes | null;
+};
+export type Axis<SupportedVizzlyDataTypes, AxisKeys> = {
+    ticks: Tick<SupportedVizzlyDataTypes>[];
+    scale: Scale<SupportedVizzlyDataTypes>;
+    postfix: string;
+    prefix: string;
+    title: string | null;
+} & AxisKeys;
+export type Tick<DataType> = {
+    value: DataType;
+    formattedValue: string | null;
+    scaleValue: DataType | null;
+    key?: string;
+};
+export type ChartOnViewClick = {
+    clickedValue: {
+        index: number;
+        y: {
+            key: string;
+            value: number;
+        };
+        x: Tick<string | number | Date>;
+    };
+    clickEvent: {
+        clientY: number;
+        nativeEvent: {
+            clientX: number;
+            clientY: number;
+        };
+    };
+};
+export type KeyId = string;
+export type Operator = string;
+export type ConditionalFormattingRule = {
+    operator: Operator;
+    value: any;
+    color: string;
+    yKey: KeyId;
+};
+export type GoalLine = {
+    value: number;
+    formattedValue: string | null;
+    color: string;
+    strokeStyle?: 'dashed' | 'solid';
+    strokeWidth: number;
+};
+export type DataItem = {
+    value: number | string | null;
+    formattedValue: string | null;
+    originalValue?: number | string | null;
+    displayValue?: 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 Key = {
+    key: KeyId;
+    keyFormatted: string;
+    dataType: DataType;
+};
+export type ShapeDefinition<T> = {
+    yKey: KeyId;
+    color: string;
+    style: T;
+};
+export type BaseXAxis = Axis<Date | string | number, {
+    key: KeyId;
+}>;
+export type BaseYAxis = Axis<number, {
+    keys: KeyId[];
+}>;
+export type Datum = {
+    [keyId: string]: DataItem;
+};
+export type BaseChartRepresentation = {
+    keys: {
+        [key: KeyId]: Key;
+    };
+    x: BaseXAxis;
+    y: BaseYAxis;
+    data: Datum[];
+};
+export type ChartDataDefinition = {
+    [keyId: string]: DataItem;
+};

package/dist/types/shared-logic/src/ComboChart/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/ComboChart/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/ComboChart/index.d.ts

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

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

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

package/dist/types/shared-logic/src/ComboChart/upcast.d.ts

@@ -0,0 +1,2 @@
+import * as Field from '../Field';
+export declare function upcast<T>(raw: any, functionsToCheck: Field.DecodingFunctionsToCheck): T;

package/dist/types/shared-logic/src/ComboChartV2/adjustColors.d.ts

@@ -0,0 +1 @@
+export declare function adjustColors(maybeColors: (string | undefined)[] | undefined, defaultColors: string[], shift: number): string[];

package/dist/types/shared-logic/src/ComboChartV2/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/ComboChartV2/buildComboChartRepresentation.d.ts

@@ -0,0 +1,55 @@
+import { Result as ResultType } from '../../../shared-logic/src/Result/types';
+import { BarChartRepresentation } from '../BarChartV2/types';
+import { LineChartRepresentation } from '../LineChartV2/types';
+export declare function buildComboChartRepresentation(xKeyField: ResultType.Field | undefined, barChartRepresentation: BarChartRepresentation, lineChartRepresentation: LineChartRepresentation): {
+    x: {
+        scale: {
+            min: number;
+            max: number;
+            dataType: import("../Field/types").DataType;
+            key: import("../ChartsV2/types").KeyId | null;
+            ordering: "asc" | "desc" | null;
+        } | {
+            min: null;
+            max: null;
+            dataType: import("../Field/types").DataType;
+            key: import("../ChartsV2/types").KeyId | null;
+            ordering: "asc" | "desc" | null;
+        };
+        ticks: import("../ChartsV2/types").Tick<string | number | Date>[];
+        postfix: string;
+        prefix: string;
+        title: string | null;
+        key: import("../ChartsV2/types").KeyId;
+    };
+    keys: {
+        [x: string]: import("../ChartsV2/types").Key;
+    };
+    y: {
+        scale: {
+            max: number;
+            min: number;
+            dataType: import("../Field/types").DataType;
+            key: import("../ChartsV2/types").KeyId | null;
+            ordering: "asc" | "desc" | null;
+        };
+        ticks: import("../ChartsV2/types").Tick<number>[];
+        barKeys: string[];
+        lineKeys: string[];
+        postfix: string;
+        prefix: string;
+        title: string | null;
+        keys: import("../ChartsV2/types").KeyId[];
+    };
+    lines: {
+        definitions: import("../ChartsV2/types").ShapeDefinition<import("../LineChartV2/types").LineStyles>[];
+        data: import("../ChartsV2/types").Datum[];
+        conditionalFormattingRules: import("../ChartsV2/types").ConditionalFormattingRule[];
+    };
+    bars: {
+        definitions: import("../ChartsV2/types").ShapeDefinition<import("../BarChartV2/types").BarStyles>[];
+        data: import("../ChartsV2/types").Datum[];
+        conditionalFormattingRules: import("../ChartsV2/types").ConditionalFormattingRule[];
+    };
+    goalLines: import("../ChartsV2/types").GoalLine[];
+};

package/dist/types/shared-logic/src/ComboChartV2/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/ComboChartV2/index.d.ts

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

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

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

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

@@ -0,0 +1,21 @@
+import { BarStyles } from '../BarChartV2/types';
+import { ShapeDefinition, ConditionalFormattingRule, GoalLine, BaseChartRepresentation, KeyId, Axis, Datum } from '../ChartsV2/types';
+import { LineStyles } from '../LineChartV2/types';
+export type ComboYAxis = Axis<number, {
+    lineKeys: KeyId[];
+    barKeys: KeyId[];
+}>;
+export interface ComboChartRepresentation extends Omit<BaseChartRepresentation, 'y' | 'data'> {
+    goalLines: GoalLine[];
+    bars: {
+        definitions: ShapeDefinition<BarStyles>[];
+        data: Datum[];
+        conditionalFormattingRules: ConditionalFormattingRule[];
+    };
+    lines: {
+        definitions: ShapeDefinition<LineStyles>[];
+        data: Datum[];
+        conditionalFormattingRules: ConditionalFormattingRule[];
+    };
+    y: ComboYAxis;
+}

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

@@ -0,0 +1,11 @@
+import { ComponentType, Component } from './types';
+import { EmptyCell } from '../Display/types';
+import { HeaderComponent } from '../Header/types';
+export * from './constants';
+export declare const initialCustomComponent: (componentId: string, dataSetId: string) => Component<Component.CustomViewAttributes>;
+export declare const initial: <T extends Component.Attributes>(attributes: T) => Component<T>;
+export declare const initialFromType: (type: ComponentType, dataSetId: string, viewId: string) => Component;
+export declare const isBarChart: (type: ComponentType) => boolean;
+export declare const isTable: (type: ComponentType) => boolean;
+export declare const isEmpty: (component: Component | EmptyCell | HeaderComponent) => component is EmptyCell;
+export declare const removeField: (component: Component, fieldId: string) => Component;

package/dist/types/shared-logic/src/Component/allViewConstants.d.ts

@@ -0,0 +1 @@
+export declare const ALL_VIEW_CONSTANTS: import("../ComponentInterface/types/namespaces.types").ViewConstants[];

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

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

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

@@ -0,0 +1,4 @@
+import { ComponentType } from './types';
+export declare const TIME_SERIES_CHARTS: ('areaChart' | 'lineChart' | 'horizontalBarChart' | 'barChart')[];
+export declare const ALL_COMPONENT_TYPES: ComponentType[];
+export declare const ALL_VIZZLY_COMPONENT_TYPES: ComponentType[];

package/dist/types/shared-logic/src/Component/dumpable.d.ts

@@ -0,0 +1,11 @@
+import { Dumpable } from '../Dumpable';
+import { Component } from './types';
+import { HeaderComponent } from '../Header/types';
+type EmptyComponent = {
+    isEmpty: true;
+    colSpan: number;
+};
+type ComponentDumpable = Dumpable<Component | EmptyComponent | HeaderComponent, Component.RawComponent | EmptyComponent | HeaderComponent>;
+export declare const load: ComponentDumpable['load'];
+export declare const dump: ComponentDumpable['dump'];
+export {};

package/dist/types/shared-logic/src/Component/getGroupingWithTimeDimension.d.ts

@@ -0,0 +1,5 @@
+import { QueryAttributes as QueryAttributesType } from '../QueryAttributes/types';
+export declare const getGroupingWithTimeDimension: (attrs: {
+    timeDimension?: QueryAttributesType["timeDimension"];
+    dimension: QueryAttributesType["dimension"];
+}) => QueryAttributesType["dimension"];

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

@@ -0,0 +1,4 @@
+export * from './Component';
+export * from './dumpable';
+export * from './saveable';
+export * from './attributesSchema';

package/dist/types/shared-logic/src/Component/mergeAttributes.d.ts

@@ -0,0 +1,2 @@
+import { Component } from './types';
+export declare const mergeAttributes: (partial: Partial<Component.Attributes>, existingProps: Partial<Component.Attributes>) => any;

package/dist/types/shared-logic/src/Component/onChangeTypes.d.ts

@@ -0,0 +1,29 @@
+type BaseOnChange = {
+    viewId: string;
+};
+export type ReturnedField = {
+    fieldId: string;
+    function: string;
+    value: string | number;
+};
+type Table = {
+    fields?: {
+        [key: string]: string | number;
+    };
+};
+export interface BasicTableChange extends Table, BaseOnChange {
+    type: 'basicTable';
+    clicked: ReturnedField;
+}
+export interface DataTableChange extends Table, BaseOnChange {
+    type: 'dataTable';
+    clicked: ReturnedField;
+}
+export interface BarChartChange extends BaseOnChange {
+    type: 'barChart';
+    clicked: {
+        grouping?: Array<ReturnedField>;
+        value?: ReturnedField;
+    };
+}
+export {};

package/dist/types/shared-logic/src/Component/removeField.d.ts

@@ -0,0 +1,10 @@
+import { QueryAttributes } from '../QueryAttributes/types';
+import { Component } from './types';
+import { QueryEngineConfig } from '../QueryEngineConfig/types';
+export declare const trimFieldsInOrder: <T extends {
+    order: Array<QueryAttributes.Order>;
+}>(attributes: T, allowedFields: Array<{
+    field: string;
+    function: QueryAttributes.Aggregate;
+}>) => T;
+export declare const removeField: <T extends Component.Attributes>(attributes: T, fieldId: string, queryEngineConfig: QueryEngineConfig) => T;

package/dist/types/shared-logic/src/Component/saveable.d.ts

@@ -0,0 +1,2 @@
+import { Component } from './types';
+export declare const saveable: (component: Partial<Component>, protectedComponent?: boolean) => Component;

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

@@ -0,0 +1,11 @@
+import Joi from '@vizzly/joi';
+import { QueryAttributes } from '../QueryAttributes/types';
+import { Component } from './types';
+export declare const removeUnusedOrderFieldsFromTimeSeriesComponent: <T extends {
+    measure: Array<QueryAttributes.Measure>;
+    order: Array<QueryAttributes.Order>;
+    timeDimension?: QueryAttributes.TimeDimension | null;
+    dimension: Array<QueryAttributes.Dimension>;
+}>(attributes: T) => T;
+declare const setAttributes: <Attributes extends Component.Attributes>(attributes: Partial<Component.Attributes>, partialAttributes: Partial<Component.Attributes>, schema: Joi.ObjectSchema<any>) => Attributes;
+export default setAttributes;

package/dist/types/shared-logic/src/Component/sharedSchemas.d.ts

@@ -0,0 +1,58 @@
+import Joi from '@vizzly/joi';
+import { SupportedAggregates } from '../Aggregate';
+import { QueryEngineConfig } from '../QueryEngineConfig/types';
+import { SupportedTimeTruncFunctions } from '@vizzly/semantic-layer-public';
+import { ComponentInterfaceConfig } from '../ComponentInterface/types';
+export * from '../Tags/tags';
+export declare const measureSchema: (supportedAggregates: SupportedAggregates, attributeSchemaOptions: ComponentInterfaceConfig["attributesSchemaOptions"]) => Joi.AlternativesSchema<any> | Joi.ObjectSchema<any>;
+export declare const orderSchema: (queryEngineConfig: QueryEngineConfig) => Joi.ObjectSchema<any>;
+export declare const timeDimensionSchema: (supportedTimeTruncFunctions: SupportedTimeTruncFunctions) => Joi.ObjectSchema<any>;
+export declare const dimensionSchema: (supportedTimeTruncFunctions: SupportedTimeTruncFunctions, attributeSchemaOptions: ComponentInterfaceConfig["attributesSchemaOptions"]) => Joi.ArraySchema<any[]>;
+export declare const queryFilterSchema: (queryEngineConfig: QueryEngineConfig, maxDepth?: number) => Joi.Schema;
+export declare const filterSchema: (queryEngineConfig: QueryEngineConfig) => Joi.ObjectSchema<any>;
+export declare const queryAttributesFilter: (queryEngineConfig: QueryEngineConfig) => Joi.ArraySchema<any[]>;
+export declare const queryAttributesLimit: () => Joi.NumberSchema<number>;
+export declare const baseAttributesSchema: (attributeSchemaOptions: ComponentInterfaceConfig["attributesSchemaOptions"]) => {
+    viewId: Joi.StringSchema<string>;
+    displayTitle: Joi.StringSchema<string>;
+    displaySubject: Joi.StringSchema<string>;
+    dataSetId: Joi.StringSchema<string>;
+    protectedByOrganisation: Joi.BooleanSchema<boolean>;
+};
+export declare const approxAxisLabelCountSchema: Joi.AnySchema<any>;
+export declare const querySchema: (queryEngineConfig: QueryEngineConfig, attributeSchemaOptions: ComponentInterfaceConfig["attributesSchemaOptions"]) => {
+    measure: Joi.ArraySchema<any[]>;
+    dimension: Joi.ArraySchema<any[]>;
+    order: Joi.ArraySchema<any[]>;
+    limit: Joi.NumberSchema<number>;
+    offset: Joi.NumberSchema<number>;
+};
+export declare const timeDimensionQuerySchema: (queryEngineConfig: QueryEngineConfig, attributeSchemaOptions: ComponentInterfaceConfig["attributesSchemaOptions"]) => {
+    filter: Joi.ArraySchema<any[]>;
+    timeDimension: Joi.AlternativesSchema<any>;
+    drilldown: Joi.AlternativesSchema<string | any[]>;
+    xAxisPrefix: Joi.StringSchema<string>;
+    yAxisPrefix: Joi.StringSchema<string>;
+    xAxisPostfix: Joi.StringSchema<string>;
+    yAxisPostfix: Joi.StringSchema<string>;
+    yAxisFormat: Joi.AlternativesSchema<any>;
+    xAxisFormat: Joi.AlternativesSchema<any>;
+    approxYAxisLabelCount: Joi.AnySchema<any>;
+    approxXAxisLabelCount: Joi.AnySchema<any>;
+    measure: Joi.ArraySchema<any[]>;
+    dimension: Joi.ArraySchema<any[]>;
+    order: Joi.ArraySchema<any[]>;
+    limit: Joi.NumberSchema<number>;
+    offset: Joi.NumberSchema<number>;
+};
+export declare const lineCurveSchema: Joi.StringSchema<string>;
+export declare const areaCurveSchema: Joi.StringSchema<string>;
+export declare const protectedFieldsMeasure: (queryEngineConfig: QueryEngineConfig) => Joi.ArraySchema<any[]>;
+export declare const protectedFieldsDimension: (queryEngineConfig: QueryEngineConfig) => Joi.ArraySchema<any[]>;
+export declare const parametersSchema: (queryEngineConfig: QueryEngineConfig, attributeSchemaOptions: ComponentInterfaceConfig["attributesSchemaOptions"]) => Joi.ObjectSchema<any>;
+export declare const goalLineSchema: () => Joi.ObjectSchema<any>;
+export declare const goalLinesSchema: () => Joi.ArraySchema<any[]>;
+export declare const quadrantsSchema: () => Joi.ObjectSchema<any>;
+export declare const headlineSchema: () => Joi.ObjectSchema<any>;
+export declare const axisTitleSchema: () => Joi.ObjectSchema<any>;
+export declare const sizingSchema: Joi.ObjectSchema<any>;

package/dist/types/shared-logic/src/Component/splitTimeDimensionFromGrouping.d.ts

@@ -0,0 +1,4 @@
+import { Component } from '../Component/types';
+import { QueryAttributes as QueryAttributesType } from '../QueryAttributes/types';
+import { DataSet as DataSetType } from '../DataSet/types';
+export declare const splitTimeDimensionFromGrouping: (grouping: QueryAttributesType["dimension"], dataSet: DataSetType) => Partial<Component.BarChartAttributes>;