import { Question, CandidateAnswer, EvaluationResult, Rubric, EvaluationTurn, FollowUpDifficulty, SessionState, RubricDimensionInput, InterviewEventEmitter, AIProviderAdapter, FollowUpEngineConfig, SynthesisResult } from '@interview-sdk/core';
import * as react from 'react';
import { CSSProperties } from 'react';

interface TranscriptEntry {
    question: Question;
    prompt: string;
    isFollowUp: boolean;
    answer: CandidateAnswer;
    evaluation: EvaluationResult;
}
/**
 * Low-risk, opt-in integrity signals — tab-switch and paste-into-answer
 * counts, nothing biometric or behavioral. These are observations for a
 * human reviewer to weigh in context, not an automated cheating verdict; if
 * you track this, disclose it to candidates (most interview platforms that
 * track tab-switching say so up front).
 */
interface IntegritySignals {
    /** Number of times the browser tab/window lost visibility while the interview was in progress. */
    tabSwitchCount: number;
    /** Wall-clock timestamp (ms since epoch) of each tab-switch-away event. */
    tabSwitchTimestamps: number[];
    /** Every paste event into an answer field — character length of what was pasted, and when. */
    pasteEvents: Array<{
        length: number;
        timestamp: number;
    }>;
}
interface InterviewReport {
    sessionId: string;
    totalScore: number;
    /** Only has an entry for a dimension at least one question actually assessed (see `Question.dimensions`) — one no question addressed is simply absent, not present at 0. */
    dimensionAverages: Record<string, number>;
    strengths: string[];
    weaknesses: string[];
    missedConcepts: string[];
    transcript: TranscriptEntry[];
    /** Only present when the caller opted into tracking (e.g. InterviewWidget's trackIntegritySignals prop). */
    integritySignals?: IntegritySignals;
}
/** Also used by LiveSignals to mark where a "pass" begins on its meters — one definition of "strong" shared across the live view and the final report. */
declare const STRENGTH_THRESHOLD = 75;
/**
 * Builds a heuristic report from rubric scores and concept coverage already
 * present in the transcript. Strengths/weaknesses/recommendations are
 * derived from dimension averages and missed concepts, not AI-generated
 * commentary — there is no such call in this SDK today.
 */
declare function buildReport(sessionId: string, rubric: Rubric, transcript: TranscriptEntry[], integritySignals?: IntegritySignals): InterviewReport;

interface ProcessAnswerInput {
    question: Question;
    rubric: Rubric;
    answer: CandidateAnswer;
    previousTurns: EvaluationTurn[];
    currentFollowUpDepth: number;
    askedFollowUps: string[];
}
interface ProcessAnswerFollowUp {
    prompt: string;
    difficulty?: FollowUpDifficulty;
    targetsMissedConcepts: string[];
}
interface ProcessAnswerResult {
    evaluation: EvaluationResult;
    followUp?: ProcessAnswerFollowUp;
}
/**
 * Abstracts over Client Mode (evaluate/follow-up run in the browser via an
 * injected AIProviderAdapter) and Server Mode (a single round trip to the
 * developer's own backend, which does the same work using
 * @interview-sdk/server). InterviewWidget/useInterview only ever talk to
 * this interface, never to the mode-specific detail.
 */
interface InterviewProcessor {
    processAnswer(input: ProcessAnswerInput): Promise<ProcessAnswerResult>;
}

