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

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

@@ -0,0 +1,6 @@
+import { QueryAttributes } from '../QueryAttributes/types';
+import { DecodingFunctionsToCheck } from '../Field';
+export declare const id: (metric: QueryAttributes.Dimension) => string;
+export declare const isPivot: (dimensions: QueryAttributes.Dimension[], pivot: "x" | "y") => boolean;
+export declare const findDimension: (dimensions: QueryAttributes.Dimension[], fieldId: string, functionsToCheck: DecodingFunctionsToCheck) => QueryAttributes.Dimension;
+export declare const isDateTime: (dimension: QueryAttributes.Dimension) => boolean;

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

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

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

@@ -0,0 +1,23 @@
+import { Component, ComponentType } from '../Component/types';
+import { Display, DisplayRow, EmptyCell } from './types';
+import { HeaderComponent } from '../Header/types';
+export { removeAllFieldReferences } from './removeAllFieldReferences';
+export declare const allComponentsInDirection: (display: Display, rowIndex: number, cellIndex: number, direction: "left" | "right") => Array<Component | EmptyCell | HeaderComponent>;
+export declare const getNextComponentIndexWithSpace: (display: Display, rowIndex: number, cellIndex: number, direction: "left" | "right") => number;
+export declare const insertRow: (display: Display, rowIndex: number, height?: number) => Display;
+export declare const newEmptyCell: (colSpan: number) => EmptyCell;
+export declare const TOTAL_COLSPAN = 12;
+export declare const appendEmptyCell: (currentPanels: Display, rowIndex: number) => Display;
+export declare const setComponent: (display: Display, component: Component | EmptyCell | HeaderComponent, rowIndex: number, cellIndex: number) => Display;
+type Move = {
+    rowIndex: number;
+    cellIndex: number;
+};
+export declare const swapComponents: (display: Display, positionA: Move, positionB: Move) => Display;
+export declare const init: () => Display;
+export declare const initRow: (components: Array<Component | EmptyCell | HeaderComponent>, height?: number) => DisplayRow;
+export declare const listComponentTypesUsed: (display: Display) => ComponentType[];
+export declare const isComponentEmpty: (component: Component | EmptyCell | HeaderComponent) => component is EmptyCell;
+export declare function isDisplayComponentsEmpty(display: Display): boolean;
+export declare const moveDisplayToNewIndex: (display: DisplayRow[], movingIndex: number, destinationIndex: number) => DisplayRow[];
+export declare const countNonHeaderRows: (display: Display) => number;

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

@@ -0,0 +1,5 @@
+import { Dumpable } from '../Dumpable';
+import { Display, DisplayDumped } from './types';
+export type DumpableDisplay = Dumpable<Display, DisplayDumped>;
+export declare const load: DumpableDisplay['load'];
+export declare const dump: DumpableDisplay['dump'];

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

@@ -0,0 +1,2 @@
+export * from './Display';
+export * from './dumpable';

package/dist/types/shared-logic/src/Display/removeAllFieldReferences.d.ts

@@ -0,0 +1,3 @@
+import { Display } from './types';
+import { DataSet } from '../DataSet/types';
+export declare const removeAllFieldReferences: (display: Display, fieldsToRemove: DataSet.Field[]) => Display;

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

@@ -0,0 +1,15 @@
+import { Component } from '../Component/types';
+import { HeaderComponent } from '../Header/types';
+export type EmptyCell = {
+    isEmpty: true;
+    colSpan: number;
+};
+export type DisplayRow = {
+    components: Array<Component | EmptyCell | HeaderComponent>;
+    height: number;
+};
+export type Display = DisplayRow[];
+export type DisplayDumped = Array<{
+    components: Array<Component.RawComponent | EmptyCell | HeaderComponent>;
+    height: number;
+}>;

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

@@ -0,0 +1,7 @@
+import { DisplayRow, EmptyCell } from './types';
+import { Component as ComponentType } from '../Component/types';
+import { ComponentInterfaceConfig } from '../ComponentInterface/types';
+import { HeaderComponent } from '../Header/types';
+type OldDisplayRow = (ComponentType | null | EmptyCell | HeaderComponent)[];
+export declare const upcastRow: (displayRow: OldDisplayRow | DisplayRow, componentInterfaceConfig?: ComponentInterfaceConfig) => DisplayRow;
+export {};

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

