@e-llm-studio/feedback-flow 0.0.0-stage → 0.1.31

package/dist/types.d.ts

@@ -0,0 +1,276 @@
+import type { CSSProperties } from "react";
+export type FeedbackSeverity = "critical" | "high" | "medium" | "low";
+export interface FeedbackAttachmentRef {
+    attachmentId: string;
+    gcsUrl: string;
+    publicUrl?: string;
+    name: string;
+    type?: string;
+    size?: number;
+    lastModified?: number;
+}
+export interface FeedbackGap {
+    /** Existing server identity; absent only for a newly added gap. */
+    negativeId?: string;
+    description: string;
+    severity?: FeedbackSeverity;
+    /** The short-answer follow-up has been shown for this gap. */
+    detailRequested?: boolean;
+    screenshots: (File | FeedbackAttachmentRef)[];
+}
+export interface FeedbackSubmission {
+    requestId: string;
+    featureId: string;
+    rating: number;
+    timeSavedMinutes?: number;
+    mostUseful?: string;
+    usefulMoreDetail?: string;
+    usefulDetailShown?: boolean;
+    gaps: FeedbackGap[];
+    metadata?: FeedbackMetadata;
+}
+export type FeedbackProgressStep = "rating" | "time" | "useful" | "gap" | "success";
+/** Host-defined context included with every submission; the library does not interpret it. */
+export type FeedbackMetadata = Record<string, unknown> & {
+    mode?: string;
+    modeId?: string;
+    owner?: string;
+    featureContext?: string;
+    userEmail?: string;
+    traceId?: string;
+    /** Optional backend query ID for the response being rated. */
+    queryId?: string;
+    /** Optional chat session ID; typically supplied by LSC hosts. */
+    sessionId?: string;
+    /** Optional request ID of the AI response being rated. */
+    requestId?: string;
+    /** Saved after each completed step so an interrupted form can resume. */
+    feedbackProgress?: {
+        nextStep: FeedbackProgressStep;
+        completed: boolean;
+    };
+};
+/** Context supplied by each integration; custom fields are flattened into submission.metadata. */
+export interface FeedbackTrackingContext {
+    mode?: string;
+    modeId?: string;
+    owner?: string;
+    featureContext?: string;
+    userEmail?: string;
+    traceId?: string;
+    custom?: Record<string, unknown>;
+}
+export interface FeedbackCopy {
+    prompt: string;
+    continueLabel: string;
+    savedLabel: string;
+    reviewLabel: string;
+    fiveStarTooltip: string;
+    starTooltipLabel?: (star: number) => string;
+    starGroupLabel: string;
+    starLabel: (star: number) => string;
+    backLabel: string;
+    closeLabel: string;
+    ratingControlLabel: string;
+    ratingContinueLabel: string;
+    ratingTitle: string;
+    ratingSubtitle: string;
+    ratingHint: string;
+    enterHint: string;
+    ratingValueLabel: (rating: number) => string;
+    timeSavedTitle: string;
+    positiveRatingIntroTitle: string;
+    positiveRatingIntroDescription: string;
+    timeOptions: {
+        value: number;
+        label: string;
+    }[];
+    otherLabel: string;
+    minuteUnit: string;
+    usefulTitle: string;
+    lowRatingUsefulTitle: string;
+    usefulMoreDetailTitle: string;
+    usefulMoreDetailPrompt: string;
+    usefulPlaceholder: string;
+    usefulMinimumWords: number;
+    gapTitle: string;
+    fiveStarGapTitle: string;
+    lowRatingIntroTitle: string;
+    lowRatingIntroDescription: string;
+    gapSubtitle: string;
+    gapMoreDetailPrompt: string;
+    gapPlaceholder: string;
+    severityQuestion: string;
+    severityLabels: Record<FeedbackSeverity, string>;
+    attachScreenshot: string;
+    addAnotherGap: string;
+    nextLabel: string;
+    doneLabel: string;
+    saveChangesLabel: string;
+    savingLabel: string;
+    submitErrorLabel: string;
+    successTitle: string;
+    successDescription: string;
+    successComingSoon: string;
+}
+export interface FeedbackTheme {
+    accent?: string;
+    text?: string;
+    muted?: string;
+    border?: string;
+    surface?: string;
+    gapSurface?: string;
+    overlay?: string;
+    success?: string;
+    starEmpty?: string;
+    tooltipBackground?: string;
+    tooltipText?: string;
+    severityColors?: Partial<Record<FeedbackSeverity, string>>;
+    severityBackgrounds?: Partial<Record<FeedbackSeverity, string>>;
+}
+export declare const defaultFeedbackCopy: FeedbackCopy;
+export declare const defaultFeedbackTheme: FeedbackTheme;
+export declare function createFeedbackTheme(overrides?: Partial<FeedbackTheme>): FeedbackTheme;
+export declare function createFeedbackCopy(overrides?: Partial<Omit<FeedbackCopy, "severityLabels">> & {
+    severityLabels?: Partial<FeedbackCopy["severityLabels"]>;
+}): FeedbackCopy;
+export interface StarRatingStyles {
+    root?: CSSProperties;
+    starButton?: CSSProperties;
+    starIcon?: CSSProperties;
+}
+export interface StarRatingClassNames {
+    root?: string;
+    starButton?: string;
+    starIcon?: string;
+}
+export interface FeedbackPromptStyles {
+    root?: CSSProperties;
+    labelButton?: CSSProperties;
+    stars?: CSSProperties;
+    starRating?: StarRatingStyles;
+    reviewButton?: CSSProperties;
+    tooltip?: CSSProperties;
+    extraContent?: CSSProperties;
+}
+export interface FeedbackPromptClassNames {
+    root?: string;
+    labelButton?: string;
+    stars?: string;
+    starRating?: StarRatingClassNames;
+    reviewButton?: string;
+    tooltip?: string;
+    extraContent?: string;
+}
+export interface FeedbackModalStyles {
+    backdrop?: CSSProperties;
+    dialog?: CSSProperties;
+    content?: CSSProperties;
+    topbar?: CSSProperties;
+    backButton?: CSSProperties;
+    closeButton?: CSSProperties;
+    title?: CSSProperties;
+    subtitle?: CSSProperties;
+    hint?: CSSProperties;
+    enterHintButton?: CSSProperties;
+    rangeContainer?: CSSProperties;
+    rangeTooltip?: CSSProperties;
+    rangeInput?: CSSProperties;
+    ratingOptionsContainer?: CSSProperties;
+    ratingOptionButton?: CSSProperties;
+    ratingOptionButtonSelected?: CSSProperties;
+    timePillsContainer?: CSSProperties;
+    timePillButton?: CSSProperties;
+    timePillButtonSelected?: CSSProperties;
+    customTimeWrapper?: CSSProperties;
+    customTimeInput?: CSSProperties;
+    footer?: CSSProperties;
+    usefulTitle?: CSSProperties;
+    usefulPrompt?: CSSProperties;
+    usefulField?: CSSProperties;
+    usefulTextarea?: CSSProperties;
+    gapList?: CSSProperties;
+    gapItem?: CSSProperties;
+    gapTextarea?: CSSProperties;
+    severityTitle?: CSSProperties;
+    severityContainer?: CSSProperties;
+    severityButton?: CSSProperties;
+    uploadButton?: CSSProperties;
+    uploadInput?: CSSProperties;
+    filesList?: CSSProperties;
+    fileTag?: CSSProperties;
+    addGapButton?: CSSProperties;
+    submitError?: CSSProperties;
+    successContainer?: CSSProperties;
+    successCheck?: CSSProperties;
+    successTitle?: CSSProperties;
+    successDescription?: CSSProperties;
+    successComingSoon?: CSSProperties;
+    actionBar?: CSSProperties;
+    primaryButton?: CSSProperties;
+    reviewNav?: CSSProperties;
+    reviewNavButton?: CSSProperties;
+    reviewNavNextButton?: CSSProperties;
+}
+export interface FeedbackModalClassNames {
+    backdrop?: string;
+    dialog?: string;
+    content?: string;
+    topbar?: string;
+    backButton?: string;
+    closeButton?: string;
+    title?: string;
+    subtitle?: string;
+    hint?: string;
+    enterHintButton?: string;
+    rangeContainer?: string;
+    rangeTooltip?: string;
+    rangeInput?: string;
+    ratingOptionsContainer?: string;
+    ratingOptionButton?: string;
+    ratingOptionButtonSelected?: string;
+    timePillsContainer?: string;
+    timePillButton?: string;
+    timePillButtonSelected?: string;
+    customTimeWrapper?: string;
+    customTimeInput?: string;
+    footer?: string;
+    usefulTitle?: string;
+    usefulPrompt?: string;
+    usefulField?: string;
+    usefulTextarea?: string;
+    gapList?: string;
+    gapItem?: string;
+    gapTextarea?: string;
+    severityTitle?: string;
+    severityContainer?: string;
+    severityButton?: string;
+    uploadButton?: string;
+    uploadInput?: string;
+    filesList?: string;
+    fileTag?: string;
+    addGapButton?: string;
+    submitError?: string;
+    successContainer?: string;
+    successCheck?: string;
+    successTitle?: string;
+    successDescription?: string;
+    successComingSoon?: string;
+    actionBar?: string;
+    primaryButton?: string;
+    reviewNav?: string;
+    reviewNavButton?: string;
+    reviewNavNextButton?: string;
+}
+export interface FeedbackExperienceStyles {
+    container?: CSSProperties;
+    floatingWrapper?: CSSProperties;
+    prompt?: FeedbackPromptStyles;
+    modal?: FeedbackModalStyles;
+}
+export interface FeedbackExperienceClassNames {
+    container?: string;
+    floatingWrapper?: string;
+    prompt?: FeedbackPromptClassNames;
+    modal?: FeedbackModalClassNames;
+}

