@aintela/bi 0.2.0

package/dist/client/BiClientProvider.d.ts

@@ -0,0 +1,21 @@
+import { default as React } from 'react';
+import { BiClient, BiClientOptions } from './BiClient';
+export interface BiClientProviderProps {
+    /** A ready client — or pass `options` and let the provider build one. */
+    client?: BiClient;
+    options?: BiClientOptions;
+    /**
+     * Session the inline components (`Chart`, `IFrame`) scope their artifact
+     * URLs to when the tool call did not name one. Typically the active chat
+     * session id.
+     */
+    sessionId?: string;
+    children: React.ReactNode;
+}
+export declare const BiClientProvider: React.FC<BiClientProviderProps>;
+/** The ambient client. Throws with a clear message when no provider is mounted. */
+export declare function useBiClient(): BiClient;
+/** Same as {@link useBiClient} but returns `null` instead of throwing. */
+export declare function useBiClientOptional(): BiClient | null;
+/** The session id the nearest `BiClientProvider` was given, if any. */
+export declare function useBiSessionId(): string | undefined;

package/dist/client/index.d.ts

@@ -0,0 +1,4 @@
+export { createBiClient, defaultBiRoutes, biDateReviver } from './BiClient';
+export type { BiClient, BiClientOptions, BiRoutes, BiFetch, ArtifactUrlScope, QueryExecutionBody, PagedQueryBody, ExportQueryBody, DashboardActionName, FolderActionName, } from './BiClient';
+export { BiClientProvider, useBiClient, useBiClientOptional, useBiSessionId } from './BiClientProvider';
+export type { BiClientProviderProps } from './BiClientProvider';

package/dist/client.d.ts

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

package/dist/client.js

@@ -0,0 +1,11 @@
+import { B as s, b as a, c as t, d as B, u as l, a as n, e as o } from "./BiClientProvider-CWJochvi.js";
+export {
+  s as BiClientProvider,
+  a as biDateReviver,
+  t as createBiClient,
+  B as defaultBiRoutes,
+  l as useBiClient,
+  n as useBiClientOptional,
+  o as useBiSessionId
+};
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

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

package/dist/composer/environment/environmentDom.d.ts

@@ -0,0 +1,31 @@
+import { EnvironmentTarget, GuideStep } from './types';
+/** Class the environment API toggles on highlighted nodes (styled in `composer.css`). */
+export declare const ENV_HIGHLIGHT_CLASS = "llm-env-highlight-active";
+type QueryRoot = Pick<ParentNode, 'querySelectorAll'>;
+export declare function escapeCssValue(value: string): string;
+export declare function looksLikeSelector(value: string): boolean;
+/**
+ * Every selector an `EnvironmentTarget` may denote, in priority order. A
+ * plain identifier fans out to the `data-env-*` attributes first so an
+ * LLM naming a card by its `i` finds the sketch node, not a stray class.
+ */
+export declare function toSelectorList(target: EnvironmentTarget): string[];
+/** All nodes matching any selector of `target` under `root` (default `document`). */
+export declare function resolveEnvironmentElements(target: EnvironmentTarget, root?: QueryRoot | null): {
+    selectors: string[];
+    elements: HTMLElement[];
+};
+export declare function isElementVisible(element: HTMLElement): boolean;
+/** First visible match, else the first match; `includeHidden` skips the visibility test. */
+export declare function pickBestElement(elements: HTMLElement[], includeHidden?: boolean): HTMLElement | null;
+/**
+ * The spotlight's resolver: the first VISIBLE element the target denotes,
+ * or `null`. Collapsed / zero-size nodes are rejected so a tour never pins
+ * itself to something the user cannot see.
+ */
+export declare function resolveGuideElement(target: EnvironmentTarget, root?: QueryRoot | null): HTMLElement | null;
+export declare const PAD_INTERNAL_IDS: ReadonlySet<string>;
+export declare const PAD_INTERNAL_CLASSES: ReadonlySet<string>;
+export declare function targetSuggestsPadInternal(t: EnvironmentTarget): boolean;
+export declare function guideStepsRequireSketch(steps: GuideStep[]): boolean;
+export {};

package/dist/composer/environment/types.d.ts

