@tinyweb_dev/oe-exam-sdk 0.1.28 → 0.1.29

package/dist/components/exams/take/hooks/useSpeakingRendererSetup.js

@@ -1 +1,136 @@
-import{useEffect as e,useMemo as r,useCallback as t,useRef as n,useState as o}from"react";import{toast as i}from"../../../../shared/lib/toast";import{useExamTakingStore as s}from"../../../../shared/lib/stores/examTakingStore";import{useSpeakingNavigation as a}from"./useSpeakingNavigation";import{useSpeakingRecorder as c}from"./useSpeakingRecorder";export function useSpeakingRendererSetup({part:u,answers:d,onAnswerChange:m,onPartComplete:l,onPartBack:p,maxDurationMs:x=3e4,hasMic:g=!0,initialQuestionIndex:v=0,currentQuestionIndex:h}){const P=r(()=>u.questions.map((e,r)=>({...e,partName:u.name||`Part ${e.part_no}`,questionIndex:r})),[u.questions,u.name]),I=a({questions:P,initialIndex:v});e(()=>{void 0!==h&&h>=0&&h!==I.currentIndex&&I.goTo(h)},[h,I.currentIndex,I]);const N=I.currentQuestion,{attemptId:G}=s(),f=N?d[N.id]:void 0,k=!!f,w=c({attemptId:G??"",questionId:N?.id??"",maxDurationMs:x,existingAnswerKey:g?f:void 0,onRecordingComplete:(e,r)=>{const t=r||N?.id;t&&m(t,e)},onError:e=>i.error(e)});e(()=>{g&&w.isAttemptExpired&&i.error("Bài thi đã hết giờ hoặc đã được nộp.")},[g,w.isAttemptExpired]);const A=g&&"recording"===w.status,T=n(A),q=n(null),[Q,R]=o(!1);e(()=>{g?(T.current&&!A&&(R(!0),q.current&&clearTimeout(q.current),q.current=setTimeout(()=>{R(!1),q.current=null},500)),A&&q.current&&(clearTimeout(q.current),q.current=null,R(!1)),T.current=A):R(!1)},[g,A]),e(()=>()=>{q.current&&clearTimeout(q.current)},[]);const[S,C]=o(!1),D=t(e=>{C(e)},[]);e(()=>{C(!1)},[N?.id]);const E=A||Q||S,{setIsNavDisabled:b}=s();e(()=>(b(E),()=>b(!1)),[E,b]);const y=t(()=>{E||(I.canGoNext?I.goNext():l?.())},[I,E,l]),B=t(()=>{E||(I.canGoPrev?I.goPrev():p?.())},[I,E,p]),M=r(()=>({...I,showPrev:I.canGoPrev||!!p,showNext:I.canGoNext||!!l,canGoPrev:!E&&(I.canGoPrev||!!p),canGoNext:!E&&(I.canGoNext||!!l)}),[I,E,p,l]),K=!(!f||g&&"idle"!==w.status);return{nav:M,recorder:g?w:null,currentQuestion:N,handleNext:y,handlePrev:B,showExistingBadge:K,isRecordingInProgress:A,isQuestionLocked:k,isPostRecordingDelayActive:Q,onAudioPlayingChange:D}}
+import { useEffect, useMemo, useCallback, useRef, useState } from 'react';
+import { toast } from '../../../../shared/lib/toast';
+import { useExamTakingStore } from '../../../../shared/lib/stores/examTakingStore';
+import { useSpeakingNavigation } from './useSpeakingNavigation';
+import { useSpeakingRecorder } from './useSpeakingRecorder';
+export function useSpeakingRendererSetup({ part, answers, onAnswerChange, onPartComplete, onPartBack, maxDurationMs = 30000, hasMic = true, initialQuestionIndex = 0, currentQuestionIndex, }) {
+    // 1. Map questions to SpeakingQuestion[]
+    const speakingQuestions = useMemo(() => {
+        return part.questions.map((q, index) => ({
+            ...q,
+            partName: part.name || `Part ${q.part_no}`,
+            questionIndex: index,
+        }));
+    }, [part.questions, part.name]);
+    // 2. Navigation hook
+    const baseNav = useSpeakingNavigation({ questions: speakingQuestions, initialIndex: initialQuestionIndex });
+    // Sync with externally provided currentQuestionIndex if applicable
+    useEffect(() => {
+        if (currentQuestionIndex !== undefined && currentQuestionIndex >= 0 && currentQuestionIndex !== baseNav.currentIndex) {
+            baseNav.goTo(currentQuestionIndex);
+        }
+    }, [currentQuestionIndex, baseNav.currentIndex, baseNav]);
+    const currentQuestion = baseNav.currentQuestion;
+    // 3. Recorder hook
+    const { attemptId } = useExamTakingStore();
+    const existingAnswerKey = currentQuestion ? answers[currentQuestion.id] : undefined;
+    const isQuestionLocked = !!existingAnswerKey;
+    const options = {
+        attemptId: attemptId ?? '',
+        questionId: currentQuestion?.id ?? '',
+        maxDurationMs,
+        existingAnswerKey: hasMic ? existingAnswerKey : undefined,
+        onRecordingComplete: (audioKey, forQuestionId) => {
+            // Use snapshotted questionId from recording start to avoid stale-closure
+            const qId = forQuestionId || currentQuestion?.id;
+            if (qId) {
+                onAnswerChange(qId, audioKey);
+            }
+        },
+        onError: (err) => toast.error(err),
+    };
+    const recordingHook = useSpeakingRecorder(options);
+    const activeRecorder = recordingHook;
+    // 4. Toast on attempt expiry
+    useEffect(() => {
+        if (hasMic && activeRecorder.isAttemptExpired) {
+            toast.error('Bài thi đã hết giờ hoặc đã được nộp.');
+        }
+    }, [hasMic, activeRecorder.isAttemptExpired]);
+    // 5. Compute interaction guards
+    const isRecordingInProgress = hasMic && activeRecorder.status === 'recording';
+    const prevRecordingStateRef = useRef(isRecordingInProgress);
+    const postRecordingDelayRef = useRef(null);
+    const [isPostRecordingDelayActive, setIsPostRecordingDelayActive] = useState(false);
+    useEffect(() => {
+        if (!hasMic) {
+            setIsPostRecordingDelayActive(false);
+            return;
+        }
+        if (prevRecordingStateRef.current && !isRecordingInProgress) {
+            setIsPostRecordingDelayActive(true);
+            if (postRecordingDelayRef.current) {
+                clearTimeout(postRecordingDelayRef.current);
+            }
+            postRecordingDelayRef.current = setTimeout(() => {
+                setIsPostRecordingDelayActive(false);
+                postRecordingDelayRef.current = null;
+            }, 500);
+        }
+        if (isRecordingInProgress && postRecordingDelayRef.current) {
+            clearTimeout(postRecordingDelayRef.current);
+            postRecordingDelayRef.current = null;
+            setIsPostRecordingDelayActive(false);
+        }
+        prevRecordingStateRef.current = isRecordingInProgress;
+    }, [hasMic, isRecordingInProgress]);
+    useEffect(() => {
+        return () => {
+            if (postRecordingDelayRef.current) {
+                clearTimeout(postRecordingDelayRef.current);
+            }
+        };
+    }, []);
+    // Audio playback guard — blocks navigation while any audio is playing
+    const [isAudioPlaying, setIsAudioPlaying] = useState(false);
+    const handleAudioPlayingChange = useCallback((playing) => {
+        setIsAudioPlaying(playing);
+    }, []);
+    // Reset audio playing state when navigating to a new question
+    useEffect(() => {
+        setIsAudioPlaying(false);
+    }, [currentQuestion?.id]);
+    const isNavigationTemporarilyLocked = isRecordingInProgress || isPostRecordingDelayActive || isAudioPlaying;
+    const { setIsNavDisabled } = useExamTakingStore();
+    useEffect(() => {
+        setIsNavDisabled(isNavigationTemporarilyLocked);
+        return () => setIsNavDisabled(false);
+    }, [isNavigationTemporarilyLocked, setIsNavDisabled]);
+    const handleNext = useCallback(() => {
+        if (isNavigationTemporarilyLocked)
+            return;
+        if (baseNav.canGoNext)
+            baseNav.goNext();
+        else
+            onPartComplete?.();
+    }, [baseNav, isNavigationTemporarilyLocked, onPartComplete]);
+    const handlePrev = useCallback(() => {
+        if (isNavigationTemporarilyLocked)
+            return;
+        if (baseNav.canGoPrev)
+            baseNav.goPrev();
+        else
+            onPartBack?.();
+    }, [baseNav, isNavigationTemporarilyLocked, onPartBack]);
+    const nav = useMemo(() => ({
+        ...baseNav,
+        showPrev: baseNav.canGoPrev || !!onPartBack,
+        showNext: baseNav.canGoNext || !!onPartComplete,
+        canGoPrev: !isNavigationTemporarilyLocked && (baseNav.canGoPrev || !!onPartBack),
+        canGoNext: !isNavigationTemporarilyLocked && (baseNav.canGoNext || !!onPartComplete),
+    }), [baseNav, isNavigationTemporarilyLocked, onPartBack, onPartComplete]);
+    // 6. Compute existing badge
+    const showExistingBadge = !!existingAnswerKey && (!hasMic || activeRecorder.status === 'idle');
+    return {
+        nav,
+        recorder: hasMic ? activeRecorder : null,
+        currentQuestion,
+        handleNext,
+        handlePrev,
+        showExistingBadge,
+        isRecordingInProgress,
+        isQuestionLocked,
+        isPostRecordingDelayActive,
+        onAudioPlayingChange: handleAudioPlayingChange,
+    };
+}