package/dist/types.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultFeedbackTheme = exports.defaultFeedbackCopy = void 0;
+exports.createFeedbackTheme = createFeedbackTheme;
+exports.createFeedbackCopy = createFeedbackCopy;
+exports.defaultFeedbackCopy = {
+    prompt: "Help us help you!",
+    continueLabel: "Continue",
+    savedLabel: "Feedback Saved",
+    reviewLabel: "Review",
+    fiveStarTooltip: "5 · Next Level Useful – Enhances my Life",
+    starTooltipLabel: (star) => ({
+        1: "1 · Not useful — missed what I needed",
+        2: "2 · Slightly useful — needs improvement",
+        3: "3 · Somewhat useful — helped in part",
+        4: "4 · Very useful — saved me effort",
+        5: "5 · Next Level Useful — Enhances my Life",
+    }[star] ?? `${star} stars`),
+    starGroupLabel: "Rate this response",
+    starLabel: (star) => `${star} star${star === 1 ? "" : "s"}`,
+    backLabel: "Back",
+    closeLabel: "Close",
+    ratingControlLabel: "Fine tune rating",
+    ratingContinueLabel: "Continue to time saved question",
+    ratingTitle: "Somewhere in between? Fine-tune your rating to what feels right!",
+    ratingSubtitle: "Your input shapes what we improve next.",
+    ratingHint: "Select the rating that conveys the best",
+    enterHint: "Press Enter ↵ to continue",
+    ratingValueLabel: (rating) => {
+        const descriptions = {
+            "3.0": "A starting point, but I need more",
+            "3.1": "A little more helpful than average",
+            "3.2": "Useful for some of what I needed",
+            "3.3": "Helpful, with room to improve",
+            "3.4": "Solid help on this task",
+            "3.5": "Good help, though not quite complete",
+            "3.6": "Helpful for most of my task",
+            "3.7": "Quite useful, with minor gaps",
+            "3.8": "Very helpful overall",
+            "3.9": "Nearly everything I needed",
+            "4.0": "Helpful enough to move me forward",
+            "4.1": "Strong help for this task",
+            "4.2": "Made my work noticeably easier",
+            "4.3": "Really useful and reliable",
+            "4.4": "Saved me considerable effort",
+            "4.5": "Excellent help — made a difference",
+            "4.6": "Extremely useful for my work",
+            "4.7": "Almost indispensable today",
+            "4.8": "Outstanding — exceeded expectations",
+            "4.9": "Nearly perfect for what I needed",
+            "5.0": "Exactly what I needed today",
+        };
+        return `${rating.toFixed(1)} · ${descriptions[rating.toFixed(1)] ?? "Useful"}`;
+    },
+    timeSavedTitle: "How much time (in mins) did this save you?",
+    positiveRatingIntroTitle: "We’re so glad you’re enjoying it!",
+    positiveRatingIntroDescription: "What stood out to you today? Tell us in a few quick steps so we can keep making your experience great!",
+    timeOptions: [2, 5, 10, 20].map((value) => ({ value, label: `${value} min` })),
+    otherLabel: "✎ Other",
+    minuteUnit: "min",
+    usefulTitle: "What part did you find most useful?",
+    lowRatingUsefulTitle: "What did you find most useful?",
+    usefulMoreDetailTitle: "What did you find most useful?",
+    usefulMoreDetailPrompt: "Could you share a little more detail to understand you better?",
+    usefulPlaceholder: "The part that helped me most was...",
+    usefulMinimumWords: 10,
+    gapTitle: "What’s the biggest gap we could improve to make it better?",
+    fiveStarGapTitle: "Is there anything we could improve to make this even better?",
+    lowRatingIntroTitle: "We’re truly sorry. You deserve a better experience!",
+    lowRatingIntroDescription: "Tell us what went wrong in a few quick steps, so we can make things better for you.",
+    gapSubtitle: "Help us help you better",
+    gapMoreDetailPrompt: "Could you share a little more detail to help you better?",
+    gapPlaceholder: "Tell us about the gap...",
+    severityQuestion: "How severely does this issue impact your work?",
+    severityLabels: { critical: "Critical", high: "High", medium: "Medium", low: "Low" },
+    attachScreenshot: "Attach a screenshot",
+    addAnotherGap: "Add another gap",
+    nextLabel: "Next →",
+    doneLabel: "Done!",
+    saveChangesLabel: "Save changes",
+    savingLabel: "Saving feedback…",
+    submitErrorLabel: "Feedback could not be saved. Please try again.",
+    successTitle: "Thank you for your feedback!",
+    successDescription: "Your feedback is valuable and our team is already reviewing it.",
+    successComingSoon: "Coming soon",
+};
+exports.defaultFeedbackTheme = {
+    accent: "#6025e5",
+    text: "#172033",
+    muted: "#718096",
+    border: "#c8b6ff",
+    surface: "#fff",
+    gapSurface: "#faf8ff",
+    overlay: "#11182755",
+    success: "#16a34a",
+    starEmpty: "#cbd5e1",
+    tooltipBackground: "#344054",
+    tooltipText: "#fff",
+    severityColors: {
+        critical: "#dc2626",
+        high: "#ea580c",
+        medium: "#c89b25",
+        low: "#64748b",
+    },
+    severityBackgrounds: {
+        critical: "#fff1f2",
+        high: "#fff7ed",
+        medium: "#fefce8",
+        low: "#f8fafc",
+    },
+};
+function createFeedbackTheme(overrides) {
+    if (!overrides)
+        return exports.defaultFeedbackTheme;
+    return {
+        ...exports.defaultFeedbackTheme,
+        ...overrides,
+        severityColors: {
+            ...exports.defaultFeedbackTheme.severityColors,
+            ...overrides.severityColors,
+        },
+        severityBackgrounds: {
+            ...exports.defaultFeedbackTheme.severityBackgrounds,
+            ...overrides.severityBackgrounds,
+        },
+    };
+}
+function createFeedbackCopy(overrides = {}) {
+    const source = overrides && typeof overrides === "object" ? overrides : {};
+    const labels = source.severityLabels && typeof source.severityLabels === "object" ? source.severityLabels : {};
+    const copy = { ...exports.defaultFeedbackCopy };
+    for (const key of Object.keys(exports.defaultFeedbackCopy)) {
+        if (key === "severityLabels" || key === "timeOptions")
+            continue;
+        const value = source[key];
+        if (typeof value === typeof exports.defaultFeedbackCopy[key]) {
+            // This keeps missing and malformed integrations from replacing safe defaults.
+            Object.assign(copy, { [key]: value });
+        }
+    }
+    const validTimeOptions = Array.isArray(source.timeOptions)
+        ? source.timeOptions.filter((option) => typeof option?.value === "number" && Number.isFinite(option.value) && option.value >= 0 && typeof option.label === "string")
+        : [];
+    return {
+        ...copy,
+        timeOptions: validTimeOptions.length ? validTimeOptions : exports.defaultFeedbackCopy.timeOptions,
+        severityLabels: {
+            ...exports.defaultFeedbackCopy.severityLabels,
+            ...Object.fromEntries(Object.keys(exports.defaultFeedbackCopy.severityLabels).filter((severity) => typeof labels[severity] === "string").map((severity) => [severity, labels[severity]])),
+        },
+    };
+}