@@ -0,0 +1,67 @@
+import { default as React } from 'react';
+import { ComposerDashboard, SimplePadDefinition } from '../models/sketchModels';
+/**
+ * How LLM-emitted code (and the `present_guide` / `present_dashboard_pad`
+ * action tools) name a node on the page. A bare string is an identifier
+ * looked up as `[data-env-id]`, `[data-env-key]`, `[data-env-name]`, `#id`
+ * and `.class`; a string that looks like a CSS selector is used verbatim.
+ */
+export type EnvironmentTarget = string | {
+    className?: string;
+    identifier?: string;
+    selector?: string;
+};
+export interface HighlightOptions {
+    durationMs?: number;
+    scrollIntoView?: boolean;
+}
+export interface CloneComponentOptions {
+    includeHidden?: boolean;
+}
+export interface EnvironmentCloneEntry {
+    id: string;
+    sourceSelector: string;
+    html: string;
+    source: EnvironmentTarget;
+    width: number;
+    height: number;
+    createdAt: number;
+}
+export interface CloneComponentResult {
+    cloneId: string;
+    width: number;
+    source: HTMLElement;
+    height: number;
+    html: string;
+    sourceSelector: string;
+    /** Ready-to-render clone: hover highlights the original, click forwards to it. */
+    component?: React.ReactElement;
+}
+export interface GuideStep {
+    target: EnvironmentTarget;
+    title?: string;
+    description: string;
+    placement?: 'top' | 'bottom' | 'left' | 'right' | 'auto';
+}
+export interface GuideOptions {
+    onComplete?: () => void;
+    overlayOpacity?: number;
+    allowInteraction?: boolean;
+}
+/**
+ * The surface the composer exposes to live-TSX blocks (through the chat
+ * library's `EnvironmentProvider`) and to the three action tools
+ * `createBiUiTools({ environment })` registers. `useComposerEnvironment()`
+ * returns one bound to the ambient composer store.
+ */
+export interface DashboardEnvironment {
+    /** Adds the highlight class to every match for `durationMs`; returns how many nodes matched. */
+    highlightComponent: (target: EnvironmentTarget, options?: HighlightOptions) => number;
+    /** Snapshot of the first visible match, with a React clone that proxies hover + click. */
+    cloneComponent: (target: EnvironmentTarget, options?: CloneComponentOptions) => CloneComponentResult | null;
+    createDashboardPad: (dashboard: ComposerDashboard | SimplePadDefinition) => void;
+    updateDashboardPad: (dashboard: ComposerDashboard | SimplePadDefinition) => void;
+    refreshDashboard: () => void;
+    showGuide: (steps: GuideStep[], options?: GuideOptions) => void;
+    dismissGuide: () => void;
+}

package/dist/composer/icons/cardTypeIcons.d.ts

@@ -0,0 +1,31 @@
+import { default as React } from 'react';
+import { default as SvgIcon } from '@mui/material/SvgIcon';
+import { CardCategory, CardSpecificType, FilterType } from '../models/sketchModels';
+export type SvgIconComponent = typeof SvgIcon;
+export declare const CATEGORY_ICONS: Record<CardCategory, SvgIconComponent>;
+/** Legacy `SketchCardItem.color` token per category (a name, not a colour). */
+export declare const COLOR_MAP: Record<CardCategory, string>;
+export declare const SPECIFIC_TYPE_ICONS: Record<CardSpecificType, SvgIconComponent>;
+/** `@mui/icons-material` export name per type — what `SketchCardItem.muiIconName` stores. */
+export declare const SPECIFIC_TYPE_ICON_NAMES: Record<CardSpecificType, string>;
+export declare const FILTER_TYPE_ICONS: Record<FilterType, SvgIconComponent>;
+/** The three icon maps the pad draws with. */
+export interface CardTypeIconSet {
+    category: Record<CardCategory, SvgIconComponent>;
+    specificType: Record<CardSpecificType, SvgIconComponent>;
+    filterType: Record<FilterType, SvgIconComponent>;
+}
+export declare const defaultCardTypeIcons: CardTypeIconSet;
+export interface CardTypeIconsProviderProps {
+    /** Any subset; unspecified entries keep the MUI defaults. */
+    icons: {
+        category?: Partial<Record<CardCategory, SvgIconComponent>>;
+        specificType?: Partial<Record<CardSpecificType, SvgIconComponent>>;
+        filterType?: Partial<Record<FilterType, SvgIconComponent>>;
+    };
+    children: React.ReactNode;
+}
+/** Lets a host swap the pad's icons (its own set, or a different MUI style) without forking the pad. */
+export declare const CardTypeIconsProvider: React.FC<CardTypeIconsProviderProps>;
+/** The icon set in scope (MUI defaults when no provider is mounted). */
+export declare function useCardTypeIcons(): CardTypeIconSet;

