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

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;

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

@@ -0,0 +1,29 @@
+import { FilterConfig } from '../AdditionalFilter/types';
+import { Component } from '../Component/types';
+export type CustomView = StaticCustomView | SelectableCustomView;
+export type CustomViewCallbackParams = {
+    attributes?: Component.CustomViewAttributes;
+    filterConfig: FilterConfig;
+};
+export type BaseCustomView = {
+    id: string;
+};
+export type StaticCustomView = BaseCustomView & {
+    rowIndex: number;
+    cellIndex: number;
+    Component: (params: CustomViewCallbackParams) => JSX.Element | string;
+    options?: {
+        disableAddCell?: boolean;
+        raw?: boolean;
+    };
+    attributes?: {
+        displayTitle?: string;
+        displaySubject?: string;
+    };
+};
+export type SelectableCustomView = BaseCustomView & {
+    title: string;
+    Icon: () => JSX.Element;
+    Component: (params: CustomViewCallbackParams) => JSX.Element | string;
+};
+export type DumpedCustomViewAttributes = Component.CustomViewAttributes;

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

@@ -0,0 +1,39 @@
+import { Component as ComponentType } from '../Component/types';
+import { DataSet } from '../DataSet/types';
+import { CustomField } from '../CustomField/types';
+import { Dashboard, SaveableDashboardDefinition, ImportableDashboard } from './types';
+import { FieldUsage } from '@vizzly/api-client';
+export * from './saveableDashboardDefinitionSchema';
+export * from './fromRaw';
+export declare const indexOfDataSet: (dashboard: Dashboard, dataSetId: string) => number;
+export declare const getDataSet: (dashboard: Dashboard, dataSetId: string) => DataSet | null;
+export declare const hasDataSet: (dashboard: Dashboard, dataSetId: string) => boolean;
+export declare const getComponentsUsingDataSet: (dashboard: Dashboard, dataSetId: string) => ComponentType[];
+export declare const toSaveableDefinition: (dashboard: Dashboard) => SaveableDashboardDefinition;
+export declare const prepareDashboardForImport: (dashboardToImport: Dashboard | ImportableDashboard) => ImportableDashboard;
+export declare const mergeDashboardInStateAndDashboardToImport: ({ dashboardToImport, dashboardInState, }: {
+    dashboardToImport: ImportableDashboard;
+    dashboardInState: Dashboard;
+}) => Dashboard;
+export declare const setDataSets: (dashboardWithoutDataSets: Omit<Dashboard, "dataSets">, dataSets: DataSet[], customFields: {
+    [dataSetId: string]: CustomField[];
+}) => Dashboard;
+export declare const newSaveable: (overrides: Partial<SaveableDashboardDefinition>) => SaveableDashboardDefinition;
+export declare const takePlaygroundDashboards: (dashboards: Dashboard[]) => Dashboard[];
+export declare const takeLiveDashboards: (dashboards: Dashboard[]) => Dashboard[];
+export declare const getDataSetsUsedOnDisplay: (dashboard: Dashboard) => Array<DataSet>;
+export declare const getDataSetsUsedOnDashboard: (dashboard: Dashboard) => Array<DataSet>;
+export declare const getCopiesOfParentDashboard: (parentDashboardId: string, dashboards: Dashboard[]) => Dashboard[];
+export declare const getParentDashboards: (dashboards: Dashboard[]) => Dashboard[];
+export declare const getFirstCreated: (dashboards: Dashboard[]) => Dashboard;
+export declare const orderByLastUpdated: (dashboards: Dashboard[]) => Dashboard[];
+export declare const takeMostRecentlyUpdated: (dashboards: Dashboard[]) => Dashboard | null;
+export declare const find: (dashboards: Dashboard[], dashboardId: string) => Dashboard | null;
+export declare const updateLibraryWithProtectedComponents: (dashboards: Dashboard[]) => Dashboard[];
+export declare function resetToParentDashboard(dashboard: Dashboard, dashboards: Dashboard[], parentDashboardId: string): Dashboard;
+export declare const buildProgrammaticDashboard: (programaticDashboards: Partial<SaveableDashboardDefinition>[], dataSets: DataSet[]) => Dashboard[];
+export declare const VIZZLY_EDITOR_ID = "vizzly_editor";
+export declare function updateWithProgrammaticDashboard(allDashboards: Dashboard[], programmaticDashboards: Dashboard[]): Dashboard[];
+export declare const addUniqueLibraryComponents: (programmaticLibrary: ComponentType[], dashboardLibrary: ComponentType[]) => ComponentType[];
+export declare const checkAndReturnProgrammaticDashboardId: (dashboards: Dashboard[]) => string | undefined;
+export declare const getFieldUsage: (dashboardDefinition: SaveableDashboardDefinition, dataSets: DataSet[]) => FieldUsage;

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

