@mastra/playground-ui 10.0.0 → 11.0.0

package/dist/src/domains/datasets/components/datasets-table/columns.d.ts

@@ -0,0 +1,6 @@
+import { ColumnDef } from '@tanstack/react-table';
+import { DatasetRecord } from '@mastra/client-js';
+export type DatasetTableColumn = {
+    id: string;
+} & DatasetRecord;
+export declare const columns: ColumnDef<DatasetTableColumn>[];

package/dist/src/domains/datasets/components/datasets-table/datasets-table.d.ts

@@ -0,0 +1,7 @@
+import { DatasetRecord } from '@mastra/client-js';
+export interface DatasetsTableProps {
+    datasets: DatasetRecord[];
+    isLoading: boolean;
+    onCreateClick?: () => void;
+}
+export declare function DatasetsTable({ datasets, isLoading, onCreateClick }: DatasetsTableProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/datasets/components/delete-dataset-dialog.d.ts

@@ -0,0 +1,8 @@
+export interface DeleteDatasetDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    datasetId: string;
+    datasetName: string;
+    onSuccess?: () => void;
+}
+export declare function DeleteDatasetDialog({ open, onOpenChange, datasetId, datasetName, onSuccess, }: DeleteDatasetDialogProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/datasets/components/duplicate-dataset-dialog.d.ts

@@ -0,0 +1,9 @@
+export interface DuplicateDatasetDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    sourceDatasetId: string;
+    sourceDatasetName: string;
+    sourceDatasetDescription?: string;
+    onSuccess?: (datasetId: string) => void;
+}
+export declare function DuplicateDatasetDialog({ open, onOpenChange, sourceDatasetId, sourceDatasetName, sourceDatasetDescription, onSuccess, }: DuplicateDatasetDialogProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/datasets/components/edit-dataset-dialog.d.ts

@@ -0,0 +1,13 @@
+export interface EditDatasetDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    dataset: {
+        id: string;
+        name: string;
+        description?: string;
+        inputSchema?: Record<string, unknown> | null;
+        groundTruthSchema?: Record<string, unknown> | null;
+    };
+    onSuccess?: () => void;
+}
+export declare function EditDatasetDialog({ open, onOpenChange, dataset, onSuccess }: EditDatasetDialogProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/datasets/components/edit-item-dialog.d.ts

@@ -0,0 +1,12 @@
+export interface EditItemDialogProps {
+    datasetId: string;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    item: {
+        id: string;
+        input: unknown;
+        groundTruth?: unknown;
+    };
+    onSuccess?: () => void;
+}
+export declare function EditItemDialog({ datasetId, open, onOpenChange, item, onSuccess }: EditItemDialogProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/datasets/components/empty-datasets-table.d.ts

@@ -0,0 +1,4 @@
+export interface EmptyDatasetsTableProps {
+    onCreateClick?: () => void;
+}
+export declare function EmptyDatasetsTable({ onCreateClick }: EmptyDatasetsTableProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/datasets/components/experiment-trigger/experiment-trigger-dialog.d.ts

@@ -0,0 +1,8 @@
+export interface ExperimentTriggerDialogProps {
+    datasetId: string;
+    version?: number;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onSuccess?: (experimentId: string) => void;
+}
+export declare function ExperimentTriggerDialog({ datasetId, version, open, onOpenChange, onSuccess, }: ExperimentTriggerDialogProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/datasets/components/experiment-trigger/scorer-selector.d.ts

@@ -0,0 +1,6 @@
+export interface ScorerSelectorProps {
+    selectedScorers: string[];
+    setSelectedScorers: (scorers: string[]) => void;
+    disabled?: boolean;
+}
+export declare function ScorerSelector({ selectedScorers, setSelectedScorers, disabled }: ScorerSelectorProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/datasets/components/experiment-trigger/target-selector.d.ts

@@ -0,0 +1,8 @@
+export type TargetType = 'agent' | 'workflow' | 'scorer';
+export interface TargetSelectorProps {
+    targetType: TargetType | '';
+    setTargetType: (type: TargetType | '') => void;
+    targetId: string;
+    setTargetId: (id: string) => void;
+}
+export declare function TargetSelector({ targetType, setTargetType, targetId, setTargetId }: TargetSelectorProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/datasets/components/experiments/dataset-experiments-list.d.ts

@@ -0,0 +1,9 @@
+import { DatasetExperiment } from '@mastra/client-js';
+export interface DatasetExperimentsListProps {
+    experiments: DatasetExperiment[];
+    isSelectionActive: boolean;
+    selectedExperimentIds: string[];
+    onRowClick: (experimentId: string) => void;
+    onToggleSelection: (experimentId: string) => void;
+}
+export declare function DatasetExperimentsList({ experiments, isSelectionActive, selectedExperimentIds, onRowClick, onToggleSelection, }: DatasetExperimentsListProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/datasets/components/experiments/dataset-experiments-toolbar.d.ts

@@ -0,0 +1,13 @@
+import { DatasetExperimentsFilters } from '../../hooks/use-dataset-experiments';
+export type DatasetExperimentsToolbarProps = {
+    hasExperiments: boolean;
+    onCompareClick: () => void;
+    isSelectionActive: boolean;
+    selectedCount: number;
+    onExecuteCompare: () => void;
+    onCancelSelection: () => void;
+    filters: DatasetExperimentsFilters;
+    onFiltersChange: (filters: DatasetExperimentsFilters) => void;
+    targetIds: string[];
+};
+export declare function DatasetExperimentsToolbar({ hasExperiments, onCompareClick, isSelectionActive, selectedCount, onExecuteCompare, onCancelSelection, filters, onFiltersChange, targetIds, }: DatasetExperimentsToolbarProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/datasets/components/experiments/dataset-experiments.d.ts

@@ -0,0 +1,12 @@
+import { DatasetExperiment } from '@mastra/client-js';
+import { DatasetExperimentsFilters } from '../../hooks/use-dataset-experiments';
+export interface DatasetExperimentsProps {
+    experiments: DatasetExperiment[];
+    /** All experiments before filtering, used to derive target ID options */
+    allExperiments?: DatasetExperiment[];
+    isLoading: boolean;
+    datasetId: string;
+    filters: DatasetExperimentsFilters;
+    onFiltersChange: (filters: DatasetExperimentsFilters) => void;
+}
+export declare function DatasetExperiments({ experiments, allExperiments, isLoading, datasetId, filters, onFiltersChange, }: DatasetExperimentsProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/datasets/components/items/dataset-item-panel.d.ts

@@ -0,0 +1,13 @@
+import { DatasetItem } from '@mastra/client-js';
+export interface DatasetItemPanelProps {
+    datasetId: string;
+    item: DatasetItem;
+    items: DatasetItem[];
+    onItemChange: (itemId: string) => void;
+    onClose: () => void;
+}
+/**
+ * Inline panel showing full details of a single dataset item.
+ * Includes navigation to next/previous items and sections for Input, Ground Truth, and Metadata.
+ */
+export declare function DatasetItemPanel({ datasetId, item, items, onItemChange, onClose }: DatasetItemPanelProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/datasets/components/items/dataset-items-list.d.ts

@@ -0,0 +1,26 @@
+import { DatasetItem } from '@mastra/client-js';
+export interface DatasetItemsListProps {
+    items: DatasetItem[];
+    isLoading: boolean;
+    onItemClick?: (itemId: string) => void;
+    featuredItemId?: string | null;
+    setEndOfListElement?: (element: HTMLDivElement | null) => void;
+    isFetchingNextPage?: boolean;
+    hasNextPage?: boolean;
+    columns?: {
+        name: string;
+        label: string;
+        size: string;
+    }[];
+    searchQuery?: string;
+    isSelectionActive: boolean;
+    selectedIds: Set<string>;
+    onToggleSelection: (id: string, shiftKey: boolean, allIds: string[]) => void;
+    onSelectAll: (ids: string[]) => void;
+    onClearSelection: () => void;
+    maxSelection?: number;
+    onAddClick: () => void;
+    onImportClick?: () => void;
+    onImportJsonClick?: () => void;
+}
+export declare function DatasetItemsList({ items, isLoading, onItemClick, featuredItemId, setEndOfListElement, isFetchingNextPage, hasNextPage, columns, searchQuery, isSelectionActive, selectedIds, onToggleSelection, onSelectAll, onClearSelection, maxSelection, onAddClick, onImportClick, onImportJsonClick, }: DatasetItemsListProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/datasets/components/items/dataset-items-toolbar.d.ts

@@ -0,0 +1,24 @@
+export type DatasetItemsToolbarProps = {
+    onAddClick: () => void;
+    onImportClick: () => void;
+    onImportJsonClick: () => void;
+    onExportClick: () => void;
+    onExportJsonClick: () => void;
+    onCreateDatasetClick: () => void;
+    onAddToDatasetClick: () => void;
+    onDeleteClick: () => void;
+    onCompareClick: () => void;
+    hasItems: boolean;
+    searchQuery?: string;
+    onSearchChange?: (query: string) => void;
+    isSelectionActive: boolean;
+    selectedCount: number;
+    onExecuteAction: () => void;
+    onCancelSelection: () => void;
+    selectionMode: 'idle' | 'export' | 'export-json' | 'create-dataset' | 'add-to-dataset' | 'delete' | 'compare-items';
+    onVersionsClick: () => void;
+    isItemPanelOpen?: boolean;
+    isVersionsPanelOpen?: boolean;
+    isViewingOldVersion?: boolean;
+};
+export declare function DatasetItemsToolbar({ onAddClick, onImportClick, onImportJsonClick, onExportClick, onExportJsonClick, onCreateDatasetClick, onAddToDatasetClick, onDeleteClick, onCompareClick, hasItems, searchQuery, isSelectionActive, onSearchChange, selectedCount, onExecuteAction, onCancelSelection, selectionMode, onVersionsClick, isItemPanelOpen, isVersionsPanelOpen, isViewingOldVersion, }: DatasetItemsToolbarProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/datasets/components/items/dataset-items.d.ts

@@ -0,0 +1,34 @@
+import { DatasetItem } from '@mastra/client-js';
+import { DatasetVersion } from '../../hooks/use-dataset-versions';
+export interface DatasetItemsProps {
+    datasetId: string;
+    items: DatasetItem[];
+    isLoading: boolean;
+    featuredItemId: string | null;
+    onItemSelect: (itemId: string) => void;
+    onItemClose: () => void;
+    onAddClick: () => void;
+    onImportClick?: () => void;
+    onImportJsonClick?: () => void;
+    onBulkDeleteClick?: (itemIds: string[]) => void;
+    onCreateDatasetClick?: (items: DatasetItem[]) => void;
+    onAddToDatasetClick?: (items: DatasetItem[]) => void;
+    onCompareItemsClick?: (itemIds: string[]) => void;
+    datasetName?: string;
+    clearSelectionTrigger?: number;
+    setEndOfListElement?: (element: HTMLDivElement | null) => void;
+    isFetchingNextPage?: boolean;
+    hasNextPage?: boolean;
+    searchQuery?: string;
+    onSearchChange?: (query: string) => void;
+    activeDatasetVersion?: number | null;
+    currentDatasetVersion?: number;
+    onVersionSelect?: (version: DatasetVersion) => void;
+    onCompareVersionsClick?: (versionNumbers: string[]) => void;
+}
+/**
+ * Master-detail layout container for dataset items.
+ * Shows item list on left, item detail panel on right when an item is selected.
+ * Can also show versions panel instead of item detail when versions is toggled.
+ */
+export declare function DatasetItems({ datasetId, items, isLoading, featuredItemId, onItemSelect, onItemClose, onAddClick, onImportClick, onImportJsonClick, onBulkDeleteClick, onCreateDatasetClick, onAddToDatasetClick, onCompareItemsClick, datasetName, clearSelectionTrigger, setEndOfListElement, isFetchingNextPage, hasNextPage, searchQuery, onSearchChange, activeDatasetVersion, currentDatasetVersion, onVersionSelect, onCompareVersionsClick, }: DatasetItemsProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/datasets/components/items/dataset-versions-panel.d.ts

@@ -0,0 +1,12 @@
+import { DatasetVersion } from '../../hooks/use-dataset-versions';
+export interface DatasetVersionsPanelProps {
+    datasetId: string;
+    onClose: () => void;
+    onVersionSelect?: (version: DatasetVersion) => void;
+    onCompareVersionsClick?: (versionNumbers: string[]) => void;
+    activeVersion?: number | null;
+}
+/**
+ * Panel showing dataset version history with optional compare selection.
+ */
+export declare function DatasetVersionsPanel({ datasetId, onClose, onVersionSelect, onCompareVersionsClick, activeVersion, }: DatasetVersionsPanelProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/datasets/components/json-import/index.d.ts

@@ -0,0 +1 @@
+export { JSONImportDialog } from './json-import-dialog';

package/dist/src/domains/datasets/components/json-import/json-import-dialog.d.ts

@@ -0,0 +1,11 @@
+export interface JSONImportDialogProps {
+    datasetId: string;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onSuccess?: () => void;
+}
+/**
+ * Multi-step dialog for importing JSON data into a dataset.
+ * Flow: upload -> preview -> import -> complete
+ */
+export declare function JSONImportDialog({ datasetId, open, onOpenChange, onSuccess }: JSONImportDialogProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/datasets/components/json-import/json-preview-table.d.ts

@@ -0,0 +1,9 @@
+import { ImportableItem } from '../../utils/json-validation';
+export interface JSONPreviewTableProps {
+    items: ImportableItem[];
+    maxRows?: number;
+}
+/**
+ * Preview table for parsed JSON items
+ */
+export declare function JSONPreviewTable({ items, maxRows }: JSONPreviewTableProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/datasets/components/json-import/json-upload-step.d.ts

@@ -0,0 +1,10 @@
+export interface JSONUploadStepProps {
+    onFileSelect: (file: File) => void;
+    isParsing: boolean;
+    error?: string | null;
+}
+/**
+ * File upload dropzone for JSON import.
+ * Supports click-to-upload and drag-drop.
+ */
+export declare function JSONUploadStep({ onFileSelect, isParsing, error }: JSONUploadStepProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/datasets/components/json-import/json-validation-summary.d.ts

@@ -0,0 +1,9 @@
+import { JSONValidationError } from '../../utils/json-validation';
+export interface JSONValidationSummaryProps {
+    errors: JSONValidationError[];
+    maxErrors?: number;
+}
+/**
+ * Summary of JSON validation errors
+ */
+export declare function JSONValidationSummary({ errors, maxErrors }: JSONValidationSummaryProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/src/domains/datasets/components/schema-config-section.d.ts

@@ -0,0 +1,16 @@
+interface SchemaConfigSectionProps {
+    inputSchema: Record<string, unknown> | null | undefined;
+    outputSchema: Record<string, unknown> | null | undefined;
+    onChange: (schemas: {
+        inputSchema: Record<string, unknown> | null;
+        outputSchema: Record<string, unknown> | null;
+    }) => void;
+    disabled?: boolean;
+    defaultOpen?: boolean;
+}
+/**
+ * Collapsible section for configuring dataset schemas.
+ * Supports source-based auto-population from Agent, Workflow, or Scorer schemas.
+ */
+export declare function SchemaConfigSection({ inputSchema, outputSchema, onChange, disabled, defaultOpen, }: SchemaConfigSectionProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/domains/datasets/components/schema-settings/index.d.ts

@@ -0,0 +1 @@
+export { SchemaField } from './schema-field';

package/dist/src/domains/datasets/components/schema-settings/schema-field.d.ts

@@ -0,0 +1,20 @@
+import { JSONSchema7 } from 'json-schema';
+interface SchemaFieldProps {
+    label: string;
+    schemaType: 'input' | 'output';
+    value: Record<string, unknown> | null | undefined;
+    onChange: (schema: Record<string, unknown> | null) => void;
+    error?: string;
+    /** Schema to auto-populate when field is enabled */
+    sourceSchema?: JSONSchema7 | null;
+    /** Whether to auto-populate from sourceSchema when enabled */
+    autoPopulate?: boolean;
+}
+/**
+ * Schema field with toggle and JSON editor.
+ * Toggle enables/disables the schema (null = disabled).
+ * JSON parsing errors shown inline.
+ * Supports auto-population from sourceSchema when autoPopulate is true.
+ */
+export declare function SchemaField({ label, schemaType, value, onChange, error, sourceSchema, autoPopulate, }: SchemaFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/domains/datasets/components/schema-settings/schema-import.d.ts

@@ -0,0 +1,11 @@
+interface SchemaImportProps {
+    schemaType: 'input' | 'output';
+    onImport: (schema: Record<string, unknown>) => void;
+}
+/**
+ * Component for importing schema from workflows or using predefined agent schemas.
+ * For workflows: fetches and imports the workflow's input/output schema.
+ * For agents: uses predefined MessageListInput schema for input, string for output.
+ */
+export declare function SchemaImport({ schemaType, onImport }: SchemaImportProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/domains/datasets/components/versions/dataset-compare-version-toolbar.d.ts

@@ -0,0 +1,7 @@
+export interface DatasetCompareVersionToolbarProps {
+    datasetId: string;
+    versionA?: string;
+    versionB?: string;
+    onVersionChange?: (versionA: string, versionB: string) => void;
+}
+export declare function DatasetCompareVersionToolbar({ datasetId, versionA, versionB, onVersionChange, }: DatasetCompareVersionToolbarProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/datasets/components/versions/dataset-compare-versions-list.d.ts

@@ -0,0 +1,11 @@
+import { DatasetItem } from '@mastra/client-js';
+export interface DatasetCompareVersionsListProps {
+    allItems: Array<{
+        id: string;
+        createdAt: Date;
+    }>;
+    itemsAMap: Map<string, DatasetItem>;
+    itemsBMap: Map<string, DatasetItem>;
+    onItemClick?: (itemId: string, itemA?: DatasetItem, itemB?: DatasetItem) => void;
+}
+export declare function DatasetCompareVersionsList({ allItems, itemsAMap, itemsBMap, onItemClick, }: DatasetCompareVersionsListProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/datasets/components/versions/dataset-item-versions-panel.d.ts

@@ -0,0 +1,13 @@
+import { DatasetItemVersion } from '../../hooks/use-dataset-item-versions';
+export interface DatasetItemVersionsPanelProps {
+    datasetId: string;
+    itemId: string;
+    onClose: () => void;
+    onVersionSelect?: (version: DatasetItemVersion) => void;
+    onCompareVersionsClick?: (versionIds: string[]) => void;
+    activeVersion?: number | null;
+}
+/**
+ * Panel showing dataset item version history.
+ */
+export declare function DatasetItemVersionsPanel({ datasetId, itemId, onVersionSelect, onCompareVersionsClick, activeVersion, }: DatasetItemVersionsPanelProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/datasets/components/versions/index.d.ts

@@ -0,0 +1,3 @@
+export { DatasetItemVersionsPanel } from './dataset-item-versions-panel';
+export { DatasetCompareVersionToolbar } from './dataset-compare-version-toolbar';
+export { DatasetCompareVersionsList } from './dataset-compare-versions-list';

package/dist/src/domains/datasets/hooks/use-agent-schema.d.ts

@@ -0,0 +1,12 @@
+import { JSONSchema7 } from 'json-schema';
+/**
+ * Hook that returns the agent input/output schemas.
+ * - inputSchema: MessageListInput (what you pass to agent.generate())
+ * - outputSchema: string (text response)
+ */
+export declare function useAgentSchema(): {
+    inputSchema: JSONSchema7;
+    outputSchema: JSONSchema7;
+    isLoading: boolean;
+    error: Error | null;
+};

package/dist/src/domains/datasets/hooks/use-column-mapping.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Field types for column mapping in CSV import.
+ * - input: Data passed to the target (agent/workflow/scorer)
+ * - groundTruth: Ground truth for comparison
+ * - metadata: Additional context stored with items
+ * - ignore: Columns not imported
+ */
+export type FieldType = 'input' | 'groundTruth' | 'metadata' | 'ignore';
+/**
+ * Mapping of column names to their target field type.
+ */
+export type ColumnMapping = Record<string, FieldType>;
+/**
+ * Hook for managing column mapping state in CSV import flow.
+ *
+ * @param headers - Array of column names from CSV
+ * @returns State and actions for column mapping
+ */
+export declare function useColumnMapping(headers: string[]): {
+    mapping: ColumnMapping;
+    setColumnField: (column: string, field: FieldType) => void;
+    resetMapping: () => void;
+    isInputMapped: boolean;
+};

package/dist/src/domains/datasets/hooks/use-compare-experiments.d.ts

@@ -0,0 +1,11 @@
+import { CompareExperimentsParams } from '@mastra/client-js';
+type CompareExperimentsOptions = Omit<CompareExperimentsParams, 'datasetId' | 'experimentIdA' | 'experimentIdB'>;
+/**
+ * Hook to compare two dataset experiments for regression detection
+ * @param datasetId - ID of the dataset
+ * @param experimentIdA - ID of the first experiment (baseline)
+ * @param experimentIdB - ID of the second experiment (comparison)
+ * @param options - Optional thresholds for regression detection
+ */
+export declare const useCompareExperiments: (datasetId: string, experimentIdA: string, experimentIdB: string, options?: CompareExperimentsOptions) => import('@tanstack/react-query').UseQueryResult<import('@mastra/client-js').CompareExperimentsResponse, Error>;
+export {};

package/dist/src/domains/datasets/hooks/use-csv-parser.d.ts

@@ -0,0 +1,17 @@
+import { default as Papa } from 'papaparse';
+/** Result of parsing a CSV file */
+export interface ParsedCSV {
+    headers: string[];
+    data: Record<string, unknown>[];
+    errors: Papa.ParseError[];
+    warnings: string[];
+}
+/**
+ * Hook for parsing CSV files with JSON cell handling
+ * Uses web worker for large files (>1MB)
+ */
+export declare function useCSVParser(): {
+    parseFile: (file: File) => Promise<ParsedCSV>;
+    isParsing: boolean;
+    error: Error | null;
+};

package/dist/src/domains/datasets/hooks/use-dataset-experiments.d.ts

@@ -0,0 +1,49 @@
+export interface DatasetExperimentsFilters {
+    status?: string;
+    targetType?: string;
+    targetId?: string;
+}
+/**
+ * Hook to list experiments for a dataset with optional pagination and filters.
+ * Filters are applied client-side until the backend supports them.
+ */
+export declare const useDatasetExperiments: (datasetId: string, pagination?: {
+    page?: number;
+    perPage?: number;
+}, filters?: DatasetExperimentsFilters) => import('@tanstack/react-query').UseQueryResult<{
+    experiments: import('@mastra/client-js').DatasetExperiment[];
+    pagination: import('@mastra/core/storage').PaginationInfo;
+}, Error>;
+/**
+ * Hook to fetch a single dataset experiment with polling while running
+ * Polls every 2 seconds while status is 'running' or 'pending'
+ */
+export declare const useDatasetExperiment: (datasetId: string, experimentId: string) => import('@tanstack/react-query').UseQueryResult<import('@mastra/client-js').DatasetExperiment, Error>;
+interface UseDatasetExperimentResultsParams {
+    datasetId: string;
+    experimentId: string;
+    pagination?: {
+        page?: number;
+        perPage?: number;
+    };
+    experimentStatus?: string;
+}
+/**
+ * Hook to list results for a dataset experiment with optional pagination
+ * Polls every 2 seconds while experiment status is 'pending' or 'running'
+ */
+export declare const useDatasetExperimentResults: ({ datasetId, experimentId, pagination, experimentStatus, }: UseDatasetExperimentResultsParams) => import('@tanstack/react-query').UseQueryResult<{
+    results: import('@mastra/client-js').DatasetExperimentResult[];
+    pagination: import('@mastra/core/storage').PaginationInfo;
+}, Error>;
+/**
+ * Hook to fetch scores for an experiment, transformed to Record<itemId, ScoreData[]>
+ * ScoreData matches ResultsTable expectation: { id, scorerId, score, reason? }
+ */
+export declare const useScoresByExperimentId: (experimentId: string) => import('@tanstack/react-query').UseQueryResult<Record<string, {
+    id: string;
+    scorerId: string;
+    score: number;
+    reason?: string;
+}[]>, Error>;
+export {};

package/dist/src/domains/datasets/hooks/use-dataset-item-versions.d.ts

@@ -0,0 +1,21 @@
+export interface DatasetItemVersion {
+    id: string;
+    datasetId: string;
+    datasetVersion: number;
+    input: unknown;
+    groundTruth?: unknown;
+    metadata?: Record<string, unknown>;
+    validTo: number | null;
+    isDeleted: boolean;
+    createdAt: Date | string;
+    updatedAt: Date | string;
+    isLatest: boolean;
+}
+/**
+ * Hook to fetch full item history (SCD-2 rows).
+ */
+export declare const useDatasetItemVersions: (datasetId: string, itemId: string) => import('@tanstack/react-query').UseQueryResult<DatasetItemVersion[], Error>;
+/**
+ * Hook to fetch a specific version of a dataset item.
+ */
+export declare const useDatasetItemVersion: (datasetId: string, itemId: string, datasetVersion: number) => import('@tanstack/react-query').UseQueryResult<DatasetItemVersion, Error>;