import z from 'zod';
export declare const datasetIdPathParams: z.ZodObject<{
    datasetId: z.ZodString;
}, "strip", z.ZodTypeAny, {
    datasetId: string;
}, {
    datasetId: string;
}>;
export declare const experimentIdPathParams: z.ZodObject<{
    experimentId: z.ZodString;
}, "strip", z.ZodTypeAny, {
    experimentId: string;
}, {
    experimentId: string;
}>;
export declare const itemIdPathParams: z.ZodObject<{
    itemId: z.ZodString;
}, "strip", z.ZodTypeAny, {
    itemId: string;
}, {
    itemId: string;
}>;
export declare const datasetAndExperimentIdPathParams: z.ZodObject<{
    datasetId: z.ZodString;
    experimentId: z.ZodString;
}, "strip", z.ZodTypeAny, {
    datasetId: string;
    experimentId: string;
}, {
    datasetId: string;
    experimentId: string;
}>;
export declare const datasetAndItemIdPathParams: z.ZodObject<{
    datasetId: z.ZodString;
    itemId: z.ZodString;
}, "strip", z.ZodTypeAny, {
    datasetId: string;
    itemId: string;
}, {
    datasetId: string;
    itemId: string;
}>;
export declare const paginationQuerySchema: z.ZodObject<{
    page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
    perPage: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
}, "strip", z.ZodTypeAny, {
    page: number;
    perPage: number;
}, {
    page?: number | undefined;
    perPage?: number | undefined;
}>;
export declare const listItemsQuerySchema: z.ZodObject<{
    page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
    perPage: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
    version: z.ZodOptional<z.ZodNumber>;
    search: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    page: number;
    perPage: number;
    version?: number | undefined;
    search?: string | undefined;
}, {
    page?: number | undefined;
    perPage?: number | undefined;
    version?: number | undefined;
    search?: string | undefined;
}>;
export declare const createDatasetBodySchema: z.ZodObject<{
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    inputSchema: z.ZodOptional<z.ZodUnion<[z.ZodType<Record<string, unknown>, z.ZodTypeDef, Record<string, unknown>>, z.ZodNull]>>;
    groundTruthSchema: z.ZodOptional<z.ZodUnion<[z.ZodType<Record<string, unknown>, z.ZodTypeDef, Record<string, unknown>>, z.ZodNull]>>;
}, "strip", z.ZodTypeAny, {
    name: string;
    metadata?: Record<string, unknown> | undefined;
    description?: string | undefined;
    inputSchema?: Record<string, unknown> | null | undefined;
    groundTruthSchema?: Record<string, unknown> | null | undefined;
}, {
    name: string;
    metadata?: Record<string, unknown> | undefined;
    description?: string | undefined;
    inputSchema?: Record<string, unknown> | null | undefined;
    groundTruthSchema?: Record<string, unknown> | null | undefined;
}>;
export declare const updateDatasetBodySchema: z.ZodObject<{
    name: z.ZodOptional<z.ZodString>;
    description: z.ZodOptional<z.ZodString>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    inputSchema: z.ZodOptional<z.ZodUnion<[z.ZodType<Record<string, unknown>, z.ZodTypeDef, Record<string, unknown>>, z.ZodNull]>>;
    groundTruthSchema: z.ZodOptional<z.ZodUnion<[z.ZodType<Record<string, unknown>, z.ZodTypeDef, Record<string, unknown>>, z.ZodNull]>>;
}, "strip", z.ZodTypeAny, {
    metadata?: Record<string, unknown> | undefined;
    name?: string | undefined;
    description?: string | undefined;
    inputSchema?: Record<string, unknown> | null | undefined;
    groundTruthSchema?: Record<string, unknown> | null | undefined;
}, {
    metadata?: Record<string, unknown> | undefined;
    name?: string | undefined;
    description?: string | undefined;
    inputSchema?: Record<string, unknown> | null | undefined;
    groundTruthSchema?: Record<string, unknown> | null | undefined;
}>;
export declare const addItemBodySchema: z.ZodObject<{
    input: z.ZodUnknown;
    groundTruth: z.ZodOptional<z.ZodUnknown>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    metadata?: Record<string, unknown> | undefined;
    input?: unknown;
    groundTruth?: unknown;
}, {
    metadata?: Record<string, unknown> | undefined;
    input?: unknown;
    groundTruth?: unknown;
}>;
export declare const updateItemBodySchema: z.ZodObject<{
    input: z.ZodOptional<z.ZodUnknown>;
    groundTruth: z.ZodOptional<z.ZodUnknown>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    metadata?: Record<string, unknown> | undefined;
    input?: unknown;
    groundTruth?: unknown;
}, {
    metadata?: Record<string, unknown> | undefined;
    input?: unknown;
    groundTruth?: unknown;
}>;
export declare const triggerExperimentBodySchema: z.ZodObject<{
    targetType: z.ZodEnum<["agent", "workflow", "scorer"]>;
    targetId: z.ZodString;
    scorerIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    version: z.ZodOptional<z.ZodNumber>;
    maxConcurrency: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    targetType: "scorer" | "agent" | "workflow";
    targetId: string;
    version?: number | undefined;
    scorerIds?: string[] | undefined;
    maxConcurrency?: number | undefined;
}, {
    targetType: "scorer" | "agent" | "workflow";
    targetId: string;
    version?: number | undefined;
    scorerIds?: string[] | undefined;
    maxConcurrency?: number | undefined;
}>;
export declare const compareExperimentsBodySchema: z.ZodObject<{
    experimentIdA: z.ZodString;
    experimentIdB: z.ZodString;
}, "strip", z.ZodTypeAny, {
    experimentIdA: string;
    experimentIdB: string;
}, {
    experimentIdA: string;
    experimentIdB: string;
}>;
export declare const datasetResponseSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    description: z.ZodNullable<z.ZodOptional<z.ZodString>>;
    metadata: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
    inputSchema: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
    groundTruthSchema: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
    version: z.ZodNumber;
    createdAt: z.ZodDate;
    updatedAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    name: string;
    id: string;
    createdAt: Date;
    updatedAt: Date;
    version: number;
    metadata?: Record<string, unknown> | null | undefined;
    description?: string | null | undefined;
    inputSchema?: Record<string, unknown> | null | undefined;
    groundTruthSchema?: Record<string, unknown> | null | undefined;
}, {
    name: string;
    id: string;
    createdAt: Date;
    updatedAt: Date;
    version: number;
    metadata?: Record<string, unknown> | null | undefined;
    description?: string | null | undefined;
    inputSchema?: Record<string, unknown> | null | undefined;
    groundTruthSchema?: Record<string, unknown> | null | undefined;
}>;
export declare const datasetItemResponseSchema: z.ZodObject<{
    id: z.ZodString;
    datasetId: z.ZodString;
    datasetVersion: z.ZodNumber;
    input: z.ZodUnknown;
    groundTruth: z.ZodOptional<z.ZodUnknown>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    createdAt: z.ZodDate;
    updatedAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    id: string;
    createdAt: Date;
    updatedAt: Date;
    datasetId: string;
    datasetVersion: number;
    metadata?: Record<string, unknown> | undefined;
    input?: unknown;
    groundTruth?: unknown;
}, {
    id: string;
    createdAt: Date;
    updatedAt: Date;
    datasetId: string;
    datasetVersion: number;
    metadata?: Record<string, unknown> | undefined;
    input?: unknown;
    groundTruth?: unknown;
}>;
export declare const experimentResponseSchema: z.ZodObject<{
    id: z.ZodString;
    datasetId: z.ZodNullable<z.ZodString>;
    datasetVersion: z.ZodNullable<z.ZodNumber>;
    targetType: z.ZodEnum<["agent", "workflow", "scorer", "processor"]>;
    targetId: z.ZodString;
    name: z.ZodOptional<z.ZodString>;
    description: z.ZodOptional<z.ZodString>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    status: z.ZodEnum<["pending", "running", "completed", "failed"]>;
    totalItems: z.ZodNumber;
    succeededCount: z.ZodNumber;
    failedCount: z.ZodNumber;
    skippedCount: z.ZodNumber;
    startedAt: z.ZodNullable<z.ZodDate>;
    completedAt: z.ZodNullable<z.ZodDate>;
    createdAt: z.ZodDate;
    updatedAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    status: "running" | "failed" | "pending" | "completed";
    id: string;
    createdAt: Date;
    updatedAt: Date;
    datasetId: string | null;
    targetType: "scorer" | "agent" | "processor" | "workflow";
    targetId: string;
    datasetVersion: number | null;
    totalItems: number;
    succeededCount: number;
    failedCount: number;
    skippedCount: number;
    startedAt: Date | null;
    completedAt: Date | null;
    metadata?: Record<string, unknown> | undefined;
    name?: string | undefined;
    description?: string | undefined;
}, {
    status: "running" | "failed" | "pending" | "completed";
    id: string;
    createdAt: Date;
    updatedAt: Date;
    datasetId: string | null;
    targetType: "scorer" | "agent" | "processor" | "workflow";
    targetId: string;
    datasetVersion: number | null;
    totalItems: number;
    succeededCount: number;
    failedCount: number;
    skippedCount: number;
    startedAt: Date | null;
    completedAt: Date | null;
    metadata?: Record<string, unknown> | undefined;
    name?: string | undefined;
    description?: string | undefined;
}>;
export declare const scorerResultSchema: z.ZodObject<{
    scorerId: z.ZodString;
    scorerName: z.ZodString;
    score: z.ZodNullable<z.ZodNumber>;
    reason: z.ZodNullable<z.ZodString>;
    error: z.ZodNullable<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    error: string | null;
    score: number | null;
    scorerId: string;
    scorerName: string;
    reason: string | null;
}, {
    error: string | null;
    score: number | null;
    scorerId: string;
    scorerName: string;
    reason: string | null;
}>;
export declare const experimentResultResponseSchema: z.ZodObject<{
    id: z.ZodString;
    experimentId: z.ZodString;
    itemId: z.ZodString;
    itemDatasetVersion: z.ZodNullable<z.ZodNumber>;
    input: z.ZodUnknown;
    output: z.ZodNullable<z.ZodUnknown>;
    groundTruth: z.ZodNullable<z.ZodUnknown>;
    error: z.ZodNullable<z.ZodObject<{
        message: z.ZodString;
        stack: z.ZodOptional<z.ZodString>;
        code: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        message: string;
        code?: string | undefined;
        stack?: string | undefined;
    }, {
        message: string;
        code?: string | undefined;
        stack?: string | undefined;
    }>>;
    startedAt: z.ZodDate;
    completedAt: z.ZodDate;
    retryCount: z.ZodNumber;
    traceId: z.ZodNullable<z.ZodString>;
    createdAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    traceId: string | null;
    error: {
        message: string;
        code?: string | undefined;
        stack?: string | undefined;
    } | null;
    id: string;
    createdAt: Date;
    retryCount: number;
    experimentId: string;
    itemId: string;
    startedAt: Date;
    completedAt: Date;
    itemDatasetVersion: number | null;
    output?: unknown;
    input?: unknown;
    groundTruth?: unknown;
}, {
    traceId: string | null;
    error: {
        message: string;
        code?: string | undefined;
        stack?: string | undefined;
    } | null;
    id: string;
    createdAt: Date;
    retryCount: number;
    experimentId: string;
    itemId: string;
    startedAt: Date;
    completedAt: Date;
    itemDatasetVersion: number | null;
    output?: unknown;
    input?: unknown;
    groundTruth?: unknown;
}>;
export declare const comparisonResponseSchema: z.ZodObject<{
    baselineId: z.ZodString;
    items: z.ZodArray<z.ZodObject<{
        itemId: z.ZodString;
        input: z.ZodNullable<z.ZodUnknown>;
        groundTruth: z.ZodNullable<z.ZodUnknown>;
        results: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodObject<{
            output: z.ZodNullable<z.ZodUnknown>;
            scores: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodNumber>>;
        }, "strip", z.ZodTypeAny, {
            scores: Record<string, number | null>;
            output?: unknown;
        }, {
            scores: Record<string, number | null>;
            output?: unknown;
        }>>>;
    }, "strip", z.ZodTypeAny, {
        results: Record<string, {
            scores: Record<string, number | null>;
            output?: unknown;
        } | null>;
        itemId: string;
        input?: unknown;
        groundTruth?: unknown;
    }, {
        results: Record<string, {
            scores: Record<string, number | null>;
            output?: unknown;
        } | null>;
        itemId: string;
        input?: unknown;
        groundTruth?: unknown;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    baselineId: string;
    items: {
        results: Record<string, {
            scores: Record<string, number | null>;
            output?: unknown;
        } | null>;
        itemId: string;
        input?: unknown;
        groundTruth?: unknown;
    }[];
}, {
    baselineId: string;
    items: {
        results: Record<string, {
            scores: Record<string, number | null>;
            output?: unknown;
        } | null>;
        itemId: string;
        input?: unknown;
        groundTruth?: unknown;
    }[];
}>;
export declare const experimentSummaryResponseSchema: z.ZodObject<{
    experimentId: z.ZodString;
    status: z.ZodEnum<["pending", "running", "completed", "failed"]>;
    totalItems: z.ZodNumber;
    succeededCount: z.ZodNumber;
    failedCount: z.ZodNumber;
    startedAt: z.ZodDate;
    completedAt: z.ZodNullable<z.ZodDate>;
    results: z.ZodArray<z.ZodObject<{
        itemId: z.ZodString;
        itemDatasetVersion: z.ZodNullable<z.ZodNumber>;
        input: z.ZodUnknown;
        output: z.ZodNullable<z.ZodUnknown>;
        groundTruth: z.ZodNullable<z.ZodUnknown>;
        error: z.ZodNullable<z.ZodString>;
        startedAt: z.ZodDate;
        completedAt: z.ZodDate;
        retryCount: z.ZodNumber;
        scores: z.ZodArray<z.ZodObject<{
            scorerId: z.ZodString;
            scorerName: z.ZodString;
            score: z.ZodNullable<z.ZodNumber>;
            reason: z.ZodNullable<z.ZodString>;
            error: z.ZodNullable<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            error: string | null;
            score: number | null;
            scorerId: string;
            scorerName: string;
            reason: string | null;
        }, {
            error: string | null;
            score: number | null;
            scorerId: string;
            scorerName: string;
            reason: string | null;
        }>, "many">;
    }, "strip", z.ZodTypeAny, {
        error: string | null;
        retryCount: number;
        itemId: string;
        startedAt: Date;
        completedAt: Date;
        itemDatasetVersion: number | null;
        scores: {
            error: string | null;
            score: number | null;
            scorerId: string;
            scorerName: string;
            reason: string | null;
        }[];
        output?: unknown;
        input?: unknown;
        groundTruth?: unknown;
    }, {
        error: string | null;
        retryCount: number;
        itemId: string;
        startedAt: Date;
        completedAt: Date;
        itemDatasetVersion: number | null;
        scores: {
            error: string | null;
            score: number | null;
            scorerId: string;
            scorerName: string;
            reason: string | null;
        }[];
        output?: unknown;
        input?: unknown;
        groundTruth?: unknown;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    status: "running" | "failed" | "pending" | "completed";
    results: {
        error: string | null;
        retryCount: number;
        itemId: string;
        startedAt: Date;
        completedAt: Date;
        itemDatasetVersion: number | null;
        scores: {
            error: string | null;
            score: number | null;
            scorerId: string;
            scorerName: string;
            reason: string | null;
        }[];
        output?: unknown;
        input?: unknown;
        groundTruth?: unknown;
    }[];
    experimentId: string;
    totalItems: number;
    succeededCount: number;
    failedCount: number;
    startedAt: Date;
    completedAt: Date | null;
}, {
    status: "running" | "failed" | "pending" | "completed";
    results: {
        error: string | null;
        retryCount: number;
        itemId: string;
        startedAt: Date;
        completedAt: Date;
        itemDatasetVersion: number | null;
        scores: {
            error: string | null;
            score: number | null;
            scorerId: string;
            scorerName: string;
            reason: string | null;
        }[];
        output?: unknown;
        input?: unknown;
        groundTruth?: unknown;
    }[];
    experimentId: string;
    totalItems: number;
    succeededCount: number;
    failedCount: number;
    startedAt: Date;
    completedAt: Date | null;
}>;
export declare const listDatasetsResponseSchema: z.ZodObject<{
    datasets: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        name: z.ZodString;
        description: z.ZodNullable<z.ZodOptional<z.ZodString>>;
        metadata: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
        inputSchema: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
        groundTruthSchema: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
        version: z.ZodNumber;
        createdAt: z.ZodDate;
        updatedAt: z.ZodDate;
    }, "strip", z.ZodTypeAny, {
        name: string;
        id: string;
        createdAt: Date;
        updatedAt: Date;
        version: number;
        metadata?: Record<string, unknown> | null | undefined;
        description?: string | null | undefined;
        inputSchema?: Record<string, unknown> | null | undefined;
        groundTruthSchema?: Record<string, unknown> | null | undefined;
    }, {
        name: string;
        id: string;
        createdAt: Date;
        updatedAt: Date;
        version: number;
        metadata?: Record<string, unknown> | null | undefined;
        description?: string | null | undefined;
        inputSchema?: Record<string, unknown> | null | undefined;
        groundTruthSchema?: Record<string, unknown> | null | undefined;
    }>, "many">;
    pagination: z.ZodObject<{
        total: z.ZodNumber;
        page: z.ZodNumber;
        perPage: z.ZodUnion<[z.ZodNumber, z.ZodLiteral<false>]>;
        hasMore: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        total: number;
        page: number;
        perPage: number | false;
        hasMore: boolean;
    }, {
        total: number;
        page: number;
        perPage: number | false;
        hasMore: boolean;
    }>;
}, "strip", z.ZodTypeAny, {
    datasets: {
        name: string;
        id: string;
        createdAt: Date;
        updatedAt: Date;
        version: number;
        metadata?: Record<string, unknown> | null | undefined;
        description?: string | null | undefined;
        inputSchema?: Record<string, unknown> | null | undefined;
        groundTruthSchema?: Record<string, unknown> | null | undefined;
    }[];
    pagination: {
        total: number;
        page: number;
        perPage: number | false;
        hasMore: boolean;
    };
}, {
    datasets: {
        name: string;
        id: string;
        createdAt: Date;
        updatedAt: Date;
        version: number;
        metadata?: Record<string, unknown> | null | undefined;
        description?: string | null | undefined;
        inputSchema?: Record<string, unknown> | null | undefined;
        groundTruthSchema?: Record<string, unknown> | null | undefined;
    }[];
    pagination: {
        total: number;
        page: number;
        perPage: number | false;
        hasMore: boolean;
    };
}>;
export declare const listItemsResponseSchema: z.ZodObject<{
    items: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        datasetId: z.ZodString;
        datasetVersion: z.ZodNumber;
        input: z.ZodUnknown;
        groundTruth: z.ZodOptional<z.ZodUnknown>;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        createdAt: z.ZodDate;
        updatedAt: z.ZodDate;
    }, "strip", z.ZodTypeAny, {
        id: string;
        createdAt: Date;
        updatedAt: Date;
        datasetId: string;
        datasetVersion: number;
        metadata?: Record<string, unknown> | undefined;
        input?: unknown;
        groundTruth?: unknown;
    }, {
        id: string;
        createdAt: Date;
        updatedAt: Date;
        datasetId: string;
        datasetVersion: number;
        metadata?: Record<string, unknown> | undefined;
        input?: unknown;
        groundTruth?: unknown;
    }>, "many">;
    pagination: z.ZodObject<{
        total: z.ZodNumber;
        page: z.ZodNumber;
        perPage: z.ZodUnion<[z.ZodNumber, z.ZodLiteral<false>]>;
        hasMore: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        total: number;
        page: number;
        perPage: number | false;
        hasMore: boolean;
    }, {
        total: number;
        page: number;
        perPage: number | false;
        hasMore: boolean;
    }>;
}, "strip", z.ZodTypeAny, {
    items: {
        id: string;
        createdAt: Date;
        updatedAt: Date;
        datasetId: string;
        datasetVersion: number;
        metadata?: Record<string, unknown> | undefined;
        input?: unknown;
        groundTruth?: unknown;
    }[];
    pagination: {
        total: number;
        page: number;
        perPage: number | false;
        hasMore: boolean;
    };
}, {
    items: {
        id: string;
        createdAt: Date;
        updatedAt: Date;
        datasetId: string;
        datasetVersion: number;
        metadata?: Record<string, unknown> | undefined;
        input?: unknown;
        groundTruth?: unknown;
    }[];
    pagination: {
        total: number;
        page: number;
        perPage: number | false;
        hasMore: boolean;
    };
}>;
export declare const listExperimentsResponseSchema: z.ZodObject<{
    experiments: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        datasetId: z.ZodNullable<z.ZodString>;
        datasetVersion: z.ZodNullable<z.ZodNumber>;
        targetType: z.ZodEnum<["agent", "workflow", "scorer", "processor"]>;
        targetId: z.ZodString;
        name: z.ZodOptional<z.ZodString>;
        description: z.ZodOptional<z.ZodString>;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        status: z.ZodEnum<["pending", "running", "completed", "failed"]>;
        totalItems: z.ZodNumber;
        succeededCount: z.ZodNumber;
        failedCount: z.ZodNumber;
        skippedCount: z.ZodNumber;
        startedAt: z.ZodNullable<z.ZodDate>;
        completedAt: z.ZodNullable<z.ZodDate>;
        createdAt: z.ZodDate;
        updatedAt: z.ZodDate;
    }, "strip", z.ZodTypeAny, {
        status: "running" | "failed" | "pending" | "completed";
        id: string;
        createdAt: Date;
        updatedAt: Date;
        datasetId: string | null;
        targetType: "scorer" | "agent" | "processor" | "workflow";
        targetId: string;
        datasetVersion: number | null;
        totalItems: number;
        succeededCount: number;
        failedCount: number;
        skippedCount: number;
        startedAt: Date | null;
        completedAt: Date | null;
        metadata?: Record<string, unknown> | undefined;
        name?: string | undefined;
        description?: string | undefined;
    }, {
        status: "running" | "failed" | "pending" | "completed";
        id: string;
        createdAt: Date;
        updatedAt: Date;
        datasetId: string | null;
        targetType: "scorer" | "agent" | "processor" | "workflow";
        targetId: string;
        datasetVersion: number | null;
        totalItems: number;
        succeededCount: number;
        failedCount: number;
        skippedCount: number;
        startedAt: Date | null;
        completedAt: Date | null;
        metadata?: Record<string, unknown> | undefined;
        name?: string | undefined;
        description?: string | undefined;
    }>, "many">;
    pagination: z.ZodObject<{
        total: z.ZodNumber;
        page: z.ZodNumber;
        perPage: z.ZodUnion<[z.ZodNumber, z.ZodLiteral<false>]>;
        hasMore: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        total: number;
        page: number;
        perPage: number | false;
        hasMore: boolean;
    }, {
        total: number;
        page: number;
        perPage: number | false;
        hasMore: boolean;
    }>;
}, "strip", z.ZodTypeAny, {
    pagination: {
        total: number;
        page: number;
        perPage: number | false;
        hasMore: boolean;
    };
    experiments: {
        status: "running" | "failed" | "pending" | "completed";
        id: string;
        createdAt: Date;
        updatedAt: Date;
        datasetId: string | null;
        targetType: "scorer" | "agent" | "processor" | "workflow";
        targetId: string;
        datasetVersion: number | null;
        totalItems: number;
        succeededCount: number;
        failedCount: number;
        skippedCount: number;
        startedAt: Date | null;
        completedAt: Date | null;
        metadata?: Record<string, unknown> | undefined;
        name?: string | undefined;
        description?: string | undefined;
    }[];
}, {
    pagination: {
        total: number;
        page: number;
        perPage: number | false;
        hasMore: boolean;
    };
    experiments: {
        status: "running" | "failed" | "pending" | "completed";
        id: string;
        createdAt: Date;
        updatedAt: Date;
        datasetId: string | null;
        targetType: "scorer" | "agent" | "processor" | "workflow";
        targetId: string;
        datasetVersion: number | null;
        totalItems: number;
        succeededCount: number;
        failedCount: number;
        skippedCount: number;
        startedAt: Date | null;
        completedAt: Date | null;
        metadata?: Record<string, unknown> | undefined;
        name?: string | undefined;
        description?: string | undefined;
    }[];
}>;
export declare const listExperimentResultsResponseSchema: z.ZodObject<{
    results: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        experimentId: z.ZodString;
        itemId: z.ZodString;
        itemDatasetVersion: z.ZodNullable<z.ZodNumber>;
        input: z.ZodUnknown;
        output: z.ZodNullable<z.ZodUnknown>;
        groundTruth: z.ZodNullable<z.ZodUnknown>;
        error: z.ZodNullable<z.ZodObject<{
            message: z.ZodString;
            stack: z.ZodOptional<z.ZodString>;
            code: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            message: string;
            code?: string | undefined;
            stack?: string | undefined;
        }, {
            message: string;
            code?: string | undefined;
            stack?: string | undefined;
        }>>;
        startedAt: z.ZodDate;
        completedAt: z.ZodDate;
        retryCount: z.ZodNumber;
        traceId: z.ZodNullable<z.ZodString>;
        createdAt: z.ZodDate;
    }, "strip", z.ZodTypeAny, {
        traceId: string | null;
        error: {
            message: string;
            code?: string | undefined;
            stack?: string | undefined;
        } | null;
        id: string;
        createdAt: Date;
        retryCount: number;
        experimentId: string;
        itemId: string;
        startedAt: Date;
        completedAt: Date;
        itemDatasetVersion: number | null;
        output?: unknown;
        input?: unknown;
        groundTruth?: unknown;
    }, {
        traceId: string | null;
        error: {
            message: string;
            code?: string | undefined;
            stack?: string | undefined;
        } | null;
        id: string;
        createdAt: Date;
        retryCount: number;
        experimentId: string;
        itemId: string;
        startedAt: Date;
        completedAt: Date;
        itemDatasetVersion: number | null;
        output?: unknown;
        input?: unknown;
        groundTruth?: unknown;
    }>, "many">;
    pagination: z.ZodObject<{
        total: z.ZodNumber;
        page: z.ZodNumber;
        perPage: z.ZodUnion<[z.ZodNumber, z.ZodLiteral<false>]>;
        hasMore: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        total: number;
        page: number;
        perPage: number | false;
        hasMore: boolean;
    }, {
        total: number;
        page: number;
        perPage: number | false;
        hasMore: boolean;
    }>;
}, "strip", z.ZodTypeAny, {
    results: {
        traceId: string | null;
        error: {
            message: string;
            code?: string | undefined;
            stack?: string | undefined;
        } | null;
        id: string;
        createdAt: Date;
        retryCount: number;
        experimentId: string;
        itemId: string;
        startedAt: Date;
        completedAt: Date;
        itemDatasetVersion: number | null;
        output?: unknown;
        input?: unknown;
        groundTruth?: unknown;
    }[];
    pagination: {
        total: number;
        page: number;
        perPage: number | false;
        hasMore: boolean;
    };
}, {
    results: {
        traceId: string | null;
        error: {
            message: string;
            code?: string | undefined;
            stack?: string | undefined;
        } | null;
        id: string;
        createdAt: Date;
        retryCount: number;
        experimentId: string;
        itemId: string;
        startedAt: Date;
        completedAt: Date;
        itemDatasetVersion: number | null;
        output?: unknown;
        input?: unknown;
        groundTruth?: unknown;
    }[];
    pagination: {
        total: number;
        page: number;
        perPage: number | false;
        hasMore: boolean;
    };
}>;
export declare const datasetItemVersionPathParams: z.ZodObject<{
    datasetId: z.ZodString;
    itemId: z.ZodString;
    datasetVersion: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    datasetId: string;
    itemId: string;
    datasetVersion: number;
}, {
    datasetId: string;
    itemId: string;
    datasetVersion: number;
}>;
export declare const itemVersionResponseSchema: z.ZodObject<{
    id: z.ZodString;
    datasetId: z.ZodString;
    datasetVersion: z.ZodNumber;
    input: z.ZodUnknown;
    groundTruth: z.ZodOptional<z.ZodUnknown>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    validTo: z.ZodNullable<z.ZodNumber>;
    isDeleted: z.ZodBoolean;
    createdAt: z.ZodDate;
    updatedAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    id: string;
    createdAt: Date;
    updatedAt: Date;
    datasetId: string;
    datasetVersion: number;
    validTo: number | null;
    isDeleted: boolean;
    metadata?: Record<string, unknown> | undefined;
    input?: unknown;
    groundTruth?: unknown;
}, {
    id: string;
    createdAt: Date;
    updatedAt: Date;
    datasetId: string;
    datasetVersion: number;
    validTo: number | null;
    isDeleted: boolean;
    metadata?: Record<string, unknown> | undefined;
    input?: unknown;
    groundTruth?: unknown;
}>;
export declare const listItemVersionsResponseSchema: z.ZodObject<{
    history: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        datasetId: z.ZodString;
        datasetVersion: z.ZodNumber;
        input: z.ZodUnknown;
        groundTruth: z.ZodOptional<z.ZodUnknown>;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        validTo: z.ZodNullable<z.ZodNumber>;
        isDeleted: z.ZodBoolean;
        createdAt: z.ZodDate;
        updatedAt: z.ZodDate;
    }, "strip", z.ZodTypeAny, {
        id: string;
        createdAt: Date;
        updatedAt: Date;
        datasetId: string;
        datasetVersion: number;
        validTo: number | null;
        isDeleted: boolean;
        metadata?: Record<string, unknown> | undefined;
        input?: unknown;
        groundTruth?: unknown;
    }, {
        id: string;
        createdAt: Date;
        updatedAt: Date;
        datasetId: string;
        datasetVersion: number;
        validTo: number | null;
        isDeleted: boolean;
        metadata?: Record<string, unknown> | undefined;
        input?: unknown;
        groundTruth?: unknown;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    history: {
        id: string;
        createdAt: Date;
        updatedAt: Date;
        datasetId: string;
        datasetVersion: number;
        validTo: number | null;
        isDeleted: boolean;
        metadata?: Record<string, unknown> | undefined;
        input?: unknown;
        groundTruth?: unknown;
    }[];
}, {
    history: {
        id: string;
        createdAt: Date;
        updatedAt: Date;
        datasetId: string;
        datasetVersion: number;
        validTo: number | null;
        isDeleted: boolean;
        metadata?: Record<string, unknown> | undefined;
        input?: unknown;
        groundTruth?: unknown;
    }[];
}>;
export declare const datasetVersionResponseSchema: z.ZodObject<{
    id: z.ZodString;
    datasetId: z.ZodString;
    version: z.ZodNumber;
    createdAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    id: string;
    createdAt: Date;
    version: number;
    datasetId: string;
}, {
    id: string;
    createdAt: Date;
    version: number;
    datasetId: string;
}>;
export declare const listDatasetVersionsResponseSchema: z.ZodObject<{
    versions: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        datasetId: z.ZodString;
        version: z.ZodNumber;
        createdAt: z.ZodDate;
    }, "strip", z.ZodTypeAny, {
        id: string;
        createdAt: Date;
        version: number;
        datasetId: string;
    }, {
        id: string;
        createdAt: Date;
        version: number;
        datasetId: string;
    }>, "many">;
    pagination: z.ZodObject<{
        total: z.ZodNumber;
        page: z.ZodNumber;
        perPage: z.ZodUnion<[z.ZodNumber, z.ZodLiteral<false>]>;
        hasMore: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        total: number;
        page: number;
        perPage: number | false;
        hasMore: boolean;
    }, {
        total: number;
        page: number;
        perPage: number | false;
        hasMore: boolean;
    }>;
}, "strip", z.ZodTypeAny, {
    pagination: {
        total: number;
        page: number;
        perPage: number | false;
        hasMore: boolean;
    };
    versions: {
        id: string;
        createdAt: Date;
        version: number;
        datasetId: string;
    }[];
}, {
    pagination: {
        total: number;
        page: number;
        perPage: number | false;
        hasMore: boolean;
    };
    versions: {
        id: string;
        createdAt: Date;
        version: number;
        datasetId: string;
    }[];
}>;
export declare const batchInsertItemsBodySchema: z.ZodObject<{
    items: z.ZodArray<z.ZodObject<{
        input: z.ZodUnknown;
        groundTruth: z.ZodOptional<z.ZodUnknown>;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, "strip", z.ZodTypeAny, {
        metadata?: Record<string, unknown> | undefined;
        input?: unknown;
        groundTruth?: unknown;
    }, {
        metadata?: Record<string, unknown> | undefined;
        input?: unknown;
        groundTruth?: unknown;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    items: {
        metadata?: Record<string, unknown> | undefined;
        input?: unknown;
        groundTruth?: unknown;
    }[];
}, {
    items: {
        metadata?: Record<string, unknown> | undefined;
        input?: unknown;
        groundTruth?: unknown;
    }[];
}>;
export declare const batchInsertItemsResponseSchema: z.ZodObject<{
    items: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        datasetId: z.ZodString;
        datasetVersion: z.ZodNumber;
        input: z.ZodUnknown;
        groundTruth: z.ZodOptional<z.ZodUnknown>;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        createdAt: z.ZodDate;
        updatedAt: z.ZodDate;
    }, "strip", z.ZodTypeAny, {
        id: string;
        createdAt: Date;
        updatedAt: Date;
        datasetId: string;
        datasetVersion: number;
        metadata?: Record<string, unknown> | undefined;
        input?: unknown;
        groundTruth?: unknown;
    }, {
        id: string;
        createdAt: Date;
        updatedAt: Date;
        datasetId: string;
        datasetVersion: number;
        metadata?: Record<string, unknown> | undefined;
        input?: unknown;
        groundTruth?: unknown;
    }>, "many">;
    count: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    count: number;
    items: {
        id: string;
        createdAt: Date;
        updatedAt: Date;
        datasetId: string;
        datasetVersion: number;
        metadata?: Record<string, unknown> | undefined;
        input?: unknown;
        groundTruth?: unknown;
    }[];
}, {
    count: number;
    items: {
        id: string;
        createdAt: Date;
        updatedAt: Date;
        datasetId: string;
        datasetVersion: number;
        metadata?: Record<string, unknown> | undefined;
        input?: unknown;
        groundTruth?: unknown;
    }[];
}>;
export declare const batchDeleteItemsBodySchema: z.ZodObject<{
    itemIds: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    itemIds: string[];
}, {
    itemIds: string[];
}>;
export declare const batchDeleteItemsResponseSchema: z.ZodObject<{
    success: z.ZodBoolean;
    deletedCount: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    success: boolean;
    deletedCount: number;
}, {
    success: boolean;
    deletedCount: number;
}>;
//# sourceMappingURL=datasets.d.ts.map