@aintela/bi 0.2.0

package/dist/grid/GridCard.d.ts

@@ -0,0 +1,45 @@
+import { default as React, HTMLAttributes, ReactNode, CSSProperties } from 'react';
+import { SvgIconComponent } from '@mui/icons-material';
+/** Header configuration for GridCard */
+export interface GridCardHeader {
+    title: string;
+    /** Material Icons ligature name (host loads the font) or an MUI icon component */
+    icon?: string | SvgIconComponent;
+}
+/** Predefined accent variants for the card */
+export type GridCardColor = 'kpi' | 'chart' | 'table' | 'info' | 'iframe' | 'details' | 'custom';
+export type GridCardContentDisplay = 'default' | 'grid';
+/**
+ * - "Boxed": default look with header, border accents, etc.
+ * - "Naked": no header, no border accents, blends with the background; only
+ *            subtle drag/resize handles on hover.
+ */
+export type GridCardViewType = 'Boxed' | 'Naked';
+export interface GridCardProps extends HTMLAttributes<HTMLDivElement> {
+    className?: string;
+    variant?: 'default' | 'elevated';
+    viewType?: GridCardViewType;
+    header?: GridCardHeader;
+    /** Custom header render function; overrides the default header. */
+    renderHeader?: (header: GridCardHeader) => ReactNode;
+    /** Accent variant. */
+    color?: GridCardColor;
+    /** Custom accent (used when color="custom"): any CSS colour, e.g. a theme token you resolved. */
+    customColor?: string;
+    contentDisplay?: GridCardContentDisplay;
+    contentStyle?: CSSProperties;
+    contentClassName?: string;
+    noBorder?: boolean;
+    /** Raw CSS injected in a `<style>` next to the card (dashboard bundles emit per-card styles). */
+    htmlStyle?: string;
+    dragLocked?: boolean;
+    zoomLevel?: number;
+    isResizable?: boolean;
+}
+/**
+ * GridCard — a card usable directly as a react-grid-layout item. Forwards the
+ * ref and the mouse/touch props RGL needs; use it as a direct child of
+ * `GridLayout` with a `key`.
+ */
+export declare const GridCard: React.ForwardRefExoticComponent<GridCardProps & React.RefAttributes<HTMLDivElement>>;
+export default GridCard;

package/dist/grid/GridCardPlaceHolder.d.ts

@@ -0,0 +1,8 @@
+import { default as React, HTMLAttributes } from 'react';
+export interface GridCardPlaceHolderProps extends HTMLAttributes<HTMLDivElement> {
+    static?: boolean;
+    naked?: boolean;
+}
+/** An empty grid item drawn while a card is being sketched / dropped. */
+export declare const GridCardPlaceHolder: React.ForwardRefExoticComponent<GridCardPlaceHolderProps & React.RefAttributes<HTMLDivElement>>;
+export default GridCardPlaceHolder;

package/dist/grid/GridLayout.d.ts

