@sapia-ai/chatbot-v3 1.0.0

package/dist/api/types/messages.d.ts

@@ -0,0 +1,148 @@
+export declare enum RuleName {
+    MAX_TEXT_LENGTH = "maxTextLength",
+    MIN_TEXT_LENGTH = "minTextLength",
+    RECOMMENDED_TEXT_LENGTH = "recommendedTextLength",
+    MAX_VOICE_SECONDS = "maxVoiceSeconds",
+    MIN_VOICE_SECONDS = "minVoiceSeconds",
+    RECOMMENDED_VOICE_SECONDS = "recommendedVoiceSeconds"
+}
+export declare enum MessageSender {
+    AGENT = "AGENT",
+    CANDIDATE = "CANDIDATE"
+}
+export declare enum QuestionType {
+    HINT = "HINT",
+    FTQ = "FTQ",
+    MCQ = "MCQ",
+    VOICE = "VOICE",
+    VIDEO = "VIDEO",
+    SLIDER = "SLIDER",
+    DROPDOWN = "DROPDOWN",
+    BGQ = "BUTTON_GROUP_QUESTION"
+}
+export declare enum ContentType {
+    TEXT = "TEXT",
+    VOICE = "VOICE",
+    VIDEO = "VIDEO",
+    SLIDER = "SLIDER"
+}
+export declare enum PHService {
+    GENERAL_PY = "GENERAL_PY",
+    CUSTOMER_SATISFACTION = "CUSTOMER_SATISFACTION",
+    PII = "PII",
+    SENSITIVE = "SENSITIVE",
+    DISPLAY_IN_TI = "DISPLAY_IN_TI",
+    HEXACO_PERSONALITY_TEST = "HEXACO_PERSONALITY_TEST"
+}
+/** Identified via question tag { name: "PII_TYPE", value: <PiiQuestionType> } */
+export declare enum PiiQuestionType {
+    FULL_NAME = "fullName",
+    FIRST_NAME = "first_name",
+    LAST_NAME = "last_name",
+    EMAIL = "email",
+    PHONE_NUMBER = "phoneNumber",
+    LOCATION = "location"
+}
+/** Identified via question tag { name: "VIDEO_TYPE", value: <VideoQuestionType> } */
+export declare enum VideoQuestionType {
+    TEST_CAMERA = "test_camera"
+}
+export declare enum ButtonType {
+    PRIMARY = "PRIMARY",
+    SECONDARY = "SECONDARY",
+    DEFAULT = "DEFAULT"
+}
+export declare enum AssessmentStatus {
+    FI_ATS_ASSESSMENT_ORDER_COMPLETED = "FI_ATS_ASSESSMENT_ORDER_COMPLETED",
+    FI_ASSESSMENT_STARTED = "FI_ASSESSMENT_STARTED",
+    FI_ASSESSMENT_PII_SAVED = "FI_ASSESSMENT_PII_SAVED",
+    FI_ASSESSMENT_PII_COMPLETED = "FI_ASSESSMENT_PII_COMPLETED",
+    FI_ASSESSMENT_INPROGRESS = "FI_ASSESSMENT_INPROGRESS",
+    FI_ASSESSMENT_COMPLETED = "FI_ASSESSMENT_COMPLETED",
+    FI_ASSESSMENT_ENDED = "FI_ASSESSMENT_ENDED",
+    FI_ASSESSMENT_DROPPED_OUT = "FI_ASSESSMENT_DROPPED_OUT",
+    FI_PREDICTION_STARTED = "FI_PREDICTION_STARTED",
+    FI_PREDICTION_COMPLETED = "FI_PREDICTION_COMPLETED",
+    FI_ASSESSMENT_DUPLICATED = "FI_ASSESSMENT_DUPLICATED"
+}
+export type MessageIdentifier = string;
+export type Trigger = {
+    action: string;
+};
+export type Style = {
+    buttonType: ButtonType;
+};
+export type Content = {
+    value: string;
+    text: string;
+    id: string;
+};
+export type ButtonGroupContent = Content & {
+    triggers: Trigger[];
+    style: Style;
+};
+export type AnswerContent = {
+    text: string;
+    value: string;
+    /** Sanitized rich-text HTML for re-display; `text` stays the plain-text source for scoring. */
+    html?: string;
+    triggers?: Trigger[];
+    style?: Style;
+};
+export type Tag = {
+    name: string;
+    value: string;
+};
+export type QuestionRule = {
+    name: RuleName;
+    type: string;
+    value: number | string;
+};
+export type BubbleContent = {
+    value: string;
+    types: ContentType[];
+    /** BE A2UI-style render component (streaming STATE_SNAPSHOT / loaded chatLogs only). */
+    component?: 'Text' | 'VoicePlayer' | 'VideoPlayer' | 'Slider';
+};
+export type MCQQuestionOption = {
+    id: string;
+    text: string;
+    value: string;
+};
+export type DropdownOption = MCQQuestionOption;
+export type BGQButton = MCQQuestionOption & {
+    triggers: Trigger[];
+    style: Style;
+};
+export type Question = {
+    masterId?: string;
+    types: QuestionType[];
+    rules?: QuestionRule[];
+    contents: BubbleContent[];
+    options?: MCQQuestionOption[] | BGQButton[];
+    usageWhitelist?: PHService[];
+    _id: string;
+    tags?: Tag[];
+    /** BE message kind (streaming STATE_SNAPSHOT / loaded chatLogs only); "Hint" | "Question". */
+    kind?: 'Hint' | 'Question';
+};
+export type Answer = {
+    _id: string;
+    question: Question;
+    text: string;
+    value: string;
+};
+export interface Message<T> {
+    id: string;
+    sender: MessageSender;
+    messageIdentifier?: MessageIdentifier;
+    data: T;
+}
+export type CandidateResponse = Message<Answer>;
+export type AgentResponse = Message<Question>;
+export type CandidateResponseInput = {
+    userAgent: string;
+    questionId: string;
+    answer?: AnswerContent;
+};
+export type EditCandidateResponseInput = Required<Omit<CandidateResponseInput, 'userAgent'>>;