@@ -0,0 +1,23 @@
+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;
+    parent_dashboard_id: string;
+    definition: Definition;
+    name?: string | null;
+    theme: StoredTheme & {
+        rowLimit?: number;
+    };
+    created_at: string;
+    updated_at: string;
+    metadata?: Dashboard.ExternalMetadata;
+    webhook_id: string | null;
+    permission: {
+        scope: 'read' | 'read_write';
+        token: string;
+    };
+};
+export declare const fromRaw: (rawDashboard: RawDashboard, queryEngineConfig: QueryEngineConfig | undefined) => Omit<Dashboard, "dataSets">;

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

@@ -0,0 +1,2 @@
+export * from './Dashboard';
+export * from './types';

package/dist/types/shared-logic/src/Dashboard/saveableDashboardDefinitionSchema.d.ts

@@ -0,0 +1,5 @@
+import Joi from '@vizzly/joi';
+import { QueryEngineConfig } from '../QueryEngineConfig/types';
+export declare const colSpanSchema: Joi.NumberSchema<number>;
+export declare const saveableDashboardDefinitionSchema: (queryEngineConfig: QueryEngineConfig) => Joi.ObjectSchema<any>;
+export declare function displaySchema(queryEngineConfig: QueryEngineConfig): Joi.ArraySchema<any[]>;

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

@@ -0,0 +1,50 @@
+import { AdditionalFilter } from '../AdditionalFilter/types';
+import { Component } from '../Component/types';
+import { DataSet } from '../DataSet/types';
+import { CustomField } from '../CustomField/types';
+import { Display, DisplayDumped } from '../Display/types';
+import { StoredTheme } from '../Theme/types';
+export type WebParentDashboard = Pick<Dashboard, 'id' | 'webhookId' | 'createdAt' | 'updatedAt'>;
+export declare namespace Dashboard {
+    type ExternalMetadata = {
+        [key: string]: string | number;
+    };
+}
+export type Dashboard = {
+    id: string;
+    name?: string | null;
+    parentDashboardId: string | null;
+    metadata: Dashboard.ExternalMetadata;
+    /**
+     * @deprecated
+     */
+    theme: StoredTheme;
+    display: Display;
+    webhookId: string | null;
+    componentLibrary: Component[];
+    dataSets: DataSet[];
+    globalFilters: AdditionalFilter[];
+    /** @deprecated */
+    isPlayground: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    /** @deprecated */
+    protectedByOrganisation?: boolean;
+    isProgrammatic?: boolean;
+    permission?: {
+        scope: 'read' | 'read_write';
+        token: string;
+    };
+};
+export type SaveableDashboardDefinition = {
+    display: DisplayDumped;
+    componentLibrary: Component.RawComponent[];
+    globalFilters: Array<AdditionalFilter>;
+    isPlayground: boolean;
+    customFields: {
+        [dataSetId: string]: Array<CustomField>;
+    };
+    project_id?: string;
+    id?: string;
+};
+export type ImportableDashboard = Omit<Dashboard, 'id' | 'parentDashboardId' | 'webhookId' | 'createdAt' | 'updatedAt' | 'isProgrammatic' | 'theme' | 'data' | 'permission' | 'protectedByOrganisation' | 'isPlayground'>;

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

