@vizzly/services 0.15.0-dev-dfdff442d54d270df03c337679ae904243a831b6 → 0.15.0-dev-f576f0918251ec7901abbda943caec672e40c29c

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

@@ -0,0 +1,63 @@
+import { Section } from '../DataPanelConfig/types';
+import { ViewConstants } from './types/namespaces.types';
+export declare function headingConstant(constants: ViewConstants): {
+    subSection: (Section<"title"> | Section<"subject">)[];
+    type?: "heading" | undefined;
+    title: string;
+    description?: string;
+    callToAction?: string;
+    testId?: string;
+    namespace?: string;
+};
+export declare function axisLabelsConstants(constants: ViewConstants): {
+    y: {
+        prefix: Section<"axisLabels">;
+        postfix: Section<"axisLabels">;
+        format: Section<"axisLabels">;
+        count: Section<"axisLabels">;
+        axisTitle: Section<"axisLabels">;
+        type?: "axisLabels" | undefined;
+        title: string;
+        description?: string;
+        callToAction?: string;
+        testId?: string;
+        namespace?: string;
+    };
+    x: {
+        prefix: Section<"axisLabels">;
+        postfix: Section<"axisLabels">;
+        format: Section<"axisLabels">;
+        count: Section<"axisLabels">;
+        axisTitle: Section<"axisLabels">;
+        type?: "axisLabels" | undefined;
+        title: string;
+        description?: string;
+        callToAction?: string;
+        testId?: string;
+        namespace?: string;
+    };
+    type?: "axisLabels" | undefined;
+    title: string;
+    description?: string;
+    callToAction?: string;
+    testId?: string;
+    namespace?: string;
+};
+export declare function chartStylesConstant(constants: ViewConstants, line: boolean, bar: boolean): {
+    subSection: (Section<"curve"> | Section<"legend">)[];
+    type?: "chartStyles" | undefined;
+    title: string;
+    description?: string;
+    callToAction?: string;
+    testId?: string;
+    namespace?: string;
+} | {
+    subSection: (Section<"legend"> | Section<"stacked">)[];
+    type?: "chartStyles" | undefined;
+    title: string;
+    description?: string;
+    callToAction?: string;
+    testId?: string;
+    namespace?: string;
+};
+export declare function statsLabelsConstant(constants: ViewConstants, namespace: string): Omit<Section<'statsLabels'>, 'type'>;

package/dist/types/shared-logic/src/ComponentInterface/namespaces.d.ts

@@ -0,0 +1,3 @@
+import { Section } from '../DataPanelConfig/types';
+import { Namespace, ViewConstants } from './types/namespaces.types';
+export declare function namespace<Type>(constants: ViewConstants, namespace: Namespace): Section<Type>;

package/dist/types/shared-logic/src/ComponentInterface/setDataAttributesFromPreAggregatedDataSet.d.ts

@@ -0,0 +1,3 @@
+import { DataSet as DataSetType } from '../DataSet/types';
+import { Component } from '../Component/types';
+export declare const setDataAttributesFromPreAggregatedDataSet: <T extends Component.Attributes>(attributes: T, dataSet: DataSetType, setAttributes: (attrs: T, partial: any) => T) => T;

package/dist/types/shared-logic/src/ComponentInterface/types/ComponentInterfaceConfig.d.ts

@@ -0,0 +1,18 @@
+import { DataSet } from '../../DataSet/types';
+import { QueryEngineConfig } from '../../QueryEngineConfig/types';
+import { TextOverride } from '../../Translations/types';
+export type ComponentInterfaceConfig = {
+    queryEngineConfig: QueryEngineConfig;
+    attributesSchemaOptions?: {
+        restrictFields?: Array<{
+            id: string;
+            dataType: DataSet['fields'][number]['dataType'];
+            publicName?: string;
+            description?: DataSet['fields'][number]['description'];
+            canBeDimension: boolean;
+            canBeMeasure: boolean;
+        }>;
+        restrictDataSetIds?: string[];
+    };
+    textOverride?: TextOverride;
+};

package/dist/types/shared-logic/src/ComponentInterface/types/namespaces.types.d.ts

