import { z } from "zod";
type Schema<T> = z.ZodType<T, z.ZodTypeDef, unknown>;
export declare const SimulationAdapterKindSchema: z.ZodEnum<["local", "model-swarm", "mirofish"]>;
export type SimulationAdapterKind = z.infer<typeof SimulationAdapterKindSchema>;
export declare const SimulationModelProviderSchema: z.ZodEnum<["codex", "claude-code", "ollama", "openai-compatible", "anthropic-compatible", "deterministic"]>;
export type SimulationModelProvider = z.infer<typeof SimulationModelProviderSchema>;
export declare const SimulationExecutionModeSchema: z.ZodEnum<["live", "deterministic-fallback", "skipped"]>;
export type SimulationExecutionMode = z.infer<typeof SimulationExecutionModeSchema>;
export interface SimulationBudget {
    maxAgents: number;
    maxRounds: number;
    maxTokens: number;
    maxWallTimeMs: number;
    maxEstimatedCostUsd: number;
    allowLiveModels: boolean;
}
export declare const SimulationBudgetSchema: Schema<SimulationBudget>;
export interface SimulationUsage {
    inputTokens: number;
    outputTokens: number;
    estimatedCostUsd: number;
}
export declare const SimulationUsageSchema: Schema<SimulationUsage>;
export interface SimulationModelProfile {
    id: string;
    label: string;
    provider: SimulationModelProvider;
    model: string;
    reasoningEffort: string | null;
    enabled: boolean;
    available: boolean;
    source: "studio-harness" | "provider-env" | "local" | "fallback";
    requiresCredential: boolean;
    credentialEnv: string | null;
    baseUrl: string | null;
    command: string | null;
    notes: string[];
}
export declare const SimulationModelProfileSchema: Schema<SimulationModelProfile>;
export interface SimulationProviderRun {
    id: string;
    profileId: string;
    provider: SimulationModelProvider;
    model: string;
    status: "completed" | "failed" | "skipped";
    executionMode: SimulationExecutionMode;
    startedAt: string;
    completedAt: string;
    latencyMs: number;
    usage: SimulationUsage;
    error: string | null;
}
export declare const SimulationProviderRunSchema: Schema<SimulationProviderRun>;
export interface SimulationScorecard {
    adoption: number;
    resistance: number;
    confidence: number;
    risk: number;
    evidenceCoverage: number;
    modelDiversity: number;
    recommendations: string[];
}
export declare const SimulationScorecardSchema: Schema<SimulationScorecard>;
export interface SimulationTranscript {
    id: string;
    runId: string;
    scenarioId: string;
    roundId: string | null;
    agentId: string | null;
    modelProfileId: string;
    prompt: string;
    response: string;
    evidenceFindingIds: string[];
    startedAt: string;
    completedAt: string;
    usage: SimulationUsage;
    fallback: boolean;
}
export declare const SimulationTranscriptSchema: Schema<SimulationTranscript>;
export interface SimulationRound {
    id: string;
    runId: string;
    scenarioId: string;
    index: number;
    phase: "briefing" | "debate" | "variable-injection" | "synthesis";
    status: "running" | "completed" | "failed";
    startedAt: string;
    completedAt: string | null;
    agentIds: string[];
    eventIds: string[];
    transcriptIds: string[];
    scorecard: SimulationScorecard;
}
export declare const SimulationRoundSchema: Schema<SimulationRound>;
export interface SimulationVariable {
    id: string;
    name: string;
    value: string;
    description: string;
}
export declare const SimulationVariableSchema: Schema<SimulationVariable>;
export interface SimulationAgent {
    id: string;
    name: string;
    role: string;
    goals: string[];
    painPoints: string[];
    behaviors: string[];
    source: string;
    evidenceFindingIds: string[];
    influence: number;
}
export declare const SimulationAgentSchema: Schema<SimulationAgent>;
export type SimulationGraphNodeKind = "agent" | "finding" | "theme" | "risk" | "opportunity" | "contradiction" | "metric" | "variable" | "outcome";
export interface SimulationGraphNode {
    id: string;
    label: string;
    kind: SimulationGraphNodeKind;
    summary: string;
    evidenceFindingIds: string[];
    weight: number;
}
export declare const SimulationGraphNodeSchema: Schema<SimulationGraphNode>;
export type SimulationGraphEdgeKind = "represents" | "evidence" | "influence" | "conflict" | "variable" | "outcome";
export interface SimulationGraphEdge {
    id: string;
    source: string;
    target: string;
    kind: SimulationGraphEdgeKind;
    label: string;
    strength: number;
}
export declare const SimulationGraphEdgeSchema: Schema<SimulationGraphEdge>;
export interface SimulationGraph {
    nodes: SimulationGraphNode[];
    edges: SimulationGraphEdge[];
}
export declare const SimulationGraphSchema: Schema<SimulationGraph>;
export interface ProductSimulationScenario {
    id: string;
    adapter: SimulationAdapterKind;
    name: string;
    hypothesis: string;
    createdAt: string;
    sourceSummary: {
        findings: number;
        themes: number;
        personas: number;
        risks: number;
        opportunities: number;
        metrics: number;
        qualityScore: number | null;
    };
    variables: SimulationVariable[];
    agents: SimulationAgent[];
    graph: SimulationGraph;
    metadata: {
        source: "memoire-research";
        evidenceFindingIds: string[];
        licenseBoundary: "clean-room";
        modelProfiles: SimulationModelProfile[];
        budget: SimulationBudget;
    };
}
export declare const ProductSimulationScenarioSchema: Schema<ProductSimulationScenario>;
export type SimulationEventKind = "agent-reaction" | "variable-shift" | "risk-signal" | "opportunity-signal" | "outcome" | "interview" | "round-start" | "model-response" | "round-summary" | "scorecard" | "model-disagreement";
export type SimulationImpact = "positive" | "negative" | "mixed" | "neutral";
export interface SimulationEvent {
    id: string;
    runId: string;
    scenarioId: string;
    kind: SimulationEventKind;
    timestamp: string;
    title: string;
    summary: string;
    impact: SimulationImpact;
    agentId?: string;
    evidenceFindingIds: string[];
    data?: Record<string, unknown>;
}
export declare const SimulationEventSchema: Schema<SimulationEvent>;
export interface SimulationInterviewResult {
    id: string;
    runId: string;
    agentId: string;
    agentName: string;
    prompt: string;
    answer: string;
    evidenceFindingIds: string[];
    createdAt: string;
}
export declare const SimulationInterviewResultSchema: Schema<SimulationInterviewResult>;
export interface SimulationRun {
    id: string;
    scenarioId: string;
    adapter: SimulationAdapterKind;
    status: "prepared" | "running" | "completed" | "stopped" | "failed";
    startedAt: string;
    completedAt: string | null;
    eventCount: number;
    events: SimulationEvent[];
    interviews: SimulationInterviewResult[];
    budget: SimulationBudget;
    modelProfiles: SimulationModelProfile[];
    providerRuns: SimulationProviderRun[];
    rounds: SimulationRound[];
    transcripts: SimulationTranscript[];
    scorecard: SimulationScorecard;
    costs: SimulationUsage;
    error: string | null;
}
export declare const SimulationRunSchema: Schema<SimulationRun>;
export interface SimulationReport {
    id: string;
    runId: string;
    scenarioId: string;
    scenarioName: string;
    hypothesis: string;
    generatedAt: string;
    summary: string;
    recommendations: string[];
    risks: string[];
    unresolvedAssumptions: string[];
    evidenceFindingIds: string[];
    events: SimulationEvent[];
    interviews: SimulationInterviewResult[];
    budget: SimulationBudget;
    modelProfiles: SimulationModelProfile[];
    providerRuns: SimulationProviderRun[];
    rounds: SimulationRound[];
    transcripts: SimulationTranscript[];
    scorecard: SimulationScorecard;
    costs: SimulationUsage;
    comparisons: string[];
}
export declare const SimulationReportSchema: Schema<SimulationReport>;
export interface SimulationComparison {
    id: string;
    generatedAt: string;
    runIds: string[];
    winnerRunId: string | null;
    summary: string;
    runs: Array<{
        runId: string;
        scenarioId: string;
        score: number;
        adoption: number;
        risk: number;
        confidence: number;
        estimatedCostUsd: number;
    }>;
}
export declare const SimulationComparisonSchema: Schema<SimulationComparison>;
export interface SimulationPrepareResult {
    adapter: SimulationAdapterKind;
    scenario: ProductSimulationScenario;
    warnings: string[];
}
export interface SimulationInterviewRequest {
    agentId: string;
    prompt: string;
}
export interface SimulationAdapter {
    prepare(scenario: ProductSimulationScenario): Promise<SimulationPrepareResult>;
    start(scenarioId: string): Promise<SimulationRun>;
    stream(runId: string): AsyncIterable<SimulationEvent>;
    interview(runId: string, request: SimulationInterviewRequest): Promise<SimulationInterviewResult>;
    stop(runId: string): Promise<SimulationRun>;
    exportReport(runId: string): Promise<SimulationReport>;
}
export interface ProductSpecImpact {
    title: string;
    scenarioId: string;
    runId: string;
    researchBacking: string[];
    sections: Array<{
        title: string;
        body: string;
    }>;
}
export {};