@@ -0,0 +1,147 @@
+import { default as React } from 'react';
+import { Layout, LayoutItem } from 'react-grid-layout';
+import { GridConfig, ResponsiveGridConfig, ResponsiveLayouts, BreakpointName } from './types';
+import { AutoResponsiveStrategy } from './useGridConfigTranslator';
+/**
+ * Props for the GridLayout component
+ */
+export interface GridLayoutProps {
+    /**
+     * Grid configuration abstraction (rows/cells)
+     * Used to generate the initial layout
+     */
+    config?: GridConfig | ResponsiveGridConfig;
+    /**
+     * Optional override layouts (native format)
+     * When provided, these are used instead of translating config
+     * Use this for persisted user modifications
+     */
+    layouts?: Layout | ResponsiveLayouts;
+    /**
+     * Whether to automatically generate responsive layouts for different breakpoints.
+     * When true (default), a single GridConfig is automatically adapted for all screen sizes.
+     * When false, the same layout is used for all breakpoints (only scaled by column count).
+     * @default true
+     */
+    responsive?: boolean;
+    /**
+     * Strategy for auto-responsive layout generation.
+     * - "scale": Proportionally scale widths (items may become narrow)
+     * - "stack": Stack items vertically on small screens (full width)
+     * - "hybrid": Scale for medium screens, stack for small screens (default)
+     * Only applies when `responsive` is true and a single GridConfig is provided.
+     * @default "hybrid"
+     */
+    autoResponsiveStrategy?: AutoResponsiveStrategy;
+    dragLocked?: boolean;
+    /**
+     * Row height in pixels
+     * @default 25
+     */
+    rowHeight?: number;
+    /**
+     * Row height in pixels
+     * @default 50
+     */
+    rowMultiplier?: number;
+    /**
+     * Breakpoint definitions (name → min-width)
+     * @default { lg: 1200, md: 900, sm: 768, xs: 480, xxs: 0 }
+     */
+    breakpoints?: Record<BreakpointName, number>;
+    /**
+     * Column counts per breakpoint
+     * @default { lg: 12, md: 12, sm: 12, xs: 4, xxs: 2 }
+     */
+    cols?: Record<BreakpointName, number>;
+    /**
+     * Maximum number of rows
+     * @default Infinity
+     */
+    maxRows?: number;
+    /**
+     * Called when layout changes (after drag or resize ends)
+     * Only fires when layout actually changed
+     */
+    onLayoutChange?: (layout: Layout, allLayouts: ResponsiveLayouts) => void;
+    /**
+     * User-driven boundaries. RGL fires these only at the end of a real
+     * resize / drag interaction — *not* on prop syncs or layout reflows.
+     * Use these (instead of `onLayoutChange`) when the consumer needs a
+     * "the user committed a change" signal that shouldn't fire when a
+     * fresh `layouts` prop comes in from above.
+     */
+    onResizeStop?: (layout: Layout, oldItem: LayoutItem | null, newItem: LayoutItem | null) => void;
+    onDragStop?: (layout: Layout, oldItem: LayoutItem | null, newItem: LayoutItem | null) => void;
+    /**
+     * Children components (must have key prop matching cell keys)
+     */
+    children: React.ReactNode;
+    zoomLevel?: number;
+    /**
+     * Additional class name for the container
+     */
+    className?: string;
+    /**
+     * Additional styles for the container
+     */
+    style?: React.CSSProperties;
+    onDrop?: (data: any, item?: LayoutItem) => void;
+    manualWidth?: number;
+    /**
+     * Row-aware resize.
+     *
+     * When configured, dragging a card's resize handle adjusts the height
+     * of every "row sibling" — items whose top edge (`y`) matches the
+     * resized item's `y` — together. The width of the resized item is
+     * unaffected, and so are widths/heights of any items NOT in the row.
+     *
+     * - Pass `true` for the default policy: a modifier (Shift) must be
+     *   held to opt into row-aware behaviour for a given drag.
+     * - Pass an object to invert the default (`defaultOn: true` makes
+     *   row-aware the no-modifier behaviour and the modifier turns it
+     *   OFF for that drag) and/or to pick a different modifier key.
+     * - Pass `false` (or omit the prop) to disable entirely.
+     */
+    rowAwareResize?: boolean | RowAwareResizeConfig;
+}
+export interface RowAwareResizeConfig {
+    /** Master switch. Defaults to `true` when this object is supplied. */
+    enabled?: boolean;
+    /**
+     * When `true`, row-aware resize is the DEFAULT and holding the
+     * modifier inverts it (i.e. the modifier disables row-aware for that
+     * drag). When `false` (default), the user must hold the modifier to
+     * opt into row-aware for that drag.
+     */
+    defaultOn?: boolean;
+    /** Modifier key that flips the default behaviour. */
+    modifierKey?: 'Shift' | 'Alt' | 'Ctrl' | 'Meta';
+}
+/**
+ * GridLayout component
+ *
+ * A wrapper around react-grid-layout's Responsive component that accepts
+ * a simplified row/cell configuration and translates it to the native format.
+ *
+ * @example
+ * ```tsx
+ * const config: GridConfig = {
+ *   rows: [
+ *     { height: 1, cells: [{ key: "header", width: 12 }] },
+ *     { height: 3, cells: [
+ *       { key: "chart1", width: 6 },
+ *       { key: "chart2", width: 6 }
+ *     ]}
+ *   ]
+ * };
+ *
+ * <GridLayout config={config} onLayoutChange={handleChange}>
+ *   <div key="header">Header</div>
+ *   <div key="chart1">Chart 1</div>
+ *   <div key="chart2">Chart 2</div>
+ * </GridLayout>
+ * ```
+ */
+export declare const GridLayout: React.FC<GridLayoutProps>;
+export default GridLayout;