package/dist/composer/index.d.ts

@@ -0,0 +1,66 @@
+export { ComposerProvider, useComposer, useComposerStore, useComposerStoreOptional, useComposerEnvironment, environmentFromStore } from './store/ComposerProvider';
+export type { ComposerProviderProps } from './store/ComposerProvider';
+export { createComposerStore, VIEWER_COMMIT_DEBOUNCE_MS, DRAFT_SAVE_DEBOUNCE_MS, GUIDE_SHOW_DELAY_MS } from './store/createComposerStore';
+export type { ComposerState, ComposerStoreApi, CreateComposerStoreOptions, ComposerViewType, ComposerViewport } from './store/createComposerStore';
+export { toDraftPayload, fromUpsertResponse, upsertDashboardDraft, createDashboardDraft } from './store/drafts';
+export type { DraftSeed } from './store/drafts';
+export type { DashboardEnvironment, EnvironmentTarget, HighlightOptions, CloneComponentOptions, CloneComponentResult, EnvironmentCloneEntry, GuideStep, GuideOptions } from './environment/types';
+export { ENV_HIGHLIGHT_CLASS, toSelectorList, resolveEnvironmentElements, resolveGuideElement, pickBestElement, isElementVisible, targetSuggestsPadInternal, guideStepsRequireSketch, PAD_INTERNAL_IDS, PAD_INTERNAL_CLASSES, } from './environment/environmentDom';
+export { DEFAULT_PAD_HEIGHT_PX, joinClientSideChanges } from './models/sketchModels';
+export type { SketchedFilterPad, PadConfig, SimplePadDefinition, ComposerDashboard, PromptDashboardCard, PromptDashboardContainer, PromptDashboardScreenData, PromptDashboardBoxData, DashboardFolder, DashboardFolderHierarchy, DashboardHierarchy, } from './models/sketchModels';
+export { CARD_TYPE_CATALOG, FILTER_TYPE_CATALOG, groupCardCatalog, validateSketch, padConfigToDashboard, isSimplePadDefinition, sketchCardItemComparer, sketchFilterComparer, categoryPrefix } from './models/catalog';
+export type { CardTypeDefinition, FilterTypeDefinition } from './models/catalog';
+export { sanitizeToJsVariable, randomId } from './models/utils';
+export { CATEGORY_ICONS, SPECIFIC_TYPE_ICONS, SPECIFIC_TYPE_ICON_NAMES, FILTER_TYPE_ICONS, COLOR_MAP, defaultCardTypeIcons, CardTypeIconsProvider, useCardTypeIcons } from './icons/cardTypeIcons';
+export type { CardTypeIconSet, CardTypeIconsProviderProps, SvgIconComponent } from './icons/cardTypeIcons';
+export { DashboardPad } from './pad/DashboardPad';
+export type { DashboardPadProps, DashboardPickerRenderArgs } from './pad/DashboardPad';
+export { DashboardPadSketch } from './pad/DashboardPadSketch';
+export type { DashboardPadSketchProps, DashboardPadHandle } from './pad/DashboardPadSketch';
+export { CardSketch, CardScketch } from './pad/CardSketch';
+export type { CardSketchProps } from './pad/CardSketch';
+export { FilterSketch } from './pad/FilterSketch';
+export type { FilterSketchProps } from './pad/FilterSketch';
+export { ToolBox } from './pad/ToolBox';
+export type { ToolBoxProps } from './pad/ToolBox';
+export { DashboardPadEditor } from './pad/DashboardPadEditor';
+export type { DashboardPadEditorProps, DashboardPadEditorHandle, EditorTab, AddMenuItem } from './pad/DashboardPadEditor';
+export { DatasetParameterizationControls } from './pad/DatasetParameterizationControls';
+export type { DatasetParameterizationControlsProps, DatasetOption, AgentOption } from './pad/DatasetParameterizationControls';
+export { TitleSketch, TextSketh, TitleSkath } from './pad/TitleSketch';
+export type { TitleSketchProps } from './pad/TitleSketch';
+export { HoverButton } from './pad/HoverButton';
+export type { HoverButtonProps } from './pad/HoverButton';
+export { ClonedComponent } from './pad/ClonedComponent';
+export type { ClonedComponentProps } from './pad/ClonedComponent';
+export { ExamplePad } from './llm/ExamplePad';
+export type { ExamplePadProps } from './llm/ExamplePad';
+export { ExampleCardSketch, ExampleCardSketh, ExampleCardSkath } from './llm/ExampleCardSketch';
+export type { ExampleCardSketchProps } from './llm/ExampleCardSketch';
+export { PrototypePad } from './llm/PrototypePad';
+export type { PrototypePadProps } from './llm/PrototypePad';
+export { c, dateRange, datePicker, autoComplete, useDashboardPad } from './llm/useDashboardPad';
+export type { CardSize } from './llm/useDashboardPad';
+export { EnvironmentProvider, useEnvironment, useEnvironmentOptional, InertEnvironmentProvider } from '@aintela/chat/components';
+export { ComposerView } from './view/ComposerView';
+export type { ComposerViewProps, ComposerProgressPanelArgs } from './view/ComposerView';
+export { useComposerChatBridge, GRID_ROW_HEIGHT_PX } from './view/useComposerChatBridge';
+export type { ComposerChatBridge, ComposerPromptEnvelope, TurnCompleteInfo } from './view/useComposerChatBridge';
+export { ComposerChatBinding } from './view/ComposerChatBinding';
+export { DrawablePrompt } from './view/DrawablePrompt';
+export type { DrawablePromptProps } from './view/DrawablePrompt';
+export { EntryEmptyState } from './view/EntryEmptyState';
+export type { EntryEmptyStateProps } from './view/EntryEmptyState';
+export { SpotlightOverlay } from './view/SpotlightOverlay';
+export type { SpotlightOverlayProps } from './view/SpotlightOverlay';
+export { DashboardSidePanel } from './view/DashboardSidePanel';
+export type { DashboardSidePanelProps } from './view/DashboardSidePanel';
+export { DashboardPin } from './view/DashboardPin';
+export type { ComposerMode, RecentSessionItem } from './view/composerTypes';
+export { resolveComposerSurfaces } from './view/surfaces';
+export type { ComposerSurfaces } from './view/surfaces';
+export { ambientVariants, ambientVariantsReduced, activityPanelVariants, activityPanelVariantsReduced, composerLayoutTransition, composerLayoutTransitionReduced, } from './view/composerAnimations';
+export { defaultComposerSuggestions } from './view/data/suggestions';
+export type { ComposerSuggestion } from './view/data/suggestions';
+export { defaultComposerTemplates, STARTER_TEMPLATES, TEMPLATE_KIND_TO_SKETCH, templateKinds, seedFromTemplate } from './view/data/templates';
+export type { ComposerTemplate, TemplateCardKind, TemplateCellSeed } from './view/data/templates';

