@khanacademy/perseus 34.1.0 → 35.1.1

package/dist/widgets/input-number/input-number-validator.d.ts

@@ -1,6 +1,6 @@
-import type { Rubric } from "./input-number.types";
 import type { PerseusStrings } from "../../strings";
-import type { APIOptions, PerseusScore } from "@khanacademy/perseus";
+import type { PerseusInputNumberRubric } from "../../validation.types";
+import type { PerseusScore } from "@khanacademy/perseus";
 export declare const answerTypes: {
     readonly number: {
         readonly name: "Numbers";
@@ -37,5 +37,5 @@ export declare const answerTypes: {
 };
 declare function inputNumberValidator(state: {
     currentValue: string;
-}, rubric: Rubric, strings: PerseusStrings, onInputError?: APIOptions["onInputError"]): PerseusScore;
+}, rubric: PerseusInputNumberRubric, strings: PerseusStrings): PerseusScore;
 export default inputNumberValidator;

package/dist/widgets/input-number/input-number.d.ts

@@ -1,26 +1,23 @@
 import * as React from "react";
 import { PerseusI18nContext } from "../../components/i18n-context";
-import type { Rubric } from "./input-number.types";
 import type { PerseusInputNumberWidgetOptions } from "../../perseus-types";
 import type { PerseusStrings } from "../../strings";
-import type { APIOptions, Path, PerseusScore, WidgetProps } from "../../types";
-type UserInput = {
-    currentValue: string;
-};
+import type { Path, PerseusScore, WidgetProps } from "../../types";
+import type { PerseusInputNumberRubric, PerseusInputNumberUserInput } from "../../validation.types";
 type RenderProps = {
     simplify: PerseusInputNumberWidgetOptions["simplify"];
     size: PerseusInputNumberWidgetOptions["size"];
     answerType: PerseusInputNumberWidgetOptions["answerType"];
     rightAlign: PerseusInputNumberWidgetOptions["rightAlign"];
 };
-type ExternalProps = WidgetProps<RenderProps, Rubric>;
+type ExternalProps = WidgetProps<RenderProps, PerseusInputNumberRubric>;
 type Props = ExternalProps & {
     apiOptions: NonNullable<ExternalProps["apiOptions"]>;
     linterContext: NonNullable<ExternalProps["linterContext"]>;
     rightAlign: NonNullable<ExternalProps["rightAlign"]>;
     size: NonNullable<ExternalProps["size"]>;
     currentValue: string;
-    answerType: NonNullable<Rubric["answerType"]>;
+    answerType: NonNullable<PerseusInputNumberRubric["answerType"]>;
 };
 type DefaultProps = {
     answerType: Props["answerType"];
@@ -39,7 +36,7 @@ declare class InputNumber extends React.Component<Props> {
     static defaultProps: DefaultProps;
     static validate(state: {
         currentValue: string;
-    }, rubric: Rubric, strings: PerseusStrings, onInputError?: APIOptions["onInputError"]): PerseusScore;
+    }, rubric: PerseusInputNumberRubric, strings: PerseusStrings): PerseusScore;
     static getUserInputFromProps(props: Props): {
         currentValue: string;
     };
@@ -54,8 +51,8 @@ declare class InputNumber extends React.Component<Props> {
     getInputPaths: () => ReadonlyArray<Path>;
     getGrammarTypeForPath: (arg1: Path) => string;
     setInputValue: (arg1: Path, arg2: string, arg3: () => void) => void;
-    getUserInput: () => UserInput;
-    simpleValidate: (rubric: Rubric, onInputError?: APIOptions["onInputError"]) => PerseusScore;
+    getUserInput(): PerseusInputNumberUserInput;
+    simpleValidate(rubric: PerseusInputNumberRubric): PerseusScore;
     examples: () => ReadonlyArray<string>;
     render(): React.ReactNode;
 }

package/dist/widgets/interaction/interaction.d.ts

@@ -2,9 +2,9 @@ import * as React from "react";
 import type { Coord } from "../../interactive2/types";
 import type { PerseusInteractionWidgetOptions } from "../../perseus-types";
 import type { WidgetProps } from "../../types";
+import type { PerseusInteractionRubric, PerseusInteractionUserInput } from "../../validation.types";
 type RenderProps = PerseusInteractionWidgetOptions;
