@khanacademy/perseus 65.3.6 → 65.4.0

package/dist/widgets/interactive-graph.d.ts

@@ -6,7 +6,7 @@ import type { WidgetProps } from "../types";
 import type { InteractiveGraphPromptJSON } from "../widget-ai-utils/interactive-graph/interactive-graph-ai-utils";
 import type { UnsupportedWidgetPromptJSON } from "../widget-ai-utils/unsupported-widget";
 import type { QuadraticCoefficient, SineCoefficient, Range } from "@khanacademy/kmath";
-import type { PerseusGraphType, PerseusGraphTypeAngle, PerseusGraphTypePoint, PerseusGraphTypeSegment, GraphRange, LockedFigure, PerseusImageBackground, MarkingsType, PerseusInteractiveGraphUserInput, AxisLabelLocation } from "@khanacademy/perseus-core";
+import type { PerseusGraphType, PerseusGraphTypeAngle, PerseusGraphTypePoint, PerseusGraphTypeSegment, GraphRange, InteractiveGraphPublicWidgetOptions, LockedFigure, PerseusImageBackground, MarkingsType, PerseusInteractiveGraphUserInput, AxisLabelLocation } from "@khanacademy/perseus-core";
 type RenderProps = {
     /**
      * Where the little black axis lines & labels (ticks) should render.
@@ -89,9 +89,7 @@ type RenderProps = {
      */
     graph: PerseusGraphType;
     /**
-     * The correct answer for this widget. Will be undefined if the graph is
-     * being provided answerless data (e.g. because the learner has not yet
-     * submitted their guess).
+     * The correct answer for this widget.
      */
     correct?: PerseusGraphType;
     /**
@@ -108,7 +106,7 @@ type RenderProps = {
      */
     fullGraphAriaDescription?: string;
 };