package/dist/grid/gridModels.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Grid layout abstraction shared by the Dashboard model and GridLayout:
+ * a tree of rows and cells that `translateGridConfig` flattens into
+ * react-grid-layout items.
+ */
+export interface CellConfig {
+    /** Unique key for the cell (must match children keys) */
+    key?: string;
+    /** Width in grid units (out of 12 for root level) */
+    width: number;
+    /** Height override (defaults to parent row's height) */
+    height?: number;
+    minW?: number;
+    maxW?: number;
+    minH?: number;
+    maxH?: number;
+    /** Nested rows within this cell */
+    rows?: RowConfig[];
+    /** If true, item cannot be dragged or resized; others compact around it. */
+    static?: boolean;
+    isDraggable?: boolean;
+    isResizable?: boolean;
+}
+export interface RowConfig {
+    /** Height in grid units (default: 1) */
+    height?: number;
+    cells: CellConfig[];
+}
+export interface GridConfig {
+    rows: RowConfig[];
+    /** Internal — set by GridLayout from its `rowMultiplier` prop. */
+    rowMultipler?: number;
+}

package/dist/grid/index.d.ts

@@ -0,0 +1,14 @@
+export { GridLayout } from './GridLayout';
+export type { GridLayoutProps, RowAwareResizeConfig } from './GridLayout';
+export { GridCard } from './GridCard';
+export type { GridCardProps, GridCardHeader, GridCardColor, GridCardContentDisplay, GridCardViewType } from './GridCard';
+export { GridCardPlaceHolder } from './GridCardPlaceHolder';
+export type { GridCardPlaceHolderProps } from './GridCardPlaceHolder';
+export { ChartContextProvider, useChartContext } from './ChartContext';
+export type { ChartContextState } from './ChartContext';
+export { BiErrorBoundary } from './BiErrorBoundary';
+export type { BiErrorBoundaryProps } from './BiErrorBoundary';
+export { useGridConfigTranslator, translateGridConfig, translateResponsiveGridConfig, translateGridConfigAutoResponsive, } from './useGridConfigTranslator';
+export type { UseGridConfigTranslatorOptions, UseGridConfigTranslatorResult, AutoResponsiveStrategy } from './useGridConfigTranslator';
+export type { CellConfig, RowConfig, GridConfig, ResponsiveGridConfig, ResponsiveLayouts, BreakpointName } from './types';
+export { DEFAULT_BREAKPOINTS, DEFAULT_COLS, DEFAULT_ROW_HEIGHT, DEFAULT_ROW_MULTIPLIER, DEFAULT_MAX_ROWS } from './types';

package/dist/grid/types.d.ts

@@ -0,0 +1,23 @@
+import { Layout } from 'react-grid-layout';
+import { GridConfig } from './gridModels';
+export type { CellConfig, RowConfig, GridConfig } from './gridModels';
+/** Breakpoint names supported by the grid */
+export type BreakpointName = 'lg' | 'md' | 'sm' | 'xs' | 'xxs';
+/** Responsive grid configuration — a GridConfig per breakpoint */
+export interface ResponsiveGridConfig {
+    lg?: GridConfig;
+    md?: GridConfig;
+    sm?: GridConfig;
+    xs?: GridConfig;
+    xxs?: GridConfig;
+    rowMultipler?: number;
+}
+/** Responsive layouts (native react-grid-layout format) */
+export type ResponsiveLayouts = {
+    [K in BreakpointName]?: Layout;
+};
+export declare const DEFAULT_BREAKPOINTS: Record<BreakpointName, number>;
+export declare const DEFAULT_COLS: Record<BreakpointName, number>;
+export declare const DEFAULT_ROW_HEIGHT = 20;
+export declare const DEFAULT_ROW_MULTIPLIER = 3;
+export declare const DEFAULT_MAX_ROWS = 36;

package/dist/grid/useGridConfigTranslator.d.ts