package/dist/composer/llm/ExampleCardSketch.d.ts

@@ -0,0 +1,22 @@
+import { default as React } from 'react';
+import { SxProps, Theme } from '@mui/material/styles';
+import { CardCategory, CardSpecificType } from '../models/sketchModels';
+export interface ExampleCardSketchProps {
+    description?: string;
+    name?: string;
+    id?: string;
+    sx?: SxProps<Theme>;
+    category?: CardCategory;
+    specificType?: CardSpecificType;
+}
+/**
+ * Descriptor-style card preview the agent places in an `ExamplePad`
+ * (`[name] - description` with the type icon). `padConfigToDashboard`
+ * reads its props back when the pad is turned into a sketch.
+ */
+export declare const ExampleCardSketch: React.FC<ExampleCardSketchProps>;
+/** @deprecated legacy spelling the agent instructions still emit — use {@link ExampleCardSketch}. */
+export declare const ExampleCardSketh: React.FC<ExampleCardSketchProps>;
+/** @deprecated legacy spelling — use {@link ExampleCardSketch}. */
+export declare const ExampleCardSkath: React.FC<ExampleCardSketchProps>;
+export default ExampleCardSketch;

package/dist/composer/llm/ExamplePad.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+import { PadConfig } from '../models/sketchModels';
+export interface ExamplePadProps {
+    /** Optional surface colour for the pad (a theme token is used when omitted). */
+    backgroundColor?: string;
+    /** Width of the pad inside its frame (default `'80%'`). */
+    width?: string;
+    title?: string;
+    config: PadConfig[];
+    zoom?: number;
+}
+/**
+ * The agent's sketch preview inside the chat: a 12-column grid of
+ * `PadConfig` cells at a reduced zoom. Metric / gauge cells render at a
+ * fixed 100px; everything else at its configured height.
+ */
+export declare const ExamplePad: React.FC<ExamplePadProps>;
+export default ExamplePad;

