@vizzly/services 0.11.0 → 0.12.0-dev-2ab7e33d0cfee4465500870d9b623dac4802c30e

package/dist/services/src/Services/{CellServices.d.ts → Cell.d.ts}

@@ -1,5 +1,5 @@
-import * as ViewServices from './ViewServices';
 import { AdditionalFilter } from 'shared-logic/src/AdditionalFilter/types';
+import { AnyView } from './View';
 /**
  * Represents a CellAttributes type.
  * @param component - The component contained within the cell. Optional.
@@ -7,7 +7,7 @@ import { AdditionalFilter } from 'shared-logic/src/AdditionalFilter/types';
  * @param localFilters - The local filters of the cell. Optional.
  */
 export declare type CellAttributes = {
-    component?: ViewServices.View;
+    component?: AnyView;
     colSpan?: number;
     localFilters?: AdditionalFilter[];
 };
@@ -18,7 +18,7 @@ export declare class Cell {
     /**
      * The component contained within the cell. It's optional and can be undefined.
      */
-    component: ViewServices.View | undefined;
+    component: AnyView | undefined;
     /**
      * The span of the cell in terms of columns. Defaults to 12.
      */
@@ -54,7 +54,7 @@ export declare class Cell {
      *
      * @param component The component to be set in the cell.
      */
-    setComponent(component: ViewServices.View): void;
+    setComponent(component: AnyView): void;
     /**
      * Clears the component from the cell and optionally sets a new column span.
      * Marks the cell as empty.

package/dist/services/src/Services/{DashboardServices.d.ts → Dashboard.d.ts}

@@ -1,8 +1,8 @@
-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';
-import { Library } from './ComponentLibraryServices';
+import * as DashboardTypes from 'shared-logic/src/Dashboard/types';
+import { Row } from './Row';
+import { CustomField } from 'shared-logic/src/CustomField/types';
+import { Header } from './Header';
+import { Library } from './Library';
 /** Custom fields for a dashboard */
 export declare type CustomFields = {
     [dataSetId: string]: Array<CustomField>;
@@ -21,7 +21,7 @@ export declare type DashboardAttributes = {
 /**
  * Represents a Dashboard class.
  */
-export declare class Dashboard<T> {
+export declare class Dashboard {
     private dashboard;
     /**
      * Constructs a new instance of the Dashboard class.

package/dist/services/src/Services/{HeaderServices.d.ts → Header.d.ts}

@@ -1,4 +1,4 @@
-import { DisplayRow } from '../../../shared-logic/src/Display/types';
+import { DisplayRow } from 'shared-logic/src/Display/types';
 export declare type HeaderRow = DisplayRow[];
 /**
  * Represents a Header class.

package/dist/services/src/Services/{ComponentLibraryServices.d.ts → Library.d.ts}

@@ -1,12 +1,12 @@
 import { AdditionalFilter } from 'shared-logic/src/AdditionalFilter/types';
-import { Cell } from './CellServices';
-import * as ViewServices from './ViewServices';
+import { Cell } from './Cell';
+import * as Views from './View';
 /**
  * Represents a Library class.
  * @param components The `component` instance to be added to the library. `uniqueViewId` of the component, should always be the same and not auto-generated.
  */
-export declare type LibrayView = {
-    component: ViewServices.View;
+export declare type LibraryView = {
+    component: Views.AnyView;
     uniqueViewId: string;
 };
 export declare class Library {
@@ -20,7 +20,7 @@ export declare class Library {
      * @param components The `component` instance to be added to the library. `uniqueViewId` of the component, should always be the same and not auto-generated.
      */
     constructor(attributes?: {
-        components?: LibrayView[];
+        components?: LibraryView[];
     });
     /**
      * Adds a cell to the library at a specified position or appends it at the end if no position is specified.
@@ -30,7 +30,7 @@ export declare class Library {
      * @example library.addComponent(Vizzly.AreaChart, "uniqueViewId");
      * @example library.addComponent(Vizzly.AreaChart, "uniqueViewId", { position: 0 });
      */
-    addComponent(component: ViewServices.View, uniqueViewId: string, attributes?: {
+    addComponent(component: Views.AnyView, uniqueViewId: string, attributes?: {
         position?: number;
         localFilters?: AdditionalFilter[];
     }): void;
@@ -38,6 +38,6 @@ export declare class Library {
      *  Adds an array of cells to the library.
      * @param components The `component` instance to be added to the library. `uniqueViewId` of the component, should always be the same and not auto-generated.
      */
-    addComponents(components: LibrayView[]): void;
+    addComponents(components: LibraryView[]): void;
 }
-export declare const mergeInViewId: (component: ViewServices.View, uniqueViewId: string) => ViewServices.View;
+export declare const mergeInViewId: (component: Views.AnyView, uniqueViewId: string) => Views.AnyView;

package/dist/services/src/Services/{RowServices.d.ts → Row.d.ts}

@@ -1,4 +1,4 @@
-import { Cell } from './CellServices';
+import { Cell } from './Cell';
 /**
  * Represents a Row class.
  */

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

@@ -0,0 +1,65 @@
+import type { Component } from 'shared-logic/src/Component/types';
+import { ViewConfiguration as ViewConfigurationImported } from 'shared-logic/src/ViewConfiguration/types';
+import { Vizzly } from '..';
+export declare type ViewConfiguration = ViewConfigurationImported;
+declare type RequiredAttributes<T extends Component.Attributes> = {
+    dataSetId: T['dataSetId'];
+};
+export declare class View<T extends Component.Attributes> {
+    attributes: T;
+    protected vizzly: Vizzly;
+    constructor(attributes: Partial<T> & {
+        type: T['type'];
+    } & RequiredAttributes<T>);
+    updateAttributes(newAttributes: Partial<T>): void;
+}
+export declare type AnyView = AreaChart | LineChart | BarChart | PieChart | ScatterChart | ComboChart | PivotTable | BasicTable | HorizontalBarChart | MercatorMap | SingleStat | Progress;
+export declare class AreaChart extends View<Component.AreaChartAttributes> {
+    constructor(attributes: Partial<Component.AreaChartAttributes> & RequiredAttributes<Component.AreaChartAttributes>);
+    static type(): Component.AreaChartAttributes['type'];
+}
+export declare class LineChart extends View<Component.LineChartAttributes> {
+    constructor(attributes: Partial<Component.LineChartAttributes> & RequiredAttributes<Component.LineChartAttributes>);
+    static type(): Component.LineChartAttributes['type'];
+}
+export declare class BarChart extends View<Component.BarChartAttributes> {
+    constructor(attributes: Partial<Component.BarChartAttributes> & RequiredAttributes<Component.BarChartAttributes>);
+    static type(): Component.BarChartAttributes['type'];
+}
+export declare class PieChart extends View<Component.PieChartAttributes> {
+    constructor(attributes: Partial<Component.PieChartAttributes> & RequiredAttributes<Component.PieChartAttributes>);
+    static type(): Component.PieChartAttributes['type'];
+}
+export declare class ScatterChart extends View<Component.ScatterChartAttributes> {
+    constructor(attributes: Partial<Component.ScatterChartAttributes> & RequiredAttributes<Component.ScatterChartAttributes>);
+    static type(): Component.ScatterChartAttributes['type'];
+}
+export declare class ComboChart extends View<Component.ComboChartAttributes> {
+    constructor(attributes: Partial<Component.ComboChartAttributes> & RequiredAttributes<Component.ComboChartAttributes>);
+    static type(): Component.ComboChartAttributes['type'];
+}
+export declare class PivotTable extends View<Component.DataTableAttributes> {
+    constructor(attributes: Partial<Component.DataTableAttributes> & RequiredAttributes<Component.DataTableAttributes>);
+    static type(): Component.DataTableAttributes['type'];
+}
+export declare class BasicTable extends View<Component.BasicTableAttributes> {
+    constructor(attributes: Partial<Component.BasicTableAttributes> & RequiredAttributes<Component.BasicTableAttributes>);
+    static type(): Component.BasicTableAttributes['type'];
+}
+export declare class HorizontalBarChart extends View<Component.HorizontalBarChartAttributes> {
+    constructor(attributes: Partial<Component.HorizontalBarChartAttributes> & RequiredAttributes<Component.HorizontalBarChartAttributes>);
+    static type(): Component.HorizontalBarChartAttributes['type'];
+}
+export declare class MercatorMap extends View<Component.MercatorMapAttributes> {
+    constructor(attributes: Partial<Component.MercatorMapAttributes> & RequiredAttributes<Component.MercatorMapAttributes>);
+    static type(): Component.MercatorMapAttributes['type'];
+}
+export declare class SingleStat extends View<Component.SingleStatAttributes> {
+    constructor(attributes: Partial<Component.SingleStatAttributes> & RequiredAttributes<Component.SingleStatAttributes>);
+    static type(): Component.SingleStatAttributes['type'];
+}
+export declare class Progress extends View<Component.ProgressAttributes> {
+    constructor(attributes: Partial<Component.ProgressAttributes> & RequiredAttributes<Component.ProgressAttributes>);
+    static type(): Component.ProgressAttributes['type'];
+}
+export {};

package/dist/services/src/VizzlyLoader.d.ts

@@ -0,0 +1,44 @@
+import { QueryEngineConfig, QueryEngineEndpoint } from 'shared-logic/src/QueryEngineConfig/types';
+import { identityCallback, loadDataSetsCallback, loadQueryEngineConfigCallback } from 'shared-logic/src/Callbacks/types';
+import { IdentityConfig } from 'shared-logic/src/IdentityConfig/types';
+import { DashboardStorageStrategy } from 'shared-logic/src/DashboardAPI/types';
+import { VizzlyTranslations } from 'shared-logic/src/Translations/translation.types';
+import { DataSet } from 'shared-logic/src/DataSet/types';
+export declare type LoaderOptions = {
+    apiHost: string;
+    textOverrides?: VizzlyTranslations;
+    developerMode?: boolean;
+};
+declare type AccessTokens = Awaited<ReturnType<identityCallback>>;
+/**
+ * A class to manage the up-front setting up of Vizzly.
+ * For example, fetching data sets, the query engine config and
+ * access tokens used for the identity logic.
+ */
+export declare class VizzlyLoader {
+    private queryEngineConfig;
+    private dataSets;
+    private queryEngine;
+    private loadAccessTokens;
+    private loadDataSetsCallback?;
+    options: LoaderOptions;
+    constructor(queryEngine: 'in-browser' | QueryEngineEndpoint | loadQueryEngineConfigCallback | undefined, loadAccessTokens: identityCallback, loadDataSetsCallback?: loadDataSetsCallback, options?: LoaderOptions);
+    getQueryEngineConfig(): Promise<QueryEngineConfig>;
+    getIdentity(): Promise<{
+        accessTokens: AccessTokens;
+        identityConfig: IdentityConfig;
+    }>;
+    getDataSets(): Promise<DataSet[]>;
+    load(): Promise<{
+        queryEngineConfig: QueryEngineConfig;
+        dataSets: DataSet[];
+        identityConfig: IdentityConfig;
+        dashboardStorageStrategy: DashboardStorageStrategy;
+    }>;
+    /**
+     * Where should dashboards be fetched and saved from? Via the Query Engine for encryption
+     * or direct to the Vizzly API for non-encrypted storage.
+     */
+    getDashboardStorageStrategy(queryEngineConfig: QueryEngineConfig): DashboardStorageStrategy;
+}
+export {};

package/dist/services/src/errors/TimeoutWaitingForVizzlyInstance.d.ts

@@ -0,0 +1,3 @@
+export declare class TimeoutWaitingForVizzlyInstance extends Error {
+    constructor(instanceId: string, timeout: number);
+}

package/dist/services/src/errors/VizzlyInstanceNotLoaded.d.ts

@@ -0,0 +1,3 @@
+export declare class VizzlyInstanceNotLoaded extends Error {
+    constructor(instanceId: string);
+}

package/dist/services/src/index.d.ts

@@ -1,32 +1,125 @@
-import { QueryEngineConfig, QueryEngineEndpoint } from '../../shared-logic/src/QueryEngineConfig/types';
-import * as ViewServices from './Services/ViewServices';
-import { Cell } from './Services/CellServices';
-import { Row } from './Services/RowServices';
-import { Dashboard } from './Services/DashboardServices';
-import { Header } from './Services/HeaderServices';
-import { Library } from './Services/ComponentLibraryServices';
-import { loadQueryEngineConfigCallback } from '../../shared-logic/src/Callbacks/types';
-import { API } from './Services/APIServices';
-export declare class Vizzly {
-    static queryEngineConfig: QueryEngineConfig | undefined;
-    static queryEngineEndpoint: QueryEngineEndpoint | loadQueryEngineConfigCallback | 'in-browser' | undefined;
-    static load(configUrl: QueryEngineEndpoint | loadQueryEngineConfigCallback | 'in-browser'): Promise<QueryEngineConfig | null>;
-    static get Dashboard(): typeof Dashboard;
-    static get Library(): typeof Library;
-    static get Cell(): typeof Cell;
-    static get Row(): typeof Row;
-    static get Header(): typeof Header;
-    static get API(): typeof API;
-    static AreaChart: typeof ViewServices.AreaChart;
-    static LineChart: typeof ViewServices.LineChart;
-    static BarChart: typeof ViewServices.BarChart;
-    static PieChart: typeof ViewServices.PieChart;
-    static ScatterChart: typeof ViewServices.ScatterChart;
-    static ComboChart: typeof ViewServices.ComboChart;
-    static PivotTable: typeof ViewServices.PivotTable;
-    static BasicTable: typeof ViewServices.BasicTable;
-    static HorizontalBarChart: typeof ViewServices.HorizontalBarChart;
-    static MercatorMap: typeof ViewServices.MercatorMap;
-    static SingleStat: typeof ViewServices.SingleStat;
-    static Progress: typeof ViewServices.Progress;
+import { QueryEngineConfig, QueryEngineEndpoint } from 'shared-logic/src/QueryEngineConfig/types';
+import { identityCallback, loadDataSetsCallback, loadQueryEngineConfigCallback, programmaticDashboardCallback } from 'shared-logic/src/Callbacks/types';
+import { IdentityConfig } from 'shared-logic/src/IdentityConfig/types';
+import { DashboardStorageStrategy } from 'shared-logic/src/DashboardAPI/types';
+import { DataSet } from 'shared-logic/src/DataSet/types';
+import { Dashboard as DashboardFromAPI } from '@vizzly/api-client';
+import * as DashboardLogic from 'shared-logic/src/Dashboard';
+import * as GlobalLibraryLogic from 'shared-logic/src/GlobalLibrary';
+import { LoaderOptions } from './VizzlyLoader';
+import { Row } from './Services/Row';
+import { Cell } from './Services/Cell';
+import { Dashboard } from './Services/Dashboard';
+import { Header } from './Services/Header';
+import { Library } from './Services/Library';
+import * as Views from './Services/View';
+import { ViewConfiguration } from 'shared-logic/src/ViewConfiguration/types';
+export type { ViewConfiguration } from 'shared-logic/src/ViewConfiguration/types';
+export { VizzlyInstanceNotLoaded } from './errors/VizzlyInstanceNotLoaded';
+export declare type Options = {
+    apiHost: string;
+};
+export declare type FilterDashboardOptions = {
+    onlyAllowScope?: 'read' | 'read_write';
+    onlyChildDashboardsForParent?: string;
+    onlyChildDashboards?: boolean;
+    onlyParentDashboards?: boolean;
+    onlyDashboardsIncludingMetadata?: DashboardLogic.Dashboard['metadata'];
+};
+export declare type VizzlyServicesProperties = {
+    queryEngine: 'in-browser' | QueryEngineEndpoint | loadQueryEngineConfigCallback | undefined;
+    identity: identityCallback;
+    programmaticDashboard?: programmaticDashboardCallback;
+    dataSets?: loadDataSetsCallback;
+};
+declare class VizzlyServices {
+    private queryEngineConfig;
+    private dataSets;
+    private identityConfig;
+    private vizzlyAPIClient;
+    private programmaticDashboard;
+    static _instanceStore: {
+        [instanceId: string]: VizzlyServices;
+    };
+    static DEFAULT_INSTANCE_ID: string;
+    constructor(identityConfig: IdentityConfig, queryEngineConfig: QueryEngineConfig, dataSets: DataSet[], dashboardStorageStrategy: DashboardStorageStrategy, programmaticDashboard: programmaticDashboardCallback | undefined, options: {
+        host: string;
+    });
+    /**
+     * @param properties
+     * @param options
+     * @returns Vizzly instance for programmatically managing dashboards.
+     */
+    static load(properties: VizzlyServicesProperties, options?: LoaderOptions): Promise<VizzlyServices>;
+    static use(instanceId?: string): VizzlyServices;
+    static waitToUse(instanceId?: string, timeoutMs?: number): Promise<any>;
+    static clearInstances(): void;
+    /**
+     * Use the dashboard API to create the dashboard, upcast
+     * and return the dashboard with the data sets.
+     */
+    createDashboard(params: CreateDashboardParams): Promise<DashboardLogic.Dashboard>;
+    updateDashboard(params: UpdateDashboardParams): Promise<DashboardLogic.Dashboard>;
+    getDashboards(params?: {
+        abortController?: AbortController;
+    }): Promise<DashboardLogic.Dashboard[]>;
+    getGlobalLibraries(params?: {
+        abortController?: AbortController;
+    }): Promise<GlobalLibraryLogic.GlobalLibrary[]>;
+    /**
+     * Provides the configuration needed for each Vizzly view.
+     */
+    getViewConfiguration(): ViewConfiguration;
+    getIdentityConfig(): IdentityConfig;
+    static upcastDashboard(dashboard: DashboardFromAPI, dataSets: DataSet[], queryEngineConfig: QueryEngineConfig): Array<DashboardLogic.Dashboard>;
+    static filterDashboards(dashboards: DashboardLogic.Dashboard[], options: FilterDashboardOptions): DashboardLogic.Dashboard[];
+    static validateDashboard(dashboard: unknown): void;
+    static Row: typeof Row;
+    static Cell: typeof Cell;
+    static Dashboard: typeof Dashboard;
+    static Header: typeof Header;
+    static Library: typeof Library;
+    static AreaChart: typeof Views.AreaChart;
+    static LineChart: typeof Views.LineChart;
+    static BarChart: typeof Views.BarChart;
+    static PieChart: typeof Views.PieChart;
+    static ScatterChart: typeof Views.ScatterChart;
+    static ComboChart: typeof Views.ComboChart;
+    static PivotTable: typeof Views.PivotTable;
+    static BasicTable: typeof Views.BasicTable;
+    static HorizontalBarChart: typeof Views.HorizontalBarChart;
+    static MercatorMap: typeof Views.MercatorMap;
+    static SingleStat: typeof Views.SingleStat;
+    static Progress: typeof Views.Progress;
 }
+export declare type UpdateDashboardParams = {
+    dashboardId: string;
+    definition?: DashboardLogic.SaveableDashboardDefinition;
+    deleted?: boolean;
+    metadata?: Object;
+    /** @deprecated Use metadata instead. */
+    meta?: Object;
+    abortSignal?: AbortSignal;
+};
+export declare type CreateDashboardParams = {
+    definition: DashboardLogic.SaveableDashboardDefinition;
+    /** @deprecated - use `metadata` instead */
+    meta?: Object;
+    /**
+     * The metadata for the dashboard.
+     *
+     * @property {any} meta - The metadata for the dashboard can be set to anything you require.
+     *
+     */
+    metadata?: Object;
+    /**
+     * The ID of the parent dashboard.
+     *
+     * @property {string} parentDashboardId - The ID of the parent dashboard.
+     * @default The default parent dashboard ID.
+     */
+    parentDashboardId: string;
+    abortSignal?: AbortSignal;
+};
+export declare type Vizzly = VizzlyServices;
+export declare const Vizzly: typeof VizzlyServices;

package/dist/services/src/schemaValidations/dashboard.d.ts

@@ -1,4 +1,4 @@
-import { CreateDashboard, UpdateDashboardOptions } from '../Services/APIServices';
 import { QueryEngineConfig } from 'shared-logic/src/QueryEngineConfig/types';
-export declare const validateCreateDashboardParams: (params: CreateDashboard, queryEngineConfig: QueryEngineConfig | undefined) => void;
-export declare const validateUpdateDashboardParams: (params: UpdateDashboardOptions) => void;
+import { CreateDashboardParams, UpdateDashboardParams } from '..';
+export declare const validateCreateDashboardParams: (params: CreateDashboardParams, queryEngineConfig: QueryEngineConfig | undefined) => void;
+export declare const validateUpdateDashboardParams: (params: UpdateDashboardParams, queryEngineConfig: QueryEngineConfig) => void;

package/dist/services/src/schemaValidations/filters.d.ts

@@ -1,3 +1,3 @@
 import { AdditionalFilter } from 'shared-logic/src/AdditionalFilter/types';
 import { QueryEngineConfig } from 'shared-logic/src/QueryEngineConfig/types';
-export declare function validateAndSetLocalFilters(localFilters: AdditionalFilter[], queryEngineConfig?: QueryEngineConfig): AdditionalFilter[];
+export declare function validateAndSetLocalFilters(localFilters: AdditionalFilter[], queryEngineConfig: QueryEngineConfig): AdditionalFilter[];

package/dist/services/src/schemaValidations/library.d.ts

@@ -1,2 +1,2 @@
-import { LibrayView } from '../Services/ComponentLibraryServices';
-export declare function validateLibraryComponent(item: LibrayView): void;
+import { LibraryView } from '../Services/Library';
+export declare function validateLibraryComponent(item: LibraryView): void;

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

@@ -1,8 +1,10 @@
+import { SaveableDashboardDefinition } from '../Dashboard/types';
 import { DataSet } from '../DataSet/types';
 import { IdentityConfig } from '../IdentityConfig/types';
 import { DataMap } from '../JSQueryEngine/types';
 import { QueryEngineConfig } from '../QueryEngineConfig/types';
 declare type CallbackError = null;
+export declare type programmaticDashboardCallback = (dataSets: DataSet[]) => Promise<Array<Partial<SaveableDashboardDefinition>>>;
 export declare type loadDataSetsCallback = (identityConfig: IdentityConfig, queryEngineConfig: QueryEngineConfig) => Promise<Array<DataSet>>;
 export declare type IdentityTokens = {
     dashboardAccessToken: string;

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

@@ -3,7 +3,7 @@ import { SupportedAggregates } from '../Aggregate';
 import { QueryEngineConfig } from '../QueryEngineConfig/types';
 import { SupportedTimeTruncFunctions } from '../TimeDimension/types';
 import { ComponentInterfaceConfig } from '../ComponentInterface/types';
-export declare const measureSchema: (supportedAggregates: SupportedAggregates, attributeSchemaOptions: ComponentInterfaceConfig['attributesSchemaOptions']) => Joi.ObjectSchema<any> | Joi.AlternativesSchema<any>;
+export declare const measureSchema: (supportedAggregates: SupportedAggregates, attributeSchemaOptions: ComponentInterfaceConfig['attributesSchemaOptions']) => Joi.AlternativesSchema<any> | Joi.ObjectSchema<any>;
 export declare const orderSchema: (queryEngineConfig: QueryEngineConfig) => Joi.ObjectSchema<any>;
 export declare const timeDimensionSchema: (supportedTimeTruncFunctions: SupportedTimeTruncFunctions) => Joi.ObjectSchema<any>;
 export declare const dimensionSchema: (supportedTimeTruncFunctions: SupportedTimeTruncFunctions, attributeSchemaOptions: ComponentInterfaceConfig['attributesSchemaOptions']) => Joi.ArraySchema<any[]>;

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

@@ -14,5 +14,9 @@ export declare type RawDashboard<Definition = RawDefinition> = {
     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/shared-logic/src/Dashboard/types.d.ts

@@ -13,6 +13,9 @@ export declare type Dashboard = {
     id: string;
     parentDashboardId: string | null;
     metadata: Dashboard.ExternalMetadata;
+    /**
+     * @deprecated
+     */
     theme: StoredTheme;
     display: Display;
     webhookId: string | null;
@@ -23,8 +26,13 @@ export declare type Dashboard = {
     isPlayground: boolean;
     createdAt: Date;
     updatedAt: Date;
+    /** @deprecated */
     protectedByOrganisation?: boolean;
     isProgrammatic?: boolean;
+    permission?: {
+        scope: 'read' | 'read_write';
+        token: string;
+    };
 };
 export declare type SaveableDashboardDefinition = {
     display: DisplayDumped;

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

@@ -1,12 +1,9 @@
 import Joi from '@vizzly/joi';
-import { loadDataSetsCallback } from 'shared-logic/src/Callbacks/types';
-import { IdentityConfig } from 'shared-logic/src/IdentityConfig/types';
+import { loadDataSetsCallback, loadQueryEngineConfigCallback } from 'shared-logic/src/Callbacks/types';
 import { QueryEngineEndpoint } from 'shared-logic/src/QueryEngineConfig/types';
-import { DataSet } from '../DataSet/types';
-export declare type DataSetsCallback = (identityConfig: IdentityConfig) => Promise<Array<DataSet> | null>;
 export interface Property {
     schema: Joi.Schema;
 }
 declare const dataSets: Property;
 export default dataSets;
-export declare const withReturnValidation: (dataSets?: DataSetsCallback, querEngineEndpoint?: QueryEngineEndpoint) => loadDataSetsCallback;
+export declare const withReturnValidation: (dataSets: loadDataSetsCallback | undefined, queryEngineEndpoint: QueryEngineEndpoint | loadQueryEngineConfigCallback | undefined) => loadDataSetsCallback;

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

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

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

@@ -0,0 +1,10 @@
+import { GlobalLibrary, GlobalLibraryLibrary } from './types';
+export declare type RawGlobalLibrary = {
+    id: string;
+    name: string;
+    library: GlobalLibraryLibrary;
+    created_at: string;
+    updated_at: string;
+    parent_global_library_id: string;
+};
+export declare const fromRaw: (rawGlobalLibrary: RawGlobalLibrary) => GlobalLibrary;

package/dist/shared-logic/src/GlobalLibrary/index.d.ts

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

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

@@ -0,0 +1,16 @@
+import { Component } from '../Component/types';
+import { CustomField } from '../CustomField/types';
+export declare type GlobalLibraryLibrary = {
+    views?: Component[];
+    customFields?: {
+        [dataSetId: string]: Array<CustomField>;
+    };
+};
+export declare type GlobalLibrary = {
+    id: string;
+    name: string;
+    library: GlobalLibraryLibrary;
+    createdAt: Date;
+    updatedAt: Date;
+    parentGlobalLibraryId: string;
+};

package/dist/shared-logic/src/QueryEngineConfig/loadQueryEngineConfig.d.ts

@@ -1,3 +1,3 @@
 import { QueryEngineConfig, QueryEngineEndpoint } from '../QueryEngineConfig/types';
-import { loadQueryEngineConfigCallback } from '../Callbacks/types';
-export declare const loadQueryEngineConfig: (loadQueryEngineConfig: loadQueryEngineConfigCallback | QueryEngineEndpoint) => Promise<QueryEngineConfig>;
+import { loadQueryEngineConfigCallback, loadDataSetsCallback } from '../Callbacks/types';
+export declare const loadQueryEngineConfig: (loadQueryEngineConfig: loadQueryEngineConfigCallback | QueryEngineEndpoint, userProvidedLoadDataSetsCallback: loadDataSetsCallback | undefined) => Promise<QueryEngineConfig>;