@@ -0,0 +1,3 @@
+export * from './joiToDocumentation';
+export * from './joiToSchemaDefinition';
+export * from './joiToAiDefinition';

package/dist/types/shared-logic/src/Documentation/joiToAiDefinition.d.ts

@@ -0,0 +1,5 @@
+import Joi from '@vizzly/joi';
+import joiToJson from 'joi-to-json';
+type SchemaDocumentation = ReturnType<typeof joiToJson>;
+export declare const joiToAiDefinition: (obj: Joi.Schema) => SchemaDocumentation;
+export {};

package/dist/types/shared-logic/src/Documentation/joiToDocumentation.d.ts

@@ -0,0 +1,4 @@
+import Joi from '@vizzly/joi';
+import joiToJson from 'joi-to-json';
+export type SchemaDocumentation = ReturnType<typeof joiToJson>;
+export declare const joiToDocumentation: (obj: Joi.Schema) => SchemaDocumentation;

package/dist/types/shared-logic/src/Documentation/joiToSchemaDefinition.d.ts

@@ -0,0 +1,2 @@
+import Joi from '@vizzly/joi';
+export declare const joiToSchemaDefinition: (obj: Joi.Schema) => any;

package/dist/types/shared-logic/src/Downloads/downloadToJSON.d.ts

@@ -0,0 +1,4 @@
+export declare const downloadToJSON: ({ data, fileName }: {
+    data: Object;
+    fileName: string;
+}) => "Success" | "Sorry, the data supplied to downloadToJSON was not a valid object";

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

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

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

@@ -0,0 +1,30 @@
+import { Component } from '../Component/types';
+import { DataSet } from '../DataSet/types';
+import { Datum, ParsedDatumKey } from '../DatumKey';
+import { QueryAttributes } from '../QueryAttributes/types';
+import { QueryEngineConfig } from '../QueryEngineConfig/types';
+export declare const updateTimeDimension: (dataSet: DataSet, option: QueryAttributes.TimeDimension & {
+    function?: string;
+}) => QueryAttributes.TimeDimension | null;
+export type DrilldownField = Component.DrilldownOptions & {
+    value: string | number | Date;
+};
+export type SelectedDrilldown = {
+    newField: Component.DrilldownOptions;
+    existingField?: DrilldownField;
+};
+export declare const newDimensions: (dataSet: DataSet, existingField: DrilldownField | undefined, option: QueryAttributes.Dimension, dimension: QueryAttributes.Dimension[], hasDateTimeInDimension?: boolean) => QueryAttributes.Dimension[];
+export declare const updateFilter: (existingFilters: QueryAttributes.Filter[][], data: any[][], queryEngineConfig: QueryEngineConfig, existingField: DrilldownField | undefined, timeDimension: QueryAttributes.TimeDimension | null, dimension?: QueryAttributes.Dimension[]) => QueryAttributes.Filter[][];
+export declare const drilldownDepthReached: (drilldownSelections: SelectedDrilldown[]) => boolean;
+export declare const updatedOrder: (existingOrder: QueryAttributes.Order[], dataSet: DataSet, existingField: DrilldownField | undefined, option: QueryAttributes.Dimension | QueryAttributes.TimeDimension) => QueryAttributes.Order[];
+export declare const validDrilldownProperties: (dataSet: DataSet, drilldown: SelectedDrilldown) => boolean;
+export declare function buildSelectedField(clickedValue: Datum, queryEngineConfig: QueryEngineConfig): {
+    field: string;
+    value: string;
+    function: string;
+};
+export declare function buildClickedOnFieldForQuery(getField: (metric: {
+    field: string;
+    function: string;
+}) => string, parseKey: (key: string) => ParsedDatumKey | undefined, dimension?: QueryAttributes.Dimension[], timeDimension?: QueryAttributes.TimeDimension | null, clickedValue?: Datum | undefined): DrilldownField[];
+export declare function buildDrilldownFilters(attributes: Component.BarChartAttributes | Component.HorizontalBarChartAttributes | Component.PieChartAttributes, queries: Partial<QueryAttributes>, existingField: DrilldownField[], combineFilters: (array1: QueryAttributes.Filter[][], array2: QueryAttributes.Filter[][]) => QueryAttributes.Filter[][], updateFilter: (field: DrilldownField, timeDimension: QueryAttributes.TimeDimension | null, dimension: QueryAttributes.Dimension[]) => QueryAttributes.Filter[][]): QueryAttributes.Filter[][];