@@ -0,0 +1,7 @@
+import { Dashboard as DashboardType } from '../Dashboard/types';
+import { QueryEngineConfig, QueryEngineEndpoint } from '../QueryEngineConfig/types';
+import { IdentityConfig as IdentityConfigType } from '../IdentityConfig/types';
+import { DashboardStorageStrategy } from './types';
+export declare const DEFAULT_STRATEGY: DashboardStorageStrategy;
+export declare const getDashboardStorageStrategy: (queryEngineEndpoint: Function | QueryEngineEndpoint | undefined, queryEngineConfig: QueryEngineConfig | undefined) => DashboardStorageStrategy;
+export declare const getDefaultParentDashboardId: (parentDashboardId: string | undefined, parentDashboardIdOnDashboardAccessToken: IdentityConfigType["dashboardAccess"]["dashboardId"], dashboards: Array<DashboardType>) => string;

package/dist/types/shared-logic/src/DashboardAPI/dataConfigurationAndIdentity.d.ts

@@ -0,0 +1,7 @@
+import { IdentityTokens } from '../Callbacks/types';
+import { identityCallback as identityCallbackImported } from '../Callbacks/types';
+export type identityCallback = identityCallbackImported;
+export declare const fetchIdentityConfig: (identityCallback: identityCallback) => Promise<{
+    identityConfig: import("../IdentityConfig/types").IdentityConfig;
+    tokens: IdentityTokens;
+}>;

package/dist/types/shared-logic/src/DashboardAPI/dataSets.d.ts

@@ -0,0 +1,10 @@
+import Joi from '@vizzly/joi';
+import { loadDataSetsCallback, loadQueryEngineConfigCallback } from '../Callbacks/types';
+import { QueryEngineEndpoint } from '../QueryEngineConfig/types';
+import { DataSet } from '../DataSet/types';
+export interface Property {
+    schema: Joi.Schema;
+}
+declare const dataSets: Property;
+export default dataSets;
+export declare const withReturnValidation: (dataSets: loadDataSetsCallback | undefined, queryEngineEndpoint: QueryEngineEndpoint | loadQueryEngineConfigCallback | undefined) => loadDataSetsCallback<DataSet>;

package/dist/types/shared-logic/src/DashboardAPI/getDashboardAdminOverride.d.ts

@@ -0,0 +1 @@
+export declare const getDashboardAdminOverride: (url: string) => string | null;

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

@@ -0,0 +1,18 @@
+import { Dashboard } from '../Dashboard/types';
+import { QueryEngineEndpoint } from '../QueryEngineConfig/types';
+export type VizzlyDashboard = {
+    id: Dashboard['id'];
+    parentDashboardId: Dashboard['parentDashboardId'] | undefined;
+    display: Dashboard['display'];
+    globalFilters: Dashboard['globalFilters'];
+    componentLibrary: Dashboard['componentLibrary'];
+    createdAt: Dashboard['createdAt'];
+    updatedAt: Dashboard['updatedAt'];
+    metadata: Dashboard['metadata'];
+};
+export type DashboardStorageStrategy = {
+    strategy: 'vizzlyApi';
+} | {
+    strategy: 'queryEngine';
+    endpoint: QueryEngineEndpoint;
+};

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

@@ -0,0 +1,7 @@
+import { DashboardPermission } from './types';
+export declare const getDashboardIds: (dashboardPermissions: DashboardPermission[]) => Array<string>;
+export declare const getReadPermission: (dashboardId: string, dashboardPermissions: DashboardPermission[]) => DashboardPermission;
+export declare const getReadOnlyPermission: (dashboardId: string, dashboardPermissions: DashboardPermission[]) => DashboardPermission;
+export declare const getWritePermission: (dashboardId: string, dashboardPermissions: DashboardPermission[]) => DashboardPermission;
+export declare const hasWritePermission: (dashboardId: string, dashboardPermissions: DashboardPermission[]) => boolean;
+export declare const hasReadOnlyPermission: (dashboardId: string, dashboardPermissions: DashboardPermission[]) => boolean;

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

@@ -0,0 +1,12 @@
+export type RawDashboardPermission = {
+    dashboard_id: string;
+    scope: 'read' | 'read_write';
+    token: string;
+    user_reference: '*' | string;
+};
+export type DashboardPermission = {
+    dashboardId: string;
+    scope: 'read' | 'read_write';
+    token: string;
+    userReference: '*' | string;
+};

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