@@ -0,0 +1,72 @@
+import { Layout } from 'react-grid-layout';
+import { GridConfig, ResponsiveGridConfig, ResponsiveLayouts, BreakpointName } from './types';
+/**
+ * Translates a GridConfig (row/cell tree) into a flat Layout array
+ * that react-grid-layout understands.
+ *
+ * @param config - The grid configuration
+ * @param cols - Number of columns (default: 12)
+ * @returns Flat layout array for react-grid-layout
+ */
+export declare function translateGridConfig(config: GridConfig, cols?: number): Layout;
+/**
+ * Translates a ResponsiveGridConfig into ResponsiveLayouts
+ * If a breakpoint is not defined, it falls back to larger breakpoints
+ *
+ * @param config - The responsive grid configuration
+ * @param colsPerBreakpoint - Columns per breakpoint (default: DEFAULT_COLS)
+ * @returns Responsive layouts object for react-grid-layout
+ */
+export declare function translateResponsiveGridConfig(config: ResponsiveGridConfig, colsPerBreakpoint?: Record<BreakpointName, number>): ResponsiveLayouts;
+/**
+ * Auto-responsive translation strategy.
+ * Determines how items should be arranged when columns decrease.
+ */
+export type AutoResponsiveStrategy = "scale" | "stack" | "hybrid";
+/**
+ * Translates a single GridConfig into responsive layouts automatically.
+ *
+ * This function intelligently adapts the layout for different screen sizes:
+ * - For breakpoints with same column count as base: preserves layout
+ * - For breakpoints with fewer columns: applies the chosen strategy
+ *
+ * Strategies:
+ * - "scale": Proportionally scale widths (items may become very narrow)
+ * - "stack": Stack items vertically (each item becomes full width)
+ * - "hybrid": Scale for moderate reductions, stack for small screens (default)
+ *
+ * @param config - The grid configuration (designed for lg/12 columns)
+ * @param colsPerBreakpoint - Columns per breakpoint (default: DEFAULT_COLS)
+ * @param strategy - How to handle smaller breakpoints (default: "hybrid")
+ * @returns Responsive layouts object for react-grid-layout
+ */
+export declare function translateGridConfigAutoResponsive(config: GridConfig, colsPerBreakpoint?: Record<BreakpointName, number>, strategy?: AutoResponsiveStrategy): ResponsiveLayouts;
+/**
+ * Options for the useGridConfigTranslator hook
+ */
+export interface UseGridConfigTranslatorOptions {
+    /** Grid configuration (single or responsive) */
+    config: GridConfig | ResponsiveGridConfig;
+    /** Whether the config is responsive (has per-breakpoint configs) */
+    responsive?: boolean;
+    /** Columns per breakpoint (only used if responsive) */
+    cols?: Record<BreakpointName, number>;
+}
+/**
+ * Result of the useGridConfigTranslator hook
+ */
+export interface UseGridConfigTranslatorResult {
+    /** Single layout (only if not responsive) */
+    layout: Layout | undefined;
+    /** Responsive layouts (only if responsive) */
+    layouts: ResponsiveLayouts | undefined;
+}
+/**
+ * Hook to translate GridConfig to react-grid-layout format
+ * Memoizes the result to avoid unnecessary recalculations
+ *
+ * @param options - Translation options
+ * @returns Translated layout(s)
+ */
+export declare function useGridConfigTranslator(options: UseGridConfigTranslatorOptions): UseGridConfigTranslatorResult;
+export default useGridConfigTranslator;

package/dist/grid.d.ts

@@ -0,0 +1,2 @@
+export * from './grid/index'
+export {}

package/dist/grid.js

@@ -0,0 +1,20 @@
+import { B as s, D as o, a as t, b as e, c as i, d, G as n, e as C, f as E, t as G, g as L, h as T, u as A } from "./index-DGyvUtY3.js";
+import { C as f, u } from "./ChartContext-C_f_6khG.js";
+export {
+  s as BiErrorBoundary,
+  f as ChartContextProvider,
+  o as DEFAULT_BREAKPOINTS,
+  t as DEFAULT_COLS,
+  e as DEFAULT_MAX_ROWS,
+  i as DEFAULT_ROW_HEIGHT,
+  d as DEFAULT_ROW_MULTIPLIER,
+  n as GridCard,
+  C as GridCardPlaceHolder,
+  E as GridLayout,
+  G as translateGridConfig,
+  L as translateGridConfigAutoResponsive,
+  T as translateResponsiveGridConfig,
+  u as useChartContext,
+  A as useGridConfigTranslator
+};
+//# sourceMappingURL=grid.js.map

package/dist/grid.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grid.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}

package/dist/hooks/DashboardParametersContext.d.ts