package/dist/api/types/responses.d.ts

@@ -0,0 +1,106 @@
+import { Branding } from './branding';
+import { AgentResponse, AssessmentStatus, BGQButton, CandidateResponse, ContentType, MCQQuestionOption, PHService, QuestionRule, QuestionType, Tag } from './messages';
+/** Session token returned by /start/ats; sent as a dynamic header on subsequent calls. */
+export type FiToken = {
+    name: string;
+    value: string;
+};
+export type StartAtsResponse = {
+    assessmentId: string;
+    chatLogs: (CandidateResponse | AgentResponse)[];
+    branding?: Branding;
+    hasVideoQuestion?: boolean;
+    assessmentStatus: AssessmentStatus;
+    isCohortClosed?: boolean;
+    cohortIsArchivedMessage?: AgentResponse;
+    numOfNormalQuestion: number;
+    numOfNormalAnswer: number;
+    fiToken: FiToken;
+    language: string;
+    agcDetectionAttempt: number;
+    allowNextAgcDetection: boolean;
+    isTermsAndConditionsAccepted: boolean;
+    candidateCountryCode?: string;
+    assessmentIsReusedMessage?: AgentResponse;
+    /** Candidate display name for the pre-interview welcome (optional; absent → generic greeting). */
+    candidateName?: string;
+    /** Role/position title for the welcome + header (optional; falls back to branding.title). */
+    roleTitle?: string;
+};
+export type NextResponse = {
+    nextResponse: AgentResponse;
+    candidateResponse?: CandidateResponse;
+    assessmentStatus: AssessmentStatus;
+    duplicatedWithAssessmentLink?: string;
+    cohortIsArchivedMessage?: AgentResponse;
+    assessmentIsReusedMessage?: AgentResponse;
+    numOfNormalAnswer: number;
+    isTermsAndConditionsAccepted: boolean;
+    fiToken?: FiToken;
+};
+export type EditAnswerResponse = {
+    updatedCandidateResponse: CandidateResponse;
+    cohortIsArchivedMessage?: AgentResponse;
+};
+export type TranslationResponse = Record<string, string>;
+/** POST /:assessmentId/extract-human-name — extracts name parts from free text. */
+export type ExtractHumanNameType = 'firstName' | 'lastName' | 'fullName';
+export type ExtractHumanNameResponse = {
+    firstName?: string;
+    lastName?: string;
+    fullName?: string;
+};
+/** GET video-upload-signed-url / video-access-signed-url — S3 signed URL + filename. */
+export type VideoSignedUrlResponse = {
+    url: string;
+    videoFileName: string;
+};
+/** GET access-management — whether an email gate is required before the interview. */
+export type AccessManagementResponse = {
+    shouldAuthenticate: boolean;
+    emailHint?: string;
+    language?: string;
+};
+/** POST verify-access — whether the candidate email matches. */
+export type VerifyAccessResponse = {
+    allowToAccess: boolean;
+};
+/** POST detect-agc — automated-content detection on submit. */
+export type DetectAgcResponse = {
+    attempt: number;
+    isAgc: boolean;
+    allowNextAgcDetection: boolean;
+};
+export type AgUiEventType = 'RUN_STARTED' | 'STATE_SNAPSHOT' | 'TEXT_MESSAGE_START' | 'TEXT_MESSAGE_CONTENT' | 'TEXT_MESSAGE_END' | 'CUSTOM' | 'RUN_FINISHED' | 'RUN_ERROR';
+/** A2UI-style render component for a content bubble (STATE_SNAPSHOT contents[].component). */
+export type ContentComponentName = 'Text' | 'VoicePlayer' | 'VideoPlayer' | 'Slider';
+/** STATE_SNAPSHOT.snapshot.question — same data as our Question, but `types` is `questionTypes`. */
+export type SnapshotQuestion = {
+    _id: string;
+    masterId?: string;
+    /** Bubble template: "Hint" (agent context, unanswerable) vs "Question". */
+    kind?: 'Hint' | 'Question';
+    /** Answer-input component (ignored — response stays questionType-driven). */
+    component?: string | null;
+    questionTypes: QuestionType[];
+    options?: MCQQuestionOption[] | BGQButton[];
+    rules?: QuestionRule[];
+    tags?: Tag[];
+    usageWhitelist?: PHService[];
+    contents?: {
+        component: ContentComponentName;
+        types: ContentType[];
+    }[];
+};
+/** One parsed AG-UI frame (only the fields our client reads are typed). */
+export type AgUiFrame = {
+    type: AgUiEventType;
+    snapshot?: {
+        question?: SnapshotQuestion;
+    };
+    /** TEXT_MESSAGE_* message id, shape "<baseId>:<contentIndex>"; segments bundled messages. */
+    messageId?: string;
+    delta?: string;
+    result?: NextResponse;
+    message?: string;
+};