@@ -0,0 +1,124 @@
+export type Section<Type> = {
+    type?: Type;
+    title: string;
+    description?: string;
+    callToAction?: string;
+};
+export type ViewConstants = {
+    title: string;
+    description: string;
+    namespace: ComponentNamespace;
+    data_panel: DataPanelNamespaces;
+    format_panel: FormatPanelNamespaces;
+};
+export type SubSection<Type> = Section<Type> & {
+    namespace?: string;
+};
+type SubSectionDef = {
+    line?: SubSection<'metrics'>;
+    bar?: SubSection<'metrics'>;
+    xAxis?: SubSection<'metrics'>;
+    yAxis?: SubSection<'metrics'>;
+    zAxis?: SubSection<'metrics'>;
+};
+export type Pagination = {
+    options: number[];
+};
+export interface DataPanelNamespaces {
+    combo_chart_dimension?: Section<'comboChartDimension'>;
+    comparison?: Section<'comparison'>;
+    custom_metrics?: Section<'customMetrics'>;
+    data_set: Section<'dataSet'>;
+    dateComparison?: Section<'dateComparison'>;
+    drilldown?: Section<'drilldown'>;
+    field_columns?: Section<'fieldCollector'>;
+    field_country?: Section<'fieldCollector'>;
+    field_grouping?: Section<'fieldCollector'>;
+    field_metrics?: Section<'fieldCollector'>;
+    field_rows?: Section<'fieldCollector'>;
+    field_x_axis?: Section<'fieldCollector'>;
+    field_y_axis?: Section<'fieldCollector'>;
+    field_z_axis?: Section<'fieldCollector'>;
+    fields?: Section<'fields'>;
+    filter?: Section<'filter'>;
+    labelled_metrics?: Section<'labelledMetrics'> & {
+        subSectionDefinition: SubSectionDef;
+    };
+    limit?: Section<'limit'>;
+    pagination?: Section<'pagination'>;
+    progress_goals?: Section<'progressGoals'>;
+    sort?: Section<'sort'>;
+    views: Section<'views'>;
+}
+export type Namespace = keyof FormatPanelNamespaces | keyof DataPanelNamespaces;
+export interface FormatPanelNamespaces {
+    axis_labels?: Section<'axisLabels'> & {
+        subSectionDefinition: {
+            x: SubSection<'axisLabels'>;
+            'x.prefix': SubSection<'axisLabels'>;
+            'x.postfix': SubSection<'axisLabels'>;
+            'x.format': SubSection<'axisLabels'>;
+            'x.count': SubSection<'axisLabels'>;
+            'x.axis_title'?: SubSection<'axisLabels'>;
+            y: SubSection<'axisLabels'>;
+            'y.prefix': SubSection<'axisLabels'>;
+            'y.postfix': SubSection<'axisLabels'>;
+            'y.format': SubSection<'axisLabels'>;
+            'y.count': SubSection<'axisLabels'>;
+            'y.axis_title'?: SubSection<'axisLabels'>;
+            z?: SubSection<'axisLabels'>;
+            'z.prefix'?: SubSection<'axisLabels'>;
+            'z.postfix'?: SubSection<'axisLabels'>;
+            'z.format'?: SubSection<'axisLabels'>;
+            'z.count'?: SubSection<'axisLabels'>;
+            'z.axis_title'?: SubSection<'axisLabels'>;
+        };
+    };
+    stats_labels?: Section<'statsLabels'> & {
+        subSectionDefinition: {
+            prefix: SubSection<'statsLabels'>;
+            postfix: SubSection<'statsLabels'>;
+            format: SubSection<'statsLabels'>;
+            count: SubSection<'statsLabels'>;
+        };
+    };
+    rich_text?: Section<'richText'>;
+    heading: Section<'heading'> & {
+        subSectionDefinition: {
+            title: SubSection<'title'>;
+            subject: SubSection<'subject'>;
+        };
+    };
+    progress_type?: Section<'progressType'>;
+    chart_styles?: Section<'chartStyles'> & {
+        subSectionDefinition: {
+            stacked?: SubSection<'stacked'>;
+            legend?: SubSection<'legend'>;
+            labels?: SubSection<'labels'>;
+            curve?: SubSection<'curve'>;
+            number_format?: SubSection<'numberFormat'>;
+        };
+    };
+    format?: Section<'format'> & {
+        subSectionDefinition: {
+            time?: SubSection<'time'>;
+            font_size?: SubSection<'fontSize'>;
+            direction?: SubSection<'direction'>;
+        };
+    };
+    goal_line?: Section<'goalLine'>;
+    map_colors?: Section<'mapColors'>;
+    waterfall_colors?: Section<'waterfallColors'>;
+    headline?: Section<'headline'>;
+    trends?: Section<'trends'>;
+    prefixes?: Section<'prefixes'>;
+    conditional_formatting?: Section<'conditionalFormatting'> & {
+        subSectionDefinition?: {
+            bar: SubSection<'stacked'>;
+            line: SubSection<'stacked'>;
+        };
+    };
+    quadrants?: Section<'quadrants'>;
+}
+export type ComponentNamespace = 'area_chart' | 'bar_chart' | 'basic_table' | 'bubble_chart' | 'combo_chart' | 'custom' | 'fields' | 'funnel_chart' | 'headline' | 'horizontal_bar_chart' | 'line_chart' | 'mercator_map' | 'pie_chart' | 'sunburst_chart' | 'pivot_table' | 'progress' | 'rich_text' | 'scatter_chart' | 'single_stat' | 'waterfall_chart' | 'radar_chart';
+export {};

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