@@ -0,0 +1,32 @@
+import { default as React, ReactNode } from 'react';
+export interface ParametersStateSlim {
+    dashboardId: string;
+    parameters: Record<string, string | string[]>;
+    /**
+     * Monotonic counter the host bumps to force every active
+     * `useDashboardData` consumer to re-fetch with `noCache`. Defaults to 0;
+     * the hook treats the first observed value as the baseline (mounting is
+     * never a force-refresh).
+     */
+    refreshTick?: number;
+    /**
+     * Admin-only runtime override for the dataset on a parameterised
+     * dashboard. Shipped in every data-fetch POST body; the server validates
+     * and silently drops it for non-admin callers.
+     */
+    datasetOverride?: string;
+}
+export interface ParametersState {
+    dashboardId: string;
+    parameters: Record<string, string | string[]>;
+    setParameter: (key: string, value: string | string[] | undefined) => void;
+    getParameter: (key: string) => string | string[] | undefined;
+    refreshTick: number;
+    datasetOverride?: string;
+}
+export declare const DashboardParametersContext: React.Context<ParametersState | undefined>;
+export declare function DashboardParametersProvider({ values, children }: {
+    values: ParametersStateSlim;
+    children: ReactNode;
+}): React.JSX.Element;
+export declare function useDashboardParameters(): ParametersState | undefined;

package/dist/hooks/index.d.ts

@@ -0,0 +1,8 @@
+export { useDashboardData } from './useDashboardData';
+export type { UseDashboardDataResult, SchemaInput, QueryResult, QueryResultRow, ResultField } from './useDashboardData';
+export { useDashboardLazyData } from './useDashboardLazyData';
+export type { LazyDataResult, LazySchemaInput } from './useDashboardLazyData';
+export { DashboardParametersContext, DashboardParametersProvider, useDashboardParameters } from './DashboardParametersContext';
+export type { ParametersState, ParametersStateSlim } from './DashboardParametersContext';
+export { createBiClient, BiClientProvider, useBiClient, useBiClientOptional, useBiSessionId } from '../client';
+export type { BiClient, BiClientOptions, BiRoutes, BiFetch, ArtifactUrlScope, QueryExecutionBody, PagedQueryBody, ExportQueryBody, BiClientProviderProps } from '../client';

package/dist/hooks/useDashboardData.d.ts

@@ -0,0 +1,20 @@
+import { DataResult, ColumnSchema, FieldType, InferModel } from '../data/dataUtils';
+import { QueryResult } from '../data/queryModel';
+export type { QueryResult, QueryResultRow, ResultField } from '../data/queryModel';
+export type SchemaInput<S extends Record<string, FieldType>> = ColumnSchema<S> | S;
+export interface UseDashboardDataResult {
+    data: QueryResult | null;
+    loading: boolean;
+    error: string | null;
+    refetch: () => void;
+    toDataResult: <const S extends Record<string, FieldType>>(schema: SchemaInput<S>) => DataResult<InferModel<S>> | null;
+}
+/**
+ * Fetches dashboard data by query hash through the injected `BiClient`
+ * (`client.runQuery(dashboardId, queryHash, body)`). The hash maps to a
+ * pre-registered SQL query on the server, so no raw SQL reaches the client.
+ *
+ * Reads all current parameters from `DashboardParametersContext`, POSTs them
+ * alongside the hash and re-fetches when they change.
+ */
+export declare function useDashboardData(queryHash: string): UseDashboardDataResult;

package/dist/hooks/useDashboardLazyData.d.ts

