@khanacademy/perseus 8.0.0 → 9.0.0

package/dist/interaction-tracker.d.ts

@@ -2,10 +2,10 @@ import type { APIOptions, Tracking } from "./types";
 /**
  * Wrapper for the trackInteraction apiOption.
  */
-declare class InteractionTracker {
+declare class InteractionTracker<T> {
     _tracked: boolean;
     setting: Tracking;
-    track: (extraData?: any) => void;
+    track: (extraData?: T) => void;
     trackApi: any;
     widgetID: string;
     widgetType: string;
@@ -18,6 +18,6 @@ declare class InteractionTracker {
      * @param extraData Any extra data to track about the event.
      * @private
      */
-    _track: (extraData: Record<string, any>) => void;
+    _track: (extraData: T) => void;
 }
 export default InteractionTracker;

package/dist/item-renderer.d.ts

@@ -3,7 +3,7 @@ import HintsRenderer from "./hints-renderer";
 import Renderer from "./renderer";
 import type { KeypadProps } from "./mixins/provide-keypad";
 import type { PerseusItem } from "./perseus-types";
-import type { APIOptions, FocusPath, LinterContextProps } from "./types";
+import type { APIOptions, FocusPath, LinterContextProps, PerseusDependenciesV2 } from "./types";
 import type { KEScore } from "@khanacademy/perseus-core";
 type Props = // These props are used by the ProvideKeypad mixin.
 KeypadProps & {
@@ -23,6 +23,7 @@ KeypadProps & {
     savedState: any;
     linterContext: LinterContextProps;
     legacyPerseusLint?: ReadonlyArray<string>;
+    dependencies: PerseusDependenciesV2;
 };
 type DefaultProps = {
     apiOptions: Props["apiOptions"];

package/dist/multi-items/multi-renderer.d.ts

@@ -1,7 +1,7 @@
 import * as React from "react";
 import Renderer from "../renderer";
 import type { Widget } from "../renderer";
-import type { APIOptions, FilterCriterion } from "../types";
+import type { APIOptions, FilterCriterion, PerseusDependenciesV2 } from "../types";
 import type { Item, ContentNode, HintNode, TagsNode } from "./item-types";
 import type { Shape, ArrayShape } from "./shape-types";
 import type { Tree } from "./tree-types";
@@ -47,6 +47,7 @@ type Props = {
     onInteractWithWidget?: (id: string) => void;
     apiOptions?: APIOptions;
     reviewMode?: boolean | null | undefined;
+    dependencies: PerseusDependenciesV2;
 };
 type State = {
     rendererDataTree: RendererDataTree | null | undefined;

package/dist/perseus-api.d.ts

@@ -83,7 +83,7 @@ export declare const ApiOptions: {
             type: string;
             id: string;
             correct?: boolean | undefined;
-        } & Record<string, unknown>) => void) | undefined;
+        } & Partial<import("./types").TrackingGradedGroupExtraArguments> & Partial<import("./types").TrackingSequenceExtraArguments>) => void) | undefined;
         customKeypad?: boolean | undefined;
         useV2Keypad?: boolean | undefined;
         nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;

package/dist/renderer.d.ts