package/dist/types/shared-logic/src/Drilldown/schema.d.ts

@@ -0,0 +1,3 @@
+import Joi from '@vizzly/joi';
+import { QueryEngineConfig } from '../QueryEngineConfig/types';
+export declare function drilldownSchema(queryEngineConfig: QueryEngineConfig): Joi.SchemaLike<any> | Joi.SchemaLike<any>[] | undefined;

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

@@ -0,0 +1,5 @@
+import { ComponentInterfaceConfig } from './ComponentInterface/types/ComponentInterfaceConfig';
+export interface Dumpable<Hydrated, Dumped> {
+    dump: (hydrated: Hydrated) => Dumped;
+    load: (dumped: Dumped, componentInterfaceConfig?: ComponentInterfaceConfig) => Hydrated;
+}

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

@@ -0,0 +1,4 @@
+import { QueryEngineConfig as QueryEngineConfigType } from '../QueryEngineConfig/types';
+import { FeatureToggles } from './types';
+export declare const END_USER_DEFAULT_FEATURE_TOGGLES: FeatureToggles;
+export declare const build: (partialFeatureToggles: Partial<FeatureToggles>, queryEngineConfig: QueryEngineConfigType, mode: "admin" | "endUser", scope: "read" | "read_write") => FeatureToggles;

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

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

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

@@ -0,0 +1,46 @@
+export type FeatureToggles = {
+    showGlobalFilters: boolean;
+    hideToolbar: boolean;
+    showResetButton: boolean;
+    parameters: boolean;
+    canManageGlobalFilters: boolean;
+    disableAutoSave: boolean;
+    canEditComponentLibrary: boolean;
+    canUseComponentLibrary: boolean;
+    canAddTags: boolean;
+    canCreateStandaloneComponents: boolean;
+    canEditComponentsOnDashboard: boolean;
+    canRemoveComponentsFromDashboard: boolean;
+    canConfigureLocalFilters: boolean;
+    canAddNewRows: boolean;
+    canAddNewCells: boolean;
+    canEditCustomMetrics: boolean;
+    allowSimpleMathsCustomField: boolean;
+    allowAggregateMathsCustomField: boolean;
+    allowRoundedNumberCustomField: boolean;
+    allowDateCalculationsCustomField: boolean;
+    allowPercentagesCustomField: boolean;
+    allowRulesCustomField: boolean;
+    allowConditionalCustomField: boolean;
+    allowCustomBuildField: boolean;
+    /** Show/Hide the Date and Time Filter
+     * @default false */
+    showDateAndTimeFilter: boolean;
+    /** Show/Hide the Date Filter
+     * @default true */
+    showDateFilter: boolean;
+    canSeeEmptyState: boolean;
+    /** Does the download option show for each view? */
+    canDownloadComponentData: boolean;
+    canDownloadPDF: boolean;
+    canDownloadViewData: boolean;
+    canDownloadViewAsPNG: boolean;
+    canDownloadDataSet: boolean;
+    forceMobile: boolean;
+    /** Should views only render & re-render when in the viewport? */
+    unloadOffScreenViews: boolean;
+    /** Show the saving indicator */
+    showSavingIndicator: boolean;
+    /** For `read` users, the global filters are persisted by storing configuration locally */
+    disablePersistingGlobalFiltersLocally: boolean;
+};

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