@@ -0,0 +1,45 @@
+import Joi from '@vizzly/joi';
+import { Dumpable } from '../Dumpable';
+import { DataSet } from '../DataSet/types';
+import { DataPanelConfig } from '../DataPanelConfig/types';
+import { FormatPanelConfig } from '../FormatPanelConfig/types';
+import FieldNotFoundInDataSet from '../errors/FieldNotFoundInDataSet';
+import DataSetNotFound from '../errors/DataSetNotFound';
+import CorruptedView from '../errors/CorruptedView';
+import { ComponentInterfaceConfig } from './types/ComponentInterfaceConfig';
+import { ComponentNamespace } from './types/namespaces.types';
+import { AcceptedTypes } from '../CustomField/types';
+export * from './types/ComponentInterfaceConfig';
+export interface ComponentInterface<Hydrated = any, Dumped = any> extends Dumpable<Hydrated, Dumped> {
+    title: string;
+    description: string;
+    servicesClass: string;
+    namespace: ComponentNamespace;
+    setDataAttributesFromPreAggregatedDataSet?: (attributes: Hydrated, dataSet: DataSet) => Hydrated;
+    removeField: (hydrated: Hydrated, fieldId: string) => Hydrated;
+    init: (dataSetId: string, overrides?: Partial<Hydrated>) => Hydrated;
+    setAttributes: (original: Hydrated, changes: Partial<Hydrated>) => Hydrated;
+    validate: (hydrated: Hydrated, dataSets: DataSet[]) => (CorruptedView | FieldNotFoundInDataSet | DataSetNotFound)[];
+    schema: Joi.ObjectSchema;
+    createFeedback?: (hydrated: Hydrated) => boolean | string | null;
+    isRunnable: (hydrated: Hydrated) => boolean;
+    autoGenerate: (dataSet: DataSet) => Hydrated;
+    dataPanelConfig: () => DataPanelConfig;
+    formatPanelConfig: () => FormatPanelConfig;
+    supportedCustomFields: {
+        percentages: boolean;
+        simpleMaths: boolean;
+        aggregateMaths: boolean;
+        rules: boolean;
+        roundedNumbers: boolean;
+        dateCalculations: boolean;
+        conditional: boolean;
+        customBuild: Array<AcceptedTypes> | false;
+    };
+    supportedFeatures: {
+        parameters: boolean;
+        colorGradient: boolean;
+    };
+    supportedAggregations?: Array<string>;
+}
+export type LoadComponentInterface<Hydrated, Dumped> = (config: ComponentInterfaceConfig) => ComponentInterface<Hydrated, Dumped>;

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

