@vizzly/services 0.7.1 → 0.7.2-dev-dba36cbd0af6b3bcb07804673072c6fb5fb27a1f

package/dist/services/src/Services/DashboardServices.d.ts

@@ -1,3 +1,4 @@
+import * as DashboardTypes from '../../../shared-logic/src/Dashboard/types';
 import { Row } from './RowServices';
 import { CustomField } from '../../../shared-logic/src/CustomField/types';
 import { Header } from './HeaderServices';
@@ -50,5 +51,5 @@ export declare class Dashboard<T> {
      * Builds a partial DashboardType object.
      * @returns A partial DashboardType object.
      */
-    build: () => T;
+    build(): DashboardTypes.SaveableDashboardDefinition;
 }

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

@@ -1,12 +1,31 @@
-type MessageHistory = Array<{
+export declare enum SenderType {
+    User = "user",
+    AI = "ai"
+}
+export declare enum MessageState {
+    WaitingForMessage = "waitingForMessage",
+    Thinking = "thinking"
+}
+export declare enum AIReaction {
+    ThumbsUp = "thumbs_up",
+    ThumbsDown = "thumbs_down"
+}
+export type Message = {
     content: string;
-    sender_type: 'user' | 'ai';
+    sender_type: SenderType;
     status: 'active';
-}>;
+    id: string;
+    sent_at: Date;
+    reaction: AIReaction | null;
+};
 export type ConversationState = {
     message: string;
     conversationId: string | undefined;
-    messageState: 'waitingForMessage' | 'thinking';
-    messageHistory: MessageHistory;
+    messageState: MessageState;
+    messageHistory: Message[];
 };
-export {};
+export declare enum AIFeedback {
+    Warning = "warning",
+    Critical = "critical",
+    Info = "info"
+}

package/dist/shared-logic/src/AdditionalFilter/AdditionalFilter.d.ts

@@ -3,14 +3,15 @@ import { QueryAttributes } from '../QueryAttributes/types';
 import { AdditionalFilter, TimeRangeOptions, FilterConfig, OptionalFilters } from './types';
 import { DataSet } from '../DataSet/types';
 import { DateTimeFilterOptions } from '../DateTime/types';
-export declare const typeToString: (type: AdditionalFilter['type']) => string;
+import { TextOverride } from '../Translations/types';
+export declare const typeToString: (type: AdditionalFilter['type'], textOverride: TextOverride) => string;
 export declare const allowedDataTypesForFilter: (type: AdditionalFilter['type']) => Array<DataType>;
 export declare const dump: (hydrated: AdditionalFilter) => AdditionalFilter;
-export declare const load: (dumped: AdditionalFilter) => AdditionalFilter;
+export declare const load: (dumped: AdditionalFilter, componentInterfaceConfig?: import("../ComponentInterface/types").ComponentInterfaceConfig | undefined) => AdditionalFilter;
 export declare const toQueryAttributesFilter: (dataSet: DataSet, filter: AdditionalFilter, customTimeRangeFuncs: TimeRangeOptions) => QueryAttributes.Filter[];
 export declare const fromFilterConfig: (filterConfig: FilterConfig, dataSet: DataSet, timeRangeOptions: TimeRangeOptions) => QueryAttributes.Filter[];
 export declare const hasActiveFilter: (additionalFilters: AdditionalFilter[]) => boolean;
