import type { DatasetRecord, DatasetItem, DatasetItemRow, DatasetVersion, CreateDatasetInput, UpdateDatasetInput, AddDatasetItemInput, UpdateDatasetItemInput, DeleteDatasetItemInput, ListDatasetsInput, ListDatasetsOutput, ListDatasetItemsInput, ListDatasetItemsOutput, ListDatasetVersionsInput, ListDatasetVersionsOutput, BatchInsertItemsInput, BatchDeleteItemsInput, DatasetTenancyFilters } from '../../types.js';
import { StorageDomain } from '../base.js';
import type { DatasetItemBatchPlan } from './identity.js';
/**
 * Abstract base class for datasets storage domain.
 * Provides the contract for dataset and dataset item CRUD operations.
 *
 * Schema validation is handled in this base class via Template Method pattern.
 * Subclasses implement protected _do* methods for actual storage operations,
 * including SCD-2 versioning (version bump, row ops, dataset_version insert).
 */
export declare abstract class DatasetsStorage extends StorageDomain {
    constructor();
    protected validateCallerDefinedDatasetId(id: string): void;
    /**
     * Returns an existing dataset when a caller-defined ID is reused compatibly.
     * Optional immutable fields normalize omitted and null values to the same value.
     */
    protected resolveExistingDataset(existing: DatasetRecord, input: CreateDatasetInput & {
        id: string;
    }): DatasetRecord;
    dangerouslyClearAll(): Promise<void>;
    abstract createDataset(input: CreateDatasetInput): Promise<DatasetRecord>;
    /**
     * Fetch a dataset by ID. When `filters` is provided, the row is only returned
     * if it also matches the tenancy filters — returns `null` on mismatch (never
     * throws, to avoid leaking existence across tenants via error timing/text).
     */
    abstract getDatasetById(args: {
        id: string;
        filters?: DatasetTenancyFilters;
    }): Promise<DatasetRecord | null>;
    /**
     * Delete a dataset. When `filters` is provided, the delete is a silent no-op
     * if the row does not match the tenancy filters. Never throws on mismatch.
     */
    abstract deleteDataset(args: {
        id: string;
        filters?: DatasetTenancyFilters;
    }): Promise<void>;
    abstract listDatasets(args: ListDatasetsInput): Promise<ListDatasetsOutput>;
    /**
     * Update a dataset. Validates existing items against new schemas if schemas are changing.
     * Subclasses implement _doUpdateDataset for actual storage operation.
     */
    updateDataset(args: UpdateDatasetInput): Promise<DatasetRecord>;
    /** Subclasses implement actual storage update logic */
    protected abstract _doUpdateDataset(args: UpdateDatasetInput): Promise<DatasetRecord>;
    /**
     * Add an item to a dataset. Validates input/groundTruth against dataset schemas.
     * Subclasses implement _doAddItem which handles SCD-2 versioning internally.
     */
    addItem(args: AddDatasetItemInput): Promise<DatasetItem>;
    /** Subclasses implement actual storage add logic with SCD-2 versioning */
    protected abstract _doAddItem(args: AddDatasetItemInput): Promise<DatasetItem>;
    /**
     * Update an item in a dataset. Validates changed fields against dataset schemas.
     * Subclasses implement _doUpdateItem which handles SCD-2 versioning internally.
     */
    updateItem(args: UpdateDatasetItemInput): Promise<DatasetItem>;
    /** Subclasses implement actual storage update logic with SCD-2 versioning */
    protected abstract _doUpdateItem(args: UpdateDatasetItemInput): Promise<DatasetItem>;
    /**
     * Delete an item from a dataset. Creates a tombstone row via SCD-2.
     * Subclasses implement _doDeleteItem which handles SCD-2 versioning internally.
     *
     * When `args.filters` is set, the delete is a silent no-op if the parent
     * dataset row does not match the tenancy filters — prevents deleting items
     * from a dataset in another tenant via a leaked datasetId.
     */
    deleteItem(args: DeleteDatasetItemInput): Promise<void>;
    /** Subclasses implement actual storage delete logic with SCD-2 versioning */
    protected abstract _doDeleteItem(args: DeleteDatasetItemInput): Promise<void>;
    abstract listItems(args: ListDatasetItemsInput): Promise<ListDatasetItemsOutput>;
    abstract getItemById(args: {
        id: string;
        datasetVersion?: number;
    }): Promise<DatasetItem | null>;
    abstract getItemsByVersion(args: {
        datasetId: string;
        version: number;
    }): Promise<DatasetItem[]>;
    abstract getItemHistory(itemId: string): Promise<DatasetItemRow[]>;
    abstract createDatasetVersion(datasetId: string, version: number): Promise<DatasetVersion>;
    abstract listDatasetVersions(input: ListDatasetVersionsInput): Promise<ListDatasetVersionsOutput>;
    /**
     * Batch insert items to a dataset. Validates all items against dataset schemas,
     * then delegates to subclass which handles SCD-2 versioning internally.
     */
    batchInsertItems(input: BatchInsertItemsInput): Promise<DatasetItem[]>;
    protected planDatasetItemBatch(items: BatchInsertItemsInput['items'], historyRows: DatasetItemRow[], createId: () => string): DatasetItemBatchPlan;
    protected datasetItemFromRow(row: DatasetItemRow): DatasetItem;
    /** Subclasses implement batch insert with SCD-2 versioning */
    protected abstract _doBatchInsertItems(input: BatchInsertItemsInput): Promise<DatasetItem[]>;
    /**
     * Batch delete items from a dataset. Creates tombstone rows via SCD-2.
     * Subclasses implement _doBatchDeleteItems which handles SCD-2 versioning internally.
     */
    batchDeleteItems(input: BatchDeleteItemsInput): Promise<void>;
    /** Subclasses implement batch delete with SCD-2 versioning */
    protected abstract _doBatchDeleteItems(input: BatchDeleteItemsInput): Promise<void>;
}
//# sourceMappingURL=base.d.ts.map