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

package/dist/types/services/src/Services/Cell.d.ts

@@ -0,0 +1,65 @@
+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.
+ * @param colSpan - The span of the cell in terms of columns. Defaults to 12.
+ * @param localFilters - The local filters of the cell. Optional.
+ */
+export type CellAttributes = {
+    component?: AnyView;
+    colSpan?: number;
+    localFilters?: AdditionalFilter[];
+};
+/**
+ * Represents a cell in a layout, which can contain a component and has a specified column span.
+ */
+export declare class Cell {
+    /**
+     * The component contained within the cell. It's optional and can be undefined.
+     */
+    component: AnyView | undefined;
+    /**
+     * The span of the cell in terms of columns. Defaults to 12.
+     */
+    colSpan: number;
+    /**
+     * The local filters of the cell. Optional.
+     */
+    localFilters: AdditionalFilter[] | undefined;
+    /**
+     * Indicates whether the cell is empty. It's either true or undefined.
+     */
+    isEmpty: boolean | undefined;
+    /**
+     * Constructs a new Cell instance.
+     *
+     * @param attributes The attributes of the cell.
+     */
+    constructor(attributes?: CellAttributes);
+    /**
+     * Sets or updates the cell's component and column span.
+     *
+     * @param attributes The attributes to be set in the cell.
+     */
+    set(attributes: CellAttributes): void;
+    /**
+     * Sets the column span of the cell.
+     *
+     * @param colSpan The new column span for the cell. Number should be between 1 and 12.
+     */
+    setColSpan(colSpan: number): void;
+    /**
+     * Sets the component of the cell.
+     *
+     * @param component The component to be set in the cell.
+     */
+    setComponent(component: AnyView): void;
+    /**
+     * Clears the component from the cell and optionally sets a new column span.
+     * Marks the cell as empty.
+     *
+     * @param colSpan The new column span for the cell. If not provided, defaults to 12.
+     */
+    emptyCell(colSpan?: number): void;
+}

package/dist/types/services/src/Services/Dashboard.d.ts

@@ -0,0 +1,55 @@
+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 type CustomFields = {
+    [dataSetId: string]: Array<CustomField>;
+};
+/**
+ * Represents a DashboardAttributes type.
+ * @param display - The display configuration for the dashboard.
+ * @param customFields - The custom fields of the dashboard.
+ * @param library - The component library of the dashboard.
+ */
+export type DashboardAttributes = {
+    display?: (Row | Header)[];
+    customFields?: CustomFields;
+    library?: Library;
+};
+/**
+ * Represents a Dashboard class.
+ */
+export declare class Dashboard {
+    private dashboard;
+    /**
+     * Constructs a new instance of the Dashboard class.
+     * @param id - The id of the dashboard.
+     * @param attributes - The attributes of the dashboard.
+     * @throws Error if the dashboard id is undefined.
+     */
+    constructor(id?: string | undefined, attributes?: DashboardAttributes);
+    /**
+     * Sets the display configuration for the dashboard.
+     * @param display - An array of Row or Header objects representing the new
+     *                  display configuration for the dashboard.
+     * @throws Error if the dashboard instance is undefined.
+     */
+    setDisplay(display: (Row | Header)[]): void;
+    /**
+     * Sets the custom fields of the dashboard.
+     * @param customFields
+     */
+    setCustomFields(customFields: CustomFields): void;
+    /**
+     * Sets the component library of the dashboard.
+     * @param library
+     */
+    setLibrary(library: Library): void;
+    /**
+     * Builds a partial DashboardType object.
+     * @returns A partial DashboardType object.
+     */
+    build(): DashboardTypes.SaveableDashboardDefinition;
+}

package/dist/types/services/src/Services/Editor.d.ts

@@ -0,0 +1,25 @@
+import type { Component } from '../../../shared-logic/src/Component/types';
+import { AnyView } from './View';
+export type EditorAttributes = {
+    component?: AnyView;
+};
+/**
+ * Represents a Editor class.
+ */
+export declare class Editor {
+    private editor;
+    /**
+     * Constructs a new instance of the Editor class.
+     * @param attributes - The attributes of the Editor.
+     */
+    constructor(attributes?: EditorAttributes);
+    /**
+     * Sets the view of the Editor.
+     */
+    setComponent(component: AnyView): void;
+    /**
+     * Builds a partial Component object.
+     * @returns A Component for the Editor.
+     */
+    build(): Component;
+}