interface UseInterviewOptions {
    questions: Question[];
    rubric: RubricDimensionInput[];
    processor: InterviewProcessor;
    maxFollowUpDepth?: number;
    sessionTimeoutMs?: number;
    onSessionEnd?: (report: InterviewReport) => void;
    /** Resume a session from a snapshot returned by this same hook's getSnapshot() — e.g. one restored after a page refresh or loaded back from your own backend. Only read once, on mount. */
    initialSnapshot?: InterviewSnapshot;
    /** Read once whenever a report is built (on completion or voluntary end) and attached to it as `integritySignals` — e.g. from useIntegritySignals() in @interview-sdk/react. Omit if you don't track this. */
    getIntegritySignals?: () => IntegritySignals;
}
interface SubmitAnswerOptions {
    isSkipped?: boolean;
    isSilence?: boolean;
}
/** Everything needed to resume this exact session elsewhere — persist it (localStorage, your own backend) and pass it back as `initialSnapshot` to pick up where it left off after a refresh or disconnect. */
interface InterviewSnapshot {
    flowState: SessionState;
    transcript: TranscriptEntry[];
}
interface UseInterviewResult {
    status: SessionState['status'];
    /** Wall-clock time the session actually started, for a live elapsed-time display. Undefined until start() is called. */
    startedAt: number | undefined;
    currentQuestion: Question | undefined;
    currentPrompt: string | undefined;
    isFollowUpPrompt: boolean;
    transcript: TranscriptEntry[];
    isProcessing: boolean;
    error: Error | undefined;
    report: InterviewReport | undefined;
    start: () => void;
    pause: () => void;
    resume: () => void;
    /** Voluntarily ends the session before every question has been answered, building a report from whatever's been answered so far. */
    endInterview: () => void;
    submitAnswer: (text: string, opts?: SubmitAnswerOptions) => Promise<void>;
    retryLastAnswer: () => Promise<void>;
    /** A serializable snapshot of the whole session right now — see InterviewSnapshot. */
    getSnapshot: () => InterviewSnapshot;
    /** The underlying typed event emitter (sessionStart/sessionPause/sessionResume/sessionEnd/sessionExpired/questionAdvance/followUpGenerated/scoreComputed) — subscribe for your own analytics or logging, independent of the UI. */
    events: InterviewEventEmitter;
}
declare function useInterview(options: UseInterviewOptions): UseInterviewResult;

/**
 * Client Mode: evaluation and follow-up generation run directly in the
 * browser against a developer-supplied AIProviderAdapter. Prototyping only
 * — see InterviewWidget's production guard (§10).
 */
declare class ClientModeProcessor implements InterviewProcessor {
    private readonly adapter;
    private readonly evaluationEngine;
    private readonly followUpEngine;
    constructor(adapter: AIProviderAdapter, followUpConfig?: FollowUpEngineConfig);
    processAnswer(input: ProcessAnswerInput): Promise<ProcessAnswerResult>;
}

declare class ServerModeRequestError extends Error {
}
interface ServerModeProcessorConfig {
    /**
     * URL to POST each answer to. The developer's `@interview-sdk/server`
     * route handles evaluation and follow-up generation server-side, so AI
     * keys and score integrity never reach the browser. Defaults to
     * `/api/interview/answer`.
     */
    endpoint?: string;
    /** Override fetch (e.g. for testing). */
    fetchImpl?: typeof fetch;
    /** Extra headers to send with every request (e.g. a session/auth token). */
    headers?: Record<string, string>;
}
/**
 * Server Mode: each answer is sent in a single request to the developer's
 * own backend, which evaluates it (using the same @interview-sdk/core
 * engines, server-side) and returns the result. This is the wire contract
 * @interview-sdk/server (Phase 5) implements — see that package's docs for
 * the authoritative shape once it exists.
 */
declare class ServerModeProcessor implements InterviewProcessor {
    private readonly endpoint;
    private readonly fetchImpl;
    private readonly headers;
    constructor(config?: ServerModeProcessorConfig);
    processAnswer(input: ProcessAnswerInput): Promise<ProcessAnswerResult>;
}

interface AudioLevelMeterProps {
    /** Normalized 0..1 amplitude samples — one bar per entry. */
    levels: number[];
    /** Color/role of the meter: the AI's voice, or the candidate's mic. */
    variant: 'speaking' | 'listening';
    /** Renders a calm ambient pulse instead of reactive bars — used whenever live amplitude data isn't available. */
    isIdle?: boolean;
    className?: string;
}
/**
 * Purely presentational amplitude bars, shared by QuestionAudio (AI
 * speaking) and MicButton (candidate listening). Contains no Web Audio
 * code — callers own sampling the real data.
 */
declare function AudioLevelMeter({ levels, variant, isIdle, className }: AudioLevelMeterProps): react.JSX.Element;

interface FeedbackNoteProps {
    transcript: TranscriptEntry[];
    /** Label shown above the note. Defaults to 'AI Interviewer', matching the stage tile's own label. */
    assistantName?: string;
}
/**
 * A chat-style note surfacing the AI's own rationale for the most recent
 * scored answer — evaluation.rationale is a real field populated by the
 * evaluation engine's model response (see @interview-sdk/core), not
 * fabricated UI copy. Renders nothing when no scored entry has a rationale
 * yet (e.g. a skipped/silent answer, or an adapter that doesn't return one).
 */
declare function FeedbackNote({ transcript, assistantName }: FeedbackNoteProps): react.JSX.Element | null;