@@ -0,0 +1,102 @@
+import { DataSet } from '../DataSet/types';
+import { DateTimeField, NonDateTimeField, SupportedAggregateOption } from '../Field/types';
+import { DataType } from './types';
+import { QueryAttributes, SupportedOperators } from '../QueryAttributes/types';
+import { SupportedAggregates } from '../Aggregate';
+import { SupportedTimeTruncFunctions } from '@vizzly/semantic-layer-public';
+import { QueryEngineConfig } from '../QueryEngineConfig/types';
+import { SupportedTransformationFunctions } from '../Functions/types';
+import { TextOverride } from '../Translations/types';
+import { ValueAlias as ValueAliasType } from '../ValueAlias/types';
+export declare const NULL_REPLACEMENT = "No value";
+export declare const ALL_AGGREGATES: Array<QueryAttributes.Aggregate>;
+export type OldField = {
+    id: string;
+    publicName?: string;
+    dataType: 'string' | 'number' | 'date_time' | 'boolean' | 'string[]';
+    canBeDimension?: boolean;
+    canBeMeasure?: boolean;
+    allowedGranularities?: QueryAttributes.TimeDimension.Truncate[];
+    allowedOperators?: Array<QueryAttributes.Operator>;
+    dashboardRequiredFilterGroups?: Array<{
+        publicName: string;
+    }>;
+    supportedAggregateOptions?: string[];
+    description?: string;
+};
+export declare const upcastField: (maybeOldField: OldField, queryEngineConfig: QueryEngineConfig, options?: {
+    allowEmptyPublicName: boolean;
+}) => DateTimeField | NonDateTimeField;
+export declare const valueIsOrDataType: (value: unknown, dataType: DataType) => boolean;
+export declare const parseValue: (raw: string | number | null | boolean | Date | string[], type: DataType) => string | number | boolean | Date | null;
+export declare const parseBooleanFromString: (raw: string, type: DataType) => string | boolean;
+export declare const VALID_DATA_TYPES: DataType[];
+export declare const isValidDataType: (type: string) => boolean;
+export declare const toHumanReadable: (fieldTitle: string) => string;
+export declare const dataTypeToHumanReadable: (dataType: DataType) => string;
+export declare const toString: (value: null | string | number | Date | boolean | string[], formatDate?: (date: Date) => string, nullReplacement?: string) => string | null;
+export declare const toStringShort: (value: null | string | number | Date, nullReplacement?: string) => string | number;
+export declare const removeFields: <T extends {
+    id: string;
+}>(originalFields: {
+    id: string;
+}[], fieldTitlesToRemove: string[]) => T[];
+export declare const supportedOperators: (field: DataSet.Field, supportedOperators: QueryEngineConfig["supportedOperators"], textOverride?: TextOverride) => SupportedOperators;
+export declare const getDefaultAggregateForField: <T extends SupportedAggregates>(field: {
+    dataType: DataType;
+}, supportedAggregates: T) => string;
+export declare const supportedAggregatesForField: <T extends SupportedAggregates>(field: {
+    dataType: DataType;
+    supportedAggregateOptions?: SupportedAggregateOption[];
+}, supportedAggregates: T) => Array<string>;
+export declare const supportedAggregateOptions: <T extends SupportedAggregates>(field: {
+    dataType: DataType;
+}, supportedAggregates: T) => Array<{
+    label: string;
+    value: keyof T;
+}>;
+export declare const timeDimensionTruncateToSelectOptions: (allowedTimeDimensionGranularities: QueryAttributes.TimeDimension.Truncate[], supportedTimeTruncFunctions: SupportedTimeTruncFunctions) => {
+    label: string;
+    value: QueryAttributes.TimeDimension.Truncate;
+}[];
+export declare const takeHighestGranularity: (timeDimensionGranularities: QueryAttributes.TimeDimension.Truncate[]) => QueryAttributes.TimeDimension.Truncate;
+/**
+ * Build the id of the field in string format
+ */
+export declare const id: (metric: {
+    field: string;
+    function: string;
+}) => string;
+export type DecodingFunctionsToCheck = {
+    supportedAggregates: QueryEngineConfig['supportedAggregates'] | undefined;
+    supportedTimeTruncFunctions: QueryEngineConfig['supportedTimeTruncFunctions'] | undefined;
+    supportedTransformationFunctions: QueryEngineConfig['supportedTransformationFunctions'] | undefined;
+};
+/**
+ * Decode a built id of the field. Requires all possible functions to be
+ * able to do this.
+ */
+export declare const decodeId: (metric: string, functionsToCheck: DecodingFunctionsToCheck) => QueryAttributes.Measure;
+/**
+ * @deprecated
+ * Use decodeId instead.
+ * */
+export declare const getQueryFieldIdFromResultFieldId: (fieldIdOrDatumKey: string, functionsToCheck: DecodingFunctionsToCheck) => {
+    fieldId: string;
+    function: QueryAttributes.Aggregate;
+};
+export declare const listValidFunctionsForDataType: (field: {
+    dataType: DataType;
+}, supportedTransformationFunctions: SupportedTransformationFunctions | SupportedAggregates) => string[];
+export declare const removeField: <T extends {
+    id: string;
+}>(originalFields: T[], removeFields: (QueryAttributes.Dimension | QueryAttributes.Measure)[]) => T[];
+export declare const upcastStringDimensionsToObject: (dimensions: QueryAttributes.Dimension[]) => QueryAttributes.Dimension[];
+export declare const isArrayDataType: (field: {
+    dataType: DataType;
+}) => boolean;
+declare const vizzlySupportedTransformationFunctions: SupportedTransformationFunctions;
+export declare const supportedTransformationFunctions: (keys?: Array<keyof typeof vizzlySupportedTransformationFunctions>) => SupportedTransformationFunctions;
+export declare const supportedAggregatesFunction: (queryEngineConfig: QueryEngineConfig, dataType: DataType, supportedAggregateOptions?: SupportedAggregateOption[]) => SupportedAggregateOption[];
+export declare const checkForNullValue: (dataSetId: string, dimensions: QueryAttributes.Dimension[] | null, timeDimension: QueryAttributes.TimeDimension | null, textOverride?: TextOverride, valueAlias?: ValueAliasType, textOverrideKey?: string) => string | undefined;
+export {};

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