package/dist/useFeedbackFlow.d.ts

@@ -0,0 +1,32 @@
+import { type Dispatch, type SetStateAction } from "react";
+import type { FeedbackGap, FeedbackMetadata, FeedbackProgressStep, FeedbackSubmission } from "./types";
+export type FeedbackStep = "closed" | FeedbackProgressStep;
+export declare function useFeedbackFlow(requestId: string, featureId: string, metadata?: FeedbackMetadata): FeedbackFlowController;
+export interface FeedbackFlowController {
+    requestId: string;
+    featureId: string;
+    step: FeedbackStep;
+    setStep: (step: FeedbackStep) => void;
+    resumeStep: FeedbackStep;
+    rating: number | null;
+    setRating: (rating: number) => void;
+    setReviewRating: (rating: number) => void;
+    ratingBase: number;
+    selectRating: (rating: number) => void;
+    timeSavedMinutes: number | undefined;
+    setTimeSavedMinutes: (minutes: number | undefined) => void;
+    mostUseful: string;
+    setMostUseful: (text: string) => void;
+    usefulMoreDetail: string;
+    setUsefulMoreDetail: (text: string) => void;
+    usefulDetailShown: boolean;
+    setUsefulDetailShown: (shown: boolean) => void;
+    gaps: FeedbackGap[];
+    setGaps: Dispatch<SetStateAction<FeedbackGap[]>>;
+    completed: boolean;
+    setCompleted: (completed: boolean) => void;
+    ratingLocked: boolean;
+    close: () => void;
+    submission: FeedbackSubmission | null;
+    loadSavedSubmission: (submission: FeedbackSubmission) => void;
+}

