import type { components, paths } from '../generated/api.js';
import type { ServiceId, SimulationRunId, SimulationSessionId } from '../core/branded-types.js';
import { WorkspaceScopedResource } from './base.js';
type CreateSimulationSessionRequest = components['schemas']['CreateSessionRequest'];
export type ListSimulationRunsParams = NonNullable<paths['/v1/{workspace_id}/simulations/runs']['get']['parameters']['query']>;
/**
 * Simulations — interactive agent testing via the Playground.
 *
 * Create a session to get the agent's greeting, then step through the
 * conversation turn by turn. Get LLM-generated caller suggestions to
 * guide exploratory testing.
 */
export declare class SimulationsResource extends WorkspaceScopedResource {
    /** Start a simulation session — returns the agent's greeting and initial snapshot */
    createSession(body: CreateSimulationSessionRequest): Promise<{
        greeting: string;
        is_terminal: boolean;
        session_id: string;
        snapshot: {
            [x: string]: unknown;
            context_graph_topology?: {
                [x: string]: string;
            }[] | undefined;
            conversation_history?: {
                [x: string]: unknown;
            }[] | undefined;
            current_state: {
                [x: string]: unknown;
                action_guidelines?: string[] | undefined;
                actions?: {
                    [x: string]: unknown;
                }[] | undefined;
                boundary_constraints?: string[] | undefined;
                exit_conditions?: {
                    [x: string]: unknown;
                }[] | undefined;
                guardrails?: {
                    [x: string]: unknown;
                }[] | undefined;
                name: string;
                objective?: string | undefined;
                tools?: string[] | undefined;
                type: string;
            };
            reachable_states?: {
                [x: string]: unknown;
            }[] | undefined;
            state_transitions?: string[][] | undefined;
            states_visited?: string[] | undefined;
            terminal_reached?: boolean | undefined;
            terminal_state?: string | null | undefined;
            tools_called?: string[] | undefined;
            total_turns?: number | undefined;
            turn_policy?: {
                barge_in_enabled?: boolean | undefined;
                block_forward_call?: boolean | undefined;
                block_forward_call_after_turns?: number | undefined;
                context_strategy?: string | undefined;
                greeting_shield_s?: number | undefined;
                safety_response?: string | undefined;
            } | undefined;
        };
    } & import("../index.js").ResponseMetadata>;
    /** Get the current snapshot of a session */
    getSession(sessionId: SimulationSessionId | string): Promise<{
        [x: string]: unknown;
        context_graph_topology?: {
            [x: string]: string;
        }[] | undefined;
        conversation_history?: {
            [x: string]: unknown;
        }[] | undefined;
        current_state: {
            [x: string]: unknown;
            action_guidelines?: string[] | undefined;
            actions?: {
                [x: string]: unknown;
            }[] | undefined;
            boundary_constraints?: string[] | undefined;
            exit_conditions?: {
                [x: string]: unknown;
            }[] | undefined;
            guardrails?: {
                [x: string]: unknown;
            }[] | undefined;
            name: string;
            objective?: string | undefined;
            tools?: string[] | undefined;
            type: string;
        };
        reachable_states?: {
            [x: string]: unknown;
        }[] | undefined;
        state_transitions?: string[][] | undefined;
        states_visited?: string[] | undefined;
        terminal_reached?: boolean | undefined;
        terminal_state?: string | null | undefined;
        tools_called?: string[] | undefined;
        total_turns?: number | undefined;
        turn_policy?: {
            barge_in_enabled?: boolean | undefined;
            block_forward_call?: boolean | undefined;
            block_forward_call_after_turns?: number | undefined;
            context_strategy?: string | undefined;
            greeting_shield_s?: number | undefined;
            safety_response?: string | undefined;
        } | undefined;
    } & import("../index.js").ResponseMetadata>;
    /** Delete a simulation session */
    deleteSession(sessionId: SimulationSessionId | string): Promise<{
        status: "destroyed";
    } & import("../index.js").ResponseMetadata>;
    /**
     * Send a caller utterance and advance the session by one turn.
     * Returns the agent's response observation and updated snapshot.
     */
    step(body: components['schemas']['StepRequest']): Promise<{
        observation: {
            agent_text: string;
            empathy_tier?: number | undefined;
            engine_ms?: number | null | undefined;
            has_pause?: boolean | undefined;
            is_terminal: boolean;
            nav_ms?: number | null | undefined;
            selected_action?: string | null | undefined;
            state_after: string;
            state_before: string;
            state_changed: boolean;
            tool_call_details?: {
                call_id?: string | undefined;
                input?: string | undefined;
                result?: string | undefined;
                succeeded?: boolean | undefined;
                tool_name: string;
            }[] | undefined;
            tools_called?: string[] | undefined;
        };
        snapshot: {
            [x: string]: unknown;
            context_graph_topology?: {
                [x: string]: string;
            }[] | undefined;
            conversation_history?: {
                [x: string]: unknown;
            }[] | undefined;
            current_state: {
                [x: string]: unknown;
                action_guidelines?: string[] | undefined;
                actions?: {
                    [x: string]: unknown;
                }[] | undefined;
                boundary_constraints?: string[] | undefined;
                exit_conditions?: {
                    [x: string]: unknown;
                }[] | undefined;
                guardrails?: {
                    [x: string]: unknown;
                }[] | undefined;
                name: string;
                objective?: string | undefined;
                tools?: string[] | undefined;
                type: string;
            };
            reachable_states?: {
                [x: string]: unknown;
            }[] | undefined;
            state_transitions?: string[][] | undefined;
            states_visited?: string[] | undefined;
            terminal_reached?: boolean | undefined;
            terminal_state?: string | null | undefined;
            tools_called?: string[] | undefined;
            total_turns?: number | undefined;
            turn_policy?: {
                barge_in_enabled?: boolean | undefined;
                block_forward_call?: boolean | undefined;
                block_forward_call_after_turns?: number | undefined;
                context_strategy?: string | undefined;
                greeting_shield_s?: number | undefined;
                safety_response?: string | undefined;
            } | undefined;
        };
    } & import("../index.js").ResponseMetadata>;
    /**
     * Get LLM-generated caller message suggestions for the current session state.
     * Helps exploratory testing by suggesting realistic next caller turns.
     */
    recommend(body: components['schemas']['RecommendRequest']): Promise<{
        suggestions: string[];
    } & import("../index.js").ResponseMetadata>;
    /** Get AI-generated call intelligence for a completed session */
    getIntelligence(sessionId: SimulationSessionId | string): Promise<{
        intelligence: {
            [x: string]: unknown;
        };
        session_id: string;
    } & import("../index.js").ResponseMetadata>;
    /**
     * Multi-session simulation runs — orchestrate a batch of scenarios against
     * a service to compute coverage and surface regressions. Use this when you
     * want to compare branch behavior or measure drift between versions.
     *
     * @beta New in this release; surface may evolve.
     */
    readonly runs: {
        /** List simulation runs in the workspace */
        list: (params?: ListSimulationRunsParams) => Promise<{
            [x: string]: unknown;
        } & import("../index.js").ResponseMetadata>;
        /** Create a new simulation run */
        create: (body: components["schemas"]["CreateRunRequest"]) => Promise<{
            [x: string]: unknown;
        } & import("../index.js").ResponseMetadata>;
        /** Get a simulation run with its scenarios + status */
        get: (runId: SimulationRunId | string) => Promise<{
            branch_name?: string | null | undefined;
            bridge_request?: {
                [x: string]: unknown;
            } | null | undefined;
            completed_at?: string | null | undefined;
            created_at?: string | null | undefined;
            eval_error_count?: number | undefined;
            eval_fail_count?: number | undefined;
            eval_pass_count?: number | undefined;
            eval_result_count?: number | undefined;
            eval_results?: {
                actual?: unknown | null;
                assertion_kind?: string | null | undefined;
                case_id?: string | null | undefined;
                created_at?: string | null | undefined;
                definition?: {
                    [x: string]: unknown;
                } | undefined;
                details?: {
                    [x: string]: unknown;
                } | undefined;
                eval_key: string;
                eval_type: "assertion" | "metric";
                expected?: unknown | null;
                id?: string | null | undefined;
                justification?: string | null | undefined;
                metric_key?: string | null | undefined;
                passed?: boolean | null | undefined;
                rationale?: string | null | undefined;
                references?: number[] | undefined;
                run_id?: string | null | undefined;
                score?: number | null | undefined;
                session_id?: string | null | undefined;
                status: "passed" | "failed" | "pending" | "skipped" | "error";
            }[] | undefined;
            id: string;
            metric_result_count?: number | undefined;
            metric_status?: "pending" | "available" | "unavailable" | undefined;
            metrics_last_checked_at?: string | null | undefined;
            objective?: string | null | undefined;
            scenarios?: {
                [x: string]: unknown;
            }[] | null | undefined;
            service_id: string;
            snapshot?: {
                [x: string]: unknown;
            } | null | undefined;
            status: "running" | "completed" | "failed";
            tags?: string[] | undefined;
            total_scenarios_requested?: number | null | undefined;
            total_sessions?: number | undefined;
            total_turns?: number | undefined;
        } & import("../index.js").ResponseMetadata>;
        /** Mark a run as complete (used by the harness once all sessions finish) */
        complete: (runId: SimulationRunId | string) => Promise<{
            [x: string]: string;
        } & import("../index.js").ResponseMetadata>;
        /** Spin up a session under a run (single scenario inside the run's batch) */
        createSession: (runId: SimulationRunId | string, body: CreateSimulationSessionRequest) => Promise<{
            greeting: string;
            is_terminal: boolean;
            session_id: string;
            snapshot: {
                [x: string]: unknown;
                context_graph_topology?: {
                    [x: string]: string;
                }[] | undefined;
                conversation_history?: {
                    [x: string]: unknown;
                }[] | undefined;
                current_state: {
                    [x: string]: unknown;
                    action_guidelines?: string[] | undefined;
                    actions?: {
                        [x: string]: unknown;
                    }[] | undefined;
                    boundary_constraints?: string[] | undefined;
                    exit_conditions?: {
                        [x: string]: unknown;
                    }[] | undefined;
                    guardrails?: {
                        [x: string]: unknown;
                    }[] | undefined;
                    name: string;
                    objective?: string | undefined;
                    tools?: string[] | undefined;
                    type: string;
                };
                reachable_states?: {
                    [x: string]: unknown;
                }[] | undefined;
                state_transitions?: string[][] | undefined;
                states_visited?: string[] | undefined;
                terminal_reached?: boolean | undefined;
                terminal_state?: string | null | undefined;
                tools_called?: string[] | undefined;
                total_turns?: number | undefined;
                turn_policy?: {
                    barge_in_enabled?: boolean | undefined;
                    block_forward_call?: boolean | undefined;
                    block_forward_call_after_turns?: number | undefined;
                    context_strategy?: string | undefined;
                    greeting_shield_s?: number | undefined;
                    safety_response?: string | undefined;
                } | undefined;
            };
        } & import("../index.js").ResponseMetadata>;
    };
    /**
     * Bridge — convert recorded production calls into simulation scenarios so
     * they can be replayed against a candidate version. ``plan`` returns a
     * preview of which calls would be selected; ``run`` executes the plan.
     */
    readonly bridge: {
        /** Plan a bridge run — returns the candidate scenarios without executing */
        plan: (body: components["schemas"]["BridgePlanRequest"]) => Promise<{
            available_states?: string[] | undefined;
            available_tools?: string[] | undefined;
            rationale: string;
            target_spec: {
                completion_criteria?: {
                    state_based?: string[] | undefined;
                    tool_based?: string[] | undefined;
                } | undefined;
                desired_states?: string[] | undefined;
                non_desired_states?: {
                    mode?: "hard" | "soft" | undefined;
                    state: string;
                }[] | undefined;
                ordered_pathways?: {
                    id: string;
                    sequence: string[];
                }[] | undefined;
            };
        } & import("../index.js").ResponseMetadata>;
        /** Execute a bridge run and return the resulting run handle */
        run: (body: components["schemas"]["BridgeRequest"]) => Promise<{
            case_ids?: string[] | undefined;
            inferred_target_spec?: {
                completion_criteria?: {
                    state_based?: string[] | undefined;
                    tool_based?: string[] | undefined;
                } | undefined;
                desired_states?: string[] | undefined;
                non_desired_states?: {
                    mode?: "hard" | "soft" | undefined;
                    state: string;
                }[] | undefined;
                ordered_pathways?: {
                    id: string;
                    sequence: string[];
                }[] | undefined;
            } | null | undefined;
            inferred_target_spec_rationale?: string | null | undefined;
            run_id: string;
            scenarios: {
                case_id?: string | null | undefined;
                description: string;
                initial_message: string;
                persona?: {
                    background?: string | undefined;
                    communication_style?: string | undefined;
                    default_language?: string | undefined;
                    name?: string | undefined;
                    role?: string | undefined;
                } | undefined;
                scenario_instructions: string;
                temperament?: string | undefined;
            }[];
            status: "running" | "completed" | "failed";
        } & import("../index.js").ResponseMetadata>;
    };
    /**
     * Per-service simulation views — graph of explored conversation paths,
     * recorded sessions, and per-turn telemetry. Used by the developer console's
     * coverage tab to visualize what scenarios have been exercised.
     */
    readonly services: {
        /** Get the conversation graph (nodes/edges) for a service */
        getGraph: (serviceId: ServiceId | string) => Promise<{
            [x: string]: unknown;
        } & import("../index.js").ResponseMetadata>;
        /** Reset / delete the service's accumulated graph */
        deleteGraph: (serviceId: ServiceId | string) => Promise<{
            [x: string]: unknown;
        } & import("../index.js").ResponseMetadata>;
        /** Get the set of explored conversation paths through the graph */
        getGraphPaths: (serviceId: ServiceId | string) => Promise<{
            [x: string]: unknown;
        } & import("../index.js").ResponseMetadata>;
        /** List recorded sessions for the service */
        listSessions: (serviceId: ServiceId | string) => Promise<{
            [x: string]: unknown;
        } & import("../index.js").ResponseMetadata>;
        /** List per-turn observations for the service */
        listTurns: (serviceId: ServiceId | string) => Promise<{
            [x: string]: unknown;
        } & import("../index.js").ResponseMetadata>;
    };
}
export {};
//# sourceMappingURL=simulations.d.ts.map