@@ -0,0 +1,2 @@
+import Joi from '@vizzly/joi';
+export declare const ArrayFieldSchema: Joi.ArraySchema<any[]>;

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

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

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

@@ -0,0 +1,26 @@
+import { QueryAttributes } from '../QueryAttributes/types';
+export type DataType = 'number' | 'boolean' | 'string' | 'date_time' | 'string[]';
+export type DateTimeFormat = 'DD/MM/YYYY' | 'MM/DD/YYYY' | 'DD-MM-YYYY' | 'MM-DD-YYYY' | 'DD MMMM YYYY, hh:mm' | 'dddd DD MMMM YYYY, hh:mm' | 'hh:mm' | 'hh:mm:ss' | 'DD MMMM YYYY' | 'MMMM YYYY' | 'YYYY' | 'YYYY-MM-DD[T]HH:mm:ss' | 'quarter' | 'week' | 'day_of_month' | 'day_of_week_iso' | 'week_of_year' | 'hour_of_day' | 'month_of_year';
+export type SupportedAggregateOption = string;
+type DashboardRequiredFilterGroup = {
+    /** This is displayed on the global filter, and it is also used to group related filters */
+    publicName: string;
+};
+export type BaseField = {
+    id: string;
+    publicName: string;
+    description?: string;
+    canBeDimension: boolean;
+    canBeMeasure: boolean;
+    allowedOperators: Array<QueryAttributes.Operator>;
+    dashboardRequiredFilterGroups?: DashboardRequiredFilterGroup[];
+    supportedAggregateOptions?: SupportedAggregateOption[];
+};
+export type DateTimeField = BaseField & {
+    dataType: 'date_time';
+    allowedGranularities: QueryAttributes.TimeDimension.Truncate[];
+};
+export interface NonDateTimeField extends BaseField {
+    dataType: Exclude<DataType, 'date_time'>;
+}
+export {};

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

@@ -0,0 +1,26 @@
+import { Params } from 'results-driver/src/types';
+import { DataSet } from '../DataSet/types';
+import { Query } from '../Query/types';
+import { QueryAttributes } from '../QueryAttributes/types';
+import { QueryEngineConfig } from '../QueryEngineConfig/types';
+import { VariableList } from '../Variables/types';
+export declare const addAndFilters: (filter: QueryAttributes["filter"], filterToAddToAll: QueryAttributes.Filter[][]) => QueryAttributes["filter"];
+export declare const convertArrayFilterStructureToQueryFilter: (arrayFilterStructure: QueryAttributes.Filter[][], variables: VariableList) => Query["filter"];
+export declare const combineQueryFilters: (filter: Query["filter"], filterToAddToAll: Query["filter"]) => Query["filter"];
+/**
+ * Iterates through a query filter and, for each custom metric field, builds a custom metric.
+ */
+export declare function buildQueryCustomMetrics(filter: Query['filter'], dataSet: DataSet, queryEngineConfig: QueryEngineConfig, params: Params): Query['filter'];
+export declare function getFieldFromFilter(filter: Query['filter']): {
+    type: "string";
+    value: string;
+    as?: string;
+} | {
+    type: "field";
+    value: string;
+    function: string;
+    as?: string;
+} | null;
+export declare const takeUsedFields: (filter: QueryAttributes["filter"]) => string[];
+export declare const isAvailable: (filter?: QueryAttributes["filter"]) => boolean | undefined;
+export declare const isAdditionalFilter: (value: any) => boolean;