-type Props = WidgetProps<RenderProps>;
+type Props = WidgetProps<RenderProps, PerseusInteractiveGraphUserInput>;
 type State = any;
 type DefaultProps = {
     labels: string[];
@@ -119,13 +117,103 @@ type DefaultProps = {
     markings: Props["markings"];
     showTooltips: Props["showTooltips"];
     showProtractor: Props["showProtractor"];
-    graph: Props["graph"];
+    userInput: Props["userInput"];
 };
 declare class InteractiveGraph extends React.Component<Props, State> {
     mafsRef: React.RefObject<StatefulMafsGraphType>;
     static defaultProps: DefaultProps;
     getUserInput(): PerseusInteractiveGraphUserInput;
     getPromptJSON(): InteractiveGraphPromptJSON | UnsupportedWidgetPromptJSON;
+    /**
+     * @deprecated and likely very broken API
+     * [LEMS-3185] do not trust serializedState/restoreSerializedState
+     */
+    getSerializedState(): {
+        graph: PerseusGraphType;
+        step: [number, number];
+        gridStep?: [x: number, y: number];
+        snapStep?: [x: number, y: number];
+        backgroundImage?: PerseusImageBackground;
+        markings: MarkingsType;
+        labels: string[];
+        labelLocation: AxisLabelLocation;
+        showProtractor: boolean;
+        showRuler?: boolean;
+        showTooltips?: boolean;
+        rulerLabel?: string;
+        rulerTicks?: number;
+        range: GraphRange;
+        correct?: PerseusGraphType;
+        lockedFigures: LockedFigure[];
+        fullGraphAriaLabel?: string;
+        fullGraphAriaDescription?: string;
+        reviewModeRubric?: Empty | null | undefined;
+        trackInteraction: (extraData?: Empty | undefined) => void;
+        widgetId: string;
+        alignment: string | null | undefined;
+        static: boolean | null | undefined;
+        problemNum: number | null | undefined;
+        apiOptions: Readonly<Readonly<{
+            isArticle?: boolean;
+            onFocusChange?: (newFocusPath: import("..").FocusPath, oldFocusPath: import("..").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
+            GroupMetadataEditor?: React.ComponentType<any>;
+            showAlignmentOptions?: boolean;
+            readOnly?: boolean;
+            answerableCallback?: (arg1: boolean) => unknown;
+            getAnotherHint?: () => unknown;
+            interactionCallback?: (widgetData: {
+                [widgetId: string]: any;
+            }) => void;
+            groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
+            imagePlaceholder?: React.ReactNode;
+            widgetPlaceholder?: React.ReactNode;
+            baseElements?: {
+                Link: React.ComponentType<any>;
+            };
+            imagePreloader?: (dimensions: import("../types").Dimensions) => React.ReactNode;
+            trackInteraction?: (args: {
+                type: string;
+                id: string;
+                correct?: boolean;
+            } & Partial<import("../types").TrackingGradedGroupExtraArguments> & Partial<{
+                visible: number;
+            }>) => void;
+            customKeypad?: boolean;
+            nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
+            isMobile?: boolean;
+            isMobileApp?: boolean;
+            setDrawingAreaAvailable?: (arg1: boolean) => unknown;
+            hintProgressColor?: string;
+            canScrollPage?: boolean;
+            editorChangeDelay?: number;
+            flags?: Record<"new-radio-widget", boolean>;
+            onWidgetStartProps?: (widgets: import("@khanacademy/perseus-core").PerseusWidgetsMap) => void;
+        }> & {
+            baseElements: NonNullable<import("..").APIOptions["baseElements"]>;
+            canScrollPage: NonNullable<import("..").APIOptions["canScrollPage"]>;
+            editorChangeDelay: NonNullable<import("..").APIOptions["editorChangeDelay"]>;
+            groupAnnotator: NonNullable<import("..").APIOptions["groupAnnotator"]>;
+            isArticle: NonNullable<import("..").APIOptions["isArticle"]>;
+            isMobile: NonNullable<import("..").APIOptions["isMobile"]>;
+            isMobileApp: NonNullable<import("..").APIOptions["isMobileApp"]>;
+            onFocusChange: NonNullable<import("..").APIOptions["onFocusChange"]>;
+            readOnly: NonNullable<import("..").APIOptions["readOnly"]>;
+            setDrawingAreaAvailable: NonNullable<import("..").APIOptions["setDrawingAreaAvailable"]>;
+            showAlignmentOptions: NonNullable<import("..").APIOptions["showAlignmentOptions"]>;
+        }>;
+        keypadElement?: any;
+        questionCompleted?: boolean;
+        onFocus: (blurPath: import("..").FocusPath) => void;
+        onBlur: (blurPath: import("..").FocusPath) => void;
+        findWidgets: (criterion: import("../types").FilterCriterion) => ReadonlyArray<import("../types").Widget>;
+        reviewMode: boolean;
+        showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
+        onChange: import("..").ChangeHandler;
+        handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
+        isLastUsedWidget: boolean;
+        linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
+        containerSizeClass: import("../util/sizing-utils").SizeClass;
+    };
     render(): React.JSX.Element;
     /**
      * @param {object} graph Like props.graph or props.correct
@@ -175,12 +263,19 @@ declare class InteractiveGraph extends React.Component<Props, State> {
     static getRayEquationString(props: Props): string;
     static getPolygonEquationString(props: Props): string;
     static getAngleEquationString(props: Props): string;
-    static getUserInputFromProps(props: Props): PerseusGraphType;
 }
+/**
+ * @deprecated and likely a very broken API
+ * [LEMS-3185] do not trust serializedState/restoreSerializedState
+ */
+declare function getUserInputFromSerializedState(serializedState: any): PerseusInteractiveGraphUserInput;
+declare function getStartUserInput(options: InteractiveGraphPublicWidgetOptions): PerseusGraphType;
 declare const _default: {
     name: string;
     displayName: string;
     widget: typeof InteractiveGraph;
     staticTransform: <T>(value: T) => T;
+    getStartUserInput: typeof getStartUserInput;
+    getUserInputFromSerializedState: typeof getUserInputFromSerializedState;
 };
 export default _default;

package/dist/widgets/interactive-graphs/interactive-graph-question-builder.d.ts

@@ -1,7 +1,7 @@
 import { vec } from "mafs";
 import type { SnapTo } from "./types";
 import type { Coord } from "../../interactive2/types";
-import type { AxisLabelLocation, CollinearTuple, LockedFigureColor, LockedFigureFillType, LockedLineStyle, MarkingsType, PerseusRenderer } from "@khanacademy/perseus-core";
+import type { AxisLabelLocation, CollinearTuple, LockedFigureColor, LockedFigureFillType, LockedLineStyle, MarkingsType, PerseusRenderer, StrokeWeight } from "@khanacademy/perseus-core";
 export type LockedFunctionOptions = {
     color?: LockedFigureColor;
     strokeStyle?: LockedLineStyle;
@@ -143,7 +143,8 @@ declare class InteractiveGraphQuestionBuilder {
         color?: LockedFigureColor;
         showVertices?: boolean;
         fillStyle?: LockedFigureFillType;
-        strokeStyle?: "solid" | "dashed";
+        strokeStyle?: LockedLineStyle;
+        weight?: StrokeWeight;
         labels?: LockedFigureLabelOptions[];
         ariaLabel?: string;
     }): InteractiveGraphQuestionBuilder;

package/dist/widgets/interactive-graphs/locked-figures/utils.d.ts

@@ -1 +1,3 @@
+import type { StrokeWeight } from "@khanacademy/perseus-core";
+export declare const strokeWeights: Record<StrokeWeight, number>;
 export declare function clampDomain(domain: [number, number], graphBounds: [number, number]): [number, number] | null;

package/dist/widgets/interactive-graphs/stateful-mafs-graph.d.ts

@@ -6,9 +6,7 @@ export type StatefulMafsGraphProps = {
     backgroundImage?: InteractiveGraphProps["backgroundImage"];
     graph: PerseusGraphType;
     /**
-     * The correct answer for this widget. Will be undefined if the graph is
-     * being provided answerless data (e.g. because the learner has not yet
-     * submitted their guess).
+     * The correct answer for this widget.
      */
     correct?: PerseusGraphType;
     lockedFigures: InteractiveGraphProps["lockedFigures"];
@@ -18,7 +16,7 @@ export type StatefulMafsGraphProps = {
     gridStep: [x: number, y: number];
     containerSizeClass: InteractiveGraphProps["containerSizeClass"];
     markings: InteractiveGraphProps["markings"];
-    onChange: InteractiveGraphProps["onChange"];
+    onChange: (userInput: PerseusGraphType) => void;
     showTooltips: Required<InteractiveGraphProps["showTooltips"]>;
     showProtractor: boolean;
     labels: ReadonlyArray<string>;

package/dist/widgets/interactive-graphs/types.d.ts

@@ -2,10 +2,10 @@ import type { InteractiveGraphAction } from "./reducer/interactive-graph-action"
 import type { Coord } from "../../interactive2/types";
 import type { WidgetProps } from "../../types";
 import type { QuadraticCoords } from "@khanacademy/kmath";
-import type { PerseusInteractiveGraphWidgetOptions } from "@khanacademy/perseus-core";
+import type { PerseusInteractiveGraphUserInput, PerseusInteractiveGraphWidgetOptions } from "@khanacademy/perseus-core";
 import type { Interval, vec } from "mafs";
 import type { ReactNode } from "react";
-export type InteractiveGraphProps = WidgetProps<PerseusInteractiveGraphWidgetOptions>;
+export type InteractiveGraphProps = WidgetProps<PerseusInteractiveGraphWidgetOptions, PerseusInteractiveGraphUserInput>;
 export type Dispatch = (action: InteractiveGraphAction) => unknown;
 export type MafsGraphProps<T extends InteractiveGraphState> = {
     graphState: T;

package/dist/widgets/label-image/label-image.d.ts

@@ -11,7 +11,7 @@ import Marker from "./marker";
 import type { DependencyProps } from "../../dependencies";
 import type { Widget, WidgetProps } from "../../types";
 import type { LabelImagePromptJSON } from "../../widget-ai-utils/label-image/label-image-ai-utils";
-import type { InteractiveMarkerType, PerseusLabelImageWidgetOptions, PerseusLabelImageUserInput, ShowSolutions } from "@khanacademy/perseus-core";
+import type { InteractiveMarkerType, PerseusLabelImageWidgetOptions, PerseusLabelImageUserInput, LabelImagePublicWidgetOptions, ShowSolutions, PerseusLabelImageUserInputMarker } from "@khanacademy/perseus-core";
 type PreferredPopoverDirection = "NONE" | "UP" | "DOWN" | "LEFT" | "RIGHT";
 /**
  * Represents a direction vector.
@@ -37,7 +37,8 @@ export type OptionalAnswersMarkerType = Omit<InteractiveMarkerType, "answers"> &
 type Options = Omit<PerseusLabelImageWidgetOptions, "markers"> & {
     markers: ReadonlyArray<OptionalAnswersMarkerType>;
 };
-type Props = WidgetProps<Options> & DependencyProps & {
+type Props = WidgetProps<Options, PerseusLabelImageUserInput> & {
+    analytics: DependencyProps["analytics"];
     preferredPopoverDirection?: PreferredPopoverDirection;
 };
 type LabelImageState = {
@@ -46,14 +47,15 @@ type LabelImageState = {
     hideAnswers: boolean;
 };
 /**
- * Get marker with the appropriate selection state for current display mode.
+ * Get user input marker with the appropriate selection state for current display mode.
  * When showing solutions, it auto-selects correct answers, or clears
  * selections for markers without answers.
  *
- * @param marker - The marker to update.
- * @returns The updated marker state.
+ * @param marker - The widget options marker (possibly with answer).
+ * @param userInputMarker - The user input marker (with user selection).
+ * @returns A modified version of user input, possibly with correct answer.
  */
-export declare function getUpdatedMarkerState(marker: OptionalAnswersMarkerType, reviewMode: boolean, showSolutions?: ShowSolutions): OptionalAnswersMarkerType;
+export declare function getComputedSelectedState(marker: OptionalAnswersMarkerType, userInputMarker: PerseusLabelImageUserInputMarker, reviewMode: boolean, showSolutions?: ShowSolutions): PerseusLabelImageUserInputMarker;
 export declare class LabelImage extends React.Component<Props, LabelImageState> implements Widget {
     static contextType: React.Context<import("../../components/i18n-context").I18nContextType>;
     context: React.ContextType<typeof PerseusI18nContext>;
@@ -83,24 +85,42 @@ export declare class LabelImage extends React.Component<Props, LabelImageState>
     constructor(props: Props);
     componentDidMount(): void;
     componentWillUnmount(): void;
+    /**
+     * TODO: remove this when everything is pulling from Renderer state
+     * @deprecated get user input from Renderer state
+     */
     getUserInput(): PerseusLabelImageUserInput;
     getPromptJSON(): LabelImagePromptJSON;
-    handleMarkerChange(index: number, marker: Props["markers"][number]): void;
+    handleMarkerChange(index: number, marker: PerseusLabelImageUserInput["markers"][number]): void;
     activateMarker(index: number, opened: boolean): void;
     handleMarkerKeyDown(index: number, e: React.KeyboardEvent): void;
     handleAnswerChoicesChangeForMarker(index: number, selection: ReadonlyArray<boolean>): void;
     renderMarkers(): ReadonlyArray<React.ReactNode>;
     renderInstructions(): React.ReactNode;
+    /**
+     * @deprecated and likely very broken API
+     * [LEMS-3185] do not trust serializedState/restoreSerializedState
+     */
+    getSerializedState(): any;
     render(): React.ReactNode;
 }
+declare function getStartUserInput(options: LabelImagePublicWidgetOptions): PerseusLabelImageUserInput;
+/**
+ * @deprecated and likely a very broken API
+ * [LEMS-3185] do not trust serializedState/restoreSerializedState
+ */
+declare function getUserInputFromSerializedState(serializedState: any): PerseusLabelImageUserInput;
 declare const _default: {
     name: string;
     displayName: string;
     widget: React.ForwardRefExoticComponent<Omit<Omit<PerseusLabelImageWidgetOptions, "markers"> & {
         markers: ReadonlyArray<OptionalAnswersMarkerType>;
-    } & import("../../types").UniversalWidgetProps<Empty, Empty> & Partial<import("../..").PerseusDependenciesV2> & {
+    } & import("../../types").UniversalWidgetProps<Empty, PerseusLabelImageUserInput, Empty> & {
+        analytics: DependencyProps["analytics"];
         preferredPopoverDirection?: PreferredPopoverDirection;
     }, keyof import("../..").PerseusDependenciesV2> & React.RefAttributes<LabelImage>>;
     isLintable: true;
+    getStartUserInput: typeof getStartUserInput;
+    getUserInputFromSerializedState: typeof getUserInputFromSerializedState;
 };
 export default _default;

package/dist/widgets/matcher/matcher.d.ts

@@ -3,18 +3,17 @@ import { PerseusI18nContext } from "../../components/i18n-context";
 import type { SortableOption } from "../../components/sortable";
 import type { WidgetProps, Widget } from "../../types";
 import type { MatcherPromptJSON } from "../../widget-ai-utils/matcher/matcher-ai-utils";
-import type { PerseusMatcherWidgetOptions, PerseusMatcherUserInput } from "@khanacademy/perseus-core";
-type RenderProps = PerseusMatcherWidgetOptions;
-type Props = WidgetProps<RenderProps>;
+import type { PerseusMatcherWidgetOptions, PerseusMatcherUserInput, MatcherPublicWidgetOptions } from "@khanacademy/perseus-core";
+type RenderProps = Pick<PerseusMatcherWidgetOptions, "labels" | "orderMatters" | "padding">;
+type Props = WidgetProps<RenderProps, PerseusMatcherUserInput>;
 type DefaultProps = {
-    left: Props["left"];
-    right: Props["right"];
     labels: Props["labels"];
     orderMatters: Props["orderMatters"];
     padding: Props["padding"];
     problemNum: Props["problemNum"];
     onChange: Props["onChange"];
     linterContext: Props["linterContext"];
+    userInput: Props["userInput"];
 };
 type State = {
     leftHeight: number;
@@ -26,19 +25,32 @@ export declare class Matcher extends React.Component<Props, State> implements Wi
     context: React.ContextType<typeof PerseusI18nContext>;
     static defaultProps: DefaultProps;
     state: State;
-    changeAndTrack: (arg1: any) => void;
+    changeAndTrack: () => void;
     onMeasureLeft: (arg1: any) => void;
     onMeasureRight: (arg1: any) => void;
-    getUserInput: () => PerseusMatcherUserInput;
+    _getUserInputFromSortable: () => PerseusMatcherUserInput;
+    /**
+     * TODO: remove this when everything is pulling from Renderer state
+     * @deprecated get user input from Renderer state
+     */
+    getUserInput(): PerseusMatcherUserInput;
     getPromptJSON(): MatcherPromptJSON;
     moveLeftOptionToIndex: (option: SortableOption, index: number) => void;
     moveRightOptionToIndex: (option: SortableOption, index: number) => void;
     render(): React.ReactElement;
 }
+declare function getStartUserInput(options: MatcherPublicWidgetOptions, problemNum: number): PerseusMatcherUserInput;
+/**
+ * @deprecated and likely a very broken API
+ * [LEMS-3185] do not trust serializedState/restoreSerializedState
+ */
+declare function getUserInputFromSerializedState(serializedState: any): PerseusMatcherUserInput;
 declare const _default: {
     name: string;
     displayName: string;
     widget: typeof Matcher;
     isLintable: true;
+    getStartUserInput: typeof getStartUserInput;
+    getUserInputFromSerializedState: typeof getUserInputFromSerializedState;
 };
 export default _default;

package/dist/widgets/matrix/matrix.d.ts

@@ -2,33 +2,22 @@ import * as React from "react";
 import { PerseusI18nContext } from "../../components/i18n-context";
 import type { FocusPath, Widget, WidgetProps } from "../../types";
 import type { MatrixPromptJSON } from "../../widget-ai-utils/matrix/matrix-ai-utils";
-import type { MatrixPublicWidgetOptions, PerseusMatrixUserInput, PerseusMatrixWidgetAnswers } from "@khanacademy/perseus-core";
-type ExternalProps = WidgetProps<{
-    prefix: string;
-    suffix: string;
-    answers: PerseusMatrixWidgetAnswers;
+import type { MatrixPublicWidgetOptions, PerseusMatrixUserInput, PerseusMatrixWidgetOptions } from "@khanacademy/perseus-core";
+type RenderProps = Pick<PerseusMatrixWidgetOptions, "matrixBoardSize" | "prefix" | "suffix">;
+type Props = WidgetProps<RenderProps, PerseusMatrixUserInput> & {
     cursorPosition: ReadonlyArray<number>;
-    matrixBoardSize: ReadonlyArray<number>;
-    static?: boolean | undefined;
-}>;
-type RenderProps = MatrixPublicWidgetOptions & {
-    emptyMatrix: ReadonlyArray<ReadonlyArray<string>>;
-};
-type Props = ExternalProps & {
-    onChange: (arg1: {
+    onChange: (nextProps: {
         cursorPosition?: ReadonlyArray<number>;
-        answers?: ReadonlyArray<ReadonlyArray<number | string>>;
-    }, arg2: () => boolean) => void;
-    numericInput?: boolean;
+    }, cb: () => boolean) => void;
 };
 type DefaultProps = {
     matrixBoardSize: Props["matrixBoardSize"];
-    answers: Props["answers"];
     prefix: string;
     suffix: string;
     cursorPosition: ReadonlyArray<number>;
     apiOptions: Props["apiOptions"];
     linterContext: Props["linterContext"];
+    userInput: PerseusMatrixUserInput;
 };
 type State = {
     enterTheMatrix: number;
@@ -50,18 +39,41 @@ declare class Matrix extends React.Component<Props, State> implements Widget {
     setInputValue: (arg1: any, arg2: any, arg3: any) => void;
     handleKeyDown: (arg1: any, arg2: any, arg3: any) => void;
     onValueChange: (arg1: any, arg2: any, arg3: any, arg4: any) => void;
+    /**
+     * TODO: remove this when everything is pulling from Renderer state
+     * @deprecated get user input from Renderer state
+     */
     getUserInput(): PerseusMatrixUserInput;
     getPromptJSON(): MatrixPromptJSON;
+    /**
+     * @deprecated and likely very broken API
+     * [LEMS-3185] do not trust serializedState/restoreSerializedState
+     */
+    getSerializedState(): any;
     render(): React.ReactNode;
 }
+/**
+ * TODO: I don't really think we need this. The default for a transform
+ * is an identity function and all this is doing is taking a selection from
+ * widget options; it's probably fine to pass all widget options down.
+ * @deprecated [LEMS-3199]
+ */
 declare function transform(widgetOptions: MatrixPublicWidgetOptions): RenderProps;
+declare function getCorrectUserInput(options: PerseusMatrixWidgetOptions): PerseusMatrixUserInput;
+/**
+ * @deprecated and likely a very broken API
+ * [LEMS-3185] do not trust serializedState/restoreSerializedState
+ */
+declare function getUserInputFromSerializedState(serializedState: any): PerseusMatrixUserInput;
 declare const _default: {
     name: string;
     displayName: string;
     hidden: true;
     widget: typeof Matrix;
     transform: typeof transform;
-    staticTransform: (arg1: any) => any;
+    staticTransform: typeof transform;
     isLintable: true;
+    getCorrectUserInput: typeof getCorrectUserInput;
+    getUserInputFromSerializedState: typeof getUserInputFromSerializedState;
 };
 export default _default;

package/dist/widgets/mock-widgets/mock-widget.d.ts

@@ -3,12 +3,10 @@ import type { MockWidgetOptions } from "./mock-widget-types";
 import type { WidgetProps, Widget, FocusPath } from "../../types";
 import type { MockWidgetPromptJSON } from "../../widget-ai-utils/mock-widget/prompt-utils";
 import type { PerseusMockWidgetUserInput } from "@khanacademy/perseus-score";
-type ExternalProps = WidgetProps<MockWidgetOptions>;
+type ExternalProps = WidgetProps<MockWidgetOptions, PerseusMockWidgetUserInput>;
+type Props = ExternalProps;
 type DefaultProps = {
-    currentValue: Props["currentValue"];
-};
-type Props = ExternalProps & {
-    currentValue: string;
+    userInput: Props["userInput"];
 };
 /**
  * This is a Mock Perseus widget, which is used for our various rendering tests
@@ -25,21 +23,104 @@ type Props = ExternalProps & {
 declare class MockWidgetComponent extends React.Component<Props> implements Widget {
     static defaultProps: DefaultProps;
     inputRef: HTMLElement | null;
-    static getUserInputFromProps(props: Props): PerseusMockWidgetUserInput;
     getPromptJSON(): MockWidgetPromptJSON;
-    setInputValue: (arg1: FocusPath, arg2: string, arg3?: () => unknown | null | undefined) => void;
+    setInputValue: (path: FocusPath, newValue: string, cb?: () => unknown | null | undefined) => void;
     focus: () => boolean;
     focusInputPath: () => void;
     blurInputPath: () => void;
     getInputPaths: () => ReadonlyArray<ReadonlyArray<string>>;
+    /**
+     * TODO: remove this when everything is pulling from Renderer state
+     * @deprecated get user input from Renderer state
+     */
     getUserInput(): PerseusMockWidgetUserInput;
-    handleChange: (arg1: string, arg2?: () => unknown | null | undefined) => void;
+    handleChange: (newValue: string, cb?: () => unknown | null | undefined) => void;
+    /**
+     * @deprecated and likely very broken API
+     * [LEMS-3185] do not trust serializedState/restoreSerializedState
+     */
+    getSerializedState(): {
+        currentValue: string;
+        static: boolean;
+        value: string;
+        reviewModeRubric?: Empty | null | undefined;
+        trackInteraction: (extraData?: Empty | undefined) => void;
+        widgetId: string;
+        alignment: string | null | undefined;
+        problemNum: number | null | undefined;
+        apiOptions: Readonly<Readonly<{
+            isArticle?: boolean;
+            onFocusChange?: (newFocusPath: FocusPath, oldFocusPath: FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
+            GroupMetadataEditor?: React.ComponentType<any>;
+            showAlignmentOptions?: boolean;
+            readOnly?: boolean;
+            answerableCallback?: (arg1: boolean) => unknown;
+            getAnotherHint?: () => unknown;
+            interactionCallback?: (widgetData: {
+                [widgetId: string]: any;
+            }) => void;
+            groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
+            imagePlaceholder?: React.ReactNode;
+            widgetPlaceholder?: React.ReactNode;
+            baseElements?: {
+                Link: React.ComponentType<any>;
+            };
+            imagePreloader?: (dimensions: import("../../types").Dimensions) => React.ReactNode;
+            trackInteraction?: (args: {
+                type: string;
+                id: string;
+                correct?: boolean;
+            } & Partial<import("../../types").TrackingGradedGroupExtraArguments> & Partial<{
+                visible: number;
+            }>) => void;
+            customKeypad?: boolean;
+            nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
+            isMobile?: boolean;
+            isMobileApp?: boolean;
+            setDrawingAreaAvailable?: (arg1: boolean) => unknown;
+            hintProgressColor?: string;
+            canScrollPage?: boolean;
+            editorChangeDelay?: number;
+            flags?: Record<"new-radio-widget", boolean>;
+            onWidgetStartProps?: (widgets: import("@khanacademy/perseus-core").PerseusWidgetsMap) => void;
+        }> & {
+            baseElements: NonNullable<import("../..").APIOptions["baseElements"]>;
+            canScrollPage: NonNullable<import("../..").APIOptions["canScrollPage"]>;
+            editorChangeDelay: NonNullable<import("../..").APIOptions["editorChangeDelay"]>;
+            groupAnnotator: NonNullable<import("../..").APIOptions["groupAnnotator"]>;
+            isArticle: NonNullable<import("../..").APIOptions["isArticle"]>;
+            isMobile: NonNullable<import("../..").APIOptions["isMobile"]>;
+            isMobileApp: NonNullable<import("../..").APIOptions["isMobileApp"]>;
+            onFocusChange: NonNullable<import("../..").APIOptions["onFocusChange"]>;
+            readOnly: NonNullable<import("../..").APIOptions["readOnly"]>;
+            setDrawingAreaAvailable: NonNullable<import("../..").APIOptions["setDrawingAreaAvailable"]>;
+            showAlignmentOptions: NonNullable<import("../..").APIOptions["showAlignmentOptions"]>;
+        }>;
+        keypadElement?: any;
+        questionCompleted?: boolean;
+        onFocus: (blurPath: FocusPath) => void;
+        onBlur: (blurPath: FocusPath) => void;
+        findWidgets: (criterion: import("../../types").FilterCriterion) => ReadonlyArray<Widget>;
+        reviewMode: boolean;
+        showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
+        onChange: import("../..").ChangeHandler;
+        handleUserInput: (newUserInput: PerseusMockWidgetUserInput, cb?: () => void, silent?: boolean) => void;
+        isLastUsedWidget: boolean;
+        linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
+        containerSizeClass: import("../../util/sizing-utils").SizeClass;
+    };
     render(): React.ReactNode;
 }
+/**
+ * @deprecated and likely a very broken API
+ * [LEMS-3185] do not trust serializedState/restoreSerializedState
+ */
+declare function getUserInputFromSerializedState(serializedState: any): PerseusMockWidgetUserInput;
 declare const _default: {
     name: string;
     displayName: string;
     widget: typeof MockWidgetComponent;
     isLintable: true;
+    getUserInputFromSerializedState: typeof getUserInputFromSerializedState;
 };
 export default _default;