package/dist/composer/llm/PrototypePad.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+import { PadConfig } from '../models/sketchModels';
+export interface PrototypePadProps {
+    /** Optional surface colour (a theme token is used when omitted). */
+    backgroundColor?: string;
+    width?: string;
+    title?: string;
+    config: PadConfig[];
+    zoom?: number;
+}
+/** Like `ExamplePad`, but for REAL card components: each cell gets its configured height and a 500px cap. */
+export declare const PrototypePad: React.FC<PrototypePadProps>;
+export default PrototypePad;

package/dist/composer/llm/useDashboardPad.d.ts

@@ -0,0 +1,25 @@
+import { default as React } from 'react';
+import { CardSpecificType, PadConfig, SimplePadDefinition, SketchedFilterPad } from '../models/sketchModels';
+export type CardSize = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+/**
+ * Builds one pad cell. Three forms:
+ *  - `c(size, height, name, specificType, description?)` → an `ExampleCardSketch` preview.
+ *  - `c(size, height, name, specificType, node)`         → metadata kept, `node` drawn.
+ *  - `c(size, height, node)`                             → just the node, no metadata.
+ */
+export declare function c(size: CardSize, height: number, node: React.ReactNode): PadConfig;
+export declare function c(size: CardSize, height: number, name: string, specificType: CardSpecificType, description?: string): PadConfig;
+export declare function c(size: CardSize, height: number, name: string, specificType: CardSpecificType, node: React.ReactElement): PadConfig;
+/** Date-range filter (mandatory by default) — the most common one. */
+export declare const dateRange: (i: string, name: string) => SketchedFilterPad;
+/** Single-date filter. */
+export declare const datePicker: (i: string, name: string, mandatory?: boolean) => SketchedFilterPad;
+/** Auto-complete filter (single or multiple selection). */
+export declare const autoComplete: (i: string, name: string, multiple?: boolean, mandatory?: boolean) => SketchedFilterPad;
+/**
+ * Pushes `def` into the host's sketch pad on mount, through the ambient
+ * `DashboardEnvironment` (`EnvironmentProvider value={useComposerEnvironment()}`).
+ * Inside a replayed message the chat library's `InertEnvironmentProvider`
+ * turns this into a no-op.
+ */
+export declare function useDashboardPad(def: SimplePadDefinition, type: 'update' | 'create'): void;

package/dist/composer/models/catalog.d.ts

@@ -0,0 +1,33 @@
+import { CardCategory, CardSpecificType, ComposerDashboard, FilterType, SimplePadDefinition, SketchCardItem, SketchedFilter } from './sketchModels';
+export interface CardTypeDefinition {
+    label: string;
+    category: CardCategory;
+    specificType: CardSpecificType;
+}
+/** Every card type the pad's pickers offer, in display order. Labels are the product's Portuguese. */
+export declare const CARD_TYPE_CATALOG: readonly CardTypeDefinition[];
+/** The catalog grouped by category (insertion order preserved) — what the pickers render. */
+export declare function groupCardCatalog(catalog?: readonly CardTypeDefinition[]): Record<string, CardTypeDefinition[]>;
+export interface FilterTypeDefinition {
+    label: string;
+    filterType: FilterType;
+}
+export declare const FILTER_TYPE_CATALOG: readonly FilterTypeDefinition[];
+export declare const sketchCardItemComparer: (a: SketchCardItem, b: SketchCardItem) => boolean;
+export declare const sketchFilterComparer: (a: SketchedFilter, b: SketchedFilter) => boolean;
+/**
+ * Pre-compose validation: clears every card's `todoItem` and returns the
+ * (Portuguese) error message when the sketch cannot be sent — duplicate
+ * card names, or no card at all. `null` when it is fine.
+ */
+export declare function validateSketch(dash: ComposerDashboard): string | null;
+/**
+ * Converts a `SimplePadDefinition` (flat linear config) into a dashboard
+ * document using a 12-column flow-fill. Card metadata is read from the
+ * config item first and from an `ExampleCardSketch` element's props second.
+ */
+export declare function padConfigToDashboard(def: SimplePadDefinition): ComposerDashboard;
+/** `true` for the flat pad shape (`{ config: [...] }`), `false` for a dashboard document. */
+export declare function isSimplePadDefinition(d: unknown): d is SimplePadDefinition;
+/** Next unique auto-name for a category (`chart3`, `kpi1`, …) given how many exist. */
+export declare function categoryPrefix(category: CardCategory): string;