interface InterviewLobbyProps {
    /** Begins the real interview session — typically useInterview's start(). */
    onJoin: () => void;
    /** Whether this interview uses voice at all (a transcribe function was given to InterviewWidget). Text-only mode skips the mic check entirely. */
    voiceEnabled: boolean;
    totalQuestions?: number;
    /**
     * Requests a live mic stream purely to preview it — never produces a
     * recording, distinct from MicButton's Blob-producing AudioRecorder.
     * Defaults to a real getUserMedia({ audio: true }) call. Injectable for
     * testing.
     */
    requestMicStream?: () => Promise<MediaStream>;
    /** Overrides the primary action's visible text. Defaults to 'Start interview'. */
    joinLabel?: string;
}
/**
 * A pre-join screen — a mic check plus a "ready to begin" confirmation,
 * matching the lobby real video-call/interview platforms put candidates
 * through before a live session. The mic check is always optional: joining
 * never depends on it succeeding, matching this codebase's standing rule
 * that voice is an enhancement, never a blocker.
 */
declare function InterviewLobby({ onJoin, voiceEnabled, totalQuestions, requestMicStream, joinLabel, }: InterviewLobbyProps): react.JSX.Element;

interface InterviewProgressProps {
    questions: Question[];
    currentQuestion: Question | undefined;
    transcript: TranscriptEntry[];
}
/**
 * A running checklist of every question in the interview and where the
 * candidate is right now — built entirely from data useInterview already
 * exposes (questions + transcript + currentQuestion), no new session state.
 */
declare function InterviewProgress({ questions, currentQuestion, transcript }: InterviewProgressProps): react.JSX.Element;

interface LiveSignalsProps {
    rubric: Rubric;
    transcript: TranscriptEntry[];
}
/**
 * Live per-dimension score meters for the most recently answered question —
 * reads straight from the latest transcript entry's real dimensionScores,
 * the same evaluation data ScoreSummary uses for the final report. Renders
 * nothing until at least one answer has been scored.
 *
 * Styled as a vertical instrument cluster (think a mixing console's level
 * meters) rather than the horizontal "skill bar" almost every scoring UI
 * defaults to — each meter also carries a real tick at STRENGTH_THRESHOLD,
 * the same cutoff the final report uses to call a dimension a strength, so
 * "does this clear the bar" reads at a glance instead of requiring the
 * candidate or reviewer to do the comparison themselves.
 */
declare function LiveSignals({ rubric, transcript }: LiveSignalsProps): react.JSX.Element | null;

interface AudioRecorder {
    stop: () => Promise<Blob>;
    /**
     * The live MediaStream backing this recording, when available — enables
     * a real input-level meter on the SAME stream already feeding
     * MediaRecorder, never a second getUserMedia() request. Optional:
     * test-injected fake recorders can omit it and the live meter simply
     * doesn't render.
     */
    stream?: MediaStream;
}
interface MicButtonProps {
    /** Turns captured audio into text — typically a VoiceProviderAdapter's transcribe(). */
    transcribe: (audio: Blob) => Promise<string>;
    onTranscript: (text: string) => void;
    /**
     * Called on mic denial, capture failure, empty audio, or a transcription
     * error. The candidate always has the text input in QuestionCard as a
     * fallback — this button never needs to render its own.
     */
    onError?: (error: Error) => void;
    disabled?: boolean;
    label?: string;
    /** Injectable for testing; defaults to a real getUserMedia/MediaRecorder implementation. */
    createRecorder?: () => Promise<AudioRecorder>;
    /** Notified whenever recording starts/stops — informational only, not fired for the initial mount. */
    onRecordingChange?: (isRecording: boolean) => void;
    /** Promotes this control to the primary, inviting call-to-action (e.g. once it's the candidate's turn). Defaults to false — zero visual change for existing callers. */
    emphasized?: boolean;
    /** Live input-amplitude meter while recording, sourced from the same capture stream already feeding MediaRecorder. Defaults to true; renders nothing when no stream is available. */
    showLevelMeter?: boolean;
    /** Notified with the live amplitude data whenever it changes — lets a caller drive its own separate meter display (e.g. a self-view tile) instead of this button's own inline one. Informational only. */
    onLevelsChange?: (levels: number[], isSupported: boolean) => void;
}
declare function MicButton({ transcribe, onTranscript, onError, disabled, label, createRecorder, onRecordingChange, emphasized, showLevelMeter, onLevelsChange, }: MicButtonProps): react.JSX.Element;

