@mastra/core/dist/datasets/dataset.d.ts

Mastra is a framework for building AI-powered applications and agents with a modern TypeScript stack.

import type { Mastra } from '../mastra/index.js';
import type { DatasetRecord, DatasetItem, DatasetItemRow, DatasetItemSource, DatasetVersion, TargetType, UpdateExperimentResultInput } from '../storage/types.js';
import type { StartExperimentConfig, ExperimentSummary } from './experiment/types.js';
/**
 * Public API for interacting with a single dataset.
 *
 * Provides methods for item CRUD, versioning, and experiment management.
 * Obtained via `DatasetsManager.get()` or `DatasetsManager.create()`.
 */
export declare class Dataset {
    #private;
    readonly id: string;
    constructor(id: string, mastra: Mastra);
    /**
     * Get the full dataset record from storage.
     */
    getDetails(): Promise<DatasetRecord>;
    /**
     * Update dataset metadata and/or schemas.
     * Zod schemas are automatically converted to JSON Schema.
     */
    update(input: {
        name?: string;
        description?: string;
        metadata?: Record<string, unknown>;
        inputSchema?: unknown;
        groundTruthSchema?: unknown;
        requestContextSchema?: Record<string, unknown> | null;
        tags?: string[] | null;
        targetType?: TargetType | null;
        targetIds?: string[] | null;
        scorerIds?: string[] | null;
    }): Promise<DatasetRecord>;
    /**
     * Add a single item to the dataset.
     */
    addItem(input: {
        input: unknown;
        groundTruth?: unknown;
        expectedTrajectory?: unknown;
        requestContext?: Record<string, unknown>;
        metadata?: Record<string, unknown>;
        source?: DatasetItemSource;
    }): Promise<DatasetItem>;
    /**
     * Add multiple items to the dataset in bulk.
     */
    addItems(input: {
        items: Array<{
            input: unknown;
            groundTruth?: unknown;
            expectedTrajectory?: unknown;
            requestContext?: Record<string, unknown>;
            metadata?: Record<string, unknown>;
            source?: DatasetItemSource;
        }>;
    }): Promise<DatasetItem[]>;
    /**
     * Get a single item by ID, optionally at a specific version.
     */
    getItem(args: {
        itemId: string;
        version?: number;
    }): Promise<DatasetItem | null>;
    /**
     * List items in the dataset, optionally at a specific version.
     */
    listItems(args?: {
        version?: number;
        page?: number;
        perPage?: number;
        search?: string;
    }): Promise<DatasetItem[] | {
        items: DatasetItem[];
        pagination: {
            total: number;
            page: number;
            perPage: number | false;
            hasMore: boolean;
        };
    }>;
    /**
     * Update an existing item in the dataset.
     */
    updateItem(input: {
        itemId: string;
        input?: unknown;
        groundTruth?: unknown;
        expectedTrajectory?: unknown;
        requestContext?: Record<string, unknown>;
        metadata?: Record<string, unknown>;
    }): Promise<DatasetItem>;
    /**
     * Delete a single item from the dataset.
     */
    deleteItem(args: {
        itemId: string;
    }): Promise<void>;
    /**
     * Delete multiple items from the dataset in bulk.
     */
    deleteItems(args: {
        itemIds: string[];
    }): Promise<void>;
    /**
     * List all versions of this dataset.
     */
    listVersions(args?: {
        page?: number;
        perPage?: number;
    }): Promise<{
        versions: DatasetVersion[];
        pagination: {
            total: number;
            page: number;
            perPage: number | false;
            hasMore: boolean;
        };
    }>;
    /**
     * Get full SCD-2 history of a specific item across all dataset versions.
     */
    getItemHistory(args: {
        itemId: string;
    }): Promise<DatasetItemRow[]>;
    /**
     * Run an experiment on this dataset and wait for completion.
     */
    startExperiment<I = unknown, O = unknown, E = unknown>(config: StartExperimentConfig<I, O, E>): Promise<ExperimentSummary>;
    /**
     * Start an experiment asynchronously (fire-and-forget).
     * Returns immediately with the experiment ID and pending status.
     */
    startExperimentAsync<I = unknown, O = unknown, E = unknown>(config: StartExperimentConfig<I, O, E>): Promise<{
        experimentId: string;
        status: 'pending';
        totalItems: number;
    }>;
    /**
     * List all experiments (runs) for this dataset.
     */
    listExperiments(args?: {
        page?: number;
        perPage?: number;
    }): Promise<import("../storage/types.js").ListExperimentsOutput>;
    /**
     * Get a specific experiment (run) by ID.
     */
    getExperiment(args: {
        experimentId: string;
    }): Promise<import("../storage/types.js").Experiment | null>;
    /**
     * List results for a specific experiment.
     */
    listExperimentResults(args: {
        experimentId: string;
        page?: number;
        perPage?: number;
    }): Promise<import("../storage/types.js").ListExperimentResultsOutput>;
    /**
     * Delete an experiment (run) by ID.
     */
    /**
     * Update an experiment result's status or tags.
     */
    updateExperimentResult(input: UpdateExperimentResultInput): Promise<import("../storage/types.js").ExperimentResult>;
    deleteExperiment(args: {
        experimentId: string;
    }): Promise<void>;
}
//# sourceMappingURL=dataset.d.ts.map