@@ -0,0 +1,9 @@
+import { Dashboard } from '../Dashboard/types';
+export type DashboardAccessToken = {
+    token: string;
+    scope: 'read' | 'read_write';
+};
+export type DashboardSession = {
+    accessToken: DashboardAccessToken;
+    dashboard: Dashboard;
+};

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

@@ -0,0 +1,10 @@
+import { DataType } from '../Field/types';
+export type IngestField = {
+    name: string;
+    dataType: DataType;
+};
+export type Ingest = {
+    table: string;
+    fields: Array<IngestField>;
+    content: Array<any>;
+};

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

@@ -0,0 +1,17 @@
+import { ChartDataDefinition } from '../ChartsV2/types';
+export declare const showDataLabel: (totalItems: number) => boolean;
+export declare const getMinMaxChartValue: (yKey: string, data: ChartDataDefinition[]) => {
+    minValue: number;
+    maxValue: number;
+};
+export declare const getMinMaxChartValueFromNumberArray: (data: number[]) => {
+    minValue: number;
+    maxValue: number;
+};
+export declare const getLabelDictionary: (formattedData: ChartDataDefinition[] | undefined, keys: string[]) => {
+    [key: string]: string;
+};
+export declare const getFormattedValue: (value: any, dictionary?: {
+    [key: string]: string;
+}) => any;
+export declare const getAllChartValues: (data: ChartDataDefinition[], keys: string[]) => number[];

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

@@ -0,0 +1,45 @@
+import { DataSet } from '../DataSet/types';
+import { FieldFilterOptions } from '../DataSet/fieldFilterOptions';
+import { QueryAttributes } from '../QueryAttributes/types';
+import { Section as ConstSection, Pagination } from '../ComponentInterface/types/namespaces.types';
+export type Section<Type> = ConstSection<Type> & {
+    testId?: string;
+    namespace?: string;
+};
+type MetricOptions = {
+    allowsMultiple?: boolean;
+    maximumMetricsAllowed?: number;
+    propKey?: 'xMeasure' | 'yMeasure' | 'zMeasure' | 'measure' | 'barMeasure' | 'lineMeasure';
+    filterFieldOptions?: FieldFilterOptions;
+};
+export type FieldCollectorOptions<Attrs> = {
+    callToAction?: string;
+    maxAllowed?: number;
+    preventDuplicates?: boolean;
+    fieldFilterOptions?: FieldFilterOptions;
+    getValues: (attributes: Attrs) => Array<QueryAttributes['measure'][number] | QueryAttributes['dimension'][number]>;
+    preSetPartialAttributes: (values: Array<QueryAttributes['measure'][number] | QueryAttributes['dimension'][number]>, dataSet: DataSet, originalAttributes: Attrs) => Partial<Attrs>;
+};
+export type FieldCollectorSection = Section<'fieldCollector'> & FieldCollectorOptions<any>;
+export type MetricsSection = Section<'metrics'> & MetricOptions;
+export type DimensionSection = Section<'dimension'> & {
+    newCallToAction?: string;
+    allowsMultiple?: boolean;
+    filterFieldOptions?: FieldFilterOptions;
+};
+export type LabelledMetricSection = Section<'labelledMetrics'> & {
+    subSection: Array<MetricOptions & {
+        title: string;
+    }>;
+};
+export interface ProgressGoalSection<T> extends Omit<Section<T>, 'type'> {
+    goals?: {
+        field: string;
+        value: number;
+    }[];
+}
+export type ProgressGoalsSection = Section<'progressGoals'> & ProgressGoalSection<'progressGoals'>;
+export type PaginationSection = Section<'pagination'> & Pagination;
+export type DataPanelSection = DimensionSection | FieldCollectorSection | LabelledMetricSection | MetricsSection | PaginationSection | ProgressGoalsSection | Section<'comboChartDimension'> | Section<'comparison'> | Section<'country'> | Section<'customMetrics'> | Section<'dataSet'> | Section<'dateComparison'> | Section<'drilldown'> | Section<'fields'> | Section<'filter'> | Section<'limit'> | Section<'sort'> | Section<'timeDimension'> | Section<'views'> | Section<'xAxis'>;
+export type DataPanelConfig = Array<DataPanelSection>;
+export {};

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