@@ -93,7 +93,7 @@ declare class Renderer extends React.Component<Props, State> {
     _currentFocus: FocusPath | null | undefined;
     _foundTextNodes: boolean;
     _interactionTrackers: {
-        [id: string]: InteractionTracker;
+        [id: string]: InteractionTracker<any>;
     };
     _isMounted: boolean;
     _isTwoColumn: boolean;

package/dist/server-item-renderer.d.ts

@@ -9,7 +9,7 @@
 import * as React from "react";
 import Renderer from "./renderer";
 import type { KeypadProps } from "./mixins/provide-keypad";
-import type { APIOptions, FocusPath } from "./types";
+import type { APIOptions, FocusPath, PerseusDependenciesV2 } from "./types";
 import type { RendererInterface, KEScore } from "@khanacademy/perseus-core";
 type OwnProps = // These props are used by the ProvideKeypad mixin.
 KeypadProps & {
@@ -22,6 +22,7 @@ KeypadProps & {
     problemNum?: number;
     reviewMode?: boolean;
     keypadElement?: any | null | undefined;
+    dependencies: PerseusDependenciesV2;
 };
 type HOCProps = {
     onRendered: (isRendered: boolean) => void;
@@ -110,5 +111,6 @@ declare const ref: React.ForwardRefExoticComponent<Omit<KeypadProps & {
     problemNum?: number | undefined;
     reviewMode?: boolean | undefined;
     keypadElement?: any | null | undefined;
+    dependencies: PerseusDependenciesV2;
 } & HOCProps, "onRendered"> & React.RefAttributes<ServerItemRenderer>>;
 export default ref;

package/dist/types.d.ts

@@ -4,10 +4,11 @@ import type { Item } from "./multi-items/item-types";
 import type { PerseusWidget } from "./perseus-types";
 import type { SizeClass } from "./util/sizing-utils";
 import type { KeypadAPI } from "@khanacademy/math-input";
-import type { SendEventFn } from "@khanacademy/perseus-core";
+import type { AnalyticsEventHandlerFn } from "@khanacademy/perseus-core";
 import type { Result } from "@khanacademy/wonder-blocks-data";
 import type * as React from "react";
 export type FocusPath = ReadonlyArray<string> | null | undefined;
+type Empty = Record<never, never>;
 export type Dimensions = {
     width?: number;
     height?: number;
@@ -75,6 +76,11 @@ export type ImageUploader = (file: string, callback: (url: string) => unknown) =
 export type WidgetSize = "normal" | "small" | "mini";
 export type Path = ReadonlyArray<string>;
 type StubTagEditorType = any;
+type TrackInteractionArgs = {
+    type: string;
+    id: string;
+    correct?: boolean;
+} & Partial<TrackingGradedGroupExtraArguments> & Partial<TrackingSequenceExtraArguments>;
 export type APIOptions = Readonly<{
     isArticle?: boolean;
     onInputError?: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
@@ -92,11 +98,7 @@ export type APIOptions = Readonly<{
         Link: React.ComponentType<any>;
     };
     imagePreloader?: (dimensions: Dimensions) => React.ReactNode;
-    trackInteraction?: (args: {
-        type: string;
-        id: string;
-        correct?: boolean;
-    } & Record<string, unknown>) => void;
+    trackInteraction?: (args: TrackInteractionArgs) => void;
     customKeypad?: boolean;
     useV2Keypad?: boolean;
     nativeKeypadProxy?: (blur: () => void) => KeypadAPI;
@@ -161,7 +163,6 @@ export type PerseusDependencies = {
     TeX: React.ComponentType<TeXProps>;
     staticUrl: StaticUrlFn;
     InitialRequestUrl: InitialRequestUrlInterface;
-    analytics: SendEventFn;
     useVideo(id: string, kind: VideoKind): Result<{
         video: VideoData | null | undefined;
     }>;
@@ -170,6 +171,19 @@ export type PerseusDependencies = {
     kaLocale: string;
     isMobile: boolean;
 };
+/**
+ * The modern iteration of Perseus Depedndencies. These dependencies are
+ * provided to Perseus through its entrypoints (for example:
+ * ServerItemRenderer) and then attached to the DependenciesContext so they are
+ * available anywhere down the React render tree.
+ *
+ * Prefer using this type over `PerseusDependencies` when possible.
+ */
+export type PerseusDependenciesV2 = {
+    analytics: {
+        onAnalyticsEvent: AnalyticsEventHandlerFn;
+    };
+};
 export type APIOptionsWithDefaults = Readonly<APIOptions & {
     GroupMetadataEditor: NonNullable<APIOptions["GroupMetadataEditor"]>;
     baseElements: NonNullable<APIOptions["baseElements"]>;
@@ -195,6 +209,12 @@ export type LinterContextProps = {
     stack: ReadonlyArray<string>;
 };
 export type Tracking = "" | "all";
+export type TrackingGradedGroupExtraArguments = {
+    status: "correct" | "incorrect" | "invalid";
+};
+export type TrackingSequenceExtraArguments = {
+    visible: number;
+};
 export type Alignment = "default" | "block" | "inline-block" | "inline" | "float-left" | "float-right" | "full-width";
 type WidgetOptions = any;
 export type WidgetTransform = (arg1: WidgetOptions, problemNumber?: number) => any;
@@ -220,7 +240,7 @@ export type WidgetExports<T extends React.ComponentType<any> = React.ComponentTy
 }>;
 export type WidgetInfo = PerseusWidget;
 export type FilterCriterion = string | ((id: string, widgetInfo: WidgetInfo, widget?: Widget | null | undefined) => boolean);
-export type WidgetProps<RenderProps, Rubric> = RenderProps & {
+export type WidgetProps<RenderProps, Rubric, TrackingExtraArgs = Empty> = RenderProps & {
     widgetId: string;
     alignment: string | null | undefined;
     static: boolean | null | undefined;
@@ -233,7 +253,7 @@ export type WidgetProps<RenderProps, Rubric> = RenderProps & {
     findWidgets: (arg1: FilterCriterion) => ReadonlyArray<Widget>;
     reviewModeRubric: Rubric;
     onChange: ChangeHandler;
-    trackInteraction: (extraData?: any) => void;
+    trackInteraction: (extraData?: TrackingExtraArgs) => void;
     isLastUsedWidget: boolean;
     linterContext: LinterContextProps;
     containerSizeClass: SizeClass;

package/dist/widgets/expression.d.ts

@@ -1,11 +1,20 @@
+import { KeypadType } from "@khanacademy/math-input";
 import * as React from "react";
+import { useDependencies } from "../dependencies";
 import type { PerseusExpressionWidgetOptions } from "../perseus-types";
 import type { PerseusScore, WidgetProps } from "../types";
 import type { Keys as Key } from "@khanacademy/math-input";
 type InputPath = ReadonlyArray<string>;
 type Rubric = PerseusExpressionWidgetOptions;
+type RenderProps = {
+    buttonSets: PerseusExpressionWidgetOptions["buttonSets"];
+    buttonsVisible?: PerseusExpressionWidgetOptions["buttonsVisible"];
+    functions: PerseusExpressionWidgetOptions["functions"];
+    times: PerseusExpressionWidgetOptions["times"];
+    keypadConfiguration: ReturnType<typeof keypadConfigurationForProps>;
+};
 type ExternalProps = WidgetProps<RenderProps, Rubric>;
-export type Props = ExternalProps & {
+export type Props = ExternalProps & ReturnType<typeof useDependencies> & {
     apiOptions: NonNullable<ExternalProps["apiOptions"]>;
     buttonSets: NonNullable<ExternalProps["buttonSets"]>;
     functions: NonNullable<ExternalProps["functions"]>;
@@ -56,22 +65,219 @@ export declare class Expression extends React.Component<Props, ExpressionState>
     getInputPaths: () => ReadonlyArray<ReadonlyArray<any>>;
     getGrammarTypeForPath: (inputPath: string) => string;
     setInputValue: (path: string, newValue: string, cb: () => void) => void;
+    sendExpressionEvaluatedEvent(result: "correct" | "incorrect" | "invalid"): void;
     render(): React.ReactNode | React.ReactElement<React.ComponentProps<"div">>;
 }
-type RenderProps = {
-    buttonSets: any;
-    buttonsVisible?: "always" | "focused" | "never";
-    functions: ReadonlyArray<string>;
-    keypadConfiguration: {
-        extraKeys: ReadonlyArray<any | string>;
-        keypadType: any;
-    };
-    times: boolean;
+/**
+ * Determine the keypad configuration parameters for the input, based on the
+ * provided properties.
+ *
+ * There are two configuration parameters to be passed to the keypad:
+ *   (1) The keypad type. For the Expression widget, we always use the
+ *       Expression keypad.
+ *   (2) The extra keys; namely, any variables or constants (like Pi) that need
+ *       to be included as keys on the keypad. These are scraped from the answer
+ *       forms.
+ */
+declare const keypadConfigurationForProps: (widgetOptions: PerseusExpressionWidgetOptions) => {
+    keypadType: KeypadType;
+    extraKeys: string[];
 };
 declare const _default: Readonly<{
     name: string;
     displayName: string;
-    getWidget?: (() => typeof Expression) | undefined;
+    getWidget?: (() => React.ForwardRefExoticComponent<Omit<Pick<RenderProps & {
+        widgetId: string;
+        alignment: string | null | undefined;
+        static: boolean | null | undefined;
+        problemNum: number | null | undefined;
+        apiOptions: Readonly<Readonly<{
+            isArticle?: boolean | undefined;
+            onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
+            onFocusChange?: ((newFocusPath: import("../types").FocusPath, oldFocusPath: import("../types").FocusPath, keypadElement?: HTMLElement | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
+            GroupMetadataEditor?: React.ComponentType<any> | undefined;
+            showAlignmentOptions?: boolean | undefined;
+            readOnly?: boolean | undefined;
+            answerableCallback?: ((arg1: boolean) => unknown) | undefined;
+            getAnotherHint?: (() => unknown) | undefined;
+            interactionCallback?: (() => unknown) | undefined;
+            groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
+            imagePlaceholder?: React.ReactNode;
+            widgetPlaceholder?: React.ReactNode;
+            baseElements?: {
+                Link: React.ComponentType<any>;
+            } | undefined;
+            imagePreloader?: ((dimensions: import("../types").Dimensions) => React.ReactNode) | undefined;
+            trackInteraction?: ((args: {
+                type: string;
+                id: string;
+                correct?: boolean | undefined;
+            } & Partial<import("../types").TrackingGradedGroupExtraArguments> & Partial<import("../types").TrackingSequenceExtraArguments>) => void) | undefined;
+            customKeypad?: boolean | undefined;
+            useV2Keypad?: boolean | undefined;
+            nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
+            isMobile?: boolean | undefined;
+            setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
+            useDraftEditor?: boolean | undefined;
+            hintProgressColor?: string | undefined;
+            canScrollPage?: boolean | undefined;
+            inModal?: boolean | undefined;
+            crossOutEnabled?: boolean | undefined;
+            editorChangeDelay?: number | undefined;
+        }> & {
+            GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
+            baseElements: {
+                Link: React.ComponentType<any>;
+            };
+            canScrollPage: NonNullable<boolean | undefined>;
+            crossOutEnabled: NonNullable<boolean | undefined>;
+            editorChangeDelay: number;
+            groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
+            inModal: NonNullable<boolean | undefined>;
+            isArticle: NonNullable<boolean | undefined>;
+            isMobile: NonNullable<boolean | undefined>;
+            useV2Keypad: NonNullable<boolean | undefined>;
+            onFocusChange: (newFocusPath: import("../types").FocusPath, oldFocusPath: import("../types").FocusPath, keypadElement?: HTMLElement | undefined, focusedElement?: HTMLElement | undefined) => unknown;
+            onInputError: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
+            readOnly: NonNullable<boolean | undefined>;
+            setDrawingAreaAvailable: (arg1: boolean) => unknown;
+            showAlignmentOptions: NonNullable<boolean | undefined>;
+            useDraftEditor: NonNullable<boolean | undefined>;
+        }>;
+        keypadElement?: any;
+        questionCompleted?: boolean | undefined;
+        onFocus: (blurPath: import("../types").FocusPath) => void;
+        onBlur: (blurPath: import("../types").FocusPath) => void;
+        findWidgets: (arg1: import("../types").FilterCriterion) => readonly any[];
+        reviewModeRubric: PerseusExpressionWidgetOptions;
+        onChange: import("../types").ChangeHandler;
+        trackInteraction: (extraData?: {} | undefined) => void;
+        isLastUsedWidget: boolean;
+        linterContext: import("../types").LinterContextProps;
+        containerSizeClass: import("../util/sizing-utils").SizeClass;
+    } & import("../types").PerseusDependenciesV2 & {
+        apiOptions: Readonly<Readonly<{
+            isArticle?: boolean | undefined;
+            onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
+            onFocusChange?: ((newFocusPath: import("../types").FocusPath, oldFocusPath: import("../types").FocusPath, keypadElement?: HTMLElement | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
+            GroupMetadataEditor?: React.ComponentType<any> | undefined;
+            showAlignmentOptions?: boolean | undefined;
+            readOnly?: boolean | undefined;
+            answerableCallback?: ((arg1: boolean) => unknown) | undefined;
+            getAnotherHint?: (() => unknown) | undefined;
+            interactionCallback?: (() => unknown) | undefined;
+            groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
+            imagePlaceholder?: React.ReactNode;
+            widgetPlaceholder?: React.ReactNode;
+            baseElements?: {
+                Link: React.ComponentType<any>;
+            } | undefined;
+            imagePreloader?: ((dimensions: import("../types").Dimensions) => React.ReactNode) | undefined;
+            trackInteraction?: ((args: {
+                type: string;
+                id: string;
+                correct?: boolean | undefined;
+            } & Partial<import("../types").TrackingGradedGroupExtraArguments> & Partial<import("../types").TrackingSequenceExtraArguments>) => void) | undefined;
+            customKeypad?: boolean | undefined;
+            useV2Keypad?: boolean | undefined;
+            nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
+            isMobile?: boolean | undefined;
+            setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
+            useDraftEditor?: boolean | undefined;
+            hintProgressColor?: string | undefined;
+            canScrollPage?: boolean | undefined;
+            inModal?: boolean | undefined;
+            crossOutEnabled?: boolean | undefined;
+            editorChangeDelay?: number | undefined;
+        }> & {
+            GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
+            baseElements: {
+                Link: React.ComponentType<any>;
+            };
+            canScrollPage: NonNullable<boolean | undefined>;
+            crossOutEnabled: NonNullable<boolean | undefined>;
+            editorChangeDelay: number;
+            groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
+            inModal: NonNullable<boolean | undefined>;
+            isArticle: NonNullable<boolean | undefined>;
+            isMobile: NonNullable<boolean | undefined>;
+            useV2Keypad: NonNullable<boolean | undefined>;
+            onFocusChange: (newFocusPath: import("../types").FocusPath, oldFocusPath: import("../types").FocusPath, keypadElement?: HTMLElement | undefined, focusedElement?: HTMLElement | undefined) => unknown;
+            onInputError: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
+            readOnly: NonNullable<boolean | undefined>;
+            setDrawingAreaAvailable: (arg1: boolean) => unknown;
+            showAlignmentOptions: NonNullable<boolean | undefined>;
+            useDraftEditor: NonNullable<boolean | undefined>;
+        }>;
+        buttonSets: readonly string[];
+        functions: readonly string[];
+        linterContext: import("../types").LinterContextProps;
+        onBlur: (blurPath: import("../types").FocusPath) => void;
+        onFocus: (blurPath: import("../types").FocusPath) => void;
+        times: boolean;
+        value: string;
+    }, "static" | "trackInteraction" | "onChange" | "problemNum" | "questionCompleted" | "keypadElement" | "alignment" | "findWidgets" | "buttonsVisible" | "containerSizeClass" | "widgetId" | "keypadConfiguration" | "reviewModeRubric" | "isLastUsedWidget" | "analytics"> & {
+        value?: string | undefined;
+        onFocus?: ((blurPath: import("../types").FocusPath) => void) | undefined;
+        onBlur?: ((blurPath: import("../types").FocusPath) => void) | undefined;
+        linterContext?: import("../types").LinterContextProps | undefined;
+        apiOptions?: Readonly<Readonly<{
+            isArticle?: boolean | undefined;
+            onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
+            onFocusChange?: ((newFocusPath: import("../types").FocusPath, oldFocusPath: import("../types").FocusPath, keypadElement?: HTMLElement | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
+            GroupMetadataEditor?: React.ComponentType<any> | undefined;
+            showAlignmentOptions?: boolean | undefined;
+            readOnly?: boolean | undefined;
+            answerableCallback?: ((arg1: boolean) => unknown) | undefined;
+            getAnotherHint?: (() => unknown) | undefined;
+            interactionCallback?: (() => unknown) | undefined;
+            groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
+            imagePlaceholder?: React.ReactNode;
+            widgetPlaceholder?: React.ReactNode;
+            baseElements?: {
+                Link: React.ComponentType<any>;
+            } | undefined;
+            imagePreloader?: ((dimensions: import("../types").Dimensions) => React.ReactNode) | undefined;
+            trackInteraction?: ((args: {
+                type: string;
+                id: string;
+                correct?: boolean | undefined;
+            } & Partial<import("../types").TrackingGradedGroupExtraArguments> & Partial<import("../types").TrackingSequenceExtraArguments>) => void) | undefined;
+            customKeypad?: boolean | undefined;
+            useV2Keypad?: boolean | undefined;
+            nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
+            isMobile?: boolean | undefined;
+            setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
+            useDraftEditor?: boolean | undefined;
+            hintProgressColor?: string | undefined;
+            canScrollPage?: boolean | undefined;
+            inModal?: boolean | undefined;
+            crossOutEnabled?: boolean | undefined;
+            editorChangeDelay?: number | undefined;
+        }> & {
+            GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
+            baseElements: {
+                Link: React.ComponentType<any>;
+            };
+            canScrollPage: NonNullable<boolean | undefined>;
+            crossOutEnabled: NonNullable<boolean | undefined>;
+            editorChangeDelay: number;
+            groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
+            inModal: NonNullable<boolean | undefined>;
+            isArticle: NonNullable<boolean | undefined>;
+            isMobile: NonNullable<boolean | undefined>;
+            useV2Keypad: NonNullable<boolean | undefined>;
+            onFocusChange: (newFocusPath: import("../types").FocusPath, oldFocusPath: import("../types").FocusPath, keypadElement?: HTMLElement | undefined, focusedElement?: HTMLElement | undefined) => unknown;
+            onInputError: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
+            readOnly: NonNullable<boolean | undefined>;
+            setDrawingAreaAvailable: (arg1: boolean) => unknown;
+            showAlignmentOptions: NonNullable<boolean | undefined>;
+            useDraftEditor: NonNullable<boolean | undefined>;
+        }> | undefined;
+        times?: boolean | undefined;
+        buttonSets?: readonly string[] | undefined;
+        functions?: readonly string[] | undefined;
+    } & {}, "analytics"> & React.RefAttributes<Expression>>) | undefined;
     accessible?: boolean | ((props: any) => boolean) | undefined;
     hidden?: boolean | undefined;
     version?: import("../types").Version | undefined;
@@ -86,6 +292,197 @@ declare const _default: Readonly<{
     propUpgrades?: {
         [key: string]: (arg1: any) => any;
     } | undefined;
-    widget: typeof Expression;
+    widget: React.ForwardRefExoticComponent<Omit<Pick<RenderProps & {
+        widgetId: string;
+        alignment: string | null | undefined;
+        static: boolean | null | undefined;
+        problemNum: number | null | undefined;
+        apiOptions: Readonly<Readonly<{
+            isArticle?: boolean | undefined;
+            onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
+            onFocusChange?: ((newFocusPath: import("../types").FocusPath, oldFocusPath: import("../types").FocusPath, keypadElement?: HTMLElement | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
+            GroupMetadataEditor?: React.ComponentType<any> | undefined;
+            showAlignmentOptions?: boolean | undefined;
+            readOnly?: boolean | undefined;
+            answerableCallback?: ((arg1: boolean) => unknown) | undefined;
+            getAnotherHint?: (() => unknown) | undefined;
+            interactionCallback?: (() => unknown) | undefined;
+            groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
+            imagePlaceholder?: React.ReactNode;
+            widgetPlaceholder?: React.ReactNode;
+            baseElements?: {
+                Link: React.ComponentType<any>;
+            } | undefined;
+            imagePreloader?: ((dimensions: import("../types").Dimensions) => React.ReactNode) | undefined;
+            trackInteraction?: ((args: {
+                type: string;
+                id: string;
+                correct?: boolean | undefined;
+            } & Partial<import("../types").TrackingGradedGroupExtraArguments> & Partial<import("../types").TrackingSequenceExtraArguments>) => void) | undefined;
+            customKeypad?: boolean | undefined;
+            useV2Keypad?: boolean | undefined;
+            nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
+            isMobile?: boolean | undefined;
+            setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
+            useDraftEditor?: boolean | undefined;
+            hintProgressColor?: string | undefined;
+            canScrollPage?: boolean | undefined;
+            inModal?: boolean | undefined;
+            crossOutEnabled?: boolean | undefined;
+            editorChangeDelay?: number | undefined;
+        }> & {
+            GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
+            baseElements: {
+                Link: React.ComponentType<any>;
+            };
+            canScrollPage: NonNullable<boolean | undefined>;
+            crossOutEnabled: NonNullable<boolean | undefined>;
+            editorChangeDelay: number;
+            groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
+            inModal: NonNullable<boolean | undefined>;
+            isArticle: NonNullable<boolean | undefined>;
+            isMobile: NonNullable<boolean | undefined>;
+            useV2Keypad: NonNullable<boolean | undefined>;
+            onFocusChange: (newFocusPath: import("../types").FocusPath, oldFocusPath: import("../types").FocusPath, keypadElement?: HTMLElement | undefined, focusedElement?: HTMLElement | undefined) => unknown;
+            onInputError: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
+            readOnly: NonNullable<boolean | undefined>;
+            setDrawingAreaAvailable: (arg1: boolean) => unknown;
+            showAlignmentOptions: NonNullable<boolean | undefined>;
+            useDraftEditor: NonNullable<boolean | undefined>;
+        }>;
+        keypadElement?: any;
+        questionCompleted?: boolean | undefined;
+        onFocus: (blurPath: import("../types").FocusPath) => void;
+        onBlur: (blurPath: import("../types").FocusPath) => void;
+        findWidgets: (arg1: import("../types").FilterCriterion) => readonly any[];
+        reviewModeRubric: PerseusExpressionWidgetOptions;
+        onChange: import("../types").ChangeHandler;
+        trackInteraction: (extraData?: {} | undefined) => void;
+        isLastUsedWidget: boolean;
+        linterContext: import("../types").LinterContextProps;
+        containerSizeClass: import("../util/sizing-utils").SizeClass;
+    } & import("../types").PerseusDependenciesV2 & {
+        apiOptions: Readonly<Readonly<{
+            isArticle?: boolean | undefined;
+            onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
+            onFocusChange?: ((newFocusPath: import("../types").FocusPath, oldFocusPath: import("../types").FocusPath, keypadElement?: HTMLElement | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
+            GroupMetadataEditor?: React.ComponentType<any> | undefined;
+            showAlignmentOptions?: boolean | undefined;
+            readOnly?: boolean | undefined;
+            answerableCallback?: ((arg1: boolean) => unknown) | undefined;
+            getAnotherHint?: (() => unknown) | undefined;
+            interactionCallback?: (() => unknown) | undefined;
+            groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
+            imagePlaceholder?: React.ReactNode;
+            widgetPlaceholder?: React.ReactNode;
+            baseElements?: {
+                Link: React.ComponentType<any>;
+            } | undefined;
+            imagePreloader?: ((dimensions: import("../types").Dimensions) => React.ReactNode) | undefined;
+            trackInteraction?: ((args: {
+                type: string;
+                id: string;
+                correct?: boolean | undefined;
+            } & Partial<import("../types").TrackingGradedGroupExtraArguments> & Partial<import("../types").TrackingSequenceExtraArguments>) => void) | undefined;
+            customKeypad?: boolean | undefined;
+            useV2Keypad?: boolean | undefined;
+            nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
+            isMobile?: boolean | undefined;
+            setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
+            useDraftEditor?: boolean | undefined;
+            hintProgressColor?: string | undefined;
+            canScrollPage?: boolean | undefined;
+            inModal?: boolean | undefined;
+            crossOutEnabled?: boolean | undefined;
+            editorChangeDelay?: number | undefined;
+        }> & {
+            GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
+            baseElements: {
+                Link: React.ComponentType<any>;
+            };
+            canScrollPage: NonNullable<boolean | undefined>;
+            crossOutEnabled: NonNullable<boolean | undefined>;
+            editorChangeDelay: number;
+            groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
+            inModal: NonNullable<boolean | undefined>;
+            isArticle: NonNullable<boolean | undefined>;
+            isMobile: NonNullable<boolean | undefined>;
+            useV2Keypad: NonNullable<boolean | undefined>;
+            onFocusChange: (newFocusPath: import("../types").FocusPath, oldFocusPath: import("../types").FocusPath, keypadElement?: HTMLElement | undefined, focusedElement?: HTMLElement | undefined) => unknown;
+            onInputError: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
+            readOnly: NonNullable<boolean | undefined>;
+            setDrawingAreaAvailable: (arg1: boolean) => unknown;
+            showAlignmentOptions: NonNullable<boolean | undefined>;
+            useDraftEditor: NonNullable<boolean | undefined>;
+        }>;
+        buttonSets: readonly string[];
+        functions: readonly string[];
+        linterContext: import("../types").LinterContextProps;
+        onBlur: (blurPath: import("../types").FocusPath) => void;
+        onFocus: (blurPath: import("../types").FocusPath) => void;
+        times: boolean;
+        value: string;
+    }, "static" | "trackInteraction" | "onChange" | "problemNum" | "questionCompleted" | "keypadElement" | "alignment" | "findWidgets" | "buttonsVisible" | "containerSizeClass" | "widgetId" | "keypadConfiguration" | "reviewModeRubric" | "isLastUsedWidget" | "analytics"> & {
+        value?: string | undefined;
+        onFocus?: ((blurPath: import("../types").FocusPath) => void) | undefined;
+        onBlur?: ((blurPath: import("../types").FocusPath) => void) | undefined;
+        linterContext?: import("../types").LinterContextProps | undefined;
+        apiOptions?: Readonly<Readonly<{
+            isArticle?: boolean | undefined;
+            onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
+            onFocusChange?: ((newFocusPath: import("../types").FocusPath, oldFocusPath: import("../types").FocusPath, keypadElement?: HTMLElement | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
+            GroupMetadataEditor?: React.ComponentType<any> | undefined;
+            showAlignmentOptions?: boolean | undefined;
+            readOnly?: boolean | undefined;
+            answerableCallback?: ((arg1: boolean) => unknown) | undefined;
+            getAnotherHint?: (() => unknown) | undefined;
+            interactionCallback?: (() => unknown) | undefined;
+            groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
+            imagePlaceholder?: React.ReactNode;
+            widgetPlaceholder?: React.ReactNode;
+            baseElements?: {
+                Link: React.ComponentType<any>;
+            } | undefined;
+            imagePreloader?: ((dimensions: import("../types").Dimensions) => React.ReactNode) | undefined;
+            trackInteraction?: ((args: {
+                type: string;
+                id: string;
+                correct?: boolean | undefined;
+            } & Partial<import("../types").TrackingGradedGroupExtraArguments> & Partial<import("../types").TrackingSequenceExtraArguments>) => void) | undefined;
+            customKeypad?: boolean | undefined;
+            useV2Keypad?: boolean | undefined;
+            nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
+            isMobile?: boolean | undefined;
+            setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
+            useDraftEditor?: boolean | undefined;
+            hintProgressColor?: string | undefined;
+            canScrollPage?: boolean | undefined;
+            inModal?: boolean | undefined;
+            crossOutEnabled?: boolean | undefined;
+            editorChangeDelay?: number | undefined;
+        }> & {
+            GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
+            baseElements: {
+                Link: React.ComponentType<any>;
+            };
+            canScrollPage: NonNullable<boolean | undefined>;
+            crossOutEnabled: NonNullable<boolean | undefined>;
+            editorChangeDelay: number;
+            groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
+            inModal: NonNullable<boolean | undefined>;
+            isArticle: NonNullable<boolean | undefined>;
+            isMobile: NonNullable<boolean | undefined>;
+            useV2Keypad: NonNullable<boolean | undefined>;
+            onFocusChange: (newFocusPath: import("../types").FocusPath, oldFocusPath: import("../types").FocusPath, keypadElement?: HTMLElement | undefined, focusedElement?: HTMLElement | undefined) => unknown;
+            onInputError: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
+            readOnly: NonNullable<boolean | undefined>;
+            setDrawingAreaAvailable: (arg1: boolean) => unknown;
+            showAlignmentOptions: NonNullable<boolean | undefined>;
+            useDraftEditor: NonNullable<boolean | undefined>;
+        }> | undefined;
+        times?: boolean | undefined;
+        buttonSets?: readonly string[] | undefined;
+        functions?: readonly string[] | undefined;
+    } & {}, "analytics"> & React.RefAttributes<Expression>>;
 }>;
 export default _default;