@@ -0,0 +1,79 @@
+import { GridApi, GridGetRowsParams, GridGetRowsResponse } from '@mui/x-data-grid-pro';
+import { ColumnSchema, FieldType, InferModel } from '../data/dataUtils';
+export type LazySchemaInput<S extends Record<string, FieldType>> = ColumnSchema<S> | S;
+/**
+ * Companion to {@link useDashboardData} for tables that page from the
+ * server. Returned object is consumed by `<DataTableCard lazyData={...} />`,
+ * which adapts it to MUI X DataGrid's `dataSource` prop. The card never
+ * builds an in-memory `DataResult` — sort/filter/paginate are delegated
+ * to the server via `client.getQueryPage(dashboardId, viewId, body)`.
+ *
+ * Per-page caching is intentionally not implemented here: MUI's
+ * built-in `dataSourceCache` already handles short-lived per-grid
+ * caching. We only invalidate via `apiRef.dataSource.fetchRows()` when
+ * dashboard parameters or `refreshTick` change.
+ */
+export interface LazyDataResult<TModel extends Record<string, any> = Record<string, any>> {
+    /** Direct passthrough to `<DataGrid dataSource={{ getRows }} />`. */
+    getRows: (params: GridGetRowsParams) => Promise<GridGetRowsResponse>;
+    /** Wired to `<DataGrid onDataSourceError={...} />` so fetch failures show the standard overlay. */
+    onError: (err: unknown) => void;
+    /** Owned by the hook so refetch-on-parameter-change can call `dataSource.fetchRows()`. */
+    apiRef: React.MutableRefObject<GridApi>;
+    /** Same column-config surface as `DataResult.columnSchema`. */
+    columnSchema: ColumnSchema<any>;
+    error: string | null;
+    /** True while any page request is in flight. Card uses it to drive the grid's loading overlay. */
+    loading: boolean;
+    /** Bypasses MUI's cache for the next set of fetches. */
+    refetch: () => void;
+    /**
+     * Streams the full server-side rowset as CSV (`client.exportQuery(..., 'csv', body)`)
+     * and triggers a browser download. Honors the current sort/filter
+     * state from the grid and the current dashboard parameters — so
+     * the downloaded file matches what the user is looking at, not the
+     * raw view body.
+     *
+     * The endpoint streams chunked, so even multi-million-row exports
+     * don't blow client or server memory.
+     */
+    downloadCsv: (filename?: string) => Promise<void>;
+    /**
+     * Same as {@link downloadCsv}, but hits the XLSX endpoint instead.
+     * The server writes the workbook to a temp file via MiniExcel and
+     * streams it back; client memory is bounded by the browser's blob
+     * file-store backing (large blobs page to disk automatically).
+     */
+    downloadXlsx: (filename?: string) => Promise<void>;
+    /**
+     * True from the moment {@link downloadCsv} or {@link downloadXlsx}
+     * is invoked until the download has either completed or failed.
+     * Toolbar uses this to show a progress indicator and disable the
+     * menu items.
+     */
+    exporting: boolean;
+    /**
+     * Compatibility shim with the {@link useDashboardData} →
+     * {@link toDataResult} pattern. Returns the same lazy result
+     * unchanged — the schema must already have been supplied to
+     * `useDashboardLazyData(viewId, schema)` (it drives dynamic
+     * distinct-value fetches and column rendering that the hook
+     * can't wire up after the fact).
+     *
+     * Exists purely so LLM-generated code that mirrors the local-
+     * mode pattern
+     * `const result = useDashboardLazyData('view').toLazyDataResult(schema)`
+     * compiles and behaves correctly. The `schema` argument is
+     * accepted and ignored; if the hook was called without a schema
+     * the TS compiler already flagged that at the call site.
+     */
+    toLazyDataResult: (schema?: unknown) => LazyDataResult<TModel>;
+}
+/**
+ * Hook factory: `useDashboardLazyData('view-id', schema)` returns a
+ * {@link LazyDataResult} ready to be passed to `<DataTableCard lazyData={...} />`.
+ *
+ * @param viewId server-side view name (same identifier as `useDashboardData`)
+ * @param schemaInput a schema literal (e.g. `{ airlineIata: 'string' } as const`) or a `ColumnSchema`
+ */
+export declare function useDashboardLazyData<const S extends Record<string, FieldType>>(viewId: string, schemaInput: LazySchemaInput<S>): LazyDataResult<InferModel<S>>;

package/dist/hooks.d.ts

@@ -0,0 +1,2 @@
+export * from './hooks/index'
+export {}

package/dist/hooks.js

@@ -0,0 +1,16 @@
+import { u as s, a as r } from "./index-D3OoOPjl.js";
+import { D as t, a as i, u } from "./DashboardParametersContext-Clv--79U.js";
+import { B as D, c as n, u as m, a as B, e as b } from "./BiClientProvider-CWJochvi.js";
+export {
+  D as BiClientProvider,
+  t as DashboardParametersContext,
+  i as DashboardParametersProvider,
+  n as createBiClient,
+  m as useBiClient,
+  B as useBiClientOptional,
+  b as useBiSessionId,
+  s as useDashboardData,
+  r as useDashboardLazyData,
+  u as useDashboardParameters
+};
+//# sourceMappingURL=hooks.js.map

package/dist/hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}