@@ -0,0 +1,9 @@
+import { Component } from '../Component/types';
+import * as Field from '../Field';
+type OldRules = {
+    field?: any;
+    operator?: any;
+    value?: any;
+};
+export declare const upcast: (functionsToCheck: Field.DecodingFunctionsToCheck, conditionalFormattingRules?: Array<Component.ConditionalFormatting.Rule & OldRules>) => Component.ConditionalFormatting.Rule[];
+export {};

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

@@ -0,0 +1,5 @@
+import Joi from '@vizzly/joi';
+import { QueryEngineConfig } from '../QueryEngineConfig/types';
+export declare const conditionalFormattingRuleSchema: (queryEngineConfig: QueryEngineConfig) => Joi.ObjectSchema<any>;
+export declare const prefixSchema: Joi.ObjectSchema<any>;
+export declare const conditionalFormattingRulesSchema: (queryEngineConfig: QueryEngineConfig) => Joi.ArraySchema<any[]>;

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

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

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

@@ -0,0 +1,7 @@
+import { AggregateMathField, AggregateNested } from '../../CustomField/types';
+import { Query } from '../../Query/types';
+import { QueryEngineConfig } from '../../QueryEngineConfig/types';
+import { VariableList } from '../../Variables/types';
+import { MathOperator } from '../types';
+export declare const init: (publicName: string, leftFieldId: string, leftFunction: string, operator: MathOperator, rightFieldId: string, rightFunction: string, queryEngineConfig: QueryEngineConfig, leftNested: AggregateNested | undefined, rightNested: AggregateNested | undefined) => AggregateMathField;
+export declare const build: (customField: AggregateMathField, variables: VariableList) => Query["measure"][number];

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

@@ -0,0 +1,7 @@
+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 { AliasFieldType } from '../types';
+export declare const build: (measureAttribute: QueryAttributes.Measure, customField: AliasFieldType, _queryEngineConfig: QueryEngineConfig, dataSet: DataSet, _queryHasDimension: boolean, params: Params) => Query["measure"][number];

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

@@ -0,0 +1,8 @@
+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 { ConditionalField } from '../types';
+export declare const init: (publicName: string, fieldId: string, func: string, rule: QueryAttributes.Filter[][], queryEngineConfig: QueryEngineConfig) => ConditionalField;
+export declare const build: (field: ConditionalField, queryEngineConfig: QueryEngineConfig, dataSet: DataSet, params: Params) => Query["measure"][number];

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

@@ -0,0 +1,23 @@
+import { DataSet as DataSetType } from '../DataSet/types';
+import { AggregateMathField, AliasFieldType, ConditionalField, CustomField, DateCalculationField, MetricField, PercentageField, RoundedNumberField, RulesField, SimpleMathField } from '../CustomField/types';
+import { QueryAttributes } from '../QueryAttributes/types';
+import { QueryEngineConfig } from '../QueryEngineConfig/types';
+import { Query } from '../Query/types';
+import { CustomFieldCategory } from './types';
+import { Params } from 'results-driver/src/types';
+export declare const isSimpleMathField: (field: DataSetType.Field) => field is SimpleMathField;
+export declare const isRoundedNumberField: (field: DataSetType.Field) => field is RoundedNumberField;
+export declare const isAggregateMathField: (field: DataSetType.Field) => field is AggregateMathField;
+export declare const isPercentageField: (field: DataSetType.Field) => field is PercentageField;
+export declare const isRules: (field: DataSetType.Field) => field is RulesField;
+export declare const isConditional: (field: DataSetType.Field) => field is ConditionalField;
+export declare const isCustomBuildMetric: (field: DataSetType.Field) => field is MetricField;
+export declare const isAliasField: (field: DataSetType.Field) => field is AliasFieldType;
+export declare const isDateCalculation: (field: DataSetType.Field) => field is DateCalculationField;
+export declare const getCustomFieldCategory: (field: CustomField) => CustomFieldCategory;
+export declare const isCustomField: (field: DataSetType.Field) => field is CustomField;
+/**
+ * Converts a custom field definition to
+ * a measure.
+ */
+export declare const toQueryMeasure: (measureAttribute: QueryAttributes.Measure, customField: CustomField, queryEngineConfig: QueryEngineConfig, dataSet: DataSetType, queryHasDimension: boolean, params: Params) => Query["measure"][number];

package/dist/types/shared-logic/src/CustomField/CustomMetric/build.d.ts