interface QuestionAudioProps {
    /** The prompt text to speak — re-synthesized whenever this changes. */
    text: string;
    /** Turns text into speech — typically a VoiceProviderAdapter's synthesize(). */
    synthesize: (text: string) => Promise<SynthesisResult>;
    /**
     * Called when synthesis fails or playback is unavailable. The question
     * text is always visible in QuestionCard regardless — this is a bonus
     * audio channel, never the only way to get the question.
     */
    onError?: (error: Error) => void;
    /** Attempts to play as soon as audio is ready. Defaults to true. */
    autoPlay?: boolean;
    /** Fires on the <audio> element's real 'play' event — turn-state signal for a caller coordinating a mic control. */
    onPlaybackStart?: () => void;
    /** Fires on the <audio> element's real 'pause'/'ended' events. */
    onPlaybackEnd?: () => void;
    /** Shows a live playback-amplitude presence indicator next to the control. Defaults to true; gracefully falls back to an ambient pulse wherever Web Audio decoding isn't available. */
    showLevelMeter?: boolean;
    /** Mutes the underlying <audio> element's output — playback (and onPlaybackStart/onPlaybackEnd turn-state) still runs normally, only the sound is silenced. Defaults to false. */
    muted?: boolean;
    /** A short label (e.g. "AI") centered in the orb while not speaking, so the tile reads as an identity, not a bare circle — replaced by the live level meter once playback actually starts. Omit for the orb's previous meter-only behavior. */
    avatarLabel?: string;
}
/**
 * Speaks a question aloud via a developer-supplied synthesize() and always
 * offers a manual control — autoplay is attempted but browsers block it
 * without a prior user gesture, so a blocked attempt just falls back to a
 * "Play question" button instead of failing silently.
 */
declare function QuestionAudio({ text, synthesize, onError, autoPlay, onPlaybackStart, onPlaybackEnd, showLevelMeter, muted, avatarLabel, }: QuestionAudioProps): react.JSX.Element | null;

interface QuestionCardProps {
    prompt: string;
    questionNumber: number;
    totalQuestions: number;
    isFollowUp?: boolean;
    /** A short topic tag shown on the question panel and stage (e.g. the current question's first concept). Omit for no tag. */
    topic?: string;
    /** The candidate's own display name — used for the candidate tile's label and avatar initial. Defaults to "You". */
    candidateName?: string;
    onSubmit: (text: string) => void;
    onSkip?: () => void;
    onRequestHint?: () => void;
    hint?: string;
    isSubmitting?: boolean;
    disabled?: boolean;
    /**
     * Enables the mic button, appending each transcript into the answer text.
     * Omit for text-only mode (the accessible default — a text input is
     * always present regardless of this prop).
     */
    transcribe?: (audio: Blob) => Promise<string>;
    /**
     * Enables speaking the prompt aloud (autoplayed, with a manual
     * play/replay fallback) — typically a VoiceProviderAdapter's
     * synthesize(). Omit for a silent, text-only prompt (the accessible
     * default — the prompt is always shown as text regardless of this prop).
     */
    synthesize?: (text: string) => Promise<SynthesisResult>;
    onVoiceError?: (error: Error) => void;
    /** Forwarded to MicButton; injectable for testing or a custom capture backend. */
    createRecorder?: () => Promise<AudioRecorder>;
    /** Notified whenever recording starts/stops — informational only, e.g. for a caller's own REC indicator. Not fired for the initial mount. */
    onRecordingChange?: (isRecording: boolean) => void;
    /** Live elapsed-time label (e.g. "3:45"). Omit to hide the timer entirely. */
    elapsedLabel?: string;
    /** Fraction (0-1) of the session's time budget used so far — renders a thin progress bar next to the timer. Omit when there's no fixed time budget. */
    elapsedFraction?: number;
    /** Pauses the session. Omit to hide the Pause control. Available in every mode, voice or text-only. */
    onPause?: () => void;
    pauseDisabled?: boolean;
    /** Notified with the character length of whatever was just pasted into the answer field — e.g. to feed InterviewWidget's integrity-signal tracking. Omit to not track pastes at all. */
    onAnswerPaste?: (pastedLength: number) => void;
}
/**
 * A fresh prompt (new question or follow-up) always starts a new
 * conversation turn — rather than resetting turn-state/answer-text via an
 * effect, the body below remounts fresh per prompt via `key`, the same way
 * it already remounts QuestionAudio/MicButton internally. No reset logic
 * needed anywhere.
 *
 * The live announcement of that change lives here, in this non-remounting
 * wrapper, rather than as aria-live on the visible heading inside the
 * remounted body: a brand-new DOM node arriving with aria-live already on
 * it is generally not announced by assistive tech — only text *changing*
 * inside an already-present live region is. This element's text changing
 * on every prompt update is what actually reaches a screen reader.
 *
 * Focus itself is handled separately, inside the remounting QuestionCardBody
 * below: every remount destroys whatever element previously held focus
 * (e.g. the answer field), and without an explicit refocus the browser
 * drops focus to <body> — forcing a keyboard-only candidate to Tab from the
 * very top of the page after every single answer. Moving focus to the new
 * heading each time (the standard multi-step-form pattern) fixes that.
 */
