@proofhound/shared 0.1.6

package/dist/dto/optimization.dto.d.ts

@@ -0,0 +1,2086 @@
+import { z } from 'zod';
+export declare const optimizationIdParamSchema: z.ZodString;
+export type OptimizationIdParamDto = z.infer<typeof optimizationIdParamSchema>;
+export declare const optimizationStatusSchema: z.ZodEnum<{
+    success: "success";
+    failed: "failed";
+    running: "running";
+    stopped: "stopped";
+    cancelled: "cancelled";
+}>;
+export type OptimizationStatusDto = z.infer<typeof optimizationStatusSchema>;
+export declare const optimizationControlActionSchema: z.ZodEnum<{
+    stop: "stop";
+    resume: "resume";
+    cancel: "cancel";
+}>;
+export type OptimizationControlActionDto = z.infer<typeof optimizationControlActionSchema>;
+export declare const optimizationStartingModeSchema: z.ZodEnum<{
+    from_experiment: "from_experiment";
+    from_prompt_version: "from_prompt_version";
+    from_dataset_only: "from_dataset_only";
+}>;
+export type OptimizationStartingModeDto = z.infer<typeof optimizationStartingModeSchema>;
+export declare const optimizationStrategySchema: z.ZodString;
+export type OptimizationStrategyDto = z.infer<typeof optimizationStrategySchema>;
+export declare const optimizationHintSchema: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+export type OptimizationHintDto = z.infer<typeof optimizationHintSchema>;
+export declare const optimizationGoalMetricSchema: z.ZodEnum<{
+    accuracy: "accuracy";
+    precision: "precision";
+    recall: "recall";
+    f1: "f1";
+    fpr: "fpr";
+}>;
+export type OptimizationGoalMetricDto = z.infer<typeof optimizationGoalMetricSchema>;
+export declare const createOptimizationGoalMetricSchema: z.ZodEnum<{
+    accuracy: "accuracy";
+    precision: "precision";
+    recall: "recall";
+}>;
+export type CreateOptimizationGoalMetricDto = z.infer<typeof createOptimizationGoalMetricSchema>;
+export declare const optimizationGoalComparatorSchema: z.ZodEnum<{
+    gte: "gte";
+    gt: "gt";
+    lte: "lte";
+}>;
+export type OptimizationGoalComparatorDto = z.infer<typeof optimizationGoalComparatorSchema>;
+export declare const optimizationGoalSchema: z.ZodObject<{
+    metric: z.ZodEnum<{
+        accuracy: "accuracy";
+        precision: "precision";
+        recall: "recall";
+        f1: "f1";
+        fpr: "fpr";
+    }>;
+    comparator: z.ZodEnum<{
+        gte: "gte";
+        gt: "gt";
+        lte: "lte";
+    }>;
+    target: z.ZodNumber;
+    scope: z.ZodString;
+}, z.core.$strip>;
+export type OptimizationGoalDto = z.infer<typeof optimizationGoalSchema>;
+export declare const createOptimizationGoalSchema: z.ZodObject<{
+    comparator: z.ZodEnum<{
+        gte: "gte";
+        gt: "gt";
+        lte: "lte";
+    }>;
+    target: z.ZodNumber;
+    scope: z.ZodString;
+    metric: z.ZodEnum<{
+        accuracy: "accuracy";
+        precision: "precision";
+        recall: "recall";
+    }>;
+}, z.core.$strip>;
+export type CreateOptimizationGoalDto = z.infer<typeof createOptimizationGoalSchema>;
+export declare const optimizationFieldWhitelistSchema: z.ZodObject<{
+    inputFields: z.ZodArray<z.ZodString>;
+    metaFields: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type OptimizationFieldWhitelistDto = z.infer<typeof optimizationFieldWhitelistSchema>;
+export declare const optimizationRunConfigSchema: z.ZodObject<{
+    temperature: z.ZodOptional<z.ZodNumber>;
+    concurrency: z.ZodOptional<z.ZodNumber>;
+    rpmLimit: z.ZodOptional<z.ZodNumber>;
+    tpmLimit: z.ZodOptional<z.ZodNumber>;
+    sampleTimeoutSeconds: z.ZodOptional<z.ZodNumber>;
+    retries: z.ZodOptional<z.ZodNumber>;
+    imageEncoding: z.ZodOptional<z.ZodEnum<{
+        url: "url";
+        base64: "base64";
+    }>>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export type OptimizationRunConfigDto = z.infer<typeof optimizationRunConfigSchema>;
+export declare const optimizationLoopLimitsSchema: z.ZodObject<{
+    maxRounds: z.ZodNumber;
+    stopAfterNoImprovementRounds: z.ZodNumber;
+}, z.core.$strip>;
+export type OptimizationLoopLimitsDto = z.infer<typeof optimizationLoopLimitsSchema>;
+export declare const optimizationBestMetricsSchema: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+export type OptimizationBestMetricsDto = z.infer<typeof optimizationBestMetricsSchema>;
+export declare const optimizationSummarySchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        success: "success";
+        failed: "failed";
+        running: "running";
+        stopped: "stopped";
+        cancelled: "cancelled";
+    }>;
+    reason: z.ZodString;
+    finalizedAt: z.ZodString;
+}, z.core.$strip>;
+export type OptimizationSummaryDto = z.infer<typeof optimizationSummarySchema>;
+export declare const optimizationListItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    projectId: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    strategy: z.ZodString;
+    startingMode: z.ZodEnum<{
+        from_experiment: "from_experiment";
+        from_prompt_version: "from_prompt_version";
+        from_dataset_only: "from_dataset_only";
+    }>;
+    status: z.ZodEnum<{
+        success: "success";
+        failed: "failed";
+        running: "running";
+        stopped: "stopped";
+        cancelled: "cancelled";
+    }>;
+    controlState: z.ZodNullable<z.ZodEnum<{
+        stop: "stop";
+        resume: "resume";
+        cancel: "cancel";
+    }>>;
+    sourceExperimentId: z.ZodNullable<z.ZodString>;
+    sourceExperimentName: z.ZodNullable<z.ZodString>;
+    promptId: z.ZodNullable<z.ZodString>;
+    promptName: z.ZodNullable<z.ZodString>;
+    baseVersionId: z.ZodNullable<z.ZodString>;
+    baseVersionNumber: z.ZodNullable<z.ZodNumber>;
+    datasetId: z.ZodString;
+    datasetName: z.ZodString;
+    datasetSamples: z.ZodNumber;
+    experimentModelId: z.ZodString;
+    experimentModelName: z.ZodString;
+    analysisModelId: z.ZodString;
+    analysisModelName: z.ZodString;
+    promptLanguage: z.ZodEnum<{
+        "zh-CN": "zh-CN";
+        "en-US": "en-US";
+    }>;
+    goals: z.ZodArray<z.ZodObject<{
+        metric: z.ZodEnum<{
+            accuracy: "accuracy";
+            precision: "precision";
+            recall: "recall";
+            f1: "f1";
+            fpr: "fpr";
+        }>;
+        comparator: z.ZodEnum<{
+            gte: "gte";
+            gt: "gt";
+            lte: "lte";
+        }>;
+        target: z.ZodNumber;
+        scope: z.ZodString;
+    }, z.core.$strip>>;
+    fieldWhitelist: z.ZodNullable<z.ZodObject<{
+        inputFields: z.ZodArray<z.ZodString>;
+        metaFields: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    runConfig: z.ZodObject<{
+        temperature: z.ZodOptional<z.ZodNumber>;
+        concurrency: z.ZodOptional<z.ZodNumber>;
+        rpmLimit: z.ZodOptional<z.ZodNumber>;
+        tpmLimit: z.ZodOptional<z.ZodNumber>;
+        sampleTimeoutSeconds: z.ZodOptional<z.ZodNumber>;
+        retries: z.ZodOptional<z.ZodNumber>;
+        imageEncoding: z.ZodOptional<z.ZodEnum<{
+            url: "url";
+            base64: "base64";
+        }>>;
+    }, z.core.$catchall<z.ZodUnknown>>;
+    maxRounds: z.ZodNumber;
+    currentRound: z.ZodNumber;
+    bestVersionId: z.ZodNullable<z.ZodString>;
+    bestVersionNumber: z.ZodNullable<z.ZodNumber>;
+    bestMetrics: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    trend: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber>>>;
+    trendHasBaseline: z.ZodOptional<z.ZodBoolean>;
+    summary: z.ZodNullable<z.ZodObject<{
+        kind: z.ZodEnum<{
+            success: "success";
+            failed: "failed";
+            running: "running";
+            stopped: "stopped";
+            cancelled: "cancelled";
+        }>;
+        reason: z.ZodString;
+        finalizedAt: z.ZodString;
+    }, z.core.$strip>>;
+    analysisFailureReason: z.ZodNullable<z.ZodString>;
+    dbosWorkflowId: z.ZodNullable<z.ZodString>;
+    createdBy: z.ZodString;
+    createdByDisplayName: z.ZodNullable<z.ZodString>;
+    createdByUsername: z.ZodNullable<z.ZodString>;
+    startedAt: z.ZodNullable<z.ZodString>;
+    finishedAt: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    deletedAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type OptimizationListItemDto = z.infer<typeof optimizationListItemSchema>;
+export declare const optimizationListResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        projectId: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        strategy: z.ZodString;
+        startingMode: z.ZodEnum<{
+            from_experiment: "from_experiment";
+            from_prompt_version: "from_prompt_version";
+            from_dataset_only: "from_dataset_only";
+        }>;
+        status: z.ZodEnum<{
+            success: "success";
+            failed: "failed";
+            running: "running";
+            stopped: "stopped";
+            cancelled: "cancelled";
+        }>;
+        controlState: z.ZodNullable<z.ZodEnum<{
+            stop: "stop";
+            resume: "resume";
+            cancel: "cancel";
+        }>>;
+        sourceExperimentId: z.ZodNullable<z.ZodString>;
+        sourceExperimentName: z.ZodNullable<z.ZodString>;
+        promptId: z.ZodNullable<z.ZodString>;
+        promptName: z.ZodNullable<z.ZodString>;
+        baseVersionId: z.ZodNullable<z.ZodString>;
+        baseVersionNumber: z.ZodNullable<z.ZodNumber>;
+        datasetId: z.ZodString;
+        datasetName: z.ZodString;
+        datasetSamples: z.ZodNumber;
+        experimentModelId: z.ZodString;
+        experimentModelName: z.ZodString;
+        analysisModelId: z.ZodString;
+        analysisModelName: z.ZodString;
+        promptLanguage: z.ZodEnum<{
+            "zh-CN": "zh-CN";
+            "en-US": "en-US";
+        }>;
+        goals: z.ZodArray<z.ZodObject<{
+            metric: z.ZodEnum<{
+                accuracy: "accuracy";
+                precision: "precision";
+                recall: "recall";
+                f1: "f1";
+                fpr: "fpr";
+            }>;
+            comparator: z.ZodEnum<{
+                gte: "gte";
+                gt: "gt";
+                lte: "lte";
+            }>;
+            target: z.ZodNumber;
+            scope: z.ZodString;
+        }, z.core.$strip>>;
+        fieldWhitelist: z.ZodNullable<z.ZodObject<{
+            inputFields: z.ZodArray<z.ZodString>;
+            metaFields: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        runConfig: z.ZodObject<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            concurrency: z.ZodOptional<z.ZodNumber>;
+            rpmLimit: z.ZodOptional<z.ZodNumber>;
+            tpmLimit: z.ZodOptional<z.ZodNumber>;
+            sampleTimeoutSeconds: z.ZodOptional<z.ZodNumber>;
+            retries: z.ZodOptional<z.ZodNumber>;
+            imageEncoding: z.ZodOptional<z.ZodEnum<{
+                url: "url";
+                base64: "base64";
+            }>>;
+        }, z.core.$catchall<z.ZodUnknown>>;
+        maxRounds: z.ZodNumber;
+        currentRound: z.ZodNumber;
+        bestVersionId: z.ZodNullable<z.ZodString>;
+        bestVersionNumber: z.ZodNullable<z.ZodNumber>;
+        bestMetrics: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        trend: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber>>>;
+        trendHasBaseline: z.ZodOptional<z.ZodBoolean>;
+        summary: z.ZodNullable<z.ZodObject<{
+            kind: z.ZodEnum<{
+                success: "success";
+                failed: "failed";
+                running: "running";
+                stopped: "stopped";
+                cancelled: "cancelled";
+            }>;
+            reason: z.ZodString;
+            finalizedAt: z.ZodString;
+        }, z.core.$strip>>;
+        analysisFailureReason: z.ZodNullable<z.ZodString>;
+        dbosWorkflowId: z.ZodNullable<z.ZodString>;
+        createdBy: z.ZodString;
+        createdByDisplayName: z.ZodNullable<z.ZodString>;
+        createdByUsername: z.ZodNullable<z.ZodString>;
+        startedAt: z.ZodNullable<z.ZodString>;
+        finishedAt: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        deletedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+}, z.core.$strip>;
+export type OptimizationListResponseDto = z.infer<typeof optimizationListResponseSchema>;
+export declare const optimizationSortSchema: z.ZodEnum<{
+    updated: "updated";
+    bestMetric: "bestMetric";
+    round: "round";
+}>;
+export type OptimizationSortDto = z.infer<typeof optimizationSortSchema>;
+export declare const optimizationListQuerySchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodEnum<{
+        success: "success";
+        failed: "failed";
+        running: "running";
+        stopped: "stopped";
+        cancelled: "cancelled";
+    }>>;
+    search: z.ZodOptional<z.ZodString>;
+    sort: z.ZodOptional<z.ZodEnum<{
+        updated: "updated";
+        bestMetric: "bestMetric";
+        round: "round";
+    }>>;
+}, z.core.$strip>;
+export type OptimizationListQueryDto = z.infer<typeof optimizationListQuerySchema>;
+export declare const createOptimizationSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    optimizationHint: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    strategy: z.ZodDefault<z.ZodString>;
+    strategyConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    startingMode: z.ZodEnum<{
+        from_experiment: "from_experiment";
+        from_prompt_version: "from_prompt_version";
+        from_dataset_only: "from_dataset_only";
+    }>;
+    sourceExperimentId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    promptId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    baseVersionId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    datasetId: z.ZodString;
+    experimentModelId: z.ZodString;
+    analysisModelId: z.ZodString;
+    promptLanguage: z.ZodOptional<z.ZodEnum<{
+        "zh-CN": "zh-CN";
+        "en-US": "en-US";
+    }>>;
+    goals: z.ZodArray<z.ZodObject<{
+        comparator: z.ZodEnum<{
+            gte: "gte";
+            gt: "gt";
+            lte: "lte";
+        }>;
+        target: z.ZodNumber;
+        scope: z.ZodString;
+        metric: z.ZodEnum<{
+            accuracy: "accuracy";
+            precision: "precision";
+            recall: "recall";
+        }>;
+    }, z.core.$strip>>;
+    fieldWhitelist: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        inputFields: z.ZodArray<z.ZodString>;
+        metaFields: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>>;
+    runConfig: z.ZodOptional<z.ZodObject<{
+        temperature: z.ZodOptional<z.ZodNumber>;
+        concurrency: z.ZodOptional<z.ZodNumber>;
+        rpmLimit: z.ZodOptional<z.ZodNumber>;
+        tpmLimit: z.ZodOptional<z.ZodNumber>;
+        sampleTimeoutSeconds: z.ZodOptional<z.ZodNumber>;
+        retries: z.ZodOptional<z.ZodNumber>;
+        imageEncoding: z.ZodOptional<z.ZodEnum<{
+            url: "url";
+            base64: "base64";
+        }>>;
+    }, z.core.$catchall<z.ZodUnknown>>>;
+    loopLimits: z.ZodObject<{
+        maxRounds: z.ZodNumber;
+        stopAfterNoImprovementRounds: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type CreateOptimizationDto = z.infer<typeof createOptimizationSchema>;
+export declare const optimizationGoalScopeKindSchema: z.ZodEnum<{
+    overall: "overall";
+    class: "class";
+}>;
+export type OptimizationGoalScopeKindDto = z.infer<typeof optimizationGoalScopeKindSchema>;
+export declare const optimizationDetailGoalScopeSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        overall: "overall";
+        class: "class";
+    }>;
+    classes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type OptimizationDetailGoalScopeDto = z.infer<typeof optimizationDetailGoalScopeSchema>;
+export declare const optimizationDetailGoalsLineSchema: z.ZodObject<{
+    label: z.ZodString;
+    targetText: z.ZodString;
+    tone: z.ZodEnum<{
+        overall: "overall";
+        class: "class";
+    }>;
+}, z.core.$strip>;
+export type OptimizationDetailGoalsLineDto = z.infer<typeof optimizationDetailGoalsLineSchema>;
+export declare const optimizationDetailExperimentConfigSchema: z.ZodObject<{
+    datasetName: z.ZodString;
+    promptName: z.ZodString;
+    promptVersion: z.ZodString;
+    modelName: z.ZodString;
+    baselineExperiment: z.ZodString;
+    temperature: z.ZodNumber;
+    concurrency: z.ZodNumber;
+    rpm: z.ZodNumber;
+    tpm: z.ZodNumber;
+}, z.core.$strip>;
+export type OptimizationDetailExperimentConfigDto = z.infer<typeof optimizationDetailExperimentConfigSchema>;
+export declare const optimizationDetailIterationConfigSchema: z.ZodObject<{
+    analysisModel: z.ZodString;
+    strategy: z.ZodString;
+    maxRounds: z.ZodNumber;
+    noImprovementStop: z.ZodNumber;
+    regressionThreshold: z.ZodNumber;
+}, z.core.$strip>;
+export type OptimizationDetailIterationConfigDto = z.infer<typeof optimizationDetailIterationConfigSchema>;
+export declare const optimizationDetailControlPhaseSchema: z.ZodEnum<{
+    experiment: "experiment";
+    analysis: "analysis";
+    paused: "paused";
+    finishing: "finishing";
+}>;
+export type OptimizationDetailControlPhaseDto = z.infer<typeof optimizationDetailControlPhaseSchema>;
+export declare const optimizationDetailControlStripSchema: z.ZodObject<{
+    currentRound: z.ZodNumber;
+    maxRounds: z.ZodNumber;
+    phase: z.ZodEnum<{
+        experiment: "experiment";
+        analysis: "analysis";
+        paused: "paused";
+        finishing: "finishing";
+    }>;
+    samplesDone: z.ZodNumber;
+    samplesTotal: z.ZodNumber;
+    roundRemaining: z.ZodString;
+    totalRemaining: z.ZodString;
+}, z.core.$strip>;
+export type OptimizationDetailControlStripDto = z.infer<typeof optimizationDetailControlStripSchema>;
+export declare const optimizationDetailMetricDeltaToneSchema: z.ZodEnum<{
+    ok: "ok";
+    bad: "bad";
+    neutral: "neutral";
+}>;
+export type OptimizationDetailMetricDeltaToneDto = z.infer<typeof optimizationDetailMetricDeltaToneSchema>;
+export declare const optimizationDetailRoundMetricCellSchema: z.ZodObject<{
+    label: z.ZodString;
+    value: z.ZodNumber;
+    partial: z.ZodOptional<z.ZodBoolean>;
+    delta: z.ZodOptional<z.ZodObject<{
+        value: z.ZodNumber;
+        vsLabel: z.ZodString;
+        tone: z.ZodEnum<{
+            ok: "ok";
+            bad: "bad";
+            neutral: "neutral";
+        }>;
+        betterIsLower: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type OptimizationDetailRoundMetricCellDto = z.infer<typeof optimizationDetailRoundMetricCellSchema>;
+export declare const optimizationDetailMetricComparisonSchema: z.ZodObject<{
+    value: z.ZodNumber;
+    vsLabel: z.ZodString;
+    tone: z.ZodEnum<{
+        ok: "ok";
+        bad: "bad";
+        neutral: "neutral";
+    }>;
+    betterIsLower: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type OptimizationDetailMetricComparisonDto = z.infer<typeof optimizationDetailMetricComparisonSchema>;
+export declare const optimizationDetailRoundMetricComparisonsSchema: z.ZodOptional<z.ZodObject<{
+    accuracy: z.ZodOptional<z.ZodObject<{
+        value: z.ZodNumber;
+        vsLabel: z.ZodString;
+        tone: z.ZodEnum<{
+            ok: "ok";
+            bad: "bad";
+            neutral: "neutral";
+        }>;
+        betterIsLower: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    precision: z.ZodOptional<z.ZodObject<{
+        value: z.ZodNumber;
+        vsLabel: z.ZodString;
+        tone: z.ZodEnum<{
+            ok: "ok";
+            bad: "bad";
+            neutral: "neutral";
+        }>;
+        betterIsLower: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    recall: z.ZodOptional<z.ZodObject<{
+        value: z.ZodNumber;
+        vsLabel: z.ZodString;
+        tone: z.ZodEnum<{
+            ok: "ok";
+            bad: "bad";
+            neutral: "neutral";
+        }>;
+        betterIsLower: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>>;
+export type OptimizationDetailRoundMetricComparisonsDto = z.infer<typeof optimizationDetailRoundMetricComparisonsSchema>;
+export declare const optimizationDetailRoundClassRowSchema: z.ZodObject<{
+    label: z.ZodString;
+    accuracy: z.ZodOptional<z.ZodNumber>;
+    precision: z.ZodNumber;
+    recall: z.ZodNumber;
+    f1: z.ZodOptional<z.ZodNumber>;
+    fpr: z.ZodOptional<z.ZodNumber>;
+    vsLabel: z.ZodString;
+    vsDelta: z.ZodNullable<z.ZodNumber>;
+    vsTone: z.ZodEnum<{
+        ok: "ok";
+        bad: "bad";
+        neutral: "neutral";
+    }>;
+    deltas: z.ZodOptional<z.ZodObject<{
+        accuracy: z.ZodOptional<z.ZodObject<{
+            value: z.ZodNumber;
+            vsLabel: z.ZodString;
+            tone: z.ZodEnum<{
+                ok: "ok";
+                bad: "bad";
+                neutral: "neutral";
+            }>;
+            betterIsLower: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        precision: z.ZodOptional<z.ZodObject<{
+            value: z.ZodNumber;
+            vsLabel: z.ZodString;
+            tone: z.ZodEnum<{
+                ok: "ok";
+                bad: "bad";
+                neutral: "neutral";
+            }>;
+            betterIsLower: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        recall: z.ZodOptional<z.ZodObject<{
+            value: z.ZodNumber;
+            vsLabel: z.ZodString;
+            tone: z.ZodEnum<{
+                ok: "ok";
+                bad: "bad";
+                neutral: "neutral";
+            }>;
+            betterIsLower: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type OptimizationDetailRoundClassRowDto = z.infer<typeof optimizationDetailRoundClassRowSchema>;
+export declare const optimizationDetailRoundOverallRowSchema: z.ZodObject<{
+    accuracy: z.ZodNumber;
+    precision: z.ZodNumber;
+    recall: z.ZodNumber;
+    vsLabel: z.ZodString;
+    vsDelta: z.ZodNullable<z.ZodNumber>;
+    vsTone: z.ZodEnum<{
+        ok: "ok";
+        bad: "bad";
+        neutral: "neutral";
+    }>;
+    deltas: z.ZodOptional<z.ZodObject<{
+        accuracy: z.ZodOptional<z.ZodObject<{
+            value: z.ZodNumber;
+            vsLabel: z.ZodString;
+            tone: z.ZodEnum<{
+                ok: "ok";
+                bad: "bad";
+                neutral: "neutral";
+            }>;
+            betterIsLower: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        precision: z.ZodOptional<z.ZodObject<{
+            value: z.ZodNumber;
+            vsLabel: z.ZodString;
+            tone: z.ZodEnum<{
+                ok: "ok";
+                bad: "bad";
+                neutral: "neutral";
+            }>;
+            betterIsLower: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        recall: z.ZodOptional<z.ZodObject<{
+            value: z.ZodNumber;
+            vsLabel: z.ZodString;
+            tone: z.ZodEnum<{
+                ok: "ok";
+                bad: "bad";
+                neutral: "neutral";
+            }>;
+            betterIsLower: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type OptimizationDetailRoundOverallRowDto = z.infer<typeof optimizationDetailRoundOverallRowSchema>;
+export declare const optimizationDetailRoundGoalChipAchievedSchema: z.ZodEnum<{
+    hit: "hit";
+    miss: "miss";
+}>;
+export type OptimizationDetailRoundGoalChipAchievedDto = z.infer<typeof optimizationDetailRoundGoalChipAchievedSchema>;
+export declare const optimizationDetailRoundGoalChipSchema: z.ZodObject<{
+    label: z.ZodString;
+    targetText: z.ZodString;
+    currentText: z.ZodString;
+    achieved: z.ZodEnum<{
+        hit: "hit";
+        miss: "miss";
+    }>;
+}, z.core.$strip>;
+export type OptimizationDetailRoundGoalChipDto = z.infer<typeof optimizationDetailRoundGoalChipSchema>;
+export declare const optimizationDetailRoundErrorPatternSchema: z.ZodObject<{
+    percent: z.ZodNumber;
+    title: z.ZodString;
+    detail: z.ZodString;
+    count: z.ZodObject<{
+        hit: z.ZodNumber;
+        total: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type OptimizationDetailRoundErrorPatternDto = z.infer<typeof optimizationDetailRoundErrorPatternSchema>;
+export declare const optimizationDetailRoundImprovementPrioritySchema: z.ZodEnum<{
+    high: "high";
+    medium: "medium";
+    low: "low";
+}>;
+export type OptimizationDetailRoundImprovementPriorityDto = z.infer<typeof optimizationDetailRoundImprovementPrioritySchema>;
+export declare const optimizationDetailRoundImprovementSuggestionSchema: z.ZodObject<{
+    section: z.ZodString;
+    title: z.ZodString;
+    detail: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodEnum<{
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>>;
+}, z.core.$strip>;
+export type OptimizationDetailRoundImprovementSuggestionDto = z.infer<typeof optimizationDetailRoundImprovementSuggestionSchema>;
+export declare const optimizationDetailRoundExperimentResultSchema: z.ZodObject<{
+    experimentRef: z.ZodString;
+    experimentStatus: z.ZodEnum<{
+        success: "success";
+        failed: "failed";
+        running: "running";
+    }>;
+    samplesDone: z.ZodNumber;
+    samplesTotal: z.ZodNumber;
+    correct: z.ZodNumber;
+    wrong: z.ZodNumber;
+    elapsed: z.ZodString;
+    tokenSummary: z.ZodString;
+    costLabel: z.ZodString;
+    overallRow: z.ZodNullable<z.ZodObject<{
+        accuracy: z.ZodNumber;
+        precision: z.ZodNumber;
+        recall: z.ZodNumber;
+        vsLabel: z.ZodString;
+        vsDelta: z.ZodNullable<z.ZodNumber>;
+        vsTone: z.ZodEnum<{
+            ok: "ok";
+            bad: "bad";
+            neutral: "neutral";
+        }>;
+        deltas: z.ZodOptional<z.ZodObject<{
+            accuracy: z.ZodOptional<z.ZodObject<{
+                value: z.ZodNumber;
+                vsLabel: z.ZodString;
+                tone: z.ZodEnum<{
+                    ok: "ok";
+                    bad: "bad";
+                    neutral: "neutral";
+                }>;
+                betterIsLower: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            precision: z.ZodOptional<z.ZodObject<{
+                value: z.ZodNumber;
+                vsLabel: z.ZodString;
+                tone: z.ZodEnum<{
+                    ok: "ok";
+                    bad: "bad";
+                    neutral: "neutral";
+                }>;
+                betterIsLower: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            recall: z.ZodOptional<z.ZodObject<{
+                value: z.ZodNumber;
+                vsLabel: z.ZodString;
+                tone: z.ZodEnum<{
+                    ok: "ok";
+                    bad: "bad";
+                    neutral: "neutral";
+                }>;
+                betterIsLower: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    classRows: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        accuracy: z.ZodOptional<z.ZodNumber>;
+        precision: z.ZodNumber;
+        recall: z.ZodNumber;
+        f1: z.ZodOptional<z.ZodNumber>;
+        fpr: z.ZodOptional<z.ZodNumber>;
+        vsLabel: z.ZodString;
+        vsDelta: z.ZodNullable<z.ZodNumber>;
+        vsTone: z.ZodEnum<{
+            ok: "ok";
+            bad: "bad";
+            neutral: "neutral";
+        }>;
+        deltas: z.ZodOptional<z.ZodObject<{
+            accuracy: z.ZodOptional<z.ZodObject<{
+                value: z.ZodNumber;
+                vsLabel: z.ZodString;
+                tone: z.ZodEnum<{
+                    ok: "ok";
+                    bad: "bad";
+                    neutral: "neutral";
+                }>;
+                betterIsLower: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            precision: z.ZodOptional<z.ZodObject<{
+                value: z.ZodNumber;
+                vsLabel: z.ZodString;
+                tone: z.ZodEnum<{
+                    ok: "ok";
+                    bad: "bad";
+                    neutral: "neutral";
+                }>;
+                betterIsLower: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            recall: z.ZodOptional<z.ZodObject<{
+                value: z.ZodNumber;
+                vsLabel: z.ZodString;
+                tone: z.ZodEnum<{
+                    ok: "ok";
+                    bad: "bad";
+                    neutral: "neutral";
+                }>;
+                betterIsLower: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    vsPrevLabel: z.ZodString;
+}, z.core.$strip>;
+export type OptimizationDetailRoundExperimentResultDto = z.infer<typeof optimizationDetailRoundExperimentResultSchema>;
+export declare const optimizationDetailRoundStreamSegmentSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        observation: "observation";
+        hypothesis: "hypothesis";
+        rewrite: "rewrite";
+        plain: "plain";
+    }>;
+    text: z.ZodString;
+}, z.core.$strip>;
+export type OptimizationDetailRoundStreamSegmentDto = z.infer<typeof optimizationDetailRoundStreamSegmentSchema>;
+export declare const optimizationDetailRoundStreamSchema: z.ZodObject<{
+    stage: z.ZodString;
+    analysisModel: z.ZodString;
+    segments: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            observation: "observation";
+            hypothesis: "hypothesis";
+            rewrite: "rewrite";
+            plain: "plain";
+        }>;
+        text: z.ZodString;
+    }, z.core.$strip>>;
+    showCursor: z.ZodBoolean;
+}, z.core.$strip>;
+export type OptimizationDetailRoundStreamDto = z.infer<typeof optimizationDetailRoundStreamSchema>;
+export declare const optimizationDetailPromptDiffLineSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        hunk: "hunk";
+        add: "add";
+        del: "del";
+        ctx: "ctx";
+    }>;
+    text: z.ZodString;
+    lineNumber: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+export type OptimizationDetailPromptDiffLineDto = z.infer<typeof optimizationDetailPromptDiffLineSchema>;
+export declare const optimizationDetailRoundStepKindSchema: z.ZodEnum<{
+    experiment: "experiment";
+    error_analysis: "error_analysis";
+    generate_prompt: "generate_prompt";
+}>;
+export type OptimizationDetailRoundStepKindDto = z.infer<typeof optimizationDetailRoundStepKindSchema>;
+export declare const optimizationDetailRoundStepStatusSchema: z.ZodEnum<{
+    success: "success";
+    failed: "failed";
+    pending: "pending";
+    running: "running";
+    skipped: "skipped";
+}>;
+export type OptimizationDetailRoundStepStatusDto = z.infer<typeof optimizationDetailRoundStepStatusSchema>;
+export declare const optimizationDetailRoundStepSchema: z.ZodObject<{
+    step: z.ZodEnum<{
+        experiment: "experiment";
+        error_analysis: "error_analysis";
+        generate_prompt: "generate_prompt";
+    }>;
+    status: z.ZodEnum<{
+        success: "success";
+        failed: "failed";
+        pending: "pending";
+        running: "running";
+        skipped: "skipped";
+    }>;
+    errorClass: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    errorMessage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    startedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    finishedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    runResultId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    experimentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type OptimizationDetailRoundStepDto = z.infer<typeof optimizationDetailRoundStepSchema>;
+export declare const optimizationDetailIterationRoundSchema: z.ZodObject<{
+    index: z.ZodNumber;
+    status: z.ZodEnum<{
+        success: "success";
+        failed: "failed";
+        running: "running";
+        paused: "paused";
+    }>;
+    isBaseline: z.ZodOptional<z.ZodBoolean>;
+    isBest: z.ZodOptional<z.ZodBoolean>;
+    kindLabel: z.ZodString;
+    startedAt: z.ZodOptional<z.ZodString>;
+    metrics: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodNumber;
+        partial: z.ZodOptional<z.ZodBoolean>;
+        delta: z.ZodOptional<z.ZodObject<{
+            value: z.ZodNumber;
+            vsLabel: z.ZodString;
+            tone: z.ZodEnum<{
+                ok: "ok";
+                bad: "bad";
+                neutral: "neutral";
+            }>;
+            betterIsLower: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    experimentResult: z.ZodOptional<z.ZodObject<{
+        experimentRef: z.ZodString;
+        experimentStatus: z.ZodEnum<{
+            success: "success";
+            failed: "failed";
+            running: "running";
+        }>;
+        samplesDone: z.ZodNumber;
+        samplesTotal: z.ZodNumber;
+        correct: z.ZodNumber;
+        wrong: z.ZodNumber;
+        elapsed: z.ZodString;
+        tokenSummary: z.ZodString;
+        costLabel: z.ZodString;
+        overallRow: z.ZodNullable<z.ZodObject<{
+            accuracy: z.ZodNumber;
+            precision: z.ZodNumber;
+            recall: z.ZodNumber;
+            vsLabel: z.ZodString;
+            vsDelta: z.ZodNullable<z.ZodNumber>;
+            vsTone: z.ZodEnum<{
+                ok: "ok";
+                bad: "bad";
+                neutral: "neutral";
+            }>;
+            deltas: z.ZodOptional<z.ZodObject<{
+                accuracy: z.ZodOptional<z.ZodObject<{
+                    value: z.ZodNumber;
+                    vsLabel: z.ZodString;
+                    tone: z.ZodEnum<{
+                        ok: "ok";
+                        bad: "bad";
+                        neutral: "neutral";
+                    }>;
+                    betterIsLower: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                precision: z.ZodOptional<z.ZodObject<{
+                    value: z.ZodNumber;
+                    vsLabel: z.ZodString;
+                    tone: z.ZodEnum<{
+                        ok: "ok";
+                        bad: "bad";
+                        neutral: "neutral";
+                    }>;
+                    betterIsLower: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                recall: z.ZodOptional<z.ZodObject<{
+                    value: z.ZodNumber;
+                    vsLabel: z.ZodString;
+                    tone: z.ZodEnum<{
+                        ok: "ok";
+                        bad: "bad";
+                        neutral: "neutral";
+                    }>;
+                    betterIsLower: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        classRows: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            accuracy: z.ZodOptional<z.ZodNumber>;
+            precision: z.ZodNumber;
+            recall: z.ZodNumber;
+            f1: z.ZodOptional<z.ZodNumber>;
+            fpr: z.ZodOptional<z.ZodNumber>;
+            vsLabel: z.ZodString;
+            vsDelta: z.ZodNullable<z.ZodNumber>;
+            vsTone: z.ZodEnum<{
+                ok: "ok";
+                bad: "bad";
+                neutral: "neutral";
+            }>;
+            deltas: z.ZodOptional<z.ZodObject<{
+                accuracy: z.ZodOptional<z.ZodObject<{
+                    value: z.ZodNumber;
+                    vsLabel: z.ZodString;
+                    tone: z.ZodEnum<{
+                        ok: "ok";
+                        bad: "bad";
+                        neutral: "neutral";
+                    }>;
+                    betterIsLower: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                precision: z.ZodOptional<z.ZodObject<{
+                    value: z.ZodNumber;
+                    vsLabel: z.ZodString;
+                    tone: z.ZodEnum<{
+                        ok: "ok";
+                        bad: "bad";
+                        neutral: "neutral";
+                    }>;
+                    betterIsLower: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                recall: z.ZodOptional<z.ZodObject<{
+                    value: z.ZodNumber;
+                    vsLabel: z.ZodString;
+                    tone: z.ZodEnum<{
+                        ok: "ok";
+                        bad: "bad";
+                        neutral: "neutral";
+                    }>;
+                    betterIsLower: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        vsPrevLabel: z.ZodString;
+    }, z.core.$strip>>;
+    errorPatterns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        percent: z.ZodNumber;
+        title: z.ZodString;
+        detail: z.ZodString;
+        count: z.ZodObject<{
+            hit: z.ZodNumber;
+            total: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+    improvementSuggestions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        section: z.ZodString;
+        title: z.ZodString;
+        detail: z.ZodOptional<z.ZodString>;
+        priority: z.ZodOptional<z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>>;
+    }, z.core.$strip>>>;
+    promptDiff: z.ZodOptional<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        fromText: z.ZodString;
+        toText: z.ZodString;
+        lines: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                hunk: "hunk";
+                add: "add";
+                del: "del";
+                ctx: "ctx";
+            }>;
+            text: z.ZodString;
+            lineNumber: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    stream: z.ZodOptional<z.ZodObject<{
+        stage: z.ZodString;
+        analysisModel: z.ZodString;
+        segments: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                observation: "observation";
+                hypothesis: "hypothesis";
+                rewrite: "rewrite";
+                plain: "plain";
+            }>;
+            text: z.ZodString;
+        }, z.core.$strip>>;
+        showCursor: z.ZodBoolean;
+    }, z.core.$strip>>;
+    summaryFallback: z.ZodOptional<z.ZodString>;
+    collapsed: z.ZodOptional<z.ZodBoolean>;
+    promptVersionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    experimentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    promptLink: z.ZodOptional<z.ZodString>;
+    experimentLink: z.ZodOptional<z.ZodString>;
+    totalElapsed: z.ZodOptional<z.ZodString>;
+    totalCost: z.ZodOptional<z.ZodString>;
+    steps: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        step: z.ZodEnum<{
+            experiment: "experiment";
+            error_analysis: "error_analysis";
+            generate_prompt: "generate_prompt";
+        }>;
+        status: z.ZodEnum<{
+            success: "success";
+            failed: "failed";
+            pending: "pending";
+            running: "running";
+            skipped: "skipped";
+        }>;
+        errorClass: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        errorMessage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        startedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        finishedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        runResultId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        experimentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>>;
+    goalChips: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        targetText: z.ZodString;
+        currentText: z.ZodString;
+        achieved: z.ZodEnum<{
+            hit: "hit";
+            miss: "miss";
+        }>;
+    }, z.core.$strip>>>;
+    autoPatched: z.ZodOptional<z.ZodBoolean>;
+    patchedVariables: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type OptimizationDetailIterationRoundDto = z.infer<typeof optimizationDetailIterationRoundSchema>;
+export declare const optimizationDetailBaselineMetricSchema: z.ZodObject<{
+    label: z.ZodString;
+    value: z.ZodNumber;
+    betterIsLower: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type OptimizationDetailBaselineMetricDto = z.infer<typeof optimizationDetailBaselineMetricSchema>;
+export declare const optimizationDetailBaselineRowSchema: z.ZodObject<{
+    promptVersion: z.ZodString;
+    baselineExperiment: z.ZodString;
+    metrics: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodNumber;
+        betterIsLower: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    promptPreview: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    experimentResult: z.ZodOptional<z.ZodObject<{
+        experimentRef: z.ZodString;
+        experimentStatus: z.ZodEnum<{
+            success: "success";
+            failed: "failed";
+            running: "running";
+        }>;
+        samplesDone: z.ZodNumber;
+        samplesTotal: z.ZodNumber;
+        correct: z.ZodNumber;
+        wrong: z.ZodNumber;
+        elapsed: z.ZodString;
+        tokenSummary: z.ZodString;
+        costLabel: z.ZodString;
+        overallRow: z.ZodNullable<z.ZodObject<{
+            accuracy: z.ZodNumber;
+            precision: z.ZodNumber;
+            recall: z.ZodNumber;
+            vsLabel: z.ZodString;
+            vsDelta: z.ZodNullable<z.ZodNumber>;
+            vsTone: z.ZodEnum<{
+                ok: "ok";
+                bad: "bad";
+                neutral: "neutral";
+            }>;
+            deltas: z.ZodOptional<z.ZodObject<{
+                accuracy: z.ZodOptional<z.ZodObject<{
+                    value: z.ZodNumber;
+                    vsLabel: z.ZodString;
+                    tone: z.ZodEnum<{
+                        ok: "ok";
+                        bad: "bad";
+                        neutral: "neutral";
+                    }>;
+                    betterIsLower: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                precision: z.ZodOptional<z.ZodObject<{
+                    value: z.ZodNumber;
+                    vsLabel: z.ZodString;
+                    tone: z.ZodEnum<{
+                        ok: "ok";
+                        bad: "bad";
+                        neutral: "neutral";
+                    }>;
+                    betterIsLower: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                recall: z.ZodOptional<z.ZodObject<{
+                    value: z.ZodNumber;
+                    vsLabel: z.ZodString;
+                    tone: z.ZodEnum<{
+                        ok: "ok";
+                        bad: "bad";
+                        neutral: "neutral";
+                    }>;
+                    betterIsLower: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        classRows: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            accuracy: z.ZodOptional<z.ZodNumber>;
+            precision: z.ZodNumber;
+            recall: z.ZodNumber;
+            f1: z.ZodOptional<z.ZodNumber>;
+            fpr: z.ZodOptional<z.ZodNumber>;
+            vsLabel: z.ZodString;
+            vsDelta: z.ZodNullable<z.ZodNumber>;
+            vsTone: z.ZodEnum<{
+                ok: "ok";
+                bad: "bad";
+                neutral: "neutral";
+            }>;
+            deltas: z.ZodOptional<z.ZodObject<{
+                accuracy: z.ZodOptional<z.ZodObject<{
+                    value: z.ZodNumber;
+                    vsLabel: z.ZodString;
+                    tone: z.ZodEnum<{
+                        ok: "ok";
+                        bad: "bad";
+                        neutral: "neutral";
+                    }>;
+                    betterIsLower: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                precision: z.ZodOptional<z.ZodObject<{
+                    value: z.ZodNumber;
+                    vsLabel: z.ZodString;
+                    tone: z.ZodEnum<{
+                        ok: "ok";
+                        bad: "bad";
+                        neutral: "neutral";
+                    }>;
+                    betterIsLower: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                recall: z.ZodOptional<z.ZodObject<{
+                    value: z.ZodNumber;
+                    vsLabel: z.ZodString;
+                    tone: z.ZodEnum<{
+                        ok: "ok";
+                        bad: "bad";
+                        neutral: "neutral";
+                    }>;
+                    betterIsLower: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        vsPrevLabel: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type OptimizationDetailBaselineRowDto = z.infer<typeof optimizationDetailBaselineRowSchema>;
+export declare const optimizationDetailGoalProgressAchievedSchema: z.ZodEnum<{
+    hit: "hit";
+    miss: "miss";
+    critical: "critical";
+}>;
+export type OptimizationDetailGoalProgressAchievedDto = z.infer<typeof optimizationDetailGoalProgressAchievedSchema>;
+export declare const optimizationDetailGoalProgressSchema: z.ZodObject<{
+    label: z.ZodString;
+    targetText: z.ZodString;
+    currentText: z.ZodString;
+    achieved: z.ZodEnum<{
+        hit: "hit";
+        miss: "miss";
+        critical: "critical";
+    }>;
+    percent: z.ZodNumber;
+}, z.core.$strip>;
+export type OptimizationDetailGoalProgressDto = z.infer<typeof optimizationDetailGoalProgressSchema>;
+export declare const optimizationDetailBestVersionMetricSchema: z.ZodObject<{
+    label: z.ZodString;
+    value: z.ZodNumber;
+    tone: z.ZodOptional<z.ZodEnum<{
+        ok: "ok";
+        bad: "bad";
+        neutral: "neutral";
+    }>>;
+}, z.core.$strip>;
+export type OptimizationDetailBestVersionMetricDto = z.infer<typeof optimizationDetailBestVersionMetricSchema>;
+export declare const optimizationDetailBestVersionSchema: z.ZodObject<{
+    promptRef: z.ZodString;
+    promptVersion: z.ZodString;
+    generatedAtRoundLabel: z.ZodString;
+    generatedAtRoundIndex: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    metrics: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodNumber;
+        tone: z.ZodOptional<z.ZodEnum<{
+            ok: "ok";
+            bad: "bad";
+            neutral: "neutral";
+        }>>;
+    }, z.core.$strip>>;
+    experimentRef: z.ZodString;
+    promptVersionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    experimentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type OptimizationDetailBestVersionDto = z.infer<typeof optimizationDetailBestVersionSchema>;
+export declare const optimizationDetailTrendSeriesKeySchema: z.ZodEnum<{
+    accuracy: "accuracy";
+    recall: "recall";
+    fpr: "fpr";
+}>;
+export type OptimizationDetailTrendSeriesKeyDto = z.infer<typeof optimizationDetailTrendSeriesKeySchema>;
+export declare const optimizationDetailTrendSeriesSchema: z.ZodObject<{
+    key: z.ZodEnum<{
+        accuracy: "accuracy";
+        recall: "recall";
+        fpr: "fpr";
+    }>;
+    labelKey: z.ZodString;
+    betterIsLower: z.ZodOptional<z.ZodBoolean>;
+    values: z.ZodArray<z.ZodNumber>;
+    target: z.ZodOptional<z.ZodNumber>;
+    bestRoundIndex: z.ZodOptional<z.ZodNumber>;
+    hasBaseline: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type OptimizationDetailTrendSeriesDto = z.infer<typeof optimizationDetailTrendSeriesSchema>;
+export declare const optimizationDetailSchema: z.ZodObject<{
+    id: z.ZodString;
+    projectId: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    strategy: z.ZodString;
+    startingMode: z.ZodEnum<{
+        from_experiment: "from_experiment";
+        from_prompt_version: "from_prompt_version";
+        from_dataset_only: "from_dataset_only";
+    }>;
+    status: z.ZodEnum<{
+        success: "success";
+        failed: "failed";
+        running: "running";
+        stopped: "stopped";
+        cancelled: "cancelled";
+    }>;
+    controlState: z.ZodNullable<z.ZodEnum<{
+        stop: "stop";
+        resume: "resume";
+        cancel: "cancel";
+    }>>;
+    sourceExperimentId: z.ZodNullable<z.ZodString>;
+    sourceExperimentName: z.ZodNullable<z.ZodString>;
+    promptId: z.ZodNullable<z.ZodString>;
+    promptName: z.ZodNullable<z.ZodString>;
+    baseVersionId: z.ZodNullable<z.ZodString>;
+    baseVersionNumber: z.ZodNullable<z.ZodNumber>;
+    datasetId: z.ZodString;
+    datasetName: z.ZodString;
+    datasetSamples: z.ZodNumber;
+    experimentModelId: z.ZodString;
+    experimentModelName: z.ZodString;
+    analysisModelId: z.ZodString;
+    analysisModelName: z.ZodString;
+    promptLanguage: z.ZodEnum<{
+        "zh-CN": "zh-CN";
+        "en-US": "en-US";
+    }>;
+    goals: z.ZodArray<z.ZodObject<{
+        metric: z.ZodEnum<{
+            accuracy: "accuracy";
+            precision: "precision";
+            recall: "recall";
+            f1: "f1";
+            fpr: "fpr";
+        }>;
+        comparator: z.ZodEnum<{
+            gte: "gte";
+            gt: "gt";
+            lte: "lte";
+        }>;
+        target: z.ZodNumber;
+        scope: z.ZodString;
+    }, z.core.$strip>>;
+    fieldWhitelist: z.ZodNullable<z.ZodObject<{
+        inputFields: z.ZodArray<z.ZodString>;
+        metaFields: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    runConfig: z.ZodObject<{
+        temperature: z.ZodOptional<z.ZodNumber>;
+        concurrency: z.ZodOptional<z.ZodNumber>;
+        rpmLimit: z.ZodOptional<z.ZodNumber>;
+        tpmLimit: z.ZodOptional<z.ZodNumber>;
+        sampleTimeoutSeconds: z.ZodOptional<z.ZodNumber>;
+        retries: z.ZodOptional<z.ZodNumber>;
+        imageEncoding: z.ZodOptional<z.ZodEnum<{
+            url: "url";
+            base64: "base64";
+        }>>;
+    }, z.core.$catchall<z.ZodUnknown>>;
+    maxRounds: z.ZodNumber;
+    currentRound: z.ZodNumber;
+    bestVersionId: z.ZodNullable<z.ZodString>;
+    bestVersionNumber: z.ZodNullable<z.ZodNumber>;
+    bestMetrics: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    trendHasBaseline: z.ZodOptional<z.ZodBoolean>;
+    summary: z.ZodNullable<z.ZodObject<{
+        kind: z.ZodEnum<{
+            success: "success";
+            failed: "failed";
+            running: "running";
+            stopped: "stopped";
+            cancelled: "cancelled";
+        }>;
+        reason: z.ZodString;
+        finalizedAt: z.ZodString;
+    }, z.core.$strip>>;
+    analysisFailureReason: z.ZodNullable<z.ZodString>;
+    dbosWorkflowId: z.ZodNullable<z.ZodString>;
+    createdBy: z.ZodString;
+    createdByDisplayName: z.ZodNullable<z.ZodString>;
+    createdByUsername: z.ZodNullable<z.ZodString>;
+    startedAt: z.ZodNullable<z.ZodString>;
+    finishedAt: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    deletedAt: z.ZodNullable<z.ZodString>;
+    optimizationHint: z.ZodNullable<z.ZodString>;
+    ownerHandle: z.ZodString;
+    elapsedMs: z.ZodNullable<z.ZodNumber>;
+    experimentConfig: z.ZodNullable<z.ZodObject<{
+        datasetName: z.ZodString;
+        promptName: z.ZodString;
+        promptVersion: z.ZodString;
+        modelName: z.ZodString;
+        baselineExperiment: z.ZodString;
+        temperature: z.ZodNumber;
+        concurrency: z.ZodNumber;
+        rpm: z.ZodNumber;
+        tpm: z.ZodNumber;
+    }, z.core.$strip>>;
+    iterationConfig: z.ZodNullable<z.ZodObject<{
+        analysisModel: z.ZodString;
+        strategy: z.ZodString;
+        maxRounds: z.ZodNumber;
+        noImprovementStop: z.ZodNumber;
+        regressionThreshold: z.ZodNumber;
+    }, z.core.$strip>>;
+    goalScope: z.ZodObject<{
+        kind: z.ZodEnum<{
+            overall: "overall";
+            class: "class";
+        }>;
+        classes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    goalsLines: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        targetText: z.ZodString;
+        tone: z.ZodEnum<{
+            overall: "overall";
+            class: "class";
+        }>;
+    }, z.core.$strip>>;
+    controlStrip: z.ZodNullable<z.ZodObject<{
+        currentRound: z.ZodNumber;
+        maxRounds: z.ZodNumber;
+        phase: z.ZodEnum<{
+            experiment: "experiment";
+            analysis: "analysis";
+            paused: "paused";
+            finishing: "finishing";
+        }>;
+        samplesDone: z.ZodNumber;
+        samplesTotal: z.ZodNumber;
+        roundRemaining: z.ZodString;
+        totalRemaining: z.ZodString;
+    }, z.core.$strip>>;
+    trend: z.ZodArray<z.ZodObject<{
+        key: z.ZodEnum<{
+            accuracy: "accuracy";
+            recall: "recall";
+            fpr: "fpr";
+        }>;
+        labelKey: z.ZodString;
+        betterIsLower: z.ZodOptional<z.ZodBoolean>;
+        values: z.ZodArray<z.ZodNumber>;
+        target: z.ZodOptional<z.ZodNumber>;
+        bestRoundIndex: z.ZodOptional<z.ZodNumber>;
+        hasBaseline: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    trendBaselineRef: z.ZodNullable<z.ZodNumber>;
+    bestRoundLabel: z.ZodNullable<z.ZodString>;
+    rounds: z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        status: z.ZodEnum<{
+            success: "success";
+            failed: "failed";
+            running: "running";
+            paused: "paused";
+        }>;
+        isBaseline: z.ZodOptional<z.ZodBoolean>;
+        isBest: z.ZodOptional<z.ZodBoolean>;
+        kindLabel: z.ZodString;
+        startedAt: z.ZodOptional<z.ZodString>;
+        metrics: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodNumber;
+            partial: z.ZodOptional<z.ZodBoolean>;
+            delta: z.ZodOptional<z.ZodObject<{
+                value: z.ZodNumber;
+                vsLabel: z.ZodString;
+                tone: z.ZodEnum<{
+                    ok: "ok";
+                    bad: "bad";
+                    neutral: "neutral";
+                }>;
+                betterIsLower: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        experimentResult: z.ZodOptional<z.ZodObject<{
+            experimentRef: z.ZodString;
+            experimentStatus: z.ZodEnum<{
+                success: "success";
+                failed: "failed";
+                running: "running";
+            }>;
+            samplesDone: z.ZodNumber;
+            samplesTotal: z.ZodNumber;
+            correct: z.ZodNumber;
+            wrong: z.ZodNumber;
+            elapsed: z.ZodString;
+            tokenSummary: z.ZodString;
+            costLabel: z.ZodString;
+            overallRow: z.ZodNullable<z.ZodObject<{
+                accuracy: z.ZodNumber;
+                precision: z.ZodNumber;
+                recall: z.ZodNumber;
+                vsLabel: z.ZodString;
+                vsDelta: z.ZodNullable<z.ZodNumber>;
+                vsTone: z.ZodEnum<{
+                    ok: "ok";
+                    bad: "bad";
+                    neutral: "neutral";
+                }>;
+                deltas: z.ZodOptional<z.ZodObject<{
+                    accuracy: z.ZodOptional<z.ZodObject<{
+                        value: z.ZodNumber;
+                        vsLabel: z.ZodString;
+                        tone: z.ZodEnum<{
+                            ok: "ok";
+                            bad: "bad";
+                            neutral: "neutral";
+                        }>;
+                        betterIsLower: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>>;
+                    precision: z.ZodOptional<z.ZodObject<{
+                        value: z.ZodNumber;
+                        vsLabel: z.ZodString;
+                        tone: z.ZodEnum<{
+                            ok: "ok";
+                            bad: "bad";
+                            neutral: "neutral";
+                        }>;
+                        betterIsLower: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>>;
+                    recall: z.ZodOptional<z.ZodObject<{
+                        value: z.ZodNumber;
+                        vsLabel: z.ZodString;
+                        tone: z.ZodEnum<{
+                            ok: "ok";
+                            bad: "bad";
+                            neutral: "neutral";
+                        }>;
+                        betterIsLower: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            classRows: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                accuracy: z.ZodOptional<z.ZodNumber>;
+                precision: z.ZodNumber;
+                recall: z.ZodNumber;
+                f1: z.ZodOptional<z.ZodNumber>;
+                fpr: z.ZodOptional<z.ZodNumber>;
+                vsLabel: z.ZodString;
+                vsDelta: z.ZodNullable<z.ZodNumber>;
+                vsTone: z.ZodEnum<{
+                    ok: "ok";
+                    bad: "bad";
+                    neutral: "neutral";
+                }>;
+                deltas: z.ZodOptional<z.ZodObject<{
+                    accuracy: z.ZodOptional<z.ZodObject<{
+                        value: z.ZodNumber;
+                        vsLabel: z.ZodString;
+                        tone: z.ZodEnum<{
+                            ok: "ok";
+                            bad: "bad";
+                            neutral: "neutral";
+                        }>;
+                        betterIsLower: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>>;
+                    precision: z.ZodOptional<z.ZodObject<{
+                        value: z.ZodNumber;
+                        vsLabel: z.ZodString;
+                        tone: z.ZodEnum<{
+                            ok: "ok";
+                            bad: "bad";
+                            neutral: "neutral";
+                        }>;
+                        betterIsLower: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>>;
+                    recall: z.ZodOptional<z.ZodObject<{
+                        value: z.ZodNumber;
+                        vsLabel: z.ZodString;
+                        tone: z.ZodEnum<{
+                            ok: "ok";
+                            bad: "bad";
+                            neutral: "neutral";
+                        }>;
+                        betterIsLower: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            vsPrevLabel: z.ZodString;
+        }, z.core.$strip>>;
+        errorPatterns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            percent: z.ZodNumber;
+            title: z.ZodString;
+            detail: z.ZodString;
+            count: z.ZodObject<{
+                hit: z.ZodNumber;
+                total: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>>>;
+        improvementSuggestions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            section: z.ZodString;
+            title: z.ZodString;
+            detail: z.ZodOptional<z.ZodString>;
+            priority: z.ZodOptional<z.ZodEnum<{
+                high: "high";
+                medium: "medium";
+                low: "low";
+            }>>;
+        }, z.core.$strip>>>;
+        promptDiff: z.ZodOptional<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            fromText: z.ZodString;
+            toText: z.ZodString;
+            lines: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    hunk: "hunk";
+                    add: "add";
+                    del: "del";
+                    ctx: "ctx";
+                }>;
+                text: z.ZodString;
+                lineNumber: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        stream: z.ZodOptional<z.ZodObject<{
+            stage: z.ZodString;
+            analysisModel: z.ZodString;
+            segments: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    observation: "observation";
+                    hypothesis: "hypothesis";
+                    rewrite: "rewrite";
+                    plain: "plain";
+                }>;
+                text: z.ZodString;
+            }, z.core.$strip>>;
+            showCursor: z.ZodBoolean;
+        }, z.core.$strip>>;
+        summaryFallback: z.ZodOptional<z.ZodString>;
+        collapsed: z.ZodOptional<z.ZodBoolean>;
+        promptVersionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        experimentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        promptLink: z.ZodOptional<z.ZodString>;
+        experimentLink: z.ZodOptional<z.ZodString>;
+        totalElapsed: z.ZodOptional<z.ZodString>;
+        totalCost: z.ZodOptional<z.ZodString>;
+        steps: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            step: z.ZodEnum<{
+                experiment: "experiment";
+                error_analysis: "error_analysis";
+                generate_prompt: "generate_prompt";
+            }>;
+            status: z.ZodEnum<{
+                success: "success";
+                failed: "failed";
+                pending: "pending";
+                running: "running";
+                skipped: "skipped";
+            }>;
+            errorClass: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            errorMessage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            startedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            finishedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            runResultId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            experimentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>;
+        goalChips: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            targetText: z.ZodString;
+            currentText: z.ZodString;
+            achieved: z.ZodEnum<{
+                hit: "hit";
+                miss: "miss";
+            }>;
+        }, z.core.$strip>>>;
+        autoPatched: z.ZodOptional<z.ZodBoolean>;
+        patchedVariables: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    baseline: z.ZodNullable<z.ZodObject<{
+        promptVersion: z.ZodString;
+        baselineExperiment: z.ZodString;
+        metrics: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodNumber;
+            betterIsLower: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        promptPreview: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        experimentResult: z.ZodOptional<z.ZodObject<{
+            experimentRef: z.ZodString;
+            experimentStatus: z.ZodEnum<{
+                success: "success";
+                failed: "failed";
+                running: "running";
+            }>;
+            samplesDone: z.ZodNumber;
+            samplesTotal: z.ZodNumber;
+            correct: z.ZodNumber;
+            wrong: z.ZodNumber;
+            elapsed: z.ZodString;
+            tokenSummary: z.ZodString;
+            costLabel: z.ZodString;
+            overallRow: z.ZodNullable<z.ZodObject<{
+                accuracy: z.ZodNumber;
+                precision: z.ZodNumber;
+                recall: z.ZodNumber;
+                vsLabel: z.ZodString;
+                vsDelta: z.ZodNullable<z.ZodNumber>;
+                vsTone: z.ZodEnum<{
+                    ok: "ok";
+                    bad: "bad";
+                    neutral: "neutral";
+                }>;
+                deltas: z.ZodOptional<z.ZodObject<{
+                    accuracy: z.ZodOptional<z.ZodObject<{
+                        value: z.ZodNumber;
+                        vsLabel: z.ZodString;
+                        tone: z.ZodEnum<{
+                            ok: "ok";
+                            bad: "bad";
+                            neutral: "neutral";
+                        }>;
+                        betterIsLower: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>>;
+                    precision: z.ZodOptional<z.ZodObject<{
+                        value: z.ZodNumber;
+                        vsLabel: z.ZodString;
+                        tone: z.ZodEnum<{
+                            ok: "ok";
+                            bad: "bad";
+                            neutral: "neutral";
+                        }>;
+                        betterIsLower: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>>;
+                    recall: z.ZodOptional<z.ZodObject<{
+                        value: z.ZodNumber;
+                        vsLabel: z.ZodString;
+                        tone: z.ZodEnum<{
+                            ok: "ok";
+                            bad: "bad";
+                            neutral: "neutral";
+                        }>;
+                        betterIsLower: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            classRows: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                accuracy: z.ZodOptional<z.ZodNumber>;
+                precision: z.ZodNumber;
+                recall: z.ZodNumber;
+                f1: z.ZodOptional<z.ZodNumber>;
+                fpr: z.ZodOptional<z.ZodNumber>;
+                vsLabel: z.ZodString;
+                vsDelta: z.ZodNullable<z.ZodNumber>;
+                vsTone: z.ZodEnum<{
+                    ok: "ok";
+                    bad: "bad";
+                    neutral: "neutral";
+                }>;
+                deltas: z.ZodOptional<z.ZodObject<{
+                    accuracy: z.ZodOptional<z.ZodObject<{
+                        value: z.ZodNumber;
+                        vsLabel: z.ZodString;
+                        tone: z.ZodEnum<{
+                            ok: "ok";
+                            bad: "bad";
+                            neutral: "neutral";
+                        }>;
+                        betterIsLower: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>>;
+                    precision: z.ZodOptional<z.ZodObject<{
+                        value: z.ZodNumber;
+                        vsLabel: z.ZodString;
+                        tone: z.ZodEnum<{
+                            ok: "ok";
+                            bad: "bad";
+                            neutral: "neutral";
+                        }>;
+                        betterIsLower: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>>;
+                    recall: z.ZodOptional<z.ZodObject<{
+                        value: z.ZodNumber;
+                        vsLabel: z.ZodString;
+                        tone: z.ZodEnum<{
+                            ok: "ok";
+                            bad: "bad";
+                            neutral: "neutral";
+                        }>;
+                        betterIsLower: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            vsPrevLabel: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    goalProgress: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        targetText: z.ZodString;
+        currentText: z.ZodString;
+        achieved: z.ZodEnum<{
+            hit: "hit";
+            miss: "miss";
+            critical: "critical";
+        }>;
+        percent: z.ZodNumber;
+    }, z.core.$strip>>;
+    bestVersion: z.ZodNullable<z.ZodObject<{
+        promptRef: z.ZodString;
+        promptVersion: z.ZodString;
+        generatedAtRoundLabel: z.ZodString;
+        generatedAtRoundIndex: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        metrics: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodNumber;
+            tone: z.ZodOptional<z.ZodEnum<{
+                ok: "ok";
+                bad: "bad";
+                neutral: "neutral";
+            }>>;
+        }, z.core.$strip>>;
+        experimentRef: z.ZodString;
+        promptVersionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        experimentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type OptimizationDetailDto = z.infer<typeof optimizationDetailSchema>;
+export declare const optimizationDevMockTimelineSchema: z.ZodObject<{
+    trend: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodEnum<{
+            accuracy: "accuracy";
+            recall: "recall";
+            fpr: "fpr";
+        }>;
+        labelKey: z.ZodString;
+        betterIsLower: z.ZodOptional<z.ZodBoolean>;
+        values: z.ZodArray<z.ZodNumber>;
+        target: z.ZodOptional<z.ZodNumber>;
+        bestRoundIndex: z.ZodOptional<z.ZodNumber>;
+        hasBaseline: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    trendBaselineRef: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    bestRoundLabel: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    controlStrip: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        currentRound: z.ZodNumber;
+        maxRounds: z.ZodNumber;
+        phase: z.ZodEnum<{
+            experiment: "experiment";
+            analysis: "analysis";
+            paused: "paused";
+            finishing: "finishing";
+        }>;
+        samplesDone: z.ZodNumber;
+        samplesTotal: z.ZodNumber;
+        roundRemaining: z.ZodString;
+        totalRemaining: z.ZodString;
+    }, z.core.$strip>>>;
+    rounds: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        status: z.ZodEnum<{
+            success: "success";
+            failed: "failed";
+            running: "running";
+            paused: "paused";
+        }>;
+        isBaseline: z.ZodOptional<z.ZodBoolean>;
+        isBest: z.ZodOptional<z.ZodBoolean>;
+        kindLabel: z.ZodString;
+        startedAt: z.ZodOptional<z.ZodString>;
+        metrics: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodNumber;
+            partial: z.ZodOptional<z.ZodBoolean>;
+            delta: z.ZodOptional<z.ZodObject<{
+                value: z.ZodNumber;
+                vsLabel: z.ZodString;
+                tone: z.ZodEnum<{
+                    ok: "ok";
+                    bad: "bad";
+                    neutral: "neutral";
+                }>;
+                betterIsLower: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        experimentResult: z.ZodOptional<z.ZodObject<{
+            experimentRef: z.ZodString;
+            experimentStatus: z.ZodEnum<{
+                success: "success";
+                failed: "failed";
+                running: "running";
+            }>;
+            samplesDone: z.ZodNumber;
+            samplesTotal: z.ZodNumber;
+            correct: z.ZodNumber;
+            wrong: z.ZodNumber;
+            elapsed: z.ZodString;
+            tokenSummary: z.ZodString;
+            costLabel: z.ZodString;
+            overallRow: z.ZodNullable<z.ZodObject<{
+                accuracy: z.ZodNumber;
+                precision: z.ZodNumber;
+                recall: z.ZodNumber;
+                vsLabel: z.ZodString;
+                vsDelta: z.ZodNullable<z.ZodNumber>;
+                vsTone: z.ZodEnum<{
+                    ok: "ok";
+                    bad: "bad";
+                    neutral: "neutral";
+                }>;
+                deltas: z.ZodOptional<z.ZodObject<{
+                    accuracy: z.ZodOptional<z.ZodObject<{
+                        value: z.ZodNumber;
+                        vsLabel: z.ZodString;
+                        tone: z.ZodEnum<{
+                            ok: "ok";
+                            bad: "bad";
+                            neutral: "neutral";
+                        }>;
+                        betterIsLower: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>>;
+                    precision: z.ZodOptional<z.ZodObject<{
+                        value: z.ZodNumber;
+                        vsLabel: z.ZodString;
+                        tone: z.ZodEnum<{
+                            ok: "ok";
+                            bad: "bad";
+                            neutral: "neutral";
+                        }>;
+                        betterIsLower: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>>;
+                    recall: z.ZodOptional<z.ZodObject<{
+                        value: z.ZodNumber;
+                        vsLabel: z.ZodString;
+                        tone: z.ZodEnum<{
+                            ok: "ok";
+                            bad: "bad";
+                            neutral: "neutral";
+                        }>;
+                        betterIsLower: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            classRows: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                accuracy: z.ZodOptional<z.ZodNumber>;
+                precision: z.ZodNumber;
+                recall: z.ZodNumber;
+                f1: z.ZodOptional<z.ZodNumber>;
+                fpr: z.ZodOptional<z.ZodNumber>;
+                vsLabel: z.ZodString;
+                vsDelta: z.ZodNullable<z.ZodNumber>;
+                vsTone: z.ZodEnum<{
+                    ok: "ok";
+                    bad: "bad";
+                    neutral: "neutral";
+                }>;
+                deltas: z.ZodOptional<z.ZodObject<{
+                    accuracy: z.ZodOptional<z.ZodObject<{
+                        value: z.ZodNumber;
+                        vsLabel: z.ZodString;
+                        tone: z.ZodEnum<{
+                            ok: "ok";
+                            bad: "bad";
+                            neutral: "neutral";
+                        }>;
+                        betterIsLower: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>>;
+                    precision: z.ZodOptional<z.ZodObject<{
+                        value: z.ZodNumber;
+                        vsLabel: z.ZodString;
+                        tone: z.ZodEnum<{
+                            ok: "ok";
+                            bad: "bad";
+                            neutral: "neutral";
+                        }>;
+                        betterIsLower: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>>;
+                    recall: z.ZodOptional<z.ZodObject<{
+                        value: z.ZodNumber;
+                        vsLabel: z.ZodString;
+                        tone: z.ZodEnum<{
+                            ok: "ok";
+                            bad: "bad";
+                            neutral: "neutral";
+                        }>;
+                        betterIsLower: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            vsPrevLabel: z.ZodString;
+        }, z.core.$strip>>;
+        errorPatterns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            percent: z.ZodNumber;
+            title: z.ZodString;
+            detail: z.ZodString;
+            count: z.ZodObject<{
+                hit: z.ZodNumber;
+                total: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>>>;
+        improvementSuggestions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            section: z.ZodString;
+            title: z.ZodString;
+            detail: z.ZodOptional<z.ZodString>;
+            priority: z.ZodOptional<z.ZodEnum<{
+                high: "high";
+                medium: "medium";
+                low: "low";
+            }>>;
+        }, z.core.$strip>>>;
+        promptDiff: z.ZodOptional<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            fromText: z.ZodString;
+            toText: z.ZodString;
+            lines: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    hunk: "hunk";
+                    add: "add";
+                    del: "del";
+                    ctx: "ctx";
+                }>;
+                text: z.ZodString;
+                lineNumber: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        stream: z.ZodOptional<z.ZodObject<{
+            stage: z.ZodString;
+            analysisModel: z.ZodString;
+            segments: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    observation: "observation";
+                    hypothesis: "hypothesis";
+                    rewrite: "rewrite";
+                    plain: "plain";
+                }>;
+                text: z.ZodString;
+            }, z.core.$strip>>;
+            showCursor: z.ZodBoolean;
+        }, z.core.$strip>>;
+        summaryFallback: z.ZodOptional<z.ZodString>;
+        collapsed: z.ZodOptional<z.ZodBoolean>;
+        promptVersionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        experimentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        promptLink: z.ZodOptional<z.ZodString>;
+        experimentLink: z.ZodOptional<z.ZodString>;
+        totalElapsed: z.ZodOptional<z.ZodString>;
+        totalCost: z.ZodOptional<z.ZodString>;
+        steps: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            step: z.ZodEnum<{
+                experiment: "experiment";
+                error_analysis: "error_analysis";
+                generate_prompt: "generate_prompt";
+            }>;
+            status: z.ZodEnum<{
+                success: "success";
+                failed: "failed";
+                pending: "pending";
+                running: "running";
+                skipped: "skipped";
+            }>;
+            errorClass: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            errorMessage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            startedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            finishedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            runResultId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            experimentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>;
+        goalChips: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            targetText: z.ZodString;
+            currentText: z.ZodString;
+            achieved: z.ZodEnum<{
+                hit: "hit";
+                miss: "miss";
+            }>;
+        }, z.core.$strip>>>;
+        autoPatched: z.ZodOptional<z.ZodBoolean>;
+        patchedVariables: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    baselineMetrics: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodNumber;
+        betterIsLower: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    goalProgress: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        targetText: z.ZodString;
+        currentText: z.ZodString;
+        achieved: z.ZodEnum<{
+            hit: "hit";
+            miss: "miss";
+            critical: "critical";
+        }>;
+        percent: z.ZodNumber;
+    }, z.core.$strip>>>;
+    bestVersion: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        promptRef: z.ZodString;
+        promptVersion: z.ZodString;
+        generatedAtRoundLabel: z.ZodString;
+        generatedAtRoundIndex: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        metrics: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodNumber;
+            tone: z.ZodOptional<z.ZodEnum<{
+                ok: "ok";
+                bad: "bad";
+                neutral: "neutral";
+            }>>;
+        }, z.core.$strip>>;
+        experimentRef: z.ZodString;
+        promptVersionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        experimentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type OptimizationDevMockTimelineDto = z.infer<typeof optimizationDevMockTimelineSchema>;
+//# sourceMappingURL=optimization.dto.d.ts.map