@khanacademy/perseus-editor 28.5.3 → 28.5.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/dist/es/index.js +1 -1
  2. package/dist/index.js +1 -1
  3. package/dist/widgets/interactive-graph-editor/interactive-graph-editor.d.ts +2719 -83
  4. package/package.json +45 -46
  5. package/dist/diffs/tags-diff.d.ts +0 -21
package/dist/widgets/interactive-graph-editor/interactive-graph-editor.d.ts CHANGED
@@ -23,7 +23,74 @@ declare const InteractiveGraph: {
23
23
  lockedFigures: LockedFigure[];
24
24
  fullGraphAriaLabel?: string;
25
25
  fullGraphAriaDescription?: string;
26
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>): {
26
+ } & {
27
+ trackInteraction: (extraData?: Empty | undefined) => void;
28
+ widgetId: string;
29
+ widgetIndex: number;
30
+ alignment: string | null | undefined;
31
+ static: boolean | null | undefined;
32
+ problemNum: number | null | undefined;
33
+ apiOptions: Readonly<Readonly<{
34
+ isArticle?: boolean;
35
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
36
+ GroupMetadataEditor?: React.ComponentType<any>;
37
+ showAlignmentOptions?: boolean;
38
+ readOnly?: boolean;
39
+ answerableCallback?: (arg1: boolean) => unknown;
40
+ getAnotherHint?: () => unknown;
41
+ interactionCallback?: (widgetData: {
42
+ [widgetId: string]: any;
43
+ }) => void;
44
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
45
+ imagePlaceholder?: React.ReactNode;
46
+ widgetPlaceholder?: React.ReactNode;
47
+ baseElements?: {
48
+ Link: React.ComponentType<any>;
49
+ };
50
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
51
+ trackInteraction?: (args: {
52
+ type: string;
53
+ id: string;
54
+ correct?: boolean;
55
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
56
+ visible: number;
57
+ }>) => void;
58
+ customKeypad?: boolean;
59
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
60
+ isMobile?: boolean;
61
+ isMobileApp?: boolean;
62
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
63
+ hintProgressColor?: string;
64
+ canScrollPage?: boolean;
65
+ editorChangeDelay?: number;
66
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
67
+ }> & {
68
+ baseElements: NonNullable<{
69
+ Link: React.ComponentType<any>;
70
+ } | undefined>;
71
+ canScrollPage: NonNullable<boolean | undefined>;
72
+ editorChangeDelay: NonNullable<number | undefined>;
73
+ groupAnnotator: NonNullable<((groupNumber: number, widgetId: string) => React.ReactNode) | undefined>;
74
+ isArticle: NonNullable<boolean | undefined>;
75
+ isMobile: NonNullable<boolean | undefined>;
76
+ isMobileApp: NonNullable<boolean | undefined>;
77
+ onFocusChange: NonNullable<((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown) | undefined>;
78
+ readOnly: NonNullable<boolean | undefined>;
79
+ setDrawingAreaAvailable: NonNullable<((arg1: boolean) => unknown) | undefined>;
80
+ showAlignmentOptions: NonNullable<boolean | undefined>;
81
+ }>;
82
+ keypadElement?: any;
83
+ questionCompleted?: boolean;
84
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
85
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
86
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
87
+ reviewMode: boolean;
88
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
89
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
90
+ userInput: PerseusGraphType;
91
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
92
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
93
+ }): {
27
94
  mafsRef: React.RefObject<import("../../../../perseus/src/widgets/interactive-graphs/stateful-mafs-graph").StatefulMafsGraphType>;
28
95
  getUserInput(): import("@khanacademy/perseus-core").PerseusInteractiveGraphUserInput;
29
96
  getPromptJSON(): import("../../../../perseus/src/widget-ai-utils/interactive-graph/interactive-graph-ai-utils").InteractiveGraphPromptJSON | import("../../../../perseus/src/widget-ai-utils/unsupported-widget").UnsupportedWidgetPromptJSON;
@@ -509,7 +576,74 @@ declare const InteractiveGraph: {
509
576
  lockedFigures: LockedFigure[];
510
577
  fullGraphAriaLabel?: string;
511
578
  fullGraphAriaDescription?: string;
512
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>>;
579
+ } & {
580
+ trackInteraction: (extraData?: Empty | undefined) => void;
581
+ widgetId: string;
582
+ widgetIndex: number;
583
+ alignment: string | null | undefined;
584
+ static: boolean | null | undefined;
585
+ problemNum: number | null | undefined;
586
+ apiOptions: Readonly<Readonly<{
587
+ isArticle?: boolean;
588
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
589
+ GroupMetadataEditor?: React.ComponentType<any>;
590
+ showAlignmentOptions?: boolean;
591
+ readOnly?: boolean;
592
+ answerableCallback?: (arg1: boolean) => unknown;
593
+ getAnotherHint?: () => unknown;
594
+ interactionCallback?: (widgetData: {
595
+ [widgetId: string]: any;
596
+ }) => void;
597
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
598
+ imagePlaceholder?: React.ReactNode;
599
+ widgetPlaceholder?: React.ReactNode;
600
+ baseElements?: {
601
+ Link: React.ComponentType<any>;
602
+ };
603
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
604
+ trackInteraction?: (args: {
605
+ type: string;
606
+ id: string;
607
+ correct?: boolean;
608
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
609
+ visible: number;
610
+ }>) => void;
611
+ customKeypad?: boolean;
612
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
613
+ isMobile?: boolean;
614
+ isMobileApp?: boolean;
615
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
616
+ hintProgressColor?: string;
617
+ canScrollPage?: boolean;
618
+ editorChangeDelay?: number;
619
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
620
+ }> & {
621
+ baseElements: NonNullable<{
622
+ Link: React.ComponentType<any>;
623
+ } | undefined>;
624
+ canScrollPage: NonNullable<boolean | undefined>;
625
+ editorChangeDelay: NonNullable<number | undefined>;
626
+ groupAnnotator: NonNullable<((groupNumber: number, widgetId: string) => React.ReactNode) | undefined>;
627
+ isArticle: NonNullable<boolean | undefined>;
628
+ isMobile: NonNullable<boolean | undefined>;
629
+ isMobileApp: NonNullable<boolean | undefined>;
630
+ onFocusChange: NonNullable<((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown) | undefined>;
631
+ readOnly: NonNullable<boolean | undefined>;
632
+ setDrawingAreaAvailable: NonNullable<((arg1: boolean) => unknown) | undefined>;
633
+ showAlignmentOptions: NonNullable<boolean | undefined>;
634
+ }>;
635
+ keypadElement?: any;
636
+ questionCompleted?: boolean;
637
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
638
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
639
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
640
+ reviewMode: boolean;
641
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
642
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
643
+ userInput: PerseusGraphType;
644
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
645
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
646
+ }>;
513
647
  state: Readonly<any>;
514
648
  refs: {
515
649
  [key: string]: React.ReactInstance;
@@ -535,7 +669,74 @@ declare const InteractiveGraph: {
535
669
  lockedFigures: LockedFigure[];
536
670
  fullGraphAriaLabel?: string;
537
671
  fullGraphAriaDescription?: string;
538
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>>, nextState: Readonly<any>, nextContext: any): boolean;
672
+ } & {
673
+ trackInteraction: (extraData?: Empty | undefined) => void;
674
+ widgetId: string;
675
+ widgetIndex: number;
676
+ alignment: string | null | undefined;
677
+ static: boolean | null | undefined;
678
+ problemNum: number | null | undefined;
679
+ apiOptions: Readonly<Readonly<{
680
+ isArticle?: boolean;
681
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
682
+ GroupMetadataEditor?: React.ComponentType<any>;
683
+ showAlignmentOptions?: boolean;
684
+ readOnly?: boolean;
685
+ answerableCallback?: (arg1: boolean) => unknown;
686
+ getAnotherHint?: () => unknown;
687
+ interactionCallback?: (widgetData: {
688
+ [widgetId: string]: any;
689
+ }) => void;
690
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
691
+ imagePlaceholder?: React.ReactNode;
692
+ widgetPlaceholder?: React.ReactNode;
693
+ baseElements?: {
694
+ Link: React.ComponentType<any>;
695
+ };
696
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
697
+ trackInteraction?: (args: {
698
+ type: string;
699
+ id: string;
700
+ correct?: boolean;
701
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
702
+ visible: number;
703
+ }>) => void;
704
+ customKeypad?: boolean;
705
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
706
+ isMobile?: boolean;
707
+ isMobileApp?: boolean;
708
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
709
+ hintProgressColor?: string;
710
+ canScrollPage?: boolean;
711
+ editorChangeDelay?: number;
712
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
713
+ }> & {
714
+ baseElements: NonNullable<{
715
+ Link: React.ComponentType<any>;
716
+ } | undefined>;
717
+ canScrollPage: NonNullable<boolean | undefined>;
718
+ editorChangeDelay: NonNullable<number | undefined>;
719
+ groupAnnotator: NonNullable<((groupNumber: number, widgetId: string) => React.ReactNode) | undefined>;
720
+ isArticle: NonNullable<boolean | undefined>;
721
+ isMobile: NonNullable<boolean | undefined>;
722
+ isMobileApp: NonNullable<boolean | undefined>;
723
+ onFocusChange: NonNullable<((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown) | undefined>;
724
+ readOnly: NonNullable<boolean | undefined>;
725
+ setDrawingAreaAvailable: NonNullable<((arg1: boolean) => unknown) | undefined>;
726
+ showAlignmentOptions: NonNullable<boolean | undefined>;
727
+ }>;
728
+ keypadElement?: any;
729
+ questionCompleted?: boolean;
730
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
731
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
732
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
733
+ reviewMode: boolean;
734
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
735
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
736
+ userInput: PerseusGraphType;
737
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
738
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
739
+ }>, nextState: Readonly<any>, nextContext: any): boolean;
539
740
  componentWillUnmount?(): void;
540
741
  componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
541
742
  getSnapshotBeforeUpdate?(prevProps: Readonly<{
@@ -558,7 +759,74 @@ declare const InteractiveGraph: {
558
759
  lockedFigures: LockedFigure[];
559
760
  fullGraphAriaLabel?: string;
560
761
  fullGraphAriaDescription?: string;
561
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>>, prevState: Readonly<any>): any;
762
+ } & {
763
+ trackInteraction: (extraData?: Empty | undefined) => void;
764
+ widgetId: string;
765
+ widgetIndex: number;
766
+ alignment: string | null | undefined;
767
+ static: boolean | null | undefined;
768
+ problemNum: number | null | undefined;
769
+ apiOptions: Readonly<Readonly<{
770
+ isArticle?: boolean;
771
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
772
+ GroupMetadataEditor?: React.ComponentType<any>;
773
+ showAlignmentOptions?: boolean;
774
+ readOnly?: boolean;
775
+ answerableCallback?: (arg1: boolean) => unknown;
776
+ getAnotherHint?: () => unknown;
777
+ interactionCallback?: (widgetData: {
778
+ [widgetId: string]: any;
779
+ }) => void;
780
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
781
+ imagePlaceholder?: React.ReactNode;
782
+ widgetPlaceholder?: React.ReactNode;
783
+ baseElements?: {
784
+ Link: React.ComponentType<any>;
785
+ };
786
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
787
+ trackInteraction?: (args: {
788
+ type: string;
789
+ id: string;
790
+ correct?: boolean;
791
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
792
+ visible: number;
793
+ }>) => void;
794
+ customKeypad?: boolean;
795
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
796
+ isMobile?: boolean;
797
+ isMobileApp?: boolean;
798
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
799
+ hintProgressColor?: string;
800
+ canScrollPage?: boolean;
801
+ editorChangeDelay?: number;
802
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
803
+ }> & {
804
+ baseElements: NonNullable<{
805
+ Link: React.ComponentType<any>;
806
+ } | undefined>;
807
+ canScrollPage: NonNullable<boolean | undefined>;
808
+ editorChangeDelay: NonNullable<number | undefined>;
809
+ groupAnnotator: NonNullable<((groupNumber: number, widgetId: string) => React.ReactNode) | undefined>;
810
+ isArticle: NonNullable<boolean | undefined>;
811
+ isMobile: NonNullable<boolean | undefined>;
812
+ isMobileApp: NonNullable<boolean | undefined>;
813
+ onFocusChange: NonNullable<((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown) | undefined>;
814
+ readOnly: NonNullable<boolean | undefined>;
815
+ setDrawingAreaAvailable: NonNullable<((arg1: boolean) => unknown) | undefined>;
816
+ showAlignmentOptions: NonNullable<boolean | undefined>;
817
+ }>;
818
+ keypadElement?: any;
819
+ questionCompleted?: boolean;
820
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
821
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
822
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
823
+ reviewMode: boolean;
824
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
825
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
826
+ userInput: PerseusGraphType;
827
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
828
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
829
+ }>, prevState: Readonly<any>): any;
562
830
  componentDidUpdate?(prevProps: Readonly<{
563
831
  step: [number, number];
564
832
  gridStep?: [x: number, y: number];
@@ -579,7 +847,74 @@ declare const InteractiveGraph: {
579
847
  lockedFigures: LockedFigure[];
580
848
  fullGraphAriaLabel?: string;
581
849
  fullGraphAriaDescription?: string;
582
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>>, prevState: Readonly<any>, snapshot?: any): void;
850
+ } & {
851
+ trackInteraction: (extraData?: Empty | undefined) => void;
852
+ widgetId: string;
853
+ widgetIndex: number;
854
+ alignment: string | null | undefined;
855
+ static: boolean | null | undefined;
856
+ problemNum: number | null | undefined;
857
+ apiOptions: Readonly<Readonly<{
858
+ isArticle?: boolean;
859
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
860
+ GroupMetadataEditor?: React.ComponentType<any>;
861
+ showAlignmentOptions?: boolean;
862
+ readOnly?: boolean;
863
+ answerableCallback?: (arg1: boolean) => unknown;
864
+ getAnotherHint?: () => unknown;
865
+ interactionCallback?: (widgetData: {
866
+ [widgetId: string]: any;
867
+ }) => void;
868
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
869
+ imagePlaceholder?: React.ReactNode;
870
+ widgetPlaceholder?: React.ReactNode;
871
+ baseElements?: {
872
+ Link: React.ComponentType<any>;
873
+ };
874
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
875
+ trackInteraction?: (args: {
876
+ type: string;
877
+ id: string;
878
+ correct?: boolean;
879
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
880
+ visible: number;
881
+ }>) => void;
882
+ customKeypad?: boolean;
883
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
884
+ isMobile?: boolean;
885
+ isMobileApp?: boolean;
886
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
887
+ hintProgressColor?: string;
888
+ canScrollPage?: boolean;
889
+ editorChangeDelay?: number;
890
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
891
+ }> & {
892
+ baseElements: NonNullable<{
893
+ Link: React.ComponentType<any>;
894
+ } | undefined>;
895
+ canScrollPage: NonNullable<boolean | undefined>;
896
+ editorChangeDelay: NonNullable<number | undefined>;
897
+ groupAnnotator: NonNullable<((groupNumber: number, widgetId: string) => React.ReactNode) | undefined>;
898
+ isArticle: NonNullable<boolean | undefined>;
899
+ isMobile: NonNullable<boolean | undefined>;
900
+ isMobileApp: NonNullable<boolean | undefined>;
901
+ onFocusChange: NonNullable<((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown) | undefined>;
902
+ readOnly: NonNullable<boolean | undefined>;
903
+ setDrawingAreaAvailable: NonNullable<((arg1: boolean) => unknown) | undefined>;
904
+ showAlignmentOptions: NonNullable<boolean | undefined>;
905
+ }>;
906
+ keypadElement?: any;
907
+ questionCompleted?: boolean;
908
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
909
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
910
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
911
+ reviewMode: boolean;
912
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
913
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
914
+ userInput: PerseusGraphType;
915
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
916
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
917
+ }>, prevState: Readonly<any>, snapshot?: any): void;
583
918
  componentWillMount?(): void;
584
919
  UNSAFE_componentWillMount?(): void;
585
920
  componentWillReceiveProps?(nextProps: Readonly<{
@@ -602,52 +937,77 @@ declare const InteractiveGraph: {
602
937
  lockedFigures: LockedFigure[];
603
938
  fullGraphAriaLabel?: string;
604
939
  fullGraphAriaDescription?: string;
605
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>>, nextContext: any): void;
606
- UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{
607
- step: [number, number];
608
- gridStep?: [x: number, y: number];
609
- snapStep?: [x: number, y: number];
610
- backgroundImage?: PerseusImageBackground;
611
- markings: MarkingsType;
612
- labels: string[];
613
- labelLocation: AxisLabelLocation;
614
- showProtractor: boolean;
615
- showRuler?: boolean;
616
- showTooltips?: boolean;
617
- rulerLabel?: string;
618
- rulerTicks?: number;
619
- range: import("@khanacademy/perseus-core").GraphRange;
620
- showAxisArrows: ShowAxisArrows;
621
- graph: PerseusGraphType;
622
- correct?: PerseusGraphType;
623
- lockedFigures: LockedFigure[];
624
- fullGraphAriaLabel?: string;
625
- fullGraphAriaDescription?: string;
626
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>>, nextContext: any): void;
627
- componentWillUpdate?(nextProps: Readonly<{
628
- step: [number, number];
629
- gridStep?: [x: number, y: number];
630
- snapStep?: [x: number, y: number];
631
- backgroundImage?: PerseusImageBackground;
632
- markings: MarkingsType;
633
- labels: string[];
634
- labelLocation: AxisLabelLocation;
635
- showProtractor: boolean;
636
- showRuler?: boolean;
637
- showTooltips?: boolean;
638
- rulerLabel?: string;
639
- rulerTicks?: number;
640
- range: import("@khanacademy/perseus-core").GraphRange;
641
- showAxisArrows: ShowAxisArrows;
642
- graph: PerseusGraphType;
643
- correct?: PerseusGraphType;
644
- lockedFigures: LockedFigure[];
645
- fullGraphAriaLabel?: string;
646
- fullGraphAriaDescription?: string;
647
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>>, nextState: Readonly<any>, nextContext: any): void;
648
- UNSAFE_componentWillUpdate?(nextProps: Readonly<{
649
- step: [number, number];
650
- gridStep?: [x: number, y: number];
940
+ } & {
941
+ trackInteraction: (extraData?: Empty | undefined) => void;
942
+ widgetId: string;
943
+ widgetIndex: number;
944
+ alignment: string | null | undefined;
945
+ static: boolean | null | undefined;
946
+ problemNum: number | null | undefined;
947
+ apiOptions: Readonly<Readonly<{
948
+ isArticle?: boolean;
949
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
950
+ GroupMetadataEditor?: React.ComponentType<any>;
951
+ showAlignmentOptions?: boolean;
952
+ readOnly?: boolean;
953
+ answerableCallback?: (arg1: boolean) => unknown;
954
+ getAnotherHint?: () => unknown;
955
+ interactionCallback?: (widgetData: {
956
+ [widgetId: string]: any;
957
+ }) => void;
958
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
959
+ imagePlaceholder?: React.ReactNode;
960
+ widgetPlaceholder?: React.ReactNode;
961
+ baseElements?: {
962
+ Link: React.ComponentType<any>;
963
+ };
964
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
965
+ trackInteraction?: (args: {
966
+ type: string;
967
+ id: string;
968
+ correct?: boolean;
969
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
970
+ visible: number;
971
+ }>) => void;
972
+ customKeypad?: boolean;
973
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
974
+ isMobile?: boolean;
975
+ isMobileApp?: boolean;
976
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
977
+ hintProgressColor?: string;
978
+ canScrollPage?: boolean;
979
+ editorChangeDelay?: number;
980
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
981
+ }> & {
982
+ baseElements: NonNullable<{
983
+ Link: React.ComponentType<any>;
984
+ } | undefined>;
985
+ canScrollPage: NonNullable<boolean | undefined>;
986
+ editorChangeDelay: NonNullable<number | undefined>;
987
+ groupAnnotator: NonNullable<((groupNumber: number, widgetId: string) => React.ReactNode) | undefined>;
988
+ isArticle: NonNullable<boolean | undefined>;
989
+ isMobile: NonNullable<boolean | undefined>;
990
+ isMobileApp: NonNullable<boolean | undefined>;
991
+ onFocusChange: NonNullable<((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown) | undefined>;
992
+ readOnly: NonNullable<boolean | undefined>;
993
+ setDrawingAreaAvailable: NonNullable<((arg1: boolean) => unknown) | undefined>;
994
+ showAlignmentOptions: NonNullable<boolean | undefined>;
995
+ }>;
996
+ keypadElement?: any;
997
+ questionCompleted?: boolean;
998
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
999
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
1000
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
1001
+ reviewMode: boolean;
1002
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
1003
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
1004
+ userInput: PerseusGraphType;
1005
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
1006
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
1007
+ }>, nextContext: any): void;
1008
+ UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{
1009
+ step: [number, number];
1010
+ gridStep?: [x: number, y: number];
651
1011
  snapStep?: [x: number, y: number];
652
1012
  backgroundImage?: PerseusImageBackground;
653
1013
  markings: MarkingsType;
@@ -665,7 +1025,250 @@ declare const InteractiveGraph: {
665
1025
  lockedFigures: LockedFigure[];
666
1026
  fullGraphAriaLabel?: string;
667
1027
  fullGraphAriaDescription?: string;
668
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>>, nextState: Readonly<any>, nextContext: any): void;
1028
+ } & {
1029
+ trackInteraction: (extraData?: Empty | undefined) => void;
1030
+ widgetId: string;
1031
+ widgetIndex: number;
1032
+ alignment: string | null | undefined;
1033
+ static: boolean | null | undefined;
1034
+ problemNum: number | null | undefined;
1035
+ apiOptions: Readonly<Readonly<{
1036
+ isArticle?: boolean;
1037
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
1038
+ GroupMetadataEditor?: React.ComponentType<any>;
1039
+ showAlignmentOptions?: boolean;
1040
+ readOnly?: boolean;
1041
+ answerableCallback?: (arg1: boolean) => unknown;
1042
+ getAnotherHint?: () => unknown;
1043
+ interactionCallback?: (widgetData: {
1044
+ [widgetId: string]: any;
1045
+ }) => void;
1046
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
1047
+ imagePlaceholder?: React.ReactNode;
1048
+ widgetPlaceholder?: React.ReactNode;
1049
+ baseElements?: {
1050
+ Link: React.ComponentType<any>;
1051
+ };
1052
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
1053
+ trackInteraction?: (args: {
1054
+ type: string;
1055
+ id: string;
1056
+ correct?: boolean;
1057
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
1058
+ visible: number;
1059
+ }>) => void;
1060
+ customKeypad?: boolean;
1061
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
1062
+ isMobile?: boolean;
1063
+ isMobileApp?: boolean;
1064
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
1065
+ hintProgressColor?: string;
1066
+ canScrollPage?: boolean;
1067
+ editorChangeDelay?: number;
1068
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
1069
+ }> & {
1070
+ baseElements: NonNullable<{
1071
+ Link: React.ComponentType<any>;
1072
+ } | undefined>;
1073
+ canScrollPage: NonNullable<boolean | undefined>;
1074
+ editorChangeDelay: NonNullable<number | undefined>;
1075
+ groupAnnotator: NonNullable<((groupNumber: number, widgetId: string) => React.ReactNode) | undefined>;
1076
+ isArticle: NonNullable<boolean | undefined>;
1077
+ isMobile: NonNullable<boolean | undefined>;
1078
+ isMobileApp: NonNullable<boolean | undefined>;
1079
+ onFocusChange: NonNullable<((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown) | undefined>;
1080
+ readOnly: NonNullable<boolean | undefined>;
1081
+ setDrawingAreaAvailable: NonNullable<((arg1: boolean) => unknown) | undefined>;
1082
+ showAlignmentOptions: NonNullable<boolean | undefined>;
1083
+ }>;
1084
+ keypadElement?: any;
1085
+ questionCompleted?: boolean;
1086
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
1087
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
1088
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
1089
+ reviewMode: boolean;
1090
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
1091
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
1092
+ userInput: PerseusGraphType;
1093
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
1094
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
1095
+ }>, nextContext: any): void;
1096
+ componentWillUpdate?(nextProps: Readonly<{
1097
+ step: [number, number];
1098
+ gridStep?: [x: number, y: number];
1099
+ snapStep?: [x: number, y: number];
1100
+ backgroundImage?: PerseusImageBackground;
1101
+ markings: MarkingsType;
1102
+ labels: string[];
1103
+ labelLocation: AxisLabelLocation;
1104
+ showProtractor: boolean;
1105
+ showRuler?: boolean;
1106
+ showTooltips?: boolean;
1107
+ rulerLabel?: string;
1108
+ rulerTicks?: number;
1109
+ range: import("@khanacademy/perseus-core").GraphRange;
1110
+ showAxisArrows: ShowAxisArrows;
1111
+ graph: PerseusGraphType;
1112
+ correct?: PerseusGraphType;
1113
+ lockedFigures: LockedFigure[];
1114
+ fullGraphAriaLabel?: string;
1115
+ fullGraphAriaDescription?: string;
1116
+ } & {
1117
+ trackInteraction: (extraData?: Empty | undefined) => void;
1118
+ widgetId: string;
1119
+ widgetIndex: number;
1120
+ alignment: string | null | undefined;
1121
+ static: boolean | null | undefined;
1122
+ problemNum: number | null | undefined;
1123
+ apiOptions: Readonly<Readonly<{
1124
+ isArticle?: boolean;
1125
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
1126
+ GroupMetadataEditor?: React.ComponentType<any>;
1127
+ showAlignmentOptions?: boolean;
1128
+ readOnly?: boolean;
1129
+ answerableCallback?: (arg1: boolean) => unknown;
1130
+ getAnotherHint?: () => unknown;
1131
+ interactionCallback?: (widgetData: {
1132
+ [widgetId: string]: any;
1133
+ }) => void;
1134
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
1135
+ imagePlaceholder?: React.ReactNode;
1136
+ widgetPlaceholder?: React.ReactNode;
1137
+ baseElements?: {
1138
+ Link: React.ComponentType<any>;
1139
+ };
1140
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
1141
+ trackInteraction?: (args: {
1142
+ type: string;
1143
+ id: string;
1144
+ correct?: boolean;
1145
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
1146
+ visible: number;
1147
+ }>) => void;
1148
+ customKeypad?: boolean;
1149
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
1150
+ isMobile?: boolean;
1151
+ isMobileApp?: boolean;
1152
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
1153
+ hintProgressColor?: string;
1154
+ canScrollPage?: boolean;
1155
+ editorChangeDelay?: number;
1156
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
1157
+ }> & {
1158
+ baseElements: NonNullable<{
1159
+ Link: React.ComponentType<any>;
1160
+ } | undefined>;
1161
+ canScrollPage: NonNullable<boolean | undefined>;
1162
+ editorChangeDelay: NonNullable<number | undefined>;
1163
+ groupAnnotator: NonNullable<((groupNumber: number, widgetId: string) => React.ReactNode) | undefined>;
1164
+ isArticle: NonNullable<boolean | undefined>;
1165
+ isMobile: NonNullable<boolean | undefined>;
1166
+ isMobileApp: NonNullable<boolean | undefined>;
1167
+ onFocusChange: NonNullable<((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown) | undefined>;
1168
+ readOnly: NonNullable<boolean | undefined>;
1169
+ setDrawingAreaAvailable: NonNullable<((arg1: boolean) => unknown) | undefined>;
1170
+ showAlignmentOptions: NonNullable<boolean | undefined>;
1171
+ }>;
1172
+ keypadElement?: any;
1173
+ questionCompleted?: boolean;
1174
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
1175
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
1176
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
1177
+ reviewMode: boolean;
1178
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
1179
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
1180
+ userInput: PerseusGraphType;
1181
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
1182
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
1183
+ }>, nextState: Readonly<any>, nextContext: any): void;
1184
+ UNSAFE_componentWillUpdate?(nextProps: Readonly<{
1185
+ step: [number, number];
1186
+ gridStep?: [x: number, y: number];
1187
+ snapStep?: [x: number, y: number];
1188
+ backgroundImage?: PerseusImageBackground;
1189
+ markings: MarkingsType;
1190
+ labels: string[];
1191
+ labelLocation: AxisLabelLocation;
1192
+ showProtractor: boolean;
1193
+ showRuler?: boolean;
1194
+ showTooltips?: boolean;
1195
+ rulerLabel?: string;
1196
+ rulerTicks?: number;
1197
+ range: import("@khanacademy/perseus-core").GraphRange;
1198
+ showAxisArrows: ShowAxisArrows;
1199
+ graph: PerseusGraphType;
1200
+ correct?: PerseusGraphType;
1201
+ lockedFigures: LockedFigure[];
1202
+ fullGraphAriaLabel?: string;
1203
+ fullGraphAriaDescription?: string;
1204
+ } & {
1205
+ trackInteraction: (extraData?: Empty | undefined) => void;
1206
+ widgetId: string;
1207
+ widgetIndex: number;
1208
+ alignment: string | null | undefined;
1209
+ static: boolean | null | undefined;
1210
+ problemNum: number | null | undefined;
1211
+ apiOptions: Readonly<Readonly<{
1212
+ isArticle?: boolean;
1213
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
1214
+ GroupMetadataEditor?: React.ComponentType<any>;
1215
+ showAlignmentOptions?: boolean;
1216
+ readOnly?: boolean;
1217
+ answerableCallback?: (arg1: boolean) => unknown;
1218
+ getAnotherHint?: () => unknown;
1219
+ interactionCallback?: (widgetData: {
1220
+ [widgetId: string]: any;
1221
+ }) => void;
1222
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
1223
+ imagePlaceholder?: React.ReactNode;
1224
+ widgetPlaceholder?: React.ReactNode;
1225
+ baseElements?: {
1226
+ Link: React.ComponentType<any>;
1227
+ };
1228
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
1229
+ trackInteraction?: (args: {
1230
+ type: string;
1231
+ id: string;
1232
+ correct?: boolean;
1233
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
1234
+ visible: number;
1235
+ }>) => void;
1236
+ customKeypad?: boolean;
1237
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
1238
+ isMobile?: boolean;
1239
+ isMobileApp?: boolean;
1240
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
1241
+ hintProgressColor?: string;
1242
+ canScrollPage?: boolean;
1243
+ editorChangeDelay?: number;
1244
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
1245
+ }> & {
1246
+ baseElements: NonNullable<{
1247
+ Link: React.ComponentType<any>;
1248
+ } | undefined>;
1249
+ canScrollPage: NonNullable<boolean | undefined>;
1250
+ editorChangeDelay: NonNullable<number | undefined>;
1251
+ groupAnnotator: NonNullable<((groupNumber: number, widgetId: string) => React.ReactNode) | undefined>;
1252
+ isArticle: NonNullable<boolean | undefined>;
1253
+ isMobile: NonNullable<boolean | undefined>;
1254
+ isMobileApp: NonNullable<boolean | undefined>;
1255
+ onFocusChange: NonNullable<((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown) | undefined>;
1256
+ readOnly: NonNullable<boolean | undefined>;
1257
+ setDrawingAreaAvailable: NonNullable<((arg1: boolean) => unknown) | undefined>;
1258
+ showAlignmentOptions: NonNullable<boolean | undefined>;
1259
+ }>;
1260
+ keypadElement?: any;
1261
+ questionCompleted?: boolean;
1262
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
1263
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
1264
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
1265
+ reviewMode: boolean;
1266
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
1267
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
1268
+ userInput: PerseusGraphType;
1269
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
1270
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
1271
+ }>, nextState: Readonly<any>, nextContext: any): void;
669
1272
  };
670
1273
  new (props: {
671
1274
  step: [number, number];
@@ -687,7 +1290,74 @@ declare const InteractiveGraph: {
687
1290
  lockedFigures: LockedFigure[];
688
1291
  fullGraphAriaLabel?: string;
689
1292
  fullGraphAriaDescription?: string;
690
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>, context: any): {
1293
+ } & {
1294
+ trackInteraction: (extraData?: Empty | undefined) => void;
1295
+ widgetId: string;
1296
+ widgetIndex: number;
1297
+ alignment: string | null | undefined;
1298
+ static: boolean | null | undefined;
1299
+ problemNum: number | null | undefined;
1300
+ apiOptions: Readonly<Readonly<{
1301
+ isArticle?: boolean;
1302
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
1303
+ GroupMetadataEditor?: React.ComponentType<any>;
1304
+ showAlignmentOptions?: boolean;
1305
+ readOnly?: boolean;
1306
+ answerableCallback?: (arg1: boolean) => unknown;
1307
+ getAnotherHint?: () => unknown;
1308
+ interactionCallback?: (widgetData: {
1309
+ [widgetId: string]: any;
1310
+ }) => void;
1311
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
1312
+ imagePlaceholder?: React.ReactNode;
1313
+ widgetPlaceholder?: React.ReactNode;
1314
+ baseElements?: {
1315
+ Link: React.ComponentType<any>;
1316
+ };
1317
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
1318
+ trackInteraction?: (args: {
1319
+ type: string;
1320
+ id: string;
1321
+ correct?: boolean;
1322
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
1323
+ visible: number;
1324
+ }>) => void;
1325
+ customKeypad?: boolean;
1326
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
1327
+ isMobile?: boolean;
1328
+ isMobileApp?: boolean;
1329
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
1330
+ hintProgressColor?: string;
1331
+ canScrollPage?: boolean;
1332
+ editorChangeDelay?: number;
1333
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
1334
+ }> & {
1335
+ baseElements: NonNullable<{
1336
+ Link: React.ComponentType<any>;
1337
+ } | undefined>;
1338
+ canScrollPage: NonNullable<boolean | undefined>;
1339
+ editorChangeDelay: NonNullable<number | undefined>;
1340
+ groupAnnotator: NonNullable<((groupNumber: number, widgetId: string) => React.ReactNode) | undefined>;
1341
+ isArticle: NonNullable<boolean | undefined>;
1342
+ isMobile: NonNullable<boolean | undefined>;
1343
+ isMobileApp: NonNullable<boolean | undefined>;
1344
+ onFocusChange: NonNullable<((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown) | undefined>;
1345
+ readOnly: NonNullable<boolean | undefined>;
1346
+ setDrawingAreaAvailable: NonNullable<((arg1: boolean) => unknown) | undefined>;
1347
+ showAlignmentOptions: NonNullable<boolean | undefined>;
1348
+ }>;
1349
+ keypadElement?: any;
1350
+ questionCompleted?: boolean;
1351
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
1352
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
1353
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
1354
+ reviewMode: boolean;
1355
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
1356
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
1357
+ userInput: PerseusGraphType;
1358
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
1359
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
1360
+ }, context: any): {
691
1361
  mafsRef: React.RefObject<import("../../../../perseus/src/widgets/interactive-graphs/stateful-mafs-graph").StatefulMafsGraphType>;
692
1362
  getUserInput(): import("@khanacademy/perseus-core").PerseusInteractiveGraphUserInput;
693
1363
  getPromptJSON(): import("../../../../perseus/src/widget-ai-utils/interactive-graph/interactive-graph-ai-utils").InteractiveGraphPromptJSON | import("../../../../perseus/src/widget-ai-utils/unsupported-widget").UnsupportedWidgetPromptJSON;
@@ -1173,7 +1843,74 @@ declare const InteractiveGraph: {
1173
1843
  lockedFigures: LockedFigure[];
1174
1844
  fullGraphAriaLabel?: string;
1175
1845
  fullGraphAriaDescription?: string;
1176
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>>;
1846
+ } & {
1847
+ trackInteraction: (extraData?: Empty | undefined) => void;
1848
+ widgetId: string;
1849
+ widgetIndex: number;
1850
+ alignment: string | null | undefined;
1851
+ static: boolean | null | undefined;
1852
+ problemNum: number | null | undefined;
1853
+ apiOptions: Readonly<Readonly<{
1854
+ isArticle?: boolean;
1855
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
1856
+ GroupMetadataEditor?: React.ComponentType<any>;
1857
+ showAlignmentOptions?: boolean;
1858
+ readOnly?: boolean;
1859
+ answerableCallback?: (arg1: boolean) => unknown;
1860
+ getAnotherHint?: () => unknown;
1861
+ interactionCallback?: (widgetData: {
1862
+ [widgetId: string]: any;
1863
+ }) => void;
1864
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
1865
+ imagePlaceholder?: React.ReactNode;
1866
+ widgetPlaceholder?: React.ReactNode;
1867
+ baseElements?: {
1868
+ Link: React.ComponentType<any>;
1869
+ };
1870
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
1871
+ trackInteraction?: (args: {
1872
+ type: string;
1873
+ id: string;
1874
+ correct?: boolean;
1875
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
1876
+ visible: number;
1877
+ }>) => void;
1878
+ customKeypad?: boolean;
1879
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
1880
+ isMobile?: boolean;
1881
+ isMobileApp?: boolean;
1882
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
1883
+ hintProgressColor?: string;
1884
+ canScrollPage?: boolean;
1885
+ editorChangeDelay?: number;
1886
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
1887
+ }> & {
1888
+ baseElements: NonNullable<{
1889
+ Link: React.ComponentType<any>;
1890
+ } | undefined>;
1891
+ canScrollPage: NonNullable<boolean | undefined>;
1892
+ editorChangeDelay: NonNullable<number | undefined>;
1893
+ groupAnnotator: NonNullable<((groupNumber: number, widgetId: string) => React.ReactNode) | undefined>;
1894
+ isArticle: NonNullable<boolean | undefined>;
1895
+ isMobile: NonNullable<boolean | undefined>;
1896
+ isMobileApp: NonNullable<boolean | undefined>;
1897
+ onFocusChange: NonNullable<((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown) | undefined>;
1898
+ readOnly: NonNullable<boolean | undefined>;
1899
+ setDrawingAreaAvailable: NonNullable<((arg1: boolean) => unknown) | undefined>;
1900
+ showAlignmentOptions: NonNullable<boolean | undefined>;
1901
+ }>;
1902
+ keypadElement?: any;
1903
+ questionCompleted?: boolean;
1904
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
1905
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
1906
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
1907
+ reviewMode: boolean;
1908
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
1909
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
1910
+ userInput: PerseusGraphType;
1911
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
1912
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
1913
+ }>;
1177
1914
  state: Readonly<any>;
1178
1915
  refs: {
1179
1916
  [key: string]: React.ReactInstance;
@@ -1199,7 +1936,74 @@ declare const InteractiveGraph: {
1199
1936
  lockedFigures: LockedFigure[];
1200
1937
  fullGraphAriaLabel?: string;
1201
1938
  fullGraphAriaDescription?: string;
1202
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>>, nextState: Readonly<any>, nextContext: any): boolean;
1939
+ } & {
1940
+ trackInteraction: (extraData?: Empty | undefined) => void;
1941
+ widgetId: string;
1942
+ widgetIndex: number;
1943
+ alignment: string | null | undefined;
1944
+ static: boolean | null | undefined;
1945
+ problemNum: number | null | undefined;
1946
+ apiOptions: Readonly<Readonly<{
1947
+ isArticle?: boolean;
1948
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
1949
+ GroupMetadataEditor?: React.ComponentType<any>;
1950
+ showAlignmentOptions?: boolean;
1951
+ readOnly?: boolean;
1952
+ answerableCallback?: (arg1: boolean) => unknown;
1953
+ getAnotherHint?: () => unknown;
1954
+ interactionCallback?: (widgetData: {
1955
+ [widgetId: string]: any;
1956
+ }) => void;
1957
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
1958
+ imagePlaceholder?: React.ReactNode;
1959
+ widgetPlaceholder?: React.ReactNode;
1960
+ baseElements?: {
1961
+ Link: React.ComponentType<any>;
1962
+ };
1963
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
1964
+ trackInteraction?: (args: {
1965
+ type: string;
1966
+ id: string;
1967
+ correct?: boolean;
1968
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
1969
+ visible: number;
1970
+ }>) => void;
1971
+ customKeypad?: boolean;
1972
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
1973
+ isMobile?: boolean;
1974
+ isMobileApp?: boolean;
1975
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
1976
+ hintProgressColor?: string;
1977
+ canScrollPage?: boolean;
1978
+ editorChangeDelay?: number;
1979
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
1980
+ }> & {
1981
+ baseElements: NonNullable<{
1982
+ Link: React.ComponentType<any>;
1983
+ } | undefined>;
1984
+ canScrollPage: NonNullable<boolean | undefined>;
1985
+ editorChangeDelay: NonNullable<number | undefined>;
1986
+ groupAnnotator: NonNullable<((groupNumber: number, widgetId: string) => React.ReactNode) | undefined>;
1987
+ isArticle: NonNullable<boolean | undefined>;
1988
+ isMobile: NonNullable<boolean | undefined>;
1989
+ isMobileApp: NonNullable<boolean | undefined>;
1990
+ onFocusChange: NonNullable<((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown) | undefined>;
1991
+ readOnly: NonNullable<boolean | undefined>;
1992
+ setDrawingAreaAvailable: NonNullable<((arg1: boolean) => unknown) | undefined>;
1993
+ showAlignmentOptions: NonNullable<boolean | undefined>;
1994
+ }>;
1995
+ keypadElement?: any;
1996
+ questionCompleted?: boolean;
1997
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
1998
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
1999
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
2000
+ reviewMode: boolean;
2001
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
2002
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
2003
+ userInput: PerseusGraphType;
2004
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
2005
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
2006
+ }>, nextState: Readonly<any>, nextContext: any): boolean;
1203
2007
  componentWillUnmount?(): void;
1204
2008
  componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
1205
2009
  getSnapshotBeforeUpdate?(prevProps: Readonly<{
@@ -1222,7 +2026,74 @@ declare const InteractiveGraph: {
1222
2026
  lockedFigures: LockedFigure[];
1223
2027
  fullGraphAriaLabel?: string;
1224
2028
  fullGraphAriaDescription?: string;
1225
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>>, prevState: Readonly<any>): any;
2029
+ } & {
2030
+ trackInteraction: (extraData?: Empty | undefined) => void;
2031
+ widgetId: string;
2032
+ widgetIndex: number;
2033
+ alignment: string | null | undefined;
2034
+ static: boolean | null | undefined;
2035
+ problemNum: number | null | undefined;
2036
+ apiOptions: Readonly<Readonly<{
2037
+ isArticle?: boolean;
2038
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
2039
+ GroupMetadataEditor?: React.ComponentType<any>;
2040
+ showAlignmentOptions?: boolean;
2041
+ readOnly?: boolean;
2042
+ answerableCallback?: (arg1: boolean) => unknown;
2043
+ getAnotherHint?: () => unknown;
2044
+ interactionCallback?: (widgetData: {
2045
+ [widgetId: string]: any;
2046
+ }) => void;
2047
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
2048
+ imagePlaceholder?: React.ReactNode;
2049
+ widgetPlaceholder?: React.ReactNode;
2050
+ baseElements?: {
2051
+ Link: React.ComponentType<any>;
2052
+ };
2053
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
2054
+ trackInteraction?: (args: {
2055
+ type: string;
2056
+ id: string;
2057
+ correct?: boolean;
2058
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
2059
+ visible: number;
2060
+ }>) => void;
2061
+ customKeypad?: boolean;
2062
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
2063
+ isMobile?: boolean;
2064
+ isMobileApp?: boolean;
2065
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
2066
+ hintProgressColor?: string;
2067
+ canScrollPage?: boolean;
2068
+ editorChangeDelay?: number;
2069
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
2070
+ }> & {
2071
+ baseElements: NonNullable<{
2072
+ Link: React.ComponentType<any>;
2073
+ } | undefined>;
2074
+ canScrollPage: NonNullable<boolean | undefined>;
2075
+ editorChangeDelay: NonNullable<number | undefined>;
2076
+ groupAnnotator: NonNullable<((groupNumber: number, widgetId: string) => React.ReactNode) | undefined>;
2077
+ isArticle: NonNullable<boolean | undefined>;
2078
+ isMobile: NonNullable<boolean | undefined>;
2079
+ isMobileApp: NonNullable<boolean | undefined>;
2080
+ onFocusChange: NonNullable<((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown) | undefined>;
2081
+ readOnly: NonNullable<boolean | undefined>;
2082
+ setDrawingAreaAvailable: NonNullable<((arg1: boolean) => unknown) | undefined>;
2083
+ showAlignmentOptions: NonNullable<boolean | undefined>;
2084
+ }>;
2085
+ keypadElement?: any;
2086
+ questionCompleted?: boolean;
2087
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2088
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2089
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
2090
+ reviewMode: boolean;
2091
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
2092
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
2093
+ userInput: PerseusGraphType;
2094
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
2095
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
2096
+ }>, prevState: Readonly<any>): any;
1226
2097
  componentDidUpdate?(prevProps: Readonly<{
1227
2098
  step: [number, number];
1228
2099
  gridStep?: [x: number, y: number];
@@ -1243,7 +2114,74 @@ declare const InteractiveGraph: {
1243
2114
  lockedFigures: LockedFigure[];
1244
2115
  fullGraphAriaLabel?: string;
1245
2116
  fullGraphAriaDescription?: string;
1246
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>>, prevState: Readonly<any>, snapshot?: any): void;
2117
+ } & {
2118
+ trackInteraction: (extraData?: Empty | undefined) => void;
2119
+ widgetId: string;
2120
+ widgetIndex: number;
2121
+ alignment: string | null | undefined;
2122
+ static: boolean | null | undefined;
2123
+ problemNum: number | null | undefined;
2124
+ apiOptions: Readonly<Readonly<{
2125
+ isArticle?: boolean;
2126
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
2127
+ GroupMetadataEditor?: React.ComponentType<any>;
2128
+ showAlignmentOptions?: boolean;
2129
+ readOnly?: boolean;
2130
+ answerableCallback?: (arg1: boolean) => unknown;
2131
+ getAnotherHint?: () => unknown;
2132
+ interactionCallback?: (widgetData: {
2133
+ [widgetId: string]: any;
2134
+ }) => void;
2135
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
2136
+ imagePlaceholder?: React.ReactNode;
2137
+ widgetPlaceholder?: React.ReactNode;
2138
+ baseElements?: {
2139
+ Link: React.ComponentType<any>;
2140
+ };
2141
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
2142
+ trackInteraction?: (args: {
2143
+ type: string;
2144
+ id: string;
2145
+ correct?: boolean;
2146
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
2147
+ visible: number;
2148
+ }>) => void;
2149
+ customKeypad?: boolean;
2150
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
2151
+ isMobile?: boolean;
2152
+ isMobileApp?: boolean;
2153
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
2154
+ hintProgressColor?: string;
2155
+ canScrollPage?: boolean;
2156
+ editorChangeDelay?: number;
2157
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
2158
+ }> & {
2159
+ baseElements: NonNullable<{
2160
+ Link: React.ComponentType<any>;
2161
+ } | undefined>;
2162
+ canScrollPage: NonNullable<boolean | undefined>;
2163
+ editorChangeDelay: NonNullable<number | undefined>;
2164
+ groupAnnotator: NonNullable<((groupNumber: number, widgetId: string) => React.ReactNode) | undefined>;
2165
+ isArticle: NonNullable<boolean | undefined>;
2166
+ isMobile: NonNullable<boolean | undefined>;
2167
+ isMobileApp: NonNullable<boolean | undefined>;
2168
+ onFocusChange: NonNullable<((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown) | undefined>;
2169
+ readOnly: NonNullable<boolean | undefined>;
2170
+ setDrawingAreaAvailable: NonNullable<((arg1: boolean) => unknown) | undefined>;
2171
+ showAlignmentOptions: NonNullable<boolean | undefined>;
2172
+ }>;
2173
+ keypadElement?: any;
2174
+ questionCompleted?: boolean;
2175
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2176
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2177
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
2178
+ reviewMode: boolean;
2179
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
2180
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
2181
+ userInput: PerseusGraphType;
2182
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
2183
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
2184
+ }>, prevState: Readonly<any>, snapshot?: any): void;
1247
2185
  componentWillMount?(): void;
1248
2186
  UNSAFE_componentWillMount?(): void;
1249
2187
  componentWillReceiveProps?(nextProps: Readonly<{
@@ -1266,7 +2204,74 @@ declare const InteractiveGraph: {
1266
2204
  lockedFigures: LockedFigure[];
1267
2205
  fullGraphAriaLabel?: string;
1268
2206
  fullGraphAriaDescription?: string;
1269
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>>, nextContext: any): void;
2207
+ } & {
2208
+ trackInteraction: (extraData?: Empty | undefined) => void;
2209
+ widgetId: string;
2210
+ widgetIndex: number;
2211
+ alignment: string | null | undefined;
2212
+ static: boolean | null | undefined;
2213
+ problemNum: number | null | undefined;
2214
+ apiOptions: Readonly<Readonly<{
2215
+ isArticle?: boolean;
2216
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
2217
+ GroupMetadataEditor?: React.ComponentType<any>;
2218
+ showAlignmentOptions?: boolean;
2219
+ readOnly?: boolean;
2220
+ answerableCallback?: (arg1: boolean) => unknown;
2221
+ getAnotherHint?: () => unknown;
2222
+ interactionCallback?: (widgetData: {
2223
+ [widgetId: string]: any;
2224
+ }) => void;
2225
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
2226
+ imagePlaceholder?: React.ReactNode;
2227
+ widgetPlaceholder?: React.ReactNode;
2228
+ baseElements?: {
2229
+ Link: React.ComponentType<any>;
2230
+ };
2231
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
2232
+ trackInteraction?: (args: {
2233
+ type: string;
2234
+ id: string;
2235
+ correct?: boolean;
2236
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
2237
+ visible: number;
2238
+ }>) => void;
2239
+ customKeypad?: boolean;
2240
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
2241
+ isMobile?: boolean;
2242
+ isMobileApp?: boolean;
2243
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
2244
+ hintProgressColor?: string;
2245
+ canScrollPage?: boolean;
2246
+ editorChangeDelay?: number;
2247
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
2248
+ }> & {
2249
+ baseElements: NonNullable<{
2250
+ Link: React.ComponentType<any>;
2251
+ } | undefined>;
2252
+ canScrollPage: NonNullable<boolean | undefined>;
2253
+ editorChangeDelay: NonNullable<number | undefined>;
2254
+ groupAnnotator: NonNullable<((groupNumber: number, widgetId: string) => React.ReactNode) | undefined>;
2255
+ isArticle: NonNullable<boolean | undefined>;
2256
+ isMobile: NonNullable<boolean | undefined>;
2257
+ isMobileApp: NonNullable<boolean | undefined>;
2258
+ onFocusChange: NonNullable<((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown) | undefined>;
2259
+ readOnly: NonNullable<boolean | undefined>;
2260
+ setDrawingAreaAvailable: NonNullable<((arg1: boolean) => unknown) | undefined>;
2261
+ showAlignmentOptions: NonNullable<boolean | undefined>;
2262
+ }>;
2263
+ keypadElement?: any;
2264
+ questionCompleted?: boolean;
2265
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2266
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2267
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
2268
+ reviewMode: boolean;
2269
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
2270
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
2271
+ userInput: PerseusGraphType;
2272
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
2273
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
2274
+ }>, nextContext: any): void;
1270
2275
  UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{
1271
2276
  step: [number, number];
1272
2277
  gridStep?: [x: number, y: number];
@@ -1287,7 +2292,74 @@ declare const InteractiveGraph: {
1287
2292
  lockedFigures: LockedFigure[];
1288
2293
  fullGraphAriaLabel?: string;
1289
2294
  fullGraphAriaDescription?: string;
1290
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>>, nextContext: any): void;
2295
+ } & {
2296
+ trackInteraction: (extraData?: Empty | undefined) => void;
2297
+ widgetId: string;
2298
+ widgetIndex: number;
2299
+ alignment: string | null | undefined;
2300
+ static: boolean | null | undefined;
2301
+ problemNum: number | null | undefined;
2302
+ apiOptions: Readonly<Readonly<{
2303
+ isArticle?: boolean;
2304
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
2305
+ GroupMetadataEditor?: React.ComponentType<any>;
2306
+ showAlignmentOptions?: boolean;
2307
+ readOnly?: boolean;
2308
+ answerableCallback?: (arg1: boolean) => unknown;
2309
+ getAnotherHint?: () => unknown;
2310
+ interactionCallback?: (widgetData: {
2311
+ [widgetId: string]: any;
2312
+ }) => void;
2313
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
2314
+ imagePlaceholder?: React.ReactNode;
2315
+ widgetPlaceholder?: React.ReactNode;
2316
+ baseElements?: {
2317
+ Link: React.ComponentType<any>;
2318
+ };
2319
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
2320
+ trackInteraction?: (args: {
2321
+ type: string;
2322
+ id: string;
2323
+ correct?: boolean;
2324
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
2325
+ visible: number;
2326
+ }>) => void;
2327
+ customKeypad?: boolean;
2328
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
2329
+ isMobile?: boolean;
2330
+ isMobileApp?: boolean;
2331
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
2332
+ hintProgressColor?: string;
2333
+ canScrollPage?: boolean;
2334
+ editorChangeDelay?: number;
2335
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
2336
+ }> & {
2337
+ baseElements: NonNullable<{
2338
+ Link: React.ComponentType<any>;
2339
+ } | undefined>;
2340
+ canScrollPage: NonNullable<boolean | undefined>;
2341
+ editorChangeDelay: NonNullable<number | undefined>;
2342
+ groupAnnotator: NonNullable<((groupNumber: number, widgetId: string) => React.ReactNode) | undefined>;
2343
+ isArticle: NonNullable<boolean | undefined>;
2344
+ isMobile: NonNullable<boolean | undefined>;
2345
+ isMobileApp: NonNullable<boolean | undefined>;
2346
+ onFocusChange: NonNullable<((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown) | undefined>;
2347
+ readOnly: NonNullable<boolean | undefined>;
2348
+ setDrawingAreaAvailable: NonNullable<((arg1: boolean) => unknown) | undefined>;
2349
+ showAlignmentOptions: NonNullable<boolean | undefined>;
2350
+ }>;
2351
+ keypadElement?: any;
2352
+ questionCompleted?: boolean;
2353
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2354
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2355
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
2356
+ reviewMode: boolean;
2357
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
2358
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
2359
+ userInput: PerseusGraphType;
2360
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
2361
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
2362
+ }>, nextContext: any): void;
1291
2363
  componentWillUpdate?(nextProps: Readonly<{
1292
2364
  step: [number, number];
1293
2365
  gridStep?: [x: number, y: number];
@@ -1308,7 +2380,74 @@ declare const InteractiveGraph: {
1308
2380
  lockedFigures: LockedFigure[];
1309
2381
  fullGraphAriaLabel?: string;
1310
2382
  fullGraphAriaDescription?: string;
1311
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>>, nextState: Readonly<any>, nextContext: any): void;
2383
+ } & {
2384
+ trackInteraction: (extraData?: Empty | undefined) => void;
2385
+ widgetId: string;
2386
+ widgetIndex: number;
2387
+ alignment: string | null | undefined;
2388
+ static: boolean | null | undefined;
2389
+ problemNum: number | null | undefined;
2390
+ apiOptions: Readonly<Readonly<{
2391
+ isArticle?: boolean;
2392
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
2393
+ GroupMetadataEditor?: React.ComponentType<any>;
2394
+ showAlignmentOptions?: boolean;
2395
+ readOnly?: boolean;
2396
+ answerableCallback?: (arg1: boolean) => unknown;
2397
+ getAnotherHint?: () => unknown;
2398
+ interactionCallback?: (widgetData: {
2399
+ [widgetId: string]: any;
2400
+ }) => void;
2401
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
2402
+ imagePlaceholder?: React.ReactNode;
2403
+ widgetPlaceholder?: React.ReactNode;
2404
+ baseElements?: {
2405
+ Link: React.ComponentType<any>;
2406
+ };
2407
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
2408
+ trackInteraction?: (args: {
2409
+ type: string;
2410
+ id: string;
2411
+ correct?: boolean;
2412
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
2413
+ visible: number;
2414
+ }>) => void;
2415
+ customKeypad?: boolean;
2416
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
2417
+ isMobile?: boolean;
2418
+ isMobileApp?: boolean;
2419
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
2420
+ hintProgressColor?: string;
2421
+ canScrollPage?: boolean;
2422
+ editorChangeDelay?: number;
2423
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
2424
+ }> & {
2425
+ baseElements: NonNullable<{
2426
+ Link: React.ComponentType<any>;
2427
+ } | undefined>;
2428
+ canScrollPage: NonNullable<boolean | undefined>;
2429
+ editorChangeDelay: NonNullable<number | undefined>;
2430
+ groupAnnotator: NonNullable<((groupNumber: number, widgetId: string) => React.ReactNode) | undefined>;
2431
+ isArticle: NonNullable<boolean | undefined>;
2432
+ isMobile: NonNullable<boolean | undefined>;
2433
+ isMobileApp: NonNullable<boolean | undefined>;
2434
+ onFocusChange: NonNullable<((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown) | undefined>;
2435
+ readOnly: NonNullable<boolean | undefined>;
2436
+ setDrawingAreaAvailable: NonNullable<((arg1: boolean) => unknown) | undefined>;
2437
+ showAlignmentOptions: NonNullable<boolean | undefined>;
2438
+ }>;
2439
+ keypadElement?: any;
2440
+ questionCompleted?: boolean;
2441
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2442
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2443
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
2444
+ reviewMode: boolean;
2445
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
2446
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
2447
+ userInput: PerseusGraphType;
2448
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
2449
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
2450
+ }>, nextState: Readonly<any>, nextContext: any): void;
1312
2451
  UNSAFE_componentWillUpdate?(nextProps: Readonly<{
1313
2452
  step: [number, number];
1314
2453
  gridStep?: [x: number, y: number];
@@ -1329,7 +2468,74 @@ declare const InteractiveGraph: {
1329
2468
  lockedFigures: LockedFigure[];
1330
2469
  fullGraphAriaLabel?: string;
1331
2470
  fullGraphAriaDescription?: string;
1332
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>>, nextState: Readonly<any>, nextContext: any): void;
2471
+ } & {
2472
+ trackInteraction: (extraData?: Empty | undefined) => void;
2473
+ widgetId: string;
2474
+ widgetIndex: number;
2475
+ alignment: string | null | undefined;
2476
+ static: boolean | null | undefined;
2477
+ problemNum: number | null | undefined;
2478
+ apiOptions: Readonly<Readonly<{
2479
+ isArticle?: boolean;
2480
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
2481
+ GroupMetadataEditor?: React.ComponentType<any>;
2482
+ showAlignmentOptions?: boolean;
2483
+ readOnly?: boolean;
2484
+ answerableCallback?: (arg1: boolean) => unknown;
2485
+ getAnotherHint?: () => unknown;
2486
+ interactionCallback?: (widgetData: {
2487
+ [widgetId: string]: any;
2488
+ }) => void;
2489
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
2490
+ imagePlaceholder?: React.ReactNode;
2491
+ widgetPlaceholder?: React.ReactNode;
2492
+ baseElements?: {
2493
+ Link: React.ComponentType<any>;
2494
+ };
2495
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
2496
+ trackInteraction?: (args: {
2497
+ type: string;
2498
+ id: string;
2499
+ correct?: boolean;
2500
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
2501
+ visible: number;
2502
+ }>) => void;
2503
+ customKeypad?: boolean;
2504
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
2505
+ isMobile?: boolean;
2506
+ isMobileApp?: boolean;
2507
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
2508
+ hintProgressColor?: string;
2509
+ canScrollPage?: boolean;
2510
+ editorChangeDelay?: number;
2511
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
2512
+ }> & {
2513
+ baseElements: NonNullable<{
2514
+ Link: React.ComponentType<any>;
2515
+ } | undefined>;
2516
+ canScrollPage: NonNullable<boolean | undefined>;
2517
+ editorChangeDelay: NonNullable<number | undefined>;
2518
+ groupAnnotator: NonNullable<((groupNumber: number, widgetId: string) => React.ReactNode) | undefined>;
2519
+ isArticle: NonNullable<boolean | undefined>;
2520
+ isMobile: NonNullable<boolean | undefined>;
2521
+ isMobileApp: NonNullable<boolean | undefined>;
2522
+ onFocusChange: NonNullable<((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown) | undefined>;
2523
+ readOnly: NonNullable<boolean | undefined>;
2524
+ setDrawingAreaAvailable: NonNullable<((arg1: boolean) => unknown) | undefined>;
2525
+ showAlignmentOptions: NonNullable<boolean | undefined>;
2526
+ }>;
2527
+ keypadElement?: any;
2528
+ questionCompleted?: boolean;
2529
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2530
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2531
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
2532
+ reviewMode: boolean;
2533
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
2534
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
2535
+ userInput: PerseusGraphType;
2536
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
2537
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
2538
+ }>, nextState: Readonly<any>, nextContext: any): void;
1333
2539
  };
1334
2540
  defaultProps: {
1335
2541
  labels: string[];
@@ -1363,7 +2569,72 @@ declare const InteractiveGraph: {
1363
2569
  lockedFigures: LockedFigure[];
1364
2570
  fullGraphAriaLabel?: string;
1365
2571
  fullGraphAriaDescription?: string;
1366
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>): import("@khanacademy/perseus").Coord[];
2572
+ } & {
2573
+ trackInteraction: (extraData?: Empty | undefined) => void;
2574
+ widgetId: string;
2575
+ widgetIndex: number;
2576
+ alignment: string | null | undefined;
2577
+ static: boolean | null | undefined;
2578
+ problemNum: number | null | undefined;
2579
+ apiOptions: Readonly<Readonly<{
2580
+ isArticle?: boolean;
2581
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
2582
+ GroupMetadataEditor?: React.ComponentType<any>;
2583
+ showAlignmentOptions?: boolean;
2584
+ readOnly?: boolean;
2585
+ answerableCallback?: (arg1: boolean) => unknown;
2586
+ getAnotherHint?: () => unknown;
2587
+ interactionCallback?: (widgetData: {
2588
+ [widgetId: string]: any;
2589
+ }) => void;
2590
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
2591
+ imagePlaceholder?: React.ReactNode;
2592
+ widgetPlaceholder?: React.ReactNode;
2593
+ baseElements?: {
2594
+ Link: React.ComponentType<any>;
2595
+ };
2596
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
2597
+ trackInteraction?: (args: {
2598
+ type: string;
2599
+ id: string;
2600
+ correct?: boolean;
2601
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
2602
+ visible: number;
2603
+ }>) => void;
2604
+ customKeypad?: boolean;
2605
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
2606
+ isMobile?: boolean;
2607
+ isMobileApp?: boolean;
2608
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
2609
+ hintProgressColor?: string;
2610
+ canScrollPage?: boolean;
2611
+ editorChangeDelay?: number;
2612
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
2613
+ }> & {
2614
+ baseElements: NonNullable<import("@khanacademy/perseus").APIOptions["baseElements"]>;
2615
+ canScrollPage: NonNullable<import("@khanacademy/perseus").APIOptions["canScrollPage"]>;
2616
+ editorChangeDelay: NonNullable<import("@khanacademy/perseus").APIOptions["editorChangeDelay"]>;
2617
+ groupAnnotator: NonNullable<import("@khanacademy/perseus").APIOptions["groupAnnotator"]>;
2618
+ isArticle: NonNullable<import("@khanacademy/perseus").APIOptions["isArticle"]>;
2619
+ isMobile: NonNullable<import("@khanacademy/perseus").APIOptions["isMobile"]>;
2620
+ isMobileApp: NonNullable<import("@khanacademy/perseus").APIOptions["isMobileApp"]>;
2621
+ onFocusChange: NonNullable<import("@khanacademy/perseus").APIOptions["onFocusChange"]>;
2622
+ readOnly: NonNullable<import("@khanacademy/perseus").APIOptions["readOnly"]>;
2623
+ setDrawingAreaAvailable: NonNullable<import("@khanacademy/perseus").APIOptions["setDrawingAreaAvailable"]>;
2624
+ showAlignmentOptions: NonNullable<import("@khanacademy/perseus").APIOptions["showAlignmentOptions"]>;
2625
+ }>;
2626
+ keypadElement?: any;
2627
+ questionCompleted?: boolean;
2628
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2629
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2630
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
2631
+ reviewMode: boolean;
2632
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
2633
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
2634
+ userInput: PerseusGraphType;
2635
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
2636
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
2637
+ }): import("@khanacademy/perseus").Coord[];
1367
2638
  getPointCoords(graph: import("@khanacademy/perseus-core").PerseusGraphTypePoint, props: {
1368
2639
  step: [number, number];
1369
2640
  gridStep?: [x: number, y: number];
@@ -1384,7 +2655,72 @@ declare const InteractiveGraph: {
1384
2655
  lockedFigures: LockedFigure[];
1385
2656
  fullGraphAriaLabel?: string;
1386
2657
  fullGraphAriaDescription?: string;
1387
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>): import("@khanacademy/perseus").Coord[];
2658
+ } & {
2659
+ trackInteraction: (extraData?: Empty | undefined) => void;
2660
+ widgetId: string;
2661
+ widgetIndex: number;
2662
+ alignment: string | null | undefined;
2663
+ static: boolean | null | undefined;
2664
+ problemNum: number | null | undefined;
2665
+ apiOptions: Readonly<Readonly<{
2666
+ isArticle?: boolean;
2667
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
2668
+ GroupMetadataEditor?: React.ComponentType<any>;
2669
+ showAlignmentOptions?: boolean;
2670
+ readOnly?: boolean;
2671
+ answerableCallback?: (arg1: boolean) => unknown;
2672
+ getAnotherHint?: () => unknown;
2673
+ interactionCallback?: (widgetData: {
2674
+ [widgetId: string]: any;
2675
+ }) => void;
2676
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
2677
+ imagePlaceholder?: React.ReactNode;
2678
+ widgetPlaceholder?: React.ReactNode;
2679
+ baseElements?: {
2680
+ Link: React.ComponentType<any>;
2681
+ };
2682
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
2683
+ trackInteraction?: (args: {
2684
+ type: string;
2685
+ id: string;
2686
+ correct?: boolean;
2687
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
2688
+ visible: number;
2689
+ }>) => void;
2690
+ customKeypad?: boolean;
2691
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
2692
+ isMobile?: boolean;
2693
+ isMobileApp?: boolean;
2694
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
2695
+ hintProgressColor?: string;
2696
+ canScrollPage?: boolean;
2697
+ editorChangeDelay?: number;
2698
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
2699
+ }> & {
2700
+ baseElements: NonNullable<import("@khanacademy/perseus").APIOptions["baseElements"]>;
2701
+ canScrollPage: NonNullable<import("@khanacademy/perseus").APIOptions["canScrollPage"]>;
2702
+ editorChangeDelay: NonNullable<import("@khanacademy/perseus").APIOptions["editorChangeDelay"]>;
2703
+ groupAnnotator: NonNullable<import("@khanacademy/perseus").APIOptions["groupAnnotator"]>;
2704
+ isArticle: NonNullable<import("@khanacademy/perseus").APIOptions["isArticle"]>;
2705
+ isMobile: NonNullable<import("@khanacademy/perseus").APIOptions["isMobile"]>;
2706
+ isMobileApp: NonNullable<import("@khanacademy/perseus").APIOptions["isMobileApp"]>;
2707
+ onFocusChange: NonNullable<import("@khanacademy/perseus").APIOptions["onFocusChange"]>;
2708
+ readOnly: NonNullable<import("@khanacademy/perseus").APIOptions["readOnly"]>;
2709
+ setDrawingAreaAvailable: NonNullable<import("@khanacademy/perseus").APIOptions["setDrawingAreaAvailable"]>;
2710
+ showAlignmentOptions: NonNullable<import("@khanacademy/perseus").APIOptions["showAlignmentOptions"]>;
2711
+ }>;
2712
+ keypadElement?: any;
2713
+ questionCompleted?: boolean;
2714
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2715
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2716
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
2717
+ reviewMode: boolean;
2718
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
2719
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
2720
+ userInput: PerseusGraphType;
2721
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
2722
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
2723
+ }): import("@khanacademy/perseus").Coord[];
1388
2724
  getLinearSystemCoords(graph: PerseusGraphType, props: {
1389
2725
  step: [number, number];
1390
2726
  gridStep?: [x: number, y: number];
@@ -1405,7 +2741,72 @@ declare const InteractiveGraph: {
1405
2741
  lockedFigures: LockedFigure[];
1406
2742
  fullGraphAriaLabel?: string;
1407
2743
  fullGraphAriaDescription?: string;
1408
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>): import("@khanacademy/perseus").Coord[][];
2744
+ } & {
2745
+ trackInteraction: (extraData?: Empty | undefined) => void;
2746
+ widgetId: string;
2747
+ widgetIndex: number;
2748
+ alignment: string | null | undefined;
2749
+ static: boolean | null | undefined;
2750
+ problemNum: number | null | undefined;
2751
+ apiOptions: Readonly<Readonly<{
2752
+ isArticle?: boolean;
2753
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
2754
+ GroupMetadataEditor?: React.ComponentType<any>;
2755
+ showAlignmentOptions?: boolean;
2756
+ readOnly?: boolean;
2757
+ answerableCallback?: (arg1: boolean) => unknown;
2758
+ getAnotherHint?: () => unknown;
2759
+ interactionCallback?: (widgetData: {
2760
+ [widgetId: string]: any;
2761
+ }) => void;
2762
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
2763
+ imagePlaceholder?: React.ReactNode;
2764
+ widgetPlaceholder?: React.ReactNode;
2765
+ baseElements?: {
2766
+ Link: React.ComponentType<any>;
2767
+ };
2768
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
2769
+ trackInteraction?: (args: {
2770
+ type: string;
2771
+ id: string;
2772
+ correct?: boolean;
2773
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
2774
+ visible: number;
2775
+ }>) => void;
2776
+ customKeypad?: boolean;
2777
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
2778
+ isMobile?: boolean;
2779
+ isMobileApp?: boolean;
2780
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
2781
+ hintProgressColor?: string;
2782
+ canScrollPage?: boolean;
2783
+ editorChangeDelay?: number;
2784
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
2785
+ }> & {
2786
+ baseElements: NonNullable<import("@khanacademy/perseus").APIOptions["baseElements"]>;
2787
+ canScrollPage: NonNullable<import("@khanacademy/perseus").APIOptions["canScrollPage"]>;
2788
+ editorChangeDelay: NonNullable<import("@khanacademy/perseus").APIOptions["editorChangeDelay"]>;
2789
+ groupAnnotator: NonNullable<import("@khanacademy/perseus").APIOptions["groupAnnotator"]>;
2790
+ isArticle: NonNullable<import("@khanacademy/perseus").APIOptions["isArticle"]>;
2791
+ isMobile: NonNullable<import("@khanacademy/perseus").APIOptions["isMobile"]>;
2792
+ isMobileApp: NonNullable<import("@khanacademy/perseus").APIOptions["isMobileApp"]>;
2793
+ onFocusChange: NonNullable<import("@khanacademy/perseus").APIOptions["onFocusChange"]>;
2794
+ readOnly: NonNullable<import("@khanacademy/perseus").APIOptions["readOnly"]>;
2795
+ setDrawingAreaAvailable: NonNullable<import("@khanacademy/perseus").APIOptions["setDrawingAreaAvailable"]>;
2796
+ showAlignmentOptions: NonNullable<import("@khanacademy/perseus").APIOptions["showAlignmentOptions"]>;
2797
+ }>;
2798
+ keypadElement?: any;
2799
+ questionCompleted?: boolean;
2800
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2801
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2802
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
2803
+ reviewMode: boolean;
2804
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
2805
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
2806
+ userInput: PerseusGraphType;
2807
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
2808
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
2809
+ }): import("@khanacademy/perseus").Coord[][];
1409
2810
  getPolygonCoords(graph: PerseusGraphType, props: {
1410
2811
  step: [number, number];
1411
2812
  gridStep?: [x: number, y: number];
@@ -1426,7 +2827,72 @@ declare const InteractiveGraph: {
1426
2827
  lockedFigures: LockedFigure[];
1427
2828
  fullGraphAriaLabel?: string;
1428
2829
  fullGraphAriaDescription?: string;
1429
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>): import("@khanacademy/perseus").Coord[];
2830
+ } & {
2831
+ trackInteraction: (extraData?: Empty | undefined) => void;
2832
+ widgetId: string;
2833
+ widgetIndex: number;
2834
+ alignment: string | null | undefined;
2835
+ static: boolean | null | undefined;
2836
+ problemNum: number | null | undefined;
2837
+ apiOptions: Readonly<Readonly<{
2838
+ isArticle?: boolean;
2839
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
2840
+ GroupMetadataEditor?: React.ComponentType<any>;
2841
+ showAlignmentOptions?: boolean;
2842
+ readOnly?: boolean;
2843
+ answerableCallback?: (arg1: boolean) => unknown;
2844
+ getAnotherHint?: () => unknown;
2845
+ interactionCallback?: (widgetData: {
2846
+ [widgetId: string]: any;
2847
+ }) => void;
2848
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
2849
+ imagePlaceholder?: React.ReactNode;
2850
+ widgetPlaceholder?: React.ReactNode;
2851
+ baseElements?: {
2852
+ Link: React.ComponentType<any>;
2853
+ };
2854
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
2855
+ trackInteraction?: (args: {
2856
+ type: string;
2857
+ id: string;
2858
+ correct?: boolean;
2859
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
2860
+ visible: number;
2861
+ }>) => void;
2862
+ customKeypad?: boolean;
2863
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
2864
+ isMobile?: boolean;
2865
+ isMobileApp?: boolean;
2866
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
2867
+ hintProgressColor?: string;
2868
+ canScrollPage?: boolean;
2869
+ editorChangeDelay?: number;
2870
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
2871
+ }> & {
2872
+ baseElements: NonNullable<import("@khanacademy/perseus").APIOptions["baseElements"]>;
2873
+ canScrollPage: NonNullable<import("@khanacademy/perseus").APIOptions["canScrollPage"]>;
2874
+ editorChangeDelay: NonNullable<import("@khanacademy/perseus").APIOptions["editorChangeDelay"]>;
2875
+ groupAnnotator: NonNullable<import("@khanacademy/perseus").APIOptions["groupAnnotator"]>;
2876
+ isArticle: NonNullable<import("@khanacademy/perseus").APIOptions["isArticle"]>;
2877
+ isMobile: NonNullable<import("@khanacademy/perseus").APIOptions["isMobile"]>;
2878
+ isMobileApp: NonNullable<import("@khanacademy/perseus").APIOptions["isMobileApp"]>;
2879
+ onFocusChange: NonNullable<import("@khanacademy/perseus").APIOptions["onFocusChange"]>;
2880
+ readOnly: NonNullable<import("@khanacademy/perseus").APIOptions["readOnly"]>;
2881
+ setDrawingAreaAvailable: NonNullable<import("@khanacademy/perseus").APIOptions["setDrawingAreaAvailable"]>;
2882
+ showAlignmentOptions: NonNullable<import("@khanacademy/perseus").APIOptions["showAlignmentOptions"]>;
2883
+ }>;
2884
+ keypadElement?: any;
2885
+ questionCompleted?: boolean;
2886
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2887
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2888
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
2889
+ reviewMode: boolean;
2890
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
2891
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
2892
+ userInput: PerseusGraphType;
2893
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
2894
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
2895
+ }): import("@khanacademy/perseus").Coord[];
1430
2896
  getSegmentCoords(graph: import("@khanacademy/perseus-core").PerseusGraphTypeSegment, props: {
1431
2897
  step: [number, number];
1432
2898
  gridStep?: [x: number, y: number];
@@ -1447,7 +2913,72 @@ declare const InteractiveGraph: {
1447
2913
  lockedFigures: LockedFigure[];
1448
2914
  fullGraphAriaLabel?: string;
1449
2915
  fullGraphAriaDescription?: string;
1450
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>): import("@khanacademy/perseus").Coord[][];
2916
+ } & {
2917
+ trackInteraction: (extraData?: Empty | undefined) => void;
2918
+ widgetId: string;
2919
+ widgetIndex: number;
2920
+ alignment: string | null | undefined;
2921
+ static: boolean | null | undefined;
2922
+ problemNum: number | null | undefined;
2923
+ apiOptions: Readonly<Readonly<{
2924
+ isArticle?: boolean;
2925
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
2926
+ GroupMetadataEditor?: React.ComponentType<any>;
2927
+ showAlignmentOptions?: boolean;
2928
+ readOnly?: boolean;
2929
+ answerableCallback?: (arg1: boolean) => unknown;
2930
+ getAnotherHint?: () => unknown;
2931
+ interactionCallback?: (widgetData: {
2932
+ [widgetId: string]: any;
2933
+ }) => void;
2934
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
2935
+ imagePlaceholder?: React.ReactNode;
2936
+ widgetPlaceholder?: React.ReactNode;
2937
+ baseElements?: {
2938
+ Link: React.ComponentType<any>;
2939
+ };
2940
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
2941
+ trackInteraction?: (args: {
2942
+ type: string;
2943
+ id: string;
2944
+ correct?: boolean;
2945
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
2946
+ visible: number;
2947
+ }>) => void;
2948
+ customKeypad?: boolean;
2949
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
2950
+ isMobile?: boolean;
2951
+ isMobileApp?: boolean;
2952
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
2953
+ hintProgressColor?: string;
2954
+ canScrollPage?: boolean;
2955
+ editorChangeDelay?: number;
2956
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
2957
+ }> & {
2958
+ baseElements: NonNullable<import("@khanacademy/perseus").APIOptions["baseElements"]>;
2959
+ canScrollPage: NonNullable<import("@khanacademy/perseus").APIOptions["canScrollPage"]>;
2960
+ editorChangeDelay: NonNullable<import("@khanacademy/perseus").APIOptions["editorChangeDelay"]>;
2961
+ groupAnnotator: NonNullable<import("@khanacademy/perseus").APIOptions["groupAnnotator"]>;
2962
+ isArticle: NonNullable<import("@khanacademy/perseus").APIOptions["isArticle"]>;
2963
+ isMobile: NonNullable<import("@khanacademy/perseus").APIOptions["isMobile"]>;
2964
+ isMobileApp: NonNullable<import("@khanacademy/perseus").APIOptions["isMobileApp"]>;
2965
+ onFocusChange: NonNullable<import("@khanacademy/perseus").APIOptions["onFocusChange"]>;
2966
+ readOnly: NonNullable<import("@khanacademy/perseus").APIOptions["readOnly"]>;
2967
+ setDrawingAreaAvailable: NonNullable<import("@khanacademy/perseus").APIOptions["setDrawingAreaAvailable"]>;
2968
+ showAlignmentOptions: NonNullable<import("@khanacademy/perseus").APIOptions["showAlignmentOptions"]>;
2969
+ }>;
2970
+ keypadElement?: any;
2971
+ questionCompleted?: boolean;
2972
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2973
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2974
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
2975
+ reviewMode: boolean;
2976
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
2977
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
2978
+ userInput: PerseusGraphType;
2979
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
2980
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
2981
+ }): import("@khanacademy/perseus").Coord[][];
1451
2982
  getAngleCoords(graph: import("@khanacademy/perseus-core").PerseusGraphTypeAngle, props: {
1452
2983
  step: [number, number];
1453
2984
  gridStep?: [x: number, y: number];
@@ -1468,7 +2999,72 @@ declare const InteractiveGraph: {
1468
2999
  lockedFigures: LockedFigure[];
1469
3000
  fullGraphAriaLabel?: string;
1470
3001
  fullGraphAriaDescription?: string;
1471
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>): [import("@khanacademy/perseus").Coord, import("@khanacademy/perseus").Coord, import("@khanacademy/perseus").Coord];
3002
+ } & {
3003
+ trackInteraction: (extraData?: Empty | undefined) => void;
3004
+ widgetId: string;
3005
+ widgetIndex: number;
3006
+ alignment: string | null | undefined;
3007
+ static: boolean | null | undefined;
3008
+ problemNum: number | null | undefined;
3009
+ apiOptions: Readonly<Readonly<{
3010
+ isArticle?: boolean;
3011
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
3012
+ GroupMetadataEditor?: React.ComponentType<any>;
3013
+ showAlignmentOptions?: boolean;
3014
+ readOnly?: boolean;
3015
+ answerableCallback?: (arg1: boolean) => unknown;
3016
+ getAnotherHint?: () => unknown;
3017
+ interactionCallback?: (widgetData: {
3018
+ [widgetId: string]: any;
3019
+ }) => void;
3020
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
3021
+ imagePlaceholder?: React.ReactNode;
3022
+ widgetPlaceholder?: React.ReactNode;
3023
+ baseElements?: {
3024
+ Link: React.ComponentType<any>;
3025
+ };
3026
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
3027
+ trackInteraction?: (args: {
3028
+ type: string;
3029
+ id: string;
3030
+ correct?: boolean;
3031
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
3032
+ visible: number;
3033
+ }>) => void;
3034
+ customKeypad?: boolean;
3035
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
3036
+ isMobile?: boolean;
3037
+ isMobileApp?: boolean;
3038
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
3039
+ hintProgressColor?: string;
3040
+ canScrollPage?: boolean;
3041
+ editorChangeDelay?: number;
3042
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
3043
+ }> & {
3044
+ baseElements: NonNullable<import("@khanacademy/perseus").APIOptions["baseElements"]>;
3045
+ canScrollPage: NonNullable<import("@khanacademy/perseus").APIOptions["canScrollPage"]>;
3046
+ editorChangeDelay: NonNullable<import("@khanacademy/perseus").APIOptions["editorChangeDelay"]>;
3047
+ groupAnnotator: NonNullable<import("@khanacademy/perseus").APIOptions["groupAnnotator"]>;
3048
+ isArticle: NonNullable<import("@khanacademy/perseus").APIOptions["isArticle"]>;
3049
+ isMobile: NonNullable<import("@khanacademy/perseus").APIOptions["isMobile"]>;
3050
+ isMobileApp: NonNullable<import("@khanacademy/perseus").APIOptions["isMobileApp"]>;
3051
+ onFocusChange: NonNullable<import("@khanacademy/perseus").APIOptions["onFocusChange"]>;
3052
+ readOnly: NonNullable<import("@khanacademy/perseus").APIOptions["readOnly"]>;
3053
+ setDrawingAreaAvailable: NonNullable<import("@khanacademy/perseus").APIOptions["setDrawingAreaAvailable"]>;
3054
+ showAlignmentOptions: NonNullable<import("@khanacademy/perseus").APIOptions["showAlignmentOptions"]>;
3055
+ }>;
3056
+ keypadElement?: any;
3057
+ questionCompleted?: boolean;
3058
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
3059
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
3060
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
3061
+ reviewMode: boolean;
3062
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
3063
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
3064
+ userInput: PerseusGraphType;
3065
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
3066
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
3067
+ }): [import("@khanacademy/perseus").Coord, import("@khanacademy/perseus").Coord, import("@khanacademy/perseus").Coord];
1472
3068
  normalizeCoords(coordsList: import("@khanacademy/perseus").Coord[], ranges: [import("@khanacademy/kmath").Range, import("@khanacademy/kmath").Range]): import("@khanacademy/perseus").Coord[];
1473
3069
  getEquationString(props: {
1474
3070
  step: [number, number];
@@ -1490,7 +3086,72 @@ declare const InteractiveGraph: {
1490
3086
  lockedFigures: LockedFigure[];
1491
3087
  fullGraphAriaLabel?: string;
1492
3088
  fullGraphAriaDescription?: string;
1493
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>): string;
3089
+ } & {
3090
+ trackInteraction: (extraData?: Empty | undefined) => void;
3091
+ widgetId: string;
3092
+ widgetIndex: number;
3093
+ alignment: string | null | undefined;
3094
+ static: boolean | null | undefined;
3095
+ problemNum: number | null | undefined;
3096
+ apiOptions: Readonly<Readonly<{
3097
+ isArticle?: boolean;
3098
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
3099
+ GroupMetadataEditor?: React.ComponentType<any>;
3100
+ showAlignmentOptions?: boolean;
3101
+ readOnly?: boolean;
3102
+ answerableCallback?: (arg1: boolean) => unknown;
3103
+ getAnotherHint?: () => unknown;
3104
+ interactionCallback?: (widgetData: {
3105
+ [widgetId: string]: any;
3106
+ }) => void;
3107
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
3108
+ imagePlaceholder?: React.ReactNode;
3109
+ widgetPlaceholder?: React.ReactNode;
3110
+ baseElements?: {
3111
+ Link: React.ComponentType<any>;
3112
+ };
3113
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
3114
+ trackInteraction?: (args: {
3115
+ type: string;
3116
+ id: string;
3117
+ correct?: boolean;
3118
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
3119
+ visible: number;
3120
+ }>) => void;
3121
+ customKeypad?: boolean;
3122
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
3123
+ isMobile?: boolean;
3124
+ isMobileApp?: boolean;
3125
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
3126
+ hintProgressColor?: string;
3127
+ canScrollPage?: boolean;
3128
+ editorChangeDelay?: number;
3129
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
3130
+ }> & {
3131
+ baseElements: NonNullable<import("@khanacademy/perseus").APIOptions["baseElements"]>;
3132
+ canScrollPage: NonNullable<import("@khanacademy/perseus").APIOptions["canScrollPage"]>;
3133
+ editorChangeDelay: NonNullable<import("@khanacademy/perseus").APIOptions["editorChangeDelay"]>;
3134
+ groupAnnotator: NonNullable<import("@khanacademy/perseus").APIOptions["groupAnnotator"]>;
3135
+ isArticle: NonNullable<import("@khanacademy/perseus").APIOptions["isArticle"]>;
3136
+ isMobile: NonNullable<import("@khanacademy/perseus").APIOptions["isMobile"]>;
3137
+ isMobileApp: NonNullable<import("@khanacademy/perseus").APIOptions["isMobileApp"]>;
3138
+ onFocusChange: NonNullable<import("@khanacademy/perseus").APIOptions["onFocusChange"]>;
3139
+ readOnly: NonNullable<import("@khanacademy/perseus").APIOptions["readOnly"]>;
3140
+ setDrawingAreaAvailable: NonNullable<import("@khanacademy/perseus").APIOptions["setDrawingAreaAvailable"]>;
3141
+ showAlignmentOptions: NonNullable<import("@khanacademy/perseus").APIOptions["showAlignmentOptions"]>;
3142
+ }>;
3143
+ keypadElement?: any;
3144
+ questionCompleted?: boolean;
3145
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
3146
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
3147
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
3148
+ reviewMode: boolean;
3149
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
3150
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
3151
+ userInput: PerseusGraphType;
3152
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
3153
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
3154
+ }): string;
1494
3155
  pointsFromNormalized(props: {
1495
3156
  step: [number, number];
1496
3157
  gridStep?: [x: number, y: number];
@@ -1511,7 +3172,72 @@ declare const InteractiveGraph: {
1511
3172
  lockedFigures: LockedFigure[];
1512
3173
  fullGraphAriaLabel?: string;
1513
3174
  fullGraphAriaDescription?: string;
1514
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>, coordsList: import("@khanacademy/perseus").Coord[], noSnap?: boolean): import("@khanacademy/perseus").Coord[];
3175
+ } & {
3176
+ trackInteraction: (extraData?: Empty | undefined) => void;
3177
+ widgetId: string;
3178
+ widgetIndex: number;
3179
+ alignment: string | null | undefined;
3180
+ static: boolean | null | undefined;
3181
+ problemNum: number | null | undefined;
3182
+ apiOptions: Readonly<Readonly<{
3183
+ isArticle?: boolean;
3184
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
3185
+ GroupMetadataEditor?: React.ComponentType<any>;
3186
+ showAlignmentOptions?: boolean;
3187
+ readOnly?: boolean;
3188
+ answerableCallback?: (arg1: boolean) => unknown;
3189
+ getAnotherHint?: () => unknown;
3190
+ interactionCallback?: (widgetData: {
3191
+ [widgetId: string]: any;
3192
+ }) => void;
3193
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
3194
+ imagePlaceholder?: React.ReactNode;
3195
+ widgetPlaceholder?: React.ReactNode;
3196
+ baseElements?: {
3197
+ Link: React.ComponentType<any>;
3198
+ };
3199
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
3200
+ trackInteraction?: (args: {
3201
+ type: string;
3202
+ id: string;
3203
+ correct?: boolean;
3204
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
3205
+ visible: number;
3206
+ }>) => void;
3207
+ customKeypad?: boolean;
3208
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
3209
+ isMobile?: boolean;
3210
+ isMobileApp?: boolean;
3211
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
3212
+ hintProgressColor?: string;
3213
+ canScrollPage?: boolean;
3214
+ editorChangeDelay?: number;
3215
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
3216
+ }> & {
3217
+ baseElements: NonNullable<import("@khanacademy/perseus").APIOptions["baseElements"]>;
3218
+ canScrollPage: NonNullable<import("@khanacademy/perseus").APIOptions["canScrollPage"]>;
3219
+ editorChangeDelay: NonNullable<import("@khanacademy/perseus").APIOptions["editorChangeDelay"]>;
3220
+ groupAnnotator: NonNullable<import("@khanacademy/perseus").APIOptions["groupAnnotator"]>;
3221
+ isArticle: NonNullable<import("@khanacademy/perseus").APIOptions["isArticle"]>;
3222
+ isMobile: NonNullable<import("@khanacademy/perseus").APIOptions["isMobile"]>;
3223
+ isMobileApp: NonNullable<import("@khanacademy/perseus").APIOptions["isMobileApp"]>;
3224
+ onFocusChange: NonNullable<import("@khanacademy/perseus").APIOptions["onFocusChange"]>;
3225
+ readOnly: NonNullable<import("@khanacademy/perseus").APIOptions["readOnly"]>;
3226
+ setDrawingAreaAvailable: NonNullable<import("@khanacademy/perseus").APIOptions["setDrawingAreaAvailable"]>;
3227
+ showAlignmentOptions: NonNullable<import("@khanacademy/perseus").APIOptions["showAlignmentOptions"]>;
3228
+ }>;
3229
+ keypadElement?: any;
3230
+ questionCompleted?: boolean;
3231
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
3232
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
3233
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
3234
+ reviewMode: boolean;
3235
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
3236
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
3237
+ userInput: PerseusGraphType;
3238
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
3239
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
3240
+ }, coordsList: import("@khanacademy/perseus").Coord[], noSnap?: boolean): import("@khanacademy/perseus").Coord[];
1515
3241
  getNoneEquationString(): string;
1516
3242
  getLinearEquationString(props: {
1517
3243
  step: [number, number];
@@ -1533,7 +3259,72 @@ declare const InteractiveGraph: {
1533
3259
  lockedFigures: LockedFigure[];
1534
3260
  fullGraphAriaLabel?: string;
1535
3261
  fullGraphAriaDescription?: string;
1536
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>): string;
3262
+ } & {
3263
+ trackInteraction: (extraData?: Empty | undefined) => void;
3264
+ widgetId: string;
3265
+ widgetIndex: number;
3266
+ alignment: string | null | undefined;
3267
+ static: boolean | null | undefined;
3268
+ problemNum: number | null | undefined;
3269
+ apiOptions: Readonly<Readonly<{
3270
+ isArticle?: boolean;
3271
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
3272
+ GroupMetadataEditor?: React.ComponentType<any>;
3273
+ showAlignmentOptions?: boolean;
3274
+ readOnly?: boolean;
3275
+ answerableCallback?: (arg1: boolean) => unknown;
3276
+ getAnotherHint?: () => unknown;
3277
+ interactionCallback?: (widgetData: {
3278
+ [widgetId: string]: any;
3279
+ }) => void;
3280
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
3281
+ imagePlaceholder?: React.ReactNode;
3282
+ widgetPlaceholder?: React.ReactNode;
3283
+ baseElements?: {
3284
+ Link: React.ComponentType<any>;
3285
+ };
3286
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
3287
+ trackInteraction?: (args: {
3288
+ type: string;
3289
+ id: string;
3290
+ correct?: boolean;
3291
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
3292
+ visible: number;
3293
+ }>) => void;
3294
+ customKeypad?: boolean;
3295
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
3296
+ isMobile?: boolean;
3297
+ isMobileApp?: boolean;
3298
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
3299
+ hintProgressColor?: string;
3300
+ canScrollPage?: boolean;
3301
+ editorChangeDelay?: number;
3302
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
3303
+ }> & {
3304
+ baseElements: NonNullable<import("@khanacademy/perseus").APIOptions["baseElements"]>;
3305
+ canScrollPage: NonNullable<import("@khanacademy/perseus").APIOptions["canScrollPage"]>;
3306
+ editorChangeDelay: NonNullable<import("@khanacademy/perseus").APIOptions["editorChangeDelay"]>;
3307
+ groupAnnotator: NonNullable<import("@khanacademy/perseus").APIOptions["groupAnnotator"]>;
3308
+ isArticle: NonNullable<import("@khanacademy/perseus").APIOptions["isArticle"]>;
3309
+ isMobile: NonNullable<import("@khanacademy/perseus").APIOptions["isMobile"]>;
3310
+ isMobileApp: NonNullable<import("@khanacademy/perseus").APIOptions["isMobileApp"]>;
3311
+ onFocusChange: NonNullable<import("@khanacademy/perseus").APIOptions["onFocusChange"]>;
3312
+ readOnly: NonNullable<import("@khanacademy/perseus").APIOptions["readOnly"]>;
3313
+ setDrawingAreaAvailable: NonNullable<import("@khanacademy/perseus").APIOptions["setDrawingAreaAvailable"]>;
3314
+ showAlignmentOptions: NonNullable<import("@khanacademy/perseus").APIOptions["showAlignmentOptions"]>;
3315
+ }>;
3316
+ keypadElement?: any;
3317
+ questionCompleted?: boolean;
3318
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
3319
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
3320
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
3321
+ reviewMode: boolean;
3322
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
3323
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
3324
+ userInput: PerseusGraphType;
3325
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
3326
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
3327
+ }): string;
1537
3328
  getCurrentQuadraticCoefficients(props: {
1538
3329
  step: [number, number];
1539
3330
  gridStep?: [x: number, y: number];
@@ -1554,7 +3345,72 @@ declare const InteractiveGraph: {
1554
3345
  lockedFigures: LockedFigure[];
1555
3346
  fullGraphAriaLabel?: string;
1556
3347
  fullGraphAriaDescription?: string;
1557
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>): import("@khanacademy/kmath").QuadraticCoefficient;
3348
+ } & {
3349
+ trackInteraction: (extraData?: Empty | undefined) => void;
3350
+ widgetId: string;
3351
+ widgetIndex: number;
3352
+ alignment: string | null | undefined;
3353
+ static: boolean | null | undefined;
3354
+ problemNum: number | null | undefined;
3355
+ apiOptions: Readonly<Readonly<{
3356
+ isArticle?: boolean;
3357
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
3358
+ GroupMetadataEditor?: React.ComponentType<any>;
3359
+ showAlignmentOptions?: boolean;
3360
+ readOnly?: boolean;
3361
+ answerableCallback?: (arg1: boolean) => unknown;
3362
+ getAnotherHint?: () => unknown;
3363
+ interactionCallback?: (widgetData: {
3364
+ [widgetId: string]: any;
3365
+ }) => void;
3366
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
3367
+ imagePlaceholder?: React.ReactNode;
3368
+ widgetPlaceholder?: React.ReactNode;
3369
+ baseElements?: {
3370
+ Link: React.ComponentType<any>;
3371
+ };
3372
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
3373
+ trackInteraction?: (args: {
3374
+ type: string;
3375
+ id: string;
3376
+ correct?: boolean;
3377
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
3378
+ visible: number;
3379
+ }>) => void;
3380
+ customKeypad?: boolean;
3381
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
3382
+ isMobile?: boolean;
3383
+ isMobileApp?: boolean;
3384
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
3385
+ hintProgressColor?: string;
3386
+ canScrollPage?: boolean;
3387
+ editorChangeDelay?: number;
3388
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
3389
+ }> & {
3390
+ baseElements: NonNullable<import("@khanacademy/perseus").APIOptions["baseElements"]>;
3391
+ canScrollPage: NonNullable<import("@khanacademy/perseus").APIOptions["canScrollPage"]>;
3392
+ editorChangeDelay: NonNullable<import("@khanacademy/perseus").APIOptions["editorChangeDelay"]>;
3393
+ groupAnnotator: NonNullable<import("@khanacademy/perseus").APIOptions["groupAnnotator"]>;
3394
+ isArticle: NonNullable<import("@khanacademy/perseus").APIOptions["isArticle"]>;
3395
+ isMobile: NonNullable<import("@khanacademy/perseus").APIOptions["isMobile"]>;
3396
+ isMobileApp: NonNullable<import("@khanacademy/perseus").APIOptions["isMobileApp"]>;
3397
+ onFocusChange: NonNullable<import("@khanacademy/perseus").APIOptions["onFocusChange"]>;
3398
+ readOnly: NonNullable<import("@khanacademy/perseus").APIOptions["readOnly"]>;
3399
+ setDrawingAreaAvailable: NonNullable<import("@khanacademy/perseus").APIOptions["setDrawingAreaAvailable"]>;
3400
+ showAlignmentOptions: NonNullable<import("@khanacademy/perseus").APIOptions["showAlignmentOptions"]>;
3401
+ }>;
3402
+ keypadElement?: any;
3403
+ questionCompleted?: boolean;
3404
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
3405
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
3406
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
3407
+ reviewMode: boolean;
3408
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
3409
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
3410
+ userInput: PerseusGraphType;
3411
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
3412
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
3413
+ }): import("@khanacademy/kmath").QuadraticCoefficient;
1558
3414
  defaultQuadraticCoords(props: {
1559
3415
  step: [number, number];
1560
3416
  gridStep?: [x: number, y: number];
@@ -1575,7 +3431,72 @@ declare const InteractiveGraph: {
1575
3431
  lockedFigures: LockedFigure[];
1576
3432
  fullGraphAriaLabel?: string;
1577
3433
  fullGraphAriaDescription?: string;
1578
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>): import("../../../../perseus/src/widgets/interactive-graphs/types").QuadraticGraphState["coords"];
3434
+ } & {
3435
+ trackInteraction: (extraData?: Empty | undefined) => void;
3436
+ widgetId: string;
3437
+ widgetIndex: number;
3438
+ alignment: string | null | undefined;
3439
+ static: boolean | null | undefined;
3440
+ problemNum: number | null | undefined;
3441
+ apiOptions: Readonly<Readonly<{
3442
+ isArticle?: boolean;
3443
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
3444
+ GroupMetadataEditor?: React.ComponentType<any>;
3445
+ showAlignmentOptions?: boolean;
3446
+ readOnly?: boolean;
3447
+ answerableCallback?: (arg1: boolean) => unknown;
3448
+ getAnotherHint?: () => unknown;
3449
+ interactionCallback?: (widgetData: {
3450
+ [widgetId: string]: any;
3451
+ }) => void;
3452
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
3453
+ imagePlaceholder?: React.ReactNode;
3454
+ widgetPlaceholder?: React.ReactNode;
3455
+ baseElements?: {
3456
+ Link: React.ComponentType<any>;
3457
+ };
3458
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
3459
+ trackInteraction?: (args: {
3460
+ type: string;
3461
+ id: string;
3462
+ correct?: boolean;
3463
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
3464
+ visible: number;
3465
+ }>) => void;
3466
+ customKeypad?: boolean;
3467
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
3468
+ isMobile?: boolean;
3469
+ isMobileApp?: boolean;
3470
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
3471
+ hintProgressColor?: string;
3472
+ canScrollPage?: boolean;
3473
+ editorChangeDelay?: number;
3474
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
3475
+ }> & {
3476
+ baseElements: NonNullable<import("@khanacademy/perseus").APIOptions["baseElements"]>;
3477
+ canScrollPage: NonNullable<import("@khanacademy/perseus").APIOptions["canScrollPage"]>;
3478
+ editorChangeDelay: NonNullable<import("@khanacademy/perseus").APIOptions["editorChangeDelay"]>;
3479
+ groupAnnotator: NonNullable<import("@khanacademy/perseus").APIOptions["groupAnnotator"]>;
3480
+ isArticle: NonNullable<import("@khanacademy/perseus").APIOptions["isArticle"]>;
3481
+ isMobile: NonNullable<import("@khanacademy/perseus").APIOptions["isMobile"]>;
3482
+ isMobileApp: NonNullable<import("@khanacademy/perseus").APIOptions["isMobileApp"]>;
3483
+ onFocusChange: NonNullable<import("@khanacademy/perseus").APIOptions["onFocusChange"]>;
3484
+ readOnly: NonNullable<import("@khanacademy/perseus").APIOptions["readOnly"]>;
3485
+ setDrawingAreaAvailable: NonNullable<import("@khanacademy/perseus").APIOptions["setDrawingAreaAvailable"]>;
3486
+ showAlignmentOptions: NonNullable<import("@khanacademy/perseus").APIOptions["showAlignmentOptions"]>;
3487
+ }>;
3488
+ keypadElement?: any;
3489
+ questionCompleted?: boolean;
3490
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
3491
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
3492
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
3493
+ reviewMode: boolean;
3494
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
3495
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
3496
+ userInput: PerseusGraphType;
3497
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
3498
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
3499
+ }): import("../../../../perseus/src/widgets/interactive-graphs/types").QuadraticGraphState["coords"];
1579
3500
  getQuadraticEquationString(props: {
1580
3501
  step: [number, number];
1581
3502
  gridStep?: [x: number, y: number];
@@ -1596,7 +3517,72 @@ declare const InteractiveGraph: {
1596
3517
  lockedFigures: LockedFigure[];
1597
3518
  fullGraphAriaLabel?: string;
1598
3519
  fullGraphAriaDescription?: string;
1599
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>): string;
3520
+ } & {
3521
+ trackInteraction: (extraData?: Empty | undefined) => void;
3522
+ widgetId: string;
3523
+ widgetIndex: number;
3524
+ alignment: string | null | undefined;
3525
+ static: boolean | null | undefined;
3526
+ problemNum: number | null | undefined;
3527
+ apiOptions: Readonly<Readonly<{
3528
+ isArticle?: boolean;
3529
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
3530
+ GroupMetadataEditor?: React.ComponentType<any>;
3531
+ showAlignmentOptions?: boolean;
3532
+ readOnly?: boolean;
3533
+ answerableCallback?: (arg1: boolean) => unknown;
3534
+ getAnotherHint?: () => unknown;
3535
+ interactionCallback?: (widgetData: {
3536
+ [widgetId: string]: any;
3537
+ }) => void;
3538
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
3539
+ imagePlaceholder?: React.ReactNode;
3540
+ widgetPlaceholder?: React.ReactNode;
3541
+ baseElements?: {
3542
+ Link: React.ComponentType<any>;
3543
+ };
3544
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
3545
+ trackInteraction?: (args: {
3546
+ type: string;
3547
+ id: string;
3548
+ correct?: boolean;
3549
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
3550
+ visible: number;
3551
+ }>) => void;
3552
+ customKeypad?: boolean;
3553
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
3554
+ isMobile?: boolean;
3555
+ isMobileApp?: boolean;
3556
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
3557
+ hintProgressColor?: string;
3558
+ canScrollPage?: boolean;
3559
+ editorChangeDelay?: number;
3560
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
3561
+ }> & {
3562
+ baseElements: NonNullable<import("@khanacademy/perseus").APIOptions["baseElements"]>;
3563
+ canScrollPage: NonNullable<import("@khanacademy/perseus").APIOptions["canScrollPage"]>;
3564
+ editorChangeDelay: NonNullable<import("@khanacademy/perseus").APIOptions["editorChangeDelay"]>;
3565
+ groupAnnotator: NonNullable<import("@khanacademy/perseus").APIOptions["groupAnnotator"]>;
3566
+ isArticle: NonNullable<import("@khanacademy/perseus").APIOptions["isArticle"]>;
3567
+ isMobile: NonNullable<import("@khanacademy/perseus").APIOptions["isMobile"]>;
3568
+ isMobileApp: NonNullable<import("@khanacademy/perseus").APIOptions["isMobileApp"]>;
3569
+ onFocusChange: NonNullable<import("@khanacademy/perseus").APIOptions["onFocusChange"]>;
3570
+ readOnly: NonNullable<import("@khanacademy/perseus").APIOptions["readOnly"]>;
3571
+ setDrawingAreaAvailable: NonNullable<import("@khanacademy/perseus").APIOptions["setDrawingAreaAvailable"]>;
3572
+ showAlignmentOptions: NonNullable<import("@khanacademy/perseus").APIOptions["showAlignmentOptions"]>;
3573
+ }>;
3574
+ keypadElement?: any;
3575
+ questionCompleted?: boolean;
3576
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
3577
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
3578
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
3579
+ reviewMode: boolean;
3580
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
3581
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
3582
+ userInput: PerseusGraphType;
3583
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
3584
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
3585
+ }): string;
1600
3586
  getCurrentSinusoidCoefficients(props: {
1601
3587
  step: [number, number];
1602
3588
  gridStep?: [x: number, y: number];
@@ -1617,7 +3603,72 @@ declare const InteractiveGraph: {
1617
3603
  lockedFigures: LockedFigure[];
1618
3604
  fullGraphAriaLabel?: string;
1619
3605
  fullGraphAriaDescription?: string;
1620
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>): import("@khanacademy/kmath").SineCoefficient;
3606
+ } & {
3607
+ trackInteraction: (extraData?: Empty | undefined) => void;
3608
+ widgetId: string;
3609
+ widgetIndex: number;
3610
+ alignment: string | null | undefined;
3611
+ static: boolean | null | undefined;
3612
+ problemNum: number | null | undefined;
3613
+ apiOptions: Readonly<Readonly<{
3614
+ isArticle?: boolean;
3615
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
3616
+ GroupMetadataEditor?: React.ComponentType<any>;
3617
+ showAlignmentOptions?: boolean;
3618
+ readOnly?: boolean;
3619
+ answerableCallback?: (arg1: boolean) => unknown;
3620
+ getAnotherHint?: () => unknown;
3621
+ interactionCallback?: (widgetData: {
3622
+ [widgetId: string]: any;
3623
+ }) => void;
3624
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
3625
+ imagePlaceholder?: React.ReactNode;
3626
+ widgetPlaceholder?: React.ReactNode;
3627
+ baseElements?: {
3628
+ Link: React.ComponentType<any>;
3629
+ };
3630
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
3631
+ trackInteraction?: (args: {
3632
+ type: string;
3633
+ id: string;
3634
+ correct?: boolean;
3635
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
3636
+ visible: number;
3637
+ }>) => void;
3638
+ customKeypad?: boolean;
3639
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
3640
+ isMobile?: boolean;
3641
+ isMobileApp?: boolean;
3642
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
3643
+ hintProgressColor?: string;
3644
+ canScrollPage?: boolean;
3645
+ editorChangeDelay?: number;
3646
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
3647
+ }> & {
3648
+ baseElements: NonNullable<import("@khanacademy/perseus").APIOptions["baseElements"]>;
3649
+ canScrollPage: NonNullable<import("@khanacademy/perseus").APIOptions["canScrollPage"]>;
3650
+ editorChangeDelay: NonNullable<import("@khanacademy/perseus").APIOptions["editorChangeDelay"]>;
3651
+ groupAnnotator: NonNullable<import("@khanacademy/perseus").APIOptions["groupAnnotator"]>;
3652
+ isArticle: NonNullable<import("@khanacademy/perseus").APIOptions["isArticle"]>;
3653
+ isMobile: NonNullable<import("@khanacademy/perseus").APIOptions["isMobile"]>;
3654
+ isMobileApp: NonNullable<import("@khanacademy/perseus").APIOptions["isMobileApp"]>;
3655
+ onFocusChange: NonNullable<import("@khanacademy/perseus").APIOptions["onFocusChange"]>;
3656
+ readOnly: NonNullable<import("@khanacademy/perseus").APIOptions["readOnly"]>;
3657
+ setDrawingAreaAvailable: NonNullable<import("@khanacademy/perseus").APIOptions["setDrawingAreaAvailable"]>;
3658
+ showAlignmentOptions: NonNullable<import("@khanacademy/perseus").APIOptions["showAlignmentOptions"]>;
3659
+ }>;
3660
+ keypadElement?: any;
3661
+ questionCompleted?: boolean;
3662
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
3663
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
3664
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
3665
+ reviewMode: boolean;
3666
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
3667
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
3668
+ userInput: PerseusGraphType;
3669
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
3670
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
3671
+ }): import("@khanacademy/kmath").SineCoefficient;
1621
3672
  defaultSinusoidCoords(props: {
1622
3673
  step: [number, number];
1623
3674
  gridStep?: [x: number, y: number];
@@ -1638,7 +3689,72 @@ declare const InteractiveGraph: {
1638
3689
  lockedFigures: LockedFigure[];
1639
3690
  fullGraphAriaLabel?: string;
1640
3691
  fullGraphAriaDescription?: string;
1641
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>): import("@khanacademy/perseus").Coord[];
3692
+ } & {
3693
+ trackInteraction: (extraData?: Empty | undefined) => void;
3694
+ widgetId: string;
3695
+ widgetIndex: number;
3696
+ alignment: string | null | undefined;
3697
+ static: boolean | null | undefined;
3698
+ problemNum: number | null | undefined;
3699
+ apiOptions: Readonly<Readonly<{
3700
+ isArticle?: boolean;
3701
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
3702
+ GroupMetadataEditor?: React.ComponentType<any>;
3703
+ showAlignmentOptions?: boolean;
3704
+ readOnly?: boolean;
3705
+ answerableCallback?: (arg1: boolean) => unknown;
3706
+ getAnotherHint?: () => unknown;
3707
+ interactionCallback?: (widgetData: {
3708
+ [widgetId: string]: any;
3709
+ }) => void;
3710
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
3711
+ imagePlaceholder?: React.ReactNode;
3712
+ widgetPlaceholder?: React.ReactNode;
3713
+ baseElements?: {
3714
+ Link: React.ComponentType<any>;
3715
+ };
3716
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
3717
+ trackInteraction?: (args: {
3718
+ type: string;
3719
+ id: string;
3720
+ correct?: boolean;
3721
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
3722
+ visible: number;
3723
+ }>) => void;
3724
+ customKeypad?: boolean;
3725
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
3726
+ isMobile?: boolean;
3727
+ isMobileApp?: boolean;
3728
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
3729
+ hintProgressColor?: string;
3730
+ canScrollPage?: boolean;
3731
+ editorChangeDelay?: number;
3732
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
3733
+ }> & {
3734
+ baseElements: NonNullable<import("@khanacademy/perseus").APIOptions["baseElements"]>;
3735
+ canScrollPage: NonNullable<import("@khanacademy/perseus").APIOptions["canScrollPage"]>;
3736
+ editorChangeDelay: NonNullable<import("@khanacademy/perseus").APIOptions["editorChangeDelay"]>;
3737
+ groupAnnotator: NonNullable<import("@khanacademy/perseus").APIOptions["groupAnnotator"]>;
3738
+ isArticle: NonNullable<import("@khanacademy/perseus").APIOptions["isArticle"]>;
3739
+ isMobile: NonNullable<import("@khanacademy/perseus").APIOptions["isMobile"]>;
3740
+ isMobileApp: NonNullable<import("@khanacademy/perseus").APIOptions["isMobileApp"]>;
3741
+ onFocusChange: NonNullable<import("@khanacademy/perseus").APIOptions["onFocusChange"]>;
3742
+ readOnly: NonNullable<import("@khanacademy/perseus").APIOptions["readOnly"]>;
3743
+ setDrawingAreaAvailable: NonNullable<import("@khanacademy/perseus").APIOptions["setDrawingAreaAvailable"]>;
3744
+ showAlignmentOptions: NonNullable<import("@khanacademy/perseus").APIOptions["showAlignmentOptions"]>;
3745
+ }>;
3746
+ keypadElement?: any;
3747
+ questionCompleted?: boolean;
3748
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
3749
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
3750
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
3751
+ reviewMode: boolean;
3752
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
3753
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
3754
+ userInput: PerseusGraphType;
3755
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
3756
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
3757
+ }): import("@khanacademy/perseus").Coord[];
1642
3758
  getSinusoidEquationString(props: {
1643
3759
  step: [number, number];
1644
3760
  gridStep?: [x: number, y: number];
@@ -1659,7 +3775,72 @@ declare const InteractiveGraph: {
1659
3775
  lockedFigures: LockedFigure[];
1660
3776
  fullGraphAriaLabel?: string;
1661
3777
  fullGraphAriaDescription?: string;
1662
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>): string;
3778
+ } & {
3779
+ trackInteraction: (extraData?: Empty | undefined) => void;
3780
+ widgetId: string;
3781
+ widgetIndex: number;
3782
+ alignment: string | null | undefined;
3783
+ static: boolean | null | undefined;
3784
+ problemNum: number | null | undefined;
3785
+ apiOptions: Readonly<Readonly<{
3786
+ isArticle?: boolean;
3787
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
3788
+ GroupMetadataEditor?: React.ComponentType<any>;
3789
+ showAlignmentOptions?: boolean;
3790
+ readOnly?: boolean;
3791
+ answerableCallback?: (arg1: boolean) => unknown;
3792
+ getAnotherHint?: () => unknown;
3793
+ interactionCallback?: (widgetData: {
3794
+ [widgetId: string]: any;
3795
+ }) => void;
3796
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
3797
+ imagePlaceholder?: React.ReactNode;
3798
+ widgetPlaceholder?: React.ReactNode;
3799
+ baseElements?: {
3800
+ Link: React.ComponentType<any>;
3801
+ };
3802
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
3803
+ trackInteraction?: (args: {
3804
+ type: string;
3805
+ id: string;
3806
+ correct?: boolean;
3807
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
3808
+ visible: number;
3809
+ }>) => void;
3810
+ customKeypad?: boolean;
3811
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
3812
+ isMobile?: boolean;
3813
+ isMobileApp?: boolean;
3814
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
3815
+ hintProgressColor?: string;
3816
+ canScrollPage?: boolean;
3817
+ editorChangeDelay?: number;
3818
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
3819
+ }> & {
3820
+ baseElements: NonNullable<import("@khanacademy/perseus").APIOptions["baseElements"]>;
3821
+ canScrollPage: NonNullable<import("@khanacademy/perseus").APIOptions["canScrollPage"]>;
3822
+ editorChangeDelay: NonNullable<import("@khanacademy/perseus").APIOptions["editorChangeDelay"]>;
3823
+ groupAnnotator: NonNullable<import("@khanacademy/perseus").APIOptions["groupAnnotator"]>;
3824
+ isArticle: NonNullable<import("@khanacademy/perseus").APIOptions["isArticle"]>;
3825
+ isMobile: NonNullable<import("@khanacademy/perseus").APIOptions["isMobile"]>;
3826
+ isMobileApp: NonNullable<import("@khanacademy/perseus").APIOptions["isMobileApp"]>;
3827
+ onFocusChange: NonNullable<import("@khanacademy/perseus").APIOptions["onFocusChange"]>;
3828
+ readOnly: NonNullable<import("@khanacademy/perseus").APIOptions["readOnly"]>;
3829
+ setDrawingAreaAvailable: NonNullable<import("@khanacademy/perseus").APIOptions["setDrawingAreaAvailable"]>;
3830
+ showAlignmentOptions: NonNullable<import("@khanacademy/perseus").APIOptions["showAlignmentOptions"]>;
3831
+ }>;
3832
+ keypadElement?: any;
3833
+ questionCompleted?: boolean;
3834
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
3835
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
3836
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
3837
+ reviewMode: boolean;
3838
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
3839
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
3840
+ userInput: PerseusGraphType;
3841
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
3842
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
3843
+ }): string;
1663
3844
  getCircleEquationString(props: {
1664
3845
  step: [number, number];
1665
3846
  gridStep?: [x: number, y: number];
@@ -1680,7 +3861,72 @@ declare const InteractiveGraph: {
1680
3861
  lockedFigures: LockedFigure[];
1681
3862
  fullGraphAriaLabel?: string;
1682
3863
  fullGraphAriaDescription?: string;
1683
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>): string;
3864
+ } & {
3865
+ trackInteraction: (extraData?: Empty | undefined) => void;
3866
+ widgetId: string;
3867
+ widgetIndex: number;
3868
+ alignment: string | null | undefined;
3869
+ static: boolean | null | undefined;
3870
+ problemNum: number | null | undefined;
3871
+ apiOptions: Readonly<Readonly<{
3872
+ isArticle?: boolean;
3873
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
3874
+ GroupMetadataEditor?: React.ComponentType<any>;
3875
+ showAlignmentOptions?: boolean;
3876
+ readOnly?: boolean;
3877
+ answerableCallback?: (arg1: boolean) => unknown;
3878
+ getAnotherHint?: () => unknown;
3879
+ interactionCallback?: (widgetData: {
3880
+ [widgetId: string]: any;
3881
+ }) => void;
3882
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
3883
+ imagePlaceholder?: React.ReactNode;
3884
+ widgetPlaceholder?: React.ReactNode;
3885
+ baseElements?: {
3886
+ Link: React.ComponentType<any>;
3887
+ };
3888
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
3889
+ trackInteraction?: (args: {
3890
+ type: string;
3891
+ id: string;
3892
+ correct?: boolean;
3893
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
3894
+ visible: number;
3895
+ }>) => void;
3896
+ customKeypad?: boolean;
3897
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
3898
+ isMobile?: boolean;
3899
+ isMobileApp?: boolean;
3900
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
3901
+ hintProgressColor?: string;
3902
+ canScrollPage?: boolean;
3903
+ editorChangeDelay?: number;
3904
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
3905
+ }> & {
3906
+ baseElements: NonNullable<import("@khanacademy/perseus").APIOptions["baseElements"]>;
3907
+ canScrollPage: NonNullable<import("@khanacademy/perseus").APIOptions["canScrollPage"]>;
3908
+ editorChangeDelay: NonNullable<import("@khanacademy/perseus").APIOptions["editorChangeDelay"]>;
3909
+ groupAnnotator: NonNullable<import("@khanacademy/perseus").APIOptions["groupAnnotator"]>;
3910
+ isArticle: NonNullable<import("@khanacademy/perseus").APIOptions["isArticle"]>;
3911
+ isMobile: NonNullable<import("@khanacademy/perseus").APIOptions["isMobile"]>;
3912
+ isMobileApp: NonNullable<import("@khanacademy/perseus").APIOptions["isMobileApp"]>;
3913
+ onFocusChange: NonNullable<import("@khanacademy/perseus").APIOptions["onFocusChange"]>;
3914
+ readOnly: NonNullable<import("@khanacademy/perseus").APIOptions["readOnly"]>;
3915
+ setDrawingAreaAvailable: NonNullable<import("@khanacademy/perseus").APIOptions["setDrawingAreaAvailable"]>;
3916
+ showAlignmentOptions: NonNullable<import("@khanacademy/perseus").APIOptions["showAlignmentOptions"]>;
3917
+ }>;
3918
+ keypadElement?: any;
3919
+ questionCompleted?: boolean;
3920
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
3921
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
3922
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
3923
+ reviewMode: boolean;
3924
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
3925
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
3926
+ userInput: PerseusGraphType;
3927
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
3928
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
3929
+ }): string;
1684
3930
  getLinearSystemEquationString(props: {
1685
3931
  step: [number, number];
1686
3932
  gridStep?: [x: number, y: number];
@@ -1701,7 +3947,72 @@ declare const InteractiveGraph: {
1701
3947
  lockedFigures: LockedFigure[];
1702
3948
  fullGraphAriaLabel?: string;
1703
3949
  fullGraphAriaDescription?: string;
1704
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>): string;
3950
+ } & {
3951
+ trackInteraction: (extraData?: Empty | undefined) => void;
3952
+ widgetId: string;
3953
+ widgetIndex: number;
3954
+ alignment: string | null | undefined;
3955
+ static: boolean | null | undefined;
3956
+ problemNum: number | null | undefined;
3957
+ apiOptions: Readonly<Readonly<{
3958
+ isArticle?: boolean;
3959
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
3960
+ GroupMetadataEditor?: React.ComponentType<any>;
3961
+ showAlignmentOptions?: boolean;
3962
+ readOnly?: boolean;
3963
+ answerableCallback?: (arg1: boolean) => unknown;
3964
+ getAnotherHint?: () => unknown;
3965
+ interactionCallback?: (widgetData: {
3966
+ [widgetId: string]: any;
3967
+ }) => void;
3968
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
3969
+ imagePlaceholder?: React.ReactNode;
3970
+ widgetPlaceholder?: React.ReactNode;
3971
+ baseElements?: {
3972
+ Link: React.ComponentType<any>;
3973
+ };
3974
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
3975
+ trackInteraction?: (args: {
3976
+ type: string;
3977
+ id: string;
3978
+ correct?: boolean;
3979
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
3980
+ visible: number;
3981
+ }>) => void;
3982
+ customKeypad?: boolean;
3983
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
3984
+ isMobile?: boolean;
3985
+ isMobileApp?: boolean;
3986
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
3987
+ hintProgressColor?: string;
3988
+ canScrollPage?: boolean;
3989
+ editorChangeDelay?: number;
3990
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
3991
+ }> & {
3992
+ baseElements: NonNullable<import("@khanacademy/perseus").APIOptions["baseElements"]>;
3993
+ canScrollPage: NonNullable<import("@khanacademy/perseus").APIOptions["canScrollPage"]>;
3994
+ editorChangeDelay: NonNullable<import("@khanacademy/perseus").APIOptions["editorChangeDelay"]>;
3995
+ groupAnnotator: NonNullable<import("@khanacademy/perseus").APIOptions["groupAnnotator"]>;
3996
+ isArticle: NonNullable<import("@khanacademy/perseus").APIOptions["isArticle"]>;
3997
+ isMobile: NonNullable<import("@khanacademy/perseus").APIOptions["isMobile"]>;
3998
+ isMobileApp: NonNullable<import("@khanacademy/perseus").APIOptions["isMobileApp"]>;
3999
+ onFocusChange: NonNullable<import("@khanacademy/perseus").APIOptions["onFocusChange"]>;
4000
+ readOnly: NonNullable<import("@khanacademy/perseus").APIOptions["readOnly"]>;
4001
+ setDrawingAreaAvailable: NonNullable<import("@khanacademy/perseus").APIOptions["setDrawingAreaAvailable"]>;
4002
+ showAlignmentOptions: NonNullable<import("@khanacademy/perseus").APIOptions["showAlignmentOptions"]>;
4003
+ }>;
4004
+ keypadElement?: any;
4005
+ questionCompleted?: boolean;
4006
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
4007
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
4008
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
4009
+ reviewMode: boolean;
4010
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
4011
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
4012
+ userInput: PerseusGraphType;
4013
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
4014
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
4015
+ }): string;
1705
4016
  getPointEquationString(props: {
1706
4017
  step: [number, number];
1707
4018
  gridStep?: [x: number, y: number];
@@ -1722,7 +4033,72 @@ declare const InteractiveGraph: {
1722
4033
  lockedFigures: LockedFigure[];
1723
4034
  fullGraphAriaLabel?: string;
1724
4035
  fullGraphAriaDescription?: string;
1725
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>): string;
4036
+ } & {
4037
+ trackInteraction: (extraData?: Empty | undefined) => void;
4038
+ widgetId: string;
4039
+ widgetIndex: number;
4040
+ alignment: string | null | undefined;
4041
+ static: boolean | null | undefined;
4042
+ problemNum: number | null | undefined;
4043
+ apiOptions: Readonly<Readonly<{
4044
+ isArticle?: boolean;
4045
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
4046
+ GroupMetadataEditor?: React.ComponentType<any>;
4047
+ showAlignmentOptions?: boolean;
4048
+ readOnly?: boolean;
4049
+ answerableCallback?: (arg1: boolean) => unknown;
4050
+ getAnotherHint?: () => unknown;
4051
+ interactionCallback?: (widgetData: {
4052
+ [widgetId: string]: any;
4053
+ }) => void;
4054
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
4055
+ imagePlaceholder?: React.ReactNode;
4056
+ widgetPlaceholder?: React.ReactNode;
4057
+ baseElements?: {
4058
+ Link: React.ComponentType<any>;
4059
+ };
4060
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
4061
+ trackInteraction?: (args: {
4062
+ type: string;
4063
+ id: string;
4064
+ correct?: boolean;
4065
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
4066
+ visible: number;
4067
+ }>) => void;
4068
+ customKeypad?: boolean;
4069
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
4070
+ isMobile?: boolean;
4071
+ isMobileApp?: boolean;
4072
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
4073
+ hintProgressColor?: string;
4074
+ canScrollPage?: boolean;
4075
+ editorChangeDelay?: number;
4076
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
4077
+ }> & {
4078
+ baseElements: NonNullable<import("@khanacademy/perseus").APIOptions["baseElements"]>;
4079
+ canScrollPage: NonNullable<import("@khanacademy/perseus").APIOptions["canScrollPage"]>;
4080
+ editorChangeDelay: NonNullable<import("@khanacademy/perseus").APIOptions["editorChangeDelay"]>;
4081
+ groupAnnotator: NonNullable<import("@khanacademy/perseus").APIOptions["groupAnnotator"]>;
4082
+ isArticle: NonNullable<import("@khanacademy/perseus").APIOptions["isArticle"]>;
4083
+ isMobile: NonNullable<import("@khanacademy/perseus").APIOptions["isMobile"]>;
4084
+ isMobileApp: NonNullable<import("@khanacademy/perseus").APIOptions["isMobileApp"]>;
4085
+ onFocusChange: NonNullable<import("@khanacademy/perseus").APIOptions["onFocusChange"]>;
4086
+ readOnly: NonNullable<import("@khanacademy/perseus").APIOptions["readOnly"]>;
4087
+ setDrawingAreaAvailable: NonNullable<import("@khanacademy/perseus").APIOptions["setDrawingAreaAvailable"]>;
4088
+ showAlignmentOptions: NonNullable<import("@khanacademy/perseus").APIOptions["showAlignmentOptions"]>;
4089
+ }>;
4090
+ keypadElement?: any;
4091
+ questionCompleted?: boolean;
4092
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
4093
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
4094
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
4095
+ reviewMode: boolean;
4096
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
4097
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
4098
+ userInput: PerseusGraphType;
4099
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
4100
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
4101
+ }): string;
1726
4102
  getSegmentEquationString(props: {
1727
4103
  step: [number, number];
1728
4104
  gridStep?: [x: number, y: number];
@@ -1743,7 +4119,72 @@ declare const InteractiveGraph: {
1743
4119
  lockedFigures: LockedFigure[];
1744
4120
  fullGraphAriaLabel?: string;
1745
4121
  fullGraphAriaDescription?: string;
1746
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>): string;
4122
+ } & {
4123
+ trackInteraction: (extraData?: Empty | undefined) => void;
4124
+ widgetId: string;
4125
+ widgetIndex: number;
4126
+ alignment: string | null | undefined;
4127
+ static: boolean | null | undefined;
4128
+ problemNum: number | null | undefined;
4129
+ apiOptions: Readonly<Readonly<{
4130
+ isArticle?: boolean;
4131
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
4132
+ GroupMetadataEditor?: React.ComponentType<any>;
4133
+ showAlignmentOptions?: boolean;
4134
+ readOnly?: boolean;
4135
+ answerableCallback?: (arg1: boolean) => unknown;
4136
+ getAnotherHint?: () => unknown;
4137
+ interactionCallback?: (widgetData: {
4138
+ [widgetId: string]: any;
4139
+ }) => void;
4140
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
4141
+ imagePlaceholder?: React.ReactNode;
4142
+ widgetPlaceholder?: React.ReactNode;
4143
+ baseElements?: {
4144
+ Link: React.ComponentType<any>;
4145
+ };
4146
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
4147
+ trackInteraction?: (args: {
4148
+ type: string;
4149
+ id: string;
4150
+ correct?: boolean;
4151
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
4152
+ visible: number;
4153
+ }>) => void;
4154
+ customKeypad?: boolean;
4155
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
4156
+ isMobile?: boolean;
4157
+ isMobileApp?: boolean;
4158
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
4159
+ hintProgressColor?: string;
4160
+ canScrollPage?: boolean;
4161
+ editorChangeDelay?: number;
4162
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
4163
+ }> & {
4164
+ baseElements: NonNullable<import("@khanacademy/perseus").APIOptions["baseElements"]>;
4165
+ canScrollPage: NonNullable<import("@khanacademy/perseus").APIOptions["canScrollPage"]>;
4166
+ editorChangeDelay: NonNullable<import("@khanacademy/perseus").APIOptions["editorChangeDelay"]>;
4167
+ groupAnnotator: NonNullable<import("@khanacademy/perseus").APIOptions["groupAnnotator"]>;
4168
+ isArticle: NonNullable<import("@khanacademy/perseus").APIOptions["isArticle"]>;
4169
+ isMobile: NonNullable<import("@khanacademy/perseus").APIOptions["isMobile"]>;
4170
+ isMobileApp: NonNullable<import("@khanacademy/perseus").APIOptions["isMobileApp"]>;
4171
+ onFocusChange: NonNullable<import("@khanacademy/perseus").APIOptions["onFocusChange"]>;
4172
+ readOnly: NonNullable<import("@khanacademy/perseus").APIOptions["readOnly"]>;
4173
+ setDrawingAreaAvailable: NonNullable<import("@khanacademy/perseus").APIOptions["setDrawingAreaAvailable"]>;
4174
+ showAlignmentOptions: NonNullable<import("@khanacademy/perseus").APIOptions["showAlignmentOptions"]>;
4175
+ }>;
4176
+ keypadElement?: any;
4177
+ questionCompleted?: boolean;
4178
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
4179
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
4180
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
4181
+ reviewMode: boolean;
4182
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
4183
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
4184
+ userInput: PerseusGraphType;
4185
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
4186
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
4187
+ }): string;
1747
4188
  getRayEquationString(props: {
1748
4189
  step: [number, number];
1749
4190
  gridStep?: [x: number, y: number];
@@ -1764,7 +4205,72 @@ declare const InteractiveGraph: {
1764
4205
  lockedFigures: LockedFigure[];
1765
4206
  fullGraphAriaLabel?: string;
1766
4207
  fullGraphAriaDescription?: string;
1767
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>): string;
4208
+ } & {
4209
+ trackInteraction: (extraData?: Empty | undefined) => void;
4210
+ widgetId: string;
4211
+ widgetIndex: number;
4212
+ alignment: string | null | undefined;
4213
+ static: boolean | null | undefined;
4214
+ problemNum: number | null | undefined;
4215
+ apiOptions: Readonly<Readonly<{
4216
+ isArticle?: boolean;
4217
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
4218
+ GroupMetadataEditor?: React.ComponentType<any>;
4219
+ showAlignmentOptions?: boolean;
4220
+ readOnly?: boolean;
4221
+ answerableCallback?: (arg1: boolean) => unknown;
4222
+ getAnotherHint?: () => unknown;
4223
+ interactionCallback?: (widgetData: {
4224
+ [widgetId: string]: any;
4225
+ }) => void;
4226
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
4227
+ imagePlaceholder?: React.ReactNode;
4228
+ widgetPlaceholder?: React.ReactNode;
4229
+ baseElements?: {
4230
+ Link: React.ComponentType<any>;
4231
+ };
4232
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
4233
+ trackInteraction?: (args: {
4234
+ type: string;
4235
+ id: string;
4236
+ correct?: boolean;
4237
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
4238
+ visible: number;
4239
+ }>) => void;
4240
+ customKeypad?: boolean;
4241
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
4242
+ isMobile?: boolean;
4243
+ isMobileApp?: boolean;
4244
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
4245
+ hintProgressColor?: string;
4246
+ canScrollPage?: boolean;
4247
+ editorChangeDelay?: number;
4248
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
4249
+ }> & {
4250
+ baseElements: NonNullable<import("@khanacademy/perseus").APIOptions["baseElements"]>;
4251
+ canScrollPage: NonNullable<import("@khanacademy/perseus").APIOptions["canScrollPage"]>;
4252
+ editorChangeDelay: NonNullable<import("@khanacademy/perseus").APIOptions["editorChangeDelay"]>;
4253
+ groupAnnotator: NonNullable<import("@khanacademy/perseus").APIOptions["groupAnnotator"]>;
4254
+ isArticle: NonNullable<import("@khanacademy/perseus").APIOptions["isArticle"]>;
4255
+ isMobile: NonNullable<import("@khanacademy/perseus").APIOptions["isMobile"]>;
4256
+ isMobileApp: NonNullable<import("@khanacademy/perseus").APIOptions["isMobileApp"]>;
4257
+ onFocusChange: NonNullable<import("@khanacademy/perseus").APIOptions["onFocusChange"]>;
4258
+ readOnly: NonNullable<import("@khanacademy/perseus").APIOptions["readOnly"]>;
4259
+ setDrawingAreaAvailable: NonNullable<import("@khanacademy/perseus").APIOptions["setDrawingAreaAvailable"]>;
4260
+ showAlignmentOptions: NonNullable<import("@khanacademy/perseus").APIOptions["showAlignmentOptions"]>;
4261
+ }>;
4262
+ keypadElement?: any;
4263
+ questionCompleted?: boolean;
4264
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
4265
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
4266
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
4267
+ reviewMode: boolean;
4268
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
4269
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
4270
+ userInput: PerseusGraphType;
4271
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
4272
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
4273
+ }): string;
1768
4274
  getPolygonEquationString(props: {
1769
4275
  step: [number, number];
1770
4276
  gridStep?: [x: number, y: number];
@@ -1785,7 +4291,72 @@ declare const InteractiveGraph: {
1785
4291
  lockedFigures: LockedFigure[];
1786
4292
  fullGraphAriaLabel?: string;
1787
4293
  fullGraphAriaDescription?: string;
1788
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>): string;
4294
+ } & {
4295
+ trackInteraction: (extraData?: Empty | undefined) => void;
4296
+ widgetId: string;
4297
+ widgetIndex: number;
4298
+ alignment: string | null | undefined;
4299
+ static: boolean | null | undefined;
4300
+ problemNum: number | null | undefined;
4301
+ apiOptions: Readonly<Readonly<{
4302
+ isArticle?: boolean;
4303
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
4304
+ GroupMetadataEditor?: React.ComponentType<any>;
4305
+ showAlignmentOptions?: boolean;
4306
+ readOnly?: boolean;
4307
+ answerableCallback?: (arg1: boolean) => unknown;
4308
+ getAnotherHint?: () => unknown;
4309
+ interactionCallback?: (widgetData: {
4310
+ [widgetId: string]: any;
4311
+ }) => void;
4312
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
4313
+ imagePlaceholder?: React.ReactNode;
4314
+ widgetPlaceholder?: React.ReactNode;
4315
+ baseElements?: {
4316
+ Link: React.ComponentType<any>;
4317
+ };
4318
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
4319
+ trackInteraction?: (args: {
4320
+ type: string;
4321
+ id: string;
4322
+ correct?: boolean;
4323
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
4324
+ visible: number;
4325
+ }>) => void;
4326
+ customKeypad?: boolean;
4327
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
4328
+ isMobile?: boolean;
4329
+ isMobileApp?: boolean;
4330
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
4331
+ hintProgressColor?: string;
4332
+ canScrollPage?: boolean;
4333
+ editorChangeDelay?: number;
4334
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
4335
+ }> & {
4336
+ baseElements: NonNullable<import("@khanacademy/perseus").APIOptions["baseElements"]>;
4337
+ canScrollPage: NonNullable<import("@khanacademy/perseus").APIOptions["canScrollPage"]>;
4338
+ editorChangeDelay: NonNullable<import("@khanacademy/perseus").APIOptions["editorChangeDelay"]>;
4339
+ groupAnnotator: NonNullable<import("@khanacademy/perseus").APIOptions["groupAnnotator"]>;
4340
+ isArticle: NonNullable<import("@khanacademy/perseus").APIOptions["isArticle"]>;
4341
+ isMobile: NonNullable<import("@khanacademy/perseus").APIOptions["isMobile"]>;
4342
+ isMobileApp: NonNullable<import("@khanacademy/perseus").APIOptions["isMobileApp"]>;
4343
+ onFocusChange: NonNullable<import("@khanacademy/perseus").APIOptions["onFocusChange"]>;
4344
+ readOnly: NonNullable<import("@khanacademy/perseus").APIOptions["readOnly"]>;
4345
+ setDrawingAreaAvailable: NonNullable<import("@khanacademy/perseus").APIOptions["setDrawingAreaAvailable"]>;
4346
+ showAlignmentOptions: NonNullable<import("@khanacademy/perseus").APIOptions["showAlignmentOptions"]>;
4347
+ }>;
4348
+ keypadElement?: any;
4349
+ questionCompleted?: boolean;
4350
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
4351
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
4352
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
4353
+ reviewMode: boolean;
4354
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
4355
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
4356
+ userInput: PerseusGraphType;
4357
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
4358
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
4359
+ }): string;
1789
4360
  getAngleEquationString(props: {
1790
4361
  step: [number, number];
1791
4362
  gridStep?: [x: number, y: number];
@@ -1806,7 +4377,72 @@ declare const InteractiveGraph: {
1806
4377
  lockedFigures: LockedFigure[];
1807
4378
  fullGraphAriaLabel?: string;
1808
4379
  fullGraphAriaDescription?: string;
1809
- } & import("../../../../perseus/src/types").UniversalWidgetProps<PerseusGraphType, Empty>): string;
4380
+ } & {
4381
+ trackInteraction: (extraData?: Empty | undefined) => void;
4382
+ widgetId: string;
4383
+ widgetIndex: number;
4384
+ alignment: string | null | undefined;
4385
+ static: boolean | null | undefined;
4386
+ problemNum: number | null | undefined;
4387
+ apiOptions: Readonly<Readonly<{
4388
+ isArticle?: boolean;
4389
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
4390
+ GroupMetadataEditor?: React.ComponentType<any>;
4391
+ showAlignmentOptions?: boolean;
4392
+ readOnly?: boolean;
4393
+ answerableCallback?: (arg1: boolean) => unknown;
4394
+ getAnotherHint?: () => unknown;
4395
+ interactionCallback?: (widgetData: {
4396
+ [widgetId: string]: any;
4397
+ }) => void;
4398
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
4399
+ imagePlaceholder?: React.ReactNode;
4400
+ widgetPlaceholder?: React.ReactNode;
4401
+ baseElements?: {
4402
+ Link: React.ComponentType<any>;
4403
+ };
4404
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
4405
+ trackInteraction?: (args: {
4406
+ type: string;
4407
+ id: string;
4408
+ correct?: boolean;
4409
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
4410
+ visible: number;
4411
+ }>) => void;
4412
+ customKeypad?: boolean;
4413
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
4414
+ isMobile?: boolean;
4415
+ isMobileApp?: boolean;
4416
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
4417
+ hintProgressColor?: string;
4418
+ canScrollPage?: boolean;
4419
+ editorChangeDelay?: number;
4420
+ flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
4421
+ }> & {
4422
+ baseElements: NonNullable<import("@khanacademy/perseus").APIOptions["baseElements"]>;
4423
+ canScrollPage: NonNullable<import("@khanacademy/perseus").APIOptions["canScrollPage"]>;
4424
+ editorChangeDelay: NonNullable<import("@khanacademy/perseus").APIOptions["editorChangeDelay"]>;
4425
+ groupAnnotator: NonNullable<import("@khanacademy/perseus").APIOptions["groupAnnotator"]>;
4426
+ isArticle: NonNullable<import("@khanacademy/perseus").APIOptions["isArticle"]>;
4427
+ isMobile: NonNullable<import("@khanacademy/perseus").APIOptions["isMobile"]>;
4428
+ isMobileApp: NonNullable<import("@khanacademy/perseus").APIOptions["isMobileApp"]>;
4429
+ onFocusChange: NonNullable<import("@khanacademy/perseus").APIOptions["onFocusChange"]>;
4430
+ readOnly: NonNullable<import("@khanacademy/perseus").APIOptions["readOnly"]>;
4431
+ setDrawingAreaAvailable: NonNullable<import("@khanacademy/perseus").APIOptions["setDrawingAreaAvailable"]>;
4432
+ showAlignmentOptions: NonNullable<import("@khanacademy/perseus").APIOptions["showAlignmentOptions"]>;
4433
+ }>;
4434
+ keypadElement?: any;
4435
+ questionCompleted?: boolean;
4436
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
4437
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
4438
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
4439
+ reviewMode: boolean;
4440
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
4441
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
4442
+ userInput: PerseusGraphType;
4443
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
4444
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
4445
+ }): string;
1810
4446
  contextType?: React.Context<any> | undefined;
1811
4447
  };
1812
4448
  type InteractiveGraphProps = PropsFor<typeof InteractiveGraph>;