package/dist/useFeedbackFlow.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFeedbackFlow = useFeedbackFlow;
+const react_1 = require("react");
+function useFeedbackFlow(requestId, featureId, metadata) {
+    const [step, setStep] = (0, react_1.useState)("closed");
+    const [resumeStep, setResumeStep] = (0, react_1.useState)("rating");
+    const [rating, setRating] = (0, react_1.useState)(null);
+    const [ratingBase, setRatingBase] = (0, react_1.useState)(4);
+    const [timeSavedMinutes, setTimeSavedMinutes] = (0, react_1.useState)();
+    const [mostUseful, setMostUseful] = (0, react_1.useState)("");
+    const [usefulMoreDetail, setUsefulMoreDetail] = (0, react_1.useState)("");
+    const [usefulDetailShown, setUsefulDetailShown] = (0, react_1.useState)(false);
+    const [gaps, setGaps] = (0, react_1.useState)([{ description: "", screenshots: [] }]);
+    const [completed, setCompleted] = (0, react_1.useState)(false);
+    const [ratingLocked, setRatingLocked] = (0, react_1.useState)(false);
+    const hasInteracted = (0, react_1.useRef)(false);
+    (0, react_1.useEffect)(() => {
+        hasInteracted.current = false;
+        setStep("closed");
+        setResumeStep("rating");
+        setRating(null);
+        setRatingBase(4);
+        setTimeSavedMinutes(undefined);
+        setMostUseful("");
+        setUsefulMoreDetail("");
+        setUsefulDetailShown(false);
+        setGaps([{ description: "", screenshots: [] }]);
+        setCompleted(false);
+        setRatingLocked(false);
+    }, [requestId, featureId]);
+    (0, react_1.useEffect)(() => {
+        if (step !== "closed" && step !== "success")
+            setResumeStep(step);
+    }, [step]);
+    const clearDraft = (0, react_1.useCallback)(() => {
+        setTimeSavedMinutes(undefined);
+        setMostUseful("");
+        setUsefulMoreDetail("");
+        setUsefulDetailShown(false);
+        setGaps([{ description: "", screenshots: [] }]);
+        setCompleted(false);
+        setRatingLocked(false);
+    }, []);
+    const changeRating = (0, react_1.useCallback)((value) => {
+        hasInteracted.current = true;
+        if (rating !== value)
+            clearDraft();
+        setRating(value);
+    }, [clearDraft, rating]);
+    const close = (0, react_1.useCallback)(() => {
+        setRatingLocked(true);
+        setStep("closed");
+    }, []);
+    const selectRating = (0, react_1.useCallback)((value) => {
+        hasInteracted.current = true;
+        // Keep the stars usable while their detail popup is open. Once dismissed,
+        // the closed card is read-only and the user resumes with Continue.
+        if (ratingLocked && step === "closed")
+            return;
+        changeRating(value);
+        setRatingBase(value);
+        if (value === 5) {
+            setResumeStep("time");
+            setStep("time");
+        }
+        else if (value === 3 || value === 4)
+            setStep("rating");
+        else if (value <= 2) {
+            setResumeStep("gap");
+            setStep("gap");
+        }
+        else
+            setStep("closed");
+    }, [changeRating, ratingLocked, step]);
+    const submission = (0, react_1.useMemo)(() => rating === null
+        ? null
+        : {
+            requestId,
+            featureId,
+            rating,
+            timeSavedMinutes,
+            mostUseful: mostUseful.trim() || undefined,
+            usefulDetailShown,
+            gaps: gaps.filter((gap) => gap.description.trim() || gap.screenshots.length),
+            metadata,
+        }, [featureId, gaps, metadata, mostUseful, rating, requestId, timeSavedMinutes, usefulMoreDetail, usefulDetailShown]);
+    const loadSavedSubmission = (0, react_1.useCallback)((saved) => {
+        if (hasInteracted.current || saved.requestId !== requestId || saved.featureId !== featureId)
+            return;
+        setRating(saved.rating);
+        setRatingBase(Math.floor(saved.rating));
+        setTimeSavedMinutes(saved.timeSavedMinutes);
+        const originalUseful = saved.mostUseful?.trim() ?? "";
+        const extraUseful = saved.usefulMoreDetail?.trim() ?? "";
+        setMostUseful(extraUseful
+            ? extraUseful.startsWith(originalUseful) ? extraUseful : `${originalUseful} ${extraUseful}`.trim()
+            : originalUseful);
+        setUsefulMoreDetail("");
+        setUsefulDetailShown(saved.usefulDetailShown ?? Boolean(saved.usefulMoreDetail));
+        setGaps(saved.gaps.length ? saved.gaps : [{ description: "", screenshots: [] }]);
+        const progress = saved.metadata?.feedbackProgress;
+        const isComplete = progress?.completed !== false;
+        setCompleted(isComplete);
+        setRatingLocked(isComplete);
+        setResumeStep(!isComplete && progress ? progress.nextStep : "rating");
+        setStep("closed");
+    }, [requestId, featureId]);
+    return {
+        requestId,
+        featureId,
+        step,
+        setStep,
+        resumeStep,
+        rating,
+        setRating: changeRating,
+        setReviewRating: changeRating,
+        ratingBase,
+        selectRating,
+        timeSavedMinutes,
+        setTimeSavedMinutes,
+        mostUseful,
+        setMostUseful,
+        usefulMoreDetail,
+        setUsefulMoreDetail,
+        usefulDetailShown,
+        setUsefulDetailShown,
+        gaps,
+        setGaps,
+        completed,
+        setCompleted,
+        ratingLocked,
+        close,
+        submission,
+        loadSavedSubmission,
+    };
+}

package/dist/useFeedbackPersistence.d.ts

@@ -0,0 +1,12 @@
+import { type FeedbackApi } from "./feedbackApi";
+import type { FeedbackFlowController } from "./useFeedbackFlow";
+import type { FeedbackProgressStep, FeedbackSubmission } from "./types";
+/** Loads saved feedback and saves new/reviewed answers through an interchangeable API. */
+export declare function useFeedbackPersistence(flow: FeedbackFlowController, metadata: FeedbackSubmission["metadata"], onSubmit?: (submission: FeedbackSubmission) => void | Promise<void>, api?: FeedbackApi): {
+    saveFeedback: (submission: FeedbackSubmission) => Promise<void>;
+    saveProgress: (submission: FeedbackSubmission, nextStep: FeedbackProgressStep) => Promise<void>;
+    saveOnDismiss: (submission: FeedbackSubmission, nextStep: FeedbackProgressStep, completed: boolean) => Promise<void>;
+    isLoading: boolean;
+    isSaving: boolean;
+    saveError: boolean;
+};