declare function QuestionCard(props: QuestionCardProps): react.JSX.Element;

interface TranscriptChatProps {
    transcript: TranscriptEntry[];
    /** Label shown above the AI's messages. Defaults to 'AI Interviewer'. */
    assistantName?: string;
    /** Label shown above the candidate's messages. Defaults to 'You'. */
    candidateName?: string;
}
/**
 * The running conversation as chat bubbles — every AI prompt and every
 * candidate answer, in order, plus the AI's own rationale (a real field
 * from EvaluationResult, not fabricated copy) when one was returned for
 * that answer. This is also the accessibility "captions" requirement
 * TranscriptViewer documents: nothing here is audio-only, so this list
 * keeps the same `role="log"` live-region contract.
 */
declare function TranscriptChat({ transcript, assistantName, candidateName, }: TranscriptChatProps): react.JSX.Element;

interface TranscriptViewerProps {
    transcript: TranscriptEntry[];
}
/**
 * Renders the full text of every prompt and answer. This is also the
 * accessibility "captions" requirement: nothing in this SDK is presented as
 * audio-only — whatever a voice layer speaks or transcribes always has a
 * visible text equivalent here.
 */
declare function TranscriptViewer({ transcript }: TranscriptViewerProps): react.JSX.Element;

interface ScoreSummaryProps {
    totalScore: number;
    rubric: Rubric;
    dimensionAverages: Record<string, number>;
}
declare function ScoreSummary({ totalScore, rubric, dimensionAverages }: ScoreSummaryProps): react.JSX.Element;

interface ReportCardProps {
    report: InterviewReport;
    rubric: Rubric;
    /** Called when image or CSV generation fails and the report falls back to a JSON download. */
    onExportError?: (error: Error, format: 'image' | 'csv') => void;
}
/**
 * Excludes the action buttons and any export notice from the captured
 * image — only the report content itself. html-to-image's real filter
 * callback (verified against its source) runs on every child node during
 * cloning, including raw Text nodes with no `.classList` — despite its
 * typed signature claiming `HTMLElement` — so non-Element nodes must be
 * passed through rather than assumed to have classList.
 */
declare function isExportable(domNode: HTMLElement): boolean;
declare function ReportCard({ report, rubric, onExportError }: ReportCardProps): react.JSX.Element;