@@ -0,0 +1,45 @@
+import { DataSet } from './types';
+import { CustomField, SimpleMathField } from '../CustomField/types';
+import { DateTimeField, NonDateTimeField } from '../Field/types';
+import { PreAggregatedQuery } from '../Query/types';
+import { QueryAttributes } from '../QueryAttributes/types';
+import { QueryEngineConfig } from '../QueryEngineConfig/types';
+import { ComponentType } from '../Component/types';
+import { RawDashboard } from '../Dashboard';
+export declare const find: <T extends {
+    id: string;
+}>(dataSets: Array<T>, dataSetId: string) => T | null;
+export declare const findByName: <T extends {
+    name: string;
+}>(dataSets: Array<T>, dataSetName: string) => T | null;
+export declare const findField: (dataSet: DataSet, id: string) => DataSet.Field;
+export declare const isField: (dataSet: DataSet, id: string) => DataSet.Field | undefined;
+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[];
+export declare const hasDateTimeFields: (dataSet: DataSet) => boolean;
+export declare const getPlaceholder: (dataSet: DataSet, field: string | null) => string;
+export declare const takeFieldsForDimension: (dataSet: DataSet) => DataSet.Field[];
+export declare const takeFieldsForMeasure: (dataSet: DataSet, componentType: ComponentType) => DataSet.Field[];
+/**
+ * Return all custom fields for a data set, and optionally
+ * provide the componentType to ensure the custom fields which are returned
+ * are also supported by the componentType.
+ */
+export declare const takeCustomFields: (dataSet: DataSet, componentType?: ComponentType) => CustomField[];
+export declare const takeNonCustomFields: (dataSet: DataSet) => Array<NonDateTimeField | DateTimeField | SimpleMathField>;
+export declare const takeNonPercentageCustomFields: (dataSet: DataSet) => Array<NonDateTimeField | DateTimeField | SimpleMathField>;
+export declare const removeCustomFields: (dataSet: DataSet) => DataSet;
+export declare const upsertField: (dataSet: DataSet, upsertedField: DataSet.Field) => DataSet;
+export declare const updateDataSet: (dataSets: DataSet[], updatedDataSet: DataSet) => DataSet[];
+export declare const removeField: <T extends {
+    fields: DataSet["fields"];
+}>(dataSet: T, fieldId: string) => T;
+export declare const findRemovedFieldsBetweenDataSets: (previousDataSets: DataSet[], newDataSets: DataSet[]) => Array<DataSet.Field>;
+export declare const findRemovedFields: (original: DataSet, latest: DataSet) => Array<DataSet.Field>;
+export declare const buildQueryAttributes: (dataSet: DataSet, queryEngineConfig: QueryEngineConfig, componentType: ComponentType) => QueryAttributes;
+export declare const buildDownloadQuery: (dataSet: DataSet, maxCSVDownloadLimit: number, viewFilters: QueryAttributes["filter"]) => QueryAttributes;
+export declare const buildViewOnlyQuery: (dataSet: DataSet) => PreAggregatedQuery;
+export declare const addCustomFields: (dataSets: Array<DataSet>, customFields: RawDashboard["definition"]["customFields"]) => Array<DataSet>;
+export declare const validId: (id: string, dataSet: DataSet[]) => boolean;

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

@@ -0,0 +1,17 @@
+import { ComponentType } from '../Component/types';
+import { DataType } from '../Field/types';
+export type FieldFilterOptions = {
+    removePercentage?: boolean;
+    removeRuleGrouping?: boolean;
+    removeRoundedNumbers?: boolean;
+    removeSimpleMaths?: boolean;
+    removeAggregateMaths?: boolean;
+    removeDateCalculations?: boolean;
+    removeConditional?: boolean;
+    removeCustomBuildMetric?: boolean;
+    removeAggregateCustomBuildMetric?: boolean;
+    onlyDimensions?: boolean;
+    onlyMeasures?: boolean;
+    forComponent?: ComponentType;
+    onlyFieldTypes?: DataType[];
+};

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