package/dist/components/exams/take/hooks/useSpontaneousQaGroupRecorder.d.ts

@@ -0,0 +1,11 @@
+import type { UseSpeakingRecorderReturn } from './useSpeakingRecorder';
+export interface UseSpontaneousQaGroupRecorderOptions {
+    attemptId: string;
+    questionId: string;
+    itemIndex: number;
+    maxDurationMs?: number;
+    onRecordingComplete: (audioKey: string, forItemIndex?: number) => void;
+    onError?: (error: string) => void;
+    existingAnswerKey?: string;
+}
+export declare function useSpontaneousQaGroupRecorder(options: UseSpontaneousQaGroupRecorderOptions): UseSpeakingRecorderReturn;

package/dist/components/exams/take/hooks/useSpontaneousQaGroupRecorder.js

@@ -0,0 +1,352 @@
+import { useState, useRef, useEffect, useCallback } from 'react';
+import { usePresignedFileUrl } from '../../../../shared/lib/hooks';
+import { useExamTakingApiOptional } from '../ExamTakingApiContext';
+function unwrapData(response) {
+    return response && typeof response === 'object' && 'data' in response
+        ? response.data
+        : response;
+}
+const DEFAULT_MAX_DURATION_MS = 30000;
+const WARNING_THRESHOLD_SECONDS = 5;
+const MAX_AUTO_RETRIES = 3;
+function detectSupportedMimeType() {
+    if (typeof MediaRecorder === 'undefined')
+        return null;
+    const candidates = [
+        'audio/webm;codecs=opus',
+        'audio/webm',
+        'audio/mp4',
+        'audio/ogg;codecs=opus',
+        'audio/ogg',
+    ];
+    for (const mimeType of candidates) {
+        if (MediaRecorder.isTypeSupported(mimeType)) {
+            return mimeType;
+        }
+    }
+    return null;
+}
+export function useSpontaneousQaGroupRecorder(options) {
+    const maxDurationMs = options.maxDurationMs ?? DEFAULT_MAX_DURATION_MS;
+    const maxDurationSeconds = Math.floor(maxDurationMs / 1000);
+    const api = useExamTakingApiOptional();
+    const apiRef = useRef(api);
+    apiRef.current = api;
+    const onRecordingCompleteRef = useRef(options.onRecordingComplete);
+    const onErrorRef = useRef(options.onError);
+    onRecordingCompleteRef.current = options.onRecordingComplete;
+    onErrorRef.current = options.onError;
+    const attemptIdRef = useRef(options.attemptId);
+    const questionIdRef = useRef(options.questionId);
+    const itemIndexRef = useRef(options.itemIndex);
+    attemptIdRef.current = options.attemptId;
+    questionIdRef.current = options.questionId;
+    itemIndexRef.current = options.itemIndex;
+    const [status, setStatus] = useState('idle');
+    const [remainingSeconds, setRemainingSeconds] = useState(maxDurationSeconds);
+    const [durationSeconds, setDurationSeconds] = useState(0);
+    const [previewUrl, setPreviewUrl] = useState(null);
+    const [uploadedKey, setUploadedKey] = useState(null);
+    const [error, setError] = useState(null);
+    const [isAttemptExpired, setIsAttemptExpired] = useState(false);
+    const mediaRecorderRef = useRef(null);
+    const mediaStreamRef = useRef(null);
+    const chunksRef = useRef([]);
+    const durationIntervalRef = useRef(null);
+    const previewUrlRef = useRef(null);
+    const mimeTypeRef = useRef('');
+    const recordStartTimeRef = useRef(0);
+    const pendingBlobRef = useRef(null);
+    const pendingDurationMsRef = useRef(undefined);
+    const autoRetryCountRef = useRef(0);
+    const isMountedRef = useRef(true);
+    const recordingItemIndexRef = useRef(options.itemIndex);
+    const isSupported = typeof MediaRecorder !== 'undefined';
+    const { previewUrl: existingPresignedUrl } = usePresignedFileUrl(options.existingAnswerKey);
+    const stopDurationTimer = useCallback(() => {
+        if (durationIntervalRef.current) {
+            clearInterval(durationIntervalRef.current);
+            durationIntervalRef.current = null;
+        }
+    }, []);
+    const revokePreviewUrl = useCallback(() => {
+        if (previewUrlRef.current?.startsWith('blob:')) {
+            URL.revokeObjectURL(previewUrlRef.current);
+        }
+        previewUrlRef.current = null;
+    }, []);
+    const stopMediaStream = useCallback(() => {
+        if (mediaStreamRef.current) {
+            mediaStreamRef.current.getTracks().forEach((track) => track.stop());
+            mediaStreamRef.current = null;
+        }
+    }, []);
+    const performUpload = useCallback(async (blob, durationMs, retryCount, forItemIndex) => {
+        if (!isMountedRef.current)
+            return;
+        const itemIndex = forItemIndex ?? recordingItemIndexRef.current ?? itemIndexRef.current;
+        if (itemIndexRef.current === itemIndex) {
+            setStatus('uploading');
+        }
+        const attemptId = attemptIdRef.current;
+        const questionId = questionIdRef.current;
+        if (attemptId === 'mock-attempt-speaking') {
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            if (!isMountedRef.current)
+                return;
+            const mockKey = `mock-audio-key-${questionId}-${itemIndex}`;
+            if (itemIndexRef.current === itemIndex) {
+                setStatus('uploaded');
+                setUploadedKey(mockKey);
+            }
+            onRecordingCompleteRef.current(mockKey, itemIndex);
+            pendingBlobRef.current = null;
+            pendingDurationMsRef.current = undefined;
+            return;
+        }
+        try {
+            if (!apiRef.current?.uploadGroupItemAudio) {
+                throw new Error('uploadGroupItemAudio is not implemented by the provided API adapter.');
+            }
+            const result = unwrapData(await apiRef.current.uploadGroupItemAudio({
+                attemptId,
+                questionId,
+                itemIndex,
+                audioBlob: blob,
+                durationMs,
+            }));
+            if (!isMountedRef.current)
+                return;
+            const audioKey = result.audioKey ?? '';
+            if (itemIndexRef.current === itemIndex) {
+                setStatus('uploaded');
+                setUploadedKey(audioKey);
+            }
+            onRecordingCompleteRef.current(audioKey, itemIndex);
+            pendingBlobRef.current = null;
+            pendingDurationMsRef.current = undefined;
+            autoRetryCountRef.current = 0;
+        }
+        catch (err) {
+            if (!isMountedRef.current)
+                return;
+            const axiosError = err;
+            const errorCode = axiosError?.response?.data?.code;
+            if (errorCode === 'ATTEMPT_EXPIRED' || errorCode === 'ATTEMPT_NOT_IN_PROGRESS') {
+                const message = errorCode === 'ATTEMPT_EXPIRED'
+                    ? 'Bài thi đã hết giờ'
+                    : 'Bài thi đã được nộp.';
+                setStatus('error');
+                setError(message);
+                setIsAttemptExpired(true);
+                onErrorRef.current?.(message);
+                return;
+            }
+            if (errorCode === 'AUDIO_FILE_TOO_LARGE') {
+                const message = 'Bài ghi âm quá dài. Vui lòng ghi âm ngắn hơn.';
+                setStatus('error');
+                setError(message);
+                onErrorRef.current?.(message);
+                return;
+            }
+            if (retryCount < MAX_AUTO_RETRIES) {
+                await new Promise((resolve) => setTimeout(resolve, Math.pow(2, retryCount) * 1000));
+                if (!isMountedRef.current)
+                    return;
+                autoRetryCountRef.current = retryCount + 1;
+                await performUpload(blob, durationMs, retryCount + 1, forItemIndex);
+                return;
+            }
+            const message = 'Tải lên bản ghi âm thất bại. Vui lòng thử lại.';
+            setStatus('error');
+            setError(message);
+            onErrorRef.current?.(message);
+        }
+    }, []);
+    const uploadBlob = useCallback(async (blob, durationMs, forItemIndex) => {
+        pendingBlobRef.current = blob;
+        pendingDurationMsRef.current = durationMs;
+        autoRetryCountRef.current = 0;
+        await performUpload(blob, durationMs, 0, forItemIndex);
+    }, [performUpload]);
+    const startRecording = useCallback(async () => {
+        if (options.existingAnswerKey) {
+            setStatus('uploaded');
+            setUploadedKey(options.existingAnswerKey);
+            return;
+        }
+        if (!isSupported) {
+            const message = 'Trình duyệt này không hỗ trợ ghi âm. Vui lòng dùng Chrome, Firefox hoặc Edge.';
+            setStatus('error');
+            setError(message);
+            onErrorRef.current?.(message);
+            return;
+        }
+        const mimeType = detectSupportedMimeType();
+        if (!mimeType || typeof navigator === 'undefined' || !navigator.mediaDevices?.getUserMedia) {
+            const message = 'Trình duyệt không hỗ trợ ghi âm hoặc truy cập microphone.';
+            setStatus('error');
+            setError(message);
+            onErrorRef.current?.(message);
+            return;
+        }
+        try {
+            const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+            mediaStreamRef.current = stream;
+            mimeTypeRef.current = mimeType;
+            const recorder = new MediaRecorder(stream, { mimeType });
+            mediaRecorderRef.current = recorder;
+            chunksRef.current = [];
+            recorder.ondataavailable = (event) => {
+                if (event.data.size > 0) {
+                    chunksRef.current.push(event.data);
+                }
+            };
+            recorder.onstop = () => {
+                const durationMs = Date.now() - recordStartTimeRef.current;
+                const blob = new Blob(chunksRef.current, { type: mimeTypeRef.current });
+                const url = URL.createObjectURL(blob);
+                const snapshotItemIndex = recordingItemIndexRef.current;
+                revokePreviewUrl();
+                previewUrlRef.current = url;
+                setPreviewUrl(url);
+                setStatus('recorded');
+                uploadBlob(blob, durationMs, snapshotItemIndex);
+            };
+            recorder.start();
+            recordStartTimeRef.current = Date.now();
+            recordingItemIndexRef.current = itemIndexRef.current;
+            setStatus('recording');
+            setDurationSeconds(0);
+            setRemainingSeconds(maxDurationSeconds);
+            setError(null);
+            setUploadedKey(null);
+            setPreviewUrl(null);
+            setIsAttemptExpired(false);
+            durationIntervalRef.current = setInterval(() => {
+                setDurationSeconds((prev) => prev + 1);
+                setRemainingSeconds((prev) => {
+                    const next = Math.max(0, prev - 1);
+                    if (next === 0) {
+                        stopDurationTimer();
+                        if (mediaRecorderRef.current?.state === 'recording') {
+                            mediaRecorderRef.current.stop();
+                        }
+                        stopMediaStream();
+                    }
+                    return next;
+                });
+            }, 1000);
+        }
+        catch (err) {
+            stopMediaStream();
+            const errName = err instanceof DOMException ? err.name : '';
+            let message = 'Không thể truy cập microphone. Vui lòng thử lại.';
+            if (errName === 'NotAllowedError' || errName === 'PermissionDeniedError') {
+                message = 'Vui lòng cấp quyền truy cập microphone trong cài đặt trình duyệt.';
+            }
+            else if (errName === 'NotFoundError' || errName === 'DevicesNotFoundError') {
+                message = 'Không tìm thấy thiết bị microphone nào kết nối với máy tính.';
+            }
+            else if (errName === 'NotReadableError' || errName === 'TrackStartError') {
+                message = 'Microphone đang được ứng dụng khác sử dụng hoặc gặp lỗi phần cứng.';
+            }
+            setStatus('error');
+            setError(message);
+            onErrorRef.current?.(message);
+        }
+    }, [
+        isSupported,
+        maxDurationSeconds,
+        options.existingAnswerKey,
+        revokePreviewUrl,
+        stopDurationTimer,
+        stopMediaStream,
+        uploadBlob,
+    ]);
+    const stopRecording = useCallback(() => {
+        stopDurationTimer();
+        if (mediaRecorderRef.current?.state === 'recording') {
+            mediaRecorderRef.current.stop();
+        }
+        stopMediaStream();
+    }, [stopDurationTimer, stopMediaStream]);
+    const resetRecording = useCallback(() => {
+        stopDurationTimer();
+        stopMediaStream();
+        if (mediaRecorderRef.current?.state === 'recording') {
+            mediaRecorderRef.current.stop();
+        }
+        mediaRecorderRef.current = null;
+        chunksRef.current = [];
+        pendingBlobRef.current = null;
+        pendingDurationMsRef.current = undefined;
+        autoRetryCountRef.current = 0;
+        revokePreviewUrl();
+        setPreviewUrl(null);
+        setUploadedKey(null);
+        setDurationSeconds(0);
+        setRemainingSeconds(maxDurationSeconds);
+        setError(null);
+        setStatus('idle');
+        setIsAttemptExpired(false);
+    }, [maxDurationSeconds, revokePreviewUrl, stopDurationTimer, stopMediaStream]);
+    const reRecord = useCallback(async () => {
+        if (options.existingAnswerKey) {
+            setStatus('uploaded');
+            setUploadedKey(options.existingAnswerKey);
+            return;
+        }
+        resetRecording();
+        await startRecording();
+    }, [options.existingAnswerKey, resetRecording, startRecording]);
+    const retryUpload = useCallback(async () => {
+        const blob = pendingBlobRef.current;
+        if (!blob)
+            return;
+        autoRetryCountRef.current = 0;
+        await performUpload(blob, pendingDurationMsRef.current, 0, recordingItemIndexRef.current);
+    }, [performUpload]);
+    useEffect(() => {
+        resetRecording();
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [options.questionId, options.itemIndex]);
+    useEffect(() => {
+        if (status === 'idle' && existingPresignedUrl && options.existingAnswerKey && !previewUrl) {
+            setPreviewUrl(existingPresignedUrl);
+            previewUrlRef.current = existingPresignedUrl;
+            setUploadedKey(options.existingAnswerKey);
+            setStatus('uploaded');
+        }
+    }, [existingPresignedUrl, options.existingAnswerKey, previewUrl, status]);
+    useEffect(() => {
+        isMountedRef.current = true;
+        return () => {
+            isMountedRef.current = false;
+            stopDurationTimer();
+            if (mediaRecorderRef.current?.state === 'recording') {
+                mediaRecorderRef.current.stop();
+            }
+            stopMediaStream();
+            revokePreviewUrl();
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    return {
+        status,
+        remainingSeconds,
+        isWarning: remainingSeconds <= WARNING_THRESHOLD_SECONDS && status === 'recording',
+        durationSeconds,
+        previewUrl,
+        uploadedKey,
+        error,
+        isSupported,
+        isAttemptExpired,
+        liveTranscript: null,
+        startRecording,
+        stopRecording,
+        resetRecording,
+        reRecord,
+        retryUpload,
+    };
+}

package/dist/components/exams/take/hooks/useSpontaneousQaGroupRendererSetup.d.ts

@@ -0,0 +1,42 @@
+import { type SpeakingQuestion } from './useSpeakingNavigation';
+import type { QuestionPart } from '../utils/question-transformers';
+export interface UseSpontaneousQaGroupRendererSetupOptions {
+    part: QuestionPart;
+    answers: Record<string, unknown>;
+    onAnswerChange: (questionId: string, value: unknown) => void;
+    onPartComplete?: () => void;
+    onPartBack?: () => void;
+    maxDurationMs?: number;
+    hasMic?: boolean;
+    initialQuestionIndex?: number;
+    currentQuestionIndex?: number;
+}
+export declare function useSpontaneousQaGroupRendererSetup({ part, answers, onAnswerChange, onPartComplete, onPartBack, maxDurationMs, hasMic, initialQuestionIndex, currentQuestionIndex, }: UseSpontaneousQaGroupRendererSetupOptions): {
+    nav: {
+        showPrev: boolean;
+        showNext: boolean;
+        canGoPrev: boolean;
+        canGoNext: boolean;
+        currentIndex: number;
+        currentQuestion: SpeakingQuestion | null;
+        totalQuestions: number;
+        currentPartNo: number;
+        currentPartName: string;
+        questionNumberInPart: number;
+        goNext: () => void;
+        goPrev: () => void;
+        goTo: (index: number) => void;
+    };
+    recorder: import("./useSpeakingRecorder").UseSpeakingRecorderReturn;
+    currentQuestion: SpeakingQuestion;
+    handleNext: () => void;
+    handlePrev: () => void;
+    showExistingBadge: boolean;
+    isRecordingInProgress: boolean;
+    isQuestionLocked: boolean;
+    isPostRecordingDelayActive: boolean;
+    onAudioPlayingChange: (playing: boolean) => void;
+    instruction: any;
+    parentId: string;
+    flattenedCount: number;
+};