package/dist/types/shared-logic/src/Filter/combineFilters.d.ts

@@ -0,0 +1,2 @@
+import { QueryAttributes } from '../QueryAttributes/types';
+export declare const combineFilters: (array1: QueryAttributes.Filter[][], array2: QueryAttributes.Filter[][]) => QueryAttributes.Filter[][];

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

@@ -0,0 +1,2 @@
+export * from './Filter';
+export * from './combineFilters';

package/dist/types/shared-logic/src/Filter/relative.d.ts

@@ -0,0 +1,55 @@
+import { DataSet as DataSetType } from '../DataSet/types';
+import { Field } from '../AdditionalFilter/types';
+import { QueryAttributes } from '../QueryAttributes/types';
+import { TextOverride } from '../Translations/types';
+import Joi from '@vizzly/joi';
+export type RelativeDate = {
+    unit: DurationType | null;
+    value: number | null;
+    timeFrame: TimeframeType | null;
+};
+export declare const defaultDurationOptions: (textOverride?: TextOverride) => {
+    minutes: {
+        description: string;
+        formatter: (currentDate: Date, value: number) => void;
+    };
+    hours: {
+        description: string;
+        formatter: (currentDate: Date, value: number) => void;
+    };
+    days: {
+        description: string;
+        formatter: (currentDate: Date, value: number) => void;
+    };
+    weeks: {
+        description: string;
+        formatter: (currentDate: Date, value: number) => void;
+    };
+    months: {
+        description: string;
+        formatter: (currentDate: Date, value: number) => void;
+    };
+    years: {
+        description: string;
+        formatter: (currentDate: Date, value: number) => void;
+    };
+};
+type DurationOptions = ReturnType<typeof defaultDurationOptions>;
+export type DurationType = keyof DurationOptions;
+export declare const defaultTimeframeOptions: (textOverride?: TextOverride) => {
+    future: {
+        description: string;
+    };
+    past: {
+        description: string;
+    };
+};
+type TimeframeOptions = ReturnType<typeof defaultTimeframeOptions>;
+export type TimeframeType = keyof TimeframeOptions;
+export declare const relativeSchema: Joi.ObjectSchema<any>;
+export declare function isRelative(value: any): any;
+export declare function isRelativeDateDefined(value: RelativeDate): boolean;
+export declare const init: () => RelativeDate;
+export declare const calculateRelativeDate: (relativeDate: RelativeDate, startDate?: Date) => Date;
+export declare const buildRelativeRange: (relativeFilters: QueryAttributes.Filter[][], dataSet: DataSetType, appliesToFields?: Field[]) => QueryAttributes.Filter[][];
+export {};

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

@@ -0,0 +1,7 @@
+import type { Query } from '@vizzly/sqlbuilder-public';
+export declare enum Clause {
+    AND_WHERE = "andWhere",
+    OR_WHERE = "orWhere",
+    WHERE = "where"
+}
+export type WhereClause = Query['filter'];

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