@@ -0,0 +1,3 @@
+import { DataSet } from './types';
+import { FieldFilterOptions } from './fieldFilterOptions';
+export declare function filterFields(originalFields: DataSet.Field[], options?: FieldFilterOptions): DataSet.Field[];

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

@@ -0,0 +1,3 @@
+export * from './DataSet';
+export * from './newField';
+export * from './filterFields';

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

@@ -0,0 +1,15 @@
+import { QueryEngineConfig } from '../QueryEngineConfig/types';
+import { DateTimeField, NonDateTimeField } from '../Field/types';
+export type FieldOverrides = Partial<{
+    canBeDimension: boolean;
+    canBeMeasure: boolean;
+    allowedOperators: Array<string>;
+}>;
+export type DateTimeFieldOverrides = FieldOverrides & Partial<{
+    allowedGranularities: Array<string>;
+}>;
+export declare const stringField: (queryEngineConfig: QueryEngineConfig, id: string, publicName: string, overrides?: FieldOverrides) => NonDateTimeField;
+export declare const numberField: (queryEngineConfig: QueryEngineConfig, id: string, publicName: string, overrides?: FieldOverrides) => NonDateTimeField;
+export declare const stringArrayField: (queryEngineConfig: QueryEngineConfig, id: string, publicName: string, overrides?: FieldOverrides) => NonDateTimeField;
+export declare const booleanField: (queryEngineConfig: QueryEngineConfig, id: string, publicName: string, overrides?: FieldOverrides) => NonDateTimeField;
+export declare const dateTimeField: (queryEngineConfig: QueryEngineConfig, id: string, publicName: string, overrides: DateTimeFieldOverrides) => DateTimeField;

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

@@ -0,0 +1,19 @@
+import { CustomField } from '../CustomField/types';
+import { DateTimeField, NonDateTimeField } from '../Field/types';
+import { PartialBy } from '../typeHelpers';
+export declare namespace DataSet {
+    type Field = DateTimeField | NonDateTimeField | CustomField;
+    type PreUpcastField = PartialBy<DateTimeField, 'allowedGranularities' | 'allowedOperators' | 'canBeDimension' | 'canBeMeasure' | 'supportedAggregateOptions'> | PartialBy<NonDateTimeField, 'allowedOperators' | 'canBeDimension' | 'canBeMeasure' | 'supportedAggregateOptions'> | PartialBy<CustomField, 'allowedOperators' | 'canBeDimension' | 'canBeMeasure' | 'supportedAggregateOptions'>;
+}
+export type DataSet<Field = DataSet.Field> = {
+    id: string;
+    name: string;
+    description?: string;
+    /**
+     * Hide the data set from the editor. This allows data sets to be used to power dashboard
+     * filters, but not used to create views on.
+     * */
+    hide?: boolean;
+    fields: Field[];
+    preAggregated?: undefined | false | string[];
+};

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

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

package/dist/types/shared-logic/src/DataTable/resultToPivotTableRepresentation.d.ts

@@ -0,0 +1,7 @@
+import { TextOverride } from '../../../shared-logic/src/Translations/types';
+import { QueryAttributes } from '../QueryAttributes/types';
+import { Result as ResultType } from '../Result/types';
+import { TableRepresentation } from './types';
+import { Component } from '../Component/types';
+import { ValueAlias } from '../ValueAlias/types';
+export declare const resultToPivotTableRepresentation: (result: ResultType, dimension: QueryAttributes["dimension"], measure: QueryAttributes["measure"], dataSetId: string, textOverride?: TextOverride, hiddenFields?: Component.HiddenField[], valueAlias?: ValueAlias) => TableRepresentation;

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

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

package/dist/types/shared-logic/src/DataTable/shared.contants.d.ts

@@ -0,0 +1 @@
+export declare const ROW_NUMBER_OPTIONS: number[];

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