@@ -0,0 +1,7 @@
+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 { MetricField } from '../types';
+export declare const build: (measureAttribute: QueryAttributes.Measure, customField: MetricField, dataSet: DataSet, queryEngineConfig: QueryEngineConfig, params: Params) => Query["measure"][number];

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

@@ -0,0 +1,3 @@
+export * from './init';
+export * from './build';
+export * from './validate';

package/dist/types/shared-logic/src/CustomField/CustomMetric/init.d.ts

@@ -0,0 +1,4 @@
+import * as Types from './types';
+import { QueryEngineConfig } from '../../QueryEngineConfig/types';
+import { MetricField } from '../types';
+export declare const init: (publicName: string, metric: Types.Metric, queryEngineConfig: QueryEngineConfig) => MetricField;

package/dist/types/shared-logic/src/CustomField/CustomMetric/types.d.ts

@@ -0,0 +1,47 @@
+import { QueryAttributes } from '../../../../shared-logic/src/QueryAttributes/types';
+export declare enum PropertyType {
+    Operator = "operator",
+    IfLogic = "ifLogic",
+    NumberInput = "number",
+    Variable = "variable",
+    Field = "field",
+    Aggregate = "aggregate"
+}
+export declare enum OperatorType {
+    Divide = "/",
+    Multiply = "*",
+    Subtract = "-",
+    Add = "+"
+}
+export type NumberInput = {
+    type: PropertyType.NumberInput;
+    value: number | undefined;
+};
+export type Variable = {
+    type: PropertyType.Variable;
+    value: string;
+};
+export type Field = {
+    type: PropertyType.Field;
+    fieldId: string;
+    function: string;
+};
+export type Aggregate = {
+    type: PropertyType.Aggregate;
+    fieldId: string;
+    function?: string;
+};
+export type IfLogic = {
+    type: PropertyType.IfLogic;
+    cases: Array<{
+        filter: Array<QueryAttributes.Filter[]>;
+        returns: Operator | NumberInput | Field | Variable | IfLogic | Aggregate | undefined;
+    }>;
+    else: Operator | NumberInput | Field | Variable | IfLogic | undefined | Aggregate;
+};
+export type Operator = {
+    type: PropertyType.Operator;
+    op: OperatorType;
+    values: Array<Operator | NumberInput | Field | Variable | IfLogic | Aggregate>;
+};
+export type Metric = Operator | IfLogic | Aggregate | NumberInput | Field;

package/dist/types/shared-logic/src/CustomField/CustomMetric/validate.d.ts

@@ -0,0 +1,2 @@
+import { MetricField } from '../types';
+export declare const validate: (field: MetricField) => boolean;

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

@@ -0,0 +1,7 @@
+import { Query } from '../../Query/types';
+import { QueryAttributes } from '../../QueryAttributes/types';
+import { QueryEngineConfig } from '../../QueryEngineConfig/types';
+import { VariableList } from '../../Variables/types';
+import { DateCalculationField } from '../types';
+export declare const init: (publicName: string, leftFieldId: string, dateCalculationFunction: DateCalculationField["dateCalculationFunction"], rightFieldId: string, queryEngineConfig: QueryEngineConfig) => DateCalculationField;
+export declare const build: (measureAttribute: QueryAttributes.Measure, customField: DateCalculationField, variables: VariableList) => Query["measure"][number];

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

@@ -0,0 +1,16 @@
+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';
+import { PercentageField } from '../types';
+/**
+ * Creates a new custom percentage field.
+ */
+export declare const init: (publicName: string, denominatorFieldId: string, denominatorAggregate: string, numeratorFieldId: string | null, numeratorAggregate: string | null, numeratorFilter: QueryAttributes["filter"], denominatorFilter: QueryAttributes["filter"], queryEngineConfig: QueryEngineConfig, denominatorScope?: PercentageField["denominatorScope"]) => PercentageField;
+export declare const build: (customField: PercentageField, queryEngineConfig: QueryEngineConfig, dataSet: DataSet, _queryHasDimension: boolean, params: Params) => Query["measure"][number];
+export declare function buildPercentageFilters(customField: PercentageField, variables: VariableList): {
+    queryFilterFromNumeratorFilter: import("@vizzly/sqlbuilder-public").RecursiveFilter;
+    queryFilterFromDenominatorFilter: import("@vizzly/sqlbuilder-public").RecursiveFilter;
+};

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