package/dist/api.js

@@ -0,0 +1,2 @@
+import { _ as e, a as t, c as n, d as r, f as i, g as a, h as o, i as s, l as c, m as l, n as u, o as d, p as f, r as p, s as m, t as h, u as g } from "./messages-C4jqrtSG.js";
+export { r as API_ORIGIN_BY_ENV, h as AssessmentStatus, u as ButtonType, i as CHATBOT_API_PATH, g as ChatbotApiClient, p as ContentType, f as DEFAULT_LOCAL_API_ORIGIN, l as ENVIRONMENTS, s as MessageSender, t as PHService, d as PiiQuestionType, m as QuestionType, o as REGIONS, n as RuleName, c as VideoQuestionType, a as buildChatbotBaseUrl, e as resolveApiOrigin };

package/dist/classPrivateFieldSet2-DtQPURVD.js

@@ -0,0 +1,32 @@
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/checkPrivateRedeclaration.js
+function e(e, t) {
+	if (t.has(e)) throw TypeError("Cannot initialize the same private elements twice on an object");
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/classPrivateMethodInitSpec.js
+function t(t, n) {
+	e(t, n), n.add(t);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/classPrivateFieldInitSpec.js
+function n(t, n, r) {
+	e(t, n), n.set(t, r);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/assertClassBrand.js
+function r(e, t, n) {
+	if (typeof e == "function" ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
+	throw TypeError("Private element is not present on this object");
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/classPrivateFieldGet2.js
+function i(e, t) {
+	return e.get(r(e, t));
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/classPrivateFieldSet2.js
+function a(e, t, n) {
+	return e.set(r(e, t), n), n;
+}
+//#endregion
+export { t as a, n as i, i as n, r, a as t };

package/dist/core/bubbles/convert.d.ts

@@ -0,0 +1,18 @@
+import { PiiQuestionType, VideoQuestionType, AgentResponse, CandidateResponse, Tag } from '../../api/types/messages';
+import { MessageBubble } from './types';
+export declare const piiQuestionTypeFromQuestionTags: (tags?: Tag[]) => PiiQuestionType | undefined;
+export declare const videoQuestionTypeFromQuestionTags: (tags?: Tag[]) => VideoQuestionType | undefined;
+export declare const convertRawCandidateResponseToMessageBubble: (response: CandidateResponse) => MessageBubble;
+export declare const convertRawAgentResponseToMessageBubble: (response: AgentResponse, hasNext?: boolean) => MessageBubble;
+export declare const convertRawResponseToMessageBubble: (response: CandidateResponse | AgentResponse, hasNext?: boolean) => MessageBubble | undefined;
+/**
+ * For option/slider questions the candidate "answers inline", so a synthetic
+ * candidate bubble is appended right after the agent question bubble.
+ */
+export declare const addCandidateResponseMessageBubble: (response: AgentResponse) => MessageBubble | undefined;
+export declare const convertMessageBubbles: (chatLogs: (CandidateResponse | AgentResponse)[]) => MessageBubble[];
+/** Only load the next message when the answered question is the last agent bubble. */
+export declare const checkShouldLoadNext: ({ messageBubbleList, questionId, }: {
+    messageBubbleList: MessageBubble[];
+    questionId: string;
+}) => boolean;

package/dist/core/bubbles/types.d.ts

@@ -0,0 +1,55 @@
+import { AnswerContent, ContentType, MessageIdentifier, MessageSender, PHService, PiiQuestionType, QuestionRule, QuestionType, Style, Tag, Trigger, VideoQuestionType } from '../../api/types/messages';
+export declare enum BubbleStatus {
+    ANSWERED = "ANSWERED",
+    ANSWERING = "ANSWERING",
+    EDITING = "EDITING",
+    PENDING = "PENDING",
+    FAILED = "FAILED"
+}
+/** A bubble content entry; for MCQ/DROPDOWN options and BGQ buttons it carries
+ * the selectable option (BGQ adds triggers/style, echoed back in the answer). */
+export type OptionContent = {
+    id: string;
+    text: string;
+    value: string;
+    triggers?: Trigger[];
+    style?: Style;
+};
+/** BE A2UI-style content render component (STATE_SNAPSHOT / loaded chatLogs contents[].component). */
+export type ContentComponent = 'Text' | 'VoicePlayer' | 'VideoPlayer' | 'Slider';
+/** BE message kind (STATE_SNAPSHOT / loaded chatLogs question.kind). */
+export type MessageKind = 'Hint' | 'Question';
+export type MessageItem = {
+    id: string;
+    types: ContentType[];
+    contents: OptionContent[];
+    /** BE-provided render component for this content; falls back to `types` when absent. */
+    component?: ContentComponent;
+};
+export type MessageBubbleData = {
+    messageItems: MessageItem[];
+    answer?: AnswerContent | null;
+    rules?: QuestionRule[];
+    tags?: Tag[];
+};
+export type MessageBubble = {
+    status: BubbleStatus;
+    sender: MessageSender;
+    messageIdentifier?: MessageIdentifier;
+    id: string;
+    types: QuestionType[];
+    usageWhitelist?: PHService[];
+    questionId: string;
+    data: MessageBubbleData;
+    masterId?: string;
+    /** BE-provided message kind; falls back to `types` when absent. */
+    messageKind?: MessageKind;
+    piiQuestionType?: PiiQuestionType;
+    videoQuestionType?: VideoQuestionType;
+    /** Video answer in flight: upload progress 0–1 (PENDING video bubbles). */
+    uploadProgress?: number;
+    /** Locally-recorded blob for immediate playback before/without a signed URL. */
+    videoBlob?: Blob;
+    /** Recorded file extension (webm/mp4), needed to fetch the playback access URL. */
+    videoExtension?: string;
+};

package/dist/core/constants.d.ts

@@ -0,0 +1,14 @@
+/** Streaming reveal cadence: ms per char-step (React passes 0 under prefers-reduced-motion). */
+export declare const STREAM_REVEAL_MS = 12;
+/** Chars revealed per reveal tick — bounds store writes to ~60/s at the default cadence. */
+export declare const STREAM_CHARS_PER_TICK = 2;
+/** Id prefix for the transient live agent bubble shown while a message streams in. */
+export declare const STREAM_BUBBLE_ID_PREFIX = "stream-live";
+export declare const QUESTION_TAG_PII_TYPE = "PII_TYPE";
+export declare const QUESTION_TAG_VIDEO_TYPE = "VIDEO_TYPE";
+/** Experience-rating slider range and starting position (legacy defaultSliderValue). */
+export declare const SLIDER_MIN = 1;
+export declare const SLIDER_MAX = 10;
+export declare const SLIDER_DEFAULT_VALUE = 8;
+/** Default video answer length when the question carries no max-seconds rule. */
+export declare const MAX_VIDEO_SECONDS_DEFAULT = 60;

package/dist/core/events.d.ts

@@ -0,0 +1,44 @@
+export declare const CHATBOT_EVENTS: {
+    readonly ASSESSMENT_STARTED: "assessment:started";
+    readonly ASSESSMENT_ENDED: "assessment:ended";
+    readonly ASSESSMENT_DUPLICATED: "assessment:duplicated";
+    readonly ANSWER_SAVED: "answer:saved";
+    readonly ANSWER_EDITED: "answer:edited";
+    readonly ERROR: "error";
+    readonly LOG: "log";
+};
+export type ChatbotEventName = (typeof CHATBOT_EVENTS)[keyof typeof CHATBOT_EVENTS];
+export type ChatbotEventMap = {
+    [CHATBOT_EVENTS.ASSESSMENT_STARTED]: {
+        assessmentId: string;
+    };
+    [CHATBOT_EVENTS.ASSESSMENT_ENDED]: {
+        assessmentId: string;
+    };
+    [CHATBOT_EVENTS.ASSESSMENT_DUPLICATED]: {
+        assessmentId: string;
+        duplicatedWithAssessmentLink?: string;
+    };
+    [CHATBOT_EVENTS.ANSWER_SAVED]: {
+        questionId: string;
+    };
+    [CHATBOT_EVENTS.ANSWER_EDITED]: {
+        questionId: string;
+    };
+    [CHATBOT_EVENTS.ERROR]: {
+        type: string;
+        message: string;
+    };
+    [CHATBOT_EVENTS.LOG]: {
+        type: string;
+        message: string;
+    };
+};
+type Handler<E extends ChatbotEventName> = (payload: ChatbotEventMap[E]) => void;
+export declare class ChatbotEventEmitter {
+    private handlers;
+    on<E extends ChatbotEventName>(event: E, handler: Handler<E>): () => void;
+    off<E extends ChatbotEventName>(event: E, handler: Handler<E>): void;
+    emit<E extends ChatbotEventName>(event: E, payload: ChatbotEventMap[E]): void;
+}
+export {};

package/dist/core/i18n/fallback.d.ts

@@ -0,0 +1,2 @@
+import { TranslationFile } from './translator';
+export declare const FALLBACK_TRANSLATIONS: TranslationFile;

package/dist/core/i18n/languages.d.ts

@@ -0,0 +1,11 @@
+export declare const SUPPORTED_LANGUAGES: readonly ["en-GB", "en-US", "fr", "es", "de", "fi", "da", "nl", "it", "sv", "nb", "pl", "ar"];
+export type SupportedLanguage = (typeof SUPPORTED_LANGUAGES)[number];
+export declare const FALLBACK_LANGUAGE: SupportedLanguage;
+/** Right-to-left languages (base code). */
+export declare const RTL_LANGUAGES: readonly ["ar"];
+/** Map a browser language tag to a supported language (any en-* → en-US). */
+export declare const normalizeLanguage: (browserLanguage?: string) => SupportedLanguage;
+/** Resolve the interview language: explicit override, else the browser default. */
+export declare const resolveLanguage: (override?: string, browserLanguage?: string) => SupportedLanguage;
+export declare const isRtlLanguage: (language: string) => boolean;
+export declare const directionForLanguage: (language: string) => "rtl" | "ltr";

package/dist/core/i18n/translator.d.ts

@@ -0,0 +1,13 @@
+export type TranslationFile = Record<string, string>;
+/** Replaces {{name}} placeholders with params; missing params become ''. */
+export declare const interpolate: (template: string, params?: Record<string, string | number>) => string;
+export type TranslateOptions = {
+    count?: number;
+} & Record<string, string | number>;
+export type Translator = (key: string, options?: TranslateOptions) => string;
+/**
+ * Builds a translator that looks up the fetched file, then the bundled
+ * fallback, then returns the key itself (so missing keys are visible, never
+ * throw — unlike the legacy translator which threw on missing keys).
+ */
+export declare const createTranslator: (file: TranslationFile | undefined, fallback: TranslationFile) => Translator;

package/dist/core/interview.d.ts

@@ -0,0 +1,207 @@
+import { ChatbotApiClient } from '../api/client';
+import { PiiErrorKey } from './validation/pii';
+import { ChatbotEventEmitter } from './events';
+import { InterviewStore } from './store';
+export declare const ERROR_TYPE_START_FAILED = "FI_START_ASSESSMENT_FAILED";
+export declare const ERROR_TYPE_LOAD_NEXT_FAILED = "FI_LOAD_NEXT_FAILED";
+export declare const ERROR_TYPE_EXTRACT_NAME_FAILED = "FI_EXTRACT_HUMAN_NAME_FAILED";
+export declare const ERROR_TYPE_EDIT_ANSWER_FAILED = "FI_EDIT_ANSWER_FAILED";
+export declare const ERROR_TYPE_UPLOAD_VIDEO_FAILED = "FI_SUBMIT_VIDEO_ANSWER_FAILED";
+export declare const ERROR_TYPE_TRANSLATION_FAILED = "FI_GET_TRANSLATION_FAILED";
+export declare const ERROR_TYPE_VERIFY_ACCESS_FAILED = "FI_VERIFY_ACCESS_FAILED";
+export declare const ERROR_TYPE_DETECT_AGC_FAILED = "FI_DETECT_AGC_FAILED";
+export declare const LOG_TYPE_INVALID_PHONE_NUMBER = "INVALID_PHONE_NUMBER";
+export declare const LOG_TYPE_INVALID_PASTE_ANSWER_ACTION = "INVALID_PASTE_ANSWER_ACTION";
+/** Result of a validated PII submission (drives the UI error/confirm modals). */
+export type PiiSubmitOutcome = {
+    status: 'submitted';
+} | {
+    status: 'invalid';
+    errorKey: PiiErrorKey;
+} | {
+    status: 'confirm-name';
+    suggested: string;
+    original: string;
+};
+export type InterviewEngineDeps = {
+    client: ChatbotApiClient;
+    store: InterviewStore;
+    emitter: ChatbotEventEmitter;
+    assessmentId: string;
+    /** Resolved interview language; translations are fetched for it on start. */
+    language?: string;
+    /** Injectable for tests; defaults to the browser UA. */
+    userAgent?: string;
+    /** Show the pre-interview welcome gate on a fresh start (off by default). */
+    welcomeGate?: boolean;
+    /** Per-char reveal cadence (ms) while streaming; 0 reveals each chunk wholesale (reduced-motion). */
+    streamRevealMs?: number;
+};
+export declare class InterviewEngine {
+    private readonly client;
+    private readonly store;
+    private readonly emitter;
+    private readonly assessmentId;
+    private readonly userAgent;
+    private readonly language;
+    private readonly welcomeGate;
+    private readonly streamRevealMs;
+    /** Aborts the in-flight stream when a new load starts. */
+    private streamAbort?;
+    /** Monotonic counter for unique live-bubble ids (avoids Date.now in core). */
+    private streamSeq;
+    private lastFailedInput?;
+    /** Bubble whose answer submission is in flight (optimistic FTQ or inline option bubble). */
+    private pendingBubbleId?;
+    /** Retained recorded video for retry after an upload failure. */
+    private lastVideoAnswer?;
+    /** Option id held back pending the AGC warning resolution. */
+    private pendingAgcOptionId?;
+    constructor(deps: InterviewEngineDeps);
+    /** Fetch the translation file; on failure the bundled fallback is used. */
+    private loadTranslations;
+    /**
+     * Entry point: gate the interview on email access verification when the
+     * assessment requires it (legacy AccessVerification), else start directly.
+     * A still-valid cached email is re-verified silently.
+     */
+    begin(): Promise<void>;
+    /** Verify a candidate email against the gate; on success cache it and start. */
+    verifyAccessEmail(email: string): Promise<void>;
+    start(): Promise<void>;
+    /** Raw chatLogs captured at start, replayed by firstLoad once the welcome gate clears. */
+    private welcomeChatLogs;
+    /**
+     * Candidate clicked "Next" on the welcome screen — reveal the chat and play
+     * the agent's opening message(s). No-op unless we're holding at the gate.
+     */
+    confirmWelcome(): Promise<void>;
+    /**
+     * Ported from legacy firstLoadMessageBasedOnChatLogs: empty history → fetch the
+     * first message; history ending in a HINT (either the agent's question or the
+     * candidate's ack of it) → acknowledge it to fetch the next one. On a finished
+     * assessment the re-ack returns no nextResponse, which ends the interview.
+     */
+    private firstLoad;
+    /**
+     * Submit a free-text answer to the current (last agent) question. `html` is
+     * the optional sanitized rich-text rendering; `text` remains the plain-text
+     * source the backend scores against.
+     */
+    submitTextAnswer(text: string, html?: string): Promise<void>;
+    /** Validate then submit an email PII answer (legacy FTQResponse email branch). */
+    submitEmailAnswer(text: string): Promise<PiiSubmitOutcome>;
+    /**
+     * Validate + normalize a phone PII answer to E.164 then submit. On a
+     * possible-but-invalid number, emits the legacy INVALID_PHONE_NUMBER log event.
+     */
+    submitPhoneAnswer(text: string, countryCode: string): Promise<PiiSubmitOutcome>;
+    /**
+     * Validate a name PII answer. If it likely contains more than the asked-for
+     * name part, call extract-human-name; when the extracted value differs, return
+     * a confirm outcome for the UI (legacy NameExtractionConfirmModal). Otherwise
+     * submit directly. Confirm via submitNameConfirmed.
+     */
+    submitNameAnswer(text: string): Promise<PiiSubmitOutcome>;
+    /** Submit the name value the candidate confirmed in the extraction modal. */
+    submitNameConfirmed(text: string): Promise<void>;
+    /** Submit a location PII answer (address text + serialized place; legacy handleSelectLocation). */
+    submitLocationAnswer(location: {
+        address: string;
+        [key: string]: unknown;
+    }): Promise<void>;
+    /**
+     * Re-edit a previously answered question (legacy EDIT_MODE_ENTER): mark its
+     * candidate bubble EDITING so the input/options re-appear; the next submit
+     * routes to edit-answer instead of next.
+     */
+    enterEditMode(questionId: string): void;
+    /** Cancel an in-progress edit, restoring the answered bubble (legacy EDIT_MODE_EXIT). */
+    cancelEditMode(): void;
+    /**
+     * Upload a recorded video answer then submit its server filename (legacy
+     * useUploadVideo + ChatbotStateContext video answer): append a PENDING video
+     * bubble showing upload progress, get the S3 signed URL, PUT the blob, then
+     * POST the returned videoFileName to /next. On failure the bubble goes FAILED
+     * and the blob is retained for retry.
+     */
+    submitVideoAnswer(blob: Blob, extension: string): Promise<void>;
+    /** Retry a failed video upload with the retained blob. */
+    retryVideoAnswer(): Promise<void>;
+    /** Fetch a signed playback URL for a recorded video answer (legacy getVideoAccessUrl). */
+    getVideoPlaybackUrl(questionId: string, extension: string): Promise<string>;
+    private upsertVideoBubble;
+    private removeBubble;
+    private submitFreeText;
+    /** Routes an answer to edit-answer when re-editing, else to the next-question flow. */
+    private dispatchFreshOrEdit;
+    /** Submit an edited answer (legacy useSubmitEditedAnswer + EDIT_ANSWER_REQUEST_COMPLETED). */
+    private editExistingAnswer;
+    /** Question being answered: the one under edit if editing, else the last agent bubble. */
+    private currentEditableQuestionId;
+    private currentPiiType;
+    /**
+     * Submit the selected option (MCQ/DROPDOWN/BGQ, incl. the terms-accept MCQ) of the
+     * current question. The option lives in the inline candidate bubble appended by
+     * bubble conversion; BGQ buttons echo their triggers/style back in the answer
+     * (ported from legacy handleSelectOption / handleSelectBGQButton).
+     */
+    submitOptionAnswer(optionId: string, skipAgcDetection?: boolean): Promise<void>;
+    /**
+     * Calls detect-agc when submitting the SUBMIT_QUESTION_MESSAGE and a check is
+     * allowed; returns true (→ show warning) when automated content is suspected.
+     */
+    private detectedAgc;
+    /** Continue submitting after the AGC warning (legacy "Continue" — skips re-detection). */
+    continueAfterAgcWarning(): Promise<void>;
+    /** Dismiss the AGC warning to edit the answer (legacy "Edit"). */
+    dismissAgcWarning(): void;
+    /** Emits the legacy INVALID_PASTE_ANSWER_ACTION log when paste is disallowed. */
+    reportPaste(): void;
+    /** Submit the experience-rating slider score (legacy handleSubmitRating). */
+    submitSliderAnswer(score: number): Promise<void>;
+    /** Stamp the inline candidate bubble with the chosen answer and send it (or edit it). */
+    private submitInlineAnswer;
+    /** Re-submit the answer whose bubble is in FAILED state. */
+    retryLastAnswer(): Promise<void>;
+    private currentQuestionId;
+    /** The synthetic candidate bubble holding the question's selectable options. */
+    private inlineCandidateBubble;
+    private appendOptimisticCandidateBubble;
+    private setPendingBubbleStatus;
+    /** Swap the in-flight bubble for the server-confirmed candidate response. */
+    private replacePendingBubble;
+    /**
+     * Loads the next message via /next/stream (the sole load path): consumes the
+     * AG-UI stream, revealing agent text char-by-char into a transient live bubble,
+     * then swaps it for the authoritative bubble from the terminal RUN_FINISHED
+     * frame. Shares the candidate-settle and agent-append tails with the answer flow.
+     */
+    private loadNext;
+    /** Minimal agent bubble for the streaming text (mirrors convertRawAgentResponseToMessageBubble
+     * for a single TEXT content); meta, when present, seeds types/rules/tags so the live bubble
+     * can render as the question card from the first character. While revealing, the content is
+     * typed out as plain TEXT; once `committed`, the snapshot content's BE render indicators
+     * (types/component) are applied so a bundled video hint settles to the embedded player
+     * instead of leaking its URL as text. */
+    private buildLiveBubble;
+    /**
+     * Handle terminal/duplicate signals on a response (legacy
+     * chatbotStateReducer): emit assessment:duplicated and render a terminal
+     * agent message (archived cohort / reused assessment), ending the interview.
+     * Returns true when the interview has been terminated.
+     */
+    private handleTerminalSignals;
+    /**
+     * Settle the in-flight candidate bubble with the server-confirmed response and
+     * update the meta fields, then handle terminal/duplicate signals.
+     * Returns true when the interview has been terminated (caller stops).
+     */
+    private settleAnswerAndStatus;
+    /**
+     * Append the authoritative next agent bubble (plus any inline option/slider
+     * candidate bubble), recurse on HINTs, and end the interview when there is no
+     * next question. Assumes the answer is already settled and the live bubble removed.
+     */
+    private appendAgentAndContinue;
+}