@@ -0,0 +1,48 @@
+import { FormattingRuleType } from '../FormattingRule/types';
+import { Section } from '../DataPanelConfig/types';
+export type HeadingSubSections = Section<'title'> | Section<'subject'>;
+export type HeadingSection = Section<'heading'> & {
+    subSection: Array<HeadingSubSections>;
+};
+export type FormatSubSections = Section<'time'> | Section<'fontSize'> | Section<'direction'>;
+export type FormatSection = Section<'format'> & {
+    subSection: Array<FormatSubSections>;
+};
+export type ChartStylesSubSections = Section<'stacked' | 'curve' | 'legend' | 'numberFormat' | 'labels'>;
+export type ChartStylesSection = Section<'chartStyles'> & {
+    subSection: Array<ChartStylesSubSections>;
+};
+export interface LabelSection<T> extends Omit<Section<T>, 'type'> {
+    prefix: Omit<Section<T>, 'type'>;
+    postfix: Omit<Section<T>, 'type'>;
+    format?: Omit<Section<T>, 'type'>;
+    count: Omit<Section<T>, 'type'>;
+    axisTitle?: Omit<Section<T>, 'type'>;
+}
+export type AxisLabelsSection = Section<'axisLabels'> & {
+    x: LabelSection<'axisLabels'>;
+    y: LabelSection<'axisLabels'>;
+};
+export type LabelsSection = Section<'statsLabels'> & LabelSection<'statsLabels'>;
+export type PrefixSection = Section<'prefixes'>;
+export type MapColorsSection = Section<'mapColors'>;
+export type WaterfallColorsSection = Section<'waterfallColors'>;
+export type HeadlineSection = Section<'headline'>;
+export type RichTextFormatSection = Section<'richText'>;
+export interface QuadrantsSection extends Section<'quadrants'> {
+}
+export interface ConditionalFormattingSection extends Section<'conditionalFormatting'> {
+    ruleType: FormattingRuleType;
+    subSection?: {
+        title: string;
+        propKey: 'bar' | 'line';
+    }[];
+}
+export interface GoalLineSection extends Section<'goalLine'> {
+}
+export interface ProgressTypeSection<T> extends Omit<Section<T>, 'type'> {
+    progressType?: Omit<Section<T>, 'type'>;
+}
+export type ProgressTypesSection = Section<'progressType'> & ProgressTypeSection<'progressType'>;
+export type FormatPanelSection = HeadingSection | FormatSection | ChartStylesSection | PrefixSection | AxisLabelsSection | LabelsSection | MapColorsSection | WaterfallColorsSection | QuadrantsSection | ConditionalFormattingSection | GoalLineSection | ProgressTypesSection | HeadlineSection | RichTextFormatSection | Section<'trends'>;
+export type FormatPanelConfig = Array<FormatPanelSection>;

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

@@ -0,0 +1 @@
+export type FormattingRuleType = 'backgroundColor' | 'fontColor' | 'lineColor' | 'areaColor';

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

@@ -0,0 +1,8 @@
+import { DataType } from '../Field/types';
+export type SupportedFunction = {
+    publicName: string;
+    validDataTypes: Array<Omit<DataType, 'date_time'>>;
+};
+export type SupportedTransformationFunctions = {
+    [id: string]: SupportedFunction;
+};

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

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

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

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

package/dist/types/shared-logic/src/Generate/aggregateMathsField.d.ts

@@ -0,0 +1,4 @@
+import { DataSet } from '../DataSet/types';
+import { QueryEngineConfig } from '../QueryEngineConfig/types';
+declare const generateAggregateMathsFields: (dataSet: DataSet, queryEngineConfig: QueryEngineConfig, seed?: number) => DataSet.Field[];
+export default generateAggregateMathsFields;

package/dist/types/shared-logic/src/Generate/chunk.d.ts

@@ -0,0 +1 @@
+export default function chunk(arr: Array<any>): Array<any>;

package/dist/types/shared-logic/src/Generate/conditionalPercentageField.d.ts

@@ -0,0 +1,4 @@
+import { DataSet } from '../DataSet/types';
+import { QueryEngineConfig } from '../QueryEngineConfig/types';
+declare const generateConditionalPercentageField: (dataSet: DataSet, queryEngineConfig: QueryEngineConfig, seed?: number) => DataSet.Field[];
+export default generateConditionalPercentageField;

package/dist/types/shared-logic/src/Generate/customFields.d.ts

@@ -0,0 +1,4 @@
+import { DataSet } from '../DataSet/types';
+import { QueryEngineConfig } from '../QueryEngineConfig/types';
+declare const generateCustomFields: (dataSet: DataSet, queryEngineConfig: QueryEngineConfig, seed?: number) => DataSet["fields"];
+export default generateCustomFields;

package/dist/types/shared-logic/src/Generate/dateCalculationField.d.ts