type InterviewMode = 'client' | 'server';
interface InterviewWidgetProps {
    questions: Question[];
    rubric: RubricDimensionInput[];
    mode: InterviewMode;
    /** Required in Client Mode: the AI provider adapter that runs directly in the browser. Prototyping only. */
    adapter?: AIProviderAdapter;
    /** Server Mode: URL of the developer's own answer-processing endpoint. Defaults to /api/interview/answer. */
    apiBaseUrl?: string;
    /** Server Mode: extra headers (e.g. an auth token) sent with every request. */
    serverHeaders?: Record<string, string>;
    maxFollowUpDepth?: number;
    sessionTimeoutMs?: number;
    onSessionEnd?: (report: InterviewReport) => void;
    /** Enables the mic button; omit for text-only mode (the accessible default). */
    transcribe?: (audio: Blob) => Promise<string>;
    /** Speaks each question/follow-up aloud; omit for a silent, text-only prompt (the accessible default). */
    synthesize?: (text: string) => Promise<SynthesisResult>;
    onVoiceError?: (error: Error) => void;
    /**
     * Client Mode exposes AI keys in the browser and lets scores be computed
     * client-side — it refuses to run under NODE_ENV=production unless this
     * is explicitly set. Use Server Mode for production instead.
     */
    allowClientModeInProduction?: boolean;
    /**
     * Requests a live mic stream for the pre-join lobby's mic check — purely a
     * preview, never a recording. Defaults to a real getUserMedia call.
     * Injectable for testing.
     */
    requestMicStream?: () => Promise<MediaStream>;
    /** Overrides the lobby's primary action text. Defaults to 'Start interview'. */
    joinLabel?: string;
    /** Optional session context shown in the header (e.g. "Senior Software Engineer — Round 2"). */
    roleTitle?: string;
    /** The candidate's own display name, shown on their tile. Defaults to "You". */
    candidateName?: string;
    /**
     * Called when the final report's image or CSV export fails and falls
     * back to a JSON download (e.g. the optional `html-to-image` peer
     * dependency isn't installed) — the report itself already shows a
     * visible notice when this happens; use this to also log it or notify
     * your own backend.
     */
    onExportError?: (error: Error, format: 'image' | 'csv') => void;
    /**
     * When set, automatically saves the session to localStorage under this
     * key after every state change, and resumes from it on mount — a page
     * refresh or accidental tab close picks back up on the same question with
     * the same transcript, no manual getSnapshot()/initialSnapshot wiring
     * needed. Cleared automatically once the interview completes or expires.
     * Omit for a fresh session on every mount (the previous default, still
     * fully supported). Use a key that's unique per candidate+interview (e.g.
     * including a session or candidate id) — otherwise two different
     * candidates on the same browser profile would resume each other's answers.
     */
    persistKey?: string;
    /**
     * Tracks two low-risk, non-biometric integrity signals while the
     * interview is active — how many times the tab lost focus, and how many
     * times the candidate pasted into an answer — and attaches them to the
     * final report as `integritySignals`. Off by default; if you turn this
     * on, disclose it to candidates (most platforms that track tab-switching
     * say so up front). These are signals for a human reviewer to weigh in
     * context, never an automated cheating verdict.
     */
    trackIntegritySignals?: boolean;
    /** Extra class name(s) added to the root element, alongside `isdk-widget`. */
    className?: string;
    /**
     * Inline styles on the root element — the escape hatch for hosts whose
     * ancestor chain doesn't carry a definite height all the way down (e.g.
     * `style={{ height: '100dvh' }}`), since the widget's own CSS fills 100%
     * of its container but can't invent a height no ancestor provides.
     */
    style?: CSSProperties;
}
/**
 * mode/adapter are a one-time setup choice in real apps (typically a
 * memoized value, never re-derived per keystroke), so throwing loudly and
 * immediately here — outside InterviewErrorBoundary — fits: it's exactly
 * the kind of developer mistake that should be impossible to miss.
 *
 * Rubric/question validation is deliberately NOT duplicated here. Unlike
 * mode/adapter, questions and rubric are exactly the props a host app is
 * likely to edit live (a question builder, a dashboard) — a momentarily
 * blank prompt while someone retypes it is normal, not a bug, and must
 * never take the whole host page down with it. useInterview below already
 * validates this config as the single source of truth for both this
 * component and any headless consumer of that hook; here, that throw
 * happens inside the boundary, so a real invalid config still fails
 * clearly and immediately (the boundary's fallback renders the message),
 * it just can't escape and unmount an app embedding this widget.
 */
declare function InterviewWidget(props: InterviewWidgetProps): react.JSX.Element;

export { AudioLevelMeter, type AudioLevelMeterProps, type AudioRecorder, ClientModeProcessor, FeedbackNote, type FeedbackNoteProps, type IntegritySignals, InterviewLobby, type InterviewLobbyProps, type InterviewMode, type InterviewProcessor, InterviewProgress, type InterviewProgressProps, type InterviewReport, type InterviewSnapshot, InterviewWidget, type InterviewWidgetProps, LiveSignals, type LiveSignalsProps, MicButton, type MicButtonProps, type ProcessAnswerFollowUp, type ProcessAnswerInput, type ProcessAnswerResult, QuestionAudio, type QuestionAudioProps, QuestionCard, type QuestionCardProps, ReportCard, type ReportCardProps, STRENGTH_THRESHOLD, ScoreSummary, type ScoreSummaryProps, ServerModeProcessor, type ServerModeProcessorConfig, ServerModeRequestError, type SubmitAnswerOptions, TranscriptChat, type TranscriptChatProps, type TranscriptEntry, TranscriptViewer, type TranscriptViewerProps, type UseInterviewOptions, type UseInterviewResult, buildReport, isExportable, useInterview };