@khanacademy/perseus-editor 25.1.1 → 25.2.0

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 (11) hide show
  1. package/dist/es/index.js +15 -15
  2. package/dist/es/index.js.map +1 -1
  3. package/dist/index.js +14 -14
  4. package/dist/index.js.map +1 -1
  5. package/dist/widgets/expression-editor.d.ts +2 -3
  6. package/dist/widgets/group-editor.d.ts +0 -2
  7. package/dist/widgets/interactive-graph-editor/interactive-graph-editor.d.ts +984 -62
  8. package/dist/widgets/matrix-editor.d.ts +1 -1
  9. package/dist/widgets/radio/editor.d.ts +1 -3
  10. package/dist/widgets/video-editor.d.ts +0 -1
  11. package/package.json +43 -43
package/dist/widgets/interactive-graph-editor/interactive-graph-editor.d.ts CHANGED
@@ -22,10 +22,481 @@ declare const InteractiveGraph: {
22
22
  lockedFigures: LockedFigure[];
23
23
  fullGraphAriaLabel?: string;
24
24
  fullGraphAriaDescription?: string;
25
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>): {
25
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>): {
26
26
  mafsRef: React.RefObject<import("../../../../perseus/src/widgets/interactive-graphs/stateful-mafs-graph").StatefulMafsGraphType>;
27
27
  getUserInput(): import("@khanacademy/perseus-core").PerseusInteractiveGraphUserInput;
28
28
  getPromptJSON(): import("../../../../perseus/src/widget-ai-utils/interactive-graph/interactive-graph-ai-utils").InteractiveGraphPromptJSON | import("../../../../perseus/src/widget-ai-utils/unsupported-widget").UnsupportedWidgetPromptJSON;
29
+ getSerializedState(): {
30
+ graph: PerseusGraphType;
31
+ step: [number, number];
32
+ gridStep?: [x: number, y: number];
33
+ snapStep?: [x: number, y: number];
34
+ backgroundImage?: PerseusImageBackground;
35
+ markings: MarkingsType;
36
+ labels: string[];
37
+ labelLocation: AxisLabelLocation;
38
+ showProtractor: boolean;
39
+ showRuler?: boolean;
40
+ showTooltips?: boolean;
41
+ rulerLabel?: string;
42
+ rulerTicks?: number;
43
+ range: import("@khanacademy/perseus-core").GraphRange;
44
+ correct?: PerseusGraphType;
45
+ lockedFigures: LockedFigure[];
46
+ fullGraphAriaLabel?: string;
47
+ fullGraphAriaDescription?: string;
48
+ reviewModeRubric?: Empty | null | undefined;
49
+ trackInteraction: (extraData?: Empty | undefined) => void;
50
+ widgetId: string;
51
+ alignment: string | null | undefined;
52
+ static: boolean | null | undefined;
53
+ problemNum: number | null | undefined;
54
+ apiOptions: Readonly<Readonly<{
55
+ isArticle?: boolean;
56
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
57
+ GroupMetadataEditor?: React.ComponentType<any>;
58
+ showAlignmentOptions?: boolean;
59
+ readOnly?: boolean;
60
+ answerableCallback?: (arg1: boolean) => unknown;
61
+ getAnotherHint?: () => unknown;
62
+ interactionCallback?: (widgetData: {
63
+ [widgetId: string]: any;
64
+ }) => void;
65
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
66
+ imagePlaceholder?: React.ReactNode;
67
+ widgetPlaceholder?: React.ReactNode;
68
+ baseElements?: {
69
+ Link: React.ComponentType<any>;
70
+ };
71
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
72
+ trackInteraction?: (args: {
73
+ type: string;
74
+ id: string;
75
+ correct?: boolean;
76
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
77
+ visible: number;
78
+ }>) => void;
79
+ customKeypad?: boolean;
80
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
81
+ isMobile?: boolean;
82
+ isMobileApp?: boolean;
83
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
84
+ hintProgressColor?: string;
85
+ canScrollPage?: boolean;
86
+ editorChangeDelay?: number;
87
+ flags?: Record<"new-radio-widget", boolean>;
88
+ onWidgetStartProps?: (widgets: import("@khanacademy/perseus-core").PerseusWidgetsMap) => void;
89
+ }> & {
90
+ baseElements: NonNullable<Readonly<{
91
+ isArticle?: boolean;
92
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
93
+ GroupMetadataEditor?: React.ComponentType<any>;
94
+ showAlignmentOptions?: boolean;
95
+ readOnly?: boolean;
96
+ answerableCallback?: (arg1: boolean) => unknown;
97
+ getAnotherHint?: () => unknown;
98
+ interactionCallback?: (widgetData: {
99
+ [widgetId: string]: any;
100
+ }) => void;
101
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
102
+ imagePlaceholder?: React.ReactNode;
103
+ widgetPlaceholder?: React.ReactNode;
104
+ baseElements?: {
105
+ Link: React.ComponentType<any>;
106
+ };
107
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
108
+ trackInteraction?: (args: {
109
+ type: string;
110
+ id: string;
111
+ correct?: boolean;
112
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
113
+ visible: number;
114
+ }>) => void;
115
+ customKeypad?: boolean;
116
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
117
+ isMobile?: boolean;
118
+ isMobileApp?: boolean;
119
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
120
+ hintProgressColor?: string;
121
+ canScrollPage?: boolean;
122
+ editorChangeDelay?: number;
123
+ flags?: Record<"new-radio-widget", boolean>;
124
+ onWidgetStartProps?: (widgets: import("@khanacademy/perseus-core").PerseusWidgetsMap) => void;
125
+ }>["baseElements"]>;
126
+ canScrollPage: NonNullable<Readonly<{
127
+ isArticle?: boolean;
128
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
129
+ GroupMetadataEditor?: React.ComponentType<any>;
130
+ showAlignmentOptions?: boolean;
131
+ readOnly?: boolean;
132
+ answerableCallback?: (arg1: boolean) => unknown;
133
+ getAnotherHint?: () => unknown;
134
+ interactionCallback?: (widgetData: {
135
+ [widgetId: string]: any;
136
+ }) => void;
137
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
138
+ imagePlaceholder?: React.ReactNode;
139
+ widgetPlaceholder?: React.ReactNode;
140
+ baseElements?: {
141
+ Link: React.ComponentType<any>;
142
+ };
143
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
144
+ trackInteraction?: (args: {
145
+ type: string;
146
+ id: string;
147
+ correct?: boolean;
148
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
149
+ visible: number;
150
+ }>) => void;
151
+ customKeypad?: boolean;
152
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
153
+ isMobile?: boolean;
154
+ isMobileApp?: boolean;
155
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
156
+ hintProgressColor?: string;
157
+ canScrollPage?: boolean;
158
+ editorChangeDelay?: number;
159
+ flags?: Record<"new-radio-widget", boolean>;
160
+ onWidgetStartProps?: (widgets: import("@khanacademy/perseus-core").PerseusWidgetsMap) => void;
161
+ }>["canScrollPage"]>;
162
+ editorChangeDelay: NonNullable<Readonly<{
163
+ isArticle?: boolean;
164
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
165
+ GroupMetadataEditor?: React.ComponentType<any>;
166
+ showAlignmentOptions?: boolean;
167
+ readOnly?: boolean;
168
+ answerableCallback?: (arg1: boolean) => unknown;
169
+ getAnotherHint?: () => unknown;
170
+ interactionCallback?: (widgetData: {
171
+ [widgetId: string]: any;
172
+ }) => void;
173
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
174
+ imagePlaceholder?: React.ReactNode;
175
+ widgetPlaceholder?: React.ReactNode;
176
+ baseElements?: {
177
+ Link: React.ComponentType<any>;
178
+ };
179
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
180
+ trackInteraction?: (args: {
181
+ type: string;
182
+ id: string;
183
+ correct?: boolean;
184
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
185
+ visible: number;
186
+ }>) => void;
187
+ customKeypad?: boolean;
188
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
189
+ isMobile?: boolean;
190
+ isMobileApp?: boolean;
191
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
192
+ hintProgressColor?: string;
193
+ canScrollPage?: boolean;
194
+ editorChangeDelay?: number;
195
+ flags?: Record<"new-radio-widget", boolean>;
196
+ onWidgetStartProps?: (widgets: import("@khanacademy/perseus-core").PerseusWidgetsMap) => void;
197
+ }>["editorChangeDelay"]>;
198
+ groupAnnotator: NonNullable<Readonly<{
199
+ isArticle?: boolean;
200
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
201
+ GroupMetadataEditor?: React.ComponentType<any>;
202
+ showAlignmentOptions?: boolean;
203
+ readOnly?: boolean;
204
+ answerableCallback?: (arg1: boolean) => unknown;
205
+ getAnotherHint?: () => unknown;
206
+ interactionCallback?: (widgetData: {
207
+ [widgetId: string]: any;
208
+ }) => void;
209
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
210
+ imagePlaceholder?: React.ReactNode;
211
+ widgetPlaceholder?: React.ReactNode;
212
+ baseElements?: {
213
+ Link: React.ComponentType<any>;
214
+ };
215
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
216
+ trackInteraction?: (args: {
217
+ type: string;
218
+ id: string;
219
+ correct?: boolean;
220
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
221
+ visible: number;
222
+ }>) => void;
223
+ customKeypad?: boolean;
224
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
225
+ isMobile?: boolean;
226
+ isMobileApp?: boolean;
227
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
228
+ hintProgressColor?: string;
229
+ canScrollPage?: boolean;
230
+ editorChangeDelay?: number;
231
+ flags?: Record<"new-radio-widget", boolean>;
232
+ onWidgetStartProps?: (widgets: import("@khanacademy/perseus-core").PerseusWidgetsMap) => void;
233
+ }>["groupAnnotator"]>;
234
+ isArticle: NonNullable<Readonly<{
235
+ isArticle?: boolean;
236
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
237
+ GroupMetadataEditor?: React.ComponentType<any>;
238
+ showAlignmentOptions?: boolean;
239
+ readOnly?: boolean;
240
+ answerableCallback?: (arg1: boolean) => unknown;
241
+ getAnotherHint?: () => unknown;
242
+ interactionCallback?: (widgetData: {
243
+ [widgetId: string]: any;
244
+ }) => void;
245
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
246
+ imagePlaceholder?: React.ReactNode;
247
+ widgetPlaceholder?: React.ReactNode;
248
+ baseElements?: {
249
+ Link: React.ComponentType<any>;
250
+ };
251
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
252
+ trackInteraction?: (args: {
253
+ type: string;
254
+ id: string;
255
+ correct?: boolean;
256
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
257
+ visible: number;
258
+ }>) => void;
259
+ customKeypad?: boolean;
260
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
261
+ isMobile?: boolean;
262
+ isMobileApp?: boolean;
263
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
264
+ hintProgressColor?: string;
265
+ canScrollPage?: boolean;
266
+ editorChangeDelay?: number;
267
+ flags?: Record<"new-radio-widget", boolean>;
268
+ onWidgetStartProps?: (widgets: import("@khanacademy/perseus-core").PerseusWidgetsMap) => void;
269
+ }>["isArticle"]>;
270
+ isMobile: NonNullable<Readonly<{
271
+ isArticle?: boolean;
272
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
273
+ GroupMetadataEditor?: React.ComponentType<any>;
274
+ showAlignmentOptions?: boolean;
275
+ readOnly?: boolean;
276
+ answerableCallback?: (arg1: boolean) => unknown;
277
+ getAnotherHint?: () => unknown;
278
+ interactionCallback?: (widgetData: {
279
+ [widgetId: string]: any;
280
+ }) => void;
281
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
282
+ imagePlaceholder?: React.ReactNode;
283
+ widgetPlaceholder?: React.ReactNode;
284
+ baseElements?: {
285
+ Link: React.ComponentType<any>;
286
+ };
287
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
288
+ trackInteraction?: (args: {
289
+ type: string;
290
+ id: string;
291
+ correct?: boolean;
292
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
293
+ visible: number;
294
+ }>) => void;
295
+ customKeypad?: boolean;
296
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
297
+ isMobile?: boolean;
298
+ isMobileApp?: boolean;
299
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
300
+ hintProgressColor?: string;
301
+ canScrollPage?: boolean;
302
+ editorChangeDelay?: number;
303
+ flags?: Record<"new-radio-widget", boolean>;
304
+ onWidgetStartProps?: (widgets: import("@khanacademy/perseus-core").PerseusWidgetsMap) => void;
305
+ }>["isMobile"]>;
306
+ isMobileApp: NonNullable<Readonly<{
307
+ isArticle?: boolean;
308
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
309
+ GroupMetadataEditor?: React.ComponentType<any>;
310
+ showAlignmentOptions?: boolean;
311
+ readOnly?: boolean;
312
+ answerableCallback?: (arg1: boolean) => unknown;
313
+ getAnotherHint?: () => unknown;
314
+ interactionCallback?: (widgetData: {
315
+ [widgetId: string]: any;
316
+ }) => void;
317
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
318
+ imagePlaceholder?: React.ReactNode;
319
+ widgetPlaceholder?: React.ReactNode;
320
+ baseElements?: {
321
+ Link: React.ComponentType<any>;
322
+ };
323
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
324
+ trackInteraction?: (args: {
325
+ type: string;
326
+ id: string;
327
+ correct?: boolean;
328
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
329
+ visible: number;
330
+ }>) => void;
331
+ customKeypad?: boolean;
332
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
333
+ isMobile?: boolean;
334
+ isMobileApp?: boolean;
335
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
336
+ hintProgressColor?: string;
337
+ canScrollPage?: boolean;
338
+ editorChangeDelay?: number;
339
+ flags?: Record<"new-radio-widget", boolean>;
340
+ onWidgetStartProps?: (widgets: import("@khanacademy/perseus-core").PerseusWidgetsMap) => void;
341
+ }>["isMobileApp"]>;
342
+ onFocusChange: NonNullable<Readonly<{
343
+ isArticle?: boolean;
344
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
345
+ GroupMetadataEditor?: React.ComponentType<any>;
346
+ showAlignmentOptions?: boolean;
347
+ readOnly?: boolean;
348
+ answerableCallback?: (arg1: boolean) => unknown;
349
+ getAnotherHint?: () => unknown;
350
+ interactionCallback?: (widgetData: {
351
+ [widgetId: string]: any;
352
+ }) => void;
353
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
354
+ imagePlaceholder?: React.ReactNode;
355
+ widgetPlaceholder?: React.ReactNode;
356
+ baseElements?: {
357
+ Link: React.ComponentType<any>;
358
+ };
359
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
360
+ trackInteraction?: (args: {
361
+ type: string;
362
+ id: string;
363
+ correct?: boolean;
364
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
365
+ visible: number;
366
+ }>) => void;
367
+ customKeypad?: boolean;
368
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
369
+ isMobile?: boolean;
370
+ isMobileApp?: boolean;
371
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
372
+ hintProgressColor?: string;
373
+ canScrollPage?: boolean;
374
+ editorChangeDelay?: number;
375
+ flags?: Record<"new-radio-widget", boolean>;
376
+ onWidgetStartProps?: (widgets: import("@khanacademy/perseus-core").PerseusWidgetsMap) => void;
377
+ }>["onFocusChange"]>;
378
+ readOnly: NonNullable<Readonly<{
379
+ isArticle?: boolean;
380
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
381
+ GroupMetadataEditor?: React.ComponentType<any>;
382
+ showAlignmentOptions?: boolean;
383
+ readOnly?: boolean;
384
+ answerableCallback?: (arg1: boolean) => unknown;
385
+ getAnotherHint?: () => unknown;
386
+ interactionCallback?: (widgetData: {
387
+ [widgetId: string]: any;
388
+ }) => void;
389
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
390
+ imagePlaceholder?: React.ReactNode;
391
+ widgetPlaceholder?: React.ReactNode;
392
+ baseElements?: {
393
+ Link: React.ComponentType<any>;
394
+ };
395
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
396
+ trackInteraction?: (args: {
397
+ type: string;
398
+ id: string;
399
+ correct?: boolean;
400
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
401
+ visible: number;
402
+ }>) => void;
403
+ customKeypad?: boolean;
404
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
405
+ isMobile?: boolean;
406
+ isMobileApp?: boolean;
407
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
408
+ hintProgressColor?: string;
409
+ canScrollPage?: boolean;
410
+ editorChangeDelay?: number;
411
+ flags?: Record<"new-radio-widget", boolean>;
412
+ onWidgetStartProps?: (widgets: import("@khanacademy/perseus-core").PerseusWidgetsMap) => void;
413
+ }>["readOnly"]>;
414
+ setDrawingAreaAvailable: NonNullable<Readonly<{
415
+ isArticle?: boolean;
416
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
417
+ GroupMetadataEditor?: React.ComponentType<any>;
418
+ showAlignmentOptions?: boolean;
419
+ readOnly?: boolean;
420
+ answerableCallback?: (arg1: boolean) => unknown;
421
+ getAnotherHint?: () => unknown;
422
+ interactionCallback?: (widgetData: {
423
+ [widgetId: string]: any;
424
+ }) => void;
425
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
426
+ imagePlaceholder?: React.ReactNode;
427
+ widgetPlaceholder?: React.ReactNode;
428
+ baseElements?: {
429
+ Link: React.ComponentType<any>;
430
+ };
431
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
432
+ trackInteraction?: (args: {
433
+ type: string;
434
+ id: string;
435
+ correct?: boolean;
436
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
437
+ visible: number;
438
+ }>) => void;
439
+ customKeypad?: boolean;
440
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
441
+ isMobile?: boolean;
442
+ isMobileApp?: boolean;
443
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
444
+ hintProgressColor?: string;
445
+ canScrollPage?: boolean;
446
+ editorChangeDelay?: number;
447
+ flags?: Record<"new-radio-widget", boolean>;
448
+ onWidgetStartProps?: (widgets: import("@khanacademy/perseus-core").PerseusWidgetsMap) => void;
449
+ }>["setDrawingAreaAvailable"]>;
450
+ showAlignmentOptions: NonNullable<Readonly<{
451
+ isArticle?: boolean;
452
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
453
+ GroupMetadataEditor?: React.ComponentType<any>;
454
+ showAlignmentOptions?: boolean;
455
+ readOnly?: boolean;
456
+ answerableCallback?: (arg1: boolean) => unknown;
457
+ getAnotherHint?: () => unknown;
458
+ interactionCallback?: (widgetData: {
459
+ [widgetId: string]: any;
460
+ }) => void;
461
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
462
+ imagePlaceholder?: React.ReactNode;
463
+ widgetPlaceholder?: React.ReactNode;
464
+ baseElements?: {
465
+ Link: React.ComponentType<any>;
466
+ };
467
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
468
+ trackInteraction?: (args: {
469
+ type: string;
470
+ id: string;
471
+ correct?: boolean;
472
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
473
+ visible: number;
474
+ }>) => void;
475
+ customKeypad?: boolean;
476
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
477
+ isMobile?: boolean;
478
+ isMobileApp?: boolean;
479
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
480
+ hintProgressColor?: string;
481
+ canScrollPage?: boolean;
482
+ editorChangeDelay?: number;
483
+ flags?: Record<"new-radio-widget", boolean>;
484
+ onWidgetStartProps?: (widgets: import("@khanacademy/perseus-core").PerseusWidgetsMap) => void;
485
+ }>["showAlignmentOptions"]>;
486
+ }>;
487
+ keypadElement?: any;
488
+ questionCompleted?: boolean;
489
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
490
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
491
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
492
+ reviewMode: boolean;
493
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
494
+ onChange: import("@khanacademy/perseus").ChangeHandler;
495
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
496
+ isLastUsedWidget: boolean;
497
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
498
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
499
+ };
29
500
  render(): React.JSX.Element;
30
501
  context: unknown;
31
502
  setState<K extends string | number | symbol>(state: any, callback?: (() => void) | undefined): void;
@@ -49,7 +520,7 @@ declare const InteractiveGraph: {
49
520
  lockedFigures: LockedFigure[];
50
521
  fullGraphAriaLabel?: string;
51
522
  fullGraphAriaDescription?: string;
52
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>>;
523
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>>;
53
524
  state: Readonly<any>;
54
525
  refs: {
55
526
  [key: string]: React.ReactInstance;
@@ -74,7 +545,7 @@ declare const InteractiveGraph: {
74
545
  lockedFigures: LockedFigure[];
75
546
  fullGraphAriaLabel?: string;
76
547
  fullGraphAriaDescription?: string;
77
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>>, nextState: Readonly<any>, nextContext: any): boolean;
548
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>>, nextState: Readonly<any>, nextContext: any): boolean;
78
549
  componentWillUnmount?(): void;
79
550
  componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
80
551
  getSnapshotBeforeUpdate?(prevProps: Readonly<{
@@ -96,7 +567,7 @@ declare const InteractiveGraph: {
96
567
  lockedFigures: LockedFigure[];
97
568
  fullGraphAriaLabel?: string;
98
569
  fullGraphAriaDescription?: string;
99
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>>, prevState: Readonly<any>): any;
570
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>>, prevState: Readonly<any>): any;
100
571
  componentDidUpdate?(prevProps: Readonly<{
101
572
  step: [number, number];
102
573
  gridStep?: [x: number, y: number];
@@ -116,7 +587,7 @@ declare const InteractiveGraph: {
116
587
  lockedFigures: LockedFigure[];
117
588
  fullGraphAriaLabel?: string;
118
589
  fullGraphAriaDescription?: string;
119
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>>, prevState: Readonly<any>, snapshot?: any): void;
590
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>>, prevState: Readonly<any>, snapshot?: any): void;
120
591
  componentWillMount?(): void;
121
592
  UNSAFE_componentWillMount?(): void;
122
593
  componentWillReceiveProps?(nextProps: Readonly<{
@@ -138,7 +609,7 @@ declare const InteractiveGraph: {
138
609
  lockedFigures: LockedFigure[];
139
610
  fullGraphAriaLabel?: string;
140
611
  fullGraphAriaDescription?: string;
141
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>>, nextContext: any): void;
612
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>>, nextContext: any): void;
142
613
  UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{
143
614
  step: [number, number];
144
615
  gridStep?: [x: number, y: number];
@@ -158,7 +629,7 @@ declare const InteractiveGraph: {
158
629
  lockedFigures: LockedFigure[];
159
630
  fullGraphAriaLabel?: string;
160
631
  fullGraphAriaDescription?: string;
161
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>>, nextContext: any): void;
632
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>>, nextContext: any): void;
162
633
  componentWillUpdate?(nextProps: Readonly<{
163
634
  step: [number, number];
164
635
  gridStep?: [x: number, y: number];
@@ -178,7 +649,7 @@ declare const InteractiveGraph: {
178
649
  lockedFigures: LockedFigure[];
179
650
  fullGraphAriaLabel?: string;
180
651
  fullGraphAriaDescription?: string;
181
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>>, nextState: Readonly<any>, nextContext: any): void;
652
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>>, nextState: Readonly<any>, nextContext: any): void;
182
653
  UNSAFE_componentWillUpdate?(nextProps: Readonly<{
183
654
  step: [number, number];
184
655
  gridStep?: [x: number, y: number];
@@ -198,7 +669,7 @@ declare const InteractiveGraph: {
198
669
  lockedFigures: LockedFigure[];
199
670
  fullGraphAriaLabel?: string;
200
671
  fullGraphAriaDescription?: string;
201
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>>, nextState: Readonly<any>, nextContext: any): void;
672
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>>, nextState: Readonly<any>, nextContext: any): void;
202
673
  };
203
674
  new (props: {
204
675
  step: [number, number];
@@ -219,10 +690,481 @@ declare const InteractiveGraph: {
219
690
  lockedFigures: LockedFigure[];
220
691
  fullGraphAriaLabel?: string;
221
692
  fullGraphAriaDescription?: string;
222
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>, context: any): {
693
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>, context: any): {
223
694
  mafsRef: React.RefObject<import("../../../../perseus/src/widgets/interactive-graphs/stateful-mafs-graph").StatefulMafsGraphType>;
224
695
  getUserInput(): import("@khanacademy/perseus-core").PerseusInteractiveGraphUserInput;
225
696
  getPromptJSON(): import("../../../../perseus/src/widget-ai-utils/interactive-graph/interactive-graph-ai-utils").InteractiveGraphPromptJSON | import("../../../../perseus/src/widget-ai-utils/unsupported-widget").UnsupportedWidgetPromptJSON;
697
+ getSerializedState(): {
698
+ graph: PerseusGraphType;
699
+ step: [number, number];
700
+ gridStep?: [x: number, y: number];
701
+ snapStep?: [x: number, y: number];
702
+ backgroundImage?: PerseusImageBackground;
703
+ markings: MarkingsType;
704
+ labels: string[];
705
+ labelLocation: AxisLabelLocation;
706
+ showProtractor: boolean;
707
+ showRuler?: boolean;
708
+ showTooltips?: boolean;
709
+ rulerLabel?: string;
710
+ rulerTicks?: number;
711
+ range: import("@khanacademy/perseus-core").GraphRange;
712
+ correct?: PerseusGraphType;
713
+ lockedFigures: LockedFigure[];
714
+ fullGraphAriaLabel?: string;
715
+ fullGraphAriaDescription?: string;
716
+ reviewModeRubric?: Empty | null | undefined;
717
+ trackInteraction: (extraData?: Empty | undefined) => void;
718
+ widgetId: string;
719
+ alignment: string | null | undefined;
720
+ static: boolean | null | undefined;
721
+ problemNum: number | null | undefined;
722
+ apiOptions: Readonly<Readonly<{
723
+ isArticle?: boolean;
724
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
725
+ GroupMetadataEditor?: React.ComponentType<any>;
726
+ showAlignmentOptions?: boolean;
727
+ readOnly?: boolean;
728
+ answerableCallback?: (arg1: boolean) => unknown;
729
+ getAnotherHint?: () => unknown;
730
+ interactionCallback?: (widgetData: {
731
+ [widgetId: string]: any;
732
+ }) => void;
733
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
734
+ imagePlaceholder?: React.ReactNode;
735
+ widgetPlaceholder?: React.ReactNode;
736
+ baseElements?: {
737
+ Link: React.ComponentType<any>;
738
+ };
739
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
740
+ trackInteraction?: (args: {
741
+ type: string;
742
+ id: string;
743
+ correct?: boolean;
744
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
745
+ visible: number;
746
+ }>) => void;
747
+ customKeypad?: boolean;
748
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
749
+ isMobile?: boolean;
750
+ isMobileApp?: boolean;
751
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
752
+ hintProgressColor?: string;
753
+ canScrollPage?: boolean;
754
+ editorChangeDelay?: number;
755
+ flags?: Record<"new-radio-widget", boolean>;
756
+ onWidgetStartProps?: (widgets: import("@khanacademy/perseus-core").PerseusWidgetsMap) => void;
757
+ }> & {
758
+ baseElements: NonNullable<Readonly<{
759
+ isArticle?: boolean;
760
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
761
+ GroupMetadataEditor?: React.ComponentType<any>;
762
+ showAlignmentOptions?: boolean;
763
+ readOnly?: boolean;
764
+ answerableCallback?: (arg1: boolean) => unknown;
765
+ getAnotherHint?: () => unknown;
766
+ interactionCallback?: (widgetData: {
767
+ [widgetId: string]: any;
768
+ }) => void;
769
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
770
+ imagePlaceholder?: React.ReactNode;
771
+ widgetPlaceholder?: React.ReactNode;
772
+ baseElements?: {
773
+ Link: React.ComponentType<any>;
774
+ };
775
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
776
+ trackInteraction?: (args: {
777
+ type: string;
778
+ id: string;
779
+ correct?: boolean;
780
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
781
+ visible: number;
782
+ }>) => void;
783
+ customKeypad?: boolean;
784
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
785
+ isMobile?: boolean;
786
+ isMobileApp?: boolean;
787
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
788
+ hintProgressColor?: string;
789
+ canScrollPage?: boolean;
790
+ editorChangeDelay?: number;
791
+ flags?: Record<"new-radio-widget", boolean>;
792
+ onWidgetStartProps?: (widgets: import("@khanacademy/perseus-core").PerseusWidgetsMap) => void;
793
+ }>["baseElements"]>;
794
+ canScrollPage: NonNullable<Readonly<{
795
+ isArticle?: boolean;
796
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
797
+ GroupMetadataEditor?: React.ComponentType<any>;
798
+ showAlignmentOptions?: boolean;
799
+ readOnly?: boolean;
800
+ answerableCallback?: (arg1: boolean) => unknown;
801
+ getAnotherHint?: () => unknown;
802
+ interactionCallback?: (widgetData: {
803
+ [widgetId: string]: any;
804
+ }) => void;
805
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
806
+ imagePlaceholder?: React.ReactNode;
807
+ widgetPlaceholder?: React.ReactNode;
808
+ baseElements?: {
809
+ Link: React.ComponentType<any>;
810
+ };
811
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
812
+ trackInteraction?: (args: {
813
+ type: string;
814
+ id: string;
815
+ correct?: boolean;
816
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
817
+ visible: number;
818
+ }>) => void;
819
+ customKeypad?: boolean;
820
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
821
+ isMobile?: boolean;
822
+ isMobileApp?: boolean;
823
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
824
+ hintProgressColor?: string;
825
+ canScrollPage?: boolean;
826
+ editorChangeDelay?: number;
827
+ flags?: Record<"new-radio-widget", boolean>;
828
+ onWidgetStartProps?: (widgets: import("@khanacademy/perseus-core").PerseusWidgetsMap) => void;
829
+ }>["canScrollPage"]>;
830
+ editorChangeDelay: NonNullable<Readonly<{
831
+ isArticle?: boolean;
832
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
833
+ GroupMetadataEditor?: React.ComponentType<any>;
834
+ showAlignmentOptions?: boolean;
835
+ readOnly?: boolean;
836
+ answerableCallback?: (arg1: boolean) => unknown;
837
+ getAnotherHint?: () => unknown;
838
+ interactionCallback?: (widgetData: {
839
+ [widgetId: string]: any;
840
+ }) => void;
841
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
842
+ imagePlaceholder?: React.ReactNode;
843
+ widgetPlaceholder?: React.ReactNode;
844
+ baseElements?: {
845
+ Link: React.ComponentType<any>;
846
+ };
847
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
848
+ trackInteraction?: (args: {
849
+ type: string;
850
+ id: string;
851
+ correct?: boolean;
852
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
853
+ visible: number;
854
+ }>) => void;
855
+ customKeypad?: boolean;
856
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
857
+ isMobile?: boolean;
858
+ isMobileApp?: boolean;
859
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
860
+ hintProgressColor?: string;
861
+ canScrollPage?: boolean;
862
+ editorChangeDelay?: number;
863
+ flags?: Record<"new-radio-widget", boolean>;
864
+ onWidgetStartProps?: (widgets: import("@khanacademy/perseus-core").PerseusWidgetsMap) => void;
865
+ }>["editorChangeDelay"]>;
866
+ groupAnnotator: NonNullable<Readonly<{
867
+ isArticle?: boolean;
868
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
869
+ GroupMetadataEditor?: React.ComponentType<any>;
870
+ showAlignmentOptions?: boolean;
871
+ readOnly?: boolean;
872
+ answerableCallback?: (arg1: boolean) => unknown;
873
+ getAnotherHint?: () => unknown;
874
+ interactionCallback?: (widgetData: {
875
+ [widgetId: string]: any;
876
+ }) => void;
877
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
878
+ imagePlaceholder?: React.ReactNode;
879
+ widgetPlaceholder?: React.ReactNode;
880
+ baseElements?: {
881
+ Link: React.ComponentType<any>;
882
+ };
883
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
884
+ trackInteraction?: (args: {
885
+ type: string;
886
+ id: string;
887
+ correct?: boolean;
888
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
889
+ visible: number;
890
+ }>) => void;
891
+ customKeypad?: boolean;
892
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
893
+ isMobile?: boolean;
894
+ isMobileApp?: boolean;
895
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
896
+ hintProgressColor?: string;
897
+ canScrollPage?: boolean;
898
+ editorChangeDelay?: number;
899
+ flags?: Record<"new-radio-widget", boolean>;
900
+ onWidgetStartProps?: (widgets: import("@khanacademy/perseus-core").PerseusWidgetsMap) => void;
901
+ }>["groupAnnotator"]>;
902
+ isArticle: NonNullable<Readonly<{
903
+ isArticle?: boolean;
904
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
905
+ GroupMetadataEditor?: React.ComponentType<any>;
906
+ showAlignmentOptions?: boolean;
907
+ readOnly?: boolean;
908
+ answerableCallback?: (arg1: boolean) => unknown;
909
+ getAnotherHint?: () => unknown;
910
+ interactionCallback?: (widgetData: {
911
+ [widgetId: string]: any;
912
+ }) => void;
913
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
914
+ imagePlaceholder?: React.ReactNode;
915
+ widgetPlaceholder?: React.ReactNode;
916
+ baseElements?: {
917
+ Link: React.ComponentType<any>;
918
+ };
919
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
920
+ trackInteraction?: (args: {
921
+ type: string;
922
+ id: string;
923
+ correct?: boolean;
924
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
925
+ visible: number;
926
+ }>) => void;
927
+ customKeypad?: boolean;
928
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
929
+ isMobile?: boolean;
930
+ isMobileApp?: boolean;
931
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
932
+ hintProgressColor?: string;
933
+ canScrollPage?: boolean;
934
+ editorChangeDelay?: number;
935
+ flags?: Record<"new-radio-widget", boolean>;
936
+ onWidgetStartProps?: (widgets: import("@khanacademy/perseus-core").PerseusWidgetsMap) => void;
937
+ }>["isArticle"]>;
938
+ isMobile: NonNullable<Readonly<{
939
+ isArticle?: boolean;
940
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
941
+ GroupMetadataEditor?: React.ComponentType<any>;
942
+ showAlignmentOptions?: boolean;
943
+ readOnly?: boolean;
944
+ answerableCallback?: (arg1: boolean) => unknown;
945
+ getAnotherHint?: () => unknown;
946
+ interactionCallback?: (widgetData: {
947
+ [widgetId: string]: any;
948
+ }) => void;
949
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
950
+ imagePlaceholder?: React.ReactNode;
951
+ widgetPlaceholder?: React.ReactNode;
952
+ baseElements?: {
953
+ Link: React.ComponentType<any>;
954
+ };
955
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
956
+ trackInteraction?: (args: {
957
+ type: string;
958
+ id: string;
959
+ correct?: boolean;
960
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
961
+ visible: number;
962
+ }>) => void;
963
+ customKeypad?: boolean;
964
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
965
+ isMobile?: boolean;
966
+ isMobileApp?: boolean;
967
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
968
+ hintProgressColor?: string;
969
+ canScrollPage?: boolean;
970
+ editorChangeDelay?: number;
971
+ flags?: Record<"new-radio-widget", boolean>;
972
+ onWidgetStartProps?: (widgets: import("@khanacademy/perseus-core").PerseusWidgetsMap) => void;
973
+ }>["isMobile"]>;
974
+ isMobileApp: NonNullable<Readonly<{
975
+ isArticle?: boolean;
976
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
977
+ GroupMetadataEditor?: React.ComponentType<any>;
978
+ showAlignmentOptions?: boolean;
979
+ readOnly?: boolean;
980
+ answerableCallback?: (arg1: boolean) => unknown;
981
+ getAnotherHint?: () => unknown;
982
+ interactionCallback?: (widgetData: {
983
+ [widgetId: string]: any;
984
+ }) => void;
985
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
986
+ imagePlaceholder?: React.ReactNode;
987
+ widgetPlaceholder?: React.ReactNode;
988
+ baseElements?: {
989
+ Link: React.ComponentType<any>;
990
+ };
991
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
992
+ trackInteraction?: (args: {
993
+ type: string;
994
+ id: string;
995
+ correct?: boolean;
996
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
997
+ visible: number;
998
+ }>) => void;
999
+ customKeypad?: boolean;
1000
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
1001
+ isMobile?: boolean;
1002
+ isMobileApp?: boolean;
1003
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
1004
+ hintProgressColor?: string;
1005
+ canScrollPage?: boolean;
1006
+ editorChangeDelay?: number;
1007
+ flags?: Record<"new-radio-widget", boolean>;
1008
+ onWidgetStartProps?: (widgets: import("@khanacademy/perseus-core").PerseusWidgetsMap) => void;
1009
+ }>["isMobileApp"]>;
1010
+ onFocusChange: NonNullable<Readonly<{
1011
+ isArticle?: boolean;
1012
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
1013
+ GroupMetadataEditor?: React.ComponentType<any>;
1014
+ showAlignmentOptions?: boolean;
1015
+ readOnly?: boolean;
1016
+ answerableCallback?: (arg1: boolean) => unknown;
1017
+ getAnotherHint?: () => unknown;
1018
+ interactionCallback?: (widgetData: {
1019
+ [widgetId: string]: any;
1020
+ }) => void;
1021
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
1022
+ imagePlaceholder?: React.ReactNode;
1023
+ widgetPlaceholder?: React.ReactNode;
1024
+ baseElements?: {
1025
+ Link: React.ComponentType<any>;
1026
+ };
1027
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
1028
+ trackInteraction?: (args: {
1029
+ type: string;
1030
+ id: string;
1031
+ correct?: boolean;
1032
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
1033
+ visible: number;
1034
+ }>) => void;
1035
+ customKeypad?: boolean;
1036
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
1037
+ isMobile?: boolean;
1038
+ isMobileApp?: boolean;
1039
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
1040
+ hintProgressColor?: string;
1041
+ canScrollPage?: boolean;
1042
+ editorChangeDelay?: number;
1043
+ flags?: Record<"new-radio-widget", boolean>;
1044
+ onWidgetStartProps?: (widgets: import("@khanacademy/perseus-core").PerseusWidgetsMap) => void;
1045
+ }>["onFocusChange"]>;
1046
+ readOnly: NonNullable<Readonly<{
1047
+ isArticle?: boolean;
1048
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
1049
+ GroupMetadataEditor?: React.ComponentType<any>;
1050
+ showAlignmentOptions?: boolean;
1051
+ readOnly?: boolean;
1052
+ answerableCallback?: (arg1: boolean) => unknown;
1053
+ getAnotherHint?: () => unknown;
1054
+ interactionCallback?: (widgetData: {
1055
+ [widgetId: string]: any;
1056
+ }) => void;
1057
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
1058
+ imagePlaceholder?: React.ReactNode;
1059
+ widgetPlaceholder?: React.ReactNode;
1060
+ baseElements?: {
1061
+ Link: React.ComponentType<any>;
1062
+ };
1063
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
1064
+ trackInteraction?: (args: {
1065
+ type: string;
1066
+ id: string;
1067
+ correct?: boolean;
1068
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
1069
+ visible: number;
1070
+ }>) => void;
1071
+ customKeypad?: boolean;
1072
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
1073
+ isMobile?: boolean;
1074
+ isMobileApp?: boolean;
1075
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
1076
+ hintProgressColor?: string;
1077
+ canScrollPage?: boolean;
1078
+ editorChangeDelay?: number;
1079
+ flags?: Record<"new-radio-widget", boolean>;
1080
+ onWidgetStartProps?: (widgets: import("@khanacademy/perseus-core").PerseusWidgetsMap) => void;
1081
+ }>["readOnly"]>;
1082
+ setDrawingAreaAvailable: NonNullable<Readonly<{
1083
+ isArticle?: boolean;
1084
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
1085
+ GroupMetadataEditor?: React.ComponentType<any>;
1086
+ showAlignmentOptions?: boolean;
1087
+ readOnly?: boolean;
1088
+ answerableCallback?: (arg1: boolean) => unknown;
1089
+ getAnotherHint?: () => unknown;
1090
+ interactionCallback?: (widgetData: {
1091
+ [widgetId: string]: any;
1092
+ }) => void;
1093
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
1094
+ imagePlaceholder?: React.ReactNode;
1095
+ widgetPlaceholder?: React.ReactNode;
1096
+ baseElements?: {
1097
+ Link: React.ComponentType<any>;
1098
+ };
1099
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
1100
+ trackInteraction?: (args: {
1101
+ type: string;
1102
+ id: string;
1103
+ correct?: boolean;
1104
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
1105
+ visible: number;
1106
+ }>) => void;
1107
+ customKeypad?: boolean;
1108
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
1109
+ isMobile?: boolean;
1110
+ isMobileApp?: boolean;
1111
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
1112
+ hintProgressColor?: string;
1113
+ canScrollPage?: boolean;
1114
+ editorChangeDelay?: number;
1115
+ flags?: Record<"new-radio-widget", boolean>;
1116
+ onWidgetStartProps?: (widgets: import("@khanacademy/perseus-core").PerseusWidgetsMap) => void;
1117
+ }>["setDrawingAreaAvailable"]>;
1118
+ showAlignmentOptions: NonNullable<Readonly<{
1119
+ isArticle?: boolean;
1120
+ onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
1121
+ GroupMetadataEditor?: React.ComponentType<any>;
1122
+ showAlignmentOptions?: boolean;
1123
+ readOnly?: boolean;
1124
+ answerableCallback?: (arg1: boolean) => unknown;
1125
+ getAnotherHint?: () => unknown;
1126
+ interactionCallback?: (widgetData: {
1127
+ [widgetId: string]: any;
1128
+ }) => void;
1129
+ groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
1130
+ imagePlaceholder?: React.ReactNode;
1131
+ widgetPlaceholder?: React.ReactNode;
1132
+ baseElements?: {
1133
+ Link: React.ComponentType<any>;
1134
+ };
1135
+ imagePreloader?: (dimensions: import("../../../../perseus/src/types").Dimensions) => React.ReactNode;
1136
+ trackInteraction?: (args: {
1137
+ type: string;
1138
+ id: string;
1139
+ correct?: boolean;
1140
+ } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
1141
+ visible: number;
1142
+ }>) => void;
1143
+ customKeypad?: boolean;
1144
+ nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
1145
+ isMobile?: boolean;
1146
+ isMobileApp?: boolean;
1147
+ setDrawingAreaAvailable?: (arg1: boolean) => unknown;
1148
+ hintProgressColor?: string;
1149
+ canScrollPage?: boolean;
1150
+ editorChangeDelay?: number;
1151
+ flags?: Record<"new-radio-widget", boolean>;
1152
+ onWidgetStartProps?: (widgets: import("@khanacademy/perseus-core").PerseusWidgetsMap) => void;
1153
+ }>["showAlignmentOptions"]>;
1154
+ }>;
1155
+ keypadElement?: any;
1156
+ questionCompleted?: boolean;
1157
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
1158
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
1159
+ findWidgets: (criterion: import("../../../../perseus/src/types").FilterCriterion) => ReadonlyArray<import("../../../../perseus/src/types").Widget>;
1160
+ reviewMode: boolean;
1161
+ showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
1162
+ onChange: import("@khanacademy/perseus").ChangeHandler;
1163
+ handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
1164
+ isLastUsedWidget: boolean;
1165
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
1166
+ containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
1167
+ };
226
1168
  render(): React.JSX.Element;
227
1169
  context: unknown;
228
1170
  setState<K extends string | number | symbol>(state: any, callback?: (() => void) | undefined): void;
@@ -246,7 +1188,7 @@ declare const InteractiveGraph: {
246
1188
  lockedFigures: LockedFigure[];
247
1189
  fullGraphAriaLabel?: string;
248
1190
  fullGraphAriaDescription?: string;
249
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>>;
1191
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>>;
250
1192
  state: Readonly<any>;
251
1193
  refs: {
252
1194
  [key: string]: React.ReactInstance;
@@ -271,7 +1213,7 @@ declare const InteractiveGraph: {
271
1213
  lockedFigures: LockedFigure[];
272
1214
  fullGraphAriaLabel?: string;
273
1215
  fullGraphAriaDescription?: string;
274
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>>, nextState: Readonly<any>, nextContext: any): boolean;
1216
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>>, nextState: Readonly<any>, nextContext: any): boolean;
275
1217
  componentWillUnmount?(): void;
276
1218
  componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
277
1219
  getSnapshotBeforeUpdate?(prevProps: Readonly<{
@@ -293,7 +1235,7 @@ declare const InteractiveGraph: {
293
1235
  lockedFigures: LockedFigure[];
294
1236
  fullGraphAriaLabel?: string;
295
1237
  fullGraphAriaDescription?: string;
296
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>>, prevState: Readonly<any>): any;
1238
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>>, prevState: Readonly<any>): any;
297
1239
  componentDidUpdate?(prevProps: Readonly<{
298
1240
  step: [number, number];
299
1241
  gridStep?: [x: number, y: number];
@@ -313,7 +1255,7 @@ declare const InteractiveGraph: {
313
1255
  lockedFigures: LockedFigure[];
314
1256
  fullGraphAriaLabel?: string;
315
1257
  fullGraphAriaDescription?: string;
316
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>>, prevState: Readonly<any>, snapshot?: any): void;
1258
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>>, prevState: Readonly<any>, snapshot?: any): void;
317
1259
  componentWillMount?(): void;
318
1260
  UNSAFE_componentWillMount?(): void;
319
1261
  componentWillReceiveProps?(nextProps: Readonly<{
@@ -335,7 +1277,7 @@ declare const InteractiveGraph: {
335
1277
  lockedFigures: LockedFigure[];
336
1278
  fullGraphAriaLabel?: string;
337
1279
  fullGraphAriaDescription?: string;
338
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>>, nextContext: any): void;
1280
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>>, nextContext: any): void;
339
1281
  UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{
340
1282
  step: [number, number];
341
1283
  gridStep?: [x: number, y: number];
@@ -355,7 +1297,7 @@ declare const InteractiveGraph: {
355
1297
  lockedFigures: LockedFigure[];
356
1298
  fullGraphAriaLabel?: string;
357
1299
  fullGraphAriaDescription?: string;
358
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>>, nextContext: any): void;
1300
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>>, nextContext: any): void;
359
1301
  componentWillUpdate?(nextProps: Readonly<{
360
1302
  step: [number, number];
361
1303
  gridStep?: [x: number, y: number];
@@ -375,7 +1317,7 @@ declare const InteractiveGraph: {
375
1317
  lockedFigures: LockedFigure[];
376
1318
  fullGraphAriaLabel?: string;
377
1319
  fullGraphAriaDescription?: string;
378
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>>, nextState: Readonly<any>, nextContext: any): void;
1320
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>>, nextState: Readonly<any>, nextContext: any): void;
379
1321
  UNSAFE_componentWillUpdate?(nextProps: Readonly<{
380
1322
  step: [number, number];
381
1323
  gridStep?: [x: number, y: number];
@@ -395,7 +1337,7 @@ declare const InteractiveGraph: {
395
1337
  lockedFigures: LockedFigure[];
396
1338
  fullGraphAriaLabel?: string;
397
1339
  fullGraphAriaDescription?: string;
398
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>>, nextState: Readonly<any>, nextContext: any): void;
1340
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>>, nextState: Readonly<any>, nextContext: any): void;
399
1341
  };
400
1342
  defaultProps: {
401
1343
  labels: string[];
@@ -406,7 +1348,7 @@ declare const InteractiveGraph: {
406
1348
  markings: MarkingsType;
407
1349
  showTooltips: boolean | undefined;
408
1350
  showProtractor: boolean;
409
- graph: PerseusGraphType;
1351
+ userInput: PerseusGraphType;
410
1352
  };
411
1353
  getLineCoords(graph: PerseusGraphType, props: {
412
1354
  step: [number, number];
@@ -427,7 +1369,7 @@ declare const InteractiveGraph: {
427
1369
  lockedFigures: LockedFigure[];
428
1370
  fullGraphAriaLabel?: string;
429
1371
  fullGraphAriaDescription?: string;
430
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>): import("@khanacademy/perseus").Coord[];
1372
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>): import("@khanacademy/perseus").Coord[];
431
1373
  getPointCoords(graph: import("@khanacademy/perseus-core").PerseusGraphTypePoint, props: {
432
1374
  step: [number, number];
433
1375
  gridStep?: [x: number, y: number];
@@ -447,7 +1389,7 @@ declare const InteractiveGraph: {
447
1389
  lockedFigures: LockedFigure[];
448
1390
  fullGraphAriaLabel?: string;
449
1391
  fullGraphAriaDescription?: string;
450
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>): import("@khanacademy/perseus").Coord[];
1392
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>): import("@khanacademy/perseus").Coord[];
451
1393
  getLinearSystemCoords(graph: PerseusGraphType, props: {
452
1394
  step: [number, number];
453
1395
  gridStep?: [x: number, y: number];
@@ -467,7 +1409,7 @@ declare const InteractiveGraph: {
467
1409
  lockedFigures: LockedFigure[];
468
1410
  fullGraphAriaLabel?: string;
469
1411
  fullGraphAriaDescription?: string;
470
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>): import("@khanacademy/perseus").Coord[][];
1412
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>): import("@khanacademy/perseus").Coord[][];
471
1413
  getPolygonCoords(graph: PerseusGraphType, props: {
472
1414
  step: [number, number];
473
1415
  gridStep?: [x: number, y: number];
@@ -487,7 +1429,7 @@ declare const InteractiveGraph: {
487
1429
  lockedFigures: LockedFigure[];
488
1430
  fullGraphAriaLabel?: string;
489
1431
  fullGraphAriaDescription?: string;
490
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>): import("@khanacademy/perseus").Coord[];
1432
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>): import("@khanacademy/perseus").Coord[];
491
1433
  getSegmentCoords(graph: import("@khanacademy/perseus-core").PerseusGraphTypeSegment, props: {
492
1434
  step: [number, number];
493
1435
  gridStep?: [x: number, y: number];
@@ -507,7 +1449,7 @@ declare const InteractiveGraph: {
507
1449
  lockedFigures: LockedFigure[];
508
1450
  fullGraphAriaLabel?: string;
509
1451
  fullGraphAriaDescription?: string;
510
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>): import("@khanacademy/perseus").Coord[][];
1452
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>): import("@khanacademy/perseus").Coord[][];
511
1453
  getAngleCoords(graph: import("@khanacademy/perseus-core").PerseusGraphTypeAngle, props: {
512
1454
  step: [number, number];
513
1455
  gridStep?: [x: number, y: number];
@@ -527,7 +1469,7 @@ declare const InteractiveGraph: {
527
1469
  lockedFigures: LockedFigure[];
528
1470
  fullGraphAriaLabel?: string;
529
1471
  fullGraphAriaDescription?: string;
530
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>): [import("@khanacademy/perseus").Coord, import("@khanacademy/perseus").Coord, import("@khanacademy/perseus").Coord];
1472
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>): [import("@khanacademy/perseus").Coord, import("@khanacademy/perseus").Coord, import("@khanacademy/perseus").Coord];
531
1473
  normalizeCoords(coordsList: import("@khanacademy/perseus").Coord[], ranges: [import("@khanacademy/kmath").Range, import("@khanacademy/kmath").Range]): import("@khanacademy/perseus").Coord[];
532
1474
  getEquationString(props: {
533
1475
  step: [number, number];
@@ -548,7 +1490,7 @@ declare const InteractiveGraph: {
548
1490
  lockedFigures: LockedFigure[];
549
1491
  fullGraphAriaLabel?: string;
550
1492
  fullGraphAriaDescription?: string;
551
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>): string;
1493
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>): string;
552
1494
  pointsFromNormalized(props: {
553
1495
  step: [number, number];
554
1496
  gridStep?: [x: number, y: number];
@@ -568,7 +1510,7 @@ declare const InteractiveGraph: {
568
1510
  lockedFigures: LockedFigure[];
569
1511
  fullGraphAriaLabel?: string;
570
1512
  fullGraphAriaDescription?: string;
571
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>, coordsList: import("@khanacademy/perseus").Coord[], noSnap?: boolean): import("@khanacademy/perseus").Coord[];
1513
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>, coordsList: import("@khanacademy/perseus").Coord[], noSnap?: boolean): import("@khanacademy/perseus").Coord[];
572
1514
  getNoneEquationString(): string;
573
1515
  getLinearEquationString(props: {
574
1516
  step: [number, number];
@@ -589,7 +1531,7 @@ declare const InteractiveGraph: {
589
1531
  lockedFigures: LockedFigure[];
590
1532
  fullGraphAriaLabel?: string;
591
1533
  fullGraphAriaDescription?: string;
592
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>): string;
1534
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>): string;
593
1535
  getCurrentQuadraticCoefficients(props: {
594
1536
  step: [number, number];
595
1537
  gridStep?: [x: number, y: number];
@@ -609,7 +1551,7 @@ declare const InteractiveGraph: {
609
1551
  lockedFigures: LockedFigure[];
610
1552
  fullGraphAriaLabel?: string;
611
1553
  fullGraphAriaDescription?: string;
612
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>): import("@khanacademy/kmath").QuadraticCoefficient;
1554
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>): import("@khanacademy/kmath").QuadraticCoefficient;
613
1555
  defaultQuadraticCoords(props: {
614
1556
  step: [number, number];
615
1557
  gridStep?: [x: number, y: number];
@@ -629,7 +1571,7 @@ declare const InteractiveGraph: {
629
1571
  lockedFigures: LockedFigure[];
630
1572
  fullGraphAriaLabel?: string;
631
1573
  fullGraphAriaDescription?: string;
632
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>): import("../../../../perseus/src/widgets/interactive-graphs/types").QuadraticGraphState["coords"];
1574
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>): import("../../../../perseus/src/widgets/interactive-graphs/types").QuadraticGraphState["coords"];
633
1575
  getQuadraticEquationString(props: {
634
1576
  step: [number, number];
635
1577
  gridStep?: [x: number, y: number];
@@ -649,7 +1591,7 @@ declare const InteractiveGraph: {
649
1591
  lockedFigures: LockedFigure[];
650
1592
  fullGraphAriaLabel?: string;
651
1593
  fullGraphAriaDescription?: string;
652
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>): string;
1594
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>): string;
653
1595
  getCurrentSinusoidCoefficients(props: {
654
1596
  step: [number, number];
655
1597
  gridStep?: [x: number, y: number];
@@ -669,7 +1611,7 @@ declare const InteractiveGraph: {
669
1611
  lockedFigures: LockedFigure[];
670
1612
  fullGraphAriaLabel?: string;
671
1613
  fullGraphAriaDescription?: string;
672
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>): import("@khanacademy/kmath").SineCoefficient;
1614
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>): import("@khanacademy/kmath").SineCoefficient;
673
1615
  defaultSinusoidCoords(props: {
674
1616
  step: [number, number];
675
1617
  gridStep?: [x: number, y: number];
@@ -689,7 +1631,7 @@ declare const InteractiveGraph: {
689
1631
  lockedFigures: LockedFigure[];
690
1632
  fullGraphAriaLabel?: string;
691
1633
  fullGraphAriaDescription?: string;
692
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>): import("@khanacademy/perseus").Coord[];
1634
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>): import("@khanacademy/perseus").Coord[];
693
1635
  getSinusoidEquationString(props: {
694
1636
  step: [number, number];
695
1637
  gridStep?: [x: number, y: number];
@@ -709,7 +1651,7 @@ declare const InteractiveGraph: {
709
1651
  lockedFigures: LockedFigure[];
710
1652
  fullGraphAriaLabel?: string;
711
1653
  fullGraphAriaDescription?: string;
712
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>): string;
1654
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>): string;
713
1655
  getCircleEquationString(props: {
714
1656
  step: [number, number];
715
1657
  gridStep?: [x: number, y: number];
@@ -729,7 +1671,7 @@ declare const InteractiveGraph: {
729
1671
  lockedFigures: LockedFigure[];
730
1672
  fullGraphAriaLabel?: string;
731
1673
  fullGraphAriaDescription?: string;
732
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>): string;
1674
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>): string;
733
1675
  getLinearSystemEquationString(props: {
734
1676
  step: [number, number];
735
1677
  gridStep?: [x: number, y: number];
@@ -749,7 +1691,7 @@ declare const InteractiveGraph: {
749
1691
  lockedFigures: LockedFigure[];
750
1692
  fullGraphAriaLabel?: string;
751
1693
  fullGraphAriaDescription?: string;
752
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>): string;
1694
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>): string;
753
1695
  getPointEquationString(props: {
754
1696
  step: [number, number];
755
1697
  gridStep?: [x: number, y: number];
@@ -769,7 +1711,7 @@ declare const InteractiveGraph: {
769
1711
  lockedFigures: LockedFigure[];
770
1712
  fullGraphAriaLabel?: string;
771
1713
  fullGraphAriaDescription?: string;
772
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>): string;
1714
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>): string;
773
1715
  getSegmentEquationString(props: {
774
1716
  step: [number, number];
775
1717
  gridStep?: [x: number, y: number];
@@ -789,7 +1731,7 @@ declare const InteractiveGraph: {
789
1731
  lockedFigures: LockedFigure[];
790
1732
  fullGraphAriaLabel?: string;
791
1733
  fullGraphAriaDescription?: string;
792
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>): string;
1734
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>): string;
793
1735
  getRayEquationString(props: {
794
1736
  step: [number, number];
795
1737
  gridStep?: [x: number, y: number];
@@ -809,7 +1751,7 @@ declare const InteractiveGraph: {
809
1751
  lockedFigures: LockedFigure[];
810
1752
  fullGraphAriaLabel?: string;
811
1753
  fullGraphAriaDescription?: string;
812
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>): string;
1754
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>): string;
813
1755
  getPolygonEquationString(props: {
814
1756
  step: [number, number];
815
1757
  gridStep?: [x: number, y: number];
@@ -829,7 +1771,7 @@ declare const InteractiveGraph: {
829
1771
  lockedFigures: LockedFigure[];
830
1772
  fullGraphAriaLabel?: string;
831
1773
  fullGraphAriaDescription?: string;
832
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>): string;
1774
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>): string;
833
1775
  getAngleEquationString(props: {
834
1776
  step: [number, number];
835
1777
  gridStep?: [x: number, y: number];
@@ -849,27 +1791,7 @@ declare const InteractiveGraph: {
849
1791
  lockedFigures: LockedFigure[];
850
1792
  fullGraphAriaLabel?: string;
851
1793
  fullGraphAriaDescription?: string;
852
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>): string;
853
- getUserInputFromProps(props: {
854
- step: [number, number];
855
- gridStep?: [x: number, y: number];
856
- snapStep?: [x: number, y: number];
857
- backgroundImage?: PerseusImageBackground;
858
- markings: MarkingsType;
859
- labels: string[];
860
- labelLocation: AxisLabelLocation;
861
- showProtractor: boolean;
862
- showRuler?: boolean;
863
- showTooltips?: boolean;
864
- rulerLabel?: string;
865
- rulerTicks?: number;
866
- range: import("@khanacademy/perseus-core").GraphRange;
867
- graph: PerseusGraphType;
868
- correct?: PerseusGraphType;
869
- lockedFigures: LockedFigure[];
870
- fullGraphAriaLabel?: string;
871
- fullGraphAriaDescription?: string;
872
- } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, Empty>): PerseusGraphType;
1794
+ } & import("../../../../perseus/src/types").UniversalWidgetProps<Empty, PerseusGraphType, Empty>): string;
873
1795
  contextType?: React.Context<any> | undefined;
874
1796
  };
875
1797
  type InteractiveGraphProps = PropsFor<typeof InteractiveGraph>;
@@ -954,7 +1876,7 @@ export type Props = {
954
1876
  /**
955
1877
  * The graph to display in the graph area.
956
1878
  */
957
- graph: InteractiveGraphProps["graph"];
1879
+ graph: InteractiveGraphProps["userInput"];
958
1880
  onChange: (props: Partial<Props>) => void;
959
1881
  static?: boolean;
960
1882
  };