-export declare const getTitle: (additionalFilter: AdditionalFilter, dataSets: DataSet[]) => string;
+export declare const getTitle: (additionalFilter: AdditionalFilter, dataSets: DataSet[], textOverride?: TextOverride) => string;
 export declare const requiredFiltersAreSet: (filter: AdditionalFilter | AdditionalFilter[]) => boolean;
 export declare const isReady: (additionalFilter: AdditionalFilter) => boolean;
 /**

package/dist/shared-logic/src/Aggregate/constants.d.ts

@@ -0,0 +1,26 @@
+export declare const supportedAggregatesConstants: {
+    mean: {
+        publicName: string;
+        validDataTypes: string[];
+    };
+    sum: {
+        publicName: string;
+        validDataTypes: string[];
+    };
+    min: {
+        publicName: string;
+        validDataTypes: string[];
+    };
+    max: {
+        publicName: string;
+        validDataTypes: string[];
+    };
+    count: {
+        publicName: string;
+        validDataTypes: string[];
+    };
+    countDistinct: {
+        publicName: string;
+        validDataTypes: string[];
+    };
+};

package/dist/shared-logic/src/AreaChart/constants.d.ts

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

package/dist/shared-logic/src/BarChart/constants.d.ts

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

package/dist/shared-logic/src/BasicTable/constants.d.ts

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

package/dist/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/shared-logic/src/Component/sharedSchemas.d.ts

@@ -2,15 +2,16 @@ import Joi from '@vizzly/joi';
 import { SupportedAggregates } from '../Aggregate';
 import { QueryEngineConfig } from '../QueryEngineConfig/types';
 import { SupportedTimeTruncFunctions } from '../TimeDimension/types';
+import { ComponentInterfaceConfig } from '../ComponentInterface/types';
 export declare const additionalFilterSchema: (queryEngineConfig: QueryEngineConfig, shouldAlwaysHaveValue?: boolean) => Joi.Schema;
-export declare const measureSchema: (supportedAggregates: SupportedAggregates) => Joi.ObjectSchema<any>;
+export declare const measureSchema: (supportedAggregates: SupportedAggregates, attributeSchemaOptions: ComponentInterfaceConfig['attributesSchemaOptions']) => Joi.ObjectSchema<any> | Joi.AlternativesSchema<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) => Joi.ArraySchema<any[]>;
+export declare const dimensionSchema: (supportedTimeTruncFunctions: SupportedTimeTruncFunctions, attributeSchemaOptions: ComponentInterfaceConfig['attributesSchemaOptions']) => Joi.ArraySchema<any[]>;
 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: {
+export declare const baseAttributesSchema: (attributeSchemaOptions: ComponentInterfaceConfig['attributesSchemaOptions']) => {
     viewId: Joi.StringSchema<string>;
     displayTitle: Joi.StringSchema<string>;
     displaySubject: Joi.StringSchema<string>;
@@ -18,7 +19,7 @@ export declare const baseAttributesSchema: {
     protectedByOrganisation: Joi.BooleanSchema<boolean>;
 };
 export declare const approxAxisLabelCountSchema: Joi.AnySchema<any>;
-export declare const timeDimensionQuerySchema: (queryEngineConfig: QueryEngineConfig) => {
+export declare const timeDimensionQuerySchema: (queryEngineConfig: QueryEngineConfig, attributeSchemaOptions: ComponentInterfaceConfig['attributesSchemaOptions']) => {
     measure: Joi.ArraySchema<any[]>;
     dimension: Joi.ArraySchema<any[]>;
     drilldown: Joi.AlternativesSchema<string | any[]>;
@@ -39,7 +40,7 @@ export declare const timeDimensionQuerySchema: (queryEngineConfig: QueryEngineCo
 export declare const lineCurveSchema: 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) => Joi.ObjectSchema<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 axisTitleSchema: () => Joi.ObjectSchema<any>;

package/dist/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 | undefined;
+    callToAction?: string | undefined;
+    testId?: string | undefined;
+    namespace?: string | undefined;
+};
+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 | undefined;
+        callToAction?: string | undefined;
+        testId?: string | undefined;
+        namespace?: string | undefined;
+    };
+    x: {
+        prefix: Section<"axisLabels">;
+        postfix: Section<"axisLabels">;
+        format: Section<"axisLabels">;
+        count: Section<"axisLabels">;
+        axisTitle: Section<"axisLabels">;
+        type?: "axisLabels" | undefined;
+        title: string;
+        description?: string | undefined;
+        callToAction?: string | undefined;
+        testId?: string | undefined;
+        namespace?: string | undefined;
+    };
+    type?: "axisLabels" | undefined;
+    title: string;
+    description?: string | undefined;
+    callToAction?: string | undefined;
+    testId?: string | undefined;
+    namespace?: string | undefined;
+};
+export declare function chartStylesConstant(constants: ViewConstants, line: boolean, bar: boolean): {
+    subSection: (Section<"curve"> | Section<"legend">)[];
+    type?: "chartStyles" | undefined;
+    title: string;
+    description?: string | undefined;
+    callToAction?: string | undefined;
+    testId?: string | undefined;
+    namespace?: string | undefined;
+} | {
+    subSection: (Section<"legend"> | Section<"stacked">)[];
+    type?: "chartStyles" | undefined;
+    title: string;
+    description?: string | undefined;
+    callToAction?: string | undefined;
+    testId?: string | undefined;
+    namespace?: string | undefined;
+};
+export declare function statsLabelsConstant(constants: ViewConstants, namespace: string): Omit<Section<'statsLabels'>, 'type'>;

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

@@ -0,0 +1,104 @@
+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'>;
+};
+export interface DataPanelNamespaces {
+    data_set: Section<'dataSet'>;
+    views: Section<'views'>;
+    fields?: Section<'fields'>;
+    field_y_axis?: Section<'fieldCollector'>;
+    field_rows?: Section<'fieldCollector'>;
+    field_columns?: Section<'fieldCollector'>;
+    field_metrics?: Section<'fieldCollector'>;
+    field_grouping?: Section<'fieldCollector'>;
+    progress_goals?: Section<'progressGoals'>;
+    drilldown?: Section<'drilldown'>;
+    field_x_axis?: Section<'fieldCollector'>;
+    field_country?: Section<'fieldCollector'>;
+    sort?: Section<'sort'>;
+    filter: Section<'filter'>;
+    custom_metrics: Section<'customMetrics'>;
+    limit?: Section<'limit'>;
+    pagination?: Section<'pagination'>;
+    combo_chart_dimension?: Section<'comboChartDimension'>;
+    comparison?: Section<'comparison'>;
+    labelled_metrics?: Section<'labelledMetrics'> & {
+        subSectionDefinition: SubSectionDef;
+    };
+}
+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'>;
+        };
+    };
+    stats_labels?: Section<'statsLabels'> & {
+        subSectionDefinition: {
+            prefix: SubSection<'statsLabels'>;
+            postfix: SubSection<'statsLabels'>;
+            format: SubSection<'statsLabels'>;
+            count: SubSection<'statsLabels'>;
+        };
+    };
+    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'>;
+            curve?: SubSection<'curve'>;
+            number_format?: SubSection<'numberFormat'>;
+        };
+    };
+    format?: Section<'format'> & {
+        subSectionDefinition: {
+            time?: SubSection<'time'>;
+            font_size?: SubSection<'fontSize'>;
+        };
+    };
+    goal_line?: Section<'goalLine'>;
+    map_colors?: Section<'mapColors'>;
+    prefixes?: Section<'prefixes'>;
+    conditional_formatting?: Section<'conditionalFormatting'> & {
+        subSectionDefinition?: {
+            bar: SubSection<'stacked'>;
+        };
+    };
+}
+export type ComponentNamespace = 'pivot_table' | 'horizontal_bar_chart' | 'bar_chart' | 'area_chart' | 'line_chart' | 'scatter_chart' | 'pie_chart' | 'single_stat' | 'basic_table' | 'combo_chart' | 'mercator_map' | 'custom' | 'fields' | 'progress';
+export {};

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

@@ -1,19 +1,19 @@
 import Joi from '@vizzly/joi';
 import { Dumpable } from '../Dumpable';
-import { QueryEngineConfig } from '../QueryEngineConfig/types';
 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';
-export type ComponentInterfaceConfig = {
-    queryEngineConfig: QueryEngineConfig;
-};
+import { ComponentInterfaceConfig } from './types/ComponentInterfaceConfig';
+import { ComponentNamespace } from './types/namespaces.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;

package/dist/shared-logic/src/Dashboard/fromRaw.d.ts

@@ -1,6 +1,7 @@
 import { StoredTheme } from '../Theme/types';
 import { Dashboard, SaveableDashboardDefinition } from './types';
 import { PartialBy } from '../typeHelpers';
+import { QueryEngineConfig } from '../QueryEngineConfig/types';
 export type RawDefinition = PartialBy<SaveableDashboardDefinition, 'isPlayground' | 'customFields'>;
 export type RawDashboard<Definition = RawDefinition> = {
     id: string;
@@ -14,4 +15,4 @@ export type RawDashboard<Definition = RawDefinition> = {
     metadata?: Dashboard.ExternalMetadata;
     webhook_id: string | null;
 };
-export declare const fromRaw: (rawDashboard: RawDashboard) => Omit<Dashboard, 'dataSets'>;
+export declare const fromRaw: (rawDashboard: RawDashboard, queryEngineConfig: QueryEngineConfig | undefined) => Omit<Dashboard, 'dataSets'>;

package/dist/shared-logic/src/DashboardAPI/dashboardAPI/creating.d.ts

@@ -5,10 +5,11 @@ import { IdentityConfig as IdentityConfigType } from 'shared-logic/src/IdentityC
 import { CreateDashboardParams } from '../../api/vizzly/createDashboard';
 import { DashboardPermission as DashboardPermissionType, RawDashboardPermission } from 'shared-logic/src/DashboardPermission/types';
 import { DashboardStorageStrategy } from '../types';
+import { QueryEngineConfig } from '../../QueryEngineConfig/types';
 export declare function prepareCreateResponseForAdding(createdDashboardResponse: {
     dashboard: Dashboard.RawDashboard;
     permissions: RawDashboardPermission[];
-}, dataSets: DataSet[]): {
+}, dataSets: DataSet[], queryEngineConfig: QueryEngineConfig | undefined): {
     createdDashboard: Dashboard.Dashboard;
     formattedPermissions: DashboardPermissionType[];
 };

package/dist/shared-logic/src/DashboardAPI/dashboardAPI/updating.d.ts

@@ -4,13 +4,14 @@ import * as Dashboard from 'shared-logic/src/Dashboard';
 import { api } from '../../api';
 import { UnEncryptedDashboardUpdateResponse, UpdateDashboardParams } from '../../api/vizzly/updateDashboard';
 import { DashboardStorageStrategy } from '../types';
+import { QueryEngineConfig } from '../../QueryEngineConfig/types';
 export declare function postUpdateDashboard(dashboardStorageStrategy: DashboardStorageStrategy, vizzlyAPI: ReturnType<typeof api>, updateParams: {
     dashboardSessionToken: string;
     definition?: Dashboard.SaveableDashboardDefinition;
     meta?: any;
     deleted?: boolean;
 }): Promise<UnEncryptedDashboardUpdateResponse>;
-export declare function updateDashboardFromUpdateResponse(updatedDashboardResponse: UnEncryptedDashboardUpdateResponse, dataSets: DataSet[], dashboards: DashboardType[], params: Omit<UpdateDashboardParams, 'dashboardSessionToken'>): {
+export declare function updateDashboardFromUpdateResponse(updatedDashboardResponse: UnEncryptedDashboardUpdateResponse, dataSets: DataSet[], dashboards: DashboardType[], params: Omit<UpdateDashboardParams, 'dashboardSessionToken'>, queryEngineConfig: QueryEngineConfig | undefined): {
     newDashboards: DashboardType[];
     updatedDashboard: DashboardType;
 };

package/dist/shared-logic/src/DashboardAPI/dashboardAPI.d.ts

@@ -9,7 +9,7 @@ export * from './dashboardAPI/creating';
 export * from './dashboardAPI/updating';
 export declare function getDashboards<T extends {
     found?: any[];
-}>(dashboardsResponse: T, dataSets: DataSet[]): DashboardType[];
+}>(dashboardsResponse: T, dataSets: DataSet[], queryEngineConfig: QueryEngineConfig | undefined): DashboardType[];
 export declare function fetchDashboards(dashboardStorageStrategy: DashboardStorageStrategy, vizzlyAPI: ReturnType<typeof api>, dashboardAccessTokens: string[], abortController: AbortController): Promise<import("../api/vizzly/multiGetDashboards").Response>;
 export declare const DEFAULT_STRATEGY: DashboardStorageStrategy;
 export declare const getDashboardStorageStrategy: (queryEngineEndpoint: Function | QueryEngineEndpoint | undefined, queryEngineConfig: QueryEngineConfig | undefined) => DashboardStorageStrategy;

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

@@ -1,10 +1,9 @@
 import { DataSet, FieldFilterOptions } from '../DataSet/types';
 import { QueryAttributes } from '../QueryAttributes/types';
-export type Section<Type> = {
-    type: Type;
-    title: string;
-    description: string;
+import { Section as ConstSection } from '../ComponentInterface/types/namespaces.types';
+export type Section<Type> = ConstSection<Type> & {
     testId?: string;
+    namespace?: string;
 };
 type MetricOptions = {
     allowsMultiple?: boolean;
@@ -28,7 +27,7 @@ export type DimensionSection = Section<'dimension'> & {
     filterFieldOptions?: FieldFilterOptions;
 };
 export type LabelledMetricSection = Section<'labelledMetrics'> & {
-    metrics: Array<MetricOptions & {
+    subSection: Array<MetricOptions & {
         title: string;
     }>;
 };

package/dist/shared-logic/src/DataSet/DataSet.d.ts

@@ -11,7 +11,11 @@ import { RawDashboard } from '../Dashboard';
 export declare const find: <T extends {
     id: string;
 }>(dataSets: T[], dataSetId: string) => T | null;
+export declare const findByName: <T extends {
+    name: string;
+}>(dataSets: T[], dataSetName: string) => T | null;
 export declare const findField: (dataSet: DataSet, id: string) => DataSet.Field;
+export declare const findFieldByName: (dataSet: DataSet, name: string) => DataSet.Field;
 export declare const findDataSet: (dataSets: DataSet[], dataSetId: string) => [DataSet | null, number];
 export declare const upcastDataSet: (rawDataSet: any, queryEngineConfig: QueryEngineConfig) => DataSet;
 export declare const upcastDataSets: (rawDataSet: any[], queryEngineConfig: QueryEngineConfig) => DataSet[];
@@ -40,3 +44,4 @@ export declare const buildQueryAttributes: (dataSet: DataSet, queryEngineConfig:
 export declare const buildDownloadQuery: (dataSet: DataSet, maxCSVDownloadLimit: number, viewFilters: QueryAttributes['filter']) => QueryAttributes;
 export declare const buildViewOnlyQuery: (dataSet: DataSet) => QueryAttributes;
 export declare const addCustomFields: (dataSets: Array<DataSet>, customFields: RawDashboard['definition']['customFields']) => Array<DataSet>;
+export declare const validId: (id: string, dataSet: DataSet[]) => boolean;

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

@@ -7,6 +7,7 @@ export declare namespace DataSet {
 export type DataSet = {
     id: string;
     name: string;
+    description?: string;
     fields: DataSet.Field[];
     preAggregated?: boolean;
 };

package/dist/shared-logic/src/DataTable/constants.d.ts

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

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

@@ -7,7 +7,7 @@ export declare const insertRow: (display: Display, rowIndex: number, height?: nu
 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 addHeaderRow: (display: Display, rowIndex: number) => Display;
+export declare const addHeaderRow: (display: Display, rowIndex: number, initialTitle: string) => Display;
 export declare const setComponent: (display: Display, component: Component | EmptyCell | HeaderComponent, rowIndex: number, cellIndex: number) => Display;
 type Move = {
     rowIndex: number;
@@ -16,7 +16,7 @@ type Move = {
 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 initHeaderComponent: () => HeaderComponent;
+export declare const initHeaderComponent: (displayTitle: string) => HeaderComponent;
 export declare const listComponentTypesUsed: (display: Display) => ComponentType[];
 export declare const isComponentEmpty: (component: Component | EmptyCell | HeaderComponent) => component is EmptyCell;
 export declare const isHeaderComponent: (component: Component.RawComponent | EmptyCell | HeaderComponent | MaybeOldComponent) => component is HeaderComponent;

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

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

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

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

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

@@ -3,6 +3,7 @@ import { DateTimeField, NonDateTimeField, SupportedAggregateOption } from '../Fi
 import { DataType } from './types';
 import { QueryAttributes, SupportedOperators } from '../QueryAttributes/types';
 import * as Aggregate from '../Aggregate';
+import { SupportedAggregates } from '../Aggregate';
 import { SupportedTimeTruncFunctions } from '../TimeDimension/types';
 import { QueryEngineConfig } from '../QueryEngineConfig/types';
 import { SupportedTransformationFunctions } from '../Functions/types';
@@ -21,7 +22,9 @@ export type OldField = {
     }>;
     supportedAggregateOptions?: string[];
 };
-export declare const upcastField: (maybeOldField: OldField, queryEngineConfig: QueryEngineConfig) => DateTimeField | NonDateTimeField;
+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;
@@ -80,9 +83,9 @@ export declare const getQueryFieldIdFromResultFieldId: (fieldIdOrDatumKey: strin
     fieldId: string;
     function: QueryAttributes.Aggregate;
 };
-export declare function supportedFunctionsToSelectOptions<T>(field: {
+export declare const listValidFunctionsForDataType: (field: {
     dataType: DataType;
-}, supportedTransformationFunctions: SupportedTransformationFunctions[]): T[];
+}, supportedTransformationFunctions: SupportedTransformationFunctions | SupportedAggregates) => string[];
 export declare const removeField: <T extends {
     id: string;
 }>(originalFields: T[], removeFields: (QueryAttributes.Dimension | QueryAttributes.Measure)[]) => T[];

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

@@ -9,6 +9,7 @@ type DashboardRequiredFilterGroup = {
 export type BaseField = {
     id: string;
     publicName: string;
+    description?: string;
     canBeDimension: boolean;
     canBeMeasure: boolean;
     allowedOperators: Array<QueryAttributes.Operator>;

package/dist/shared-logic/src/HorizontalBarChart/constants.d.ts

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

package/dist/shared-logic/src/LineChart/constants.d.ts

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

package/dist/shared-logic/src/MercatorMap/constants.d.ts

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

package/dist/shared-logic/src/PieChart/constants.d.ts

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

package/dist/shared-logic/src/Progress/constants.d.ts

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

package/dist/shared-logic/src/QueryAttributes/QueryAttributes.d.ts

@@ -2,10 +2,11 @@ import { DataType } from '../Field/types';
 import { QueryAttributes, SupportedOperators } from './types';
 import { QueryEngineConfig } from '../QueryEngineConfig/types';
 import { ApproxAxisLabelCount, Component } from '../Component/types';
+import { TextOverride } from '../Translations/types';
 export declare const validOperatorsForField: (field: {
     dataType: DataType;
 }, queryEngineConfig: QueryEngineConfig) => string[];
-export declare const aggregateName: (func: QueryAttributes.Aggregate) => string;
+export declare const aggregateName: (func: QueryAttributes.Aggregate, textOverride: TextOverride) => string;
 declare const vizzlyManagedOperators: SupportedOperators;
 export declare const supportedOperators: (keys?: Array<string>) => SupportedOperators;
 export declare const operatorToString: (operator: QueryAttributes.Operator) => string;