package/dist/composer/models/sketchModels.d.ts

@@ -0,0 +1,102 @@
+import { default as React } from 'react';
+import { CardCategory, CardSpecificType, Dashboard, SketchCardItem } from '../../viewer/models';
+import { FilterType, SketchedFilter } from '../../filters/filterFactory';
+export type { CardCategory, CardSpecificType, Dashboard, SketchCardItem, FilterType, SketchedFilter };
+export declare const DEFAULT_PAD_HEIGHT_PX = 300;
+/** A sketched filter as the C# `JsSimplePadDefinition.Filters` emits it — always carries its parameter names. */
+export interface SketchedFilterPad extends SketchedFilter {
+    parametersNames: string[];
+}
+/** A single item in a pad layout (used by `ExamplePad`, `PrototypePad` and `SimplePadDefinition`). */
+export interface PadConfig {
+    /** Column span (1–12). */
+    size: number;
+    /** Card height in pixels. Applied as CSS in `ExamplePad`; converted to grid units in `padConfigToDashboard`. */
+    height?: number;
+    /** The card content — any React node. Use `ExampleCardSketch` for descriptor-style previews, or a custom component. */
+    card: React.ReactNode;
+    /** Metadata used by `padConfigToDashboard` when `card` is a custom node (name / type cannot be read from props). */
+    id?: string;
+    name?: string;
+    specificType?: CardSpecificType;
+    description?: string;
+}
+/**
+ * Single source of truth for `ExamplePad` visuals + `env.createDashboardPad()`.
+ * `filters` is the wider {@link SketchedFilterPad} because the runtime objects
+ * emitted by the server always include `parametersNames`.
+ */
+export interface SimplePadDefinition {
+    id?: string;
+    name: string;
+    filters?: SketchedFilterPad[];
+    config: PadConfig[];
+}
+/**
+ * The dashboard document as the composer edits it: the viewer's `Dashboard`
+ * plus the transient, per-turn `clientSideChanges` accumulator. The
+ * accumulator is NEVER persisted (`toDraftPayload` strips it); it is
+ * flattened into the prompt by `joinClientSideChanges` and cleared after.
+ */
+export interface ComposerDashboard extends Dashboard {
+    /**
+     * Keyed by `entity:id:operation` (`card:abc:layout`, `filter:xyz:edit`,
+     * `dashboard:name`) so repeated edits to one entity collapse to one entry.
+     */
+    clientSideChanges?: Record<string, string>;
+}
+/** Bullet list the agent receives; `undefined` when there is nothing to say. */
+export declare function joinClientSideChanges(map: Record<string, string> | undefined): string | undefined;
+export interface PromptDashboardBoxData {
+    widthPx: number;
+    heightPx: number;
+}
+export interface PromptDashboardScreenData {
+    chatBox?: PromptDashboardBoxData;
+    dashboardPreviewBox?: PromptDashboardBoxData;
+    dashboardVisualizationBox?: PromptDashboardBoxData;
+    gridRowHeightPixelsPerUnit: number;
+    gridColumnWidthPixelsPerUnit: number;
+    gridColumnWidthPixelsPerUnitFullView: number;
+    notes?: string;
+}
+export interface PromptDashboardCard extends SketchCardItem {
+    widthPx?: number;
+    heightPx?: number;
+}
+/** What every composer prompt carries besides the user's text (mirrors the C# `ClientDashboardMessage`). */
+export interface PromptDashboardContainer {
+    id: string;
+    name: string;
+    cards: PromptDashboardCard[];
+    filters: SketchedFilter[];
+    layoutType?: 'Naked' | 'Boxed';
+    remarks?: string;
+    userPrompt?: string;
+    screenData?: PromptDashboardScreenData;
+    filterValues?: Record<string, unknown>;
+    isDatasetParameterized?: boolean;
+    defaultDatasetName?: string;
+    /** `joinClientSideChanges(dashboard.clientSideChanges)`. */
+    clientSideChanges?: string;
+}
+export interface DashboardFolder {
+    id: string;
+    name: string;
+    description?: string | null;
+    createdAt?: Date | null;
+    updatedAt?: Date | null;
+    userId?: string | null;
+    accountId?: string | null;
+}
+export interface DashboardFolderHierarchy extends DashboardFolder {
+    dashboards: Dashboard[];
+}
+export interface DashboardHierarchy {
+    userFolders: DashboardFolderHierarchy[];
+    companyFolders: DashboardFolderHierarchy[];
+    userRootDashboards: Dashboard[];
+    companyRootDashboards: Dashboard[];
+    /** Admin-published "Padrão" dashboards — `userId` and `accountId` both null. */
+    defaultDashboards: Dashboard[];
+}