@@ -0,0 +1,7 @@
+import { RoundedNumberField } from '../../CustomField/types';
+import { Query } from '../../Query/types';
+import { QueryAttributes } from '../../QueryAttributes/types';
+import { QueryEngineConfig } from '../../QueryEngineConfig/types';
+import { VariableList } from '../../Variables/types';
+export declare const init: (publicName: string, fieldId: string, roundToDecimalPlaces: 0 | 2, queryEngineConfig: QueryEngineConfig) => RoundedNumberField;
+export declare const build: (measureAttribute: QueryAttributes.Measure, customField: RoundedNumberField, variables: VariableList) => Query["measure"][number];

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

@@ -0,0 +1,10 @@
+import { Params } from 'results-driver/src/types';
+import { RulesField } from '../../CustomField/types';
+import { DataSet } from '../../DataSet/types';
+import { Query, QueryNameSpace } from '../../Query/types';
+import { QueryAttributes } from '../../QueryAttributes/types';
+import { QueryEngineConfig } from '../../QueryEngineConfig/types';
+import { Rules } from './types';
+export declare const init: (publicName: string, rules: Rules[], queryEngineConfig: QueryEngineConfig) => RulesField;
+export declare const build: (measureAttribute: QueryAttributes.Measure, customField: RulesField, queryEngineConfig: QueryEngineConfig, dataSet: DataSet, params: Params) => Query["measure"][number];
+export declare const convertToCases: (rules: Rules[], queryEngineConfig: QueryEngineConfig, dataSet: DataSet, params: Params) => QueryNameSpace.Cases[];

package/dist/types/shared-logic/src/CustomField/Rules/types.d.ts

@@ -0,0 +1,5 @@
+import { QueryAttributes } from '../../QueryAttributes/types';
+export type Rules = {
+    name: string;
+    rule: QueryAttributes.Filter[][];
+};

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

@@ -0,0 +1,11 @@
+import { SimpleMathField } from '../../CustomField/types';
+import { Query, QueryNameSpace } from '../../Query/types';
+import { QueryAttributes } from '../../QueryAttributes/types';
+import { QueryEngineConfig } from '../../QueryEngineConfig/types';
+import { MathOperator } from '../types';
+import { DataSet } from '../../DataSet/types';
+import { Params } from 'results-driver/src/types';
+import { VariableList } from '../../Variables/types';
+export declare const init: (publicName: string, leftFieldId: string, operator: MathOperator, rightFieldId: string, queryEngineConfig: QueryEngineConfig) => SimpleMathField;
+export declare const build: (measureAttribute: QueryAttributes.Measure, customField: SimpleMathField, dataSet: DataSet, params: Params) => Query["measure"][number];
+export declare const buildSide: (value: string, dataSet: DataSet, variables: VariableList) => QueryNameSpace.FieldDefinition;

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

@@ -0,0 +1,15 @@
+import { Clause } from '../Filter/types';
+export declare const alwaysTrueFilter: {
+    type: Clause.AND_WHERE;
+    value: {
+        type: Clause.WHERE;
+        value: {
+            field: {
+                type: "number";
+                value: number;
+            };
+            op: string;
+            value: number;
+        };
+    }[];
+};

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

@@ -0,0 +1,10 @@
+export * from './CustomField';
+export * as Percentage from './Percentage';
+export * as SimpleMath from './SimpleMath';
+export * as AggregateMath from './AggregateMath';
+export * as Rules from './Rules';
+export * as RoundedNumber from './RoundedNumber';
+export * as DateCalculation from './DateCalculation';
+export * as Conditional from './Conditional';
+export * as CustomMetric from './CustomMetric';
+export * from './upcast';

package/dist/types/shared-logic/src/CustomField/metricValuesHaveAggregates.d.ts

@@ -0,0 +1,2 @@
+import { Aggregate, IfLogic, NumberInput, Operator, Field as FieldMetric, Variable } from './CustomMetric/types';
+export declare function metricValuesHaveAggregates(values: (Operator | IfLogic | Aggregate | NumberInput | FieldMetric | Variable)[] | undefined): boolean;

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