package/dist/types/services/src/Services/Header.d.ts

@@ -0,0 +1,19 @@
+import { DisplayRow } from '../../../shared-logic/src/Display/types';
+export type HeaderRow = DisplayRow[];
+/**
+ * Represents a Header class.
+ */
+export declare class Header {
+    /** The header component. */
+    component: HeaderRow | undefined;
+    /**
+     * Constructs a new instance of the HeaderServices class.
+     * @param title - An optional title for the header.
+     */
+    constructor(title?: string);
+    /**
+     * Sets the title of the header.
+     * @param title - The title to set.
+     */
+    setTitle(title: string): void;
+}

package/dist/types/services/src/Services/Library.d.ts

@@ -0,0 +1,43 @@
+import { AdditionalFilter } from '../../../shared-logic/src/AdditionalFilter/types';
+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 type LibraryView = {
+    component: Views.AnyView;
+    uniqueViewId: string;
+};
+export declare class Library {
+    /**
+     * An array of Cell instances representing the cells in the library.
+     */
+    library: Cell[] | undefined;
+    /**
+     * Creates a new instance of a Library.
+     * @param attributes An optional object containing the attributes of 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.
+     */
+    constructor(attributes?: {
+        components?: LibraryView[];
+    });
+    /**
+     * Adds a cell to the library at a specified position or appends it at the end if no position is specified.
+     * @param component The Component instance to be added to the library.
+     * @param uniqueViewId The unique view id of the component, should always be the same and not auto-generated. The `uniqueViewId` will become the `viewId` of the component.
+     * @param attributes An optional object containing the attributes of the cell.
+     * @example library.addComponent(Vizzly.AreaChart, "uniqueViewId");
+     * @example library.addComponent(Vizzly.AreaChart, "uniqueViewId", { position: 0 });
+     */
+    addComponent(component: Views.AnyView, uniqueViewId: string, attributes?: {
+        position?: number;
+        localFilters?: AdditionalFilter[];
+    }): void;
+    /**
+     *  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: LibraryView[]): void;
+}
+export declare const mergeInViewId: (component: Views.AnyView, uniqueViewId: string) => Views.AnyView;

package/dist/types/services/src/Services/Row.d.ts

@@ -0,0 +1,45 @@
+import { Cell } from './Cell';
+/**
+ * Represents a Row class.
+ */
+export declare class Row {
+    /**
+     * An array of Cell instances representing the cells in the row.
+     */
+    components: Cell[];
+    /**
+     * The height of the row, defaulting to 350.
+     */
+    height: number | undefined;
+    /**
+     * Creates a new instance of a Row.
+     * @param components An optional array of Cell instances to initialize the row.
+     * @param height An optional height for the row, defaults to 350.
+     */
+    constructor(components?: Cell[], height?: number);
+    /**
+     * Adds a cell to the row at a specified position or appends it at the end if no position is specified.
+     *
+     * @param component The Cell instance to be added to the row.
+     * @param position (Optional) The zero-based index at which to add the cell.
+     *                 If omitted, the cell is added at the end of the row.
+     */
+    addCell(component: Cell, position?: number): void;
+    /**
+     * Sets the height of the row.
+     * @param height The height to set for the row.
+     */
+    setHeight(height: number): void;
+    /**
+     * Sets the cells and optionally the height of the row.
+     * @param components An array of Cell instances.
+     */
+    setRow(components: Cell[]): void;
+    /**
+     * Sets the cells and optionally the height of the row.
+     * @param components An array of Cell instances.
+     * @param height An optional height to set for the row.
+     */
+    set(components: Cell[], height?: number): void;
+    private validateTotalColSpan;
+}

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

@@ -0,0 +1,85 @@
+import type { Component } from '../../../shared-logic/src/Component/types';
+import { ViewConfiguration as ViewConfigurationImported } from '../../../shared-logic/src/ViewConfiguration/types';
+import { Vizzly } from '..';
+export type ViewConfiguration = ViewConfigurationImported;
+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 type AnyView = AreaChart | LineChart | BarChart | PieChart | BubbleChart | ScatterChart | ComboChart | PivotTable | BasicTable | HorizontalBarChart | MercatorMap | SingleStat | Progress | RichText | WaterfallChart;
+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 BubbleChart extends View<Component.BubbleChartAttributes> {
+    constructor(attributes: Partial<Component.BubbleChartAttributes> & RequiredAttributes<Component.BubbleChartAttributes>);
+    static type(): Component.BubbleChartAttributes['type'];
+}
+export declare class SunburstChart extends View<Component.SunburstChartAttributes> {
+    constructor(attributes: Partial<Component.SunburstChartAttributes> & RequiredAttributes<Component.SunburstChartAttributes>);
+    static type(): Component.SunburstChartAttributes['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 declare class RichText extends View<Component.RichTextAttributes> {
+    constructor(attributes: Partial<Component.RichTextAttributes> & RequiredAttributes<Component.RichTextAttributes>);
+    static type(): Component.RichTextAttributes['type'];
+}
+export declare class WaterfallChart extends View<Component.WaterfallChartAttributes> {
+    constructor(attributes: Partial<Component.WaterfallChartAttributes> & RequiredAttributes<Component.WaterfallChartAttributes>);
+    static type(): Component.WaterfallChartAttributes['type'];
+}
+export declare class RadarChart extends View<Component.RadarChartAttributes> {
+    constructor(attributes: Partial<Component.RadarChartAttributes> & RequiredAttributes<Component.RadarChartAttributes>);
+    static type(): Component.RadarChartAttributes['type'];
+}
+export {};

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

@@ -0,0 +1,7 @@
+export { Cell } from './Cell';
+export { Dashboard } from './Dashboard';
+export { Library } from './Library';
+export { Editor } from './Editor';
+export { Header } from './Header';
+export { Row } from './Row';
+export { View } from './View';

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

@@ -0,0 +1,46 @@
+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';
+import { CustomField } from '../../shared-logic/src/CustomField/types';
+export type LoaderOptions = {
+    apiHost: string;
+    textOverrides?: Partial<VizzlyTranslations>;
+    developerMode?: boolean;
+};
+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?;
+    private extraCustomFields?;
+    options: LoaderOptions;
+    constructor(queryEngine: 'in-browser' | QueryEngineEndpoint | loadQueryEngineConfigCallback | undefined, loadAccessTokens: identityCallback, loadDataSetsCallback?: loadDataSetsCallback, extraCustomFields?: (dataSet: DataSet) => Array<CustomField>, options?: LoaderOptions);
+    getQueryEngineConfig(): Promise<QueryEngineConfig>;
+    getIdentity(): Promise<{
+        accessTokens: AccessTokens;
+        identityConfig: IdentityConfig;
+    }>;
+    getDataSets(): Promise<DataSet[]>;
+    load(): Promise<{
+        queryEngineConfig: import("@vizzly/semantic-layer-public/dist/types").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/types/services/src/errors/ServicesValidationError.d.ts

@@ -0,0 +1,2 @@
+export declare class ServicesValidationError extends Error {
+}

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

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

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

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

package/dist/types/services/src/eventbus.types.d.ts

@@ -0,0 +1,28 @@
+import { Component } from '../../shared-logic/src/Component/types';
+import { GlobalLibrary } from '../../shared-logic/src/GlobalLibrary';
+export type AddComponentToLibraryEvent = {
+    action: 'addComponentToLibrary';
+    component: Component;
+    customFields: GlobalLibrary.CustomFields;
+};
+export type DeleteComponentFromLibraryEvent = {
+    action: 'deleteComponentFromLibrary';
+    component: Component;
+};
+export type NewViewsInGlobalLibraryEvent = {
+    action: 'newViewsInGlobalLibrary';
+};
+export declare enum GlobalLibraryUpdateStatus {
+    SAVING = "saving",
+    SAVED = "saved",
+    DELETED = "deleted"
+}
+export type UpdateToGlobalLibraryStatus = {
+    action: 'updateToGlobalLibraryStatus';
+    state: GlobalLibraryUpdateStatus;
+};
+export type EventBus = (event: EventBusParams) => void;
+export type EventBusParams = {
+    data: EventBusOptions;
+};
+export type EventBusOptions = AddComponentToLibraryEvent | NewViewsInGlobalLibraryEvent | UpdateToGlobalLibraryStatus | DeleteComponentFromLibraryEvent;

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

@@ -0,0 +1,183 @@
+import { QueryEngineConfig, QueryEngineEndpoint } from '../../shared-logic/src/QueryEngineConfig/types';
+import { identityCallback, loadDataCallback, 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, UpdateGlobalLibraryParams as APIUpdateGlobalLibraryParams, GlobalLibrary, GlobalLibraryPermission, CreateGlobalLibraryParams } 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, Cell, Dashboard, Header, Library, Editor } from './Services';
+import * as Views from './Services/View';
+import { ViewConfiguration } from '../../shared-logic/src/ViewConfiguration/types';
+import { EventBus, EventBusParams } from './eventbus.types';
+import { QueryAttributes } from '../../shared-logic/src/QueryAttributes/types';
+import { CustomDriver } from 'results-driver/src/types';
+import { Result } from '../../shared-logic/src/Result/types';
+import { DateTimeFilterOptions } from '../../shared-logic/src/DateTime/types';
+import { VariableList } from '../../shared-logic/src/Variables/types';
+import { FilterConfig } from '../../shared-logic/src/AdditionalFilter/types';
+export type { FilterConfig } from '../../shared-logic/src/AdditionalFilter/types';
+export type { ViewConfiguration } from '../../shared-logic/src/ViewConfiguration/types';
+export { VizzlyInstanceNotLoaded } from './errors/VizzlyInstanceNotLoaded';
+import { CustomField } from '../../shared-logic/src/CustomField/types';
+import { AliasFields } from '../../shared-logic/src/AliasFields/types';
+export type Options = {
+    apiHost: string;
+};
+export type FilterDashboardOptions = {
+    onlyAllowScope?: 'read' | 'read_write';
+    onlyChildDashboardsForParent?: string;
+    onlyChildDashboards?: boolean;
+    onlyParentDashboards?: boolean;
+    onlyDashboardsIncludingMetadata?: DashboardLogic.Dashboard['metadata'];
+};
+export type VizzlyServicesProperties = {
+    queryEngine: 'in-browser' | QueryEngineEndpoint | loadQueryEngineConfigCallback | undefined;
+    identity: identityCallback;
+    programmaticDashboard?: programmaticDashboardCallback;
+    dataSets?: loadDataSetsCallback;
+    extraCustomFields?: (dataSet: DataSet) => Array<CustomField>;
+};
+declare class VizzlyServices {
+    private queryEngineConfig;
+    static queryEngine: QueryEngineEndpoint | loadQueryEngineConfigCallback | undefined;
+    private dataSets;
+    private identityConfig;
+    private vizzlyAPIClient;
+    private programmaticDashboard;
+    static _instanceStore: {
+        [instanceId: string]: VizzlyServices;
+    };
+    static DEFAULT_INSTANCE_ID: string;
+    private static eventBus;
+    private globalLibraryPermissions;
+    constructor(identityConfig: IdentityConfig, queryEngineConfig: QueryEngineConfig, dataSets: DataSet[], dashboardStorageStrategy: DashboardStorageStrategy, programmaticDashboard: programmaticDashboardCallback | undefined, options: {
+        host: string;
+    });
+    getDataSets(): DataSet[];
+    /**
+     * @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>;
+    updateScheduledReport(dashboardAccessToken: string, reportId: string, newCron: string | null): Promise<true | {
+        report: import("@vizzly/api-client").PersistedReport;
+    } | undefined>;
+    getScheduledReports(dashboardAccessToken: string): Promise<{
+        reports: Array<import("@vizzly/api-client").PersistedReport>;
+    }>;
+    getDashboards(params?: {
+        abortController?: AbortController;
+    }): Promise<DashboardLogic.Dashboard[]>;
+    createGlobalLibrary(params: CreateGlobalLibraryParams): Promise<{
+        global_library: GlobalLibrary;
+        permissions: import("@vizzly/api-client/dist/types").GlobalLibraryPermission[];
+    }>;
+    getGlobalLibraries(params?: {
+        abortController?: AbortController;
+    }): Promise<GlobalLibraryLogic.GlobalLibrary.Base[]>;
+    /**
+     * Provides the configuration needed for each Vizzly view.
+     */
+    getViewConfiguration(): ViewConfiguration;
+    getIdentityConfig(): IdentityConfig;
+    query(queries: Query[], params?: QueryParams): Promise<QueryResponse>;
+    static upcastDashboard(dashboard: DashboardFromAPI, dataSets: DataSet[], queryEngineConfig: QueryEngineConfig): Array<DashboardLogic.Dashboard>;
+    static filterDashboards(dashboards: DashboardLogic.Dashboard[], options: FilterDashboardOptions): DashboardLogic.Dashboard[];
+    updateGlobalLibrary(params: UpdateGlobalLibraryParams): Promise<GlobalLibrary | undefined>;
+    private static eventBusController;
+    /**
+     * Publishes data to all subscribed event bus listeners.
+     * This method is static and will affect all instances of Vizzly.
+     * @param data The event bus options containing dashboard data and targets.
+     */
+    static publish(event: EventBusParams): void;
+    /**
+     * Subscribes a new listener to the event bus and provides a method to unsubscribe.
+     * @param listener The event listener to subscribe.
+     * @returns A function that unsubscribes the listener when called.
+     */
+    static subscription(listener: EventBus): () => void;
+    static Row: typeof Row;
+    static Cell: typeof Cell;
+    static Dashboard: typeof Dashboard;
+    static Editor: typeof Editor;
+    static Header: typeof Header;
+    static Library: typeof Library;
+    static AreaChart: typeof Views.AreaChart;
+    static LineChart: typeof Views.LineChart;
+    static RadarChart: typeof Views.RadarChart;
+    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;
+    static WaterfallChart: typeof Views.WaterfallChart;
+}
+export type UpdateDashboardParams = {
+    dashboardId: string;
+    definition?: DashboardLogic.SaveableDashboardDefinition;
+    deleted?: boolean;
+    metadata?: Object;
+    /** @deprecated Use metadata instead. */
+    meta?: Object;
+    abortSignal?: AbortSignal;
+    name?: string;
+};
+export type UpdateGlobalLibraryParams = APIUpdateGlobalLibraryParams & {
+    globalLibraryId: string;
+    abortSignal?: AbortSignal;
+};
+export 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 type Query = QueryAttributes;
+export type QueryResponse = {
+    results: (Result | null)[] | (any[][] | null)[] | null;
+};
+export type Vizzly = VizzlyServices;
+export declare const Vizzly: typeof VizzlyServices;
+export type QueryParams = {
+    abortController?: AbortController;
+    instanceId?: string;
+    runQueries?: CustomDriver['runQueries'];
+    data?: loadDataCallback;
+    queryEngineEndpoint?: QueryEngineEndpoint;
+    dateFilterOptions?: DateTimeFilterOptions;
+    variables?: VariableList;
+    aliasFields?: AliasFields;
+    filterConfig?: FilterConfig;
+};

package/dist/types/services/src/schemaValidations/cell.d.ts

@@ -0,0 +1 @@
+export declare function validateColSpan(colSpan: number): number;

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

@@ -0,0 +1,6 @@
+import { QueryEngineConfig } from '../../../shared-logic/src/QueryEngineConfig/types';
+import { CreateDashboardParams, UpdateDashboardParams } from '..';
+import { JoiOptions } from '../../../shared-logic/src/validations';
+export declare const validateDashboardJoiOptions: JoiOptions;
+export declare const validateCreateDashboardParams: (params: CreateDashboardParams, queryEngineConfig: QueryEngineConfig | undefined) => void;
+export declare const validateUpdateDashboardParams: (params: UpdateDashboardParams, queryEngineConfig: QueryEngineConfig) => void;

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

@@ -0,0 +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[];

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

@@ -0,0 +1,2 @@
+export * from './query';
+export * from './dashboard';

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

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

package/dist/types/services/src/schemaValidations/query.d.ts

@@ -0,0 +1,3 @@
+import { Query } from '../';
+import { QueryEngineConfig } from '../../../shared-logic/src/QueryEngineConfig/types';
+export declare const validateQuery: (params: Query[], queryEngineConfig: QueryEngineConfig) => void;