@@ -0,0 +1,26 @@
+import { Result } from '../Result/types';
+import type { DatumKey } from '../DatumKey';
+export type GroupedTitle = {
+    colSpan: number;
+    content: string;
+    rowGroup?: boolean;
+    unformatted: string;
+};
+export type TableContent = {
+    value: any;
+    displayValue?: any;
+};
+export type TableFields = Result['fields'][number] & {
+    datumKey: DatumKey;
+};
+export type TableRepresentation = {
+    groupTitles?: {
+        consolidated: Array<GroupedTitle>;
+        unconsolidated: Array<GroupedTitle>;
+    } | false;
+    fields: Array<TableFields>;
+    content: TableContent[][];
+};
+export type TableFieldsV2 = {
+    [key: string]: string | number;
+};

package/dist/types/shared-logic/src/DateTime/DateTimeFilterOptions.d.ts

@@ -0,0 +1,105 @@
+import { TimeRangeOptions } from '../AdditionalFilter/types';
+import { TextOverride } from '../Translations/types';
+import { DateTimeFilterOptions } from './types';
+export declare const buildToday: (NOW: Date, description: string) => {
+    description: string;
+    range: {
+        before: Date;
+        after: Date;
+    };
+};
+export declare const buildYesterday: (NOW: Date, description: string) => {
+    description: string;
+    range: {
+        before: Date;
+        after: Date;
+    };
+};
+export declare const buildTimeRange: (days: number, months: number, description: string) => {
+    description: string;
+    range: {
+        before: Date;
+        after: Date;
+    };
+};
+export declare const defaultTimeRangeMapping: (textOverride: TextOverride) => {
+    today: {
+        description: string;
+        range: {
+            before: Date;
+            after: Date;
+        };
+    };
+    past_1_day: {
+        description: string;
+        range: {
+            before: Date;
+            after: Date;
+        };
+    };
+    yesterday: {
+        description: string;
+        range: {
+            before: Date;
+            after: Date;
+        };
+    };
+    past_3_days: {
+        description: string;
+        range: {
+            before: Date;
+            after: Date;
+        };
+    };
+    past_7_days: {
+        description: string;
+        range: {
+            before: Date;
+            after: Date;
+        };
+    };
+    past_30_days: {
+        description: string;
+        range: {
+            before: Date;
+            after: Date;
+        };
+    };
+    past_90_days: {
+        description: string;
+        range: {
+            before: Date;
+            after: Date;
+        };
+    };
+    past_3_months: {
+        description: string;
+        range: {
+            before: Date;
+            after: Date;
+        };
+    };
+    past_6_months: {
+        description: string;
+        range: {
+            before: Date;
+            after: Date;
+        };
+    };
+    past_12_months: {
+        description: string;
+        range: {
+            before: Date;
+            after: Date;
+        };
+    };
+    past_18_months: {
+        description: string;
+        range: {
+            before: Date;
+            after: Date;
+        };
+    };
+};
+export declare const defaultDateFilterOptions: () => DateTimeFilterOptions;
+export declare const build: (textOverride: TextOverride, overrides?: DateTimeFilterOptions) => TimeRangeOptions;

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

@@ -0,0 +1,10 @@
+export type CustomDateTimeRange = {
+    description: string;
+    range: {
+        after: Date;
+        before: Date;
+    };
+};
+export type DateTimeFilterOptions = {
+    [key: string]: boolean | CustomDateTimeRange;
+};

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

@@ -0,0 +1,2 @@
+import { QueryAttributes } from '../QueryAttributes/types';
+export declare const filterIsDate: (filter: QueryAttributes.Filter) => boolean;

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

@@ -0,0 +1,15 @@
+export type Datum = {
+    [key: string]: string | number | any;
+};
+export type DatumKey = string;
+export type ParsedDatumKey = {
+    dimensionKeys: Array<string>;
+    dimensionValues: Array<string | number | null | string[]>;
+    fieldId: string;
+    function: string;
+    modifier?: string;
+};
+export declare const key: (dimensionKeys: ParsedDatumKey["dimensionKeys"], dimensionValues: ParsedDatumKey["dimensionValues"], fieldId: ParsedDatumKey["fieldId"], func: ParsedDatumKey["function"]) => string;
+export declare const isDatumKey: (key: string | undefined) => boolean;
+export declare const parse: (key: string) => ParsedDatumKey;
+export declare const toFieldId: (key: string) => string;

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

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