package/dist/composer/models/utils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Sanitizes an arbitrary string into a valid JS/TS identifier. Separators
+ * (spaces, dashes, dots, …) become camelCase boundaries, diacritics are
+ * folded to ASCII, a leading digit gets an underscore. Mirrors the C#
+ * sanitizer the server applies to card keys.
+ */
+export declare function sanitizeToJsVariable(name: string): string;
+/** A random id (RFC 4122 v4 when `crypto.randomUUID` exists, a hex fallback otherwise). */
+export declare function randomId(): string;

package/dist/composer/pad/CardSketch.d.ts

@@ -0,0 +1,25 @@
+import { default as React } from 'react';
+import { TodoItem } from '@aintela/chat/models';
+import { SketchCardItem } from '../models/sketchModels';
+export interface CardSketchProps {
+    cellConfig: SketchCardItem;
+    todoItem?: TodoItem;
+    turnOpen?: boolean;
+    onDelete?: (cardKey: string) => void;
+    onDataEdit: (data: SketchCardItem) => void;
+    /**
+     * Draws the description when not editing. Default: plain text with line
+     * breaks preserved. The legacy pad rendered Markdown — pass
+     * `(text) => <Markdown>{text}</Markdown>` to keep that.
+     */
+    renderDescription?: (text: string) => React.ReactNode;
+}
+/**
+ * One card on the sketch: type icon (opens the type picker), click-to-edit
+ * name and description, delete, and — while a turn is open — the agent's
+ * todo status overlaid on the card.
+ */
+export declare const CardSketch: React.FC<CardSketchProps>;
+/** @deprecated legacy spelling — use {@link CardSketch}. */
+export declare const CardScketch: React.FC<CardSketchProps>;
+export default CardSketch;

package/dist/composer/pad/ClonedComponent.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+import { CloneComponentResult, EnvironmentTarget } from '../environment/types';
+export interface ClonedComponentProps {
+    entry: CloneComponentResult;
+    /** Fired on hover with the clone's source selector — the store's `highlightComponent`. */
+    onHover?: (target: EnvironmentTarget) => void;
+}
+/**
+ * The inline mirror `env.cloneComponent()` hands back to a live-TSX block:
+ * hovering highlights the original node on the page, clicking clicks it.
+ */
+export declare const ClonedComponent: React.FC<ClonedComponentProps>;
+export default ClonedComponent;

package/dist/composer/pad/DashboardPad.d.ts

@@ -0,0 +1,38 @@
+import { default as React } from 'react';
+import { ComposerDashboard, Dashboard, DashboardHierarchy } from '../models/sketchModels';
+export interface DashboardPickerRenderArgs {
+    hierarchy: DashboardHierarchy | null;
+    loading: boolean;
+    selectedDashboardId: string | null;
+    onSelect: (dashboard: Dashboard) => void;
+}
+export interface DashboardPadProps {
+    /** Chat session the draft is bound to (`originalSessionId`). */
+    sessionId: string;
+    /** Load this dashboard into the pad on mount / when it changes. */
+    dashboardId?: string;
+    turnOpen: boolean;
+    /** "Compose": the validated sketch, ready to be sent to the agent. */
+    onCompose?: (dashboardDefinition: ComposerDashboard) => void;
+    /** After a save / load / new. */
+    onChange?: (sketchDashboard: ComposerDashboard) => void;
+    onBack?: () => void;
+    /**
+     * The "Abrir" picker body (the legacy `DashboardListViewer` lives in the
+     * host app). Without it the Abrir button is not rendered.
+     */
+    renderDashboardPicker?: (args: DashboardPickerRenderArgs) => React.ReactNode;
+    /** Debug panel with the sketch JSON. */
+    showDebug?: boolean;
+    headerExtra?: React.ReactNode;
+    renderDescription?: (text: string) => React.ReactNode;
+}
+/**
+ * The V1 pad: toolbar (Sketch/Dashboard toggle, `ToolBox`, Novo / Salvar /
+ * Atualizar / Abrir / Compose) over a `DashboardPadSketch`, or over a
+ * `ScriptDashboardViewer` of the published dashboard in Dashboard view.
+ * Needs a `ComposerProvider`; the REST calls go through the ambient
+ * `BiClient` (buttons that need one are hidden without it).
+ */
+export declare const DashboardPad: React.FC<DashboardPadProps>;
+export default DashboardPad;