-type Rubric = PerseusInteractionWidgetOptions;
-type Props = WidgetProps<RenderProps, Rubric>;
+type Props = WidgetProps<RenderProps, PerseusInteractionRubric>;
 type DefaultProps = {
     graph: Props["graph"];
     elements: Props["elements"];
@@ -24,7 +24,7 @@ declare class Interaction extends React.Component<Props, State> {
     _eval: (arg1: any, arg2: any) => number;
     _extractVars: (arg1: any) => ReadonlyArray<any>;
     change: (arg1: any, arg2: any, arg3: any) => any;
-    getUserInput: () => any;
+    getUserInput(): PerseusInteractionUserInput;
     simpleValidate(): import("../../types").PerseusScore;
     render(): React.ReactNode;
 }

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

@@ -1,17 +1,14 @@
 import * as React from "react";
 import { PerseusI18nContext } from "../components/i18n-context";
+import type { StatefulMafsGraphType } from "./interactive-graphs/stateful-mafs-graph";
 import type { QuadraticGraphState } from "./interactive-graphs/types";
 import type { Coord } from "../interactive2/types";
 import type { PerseusGraphType, PerseusGraphTypeAngle, PerseusGraphTypePoint, PerseusGraphTypePolygon, PerseusGraphTypeSegment, PerseusInteractiveGraphWidgetOptions } from "../perseus-types";
-import type { Widget } from "../renderer";
 import type { ChangeHandler, PerseusScore, WidgetProps } from "../types";
 import type { QuadraticCoefficient, Range, SineCoefficient } from "../util/geometry";
+import type { PerseusInteractiveGraphRubric, PerseusInteractiveGraphUserInput } from "../validation.types";
 type RenderProps = PerseusInteractiveGraphWidgetOptions;
-export type Rubric = {
-    correct: PerseusGraphType;
-    graph: PerseusGraphType;
-};
-type Props = WidgetProps<RenderProps, Rubric>;
+type Props = WidgetProps<RenderProps, PerseusInteractiveGraphRubric>;
 type State = any;
 type DefaultProps = {
     labels: Props["labels"];
@@ -23,6 +20,8 @@ type DefaultProps = {
     showProtractor: Props["showProtractor"];
     graph: Props["graph"];
 };
+export declare function getSinusoidCoefficients(coords: ReadonlyArray<Coord>): SineCoefficient;
+export declare function getQuadraticCoefficients(coords: ReadonlyArray<Coord>): QuadraticCoefficient;
 declare class LegacyInteractiveGraph extends React.Component<Props, State> {
     static contextType: React.Context<{
         strings: import("../strings").PerseusStrings;
@@ -101,20 +100,18 @@ declare class LegacyInteractiveGraph extends React.Component<Props, State> {
     addAngleControls: () => void;
     removeAngleControls: () => void;
     toggleShowSides: () => void;
-    getUserInput(): PerseusGraphType;
-    simpleValidate(rubric: Rubric): PerseusScore;
+    getUserInput(): PerseusInteractiveGraphUserInput;
+    simpleValidate(rubric: PerseusInteractiveGraphRubric): PerseusScore;
     focus: () => void;
     render(): React.ReactNode;
 }
 declare class InteractiveGraph extends React.Component<Props, State> {
     legacyGraphRef: React.RefObject<LegacyInteractiveGraph>;
-    mafsRef: React.RefObject<Widget>;
+    mafsRef: React.RefObject<StatefulMafsGraphType>;
     static defaultProps: DefaultProps;
-    getUserInput: Widget["getUserInput"];
-    simpleValidate(rubric: Rubric): PerseusScore;
+    getUserInput(): PerseusInteractiveGraphUserInput;
+    simpleValidate(rubric: PerseusInteractiveGraphRubric): PerseusScore;
     render(): React.JSX.Element;
-    static getQuadraticCoefficients(coords: ReadonlyArray<Coord>): QuadraticCoefficient;
-    static getSinusoidCoefficients(coords: ReadonlyArray<Coord>): SineCoefficient;
     /**
      * @param {object} graph Like props.graph or props.correct
      * @param {object} props of an InteractiveGraph instance
@@ -163,7 +160,7 @@ declare class InteractiveGraph extends React.Component<Props, State> {
     static getRayEquationString(props: Props): string;
     static getPolygonEquationString(props: Props): string;
     static getAngleEquationString(props: Props): string;
-    static validate(userInput: PerseusGraphType, rubric: Rubric, component: any): PerseusScore;
+    static validate(userInput: PerseusGraphType, rubric: PerseusInteractiveGraphRubric): PerseusScore;
     static getUserInputFromProps(props: Props): PerseusGraphType;
 }
 export declare function shouldUseMafs(mafsFlags: Record<string, boolean> | undefined | boolean, graph: PerseusGraphType): boolean;

package/dist/widgets/interactive-graphs/backgrounds/axis-ticks.d.ts

@@ -1,5 +1,5 @@
 import * as React from "react";
 import type { Interval } from "mafs";
-export declare const shouldShowLabel: (number: number, range: [Interval, Interval]) => boolean;
+export declare const shouldShowLabel: (currentTick: number, range: [Interval, Interval], tickStep: number) => boolean;
 export declare function generateTickLocations(tickStep: number, min: number, max: number): number[];
 export declare const AxisTicks: () => React.JSX.Element;

package/dist/widgets/interactive-graphs/graph-locked-layer.d.ts

@@ -1,7 +1,9 @@
 import * as React from "react";
 import type { LockedFigure } from "../../perseus-types";
+import type { APIOptions } from "../../types";
 import type { Interval } from "mafs";
 type Props = {
+    flags?: APIOptions["flags"];
     lockedFigures: ReadonlyArray<LockedFigure>;
     range: [x: Interval, y: Interval];
 };

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

@@ -1,11 +1,14 @@
+import { vec } from "mafs";
 import type { Coord } from "../../interactive2/types";
 import type { CollinearTuple, LockedFigureColor, LockedFigureFillType, LockedLineStyle, PerseusRenderer } from "../../perseus-types";
-import type { Interval, vec } from "mafs";
+import type { Interval } from "mafs";
 export type LockedFunctionOptions = {
     color?: LockedFigureColor;
     strokeStyle?: LockedLineStyle;
     directionalAxis?: "x" | "y";
     domain?: Interval;
+    labels?: LockedFigureLabelOptions[];
+    ariaLabel?: string;
 };
 type LockedFigureLabelOptions = {
     text: string;
@@ -109,6 +112,7 @@ declare class InteractiveGraphQuestionBuilder {
         color?: LockedFigureColor;
         filled?: boolean;
         labels?: LockedFigureLabelOptions[];
+        ariaLabel?: string;
     }): InteractiveGraphQuestionBuilder;
     addLockedLine(point1: vec.Vector2, point2: vec.Vector2, options?: {
         kind?: "line" | "ray" | "segment";
@@ -118,19 +122,28 @@ declare class InteractiveGraphQuestionBuilder {
         showPoint1?: boolean;
         showPoint2?: boolean;
         labels?: LockedFigureLabelOptions[];
+        ariaLabel?: string;
+    }): InteractiveGraphQuestionBuilder;
+    addLockedVector(tail: vec.Vector2, tip: vec.Vector2, options?: {
+        color?: LockedFigureColor;
+        labels?: LockedFigureLabelOptions[];
+        ariaLabel?: string;
     }): InteractiveGraphQuestionBuilder;
-    addLockedVector(tail: vec.Vector2, tip: vec.Vector2, color?: LockedFigureColor): InteractiveGraphQuestionBuilder;
     addLockedEllipse(center: vec.Vector2, radius: [x: number, y: number], options?: {
         angle?: number;
         color?: LockedFigureColor;
         fillStyle?: LockedFigureFillType;
         strokeStyle?: "solid" | "dashed";
+        labels?: LockedFigureLabelOptions[];
+        ariaLabel?: string;
     }): InteractiveGraphQuestionBuilder;
     addLockedPolygon(points: vec.Vector2[], options?: {
         color?: LockedFigureColor;
         showVertices?: boolean;
         fillStyle?: LockedFigureFillType;
         strokeStyle?: "solid" | "dashed";
+        labels?: LockedFigureLabelOptions[];
+        ariaLabel?: string;
     }): InteractiveGraphQuestionBuilder;
     addLockedFunction(equation: string, options?: LockedFunctionOptions): this;
     addLockedLabel(text: string, coord: Coord, options?: {

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

@@ -0,0 +1,4 @@
+import type { PerseusScore } from "../../types";
+import type { PerseusInteractiveGraphRubric, PerseusInteractiveGraphUserInput } from "../../validation.types";
+declare function interactiveGraphValidator(userInput: PerseusInteractiveGraphUserInput, rubric: PerseusInteractiveGraphRubric): PerseusScore;
+export default interactiveGraphValidator;

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

@@ -1,4 +1,8 @@
 import * as React from "react";
 import { type LockedEllipseType } from "../../../perseus-types";
-declare const LockedEllipse: (props: LockedEllipseType) => React.JSX.Element;
+import type { APIOptions } from "../../../types";
+type Props = LockedEllipseType & {
+    flags?: APIOptions["flags"];
+};
+declare const LockedEllipse: (props: Props) => React.JSX.Element;
 export default LockedEllipse;

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

@@ -1,4 +1,8 @@
 import * as React from "react";
 import type { LockedFunctionType } from "../../../perseus-types";
-declare const LockedFunction: (props: LockedFunctionType) => React.JSX.Element | null;
+import type { APIOptions } from "../../../types";
+type Props = LockedFunctionType & {
+    flags?: APIOptions["flags"];
+};
+declare const LockedFunction: (props: Props) => React.JSX.Element | null;
 export default LockedFunction;

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

@@ -1,7 +1,9 @@
 import * as React from "react";
 import type { LockedLineType } from "../../../perseus-types";
+import type { APIOptions } from "../../../types";
 import type { Interval } from "mafs";
 type Props = LockedLineType & {
+    flags?: APIOptions["flags"];
     range: [Interval, Interval];
 };
 declare const LockedLine: (props: Props) => React.JSX.Element;

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

@@ -1,4 +1,8 @@
 import * as React from "react";
 import { type LockedPointType } from "../../../perseus-types";
-declare const LockedPoint: (props: LockedPointType) => React.JSX.Element;
+import type { APIOptions } from "../../../types";
+type Props = LockedPointType & {
+    flags?: APIOptions["flags"];
+};
+declare const LockedPoint: (props: Props) => React.JSX.Element;
 export default LockedPoint;

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

@@ -1,4 +1,8 @@
 import * as React from "react";
 import type { LockedPolygonType } from "../../../perseus-types";
-declare const LockedPolygon: (props: LockedPolygonType) => React.JSX.Element;
+import type { APIOptions } from "../../../types";
+type Props = LockedPolygonType & {
+    flags?: APIOptions["flags"];
+};
+declare const LockedPolygon: (props: Props) => React.JSX.Element;
 export default LockedPolygon;

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

@@ -1,4 +1,8 @@
 import * as React from "react";
 import type { LockedVectorType } from "../../../perseus-types";
-declare const LockedVector: (props: LockedVectorType) => React.JSX.Element;
+import type { APIOptions } from "../../../types";
+type Props = LockedVectorType & {
+    flags?: APIOptions["flags"];
+};
+declare const LockedVector: (props: Props) => React.JSX.Element;
 export default LockedVector;

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

@@ -0,0 +1,3 @@
+import type { InteractiveGraphState } from "./types";
+import type { PerseusGraphType } from "@khanacademy/perseus";
+export declare function mafsStateToInteractiveGraph(state: InteractiveGraphState, originalGraph: PerseusGraphType): PerseusGraphType;

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

@@ -1,8 +1,8 @@
 import * as React from "react";
 import type { InteractiveGraphProps } from "./types";
 import type { PerseusGraphType } from "../../perseus-types";
-import type { Widget } from "../../renderer";
 import type { APIOptions } from "../../types";
+import type { PerseusInteractiveGraphUserInput } from "../../validation.types";
 export type StatefulMafsGraphProps = {
     flags?: APIOptions["flags"];
     box: [number, number];
@@ -25,4 +25,7 @@ export type StatefulMafsGraphProps = {
     readOnly: boolean;
     static: InteractiveGraphProps["static"];
 };
-export declare const StatefulMafsGraph: React.ForwardRefExoticComponent<StatefulMafsGraphProps & React.RefAttributes<Partial<Widget>>>;
+export type StatefulMafsGraphType = {
+    getUserInput: () => PerseusInteractiveGraphUserInput;
+};
+export declare const StatefulMafsGraph: React.ForwardRefExoticComponent<StatefulMafsGraphProps & React.RefAttributes<StatefulMafsGraphType>>;

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

@@ -0,0 +1,10 @@
+import type { InteractiveMarkerType } from "./types";
+import type { PerseusScore } from "../../types";
+import type { PerseusLabelImageRubric, PerseusLabelImageUserInput } from "../../validation.types";
+type InteractiveMarkerScore = {
+    hasAnswers: boolean;
+    isCorrect: boolean;
+};
+export declare function scoreMarker(marker: InteractiveMarkerType): InteractiveMarkerScore;
+declare function labelImageValidator(state: PerseusLabelImageUserInput, rubric?: PerseusLabelImageRubric): PerseusScore;
+export default labelImageValidator;

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

@@ -8,14 +8,12 @@
 import * as React from "react";
 import { PerseusI18nContext } from "../../components/i18n-context";
 import Marker from "./marker";
-import type { InteractiveMarkerType, InteractiveMarkerScore } from "./types";
+import type { InteractiveMarkerType } from "./types";
 import type { DependencyProps } from "../../dependencies";
 import type { ChangeableProps } from "../../mixins/changeable";
 import type { APIOptions, PerseusScore } from "../../types";
+import type { PerseusLabelImageRubric, PerseusLabelImageUserInput } from "../../validation.types";
 export type PreferredPopoverDirection = "NONE" | "UP" | "DOWN" | "LEFT" | "RIGHT";
-type MarkersState = {
-    markers: ReadonlyArray<InteractiveMarkerType>;
-};
 /**
  * Represents a direction vector.
  * No diagonals allowed.
@@ -60,8 +58,7 @@ export declare class LabelImage extends React.Component<LabelImageProps, LabelIm
     context: React.ContextType<typeof PerseusI18nContext>;
     _markers: Array<Marker | null | undefined>;
     _mounted: boolean;
-    static gradeMarker(marker: InteractiveMarkerType): InteractiveMarkerScore;
-    static validate(state: MarkersState, rubric?: LabelImageProps): PerseusScore;
+    static validate(state: PerseusLabelImageUserInput, rubric?: PerseusLabelImageRubric): PerseusScore;
     /**
      * Test whether point is contained within triangle.
      *
@@ -82,8 +79,8 @@ export declare class LabelImage extends React.Component<LabelImageProps, LabelIm
     constructor(props: LabelImageProps);
     componentDidMount(): void;
     componentWillUnmount(): void;
-    simpleValidate(rubric: LabelImageProps): PerseusScore;
-    getUserInput(): MarkersState;
+    simpleValidate(rubric: PerseusLabelImageRubric): PerseusScore;
+    getUserInput(): PerseusLabelImageUserInput;
     showRationalesForCurrentlySelectedChoices(rubric: LabelImageProps): void;
     handleMarkerChange(index: number, marker: InteractiveMarkerType): void;
     activateMarker(index: number, opened: boolean): void;
@@ -99,7 +96,6 @@ declare const _default: Readonly<{
     getWidget?: (() => React.ForwardRefExoticComponent<Omit<ChangeableProps & Partial<import("../../types").PerseusDependenciesV2> & {
         apiOptions: Readonly<{
             isArticle?: boolean | undefined;
-            onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
             onFocusChange?: ((newFocusPath: import("../../types").FocusPath, oldFocusPath: import("../../types").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
             GroupMetadataEditor?: React.ComponentType<any> | undefined;
             showAlignmentOptions?: boolean | undefined;
@@ -145,8 +141,13 @@ declare const _default: Readonly<{
                     "unlimited-point"?: boolean | undefined;
                 } & {
                     "interactive-graph-locked-features-labels"?: boolean | undefined;
+                    "locked-figures-aria"?: boolean | undefined;
                     "locked-point-labels"?: boolean | undefined;
                     "locked-line-labels"?: boolean | undefined;
+                    "locked-vector-labels"?: boolean | undefined;
+                    "locked-ellipse-labels"?: boolean | undefined;
+                    "locked-polygon-labels"?: boolean | undefined;
+                    "locked-function-labels"?: boolean | undefined;
                 }) | undefined;
             } | undefined;
             onWidgetStartProps?: ((widgets: import("../..").PerseusWidgetsMap) => void) | undefined;
@@ -165,7 +166,6 @@ declare const _default: Readonly<{
     widget: React.ForwardRefExoticComponent<Omit<ChangeableProps & Partial<import("../../types").PerseusDependenciesV2> & {
         apiOptions: Readonly<{
             isArticle?: boolean | undefined;
-            onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
             onFocusChange?: ((newFocusPath: import("../../types").FocusPath, oldFocusPath: import("../../types").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
             GroupMetadataEditor?: React.ComponentType<any> | undefined;
             showAlignmentOptions?: boolean | undefined;
@@ -211,8 +211,13 @@ declare const _default: Readonly<{
                     "unlimited-point"?: boolean | undefined;
                 } & {
                     "interactive-graph-locked-features-labels"?: boolean | undefined;
+                    "locked-figures-aria"?: boolean | undefined;
                     "locked-point-labels"?: boolean | undefined;
                     "locked-line-labels"?: boolean | undefined;
+                    "locked-vector-labels"?: boolean | undefined;
+                    "locked-ellipse-labels"?: boolean | undefined;
+                    "locked-polygon-labels"?: boolean | undefined;
+                    "locked-function-labels"?: boolean | undefined;
                 }) | undefined;
             } | undefined;
             onWidgetStartProps?: ((widgets: import("../..").PerseusWidgetsMap) => void) | undefined;

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

@@ -9,7 +9,3 @@ export type InteractiveMarkerType = MarkerType & {
     showCorrectness?: "correct" | "incorrect";
     focused?: boolean;
 };
-export type InteractiveMarkerScore = {
-    hasAnswers: boolean;
-    isCorrect: boolean;
-};

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

@@ -0,0 +1,4 @@
+import type { PerseusScore } from "../../types";
+import type { PerseusMatcherRubric, PerseusMatcherUserInput } from "../../validation.types";
+declare function matcherValidator(state: PerseusMatcherUserInput, rubric: PerseusMatcherRubric): PerseusScore;
+export default matcherValidator;

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

@@ -2,10 +2,10 @@ import * as React from "react";
 import { PerseusI18nContext } from "../../components/i18n-context";
 import type { SortableOption } from "../../components/sortable";
 import type { PerseusMatcherWidgetOptions } from "../../perseus-types";
-import type { WidgetProps } from "../../types";
+import type { PerseusScore, WidgetProps } from "../../types";
+import type { PerseusMatcherRubric, PerseusMatcherUserInput } from "../../validation.types";
 type RenderProps = PerseusMatcherWidgetOptions;
-type Rubric = PerseusMatcherWidgetOptions;
-type Props = WidgetProps<RenderProps, Rubric>;
+type Props = WidgetProps<RenderProps, PerseusMatcherRubric>;
 type DefaultProps = {
     left: Props["left"];
     right: Props["right"];
@@ -29,13 +29,14 @@ export declare class Matcher extends React.Component<Props, State> {
     context: React.ContextType<typeof PerseusI18nContext>;
     static defaultProps: DefaultProps;
     state: State;
+    static validate(state: PerseusMatcherUserInput, rubric: PerseusMatcherRubric): PerseusScore;
     changeAndTrack: (arg1: any) => void;
     onMeasureLeft: (arg1: any) => void;
     onMeasureRight: (arg1: any) => void;
-    getUserInput: () => any;
+    getUserInput: () => PerseusMatcherUserInput;
     moveLeftOptionToIndex: (option: SortableOption, index: number) => void;
     moveRightOptionToIndex: (option: SortableOption, index: number) => void;
-    simpleValidate: (arg1: any) => any;
+    simpleValidate(rubric: PerseusMatcherRubric): PerseusScore;
     render(): React.ReactElement;
 }
 declare const _default: Readonly<{

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

@@ -0,0 +1,5 @@
+import type { PerseusStrings } from "../../strings";
+import type { PerseusScore } from "../../types";
+import type { PerseusMatrixRubric, PerseusMatrixUserInput } from "../../validation.types";
+declare function matrixValidator(state: PerseusMatrixUserInput, rubric: PerseusMatrixRubric, strings: PerseusStrings): PerseusScore;
+export default matrixValidator;

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

@@ -3,8 +3,9 @@ import { PerseusI18nContext } from "../../components/i18n-context";
 import type { PerseusMatrixWidgetOptions } from "../../perseus-types";
 import type { PerseusStrings } from "../../strings";
 import type { WidgetProps, PerseusScore } from "../../types";
-type Rubric = PerseusMatrixWidgetOptions;
-type ExternalProps = WidgetProps<PerseusMatrixWidgetOptions, Rubric>;
+import type { PerseusMatrixRubric, PerseusMatrixUserInput } from "../../validation.types";
+export declare function getMatrixSize(matrix: ReadonlyArray<ReadonlyArray<number>>): number[];
+type ExternalProps = WidgetProps<PerseusMatrixWidgetOptions, PerseusMatrixRubric>;
 type Props = ExternalProps & {
     onChange: (arg1: {
         cursorPosition?: ReadonlyArray<number>;
@@ -32,7 +33,7 @@ declare class Matrix extends React.Component<Props, State> {
     context: React.ContextType<typeof PerseusI18nContext>;
     cursorPosition: [number, number];
     static defaultProps: DefaultProps;
-    static validate(state: any, rubric: any, strings: PerseusStrings): PerseusScore;
+    static validate(state: PerseusMatrixUserInput, rubric: PerseusMatrixRubric, strings: PerseusStrings): PerseusScore;
     state: State;
     componentDidMount(): void;
     getInputPaths: () => ReadonlyArray<ReadonlyArray<string>>;
@@ -46,8 +47,8 @@ declare class Matrix extends React.Component<Props, State> {
     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;
-    getUserInput: () => any;
-    simpleValidate: (arg1: any) => any;
+    getUserInput(): PerseusMatrixUserInput;
+    simpleValidate(rubric: PerseusMatrixRubric): PerseusScore;
     render(): React.ReactNode;
 }
 declare const _default: Readonly<{

package/dist/widgets/molecule/molecule.d.ts

@@ -1,6 +1,7 @@
 import * as React from "react";
 import { PerseusI18nContext } from "../../components/i18n-context";
 import type { PerseusMoleculeRendererWidgetOptions } from "../../perseus-types";
+import type { PerseusMoleculeUserInput } from "../../validation.types";
 type MoleculeState = {
     parsedSmiles: any;
     error: string | null;
@@ -32,7 +33,7 @@ type DefaultProps = {
 declare class MoleculeWidget extends React.Component<Props> {
     static defaultProps: DefaultProps;
     simpleValidate(): import("../../types").PerseusScore;
-    getUserInput: () => ReadonlyArray<ReadonlyArray<string>>;
+    getUserInput(): PerseusMoleculeUserInput;
     validate(): import("../../types").PerseusScore;
     render(): React.ReactNode;
 }

package/dist/widgets/number-line/number-line-validator.d.ts

@@ -0,0 +1,4 @@
+import type { PerseusScore } from "../../types";
+import type { PerseusNumberLineRubric, PerseusNumberLineUserInput } from "../../validation.types";
+declare function numberLineValidator(state: PerseusNumberLineUserInput, rubric: PerseusNumberLineRubric): PerseusScore;
+export default numberLineValidator;

package/dist/widgets/number-line/number-line.d.ts

@@ -1,7 +1,9 @@
 import * as React from "react";
 import { PerseusI18nContext } from "../../components/i18n-context";
 import type { ChangeableProps } from "../../mixins/changeable";
-import type { APIOptions } from "../../types";
+import type { APIOptions, PerseusScore } from "../../types";
+import type { PerseusNumberLineRubric, PerseusNumberLineUserInput } from "../../validation.types";
+export type Relationship = "lt" | "gt" | "le" | "ge";
 type Props = ChangeableProps & {
     range: [number, number];
     labelRange: ReadonlyArray<number | null>;
@@ -13,7 +15,7 @@ type Props = ChangeableProps & {
     isTickCtrl: boolean;
     isInequality: boolean;
     numLinePosition: number;
-    rel: "lt" | "gt" | "le" | "ge";
+    rel: Relationship;
     onFocus: (arg1: any) => void;
     onBlur: (arg1: any) => void;
     onChange: (arg1: any, arg2?: () => void | null | undefined) => void;
@@ -48,6 +50,7 @@ declare class NumberLine extends React.Component<Props, State> {
     context: React.ContextType<typeof PerseusI18nContext>;
     static defaultProps: DefaultProps;
     state: any;
+    static validate(state: PerseusNumberLineUserInput, rubric: PerseusNumberLineRubric): PerseusScore;
     change: (...args: ReadonlyArray<unknown>) => any;
     isValid: () => boolean;
     onNumDivisionsChange: (arg1: number, arg2: any) => void;
@@ -69,8 +72,8 @@ declare class NumberLine extends React.Component<Props, State> {
     _getInequalityEndpoint: (arg1: any) => [number, number];
     _renderInequality: (arg1: any) => React.ReactElement;
     _setupGraphie: (arg1: any, arg2: any) => void;
-    getUserInput: () => any;
-    simpleValidate: (arg1: any) => any;
+    getUserInput(): PerseusNumberLineUserInput;
+    simpleValidate(rubric: PerseusNumberLineRubric): PerseusScore;
     render(): React.ReactNode;
 }
 declare const _default: Readonly<{

package/dist/widgets/numeric-input/numeric-input-validator.d.ts

@@ -1,6 +1,6 @@
-import type { Rubric, UserInput } from "./numeric-input.types";
 import type { PerseusStrings } from "../../strings";
 import type { PerseusScore } from "../../types";
+import type { PerseusNumericInputRubric, PerseusNumericInputUserInput } from "../../validation.types";
 export declare function maybeParsePercentInput(inputValue: string | number, normalizedAnswerExpected: boolean): string | number;
-declare function numericInputValidator(userInput: UserInput, rubric: Rubric, strings: PerseusStrings): PerseusScore;
+declare function numericInputValidator(userInput: PerseusNumericInputUserInput, rubric: PerseusNumericInputRubric, strings: PerseusStrings): PerseusScore;
 export default numericInputValidator;

package/dist/widgets/numeric-input/numeric-input.d.ts

@@ -2,11 +2,11 @@ import * as React from "react";
 import { PerseusI18nContext } from "../../components/i18n-context";
 import InputWithExamples from "../../components/input-with-examples";
 import SimpleKeypadInput from "../../components/simple-keypad-input";
-import type { Rubric, UserInput } from "./numeric-input.types";
 import type { PerseusNumericInputWidgetOptions, PerseusNumericInputAnswerForm } from "../../perseus-types";
 import type { PerseusStrings } from "../../strings";
 import type { FocusPath, PerseusScore, WidgetProps } from "../../types";
-type ExternalProps = WidgetProps<PerseusNumericInputWidgetOptions, Rubric>;
+import type { PerseusNumericInputRubric, PerseusNumericInputUserInput } from "../../validation.types";
+type ExternalProps = WidgetProps<PerseusNumericInputWidgetOptions, PerseusNumericInputRubric>;
 type Props = ExternalProps & {
     size: NonNullable<ExternalProps["size"]>;
     rightAlign: NonNullable<ExternalProps["rightAlign"]>;
@@ -38,20 +38,20 @@ export declare class NumericInput extends React.Component<Props, State> {
     context: React.ContextType<typeof PerseusI18nContext>;
     inputRef: SimpleKeypadInput | InputWithExamples | null | undefined;
     static defaultProps: DefaultProps;
-    static getUserInputFromProps(props: Props): UserInput;
-    static getOneCorrectAnswerFromRubric(rubric: Rubric): string | null | undefined;
-    static validate(userInput: UserInput, rubric: Rubric, strings: PerseusStrings): PerseusScore;
+    static getUserInputFromProps(props: Props): PerseusNumericInputUserInput;
+    static getOneCorrectAnswerFromRubric(rubric: PerseusNumericInputRubric): string | null | undefined;
+    static validate(userInput: PerseusNumericInputUserInput, rubric: PerseusNumericInputRubric, strings: PerseusStrings): PerseusScore;
     state: State;
     examples: () => ReadonlyArray<string>;
     shouldShowExamples: () => boolean;
-    simpleValidate: (arg1: Rubric) => PerseusScore;
+    simpleValidate(rubric: PerseusNumericInputRubric): PerseusScore;
     focus: () => boolean;
     focusInputPath: () => void;
     blurInputPath: () => void;
     getInputPaths: () => ReadonlyArray<ReadonlyArray<string>>;
     getGrammarTypeForPath: (arg1: FocusPath) => string;
     setInputValue: (arg1: FocusPath, arg2: string, arg3?: () => unknown | null | undefined) => void;
-    getUserInput: () => UserInput;
+    getUserInput(): PerseusNumericInputUserInput;
     handleChange: (arg1: string, arg2?: () => unknown | null | undefined) => void;
     _handleFocus: () => void;
     _handleBlur: () => void;