@wisdomai/react 0.0.8

package/AGENTS.md

@@ -0,0 +1,111 @@
+# @wisdomai/react — agent setup guide
+
+Instructions for an AI coding agent integrating `@wisdomai/react` into a React
+app. This SDK renders dashboards authored on the Wisdom platform, with live data
+and interactive filtering. This file is a condensed, actionable companion to
+`README.md` — consult the README for full detail.
+
+## Install
+
+```bash
+npm install @wisdomai/react
+```
+
+The host app must provide these peer dependencies: `react` (>=18), `react-dom`
+(>=18), `@mui/material` (^7), `@mui/x-date-pickers` (^7), `@emotion/react` (^11),
+`@emotion/styled` (^11), `highcharts` (^12), `highcharts-react-official` (^3),
+`graphql` (^16), `luxon` (^3).
+
+`@wisdomai/react` is **ESM-only**. Pure-CommonJS callers must use dynamic
+`import()`.
+
+## Setup
+
+### 1. Serve a token endpoint from the app's backend
+
+Add `POST /auth-token` on the **same origin** as the app, returning
+`{ jwt: string, baseUrl: string }`. The backend exchanges a long-lived,
+server-side access token for a short-lived browser JWT.
+
+Hard requirements — do not skip:
+
+- **Protect the route with the app's own authentication.** Only signed-in users
+  may call it; an open `/auth-token` lets anyone mint a Wisdom JWT for the org.
+- **`baseUrl` must include the scheme** (e.g. `https://<tenant>.wisdom.ai`). A
+  bare host throws `SubscriptionTransport: unrecognized baseUrl protocol`.
+- Keep the access token (`WISDOM_ACCESS_TOKEN`) server-side only — never send it
+  to the browser.
+
+Zero-dependency backend (any framework) via the GraphQL `exchangeAccessToken`
+query:
+
+```ts
+// Pseudocode — wrap in the app's existing auth/session check first.
+app.post('/auth-token', requireAuth, async () => {
+  const res = await fetch(`${process.env.WISDOM_BASE_URL}/graphql`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      query: 'query Exchange($t: String!) { exchangeAccessToken(accessToken: $t) }',
+      variables: { t: process.env.WISDOM_ACCESS_TOKEN },
+    }),
+  });
+  const { data } = await res.json();
+  return { jwt: data.exchangeAccessToken, baseUrl: process.env.WISDOM_BASE_URL };
+});
+```
+
+`exchangeAccessToken` issues an **org-level** JWT. When each end user should see
+only their own data, mint a **per-user** JWT with `impersonateUser` instead and
+return it as `jwt`. The node SDK's `getAuthToken()` wraps `exchangeAccessToken`
+if a Node helper is preferred.
+
+### 2. Wrap the app
+
+```tsx
+import { WisdomProvider } from '@wisdomai/react';
+
+function App() {
+  return (
+    <WisdomProvider>
+      <YourDashboards />
+    </WisdomProvider>
+  );
+}
+```
+
+`<WisdomProvider>` calls `POST /auth-token`, exposes the client via context, and
+silently refreshes the JWT before it expires. Pass a `getAuthToken` callback to
+bypass the endpoint when the app already holds a Wisdom JWT. Pass a `theme` prop
+to style SDK-rendered components.
+
+### 3. Render dashboards
+
+```tsx
+import { Dashboard, DashboardWidget, useWisdomClient } from '@wisdomai/react';
+
+// A whole dashboard:
+<Dashboard dashboardId="dashboard-id-123" />
+
+// Or a single widget:
+<DashboardWidget dashboardId="dashboard-id-123" widgetId="widget-id-456" />
+
+// Or the typed client directly (null until auth succeeds):
+const client = useWisdomClient();
+const dashboard = await client?.dashboards.get('dashboard-id-123');
+```
+
+## What renders
+
+- **Visualizations**: all chart types, data tables (server-side paging),
+  single- and multi-value metric cards, and text.
+- **Filters**: interactive string, numeric (integer/float), enum, and date —
+  via row-click, the filter drawer, or programmatically with `setFilterValue`.
+
+## Common errors
+
+- `SubscriptionTransport: unrecognized baseUrl protocol` → `baseUrl` is missing
+  the `https://` scheme.
+- `WisdomAuthError` → JWT rejected/expired; the provider's `refresh()` re-fetches.
+- `WisdomDashboardNotFoundError` → the dashboard id doesn't exist or the user
+  lacks access.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Wisdom AI, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,225 @@
+# @wisdomai/react
+
+React SDK for Wisdom AI. Ships a React context provider, auth hook, and a typed GraphQL client:
+
+- `<WisdomProvider>` — fetches a short-lived JWT + the tenant `baseUrl` from your backend's `/auth-token` endpoint and exposes them via context. Accepts an optional `theme` prop (see [Theming](#theming)) and an optional `getAuthToken` callback to bypass the default endpoint (see [Custom auth token source](#custom-auth-token-source)).
+- `useWisdomAuth()` — hook returning `{ jwt, baseUrl, client, isLoading, error, refresh }`.
+- `useWisdomClient()` — hook returning a ready-to-use `WisdomClient` (null until auth succeeds).
+- `useWisdomTheme()` — hook returning the active `WisdomTheme` (the prop passed to `<WisdomProvider>`, or the default).
+- `WisdomClient` — typed GraphQL client. Currently exposes `client.dashboards.get(id)`.
+
+## Capabilities
+
+The SDK renders dashboards authored on the Wisdom platform directly in your React app — live data, your theme, and interactive filtering. Render a full dashboard with `<Dashboard>`, or drop in individual widgets with `<DashboardWidget>`.
+
+- **Visualizations** — all chart types, data tables (with server-side paging), single- and multi-value metric cards, and text.
+- **Filters** — interactive string, numeric (integer and float), enum, and date filters, driven by row-click, the filter drawer, or programmatically via `setFilterValue` (see [Dashboard filters](#dashboard-filters)).
+
+The layout, data, and filter specs come from the dashboard you built in Wisdom; the SDK renders them client-side and keeps them in sync with the platform.
+
+## Installation
+
+```bash
+npm install @wisdomai/react
+```
+
+Provide these peer dependencies from your app: `react` (>=18), `react-dom` (>=18), `@mui/material` (^7), `@mui/x-date-pickers` (^7), `@emotion/react` (^11), `@emotion/styled` (^11), `highcharts` (^12), `highcharts-react-official` (^3), `graphql` (^16), `luxon` (^3).
+
+> Using an AI coding agent? The package ships an [`AGENTS.md`](./AGENTS.md) with condensed, copy-ready setup steps — point your agent at it to scaffold the integration.
+
+## Quick start: authentication
+
+The SDK never sees your long-lived Wisdom access token. Your backend mints a short-lived JWT from that access token and serves it; `<WisdomProvider>` fetches the JWT in the browser and refreshes it before it expires.
+
+### 1. Serve a token endpoint from your backend
+
+Expose `POST /auth-token` on the **same origin** as your app, returning `{ jwt, baseUrl }`. Keep `WISDOM_ACCESS_TOKEN` server-side only.
+
+> **Protect this route with your app's own authentication.** It exchanges your server-side access token for browser credentials, so only signed-in users of your app should be able to call it — an open `/auth-token` lets anyone mint a Wisdom JWT for your org. The examples below omit that guard for brevity; add your existing session/authz check before the exchange (and mint a per-user token with [`impersonateUser`](https://docs.wisdom.ai/integrations/graphql-api/mutations/auth/impersonate-user) when each user should see only their own data).
+
+```ts
+import { WisdomAI } from '@wisdomai/node';
+import Fastify from 'fastify';
+
+const wisdom = new WisdomAI({
+  accessToken: process.env.WISDOM_ACCESS_TOKEN!,
+  baseUrl: process.env.WISDOM_BASE_URL!,
+});
+
+const app = Fastify();
+
+// Returns { jwt, baseUrl } — a short-lived token plus your tenant API URL.
+app.post('/auth-token', () => wisdom.getAuthToken());
+
+await app.listen({ port: 3000 });
+```
+
+**Not on Node?** `getAuthToken()` is just a thin wrapper over the GraphQL [`exchangeAccessToken`](https://docs.wisdom.ai/integrations/graphql-api/queries/auth/exchange-access-token) query, so any backend can do the same exchange — `POST {baseUrl}/graphql` with your access key, then pair the returned JWT with your tenant `baseUrl`:
+
+```ts
+// exchangeAccessToken(accessToken: String!): String!  — returns a bare ~60-min JWT.
+app.post('/auth-token', async () => {
+  const res = await fetch(`${process.env.WISDOM_BASE_URL}/graphql`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      query: 'query Exchange($t: String!) { exchangeAccessToken(accessToken: $t) }',
+      variables: { t: process.env.WISDOM_ACCESS_TOKEN },
+    }),
+  });
+  const { data } = await res.json();
+  return { jwt: data.exchangeAccessToken, baseUrl: process.env.WISDOM_BASE_URL };
+});
+```
+
+`exchangeAccessToken` issues an **org-level** JWT (the same identity for every caller). For multi-user production embeds where each end user should see only their own data, mint a **per-user** JWT with [`impersonateUser`](https://docs.wisdom.ai/integrations/graphql-api/mutations/auth/impersonate-user) instead and return that as `jwt` — the provider contract (`{ jwt, baseUrl }`) is the same.
+
+### 2. Wrap your app and read a dashboard
+
+`<WisdomProvider>` calls `POST /auth-token`, exposes a ready-to-use client via `useWisdomClient()` (null until auth succeeds), and silently re-fetches the JWT shortly before it expires and when the tab regains focus.
+
+```tsx
+import { WisdomProvider, useWisdomClient } from '@wisdomai/react';
+import { useEffect, useState } from 'react';
+
+function App() {
+  return (
+    <WisdomProvider>
+      <DashboardName id="dashboard-id-123" />
+    </WisdomProvider>
+  );
+}
+
+function DashboardName({ id }: { id: string }) {
+  const client = useWisdomClient();
+  const [name, setName] = useState<string | null>(null);
+
+  useEffect(() => {
+    if (!client) return;
+    client.dashboards.get(id).then((dashboard) => setName(dashboard.name));
+  }, [client, id]);
+
+  if (!client) return <p>Authenticating…</p>;
+  return <p>{name ?? 'Loading…'}</p>;
+}
+```
+
+If your app already holds a Wisdom JWT (e.g. the SDK is mounted inside an authenticated app), skip the endpoint entirely with the [`getAuthToken` callback](#custom-auth-token-source). For the exact endpoint contract and error handling, see [Requirements on the partner backend](#requirements-on-the-partner-backend).
+
+## Usage
+
+```tsx
+import { WisdomProvider, useWisdomClient, WisdomDashboardNotFoundError } from '@wisdomai/react';
+import { useEffect, useState } from 'react';
+
+function App() {
+  return (
+    <WisdomProvider>
+      <DashboardView />
+    </WisdomProvider>
+  );
+}
+
+function DashboardView() {
+  const client = useWisdomClient();
+  const [name, setName] = useState<string | null>(null);
+  const [notFound, setNotFound] = useState(false);
+
+  useEffect(() => {
+    if (!client) return;
+    client.dashboards
+      .get('dashboard-id-123')
+      .then((dashboard) => setName(dashboard.name))
+      .catch((err) => {
+        if (err instanceof WisdomDashboardNotFoundError) setNotFound(true);
+        else throw err;
+      });
+  }, [client]);
+
+  if (!client) return <p>Authenticating…</p>;
+  if (notFound) return <p>Dashboard not found</p>;
+  return <p>{name ?? 'Loading…'}</p>;
+}
+```
+
+### Requirements on the partner backend
+
+`WisdomProvider` sends `POST /auth-token` to the same origin and expects a JSON response of shape `{ jwt: string, baseUrl: string }`. This matches the `sdk-playground` Fastify server exactly. If your backend hosts the token endpoint at a different path, you'll need a dev proxy or a reverse proxy in front of your app.
+
+> **`baseUrl` must include the scheme.** Use the full origin, e.g. `https://canary.gowisdom.ai` — not a bare host (`canary.gowisdom.ai`). The SDK derives its WebSocket endpoint from `baseUrl`, and a value without an `http(s)://` prefix throws `SubscriptionTransport: unrecognized baseUrl protocol`.
+
+### Custom auth token source
+
+If your app already has access to a JWT (e.g., the SDK is mounted inside an app that holds the user's session), pass a `getAuthToken` callback to bypass the default `POST /auth-token` fetch. The callback must resolve to `{ jwt, baseUrl }` (typed as `WisdomAuthTokenResult`), where `baseUrl` is the Wisdom tenant API URL (the same value the partner backend would otherwise return from `/auth-token`) — not the host app's origin, unless the host app reverse-proxies `/graphql` and the WS endpoints to Wisdom.
+
+```tsx
+import { WisdomProvider, type WisdomAuthTokenResult } from '@wisdomai/react';
+import { useCallback } from 'react';
+import { getAuthToken } from '@/services/auth';
+
+const WISDOM_BASE_URL = 'https://your-tenant.wisdom.ai';
+
+function App() {
+  const resolveAuth = useCallback(async (): Promise<WisdomAuthTokenResult> => {
+    const jwt = await getAuthToken();
+    return { jwt, baseUrl: WISDOM_BASE_URL };
+  }, []);
+
+  return (
+    <WisdomProvider getAuthToken={resolveAuth}>
+      <DashboardView />
+    </WisdomProvider>
+  );
+}
+```
+
+When `getAuthToken` is set, the SDK does not call `POST /auth-token` — your callback is the sole token source. Throw from the callback to surface an auth error via `useWisdomAuth().error`. Wrap the callback in `useCallback` (or define it at module scope) so its identity is stable across renders; the provider re-fetches whenever the callback reference changes.
+
+## Theming
+
+Pass a `theme` prop to `<WisdomProvider>` to control the colors, fonts, and chart palette used by SDK-rendered components (`Dashboard`, `DashboardWidgets`, `DashboardFilters`, `WisdomChart`). The theme is exposed to your own components via `useWisdomTheme()` so partner UI can stay visually consistent.
+
+```tsx
+import { WisdomProvider, type WisdomTheme } from '@wisdomai/react';
+
+const theme: WisdomTheme = {
+  primaryTextColor: '#ffffff',
+  secondaryTextColor: '#a0a0a0',
+  background: '#1a1a1a',
+  border: '#2a2a2a',
+  fontFamily: 'Inter, sans-serif',
+  chartColors: ['#4f46e5', '#10b981', '#f59e0b'],
+};
+
+<WisdomProvider theme={theme}>
+  <DashboardView />
+</WisdomProvider>;
+```
+
+`fontFamily` and `chartColors` are optional; everything else is required. If `theme` is omitted, a light default is used. The SDK does not ship light/dark presets — partner apps own their full color system.
+
+You can pass `theme` as an inline object literal without causing chart re-renders on every parent render; the provider stabilizes its identity by content.
+
+## Dashboard filters
+
+Interactive filtering (row-click, drawer, or programmatic) goes through `setFilterValue(filterId, filter)` from the dashboard context. Two parts of the contract are easy to get wrong:
+
+### `filterId` is the lookup key
+
+`setFilterValue` matches the `filterId` against `dashboard.filterSpecs[*].filterId` exactly. A `filterId` that doesn't match any spec throws `Filter not found on dashboard: <filterId>`. The same `filterId` keys highlight/active-filter lookups, so it must be the spec's `filterId` verbatim — not the `parameterName`, `displayName`, or column name.
+
+### The `columnRef` vs `column` shape asymmetry
+
+A `FilterSpec` exposes its column under **`spec.columnRefs[0]`** (a `ColumnRef`). But the serialized filter `lhs` reads the column from **`lhs.expression.flattened[0].column`** (a `DataframeColumn`) when building the GraphQL input. These are different shapes at different layers — the SDK maps between them in `buildLhsFromSpec`. If you hand-assemble an `lhs`, you must populate `expression.flattened[0].column`; leaving it empty throws a `malformed lhs` error naming the `filterId` (it does not silently render a blank chart).
+
+### Filtering a column the widgets don't query
+
+A filter only changes a widget if that widget's underlying query references the filtered column (`WidgetFilterStatus.WIDGET_FILTER_STATUS_ADDED`). If you set a filter whose column no visible widget queries — common for chat-authored widgets whose SQL never selected the entity column — `setFilterValue` resolves successfully but nothing visibly changes. The SDK emits a `console.warn` in this case so the no-op is observable during development.
+
+## Errors
+
+All errors thrown by the client extend `WisdomError`:
+
+- `WisdomAuthError` — JWT rejected or expired (HTTP 401/403, or GraphQL `UNAUTHENTICATED` / `INVALID_TOKEN`). Consumers should call `refresh()` to re-fetch a token.
+- `WisdomDashboardNotFoundError` — `dashboards.get(id)` could not return a dashboard because the ID does not exist or the caller lacks access (server emits `NOT_FOUND` or `FORBIDDEN`).
+- `WisdomError` — everything else (network failure, 5xx, malformed response, uncategorized backend errors). Carries an optional `cause` and, for GraphQL-level failures, an `errors` array.

package/dist/WisdomAuthContext.d.ts

@@ -0,0 +1,12 @@
+import type { WisdomClient } from './client';
+export interface WisdomAuthContextValue {
+    jwt: string | null;
+    baseUrl: string | null;
+    client: WisdomClient | null;
+    isLoading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+}
+export declare const WisdomAuthContext: import("react").Context<WisdomAuthContextValue | null>;
+export declare function useWisdomAuth(): WisdomAuthContextValue;
+export declare function useWisdomClient(): WisdomClient | null;

package/dist/WisdomProvider.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+import { WisdomTheme } from './theme';
+export interface WisdomAuthTokenResult {
+    jwt: string;
+    baseUrl: string;
+}
+interface WisdomProviderProps {
+    children: ReactNode;
+    theme?: Partial<WisdomTheme>;
+    getAuthToken?: () => Promise<WisdomAuthTokenResult>;
+}
+export declare function WisdomProvider({ children, theme, getAuthToken }: WisdomProviderProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/dist/client.d.ts

@@ -0,0 +1,10 @@
+import { DashboardsAPI } from './resources/dashboards';
+import { SubscriptionTransport, type SubscriptionTransportOptions } from './subscriptionTransport';
+import { type TransportOptions } from './transport';
+export type WisdomClientOptions = TransportOptions & Partial<Pick<SubscriptionTransportOptions, 'webSocketImpl'>>;
+export declare class WisdomClient {
+    readonly dashboards: DashboardsAPI;
+    readonly subscriptions: SubscriptionTransport;
+    constructor(options: WisdomClientOptions);
+    dispose(): void;
+}

package/dist/dashboard/Dashboard.d.ts

@@ -0,0 +1,12 @@
+import { DashboardScope } from '../generated/graphql/graphql';
+import type { Dashboard as DashboardData } from '../resources/dashboards';
+type DashboardProps = {
+    dashboardId: string;
+    dashboard?: never;
+    scope?: DashboardScope;
+} | {
+    dashboardId?: never;
+    dashboard: DashboardData;
+};
+export declare function Dashboard(props: DashboardProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/dist/dashboard/DashboardContext.d.ts

@@ -0,0 +1,53 @@
+import type { ParsedVisualizationFilter } from '@wisdomai/visualization/sdk-filters';
+import type { Dashboard, DomainFilterColumn } from '../resources/dashboards';
+import type { WidgetStore } from './widgetStore';
+export interface DashboardActions {
+    refetch: () => Promise<void>;
+    /**
+     * Apply a filter value (or pass `null` to clear). Resolves when the
+     * server has finished re-executing all affected widgets.
+     *
+     * Throws if the dashboard has `useFiltersV2: false` (v1 is not supported
+     * by the SDK).
+     */
+    setFilterValue: (filterId: string, filter: ParsedVisualizationFilter | null) => Promise<void>;
+}
+export interface LastRefreshedFields {
+    /**
+     * Earliest `min(visualization.collectedAt ?? dataRefreshedAt)` across the
+     * dashboard's visualization widgets, or `null` while widgets are still
+     * loading or no visualization widget exposes a usable timestamp. Reflects
+     * data staleness, not the last refresh action.
+     */
+    lastRefreshedAt: Date | null;
+    /** True once every visualization widget has settled to `success` or `error`. */
+    allWidgetsReady: boolean;
+}
+export type DashboardContextValue = ({
+    status: 'loading';
+    dashboard: Dashboard | null;
+    error: null;
+    activeFilterId: null;
+    widgetStore: WidgetStore;
+} & LastRefreshedFields & DashboardActions) | ({
+    status: 'error';
+    dashboard: null;
+    error: Error;
+    activeFilterId: null;
+    widgetStore: WidgetStore;
+} & LastRefreshedFields & DashboardActions) | ({
+    status: 'success';
+    dashboard: Dashboard;
+    error: null;
+    /** Filter currently being mutated, or null when idle. */
+    activeFilterId: string | null;
+    widgetStore: WidgetStore;
+    /**
+     * Domain columns (with allowed-value metadata) for the dashboard's
+     * filter specs, fetched eagerly by domainId. Empty until that fetch
+     * resolves; used to classify fresh enum filters as closed vs. dynamic.
+     */
+    filterColumns: DomainFilterColumn[];
+} & LastRefreshedFields & DashboardActions);
+export declare const DashboardContext: import("react").Context<DashboardContextValue | null>;
+export declare function useDashboard(): DashboardContextValue;

package/dist/dashboard/DashboardFilters.d.ts

@@ -0,0 +1,6 @@
+type FiltersDirection = 'row' | 'column';
+interface DashboardFiltersProps {
+    direction?: FiltersDirection;
+}
+export declare function DashboardFilters({ direction }?: DashboardFiltersProps): import("@emotion/react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/dashboard/DashboardHeader.d.ts

@@ -0,0 +1,4 @@
+export interface DashboardHeaderProps {
+    className?: string;
+}
+export declare function DashboardHeader({ className }: DashboardHeaderProps): import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/dashboard/DashboardProvider.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+import { DashboardScope } from '../generated/graphql/graphql';
+import type { Dashboard } from '../resources/dashboards';
+type DashboardProviderProps = {
+    dashboardId: string;
+    dashboard?: never;
+    scope?: DashboardScope;
+    children: ReactNode;
+} | {
+    dashboardId?: never;
+    dashboard: Dashboard;
+    children: ReactNode;
+};
+export declare function DashboardProvider(props: DashboardProviderProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/dist/dashboard/DashboardWidget.d.ts

@@ -0,0 +1,6 @@
+export interface DashboardWidgetProps {
+    widgetId: string;
+    /** Optional — when omitted, reads the id from `<DashboardProvider>`. */
+    dashboardId?: string;
+}
+export declare function DashboardWidget({ widgetId, dashboardId: dashboardIdProp }: DashboardWidgetProps): import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/dashboard/DashboardWidgets.d.ts

@@ -0,0 +1,3 @@
+import 'react-grid-layout/css/styles.css';
+import 'react-resizable/css/styles.css';
+export declare function DashboardWidgets(): import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/dashboard/SdkMarkdown.d.ts

@@ -0,0 +1,12 @@
+import { type Components } from 'react-markdown';
+export interface SdkMarkdownProps {
+    text: string;
+    components?: Components;
+}
+/**
+ * Lean markdown renderer bundled into the SDK. Generic on purpose — no math,
+ * no app-internal link routing, no LLM-output preprocessing (those live in the
+ * frontend's LlmMarkdown). `remark-gfm` covers tables/strikethrough/autolinks,
+ * which dashboard summaries do use.
+ */
+export declare function SdkMarkdown({ text, components }: SdkMarkdownProps): import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/dashboard/SdkSummaryWidget.d.ts

@@ -0,0 +1,5 @@
+export interface SdkSummaryWidgetProps {
+    /** Stable root widget id — never a filter-versioned clone id. */
+    widgetId: string;
+}
+export declare function SdkSummaryWidget({ widgetId }: SdkSummaryWidgetProps): import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/dashboard/SummaryContent.d.ts

@@ -0,0 +1,6 @@
+export interface SummaryContentProps {
+    summary: string;
+    /** True while a fresh summary is streaming — keeps the view pinned to the newest text. */
+    enableAutoScroll: boolean;
+}
+export declare function SummaryContent({ summary, enableAutoScroll }: SummaryContentProps): import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/dashboard/WidgetActionsMenu.d.ts

@@ -0,0 +1,6 @@
+import { RefObject } from 'react';
+export interface WidgetActionsMenuProps {
+    captureRef: RefObject<HTMLElement | null>;
+    title: string;
+}
+export declare function WidgetActionsMenu({ captureRef, title }: WidgetActionsMenuProps): import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/dashboard/WidgetCard.d.ts

@@ -0,0 +1,13 @@
+import type { ReactNode } from 'react';
+export interface WidgetCardProps {
+    title: string;
+    children: ReactNode;
+    headerActions?: ReactNode;
+    titleLoading?: boolean;
+}
+export declare function WidgetCard({ title, children, headerActions, titleLoading }: WidgetCardProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare function WidgetPlaceholderBody(): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare function WidgetErrorBody({ message }: {
+    message: string;
+}): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare function WidgetLoadingBody(): import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/dashboard/WisdomChart.d.ts

@@ -0,0 +1,6 @@
+import { type Visualization } from '@wisdomai/visualization';
+export interface WisdomChartProps {
+    visualization: Visualization;
+}
+/** @deprecated Use `<WisdomVisualization>` — it routes to the right renderer based on `visualization.type`. */
+export declare function WisdomChart({ visualization }: WisdomChartProps): import("@emotion/react/jsx-runtime").JSX.Element | null;

package/dist/dashboard/WisdomMetric.d.ts

@@ -0,0 +1,5 @@
+import { type Visualization } from '@wisdomai/visualization';
+export interface WisdomMetricProps {
+    visualization: Visualization;
+}
+export declare function WisdomMetric({ visualization }: WisdomMetricProps): import("@emotion/react/jsx-runtime").JSX.Element | null;

package/dist/dashboard/WisdomTable.d.ts

@@ -0,0 +1,10 @@
+import { type Visualization } from '@wisdomai/visualization';
+export interface WisdomTableProps {
+    visualization: Visualization;
+    /**
+     * Server-side paging; omitted when the table isn't backed by a widget fetch.
+     * Resolves to the number of rows loaded after the fetch.
+     */
+    fetchMore?: (nextLimit: number) => Promise<number>;
+}
+export declare function WisdomTable({ visualization, fetchMore }: WisdomTableProps): import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/dashboard/WisdomText.d.ts

@@ -0,0 +1,5 @@
+import { type Visualization } from '@wisdomai/visualization';
+export interface WisdomTextProps {
+    visualization: Visualization;
+}
+export declare function WisdomText({ visualization }: WisdomTextProps): import("@emotion/react/jsx-runtime").JSX.Element | null;

package/dist/dashboard/WisdomVisualization.d.ts

@@ -0,0 +1,7 @@
+import { type Visualization } from '@wisdomai/visualization';
+export interface WisdomVisualizationProps {
+    visualization: Visualization;
+    /** Server-side paging for table widgets; omitted for charts/metrics/text. */
+    fetchMore?: (nextLimit: number) => Promise<number>;
+}
+export declare function WisdomVisualization({ visualization, fetchMore }: WisdomVisualizationProps): import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/dashboard/exportWidgetAsImage.d.ts

@@ -0,0 +1,6 @@
+export type ImageFormat = 'png' | 'jpg';
+export interface ExportImageOptions {
+    backgroundColor?: string;
+    pixelRatio?: number;
+}
+export declare function exportWidgetAsImage(element: HTMLElement | null, baseName: string, format: ImageFormat, options?: ExportImageOptions): Promise<void>;

package/dist/dashboard/filterForms/BoolFilterForm.d.ts

@@ -0,0 +1,8 @@
+import { BoolFilter } from '@wisdomai/visualization/sdk-filters';
+interface BoolFilterFormProps {
+    filter: BoolFilter;
+    close: () => void;
+    onSubmit: () => void;
+}
+export declare function BoolFilterForm({ filter, close, onSubmit }: BoolFilterFormProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/dist/dashboard/filterForms/CurrentDateInput.d.ts

@@ -0,0 +1,11 @@
+import { DataframeFunctionType, DateFilter } from '@wisdomai/visualization/sdk-filters';
+import { DateFilterType } from './DateFilterForm';
+type Props = {
+    currentDateType: DataframeFunctionType;
+    filterType: DateFilterType | undefined;
+    setFilterType: (filterType: DateFilterType) => void;
+    setCurrentDateType: (currentDateType: DataframeFunctionType) => void;
+};
+export declare const getDefaultCurrentDateType: (filter: DateFilter) => DataframeFunctionType;
+export declare const CurrentDateInput: ({ currentDateType, filterType, setFilterType, setCurrentDateType }: Props) => import("@emotion/react/jsx-runtime").JSX.Element;
+export {};