package/dist/composer/pad/DashboardPadEditor.d.ts

@@ -0,0 +1,35 @@
+import { default as React, ReactNode } from 'react';
+export interface EditorTab {
+    id: string;
+    name: string;
+    contentType: string;
+    sourceId?: string;
+}
+export interface AddMenuItem {
+    label: string;
+    icon?: ReactNode;
+    contentType: string;
+    disabled?: boolean;
+    dividerBefore?: boolean;
+}
+export interface DashboardPadEditorHandle {
+    focusTab: (tabName: string) => void;
+    createTab: (contentType?: string, name?: string) => string;
+    closeTab: (tabName: string) => void;
+    getActiveTab: () => EditorTab | null;
+    getTabs: () => EditorTab[];
+}
+export interface DashboardPadEditorProps {
+    defaultContentType?: string;
+    addMenuItems?: AddMenuItem[];
+    renderContent: (tab: EditorTab) => ReactNode;
+    renderTabIcon?: (tab: EditorTab) => ReactNode;
+    onTabChange?: (tab: EditorTab) => void;
+    onTabClose?: (tab: EditorTab) => void;
+    onTabCreate?: (tab: EditorTab) => void;
+    onTabRename?: (tab: EditorTab, previousName: string) => void;
+    tabs?: EditorTab[];
+}
+/** Multi-tab shell (rename on double-click, close, "+" with an optional typed menu); every panel stays mounted. */
+export declare const DashboardPadEditor: React.ForwardRefExoticComponent<DashboardPadEditorProps & React.RefAttributes<DashboardPadEditorHandle>>;
+export default DashboardPadEditor;

package/dist/composer/pad/DashboardPadSketch.d.ts

@@ -0,0 +1,31 @@
+import { default as React } from 'react';
+import { CardCategory, CardSpecificType, FilterType } from '../models/sketchModels';
+export interface DashboardPadSketchProps {
+    /** Forces the width observer to re-measure when it changes. */
+    renderId?: string;
+    /** Hide the in-sketch filter chip row (the V2 composer shows filters in its rail instead). */
+    hideFiltersInSketch?: boolean;
+    /** Hide the built-in top bar (dashboard name + Boxed/Naked toggle). */
+    hideInternalHeader?: boolean;
+    zoomLevel?: number;
+    /** The empty-state CTA ("Clique aqui para adicionar um novo card"). */
+    onAddCard?: () => void;
+    /** Extra controls in the internal header (the legacy admin dataset / agent block). */
+    headerExtra?: React.ReactNode;
+    /** Forwarded to every `CardSketch`. */
+    renderDescription?: (text: string) => React.ReactNode;
+}
+/** What `DashboardPad` / the composer rail drive through a ref. */
+export interface DashboardPadHandle {
+    addGenericCell: () => void;
+    addTypedCell: (category: CardCategory, specificType: CardSpecificType, label: string) => void;
+    handleAddFilter: (filterType: FilterType) => void;
+}
+/**
+ * The sketch surface: a `GridLayout` of `CardSketch` cells plus the filter
+ * chips and (optionally) the name / layout header. Reads and writes the
+ * ambient composer store; every user gesture also records a
+ * `clientSideChanges` hint for the agent.
+ */
+export declare const DashboardPadSketch: React.ForwardRefExoticComponent<DashboardPadSketchProps & React.RefAttributes<DashboardPadHandle>>;
+export default DashboardPadSketch;