@@ -0,0 +1,88 @@
+import { QueryAttributes } from '../QueryAttributes/types';
+import { BaseField, DataType, NonDateTimeField } from '../Field/types';
+import { Rules } from './Rules/types';
+import { Metric } from './CustomMetric/types';
+type BaseCustomField = Omit<NonDateTimeField, 'dashboardFilterGroups'>;
+type SimpleMath = {
+    leftFieldId: string;
+    operator: MathOperator;
+    rightFieldId: string;
+};
+type RoundedNumber = {
+    roundToDecimalPlaces: 0 | 2;
+    fieldId: string;
+};
+export type Conditional = {
+    fieldId: string;
+    function: string;
+    rule: QueryAttributes.Filter[][];
+};
+export type Percentage = {
+    version: 2;
+    denominatorFieldId: string;
+    denominatorAggregate: string;
+    numeratorFieldId?: string | null;
+    numeratorAggregate?: string | null;
+    denominatorScope?: 'all' | 'withinGrouping';
+    numeratorFilter?: QueryAttributes['filter'];
+    denominatorFilter?: QueryAttributes['filter'];
+    dataType: DataType;
+};
+export type AggregateNested = {
+    operator: MathOperator;
+    fieldId: string;
+    /** @deprecated ignore this outside of upcasting */
+    aggregate?: string;
+    function: string;
+};
+export type AggregateMath = {
+    leftFieldId: string;
+    leftFunction: string;
+    leftNested?: AggregateNested;
+    operator: MathOperator;
+    rightFieldId: string;
+    rightFunction: string;
+    rightNested?: AggregateNested;
+    /** @deprecated ignore this outside of upcasting */
+    leftAggregate?: string;
+    /** @deprecated ignore this outside of upcasting */
+    rightAggregate?: string;
+};
+export type DateCalculation = {
+    leftFieldId: string;
+    rightFieldId: string;
+    dateCalculationFunction: 'seconds_between' | 'minutes_between' | 'hours_between' | 'days_between';
+};
+export type PercentageField = BaseCustomField & Percentage;
+export type RoundedNumberField = BaseCustomField & RoundedNumber;
+export type DateCalculationField = BaseCustomField & DateCalculation;
+export type AggregateMathField = BaseCustomField & AggregateMath;
+export type ConditionalField = BaseCustomField & Conditional;
+export type AliasFieldType = BaseCustomField & {
+    allowedFields: Array<{
+        id: string;
+    }>;
+};
+export type MetricField = BaseCustomField & {
+    metric: Metric;
+};
+export type SimpleMathField = BaseCustomField & SimpleMath & {
+    dataType: 'number';
+};
+export type RulesField = BaseField & {
+    rules: Rules[];
+    dataType: 'string' | 'number';
+};
+export type CustomBuildMetricField = BaseField & {
+    metricAttributes: Metric;
+    dataType: 'number';
+};
+export type CustomField = PercentageField | SimpleMathField | AggregateMathField | RulesField | RoundedNumberField | DateCalculationField | ConditionalField | MetricField | CustomBuildMetricField | AliasFieldType;
+export type MathOperator = '*' | '-' | '/' | '+';
+export type CustomFieldCategory = 'percentage' | 'math' | 'rules' | 'roundedNumber' | 'dateCalculation' | 'conditional' | 'customBuildMetric';
+export declare enum AcceptedTypes {
+    Maths = "maths",
+    IfStatement = "ifStatement",
+    Aggregates = "aggregates"
+}
+export {};

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

@@ -0,0 +1,2 @@
+import { CustomField } from '../CustomField/types';
+export declare const upcast: (maybeOldCustomField: CustomField) => CustomField;

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

@@ -0,0 +1,5 @@
+import { Component } from '../Component/types';
+import { LoadComponentInterface } from '../ComponentInterface/types';
+import { DumpedCustomViewAttributes } from './types';
+declare const CustomChart: LoadComponentInterface<Component.CustomViewAttributes, DumpedCustomViewAttributes>;
+export default CustomChart;