@@ -0,0 +1,4 @@
+import { DataSet } from '../DataSet/types';
+import { QueryEngineConfig } from '../QueryEngineConfig/types';
+declare const generateDateCalculationField: (dataSet: DataSet, queryEngineConfig: QueryEngineConfig, seed?: number) => DataSet.Field[];
+export default generateDateCalculationField;

package/dist/types/shared-logic/src/Generate/dimension.d.ts

@@ -0,0 +1,4 @@
+import { DataSet } from '../DataSet/types';
+import { QueryAttributes } from '../QueryAttributes/types';
+declare const generateDimension: (dataSet: DataSet) => QueryAttributes["dimension"][];
+export default generateDimension;

package/dist/types/shared-logic/src/Generate/filter.d.ts

@@ -0,0 +1,5 @@
+import { DataSet } from '../DataSet/types';
+import { QueryAttributes } from '../QueryAttributes/types';
+import { QueryEngineConfig } from '../QueryEngineConfig/types';
+declare const generateFilter: (dataSet: DataSet, queryEngineConfig: QueryEngineConfig, seed?: number) => QueryAttributes["filter"];
+export default generateFilter;

package/dist/types/shared-logic/src/Generate/measures.d.ts

@@ -0,0 +1,5 @@
+import { DataSet } from '../DataSet/types';
+import { QueryEngineConfig } from '../QueryEngineConfig/types';
+import { QueryAttributes } from '../QueryAttributes/types';
+declare const generateMeasures: (dataSet: DataSet, queryEngineConfig: QueryEngineConfig, seed?: number) => Array<QueryAttributes["measure"]>;
+export default generateMeasures;

package/dist/types/shared-logic/src/Generate/order.d.ts

@@ -0,0 +1,5 @@
+import { DataSet } from '../DataSet/types';
+import { QueryEngineConfig } from '../QueryEngineConfig/types';
+import { QueryAttributes } from '../QueryAttributes/types';
+declare const generateOrder: (dataSet: DataSet, queryEngineConfig: QueryEngineConfig, seed?: number) => Array<QueryAttributes["order"]>;
+export default generateOrder;

package/dist/types/shared-logic/src/Generate/query.d.ts

@@ -0,0 +1,10 @@
+import { Params } from 'results-driver/src/types';
+import { DataSet } from '../DataSet/types';
+import { Query } from '../Query/types';
+import { QueryAttributes } from '../QueryAttributes/types';
+import { QueryEngineConfig } from '../QueryEngineConfig/types';
+export declare function prepareGeneratedQueryAttributes(dataSets: Array<DataSet>, queryEngineConfig: QueryEngineConfig, seed?: number, generateCount?: number): Array<QueryAttributes & {
+    dataSet: DataSet;
+}>;
+declare const _default: (dataSets: DataSet[], queryEngineConfig: QueryEngineConfig, params: Params, seed?: number, generateCount?: number) => Array<Query>;
+export default _default;

package/dist/types/shared-logic/src/Generate/roundedNumberField.d.ts

@@ -0,0 +1,4 @@
+import { DataSet } from '../DataSet/types';
+import { QueryEngineConfig } from '../QueryEngineConfig/types';
+declare const generateRoundedNumberField: (dataSet: DataSet, queryEngineConfig: QueryEngineConfig, seed?: number) => DataSet.Field[];
+export default generateRoundedNumberField;

package/dist/types/shared-logic/src/Generate/rulesField.d.ts

@@ -0,0 +1,4 @@
+import { DataSet } from '../DataSet/types';
+import { QueryEngineConfig } from '../QueryEngineConfig/types';
+declare const rulesField: (dataSet: DataSet, queryEngineConfig: QueryEngineConfig, seed?: number) => DataSet.Field[];
+export default rulesField;

package/dist/types/shared-logic/src/Generate/seededShuffle.d.ts

@@ -0,0 +1,2 @@
+declare function shuffle(array: any, seed?: number): any;
+export default shuffle;

package/dist/types/shared-logic/src/Generate/simpleMathsFields.d.ts

@@ -0,0 +1,4 @@
+import { DataSet } from '../DataSet/types';
+import { QueryEngineConfig } from '../QueryEngineConfig/types';
+declare const generateSimpleMathsFields: (dataSet: DataSet, queryEngineConfig: QueryEngineConfig, seed?: number) => DataSet.Field[];
+export default generateSimpleMathsFields;