@khanacademy/perseus-editor 5.2.0 → 5.2.1

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 (7) hide show
  1. package/dist/components/blur-input.d.ts +2 -0
  2. package/dist/components/link.d.ts +2 -0
  3. package/dist/es/index.js +1 -1
  4. package/dist/index.js +1 -1
  5. package/dist/widgets/interactive-graph-editor.d.ts +2290 -856
  6. package/dist/widgets/unit-editor.d.ts +1 -1
  7. package/package.json +2 -2
package/dist/widgets/interactive-graph-editor.d.ts CHANGED
@@ -21,23 +21,26 @@ declare const InteractiveGraph: {
21
21
  [widgetId: string]: any;
22
22
  }) => void) | undefined;
23
23
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
24
- imagePlaceholder?: React.ReactNode;
24
+ imagePlaceholder?: React.ReactNode; /**
25
+ * The current correct answer for the graph. Updated by this component
26
+ * when the graph is changed.
27
+ *
28
+ * Note that the "Correct answer:" textbox is not an interactive
29
+ * element. Instead, it is a representation of the correct answer based
30
+ * on the state of the interactive graph previewed at the bottom of the
31
+ * editor page.
32
+ */
25
33
  widgetPlaceholder?: React.ReactNode;
26
34
  baseElements?: {
27
35
  Link: React.ComponentType<any>;
28
36
  } | undefined;
29
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
30
- * Whether to show the ruler on the graph.
31
- */
37
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
32
38
  trackInteraction?: ((args: {
33
39
  type: string;
34
40
  id: string;
35
41
  correct?: boolean | undefined;
36
42
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
37
- customKeypad?: boolean | undefined; /**
38
- * Whether to show tooltips on the graph.
39
- * (Currently not used, but will be in the future.)
40
- */
43
+ customKeypad?: boolean | undefined;
41
44
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
42
45
  isMobile?: boolean | undefined;
43
46
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -97,23 +100,26 @@ declare const InteractiveGraph: {
97
100
  [widgetId: string]: any;
98
101
  }) => void) | undefined;
99
102
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
100
- imagePlaceholder?: React.ReactNode;
103
+ imagePlaceholder?: React.ReactNode; /**
104
+ * The current correct answer for the graph. Updated by this component
105
+ * when the graph is changed.
106
+ *
107
+ * Note that the "Correct answer:" textbox is not an interactive
108
+ * element. Instead, it is a representation of the correct answer based
109
+ * on the state of the interactive graph previewed at the bottom of the
110
+ * editor page.
111
+ */
101
112
  widgetPlaceholder?: React.ReactNode;
102
113
  baseElements?: {
103
114
  Link: React.ComponentType<any>;
104
115
  } | undefined;
105
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
106
- * Whether to show the ruler on the graph.
107
- */
116
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
108
117
  trackInteraction?: ((args: {
109
118
  type: string;
110
119
  id: string;
111
120
  correct?: boolean | undefined;
112
121
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
113
- customKeypad?: boolean | undefined; /**
114
- * Whether to show tooltips on the graph.
115
- * (Currently not used, but will be in the future.)
116
- */
122
+ customKeypad?: boolean | undefined;
117
123
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
118
124
  isMobile?: boolean | undefined;
119
125
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -156,27 +162,902 @@ declare const InteractiveGraph: {
156
162
  linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
157
163
  containerSizeClass: SizingUtils.SizeClass;
158
164
  }>): {
159
- angle: any;
160
- circle: any;
161
- graphie: any;
162
- horizHairline: any;
163
- line: any;
164
- lines: readonly (readonly import("@khanacademy/perseus").Coord[])[] | null | undefined;
165
- parabola: any;
166
- pointA: any;
167
- pointB: any;
168
- pointC: any;
169
- points: any[];
170
- polygon: any;
171
- shouldResetGraphie: boolean;
172
- sinusoid: any;
173
- trashCan: any;
174
- vertHairline: any;
165
+ legacyGraphRef: React.RefObject<{
166
+ angle: any;
167
+ circle: any;
168
+ graphie: any;
169
+ horizHairline: any;
170
+ line: any;
171
+ lines: readonly (readonly import("@khanacademy/perseus").Coord[])[] | null | undefined;
172
+ parabola: any;
173
+ pointA: any;
174
+ pointB: any;
175
+ pointC: any;
176
+ points: any[];
177
+ polygon: any;
178
+ shouldResetGraphie: boolean;
179
+ sinusoid: any;
180
+ trashCan: any;
181
+ vertHairline: any;
182
+ state: any;
183
+ UNSAFE_componentWillMount(): void;
184
+ componentDidMount(): void;
185
+ UNSAFE_componentWillReceiveProps(nextProps: PerseusInteractiveGraphWidgetOptions & {
186
+ widgetId: string;
187
+ alignment: string | null | undefined;
188
+ static: boolean | null | undefined;
189
+ problemNum: number | null | undefined;
190
+ apiOptions: Readonly<Readonly<{
191
+ isArticle?: boolean | undefined;
192
+ onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
193
+ onFocusChange?: ((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
194
+ GroupMetadataEditor?: React.ComponentType<any> | undefined;
195
+ showAlignmentOptions?: boolean | undefined;
196
+ readOnly?: boolean | undefined;
197
+ answerableCallback?: ((arg1: boolean) => unknown) | undefined;
198
+ getAnotherHint?: (() => unknown) | undefined;
199
+ interactionCallback?: ((widgetData: {
200
+ [widgetId: string]: any;
201
+ }) => void) | undefined;
202
+ groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
203
+ imagePlaceholder?: React.ReactNode; /**
204
+ * The current correct answer for the graph. Updated by this component
205
+ * when the graph is changed.
206
+ *
207
+ * Note that the "Correct answer:" textbox is not an interactive
208
+ * element. Instead, it is a representation of the correct answer based
209
+ * on the state of the interactive graph previewed at the bottom of the
210
+ * editor page.
211
+ */
212
+ widgetPlaceholder?: React.ReactNode;
213
+ baseElements?: {
214
+ Link: React.ComponentType<any>;
215
+ } | undefined;
216
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
217
+ trackInteraction?: ((args: {
218
+ type: string;
219
+ id: string;
220
+ correct?: boolean | undefined;
221
+ } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
222
+ customKeypad?: boolean | undefined;
223
+ nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
224
+ isMobile?: boolean | undefined;
225
+ setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
226
+ useDraftEditor?: boolean | undefined;
227
+ hintProgressColor?: string | undefined;
228
+ canScrollPage?: boolean | undefined;
229
+ inModal?: boolean | undefined;
230
+ crossOutEnabled?: boolean | undefined;
231
+ editorChangeDelay?: number | undefined;
232
+ flags?: Record<string, boolean | Record<string, boolean>> | undefined;
233
+ onWidgetStartProps?: ((widgets: import("@khanacademy/perseus").PerseusWidgetsMap) => import("@khanacademy/perseus").PerseusWidgetsMap) | undefined;
234
+ }> & {
235
+ GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
236
+ baseElements: {
237
+ Link: React.ComponentType<any>;
238
+ };
239
+ canScrollPage: NonNullable<boolean | undefined>;
240
+ crossOutEnabled: NonNullable<boolean | undefined>;
241
+ editorChangeDelay: number;
242
+ groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
243
+ inModal: NonNullable<boolean | undefined>;
244
+ isArticle: NonNullable<boolean | undefined>;
245
+ isMobile: NonNullable<boolean | undefined>;
246
+ onFocusChange: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown;
247
+ onInputError: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
248
+ readOnly: NonNullable<boolean | undefined>;
249
+ setDrawingAreaAvailable: (arg1: boolean) => unknown;
250
+ showAlignmentOptions: NonNullable<boolean | undefined>;
251
+ useDraftEditor: NonNullable<boolean | undefined>;
252
+ }>;
253
+ keypadElement?: any;
254
+ questionCompleted?: boolean | undefined;
255
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
256
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
257
+ findWidgets: (arg1: import("../../../perseus/src/types").FilterCriterion) => readonly any[];
258
+ reviewModeRubric: PerseusInteractiveGraphWidgetOptions;
259
+ onChange: import("@khanacademy/perseus").ChangeHandler;
260
+ trackInteraction: (extraData?: {} | undefined) => void;
261
+ isLastUsedWidget: boolean;
262
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
263
+ containerSizeClass: SizingUtils.SizeClass;
264
+ }): void;
265
+ componentDidUpdate(prevProps: PerseusInteractiveGraphWidgetOptions & {
266
+ widgetId: string;
267
+ alignment: string | null | undefined;
268
+ static: boolean | null | undefined;
269
+ problemNum: number | null | undefined;
270
+ apiOptions: Readonly<Readonly<{
271
+ isArticle?: boolean | undefined;
272
+ onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
273
+ onFocusChange?: ((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
274
+ GroupMetadataEditor?: React.ComponentType<any> | undefined;
275
+ showAlignmentOptions?: boolean | undefined;
276
+ readOnly?: boolean | undefined;
277
+ answerableCallback?: ((arg1: boolean) => unknown) | undefined;
278
+ getAnotherHint?: (() => unknown) | undefined;
279
+ interactionCallback?: ((widgetData: {
280
+ [widgetId: string]: any;
281
+ }) => void) | undefined;
282
+ groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
283
+ imagePlaceholder?: React.ReactNode; /**
284
+ * The current correct answer for the graph. Updated by this component
285
+ * when the graph is changed.
286
+ *
287
+ * Note that the "Correct answer:" textbox is not an interactive
288
+ * element. Instead, it is a representation of the correct answer based
289
+ * on the state of the interactive graph previewed at the bottom of the
290
+ * editor page.
291
+ */
292
+ widgetPlaceholder?: React.ReactNode;
293
+ baseElements?: {
294
+ Link: React.ComponentType<any>;
295
+ } | undefined;
296
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
297
+ trackInteraction?: ((args: {
298
+ type: string;
299
+ id: string;
300
+ correct?: boolean | undefined;
301
+ } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
302
+ customKeypad?: boolean | undefined;
303
+ nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
304
+ isMobile?: boolean | undefined;
305
+ setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
306
+ useDraftEditor?: boolean | undefined;
307
+ hintProgressColor?: string | undefined;
308
+ canScrollPage?: boolean | undefined;
309
+ inModal?: boolean | undefined;
310
+ crossOutEnabled?: boolean | undefined;
311
+ editorChangeDelay?: number | undefined;
312
+ flags?: Record<string, boolean | Record<string, boolean>> | undefined;
313
+ onWidgetStartProps?: ((widgets: import("@khanacademy/perseus").PerseusWidgetsMap) => import("@khanacademy/perseus").PerseusWidgetsMap) | undefined;
314
+ }> & {
315
+ GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
316
+ baseElements: {
317
+ Link: React.ComponentType<any>;
318
+ };
319
+ canScrollPage: NonNullable<boolean | undefined>;
320
+ crossOutEnabled: NonNullable<boolean | undefined>;
321
+ editorChangeDelay: number;
322
+ groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
323
+ inModal: NonNullable<boolean | undefined>;
324
+ isArticle: NonNullable<boolean | undefined>;
325
+ isMobile: NonNullable<boolean | undefined>;
326
+ onFocusChange: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown;
327
+ onInputError: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
328
+ readOnly: NonNullable<boolean | undefined>;
329
+ setDrawingAreaAvailable: (arg1: boolean) => unknown;
330
+ showAlignmentOptions: NonNullable<boolean | undefined>;
331
+ useDraftEditor: NonNullable<boolean | undefined>;
332
+ }>;
333
+ keypadElement?: any;
334
+ questionCompleted?: boolean | undefined;
335
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
336
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
337
+ findWidgets: (arg1: import("../../../perseus/src/types").FilterCriterion) => readonly any[];
338
+ reviewModeRubric: PerseusInteractiveGraphWidgetOptions;
339
+ onChange: import("@khanacademy/perseus").ChangeHandler;
340
+ trackInteraction: (extraData?: {} | undefined) => void;
341
+ isLastUsedWidget: boolean;
342
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
343
+ containerSizeClass: SizingUtils.SizeClass;
344
+ }, prevState: any): void;
345
+ _getShouldShowInstructions: (arg1?: (PerseusInteractiveGraphWidgetOptions & {
346
+ widgetId: string;
347
+ alignment: string | null | undefined;
348
+ static: boolean | null | undefined;
349
+ problemNum: number | null | undefined;
350
+ apiOptions: Readonly<Readonly<{
351
+ isArticle?: boolean | undefined;
352
+ onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
353
+ onFocusChange?: ((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
354
+ GroupMetadataEditor?: React.ComponentType<any> | undefined;
355
+ showAlignmentOptions?: boolean | undefined;
356
+ readOnly?: boolean | undefined;
357
+ answerableCallback?: ((arg1: boolean) => unknown) | undefined;
358
+ getAnotherHint?: (() => unknown) | undefined;
359
+ interactionCallback?: ((widgetData: {
360
+ [widgetId: string]: any;
361
+ }) => void) | undefined;
362
+ groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
363
+ imagePlaceholder?: React.ReactNode; /**
364
+ * The current correct answer for the graph. Updated by this component
365
+ * when the graph is changed.
366
+ *
367
+ * Note that the "Correct answer:" textbox is not an interactive
368
+ * element. Instead, it is a representation of the correct answer based
369
+ * on the state of the interactive graph previewed at the bottom of the
370
+ * editor page.
371
+ */
372
+ widgetPlaceholder?: React.ReactNode;
373
+ baseElements?: {
374
+ Link: React.ComponentType<any>;
375
+ } | undefined;
376
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
377
+ trackInteraction?: ((args: {
378
+ type: string;
379
+ id: string;
380
+ correct?: boolean | undefined;
381
+ } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
382
+ customKeypad?: boolean | undefined;
383
+ nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
384
+ isMobile?: boolean | undefined;
385
+ setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
386
+ useDraftEditor?: boolean | undefined;
387
+ hintProgressColor?: string | undefined;
388
+ canScrollPage?: boolean | undefined;
389
+ inModal?: boolean | undefined;
390
+ crossOutEnabled?: boolean | undefined;
391
+ editorChangeDelay?: number | undefined;
392
+ flags?: Record<string, boolean | Record<string, boolean>> | undefined;
393
+ onWidgetStartProps?: ((widgets: import("@khanacademy/perseus").PerseusWidgetsMap) => import("@khanacademy/perseus").PerseusWidgetsMap) | undefined;
394
+ }> & {
395
+ GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
396
+ baseElements: {
397
+ Link: React.ComponentType<any>;
398
+ };
399
+ canScrollPage: NonNullable<boolean | undefined>;
400
+ crossOutEnabled: NonNullable<boolean | undefined>;
401
+ editorChangeDelay: number;
402
+ groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
403
+ inModal: NonNullable<boolean | undefined>;
404
+ isArticle: NonNullable<boolean | undefined>;
405
+ isMobile: NonNullable<boolean | undefined>;
406
+ onFocusChange: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown;
407
+ onInputError: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
408
+ readOnly: NonNullable<boolean | undefined>;
409
+ setDrawingAreaAvailable: (arg1: boolean) => unknown;
410
+ showAlignmentOptions: NonNullable<boolean | undefined>;
411
+ useDraftEditor: NonNullable<boolean | undefined>;
412
+ }>;
413
+ keypadElement?: any;
414
+ questionCompleted?: boolean | undefined;
415
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
416
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
417
+ findWidgets: (arg1: import("../../../perseus/src/types").FilterCriterion) => readonly any[];
418
+ reviewModeRubric: PerseusInteractiveGraphWidgetOptions;
419
+ onChange: import("@khanacademy/perseus").ChangeHandler;
420
+ trackInteraction: (extraData?: {} | undefined) => void;
421
+ isLastUsedWidget: boolean;
422
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
423
+ containerSizeClass: SizingUtils.SizeClass;
424
+ }) | null | undefined) => boolean;
425
+ deprecatedProps: any;
426
+ setGraphie: (arg1: any) => void;
427
+ handleAddPointsMouseDown: (arg1: import("@khanacademy/perseus").Coord) => void;
428
+ resetGraphie: () => void;
429
+ setupGraphie: () => void; /**
430
+ * The range of the graph in the x and y directions.
431
+ */
432
+ showHairlines: (arg1: import("@khanacademy/perseus").Coord) => void;
433
+ hideHairlines: () => void;
434
+ setTrashCanVisibility: (arg1: number) => void;
435
+ isClickToAddPoints: (arg1?: (PerseusInteractiveGraphWidgetOptions & {
436
+ widgetId: string;
437
+ alignment: string | null | undefined;
438
+ static: boolean | null | undefined;
439
+ problemNum: number | null | undefined;
440
+ apiOptions: Readonly<Readonly<{
441
+ isArticle?: boolean | undefined;
442
+ onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
443
+ onFocusChange?: ((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
444
+ GroupMetadataEditor?: React.ComponentType<any> | undefined;
445
+ showAlignmentOptions?: boolean | undefined;
446
+ readOnly?: boolean | undefined;
447
+ answerableCallback?: ((arg1: boolean) => unknown) | undefined;
448
+ getAnotherHint?: (() => unknown) | undefined;
449
+ interactionCallback?: ((widgetData: {
450
+ [widgetId: string]: any;
451
+ }) => void) | undefined;
452
+ groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
453
+ imagePlaceholder?: React.ReactNode; /**
454
+ * The current correct answer for the graph. Updated by this component
455
+ * when the graph is changed.
456
+ *
457
+ * Note that the "Correct answer:" textbox is not an interactive
458
+ * element. Instead, it is a representation of the correct answer based
459
+ * on the state of the interactive graph previewed at the bottom of the
460
+ * editor page.
461
+ */
462
+ widgetPlaceholder?: React.ReactNode;
463
+ baseElements?: {
464
+ Link: React.ComponentType<any>;
465
+ } | undefined;
466
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
467
+ trackInteraction?: ((args: {
468
+ type: string;
469
+ id: string;
470
+ correct?: boolean | undefined;
471
+ } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
472
+ customKeypad?: boolean | undefined;
473
+ nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
474
+ isMobile?: boolean | undefined;
475
+ setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
476
+ useDraftEditor?: boolean | undefined;
477
+ hintProgressColor?: string | undefined;
478
+ canScrollPage?: boolean | undefined;
479
+ inModal?: boolean | undefined;
480
+ crossOutEnabled?: boolean | undefined;
481
+ editorChangeDelay?: number | undefined;
482
+ flags?: Record<string, boolean | Record<string, boolean>> | undefined;
483
+ onWidgetStartProps?: ((widgets: import("@khanacademy/perseus").PerseusWidgetsMap) => import("@khanacademy/perseus").PerseusWidgetsMap) | undefined;
484
+ }> & {
485
+ GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
486
+ baseElements: {
487
+ Link: React.ComponentType<any>;
488
+ };
489
+ canScrollPage: NonNullable<boolean | undefined>;
490
+ crossOutEnabled: NonNullable<boolean | undefined>;
491
+ editorChangeDelay: number;
492
+ groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
493
+ inModal: NonNullable<boolean | undefined>;
494
+ isArticle: NonNullable<boolean | undefined>;
495
+ isMobile: NonNullable<boolean | undefined>;
496
+ onFocusChange: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown;
497
+ onInputError: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
498
+ readOnly: NonNullable<boolean | undefined>;
499
+ setDrawingAreaAvailable: (arg1: boolean) => unknown;
500
+ showAlignmentOptions: NonNullable<boolean | undefined>;
501
+ useDraftEditor: NonNullable<boolean | undefined>;
502
+ }>;
503
+ keypadElement?: any;
504
+ questionCompleted?: boolean | undefined;
505
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
506
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
507
+ findWidgets: (arg1: import("../../../perseus/src/types").FilterCriterion) => readonly any[];
508
+ reviewModeRubric: PerseusInteractiveGraphWidgetOptions;
509
+ onChange: import("@khanacademy/perseus").ChangeHandler;
510
+ trackInteraction: (extraData?: {} | undefined) => void;
511
+ isLastUsedWidget: boolean;
512
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
513
+ containerSizeClass: SizingUtils.SizeClass;
514
+ }) | null | undefined) => boolean;
515
+ areAngleGraphsEqual(prevGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypeAngle, currentGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypeAngle): boolean;
516
+ arePointGraphsEqual(prevGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypePoint, currentGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypePoint): boolean;
517
+ arePolygonGraphsEqual(prevGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypePolygon, currentGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypePolygon): boolean;
518
+ areSegmentGraphsEqual(prevGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypeSegment, currentGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypeSegment): boolean;
519
+ _lineStroke: () => {
520
+ "stroke-width"?: number | undefined;
521
+ };
522
+ addLine: (arg1: string) => void;
523
+ removeLine: () => void;
524
+ addLinearControls: () => void;
525
+ removeLinearControls: () => void;
526
+ addQuadraticControls: () => void;
527
+ updateQuadratic: () => void;
528
+ removeQuadraticControls: () => void;
529
+ addSinusoidControls: () => void;
530
+ updateSinusoid: () => void;
531
+ removeSinusoidControls: () => void;
532
+ addCircleControls: () => void; /**
533
+ * Whether to show the protractor on the graph.
534
+ */
535
+ removeCircleControls: () => void;
536
+ addLinearSystemControls: () => void;
537
+ removeLinearSystemControls: () => void;
538
+ isCoordInTrash: (arg1: import("@khanacademy/perseus").Coord) => boolean;
539
+ createPointForPointsType: (arg1: import("@khanacademy/perseus").Coord, arg2: number) => any;
540
+ removePoint: (arg1: import("@khanacademy/perseus").Coord) => number | null | undefined;
541
+ createPointForPolygonType: (arg1: import("@khanacademy/perseus").Coord, arg2: number) => any;
542
+ updateCoordsFromPoints: () => void;
543
+ clearCoords: () => void;
544
+ onChange: (arg1: any) => void;
545
+ addPointControls: () => void;
546
+ removePointControls: () => void;
547
+ addSegmentControls: () => void;
548
+ removeSegmentControls: () => void;
549
+ addRayControls: () => void;
550
+ removeRayControls: () => void;
551
+ addPolygonControls: () => void;
552
+ updatePolygon: () => void;
553
+ removePolygonControls: () => void;
554
+ addAngleControls: () => void;
555
+ removeAngleControls: () => void;
556
+ toggleShowSides: () => void;
557
+ getUserInput: () => import("@khanacademy/perseus").PerseusGraphType;
558
+ simpleValidate: (rubric: PerseusInteractiveGraphWidgetOptions) => import("@khanacademy/perseus").PerseusScore;
559
+ focus: () => void;
560
+ render(): React.ReactNode;
561
+ context: any;
562
+ setState<K extends string | number | symbol>(state: any, callback?: (() => void) | undefined): void;
563
+ forceUpdate(callback?: (() => void) | undefined): void;
564
+ readonly props: Readonly<PerseusInteractiveGraphWidgetOptions & {
565
+ widgetId: string;
566
+ alignment: string | null | undefined;
567
+ static: boolean | null | undefined;
568
+ problemNum: number | null | undefined;
569
+ apiOptions: Readonly<Readonly<{
570
+ isArticle?: boolean | undefined;
571
+ onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
572
+ onFocusChange?: ((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
573
+ GroupMetadataEditor?: React.ComponentType<any> | undefined;
574
+ showAlignmentOptions?: boolean | undefined;
575
+ readOnly?: boolean | undefined;
576
+ answerableCallback?: ((arg1: boolean) => unknown) | undefined;
577
+ getAnotherHint?: (() => unknown) | undefined;
578
+ interactionCallback?: ((widgetData: {
579
+ [widgetId: string]: any;
580
+ }) => void) | undefined;
581
+ groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
582
+ imagePlaceholder?: React.ReactNode; /**
583
+ * The current correct answer for the graph. Updated by this component
584
+ * when the graph is changed.
585
+ *
586
+ * Note that the "Correct answer:" textbox is not an interactive
587
+ * element. Instead, it is a representation of the correct answer based
588
+ * on the state of the interactive graph previewed at the bottom of the
589
+ * editor page.
590
+ */
591
+ widgetPlaceholder?: React.ReactNode;
592
+ baseElements?: {
593
+ Link: React.ComponentType<any>;
594
+ } | undefined;
595
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
596
+ trackInteraction?: ((args: {
597
+ type: string;
598
+ id: string;
599
+ correct?: boolean | undefined;
600
+ } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
601
+ customKeypad?: boolean | undefined;
602
+ nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
603
+ isMobile?: boolean | undefined;
604
+ setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
605
+ useDraftEditor?: boolean | undefined;
606
+ hintProgressColor?: string | undefined;
607
+ canScrollPage?: boolean | undefined;
608
+ inModal?: boolean | undefined;
609
+ crossOutEnabled?: boolean | undefined;
610
+ editorChangeDelay?: number | undefined;
611
+ flags?: Record<string, boolean | Record<string, boolean>> | undefined;
612
+ onWidgetStartProps?: ((widgets: import("@khanacademy/perseus").PerseusWidgetsMap) => import("@khanacademy/perseus").PerseusWidgetsMap) | undefined;
613
+ }> & {
614
+ GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
615
+ baseElements: {
616
+ Link: React.ComponentType<any>;
617
+ };
618
+ canScrollPage: NonNullable<boolean | undefined>;
619
+ crossOutEnabled: NonNullable<boolean | undefined>;
620
+ editorChangeDelay: number;
621
+ groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
622
+ inModal: NonNullable<boolean | undefined>;
623
+ isArticle: NonNullable<boolean | undefined>;
624
+ isMobile: NonNullable<boolean | undefined>;
625
+ onFocusChange: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown;
626
+ onInputError: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
627
+ readOnly: NonNullable<boolean | undefined>;
628
+ setDrawingAreaAvailable: (arg1: boolean) => unknown;
629
+ showAlignmentOptions: NonNullable<boolean | undefined>;
630
+ useDraftEditor: NonNullable<boolean | undefined>;
631
+ }>;
632
+ keypadElement?: any;
633
+ questionCompleted?: boolean | undefined;
634
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
635
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
636
+ findWidgets: (arg1: import("../../../perseus/src/types").FilterCriterion) => readonly any[];
637
+ reviewModeRubric: PerseusInteractiveGraphWidgetOptions;
638
+ onChange: import("@khanacademy/perseus").ChangeHandler;
639
+ trackInteraction: (extraData?: {} | undefined) => void;
640
+ isLastUsedWidget: boolean;
641
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
642
+ containerSizeClass: SizingUtils.SizeClass;
643
+ }> & Readonly<{
644
+ children?: React.ReactNode;
645
+ }>;
646
+ refs: {
647
+ [key: string]: React.ReactInstance;
648
+ };
649
+ shouldComponentUpdate?(nextProps: Readonly<PerseusInteractiveGraphWidgetOptions & {
650
+ widgetId: string;
651
+ alignment: string | null | undefined;
652
+ static: boolean | null | undefined;
653
+ problemNum: number | null | undefined;
654
+ apiOptions: Readonly<Readonly<{
655
+ isArticle?: boolean | undefined;
656
+ onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
657
+ onFocusChange?: ((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
658
+ GroupMetadataEditor?: React.ComponentType<any> | undefined;
659
+ showAlignmentOptions?: boolean | undefined;
660
+ readOnly?: boolean | undefined;
661
+ answerableCallback?: ((arg1: boolean) => unknown) | undefined;
662
+ getAnotherHint?: (() => unknown) | undefined;
663
+ interactionCallback?: ((widgetData: {
664
+ [widgetId: string]: any;
665
+ }) => void) | undefined;
666
+ groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
667
+ imagePlaceholder?: React.ReactNode; /**
668
+ * The current correct answer for the graph. Updated by this component
669
+ * when the graph is changed.
670
+ *
671
+ * Note that the "Correct answer:" textbox is not an interactive
672
+ * element. Instead, it is a representation of the correct answer based
673
+ * on the state of the interactive graph previewed at the bottom of the
674
+ * editor page.
675
+ */
676
+ widgetPlaceholder?: React.ReactNode;
677
+ baseElements?: {
678
+ Link: React.ComponentType<any>;
679
+ } | undefined;
680
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
681
+ trackInteraction?: ((args: {
682
+ type: string;
683
+ id: string;
684
+ correct?: boolean | undefined;
685
+ } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
686
+ customKeypad?: boolean | undefined;
687
+ nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
688
+ isMobile?: boolean | undefined;
689
+ setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
690
+ useDraftEditor?: boolean | undefined;
691
+ hintProgressColor?: string | undefined;
692
+ canScrollPage?: boolean | undefined;
693
+ inModal?: boolean | undefined;
694
+ crossOutEnabled?: boolean | undefined;
695
+ editorChangeDelay?: number | undefined;
696
+ flags?: Record<string, boolean | Record<string, boolean>> | undefined;
697
+ onWidgetStartProps?: ((widgets: import("@khanacademy/perseus").PerseusWidgetsMap) => import("@khanacademy/perseus").PerseusWidgetsMap) | undefined;
698
+ }> & {
699
+ GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
700
+ baseElements: {
701
+ Link: React.ComponentType<any>;
702
+ };
703
+ canScrollPage: NonNullable<boolean | undefined>;
704
+ crossOutEnabled: NonNullable<boolean | undefined>;
705
+ editorChangeDelay: number;
706
+ groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
707
+ inModal: NonNullable<boolean | undefined>;
708
+ isArticle: NonNullable<boolean | undefined>;
709
+ isMobile: NonNullable<boolean | undefined>;
710
+ onFocusChange: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown;
711
+ onInputError: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
712
+ readOnly: NonNullable<boolean | undefined>;
713
+ setDrawingAreaAvailable: (arg1: boolean) => unknown;
714
+ showAlignmentOptions: NonNullable<boolean | undefined>;
715
+ useDraftEditor: NonNullable<boolean | undefined>;
716
+ }>;
717
+ keypadElement?: any;
718
+ questionCompleted?: boolean | undefined;
719
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
720
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
721
+ findWidgets: (arg1: import("../../../perseus/src/types").FilterCriterion) => readonly any[];
722
+ reviewModeRubric: PerseusInteractiveGraphWidgetOptions;
723
+ onChange: import("@khanacademy/perseus").ChangeHandler;
724
+ trackInteraction: (extraData?: {} | undefined) => void;
725
+ isLastUsedWidget: boolean;
726
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
727
+ containerSizeClass: SizingUtils.SizeClass;
728
+ }>, nextState: Readonly<any>, nextContext: any): boolean;
729
+ componentWillUnmount?(): void;
730
+ componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
731
+ getSnapshotBeforeUpdate?(prevProps: Readonly<PerseusInteractiveGraphWidgetOptions & {
732
+ widgetId: string;
733
+ alignment: string | null | undefined;
734
+ static: boolean | null | undefined;
735
+ problemNum: number | null | undefined;
736
+ apiOptions: Readonly<Readonly<{
737
+ isArticle?: boolean | undefined;
738
+ onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
739
+ onFocusChange?: ((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
740
+ GroupMetadataEditor?: React.ComponentType<any> | undefined;
741
+ showAlignmentOptions?: boolean | undefined;
742
+ readOnly?: boolean | undefined;
743
+ answerableCallback?: ((arg1: boolean) => unknown) | undefined;
744
+ getAnotherHint?: (() => unknown) | undefined;
745
+ interactionCallback?: ((widgetData: {
746
+ [widgetId: string]: any;
747
+ }) => void) | undefined;
748
+ groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
749
+ imagePlaceholder?: React.ReactNode; /**
750
+ * The current correct answer for the graph. Updated by this component
751
+ * when the graph is changed.
752
+ *
753
+ * Note that the "Correct answer:" textbox is not an interactive
754
+ * element. Instead, it is a representation of the correct answer based
755
+ * on the state of the interactive graph previewed at the bottom of the
756
+ * editor page.
757
+ */
758
+ widgetPlaceholder?: React.ReactNode;
759
+ baseElements?: {
760
+ Link: React.ComponentType<any>;
761
+ } | undefined;
762
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
763
+ trackInteraction?: ((args: {
764
+ type: string;
765
+ id: string;
766
+ correct?: boolean | undefined;
767
+ } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
768
+ customKeypad?: boolean | undefined;
769
+ nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
770
+ isMobile?: boolean | undefined;
771
+ setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
772
+ useDraftEditor?: boolean | undefined;
773
+ hintProgressColor?: string | undefined;
774
+ canScrollPage?: boolean | undefined;
775
+ inModal?: boolean | undefined;
776
+ crossOutEnabled?: boolean | undefined;
777
+ editorChangeDelay?: number | undefined;
778
+ flags?: Record<string, boolean | Record<string, boolean>> | undefined;
779
+ onWidgetStartProps?: ((widgets: import("@khanacademy/perseus").PerseusWidgetsMap) => import("@khanacademy/perseus").PerseusWidgetsMap) | undefined;
780
+ }> & {
781
+ GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
782
+ baseElements: {
783
+ Link: React.ComponentType<any>;
784
+ };
785
+ canScrollPage: NonNullable<boolean | undefined>;
786
+ crossOutEnabled: NonNullable<boolean | undefined>;
787
+ editorChangeDelay: number;
788
+ groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
789
+ inModal: NonNullable<boolean | undefined>;
790
+ isArticle: NonNullable<boolean | undefined>;
791
+ isMobile: NonNullable<boolean | undefined>;
792
+ onFocusChange: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown;
793
+ onInputError: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
794
+ readOnly: NonNullable<boolean | undefined>;
795
+ setDrawingAreaAvailable: (arg1: boolean) => unknown;
796
+ showAlignmentOptions: NonNullable<boolean | undefined>;
797
+ useDraftEditor: NonNullable<boolean | undefined>;
798
+ }>;
799
+ keypadElement?: any;
800
+ questionCompleted?: boolean | undefined;
801
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
802
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
803
+ findWidgets: (arg1: import("../../../perseus/src/types").FilterCriterion) => readonly any[];
804
+ reviewModeRubric: PerseusInteractiveGraphWidgetOptions;
805
+ onChange: import("@khanacademy/perseus").ChangeHandler;
806
+ trackInteraction: (extraData?: {} | undefined) => void;
807
+ isLastUsedWidget: boolean;
808
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
809
+ containerSizeClass: SizingUtils.SizeClass;
810
+ }>, prevState: Readonly<any>): any;
811
+ componentWillMount?(): void;
812
+ componentWillReceiveProps?(nextProps: Readonly<PerseusInteractiveGraphWidgetOptions & {
813
+ widgetId: string;
814
+ alignment: string | null | undefined;
815
+ static: boolean | null | undefined;
816
+ problemNum: number | null | undefined;
817
+ apiOptions: Readonly<Readonly<{
818
+ isArticle?: boolean | undefined;
819
+ onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
820
+ onFocusChange?: ((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
821
+ GroupMetadataEditor?: React.ComponentType<any> | undefined;
822
+ showAlignmentOptions?: boolean | undefined;
823
+ readOnly?: boolean | undefined;
824
+ answerableCallback?: ((arg1: boolean) => unknown) | undefined;
825
+ getAnotherHint?: (() => unknown) | undefined;
826
+ interactionCallback?: ((widgetData: {
827
+ [widgetId: string]: any;
828
+ }) => void) | undefined;
829
+ groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
830
+ imagePlaceholder?: React.ReactNode; /**
831
+ * The current correct answer for the graph. Updated by this component
832
+ * when the graph is changed.
833
+ *
834
+ * Note that the "Correct answer:" textbox is not an interactive
835
+ * element. Instead, it is a representation of the correct answer based
836
+ * on the state of the interactive graph previewed at the bottom of the
837
+ * editor page.
838
+ */
839
+ widgetPlaceholder?: React.ReactNode;
840
+ baseElements?: {
841
+ Link: React.ComponentType<any>;
842
+ } | undefined;
843
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
844
+ trackInteraction?: ((args: {
845
+ type: string;
846
+ id: string;
847
+ correct?: boolean | undefined;
848
+ } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
849
+ customKeypad?: boolean | undefined;
850
+ nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
851
+ isMobile?: boolean | undefined;
852
+ setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
853
+ useDraftEditor?: boolean | undefined;
854
+ hintProgressColor?: string | undefined;
855
+ canScrollPage?: boolean | undefined;
856
+ inModal?: boolean | undefined;
857
+ crossOutEnabled?: boolean | undefined;
858
+ editorChangeDelay?: number | undefined;
859
+ flags?: Record<string, boolean | Record<string, boolean>> | undefined;
860
+ onWidgetStartProps?: ((widgets: import("@khanacademy/perseus").PerseusWidgetsMap) => import("@khanacademy/perseus").PerseusWidgetsMap) | undefined;
861
+ }> & {
862
+ GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
863
+ baseElements: {
864
+ Link: React.ComponentType<any>;
865
+ };
866
+ canScrollPage: NonNullable<boolean | undefined>;
867
+ crossOutEnabled: NonNullable<boolean | undefined>;
868
+ editorChangeDelay: number;
869
+ groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
870
+ inModal: NonNullable<boolean | undefined>;
871
+ isArticle: NonNullable<boolean | undefined>;
872
+ isMobile: NonNullable<boolean | undefined>;
873
+ onFocusChange: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown;
874
+ onInputError: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
875
+ readOnly: NonNullable<boolean | undefined>;
876
+ setDrawingAreaAvailable: (arg1: boolean) => unknown;
877
+ showAlignmentOptions: NonNullable<boolean | undefined>;
878
+ useDraftEditor: NonNullable<boolean | undefined>;
879
+ }>;
880
+ keypadElement?: any;
881
+ questionCompleted?: boolean | undefined;
882
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
883
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
884
+ findWidgets: (arg1: import("../../../perseus/src/types").FilterCriterion) => readonly any[];
885
+ reviewModeRubric: PerseusInteractiveGraphWidgetOptions;
886
+ onChange: import("@khanacademy/perseus").ChangeHandler;
887
+ trackInteraction: (extraData?: {} | undefined) => void;
888
+ isLastUsedWidget: boolean;
889
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
890
+ containerSizeClass: SizingUtils.SizeClass;
891
+ }>, nextContext: any): void;
892
+ componentWillUpdate?(nextProps: Readonly<PerseusInteractiveGraphWidgetOptions & {
893
+ widgetId: string;
894
+ alignment: string | null | undefined;
895
+ static: boolean | null | undefined;
896
+ problemNum: number | null | undefined;
897
+ apiOptions: Readonly<Readonly<{
898
+ isArticle?: boolean | undefined;
899
+ onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
900
+ onFocusChange?: ((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
901
+ GroupMetadataEditor?: React.ComponentType<any> | undefined;
902
+ showAlignmentOptions?: boolean | undefined;
903
+ readOnly?: boolean | undefined;
904
+ answerableCallback?: ((arg1: boolean) => unknown) | undefined;
905
+ getAnotherHint?: (() => unknown) | undefined;
906
+ interactionCallback?: ((widgetData: {
907
+ [widgetId: string]: any;
908
+ }) => void) | undefined;
909
+ groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
910
+ imagePlaceholder?: React.ReactNode; /**
911
+ * The current correct answer for the graph. Updated by this component
912
+ * when the graph is changed.
913
+ *
914
+ * Note that the "Correct answer:" textbox is not an interactive
915
+ * element. Instead, it is a representation of the correct answer based
916
+ * on the state of the interactive graph previewed at the bottom of the
917
+ * editor page.
918
+ */
919
+ widgetPlaceholder?: React.ReactNode;
920
+ baseElements?: {
921
+ Link: React.ComponentType<any>;
922
+ } | undefined;
923
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
924
+ trackInteraction?: ((args: {
925
+ type: string;
926
+ id: string;
927
+ correct?: boolean | undefined;
928
+ } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
929
+ customKeypad?: boolean | undefined;
930
+ nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
931
+ isMobile?: boolean | undefined;
932
+ setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
933
+ useDraftEditor?: boolean | undefined;
934
+ hintProgressColor?: string | undefined;
935
+ canScrollPage?: boolean | undefined;
936
+ inModal?: boolean | undefined;
937
+ crossOutEnabled?: boolean | undefined;
938
+ editorChangeDelay?: number | undefined;
939
+ flags?: Record<string, boolean | Record<string, boolean>> | undefined;
940
+ onWidgetStartProps?: ((widgets: import("@khanacademy/perseus").PerseusWidgetsMap) => import("@khanacademy/perseus").PerseusWidgetsMap) | undefined;
941
+ }> & {
942
+ GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
943
+ baseElements: {
944
+ Link: React.ComponentType<any>;
945
+ };
946
+ canScrollPage: NonNullable<boolean | undefined>;
947
+ crossOutEnabled: NonNullable<boolean | undefined>;
948
+ editorChangeDelay: number;
949
+ groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
950
+ inModal: NonNullable<boolean | undefined>;
951
+ isArticle: NonNullable<boolean | undefined>;
952
+ isMobile: NonNullable<boolean | undefined>;
953
+ onFocusChange: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown;
954
+ onInputError: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
955
+ readOnly: NonNullable<boolean | undefined>;
956
+ setDrawingAreaAvailable: (arg1: boolean) => unknown;
957
+ showAlignmentOptions: NonNullable<boolean | undefined>;
958
+ useDraftEditor: NonNullable<boolean | undefined>;
959
+ }>;
960
+ keypadElement?: any;
961
+ questionCompleted?: boolean | undefined;
962
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
963
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
964
+ findWidgets: (arg1: import("../../../perseus/src/types").FilterCriterion) => readonly any[];
965
+ reviewModeRubric: PerseusInteractiveGraphWidgetOptions;
966
+ onChange: import("@khanacademy/perseus").ChangeHandler;
967
+ trackInteraction: (extraData?: {} | undefined) => void;
968
+ isLastUsedWidget: boolean;
969
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
970
+ containerSizeClass: SizingUtils.SizeClass;
971
+ }>, nextState: Readonly<any>, nextContext: any): void;
972
+ UNSAFE_componentWillUpdate?(nextProps: Readonly<PerseusInteractiveGraphWidgetOptions & {
973
+ widgetId: string;
974
+ alignment: string | null | undefined;
975
+ static: boolean | null | undefined;
976
+ problemNum: number | null | undefined;
977
+ apiOptions: Readonly<Readonly<{
978
+ isArticle?: boolean | undefined;
979
+ onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
980
+ onFocusChange?: ((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
981
+ GroupMetadataEditor?: React.ComponentType<any> | undefined;
982
+ showAlignmentOptions?: boolean | undefined;
983
+ readOnly?: boolean | undefined;
984
+ answerableCallback?: ((arg1: boolean) => unknown) | undefined;
985
+ getAnotherHint?: (() => unknown) | undefined;
986
+ interactionCallback?: ((widgetData: {
987
+ [widgetId: string]: any;
988
+ }) => void) | undefined;
989
+ groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
990
+ imagePlaceholder?: React.ReactNode; /**
991
+ * The current correct answer for the graph. Updated by this component
992
+ * when the graph is changed.
993
+ *
994
+ * Note that the "Correct answer:" textbox is not an interactive
995
+ * element. Instead, it is a representation of the correct answer based
996
+ * on the state of the interactive graph previewed at the bottom of the
997
+ * editor page.
998
+ */
999
+ widgetPlaceholder?: React.ReactNode;
1000
+ baseElements?: {
1001
+ Link: React.ComponentType<any>;
1002
+ } | undefined;
1003
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
1004
+ trackInteraction?: ((args: {
1005
+ type: string;
1006
+ id: string;
1007
+ correct?: boolean | undefined;
1008
+ } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
1009
+ customKeypad?: boolean | undefined;
1010
+ nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
1011
+ isMobile?: boolean | undefined;
1012
+ setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
1013
+ useDraftEditor?: boolean | undefined;
1014
+ hintProgressColor?: string | undefined;
1015
+ canScrollPage?: boolean | undefined;
1016
+ inModal?: boolean | undefined;
1017
+ crossOutEnabled?: boolean | undefined;
1018
+ editorChangeDelay?: number | undefined;
1019
+ flags?: Record<string, boolean | Record<string, boolean>> | undefined;
1020
+ onWidgetStartProps?: ((widgets: import("@khanacademy/perseus").PerseusWidgetsMap) => import("@khanacademy/perseus").PerseusWidgetsMap) | undefined;
1021
+ }> & {
1022
+ GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
1023
+ baseElements: {
1024
+ Link: React.ComponentType<any>;
1025
+ };
1026
+ canScrollPage: NonNullable<boolean | undefined>;
1027
+ crossOutEnabled: NonNullable<boolean | undefined>;
1028
+ editorChangeDelay: number;
1029
+ groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
1030
+ inModal: NonNullable<boolean | undefined>;
1031
+ isArticle: NonNullable<boolean | undefined>;
1032
+ isMobile: NonNullable<boolean | undefined>;
1033
+ onFocusChange: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown;
1034
+ onInputError: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
1035
+ readOnly: NonNullable<boolean | undefined>;
1036
+ setDrawingAreaAvailable: (arg1: boolean) => unknown;
1037
+ showAlignmentOptions: NonNullable<boolean | undefined>;
1038
+ useDraftEditor: NonNullable<boolean | undefined>;
1039
+ }>;
1040
+ keypadElement?: any;
1041
+ questionCompleted?: boolean | undefined;
1042
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
1043
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
1044
+ findWidgets: (arg1: import("../../../perseus/src/types").FilterCriterion) => readonly any[];
1045
+ reviewModeRubric: PerseusInteractiveGraphWidgetOptions;
1046
+ onChange: import("@khanacademy/perseus").ChangeHandler;
1047
+ trackInteraction: (extraData?: {} | undefined) => void;
1048
+ isLastUsedWidget: boolean;
1049
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
1050
+ containerSizeClass: SizingUtils.SizeClass;
1051
+ }>, nextState: Readonly<any>, nextContext: any): void;
1052
+ }>;
175
1053
  mafsRef: React.RefObject<import("../../../perseus/src/renderer").Widget>;
176
- state: any;
177
- UNSAFE_componentWillMount(): void;
178
- componentDidMount(): void;
179
- UNSAFE_componentWillReceiveProps(nextProps: PerseusInteractiveGraphWidgetOptions & {
1054
+ getUserInput: (() => any) | undefined;
1055
+ simpleValidate: (rubric: PerseusInteractiveGraphWidgetOptions) => import("@khanacademy/perseus").PerseusScore;
1056
+ render(): JSX.Element;
1057
+ context: any;
1058
+ setState<K_1 extends string | number | symbol>(state: any, callback?: (() => void) | undefined): void;
1059
+ forceUpdate(callback?: (() => void) | undefined): void;
1060
+ readonly props: Readonly<PerseusInteractiveGraphWidgetOptions & {
180
1061
  widgetId: string;
181
1062
  alignment: string | null | undefined;
182
1063
  static: boolean | null | undefined;
@@ -194,100 +1075,26 @@ declare const InteractiveGraph: {
194
1075
  [widgetId: string]: any;
195
1076
  }) => void) | undefined;
196
1077
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
197
- imagePlaceholder?: React.ReactNode;
198
- widgetPlaceholder?: React.ReactNode;
199
- baseElements?: {
200
- Link: React.ComponentType<any>;
201
- } | undefined;
202
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
203
- * Whether to show the ruler on the graph.
1078
+ imagePlaceholder?: React.ReactNode; /**
1079
+ * The current correct answer for the graph. Updated by this component
1080
+ * when the graph is changed.
1081
+ *
1082
+ * Note that the "Correct answer:" textbox is not an interactive
1083
+ * element. Instead, it is a representation of the correct answer based
1084
+ * on the state of the interactive graph previewed at the bottom of the
1085
+ * editor page.
204
1086
  */
205
- trackInteraction?: ((args: {
206
- type: string;
207
- id: string;
208
- correct?: boolean | undefined;
209
- } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
210
- customKeypad?: boolean | undefined; /**
211
- * Whether to show tooltips on the graph.
212
- * (Currently not used, but will be in the future.)
213
- */
214
- nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
215
- isMobile?: boolean | undefined;
216
- setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
217
- useDraftEditor?: boolean | undefined;
218
- hintProgressColor?: string | undefined;
219
- canScrollPage?: boolean | undefined;
220
- inModal?: boolean | undefined;
221
- crossOutEnabled?: boolean | undefined;
222
- editorChangeDelay?: number | undefined;
223
- flags?: Record<string, boolean | Record<string, boolean>> | undefined;
224
- onWidgetStartProps?: ((widgets: import("@khanacademy/perseus").PerseusWidgetsMap) => import("@khanacademy/perseus").PerseusWidgetsMap) | undefined;
225
- }> & {
226
- GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
227
- baseElements: {
228
- Link: React.ComponentType<any>;
229
- };
230
- canScrollPage: NonNullable<boolean | undefined>;
231
- crossOutEnabled: NonNullable<boolean | undefined>;
232
- editorChangeDelay: number;
233
- groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
234
- inModal: NonNullable<boolean | undefined>;
235
- isArticle: NonNullable<boolean | undefined>;
236
- isMobile: NonNullable<boolean | undefined>;
237
- onFocusChange: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown;
238
- onInputError: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
239
- readOnly: NonNullable<boolean | undefined>;
240
- setDrawingAreaAvailable: (arg1: boolean) => unknown;
241
- showAlignmentOptions: NonNullable<boolean | undefined>;
242
- useDraftEditor: NonNullable<boolean | undefined>;
243
- }>;
244
- keypadElement?: any;
245
- questionCompleted?: boolean | undefined;
246
- onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
247
- onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
248
- findWidgets: (arg1: import("../../../perseus/src/types").FilterCriterion) => readonly any[];
249
- reviewModeRubric: PerseusInteractiveGraphWidgetOptions;
250
- onChange: import("@khanacademy/perseus").ChangeHandler;
251
- trackInteraction: (extraData?: {} | undefined) => void;
252
- isLastUsedWidget: boolean;
253
- linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
254
- containerSizeClass: SizingUtils.SizeClass;
255
- }): void;
256
- componentDidUpdate(prevProps: PerseusInteractiveGraphWidgetOptions & {
257
- widgetId: string;
258
- alignment: string | null | undefined;
259
- static: boolean | null | undefined;
260
- problemNum: number | null | undefined;
261
- apiOptions: Readonly<Readonly<{
262
- isArticle?: boolean | undefined;
263
- onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
264
- onFocusChange?: ((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
265
- GroupMetadataEditor?: React.ComponentType<any> | undefined;
266
- showAlignmentOptions?: boolean | undefined;
267
- readOnly?: boolean | undefined;
268
- answerableCallback?: ((arg1: boolean) => unknown) | undefined;
269
- getAnotherHint?: (() => unknown) | undefined;
270
- interactionCallback?: ((widgetData: {
271
- [widgetId: string]: any;
272
- }) => void) | undefined;
273
- groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
274
- imagePlaceholder?: React.ReactNode;
275
1087
  widgetPlaceholder?: React.ReactNode;
276
1088
  baseElements?: {
277
1089
  Link: React.ComponentType<any>;
278
1090
  } | undefined;
279
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
280
- * Whether to show the ruler on the graph.
281
- */
1091
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
282
1092
  trackInteraction?: ((args: {
283
1093
  type: string;
284
1094
  id: string;
285
1095
  correct?: boolean | undefined;
286
1096
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
287
- customKeypad?: boolean | undefined; /**
288
- * Whether to show tooltips on the graph.
289
- * (Currently not used, but will be in the future.)
290
- */
1097
+ customKeypad?: boolean | undefined;
291
1098
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
292
1099
  isMobile?: boolean | undefined;
293
1100
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -329,8 +1136,15 @@ declare const InteractiveGraph: {
329
1136
  isLastUsedWidget: boolean;
330
1137
  linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
331
1138
  containerSizeClass: SizingUtils.SizeClass;
332
- }, prevState: any): void;
333
- _getShouldShowInstructions: (arg1?: (PerseusInteractiveGraphWidgetOptions & {
1139
+ }> & Readonly<{
1140
+ children?: React.ReactNode;
1141
+ }>;
1142
+ state: Readonly<any>;
1143
+ refs: {
1144
+ [key: string]: React.ReactInstance;
1145
+ };
1146
+ componentDidMount?(): void;
1147
+ shouldComponentUpdate?(nextProps: Readonly<PerseusInteractiveGraphWidgetOptions & {
334
1148
  widgetId: string;
335
1149
  alignment: string | null | undefined;
336
1150
  static: boolean | null | undefined;
@@ -348,114 +1162,26 @@ declare const InteractiveGraph: {
348
1162
  [widgetId: string]: any;
349
1163
  }) => void) | undefined;
350
1164
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
351
- imagePlaceholder?: React.ReactNode;
352
- widgetPlaceholder?: React.ReactNode;
353
- baseElements?: {
354
- Link: React.ComponentType<any>;
355
- } | undefined;
356
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
357
- * Whether to show the ruler on the graph.
1165
+ imagePlaceholder?: React.ReactNode; /**
1166
+ * The current correct answer for the graph. Updated by this component
1167
+ * when the graph is changed.
1168
+ *
1169
+ * Note that the "Correct answer:" textbox is not an interactive
1170
+ * element. Instead, it is a representation of the correct answer based
1171
+ * on the state of the interactive graph previewed at the bottom of the
1172
+ * editor page.
358
1173
  */
359
- trackInteraction?: ((args: {
360
- type: string;
361
- id: string;
362
- correct?: boolean | undefined;
363
- } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
364
- customKeypad?: boolean | undefined; /**
365
- * Whether to show tooltips on the graph.
366
- * (Currently not used, but will be in the future.)
367
- */
368
- nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
369
- isMobile?: boolean | undefined;
370
- setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
371
- useDraftEditor?: boolean | undefined;
372
- hintProgressColor?: string | undefined;
373
- canScrollPage?: boolean | undefined;
374
- inModal?: boolean | undefined;
375
- crossOutEnabled?: boolean | undefined;
376
- editorChangeDelay?: number | undefined;
377
- flags?: Record<string, boolean | Record<string, boolean>> | undefined;
378
- onWidgetStartProps?: ((widgets: import("@khanacademy/perseus").PerseusWidgetsMap) => import("@khanacademy/perseus").PerseusWidgetsMap) | undefined;
379
- }> & {
380
- GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
381
- baseElements: {
382
- Link: React.ComponentType<any>;
383
- };
384
- canScrollPage: NonNullable<boolean | undefined>;
385
- crossOutEnabled: NonNullable<boolean | undefined>;
386
- editorChangeDelay: number;
387
- groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
388
- inModal: NonNullable<boolean | undefined>;
389
- isArticle: NonNullable<boolean | undefined>;
390
- isMobile: NonNullable<boolean | undefined>;
391
- onFocusChange: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown;
392
- onInputError: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
393
- readOnly: NonNullable<boolean | undefined>;
394
- setDrawingAreaAvailable: (arg1: boolean) => unknown;
395
- showAlignmentOptions: NonNullable<boolean | undefined>;
396
- useDraftEditor: NonNullable<boolean | undefined>;
397
- }>;
398
- keypadElement?: any;
399
- questionCompleted?: boolean | undefined;
400
- onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
401
- onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
402
- findWidgets: (arg1: import("../../../perseus/src/types").FilterCriterion) => readonly any[];
403
- reviewModeRubric: PerseusInteractiveGraphWidgetOptions;
404
- onChange: import("@khanacademy/perseus").ChangeHandler;
405
- trackInteraction: (extraData?: {} | undefined) => void;
406
- isLastUsedWidget: boolean;
407
- linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
408
- containerSizeClass: SizingUtils.SizeClass;
409
- }) | null | undefined) => boolean;
410
- deprecatedProps: any;
411
- setGraphie: (arg1: any) => void;
412
- handleAddPointsMouseDown: (arg1: import("@khanacademy/perseus").Coord) => void;
413
- resetGraphie: () => void; /**
414
- * The range of the graph in the x and y directions.
415
- */
416
- setupGraphie: () => void;
417
- showHairlines: (arg1: import("@khanacademy/perseus").Coord) => void;
418
- hideHairlines: () => void;
419
- /**
420
- * How far apart the tick marks on the axes are in the x and y
421
- * directions.
422
- */
423
- setTrashCanVisibility: (arg1: number) => void;
424
- isClickToAddPoints: (arg1?: (PerseusInteractiveGraphWidgetOptions & {
425
- widgetId: string;
426
- alignment: string | null | undefined;
427
- static: boolean | null | undefined;
428
- problemNum: number | null | undefined;
429
- apiOptions: Readonly<Readonly<{
430
- isArticle?: boolean | undefined;
431
- onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
432
- onFocusChange?: ((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
433
- GroupMetadataEditor?: React.ComponentType<any> | undefined;
434
- showAlignmentOptions?: boolean | undefined;
435
- readOnly?: boolean | undefined;
436
- answerableCallback?: ((arg1: boolean) => unknown) | undefined;
437
- getAnotherHint?: (() => unknown) | undefined;
438
- interactionCallback?: ((widgetData: {
439
- [widgetId: string]: any;
440
- }) => void) | undefined;
441
- groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
442
- imagePlaceholder?: React.ReactNode;
443
1174
  widgetPlaceholder?: React.ReactNode;
444
1175
  baseElements?: {
445
1176
  Link: React.ComponentType<any>;
446
1177
  } | undefined;
447
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
448
- * Whether to show the ruler on the graph.
449
- */
1178
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
450
1179
  trackInteraction?: ((args: {
451
1180
  type: string;
452
1181
  id: string;
453
1182
  correct?: boolean | undefined;
454
1183
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
455
- customKeypad?: boolean | undefined; /**
456
- * Whether to show tooltips on the graph.
457
- * (Currently not used, but will be in the future.)
458
- */
1184
+ customKeypad?: boolean | undefined;
459
1185
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
460
1186
  isMobile?: boolean | undefined;
461
1187
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -497,64 +1223,10 @@ declare const InteractiveGraph: {
497
1223
  isLastUsedWidget: boolean;
498
1224
  linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
499
1225
  containerSizeClass: SizingUtils.SizeClass;
500
- }) | null | undefined) => boolean;
501
- areAngleGraphsEqual(prevGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypeAngle, currentGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypeAngle): boolean;
502
- arePointGraphsEqual(prevGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypePoint, currentGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypePoint): boolean;
503
- arePolygonGraphsEqual(prevGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypePolygon, currentGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypePolygon): boolean;
504
- areSegmentGraphsEqual(prevGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypeSegment, currentGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypeSegment): boolean;
505
- _lineStroke: () => {
506
- "stroke-width"?: number | undefined; /**
507
- * The background image to display in the graph area and its properties.
508
- */
509
- };
510
- addLine: (arg1: string) => void;
511
- removeLine: () => void;
512
- addLinearControls: () => void;
513
- removeLinearControls: () => void;
514
- addQuadraticControls: () => void;
515
- updateQuadratic: () => void;
516
- removeQuadraticControls: () => void;
517
- addSinusoidControls: () => void;
518
- updateSinusoid: () => void;
519
- removeSinusoidControls: () => void;
520
- addCircleControls: () => void;
521
- removeCircleControls: () => void;
522
- addLinearSystemControls: () => void;
523
- removeLinearSystemControls: () => void;
524
- isCoordInTrash: (arg1: import("@khanacademy/perseus").Coord) => boolean;
525
- createPointForPointsType: (arg1: import("@khanacademy/perseus").Coord, arg2: number) => any;
526
- removePoint: (arg1: import("@khanacademy/perseus").Coord) => number | null | undefined;
527
- /**
528
- * The label to display on the ruler, if any.
529
- */
530
- createPointForPolygonType: (arg1: import("@khanacademy/perseus").Coord, arg2: number) => any;
531
- updateCoordsFromPoints: () => void;
532
- clearCoords: () => void;
533
- onChange: (arg1: any) => void;
534
- addPointControls: () => void;
535
- removePointControls: () => void;
536
- addSegmentControls: () => void;
537
- removeSegmentControls: () => void;
538
- addRayControls: () => void;
539
- removeRayControls: () => void;
540
- addPolygonControls: () => void;
541
- updatePolygon: () => void;
542
- removePolygonControls: () => void;
543
- addAngleControls: () => void;
544
- removeAngleControls: () => void;
545
- toggleShowSides: () => void; /**
546
- * The locked figures to display in the graph area.
547
- * Locked figures are graph elements (points, lines, line segmeents,
548
- * etc.) that are locked in place and not interactive.
549
- */
550
- getUserInput: () => import("@khanacademy/perseus").PerseusGraphType;
551
- simpleValidate: (rubric: PerseusInteractiveGraphWidgetOptions) => import("@khanacademy/perseus").PerseusScore;
552
- focus: () => void;
553
- render(): React.ReactNode;
554
- context: any;
555
- setState<K extends string | number | symbol>(state: any, callback?: (() => void) | undefined): void;
556
- forceUpdate(callback?: (() => void) | undefined): void;
557
- readonly props: Readonly<PerseusInteractiveGraphWidgetOptions & {
1226
+ }>, nextState: Readonly<any>, nextContext: any): boolean;
1227
+ componentWillUnmount?(): void;
1228
+ componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
1229
+ getSnapshotBeforeUpdate?(prevProps: Readonly<PerseusInteractiveGraphWidgetOptions & {
558
1230
  widgetId: string;
559
1231
  alignment: string | null | undefined;
560
1232
  static: boolean | null | undefined;
@@ -572,23 +1244,26 @@ declare const InteractiveGraph: {
572
1244
  [widgetId: string]: any;
573
1245
  }) => void) | undefined;
574
1246
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
575
- imagePlaceholder?: React.ReactNode;
1247
+ imagePlaceholder?: React.ReactNode; /**
1248
+ * The current correct answer for the graph. Updated by this component
1249
+ * when the graph is changed.
1250
+ *
1251
+ * Note that the "Correct answer:" textbox is not an interactive
1252
+ * element. Instead, it is a representation of the correct answer based
1253
+ * on the state of the interactive graph previewed at the bottom of the
1254
+ * editor page.
1255
+ */
576
1256
  widgetPlaceholder?: React.ReactNode;
577
1257
  baseElements?: {
578
1258
  Link: React.ComponentType<any>;
579
1259
  } | undefined;
580
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
581
- * Whether to show the ruler on the graph.
582
- */
1260
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
583
1261
  trackInteraction?: ((args: {
584
1262
  type: string;
585
1263
  id: string;
586
1264
  correct?: boolean | undefined;
587
1265
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
588
- customKeypad?: boolean | undefined; /**
589
- * Whether to show tooltips on the graph.
590
- * (Currently not used, but will be in the future.)
591
- */
1266
+ customKeypad?: boolean | undefined;
592
1267
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
593
1268
  isMobile?: boolean | undefined;
594
1269
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -630,13 +1305,8 @@ declare const InteractiveGraph: {
630
1305
  isLastUsedWidget: boolean;
631
1306
  linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
632
1307
  containerSizeClass: SizingUtils.SizeClass;
633
- }> & Readonly<{
634
- children?: React.ReactNode;
635
- }>;
636
- refs: {
637
- [key: string]: React.ReactInstance;
638
- };
639
- shouldComponentUpdate?(nextProps: Readonly<PerseusInteractiveGraphWidgetOptions & {
1308
+ }>, prevState: Readonly<any>): any;
1309
+ componentDidUpdate?(prevProps: Readonly<PerseusInteractiveGraphWidgetOptions & {
640
1310
  widgetId: string;
641
1311
  alignment: string | null | undefined;
642
1312
  static: boolean | null | undefined;
@@ -654,23 +1324,26 @@ declare const InteractiveGraph: {
654
1324
  [widgetId: string]: any;
655
1325
  }) => void) | undefined;
656
1326
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
657
- imagePlaceholder?: React.ReactNode;
1327
+ imagePlaceholder?: React.ReactNode; /**
1328
+ * The current correct answer for the graph. Updated by this component
1329
+ * when the graph is changed.
1330
+ *
1331
+ * Note that the "Correct answer:" textbox is not an interactive
1332
+ * element. Instead, it is a representation of the correct answer based
1333
+ * on the state of the interactive graph previewed at the bottom of the
1334
+ * editor page.
1335
+ */
658
1336
  widgetPlaceholder?: React.ReactNode;
659
1337
  baseElements?: {
660
1338
  Link: React.ComponentType<any>;
661
1339
  } | undefined;
662
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
663
- * Whether to show the ruler on the graph.
664
- */
1340
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
665
1341
  trackInteraction?: ((args: {
666
1342
  type: string;
667
1343
  id: string;
668
1344
  correct?: boolean | undefined;
669
1345
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
670
- customKeypad?: boolean | undefined; /**
671
- * Whether to show tooltips on the graph.
672
- * (Currently not used, but will be in the future.)
673
- */
1346
+ customKeypad?: boolean | undefined;
674
1347
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
675
1348
  isMobile?: boolean | undefined;
676
1349
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -712,10 +1385,10 @@ declare const InteractiveGraph: {
712
1385
  isLastUsedWidget: boolean;
713
1386
  linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
714
1387
  containerSizeClass: SizingUtils.SizeClass;
715
- }>, nextState: Readonly<any>, nextContext: any): boolean;
716
- componentWillUnmount?(): void;
717
- componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
718
- getSnapshotBeforeUpdate?(prevProps: Readonly<PerseusInteractiveGraphWidgetOptions & {
1388
+ }>, prevState: Readonly<any>, snapshot?: any): void;
1389
+ componentWillMount?(): void;
1390
+ UNSAFE_componentWillMount?(): void;
1391
+ componentWillReceiveProps?(nextProps: Readonly<PerseusInteractiveGraphWidgetOptions & {
719
1392
  widgetId: string;
720
1393
  alignment: string | null | undefined;
721
1394
  static: boolean | null | undefined;
@@ -733,23 +1406,26 @@ declare const InteractiveGraph: {
733
1406
  [widgetId: string]: any;
734
1407
  }) => void) | undefined;
735
1408
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
736
- imagePlaceholder?: React.ReactNode;
1409
+ imagePlaceholder?: React.ReactNode; /**
1410
+ * The current correct answer for the graph. Updated by this component
1411
+ * when the graph is changed.
1412
+ *
1413
+ * Note that the "Correct answer:" textbox is not an interactive
1414
+ * element. Instead, it is a representation of the correct answer based
1415
+ * on the state of the interactive graph previewed at the bottom of the
1416
+ * editor page.
1417
+ */
737
1418
  widgetPlaceholder?: React.ReactNode;
738
1419
  baseElements?: {
739
1420
  Link: React.ComponentType<any>;
740
1421
  } | undefined;
741
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
742
- * Whether to show the ruler on the graph.
743
- */
1422
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
744
1423
  trackInteraction?: ((args: {
745
1424
  type: string;
746
1425
  id: string;
747
1426
  correct?: boolean | undefined;
748
1427
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
749
- customKeypad?: boolean | undefined; /**
750
- * Whether to show tooltips on the graph.
751
- * (Currently not used, but will be in the future.)
752
- */
1428
+ customKeypad?: boolean | undefined;
753
1429
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
754
1430
  isMobile?: boolean | undefined;
755
1431
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -791,9 +1467,8 @@ declare const InteractiveGraph: {
791
1467
  isLastUsedWidget: boolean;
792
1468
  linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
793
1469
  containerSizeClass: SizingUtils.SizeClass;
794
- }>, prevState: Readonly<any>): any;
795
- componentWillMount?(): void;
796
- componentWillReceiveProps?(nextProps: Readonly<PerseusInteractiveGraphWidgetOptions & {
1470
+ }>, nextContext: any): void;
1471
+ UNSAFE_componentWillReceiveProps?(nextProps: Readonly<PerseusInteractiveGraphWidgetOptions & {
797
1472
  widgetId: string;
798
1473
  alignment: string | null | undefined;
799
1474
  static: boolean | null | undefined;
@@ -811,23 +1486,26 @@ declare const InteractiveGraph: {
811
1486
  [widgetId: string]: any;
812
1487
  }) => void) | undefined;
813
1488
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
814
- imagePlaceholder?: React.ReactNode;
1489
+ imagePlaceholder?: React.ReactNode; /**
1490
+ * The current correct answer for the graph. Updated by this component
1491
+ * when the graph is changed.
1492
+ *
1493
+ * Note that the "Correct answer:" textbox is not an interactive
1494
+ * element. Instead, it is a representation of the correct answer based
1495
+ * on the state of the interactive graph previewed at the bottom of the
1496
+ * editor page.
1497
+ */
815
1498
  widgetPlaceholder?: React.ReactNode;
816
1499
  baseElements?: {
817
1500
  Link: React.ComponentType<any>;
818
1501
  } | undefined;
819
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
820
- * Whether to show the ruler on the graph.
821
- */
1502
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
822
1503
  trackInteraction?: ((args: {
823
1504
  type: string;
824
1505
  id: string;
825
1506
  correct?: boolean | undefined;
826
1507
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
827
- customKeypad?: boolean | undefined; /**
828
- * Whether to show tooltips on the graph.
829
- * (Currently not used, but will be in the future.)
830
- */
1508
+ customKeypad?: boolean | undefined;
831
1509
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
832
1510
  isMobile?: boolean | undefined;
833
1511
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -888,23 +1566,26 @@ declare const InteractiveGraph: {
888
1566
  [widgetId: string]: any;
889
1567
  }) => void) | undefined;
890
1568
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
891
- imagePlaceholder?: React.ReactNode;
1569
+ imagePlaceholder?: React.ReactNode; /**
1570
+ * The current correct answer for the graph. Updated by this component
1571
+ * when the graph is changed.
1572
+ *
1573
+ * Note that the "Correct answer:" textbox is not an interactive
1574
+ * element. Instead, it is a representation of the correct answer based
1575
+ * on the state of the interactive graph previewed at the bottom of the
1576
+ * editor page.
1577
+ */
892
1578
  widgetPlaceholder?: React.ReactNode;
893
1579
  baseElements?: {
894
1580
  Link: React.ComponentType<any>;
895
1581
  } | undefined;
896
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
897
- * Whether to show the ruler on the graph.
898
- */
1582
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
899
1583
  trackInteraction?: ((args: {
900
1584
  type: string;
901
1585
  id: string;
902
1586
  correct?: boolean | undefined;
903
1587
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
904
- customKeypad?: boolean | undefined; /**
905
- * Whether to show tooltips on the graph.
906
- * (Currently not used, but will be in the future.)
907
- */
1588
+ customKeypad?: boolean | undefined;
908
1589
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
909
1590
  isMobile?: boolean | undefined;
910
1591
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -965,23 +1646,26 @@ declare const InteractiveGraph: {
965
1646
  [widgetId: string]: any;
966
1647
  }) => void) | undefined;
967
1648
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
968
- imagePlaceholder?: React.ReactNode;
1649
+ imagePlaceholder?: React.ReactNode; /**
1650
+ * The current correct answer for the graph. Updated by this component
1651
+ * when the graph is changed.
1652
+ *
1653
+ * Note that the "Correct answer:" textbox is not an interactive
1654
+ * element. Instead, it is a representation of the correct answer based
1655
+ * on the state of the interactive graph previewed at the bottom of the
1656
+ * editor page.
1657
+ */
969
1658
  widgetPlaceholder?: React.ReactNode;
970
1659
  baseElements?: {
971
1660
  Link: React.ComponentType<any>;
972
1661
  } | undefined;
973
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
974
- * Whether to show the ruler on the graph.
975
- */
1662
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
976
1663
  trackInteraction?: ((args: {
977
1664
  type: string;
978
1665
  id: string;
979
1666
  correct?: boolean | undefined;
980
1667
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
981
- customKeypad?: boolean | undefined; /**
982
- * Whether to show tooltips on the graph.
983
- * (Currently not used, but will be in the future.)
984
- */
1668
+ customKeypad?: boolean | undefined;
985
1669
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
986
1670
  isMobile?: boolean | undefined;
987
1671
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -1043,23 +1727,26 @@ declare const InteractiveGraph: {
1043
1727
  [widgetId: string]: any;
1044
1728
  }) => void) | undefined;
1045
1729
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
1046
- imagePlaceholder?: React.ReactNode;
1730
+ imagePlaceholder?: React.ReactNode; /**
1731
+ * The current correct answer for the graph. Updated by this component
1732
+ * when the graph is changed.
1733
+ *
1734
+ * Note that the "Correct answer:" textbox is not an interactive
1735
+ * element. Instead, it is a representation of the correct answer based
1736
+ * on the state of the interactive graph previewed at the bottom of the
1737
+ * editor page.
1738
+ */
1047
1739
  widgetPlaceholder?: React.ReactNode;
1048
1740
  baseElements?: {
1049
1741
  Link: React.ComponentType<any>;
1050
1742
  } | undefined;
1051
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
1052
- * Whether to show the ruler on the graph.
1053
- */
1743
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
1054
1744
  trackInteraction?: ((args: {
1055
1745
  type: string;
1056
1746
  id: string;
1057
1747
  correct?: boolean | undefined;
1058
1748
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
1059
- customKeypad?: boolean | undefined; /**
1060
- * Whether to show tooltips on the graph.
1061
- * (Currently not used, but will be in the future.)
1062
- */
1749
+ customKeypad?: boolean | undefined;
1063
1750
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
1064
1751
  isMobile?: boolean | undefined;
1065
1752
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -1102,27 +1789,902 @@ declare const InteractiveGraph: {
1102
1789
  linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
1103
1790
  containerSizeClass: SizingUtils.SizeClass;
1104
1791
  }, context: any): {
1105
- angle: any;
1106
- circle: any;
1107
- graphie: any;
1108
- horizHairline: any;
1109
- line: any;
1110
- lines: readonly (readonly import("@khanacademy/perseus").Coord[])[] | null | undefined;
1111
- parabola: any;
1112
- pointA: any;
1113
- pointB: any;
1114
- pointC: any;
1115
- points: any[];
1116
- polygon: any;
1117
- shouldResetGraphie: boolean;
1118
- sinusoid: any;
1119
- trashCan: any;
1120
- vertHairline: any;
1792
+ legacyGraphRef: React.RefObject<{
1793
+ angle: any;
1794
+ circle: any;
1795
+ graphie: any;
1796
+ horizHairline: any;
1797
+ line: any;
1798
+ lines: readonly (readonly import("@khanacademy/perseus").Coord[])[] | null | undefined;
1799
+ parabola: any;
1800
+ pointA: any;
1801
+ pointB: any;
1802
+ pointC: any;
1803
+ points: any[];
1804
+ polygon: any;
1805
+ shouldResetGraphie: boolean;
1806
+ sinusoid: any;
1807
+ trashCan: any;
1808
+ vertHairline: any;
1809
+ state: any;
1810
+ UNSAFE_componentWillMount(): void;
1811
+ componentDidMount(): void;
1812
+ UNSAFE_componentWillReceiveProps(nextProps: PerseusInteractiveGraphWidgetOptions & {
1813
+ widgetId: string;
1814
+ alignment: string | null | undefined;
1815
+ static: boolean | null | undefined;
1816
+ problemNum: number | null | undefined;
1817
+ apiOptions: Readonly<Readonly<{
1818
+ isArticle?: boolean | undefined;
1819
+ onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
1820
+ onFocusChange?: ((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
1821
+ GroupMetadataEditor?: React.ComponentType<any> | undefined;
1822
+ showAlignmentOptions?: boolean | undefined;
1823
+ readOnly?: boolean | undefined;
1824
+ answerableCallback?: ((arg1: boolean) => unknown) | undefined;
1825
+ getAnotherHint?: (() => unknown) | undefined;
1826
+ interactionCallback?: ((widgetData: {
1827
+ [widgetId: string]: any;
1828
+ }) => void) | undefined;
1829
+ groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
1830
+ imagePlaceholder?: React.ReactNode; /**
1831
+ * The current correct answer for the graph. Updated by this component
1832
+ * when the graph is changed.
1833
+ *
1834
+ * Note that the "Correct answer:" textbox is not an interactive
1835
+ * element. Instead, it is a representation of the correct answer based
1836
+ * on the state of the interactive graph previewed at the bottom of the
1837
+ * editor page.
1838
+ */
1839
+ widgetPlaceholder?: React.ReactNode;
1840
+ baseElements?: {
1841
+ Link: React.ComponentType<any>;
1842
+ } | undefined;
1843
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
1844
+ trackInteraction?: ((args: {
1845
+ type: string;
1846
+ id: string;
1847
+ correct?: boolean | undefined;
1848
+ } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
1849
+ customKeypad?: boolean | undefined;
1850
+ nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
1851
+ isMobile?: boolean | undefined;
1852
+ setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
1853
+ useDraftEditor?: boolean | undefined;
1854
+ hintProgressColor?: string | undefined;
1855
+ canScrollPage?: boolean | undefined;
1856
+ inModal?: boolean | undefined;
1857
+ crossOutEnabled?: boolean | undefined;
1858
+ editorChangeDelay?: number | undefined;
1859
+ flags?: Record<string, boolean | Record<string, boolean>> | undefined;
1860
+ onWidgetStartProps?: ((widgets: import("@khanacademy/perseus").PerseusWidgetsMap) => import("@khanacademy/perseus").PerseusWidgetsMap) | undefined;
1861
+ }> & {
1862
+ GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
1863
+ baseElements: {
1864
+ Link: React.ComponentType<any>;
1865
+ };
1866
+ canScrollPage: NonNullable<boolean | undefined>;
1867
+ crossOutEnabled: NonNullable<boolean | undefined>;
1868
+ editorChangeDelay: number;
1869
+ groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
1870
+ inModal: NonNullable<boolean | undefined>;
1871
+ isArticle: NonNullable<boolean | undefined>;
1872
+ isMobile: NonNullable<boolean | undefined>;
1873
+ onFocusChange: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown;
1874
+ onInputError: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
1875
+ readOnly: NonNullable<boolean | undefined>;
1876
+ setDrawingAreaAvailable: (arg1: boolean) => unknown;
1877
+ showAlignmentOptions: NonNullable<boolean | undefined>;
1878
+ useDraftEditor: NonNullable<boolean | undefined>;
1879
+ }>;
1880
+ keypadElement?: any;
1881
+ questionCompleted?: boolean | undefined;
1882
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
1883
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
1884
+ findWidgets: (arg1: import("../../../perseus/src/types").FilterCriterion) => readonly any[];
1885
+ reviewModeRubric: PerseusInteractiveGraphWidgetOptions;
1886
+ onChange: import("@khanacademy/perseus").ChangeHandler;
1887
+ trackInteraction: (extraData?: {} | undefined) => void;
1888
+ isLastUsedWidget: boolean;
1889
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
1890
+ containerSizeClass: SizingUtils.SizeClass;
1891
+ }): void;
1892
+ componentDidUpdate(prevProps: PerseusInteractiveGraphWidgetOptions & {
1893
+ widgetId: string;
1894
+ alignment: string | null | undefined;
1895
+ static: boolean | null | undefined;
1896
+ problemNum: number | null | undefined;
1897
+ apiOptions: Readonly<Readonly<{
1898
+ isArticle?: boolean | undefined;
1899
+ onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
1900
+ onFocusChange?: ((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
1901
+ GroupMetadataEditor?: React.ComponentType<any> | undefined;
1902
+ showAlignmentOptions?: boolean | undefined;
1903
+ readOnly?: boolean | undefined;
1904
+ answerableCallback?: ((arg1: boolean) => unknown) | undefined;
1905
+ getAnotherHint?: (() => unknown) | undefined;
1906
+ interactionCallback?: ((widgetData: {
1907
+ [widgetId: string]: any;
1908
+ }) => void) | undefined;
1909
+ groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
1910
+ imagePlaceholder?: React.ReactNode; /**
1911
+ * The current correct answer for the graph. Updated by this component
1912
+ * when the graph is changed.
1913
+ *
1914
+ * Note that the "Correct answer:" textbox is not an interactive
1915
+ * element. Instead, it is a representation of the correct answer based
1916
+ * on the state of the interactive graph previewed at the bottom of the
1917
+ * editor page.
1918
+ */
1919
+ widgetPlaceholder?: React.ReactNode;
1920
+ baseElements?: {
1921
+ Link: React.ComponentType<any>;
1922
+ } | undefined;
1923
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
1924
+ trackInteraction?: ((args: {
1925
+ type: string;
1926
+ id: string;
1927
+ correct?: boolean | undefined;
1928
+ } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
1929
+ customKeypad?: boolean | undefined;
1930
+ nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
1931
+ isMobile?: boolean | undefined;
1932
+ setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
1933
+ useDraftEditor?: boolean | undefined;
1934
+ hintProgressColor?: string | undefined;
1935
+ canScrollPage?: boolean | undefined;
1936
+ inModal?: boolean | undefined;
1937
+ crossOutEnabled?: boolean | undefined;
1938
+ editorChangeDelay?: number | undefined;
1939
+ flags?: Record<string, boolean | Record<string, boolean>> | undefined;
1940
+ onWidgetStartProps?: ((widgets: import("@khanacademy/perseus").PerseusWidgetsMap) => import("@khanacademy/perseus").PerseusWidgetsMap) | undefined;
1941
+ }> & {
1942
+ GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
1943
+ baseElements: {
1944
+ Link: React.ComponentType<any>;
1945
+ };
1946
+ canScrollPage: NonNullable<boolean | undefined>;
1947
+ crossOutEnabled: NonNullable<boolean | undefined>;
1948
+ editorChangeDelay: number;
1949
+ groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
1950
+ inModal: NonNullable<boolean | undefined>;
1951
+ isArticle: NonNullable<boolean | undefined>;
1952
+ isMobile: NonNullable<boolean | undefined>;
1953
+ onFocusChange: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown;
1954
+ onInputError: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
1955
+ readOnly: NonNullable<boolean | undefined>;
1956
+ setDrawingAreaAvailable: (arg1: boolean) => unknown;
1957
+ showAlignmentOptions: NonNullable<boolean | undefined>;
1958
+ useDraftEditor: NonNullable<boolean | undefined>;
1959
+ }>;
1960
+ keypadElement?: any;
1961
+ questionCompleted?: boolean | undefined;
1962
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
1963
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
1964
+ findWidgets: (arg1: import("../../../perseus/src/types").FilterCriterion) => readonly any[];
1965
+ reviewModeRubric: PerseusInteractiveGraphWidgetOptions;
1966
+ onChange: import("@khanacademy/perseus").ChangeHandler;
1967
+ trackInteraction: (extraData?: {} | undefined) => void;
1968
+ isLastUsedWidget: boolean;
1969
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
1970
+ containerSizeClass: SizingUtils.SizeClass;
1971
+ }, prevState: any): void;
1972
+ _getShouldShowInstructions: (arg1?: (PerseusInteractiveGraphWidgetOptions & {
1973
+ widgetId: string;
1974
+ alignment: string | null | undefined;
1975
+ static: boolean | null | undefined;
1976
+ problemNum: number | null | undefined;
1977
+ apiOptions: Readonly<Readonly<{
1978
+ isArticle?: boolean | undefined;
1979
+ onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
1980
+ onFocusChange?: ((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
1981
+ GroupMetadataEditor?: React.ComponentType<any> | undefined;
1982
+ showAlignmentOptions?: boolean | undefined;
1983
+ readOnly?: boolean | undefined;
1984
+ answerableCallback?: ((arg1: boolean) => unknown) | undefined;
1985
+ getAnotherHint?: (() => unknown) | undefined;
1986
+ interactionCallback?: ((widgetData: {
1987
+ [widgetId: string]: any;
1988
+ }) => void) | undefined;
1989
+ groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
1990
+ imagePlaceholder?: React.ReactNode; /**
1991
+ * The current correct answer for the graph. Updated by this component
1992
+ * when the graph is changed.
1993
+ *
1994
+ * Note that the "Correct answer:" textbox is not an interactive
1995
+ * element. Instead, it is a representation of the correct answer based
1996
+ * on the state of the interactive graph previewed at the bottom of the
1997
+ * editor page.
1998
+ */
1999
+ widgetPlaceholder?: React.ReactNode;
2000
+ baseElements?: {
2001
+ Link: React.ComponentType<any>;
2002
+ } | undefined;
2003
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
2004
+ trackInteraction?: ((args: {
2005
+ type: string;
2006
+ id: string;
2007
+ correct?: boolean | undefined;
2008
+ } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
2009
+ customKeypad?: boolean | undefined;
2010
+ nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
2011
+ isMobile?: boolean | undefined;
2012
+ setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
2013
+ useDraftEditor?: boolean | undefined;
2014
+ hintProgressColor?: string | undefined;
2015
+ canScrollPage?: boolean | undefined;
2016
+ inModal?: boolean | undefined;
2017
+ crossOutEnabled?: boolean | undefined;
2018
+ editorChangeDelay?: number | undefined;
2019
+ flags?: Record<string, boolean | Record<string, boolean>> | undefined;
2020
+ onWidgetStartProps?: ((widgets: import("@khanacademy/perseus").PerseusWidgetsMap) => import("@khanacademy/perseus").PerseusWidgetsMap) | undefined;
2021
+ }> & {
2022
+ GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
2023
+ baseElements: {
2024
+ Link: React.ComponentType<any>;
2025
+ };
2026
+ canScrollPage: NonNullable<boolean | undefined>;
2027
+ crossOutEnabled: NonNullable<boolean | undefined>;
2028
+ editorChangeDelay: number;
2029
+ groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
2030
+ inModal: NonNullable<boolean | undefined>;
2031
+ isArticle: NonNullable<boolean | undefined>;
2032
+ isMobile: NonNullable<boolean | undefined>;
2033
+ onFocusChange: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown;
2034
+ onInputError: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
2035
+ readOnly: NonNullable<boolean | undefined>;
2036
+ setDrawingAreaAvailable: (arg1: boolean) => unknown;
2037
+ showAlignmentOptions: NonNullable<boolean | undefined>;
2038
+ useDraftEditor: NonNullable<boolean | undefined>;
2039
+ }>;
2040
+ keypadElement?: any;
2041
+ questionCompleted?: boolean | undefined;
2042
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2043
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2044
+ findWidgets: (arg1: import("../../../perseus/src/types").FilterCriterion) => readonly any[];
2045
+ reviewModeRubric: PerseusInteractiveGraphWidgetOptions;
2046
+ onChange: import("@khanacademy/perseus").ChangeHandler;
2047
+ trackInteraction: (extraData?: {} | undefined) => void;
2048
+ isLastUsedWidget: boolean;
2049
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
2050
+ containerSizeClass: SizingUtils.SizeClass;
2051
+ }) | null | undefined) => boolean;
2052
+ deprecatedProps: any;
2053
+ setGraphie: (arg1: any) => void;
2054
+ handleAddPointsMouseDown: (arg1: import("@khanacademy/perseus").Coord) => void;
2055
+ resetGraphie: () => void;
2056
+ setupGraphie: () => void; /**
2057
+ * The range of the graph in the x and y directions.
2058
+ */
2059
+ showHairlines: (arg1: import("@khanacademy/perseus").Coord) => void;
2060
+ hideHairlines: () => void;
2061
+ setTrashCanVisibility: (arg1: number) => void;
2062
+ isClickToAddPoints: (arg1?: (PerseusInteractiveGraphWidgetOptions & {
2063
+ widgetId: string;
2064
+ alignment: string | null | undefined;
2065
+ static: boolean | null | undefined;
2066
+ problemNum: number | null | undefined;
2067
+ apiOptions: Readonly<Readonly<{
2068
+ isArticle?: boolean | undefined;
2069
+ onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
2070
+ onFocusChange?: ((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
2071
+ GroupMetadataEditor?: React.ComponentType<any> | undefined;
2072
+ showAlignmentOptions?: boolean | undefined;
2073
+ readOnly?: boolean | undefined;
2074
+ answerableCallback?: ((arg1: boolean) => unknown) | undefined;
2075
+ getAnotherHint?: (() => unknown) | undefined;
2076
+ interactionCallback?: ((widgetData: {
2077
+ [widgetId: string]: any;
2078
+ }) => void) | undefined;
2079
+ groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
2080
+ imagePlaceholder?: React.ReactNode; /**
2081
+ * The current correct answer for the graph. Updated by this component
2082
+ * when the graph is changed.
2083
+ *
2084
+ * Note that the "Correct answer:" textbox is not an interactive
2085
+ * element. Instead, it is a representation of the correct answer based
2086
+ * on the state of the interactive graph previewed at the bottom of the
2087
+ * editor page.
2088
+ */
2089
+ widgetPlaceholder?: React.ReactNode;
2090
+ baseElements?: {
2091
+ Link: React.ComponentType<any>;
2092
+ } | undefined;
2093
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
2094
+ trackInteraction?: ((args: {
2095
+ type: string;
2096
+ id: string;
2097
+ correct?: boolean | undefined;
2098
+ } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
2099
+ customKeypad?: boolean | undefined;
2100
+ nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
2101
+ isMobile?: boolean | undefined;
2102
+ setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
2103
+ useDraftEditor?: boolean | undefined;
2104
+ hintProgressColor?: string | undefined;
2105
+ canScrollPage?: boolean | undefined;
2106
+ inModal?: boolean | undefined;
2107
+ crossOutEnabled?: boolean | undefined;
2108
+ editorChangeDelay?: number | undefined;
2109
+ flags?: Record<string, boolean | Record<string, boolean>> | undefined;
2110
+ onWidgetStartProps?: ((widgets: import("@khanacademy/perseus").PerseusWidgetsMap) => import("@khanacademy/perseus").PerseusWidgetsMap) | undefined;
2111
+ }> & {
2112
+ GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
2113
+ baseElements: {
2114
+ Link: React.ComponentType<any>;
2115
+ };
2116
+ canScrollPage: NonNullable<boolean | undefined>;
2117
+ crossOutEnabled: NonNullable<boolean | undefined>;
2118
+ editorChangeDelay: number;
2119
+ groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
2120
+ inModal: NonNullable<boolean | undefined>;
2121
+ isArticle: NonNullable<boolean | undefined>;
2122
+ isMobile: NonNullable<boolean | undefined>;
2123
+ onFocusChange: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown;
2124
+ onInputError: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
2125
+ readOnly: NonNullable<boolean | undefined>;
2126
+ setDrawingAreaAvailable: (arg1: boolean) => unknown;
2127
+ showAlignmentOptions: NonNullable<boolean | undefined>;
2128
+ useDraftEditor: NonNullable<boolean | undefined>;
2129
+ }>;
2130
+ keypadElement?: any;
2131
+ questionCompleted?: boolean | undefined;
2132
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2133
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2134
+ findWidgets: (arg1: import("../../../perseus/src/types").FilterCriterion) => readonly any[];
2135
+ reviewModeRubric: PerseusInteractiveGraphWidgetOptions;
2136
+ onChange: import("@khanacademy/perseus").ChangeHandler;
2137
+ trackInteraction: (extraData?: {} | undefined) => void;
2138
+ isLastUsedWidget: boolean;
2139
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
2140
+ containerSizeClass: SizingUtils.SizeClass;
2141
+ }) | null | undefined) => boolean;
2142
+ areAngleGraphsEqual(prevGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypeAngle, currentGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypeAngle): boolean;
2143
+ arePointGraphsEqual(prevGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypePoint, currentGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypePoint): boolean;
2144
+ arePolygonGraphsEqual(prevGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypePolygon, currentGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypePolygon): boolean;
2145
+ areSegmentGraphsEqual(prevGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypeSegment, currentGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypeSegment): boolean;
2146
+ _lineStroke: () => {
2147
+ "stroke-width"?: number | undefined;
2148
+ };
2149
+ addLine: (arg1: string) => void;
2150
+ removeLine: () => void;
2151
+ addLinearControls: () => void;
2152
+ removeLinearControls: () => void;
2153
+ addQuadraticControls: () => void;
2154
+ updateQuadratic: () => void;
2155
+ removeQuadraticControls: () => void;
2156
+ addSinusoidControls: () => void;
2157
+ updateSinusoid: () => void;
2158
+ removeSinusoidControls: () => void;
2159
+ addCircleControls: () => void; /**
2160
+ * Whether to show the protractor on the graph.
2161
+ */
2162
+ removeCircleControls: () => void;
2163
+ addLinearSystemControls: () => void;
2164
+ removeLinearSystemControls: () => void;
2165
+ isCoordInTrash: (arg1: import("@khanacademy/perseus").Coord) => boolean;
2166
+ createPointForPointsType: (arg1: import("@khanacademy/perseus").Coord, arg2: number) => any;
2167
+ removePoint: (arg1: import("@khanacademy/perseus").Coord) => number | null | undefined;
2168
+ createPointForPolygonType: (arg1: import("@khanacademy/perseus").Coord, arg2: number) => any;
2169
+ updateCoordsFromPoints: () => void;
2170
+ clearCoords: () => void;
2171
+ onChange: (arg1: any) => void;
2172
+ addPointControls: () => void;
2173
+ removePointControls: () => void;
2174
+ addSegmentControls: () => void;
2175
+ removeSegmentControls: () => void;
2176
+ addRayControls: () => void;
2177
+ removeRayControls: () => void;
2178
+ addPolygonControls: () => void;
2179
+ updatePolygon: () => void;
2180
+ removePolygonControls: () => void;
2181
+ addAngleControls: () => void;
2182
+ removeAngleControls: () => void;
2183
+ toggleShowSides: () => void;
2184
+ getUserInput: () => import("@khanacademy/perseus").PerseusGraphType;
2185
+ simpleValidate: (rubric: PerseusInteractiveGraphWidgetOptions) => import("@khanacademy/perseus").PerseusScore;
2186
+ focus: () => void;
2187
+ render(): React.ReactNode;
2188
+ context: any;
2189
+ setState<K extends string | number | symbol>(state: any, callback?: (() => void) | undefined): void;
2190
+ forceUpdate(callback?: (() => void) | undefined): void;
2191
+ readonly props: Readonly<PerseusInteractiveGraphWidgetOptions & {
2192
+ widgetId: string;
2193
+ alignment: string | null | undefined;
2194
+ static: boolean | null | undefined;
2195
+ problemNum: number | null | undefined;
2196
+ apiOptions: Readonly<Readonly<{
2197
+ isArticle?: boolean | undefined;
2198
+ onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
2199
+ onFocusChange?: ((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
2200
+ GroupMetadataEditor?: React.ComponentType<any> | undefined;
2201
+ showAlignmentOptions?: boolean | undefined;
2202
+ readOnly?: boolean | undefined;
2203
+ answerableCallback?: ((arg1: boolean) => unknown) | undefined;
2204
+ getAnotherHint?: (() => unknown) | undefined;
2205
+ interactionCallback?: ((widgetData: {
2206
+ [widgetId: string]: any;
2207
+ }) => void) | undefined;
2208
+ groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
2209
+ imagePlaceholder?: React.ReactNode; /**
2210
+ * The current correct answer for the graph. Updated by this component
2211
+ * when the graph is changed.
2212
+ *
2213
+ * Note that the "Correct answer:" textbox is not an interactive
2214
+ * element. Instead, it is a representation of the correct answer based
2215
+ * on the state of the interactive graph previewed at the bottom of the
2216
+ * editor page.
2217
+ */
2218
+ widgetPlaceholder?: React.ReactNode;
2219
+ baseElements?: {
2220
+ Link: React.ComponentType<any>;
2221
+ } | undefined;
2222
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
2223
+ trackInteraction?: ((args: {
2224
+ type: string;
2225
+ id: string;
2226
+ correct?: boolean | undefined;
2227
+ } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
2228
+ customKeypad?: boolean | undefined;
2229
+ nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
2230
+ isMobile?: boolean | undefined;
2231
+ setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
2232
+ useDraftEditor?: boolean | undefined;
2233
+ hintProgressColor?: string | undefined;
2234
+ canScrollPage?: boolean | undefined;
2235
+ inModal?: boolean | undefined;
2236
+ crossOutEnabled?: boolean | undefined;
2237
+ editorChangeDelay?: number | undefined;
2238
+ flags?: Record<string, boolean | Record<string, boolean>> | undefined;
2239
+ onWidgetStartProps?: ((widgets: import("@khanacademy/perseus").PerseusWidgetsMap) => import("@khanacademy/perseus").PerseusWidgetsMap) | undefined;
2240
+ }> & {
2241
+ GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
2242
+ baseElements: {
2243
+ Link: React.ComponentType<any>;
2244
+ };
2245
+ canScrollPage: NonNullable<boolean | undefined>;
2246
+ crossOutEnabled: NonNullable<boolean | undefined>;
2247
+ editorChangeDelay: number;
2248
+ groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
2249
+ inModal: NonNullable<boolean | undefined>;
2250
+ isArticle: NonNullable<boolean | undefined>;
2251
+ isMobile: NonNullable<boolean | undefined>;
2252
+ onFocusChange: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown;
2253
+ onInputError: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
2254
+ readOnly: NonNullable<boolean | undefined>;
2255
+ setDrawingAreaAvailable: (arg1: boolean) => unknown;
2256
+ showAlignmentOptions: NonNullable<boolean | undefined>;
2257
+ useDraftEditor: NonNullable<boolean | undefined>;
2258
+ }>;
2259
+ keypadElement?: any;
2260
+ questionCompleted?: boolean | undefined;
2261
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2262
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2263
+ findWidgets: (arg1: import("../../../perseus/src/types").FilterCriterion) => readonly any[];
2264
+ reviewModeRubric: PerseusInteractiveGraphWidgetOptions;
2265
+ onChange: import("@khanacademy/perseus").ChangeHandler;
2266
+ trackInteraction: (extraData?: {} | undefined) => void;
2267
+ isLastUsedWidget: boolean;
2268
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
2269
+ containerSizeClass: SizingUtils.SizeClass;
2270
+ }> & Readonly<{
2271
+ children?: React.ReactNode;
2272
+ }>;
2273
+ refs: {
2274
+ [key: string]: React.ReactInstance;
2275
+ };
2276
+ shouldComponentUpdate?(nextProps: Readonly<PerseusInteractiveGraphWidgetOptions & {
2277
+ widgetId: string;
2278
+ alignment: string | null | undefined;
2279
+ static: boolean | null | undefined;
2280
+ problemNum: number | null | undefined;
2281
+ apiOptions: Readonly<Readonly<{
2282
+ isArticle?: boolean | undefined;
2283
+ onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
2284
+ onFocusChange?: ((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
2285
+ GroupMetadataEditor?: React.ComponentType<any> | undefined;
2286
+ showAlignmentOptions?: boolean | undefined;
2287
+ readOnly?: boolean | undefined;
2288
+ answerableCallback?: ((arg1: boolean) => unknown) | undefined;
2289
+ getAnotherHint?: (() => unknown) | undefined;
2290
+ interactionCallback?: ((widgetData: {
2291
+ [widgetId: string]: any;
2292
+ }) => void) | undefined;
2293
+ groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
2294
+ imagePlaceholder?: React.ReactNode; /**
2295
+ * The current correct answer for the graph. Updated by this component
2296
+ * when the graph is changed.
2297
+ *
2298
+ * Note that the "Correct answer:" textbox is not an interactive
2299
+ * element. Instead, it is a representation of the correct answer based
2300
+ * on the state of the interactive graph previewed at the bottom of the
2301
+ * editor page.
2302
+ */
2303
+ widgetPlaceholder?: React.ReactNode;
2304
+ baseElements?: {
2305
+ Link: React.ComponentType<any>;
2306
+ } | undefined;
2307
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
2308
+ trackInteraction?: ((args: {
2309
+ type: string;
2310
+ id: string;
2311
+ correct?: boolean | undefined;
2312
+ } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
2313
+ customKeypad?: boolean | undefined;
2314
+ nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
2315
+ isMobile?: boolean | undefined;
2316
+ setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
2317
+ useDraftEditor?: boolean | undefined;
2318
+ hintProgressColor?: string | undefined;
2319
+ canScrollPage?: boolean | undefined;
2320
+ inModal?: boolean | undefined;
2321
+ crossOutEnabled?: boolean | undefined;
2322
+ editorChangeDelay?: number | undefined;
2323
+ flags?: Record<string, boolean | Record<string, boolean>> | undefined;
2324
+ onWidgetStartProps?: ((widgets: import("@khanacademy/perseus").PerseusWidgetsMap) => import("@khanacademy/perseus").PerseusWidgetsMap) | undefined;
2325
+ }> & {
2326
+ GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
2327
+ baseElements: {
2328
+ Link: React.ComponentType<any>;
2329
+ };
2330
+ canScrollPage: NonNullable<boolean | undefined>;
2331
+ crossOutEnabled: NonNullable<boolean | undefined>;
2332
+ editorChangeDelay: number;
2333
+ groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
2334
+ inModal: NonNullable<boolean | undefined>;
2335
+ isArticle: NonNullable<boolean | undefined>;
2336
+ isMobile: NonNullable<boolean | undefined>;
2337
+ onFocusChange: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown;
2338
+ onInputError: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
2339
+ readOnly: NonNullable<boolean | undefined>;
2340
+ setDrawingAreaAvailable: (arg1: boolean) => unknown;
2341
+ showAlignmentOptions: NonNullable<boolean | undefined>;
2342
+ useDraftEditor: NonNullable<boolean | undefined>;
2343
+ }>;
2344
+ keypadElement?: any;
2345
+ questionCompleted?: boolean | undefined;
2346
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2347
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2348
+ findWidgets: (arg1: import("../../../perseus/src/types").FilterCriterion) => readonly any[];
2349
+ reviewModeRubric: PerseusInteractiveGraphWidgetOptions;
2350
+ onChange: import("@khanacademy/perseus").ChangeHandler;
2351
+ trackInteraction: (extraData?: {} | undefined) => void;
2352
+ isLastUsedWidget: boolean;
2353
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
2354
+ containerSizeClass: SizingUtils.SizeClass;
2355
+ }>, nextState: Readonly<any>, nextContext: any): boolean;
2356
+ componentWillUnmount?(): void;
2357
+ componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
2358
+ getSnapshotBeforeUpdate?(prevProps: Readonly<PerseusInteractiveGraphWidgetOptions & {
2359
+ widgetId: string;
2360
+ alignment: string | null | undefined;
2361
+ static: boolean | null | undefined;
2362
+ problemNum: number | null | undefined;
2363
+ apiOptions: Readonly<Readonly<{
2364
+ isArticle?: boolean | undefined;
2365
+ onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
2366
+ onFocusChange?: ((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
2367
+ GroupMetadataEditor?: React.ComponentType<any> | undefined;
2368
+ showAlignmentOptions?: boolean | undefined;
2369
+ readOnly?: boolean | undefined;
2370
+ answerableCallback?: ((arg1: boolean) => unknown) | undefined;
2371
+ getAnotherHint?: (() => unknown) | undefined;
2372
+ interactionCallback?: ((widgetData: {
2373
+ [widgetId: string]: any;
2374
+ }) => void) | undefined;
2375
+ groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
2376
+ imagePlaceholder?: React.ReactNode; /**
2377
+ * The current correct answer for the graph. Updated by this component
2378
+ * when the graph is changed.
2379
+ *
2380
+ * Note that the "Correct answer:" textbox is not an interactive
2381
+ * element. Instead, it is a representation of the correct answer based
2382
+ * on the state of the interactive graph previewed at the bottom of the
2383
+ * editor page.
2384
+ */
2385
+ widgetPlaceholder?: React.ReactNode;
2386
+ baseElements?: {
2387
+ Link: React.ComponentType<any>;
2388
+ } | undefined;
2389
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
2390
+ trackInteraction?: ((args: {
2391
+ type: string;
2392
+ id: string;
2393
+ correct?: boolean | undefined;
2394
+ } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
2395
+ customKeypad?: boolean | undefined;
2396
+ nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
2397
+ isMobile?: boolean | undefined;
2398
+ setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
2399
+ useDraftEditor?: boolean | undefined;
2400
+ hintProgressColor?: string | undefined;
2401
+ canScrollPage?: boolean | undefined;
2402
+ inModal?: boolean | undefined;
2403
+ crossOutEnabled?: boolean | undefined;
2404
+ editorChangeDelay?: number | undefined;
2405
+ flags?: Record<string, boolean | Record<string, boolean>> | undefined;
2406
+ onWidgetStartProps?: ((widgets: import("@khanacademy/perseus").PerseusWidgetsMap) => import("@khanacademy/perseus").PerseusWidgetsMap) | undefined;
2407
+ }> & {
2408
+ GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
2409
+ baseElements: {
2410
+ Link: React.ComponentType<any>;
2411
+ };
2412
+ canScrollPage: NonNullable<boolean | undefined>;
2413
+ crossOutEnabled: NonNullable<boolean | undefined>;
2414
+ editorChangeDelay: number;
2415
+ groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
2416
+ inModal: NonNullable<boolean | undefined>;
2417
+ isArticle: NonNullable<boolean | undefined>;
2418
+ isMobile: NonNullable<boolean | undefined>;
2419
+ onFocusChange: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown;
2420
+ onInputError: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
2421
+ readOnly: NonNullable<boolean | undefined>;
2422
+ setDrawingAreaAvailable: (arg1: boolean) => unknown;
2423
+ showAlignmentOptions: NonNullable<boolean | undefined>;
2424
+ useDraftEditor: NonNullable<boolean | undefined>;
2425
+ }>;
2426
+ keypadElement?: any;
2427
+ questionCompleted?: boolean | undefined;
2428
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2429
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2430
+ findWidgets: (arg1: import("../../../perseus/src/types").FilterCriterion) => readonly any[];
2431
+ reviewModeRubric: PerseusInteractiveGraphWidgetOptions;
2432
+ onChange: import("@khanacademy/perseus").ChangeHandler;
2433
+ trackInteraction: (extraData?: {} | undefined) => void;
2434
+ isLastUsedWidget: boolean;
2435
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
2436
+ containerSizeClass: SizingUtils.SizeClass;
2437
+ }>, prevState: Readonly<any>): any;
2438
+ componentWillMount?(): void;
2439
+ componentWillReceiveProps?(nextProps: Readonly<PerseusInteractiveGraphWidgetOptions & {
2440
+ widgetId: string;
2441
+ alignment: string | null | undefined;
2442
+ static: boolean | null | undefined;
2443
+ problemNum: number | null | undefined;
2444
+ apiOptions: Readonly<Readonly<{
2445
+ isArticle?: boolean | undefined;
2446
+ onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
2447
+ onFocusChange?: ((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
2448
+ GroupMetadataEditor?: React.ComponentType<any> | undefined;
2449
+ showAlignmentOptions?: boolean | undefined;
2450
+ readOnly?: boolean | undefined;
2451
+ answerableCallback?: ((arg1: boolean) => unknown) | undefined;
2452
+ getAnotherHint?: (() => unknown) | undefined;
2453
+ interactionCallback?: ((widgetData: {
2454
+ [widgetId: string]: any;
2455
+ }) => void) | undefined;
2456
+ groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
2457
+ imagePlaceholder?: React.ReactNode; /**
2458
+ * The current correct answer for the graph. Updated by this component
2459
+ * when the graph is changed.
2460
+ *
2461
+ * Note that the "Correct answer:" textbox is not an interactive
2462
+ * element. Instead, it is a representation of the correct answer based
2463
+ * on the state of the interactive graph previewed at the bottom of the
2464
+ * editor page.
2465
+ */
2466
+ widgetPlaceholder?: React.ReactNode;
2467
+ baseElements?: {
2468
+ Link: React.ComponentType<any>;
2469
+ } | undefined;
2470
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
2471
+ trackInteraction?: ((args: {
2472
+ type: string;
2473
+ id: string;
2474
+ correct?: boolean | undefined;
2475
+ } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
2476
+ customKeypad?: boolean | undefined;
2477
+ nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
2478
+ isMobile?: boolean | undefined;
2479
+ setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
2480
+ useDraftEditor?: boolean | undefined;
2481
+ hintProgressColor?: string | undefined;
2482
+ canScrollPage?: boolean | undefined;
2483
+ inModal?: boolean | undefined;
2484
+ crossOutEnabled?: boolean | undefined;
2485
+ editorChangeDelay?: number | undefined;
2486
+ flags?: Record<string, boolean | Record<string, boolean>> | undefined;
2487
+ onWidgetStartProps?: ((widgets: import("@khanacademy/perseus").PerseusWidgetsMap) => import("@khanacademy/perseus").PerseusWidgetsMap) | undefined;
2488
+ }> & {
2489
+ GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
2490
+ baseElements: {
2491
+ Link: React.ComponentType<any>;
2492
+ };
2493
+ canScrollPage: NonNullable<boolean | undefined>;
2494
+ crossOutEnabled: NonNullable<boolean | undefined>;
2495
+ editorChangeDelay: number;
2496
+ groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
2497
+ inModal: NonNullable<boolean | undefined>;
2498
+ isArticle: NonNullable<boolean | undefined>;
2499
+ isMobile: NonNullable<boolean | undefined>;
2500
+ onFocusChange: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown;
2501
+ onInputError: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
2502
+ readOnly: NonNullable<boolean | undefined>;
2503
+ setDrawingAreaAvailable: (arg1: boolean) => unknown;
2504
+ showAlignmentOptions: NonNullable<boolean | undefined>;
2505
+ useDraftEditor: NonNullable<boolean | undefined>;
2506
+ }>;
2507
+ keypadElement?: any;
2508
+ questionCompleted?: boolean | undefined;
2509
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2510
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2511
+ findWidgets: (arg1: import("../../../perseus/src/types").FilterCriterion) => readonly any[];
2512
+ reviewModeRubric: PerseusInteractiveGraphWidgetOptions;
2513
+ onChange: import("@khanacademy/perseus").ChangeHandler;
2514
+ trackInteraction: (extraData?: {} | undefined) => void;
2515
+ isLastUsedWidget: boolean;
2516
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
2517
+ containerSizeClass: SizingUtils.SizeClass;
2518
+ }>, nextContext: any): void;
2519
+ componentWillUpdate?(nextProps: Readonly<PerseusInteractiveGraphWidgetOptions & {
2520
+ widgetId: string;
2521
+ alignment: string | null | undefined;
2522
+ static: boolean | null | undefined;
2523
+ problemNum: number | null | undefined;
2524
+ apiOptions: Readonly<Readonly<{
2525
+ isArticle?: boolean | undefined;
2526
+ onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
2527
+ onFocusChange?: ((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
2528
+ GroupMetadataEditor?: React.ComponentType<any> | undefined;
2529
+ showAlignmentOptions?: boolean | undefined;
2530
+ readOnly?: boolean | undefined;
2531
+ answerableCallback?: ((arg1: boolean) => unknown) | undefined;
2532
+ getAnotherHint?: (() => unknown) | undefined;
2533
+ interactionCallback?: ((widgetData: {
2534
+ [widgetId: string]: any;
2535
+ }) => void) | undefined;
2536
+ groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
2537
+ imagePlaceholder?: React.ReactNode; /**
2538
+ * The current correct answer for the graph. Updated by this component
2539
+ * when the graph is changed.
2540
+ *
2541
+ * Note that the "Correct answer:" textbox is not an interactive
2542
+ * element. Instead, it is a representation of the correct answer based
2543
+ * on the state of the interactive graph previewed at the bottom of the
2544
+ * editor page.
2545
+ */
2546
+ widgetPlaceholder?: React.ReactNode;
2547
+ baseElements?: {
2548
+ Link: React.ComponentType<any>;
2549
+ } | undefined;
2550
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
2551
+ trackInteraction?: ((args: {
2552
+ type: string;
2553
+ id: string;
2554
+ correct?: boolean | undefined;
2555
+ } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
2556
+ customKeypad?: boolean | undefined;
2557
+ nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
2558
+ isMobile?: boolean | undefined;
2559
+ setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
2560
+ useDraftEditor?: boolean | undefined;
2561
+ hintProgressColor?: string | undefined;
2562
+ canScrollPage?: boolean | undefined;
2563
+ inModal?: boolean | undefined;
2564
+ crossOutEnabled?: boolean | undefined;
2565
+ editorChangeDelay?: number | undefined;
2566
+ flags?: Record<string, boolean | Record<string, boolean>> | undefined;
2567
+ onWidgetStartProps?: ((widgets: import("@khanacademy/perseus").PerseusWidgetsMap) => import("@khanacademy/perseus").PerseusWidgetsMap) | undefined;
2568
+ }> & {
2569
+ GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
2570
+ baseElements: {
2571
+ Link: React.ComponentType<any>;
2572
+ };
2573
+ canScrollPage: NonNullable<boolean | undefined>;
2574
+ crossOutEnabled: NonNullable<boolean | undefined>;
2575
+ editorChangeDelay: number;
2576
+ groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
2577
+ inModal: NonNullable<boolean | undefined>;
2578
+ isArticle: NonNullable<boolean | undefined>;
2579
+ isMobile: NonNullable<boolean | undefined>;
2580
+ onFocusChange: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown;
2581
+ onInputError: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
2582
+ readOnly: NonNullable<boolean | undefined>;
2583
+ setDrawingAreaAvailable: (arg1: boolean) => unknown;
2584
+ showAlignmentOptions: NonNullable<boolean | undefined>;
2585
+ useDraftEditor: NonNullable<boolean | undefined>;
2586
+ }>;
2587
+ keypadElement?: any;
2588
+ questionCompleted?: boolean | undefined;
2589
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2590
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2591
+ findWidgets: (arg1: import("../../../perseus/src/types").FilterCriterion) => readonly any[];
2592
+ reviewModeRubric: PerseusInteractiveGraphWidgetOptions;
2593
+ onChange: import("@khanacademy/perseus").ChangeHandler;
2594
+ trackInteraction: (extraData?: {} | undefined) => void;
2595
+ isLastUsedWidget: boolean;
2596
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
2597
+ containerSizeClass: SizingUtils.SizeClass;
2598
+ }>, nextState: Readonly<any>, nextContext: any): void;
2599
+ UNSAFE_componentWillUpdate?(nextProps: Readonly<PerseusInteractiveGraphWidgetOptions & {
2600
+ widgetId: string;
2601
+ alignment: string | null | undefined;
2602
+ static: boolean | null | undefined;
2603
+ problemNum: number | null | undefined;
2604
+ apiOptions: Readonly<Readonly<{
2605
+ isArticle?: boolean | undefined;
2606
+ onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
2607
+ onFocusChange?: ((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
2608
+ GroupMetadataEditor?: React.ComponentType<any> | undefined;
2609
+ showAlignmentOptions?: boolean | undefined;
2610
+ readOnly?: boolean | undefined;
2611
+ answerableCallback?: ((arg1: boolean) => unknown) | undefined;
2612
+ getAnotherHint?: (() => unknown) | undefined;
2613
+ interactionCallback?: ((widgetData: {
2614
+ [widgetId: string]: any;
2615
+ }) => void) | undefined;
2616
+ groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
2617
+ imagePlaceholder?: React.ReactNode; /**
2618
+ * The current correct answer for the graph. Updated by this component
2619
+ * when the graph is changed.
2620
+ *
2621
+ * Note that the "Correct answer:" textbox is not an interactive
2622
+ * element. Instead, it is a representation of the correct answer based
2623
+ * on the state of the interactive graph previewed at the bottom of the
2624
+ * editor page.
2625
+ */
2626
+ widgetPlaceholder?: React.ReactNode;
2627
+ baseElements?: {
2628
+ Link: React.ComponentType<any>;
2629
+ } | undefined;
2630
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
2631
+ trackInteraction?: ((args: {
2632
+ type: string;
2633
+ id: string;
2634
+ correct?: boolean | undefined;
2635
+ } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
2636
+ customKeypad?: boolean | undefined;
2637
+ nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
2638
+ isMobile?: boolean | undefined;
2639
+ setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
2640
+ useDraftEditor?: boolean | undefined;
2641
+ hintProgressColor?: string | undefined;
2642
+ canScrollPage?: boolean | undefined;
2643
+ inModal?: boolean | undefined;
2644
+ crossOutEnabled?: boolean | undefined;
2645
+ editorChangeDelay?: number | undefined;
2646
+ flags?: Record<string, boolean | Record<string, boolean>> | undefined;
2647
+ onWidgetStartProps?: ((widgets: import("@khanacademy/perseus").PerseusWidgetsMap) => import("@khanacademy/perseus").PerseusWidgetsMap) | undefined;
2648
+ }> & {
2649
+ GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
2650
+ baseElements: {
2651
+ Link: React.ComponentType<any>;
2652
+ };
2653
+ canScrollPage: NonNullable<boolean | undefined>;
2654
+ crossOutEnabled: NonNullable<boolean | undefined>;
2655
+ editorChangeDelay: number;
2656
+ groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
2657
+ inModal: NonNullable<boolean | undefined>;
2658
+ isArticle: NonNullable<boolean | undefined>;
2659
+ isMobile: NonNullable<boolean | undefined>;
2660
+ onFocusChange: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown;
2661
+ onInputError: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
2662
+ readOnly: NonNullable<boolean | undefined>;
2663
+ setDrawingAreaAvailable: (arg1: boolean) => unknown;
2664
+ showAlignmentOptions: NonNullable<boolean | undefined>;
2665
+ useDraftEditor: NonNullable<boolean | undefined>;
2666
+ }>;
2667
+ keypadElement?: any;
2668
+ questionCompleted?: boolean | undefined;
2669
+ onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2670
+ onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
2671
+ findWidgets: (arg1: import("../../../perseus/src/types").FilterCriterion) => readonly any[];
2672
+ reviewModeRubric: PerseusInteractiveGraphWidgetOptions;
2673
+ onChange: import("@khanacademy/perseus").ChangeHandler;
2674
+ trackInteraction: (extraData?: {} | undefined) => void;
2675
+ isLastUsedWidget: boolean;
2676
+ linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
2677
+ containerSizeClass: SizingUtils.SizeClass;
2678
+ }>, nextState: Readonly<any>, nextContext: any): void;
2679
+ }>;
1121
2680
  mafsRef: React.RefObject<import("../../../perseus/src/renderer").Widget>;
1122
- state: any;
1123
- UNSAFE_componentWillMount(): void;
1124
- componentDidMount(): void;
1125
- UNSAFE_componentWillReceiveProps(nextProps: PerseusInteractiveGraphWidgetOptions & {
2681
+ getUserInput: (() => any) | undefined;
2682
+ simpleValidate: (rubric: PerseusInteractiveGraphWidgetOptions) => import("@khanacademy/perseus").PerseusScore;
2683
+ render(): JSX.Element;
2684
+ context: any;
2685
+ setState<K_1 extends string | number | symbol>(state: any, callback?: (() => void) | undefined): void;
2686
+ forceUpdate(callback?: (() => void) | undefined): void;
2687
+ readonly props: Readonly<PerseusInteractiveGraphWidgetOptions & {
1126
2688
  widgetId: string;
1127
2689
  alignment: string | null | undefined;
1128
2690
  static: boolean | null | undefined;
@@ -1140,100 +2702,26 @@ declare const InteractiveGraph: {
1140
2702
  [widgetId: string]: any;
1141
2703
  }) => void) | undefined;
1142
2704
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
1143
- imagePlaceholder?: React.ReactNode;
1144
- widgetPlaceholder?: React.ReactNode;
1145
- baseElements?: {
1146
- Link: React.ComponentType<any>;
1147
- } | undefined;
1148
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
1149
- * Whether to show the ruler on the graph.
1150
- */
1151
- trackInteraction?: ((args: {
1152
- type: string;
1153
- id: string;
1154
- correct?: boolean | undefined;
1155
- } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
1156
- customKeypad?: boolean | undefined; /**
1157
- * Whether to show tooltips on the graph.
1158
- * (Currently not used, but will be in the future.)
2705
+ imagePlaceholder?: React.ReactNode; /**
2706
+ * The current correct answer for the graph. Updated by this component
2707
+ * when the graph is changed.
2708
+ *
2709
+ * Note that the "Correct answer:" textbox is not an interactive
2710
+ * element. Instead, it is a representation of the correct answer based
2711
+ * on the state of the interactive graph previewed at the bottom of the
2712
+ * editor page.
1159
2713
  */
1160
- nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
1161
- isMobile?: boolean | undefined;
1162
- setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
1163
- useDraftEditor?: boolean | undefined;
1164
- hintProgressColor?: string | undefined;
1165
- canScrollPage?: boolean | undefined;
1166
- inModal?: boolean | undefined;
1167
- crossOutEnabled?: boolean | undefined;
1168
- editorChangeDelay?: number | undefined;
1169
- flags?: Record<string, boolean | Record<string, boolean>> | undefined;
1170
- onWidgetStartProps?: ((widgets: import("@khanacademy/perseus").PerseusWidgetsMap) => import("@khanacademy/perseus").PerseusWidgetsMap) | undefined;
1171
- }> & {
1172
- GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
1173
- baseElements: {
1174
- Link: React.ComponentType<any>;
1175
- };
1176
- canScrollPage: NonNullable<boolean | undefined>;
1177
- crossOutEnabled: NonNullable<boolean | undefined>;
1178
- editorChangeDelay: number;
1179
- groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
1180
- inModal: NonNullable<boolean | undefined>;
1181
- isArticle: NonNullable<boolean | undefined>;
1182
- isMobile: NonNullable<boolean | undefined>;
1183
- onFocusChange: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown;
1184
- onInputError: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
1185
- readOnly: NonNullable<boolean | undefined>;
1186
- setDrawingAreaAvailable: (arg1: boolean) => unknown;
1187
- showAlignmentOptions: NonNullable<boolean | undefined>;
1188
- useDraftEditor: NonNullable<boolean | undefined>;
1189
- }>;
1190
- keypadElement?: any;
1191
- questionCompleted?: boolean | undefined;
1192
- onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
1193
- onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
1194
- findWidgets: (arg1: import("../../../perseus/src/types").FilterCriterion) => readonly any[];
1195
- reviewModeRubric: PerseusInteractiveGraphWidgetOptions;
1196
- onChange: import("@khanacademy/perseus").ChangeHandler;
1197
- trackInteraction: (extraData?: {} | undefined) => void;
1198
- isLastUsedWidget: boolean;
1199
- linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
1200
- containerSizeClass: SizingUtils.SizeClass;
1201
- }): void;
1202
- componentDidUpdate(prevProps: PerseusInteractiveGraphWidgetOptions & {
1203
- widgetId: string;
1204
- alignment: string | null | undefined;
1205
- static: boolean | null | undefined;
1206
- problemNum: number | null | undefined;
1207
- apiOptions: Readonly<Readonly<{
1208
- isArticle?: boolean | undefined;
1209
- onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
1210
- onFocusChange?: ((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
1211
- GroupMetadataEditor?: React.ComponentType<any> | undefined;
1212
- showAlignmentOptions?: boolean | undefined;
1213
- readOnly?: boolean | undefined;
1214
- answerableCallback?: ((arg1: boolean) => unknown) | undefined;
1215
- getAnotherHint?: (() => unknown) | undefined;
1216
- interactionCallback?: ((widgetData: {
1217
- [widgetId: string]: any;
1218
- }) => void) | undefined;
1219
- groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
1220
- imagePlaceholder?: React.ReactNode;
1221
2714
  widgetPlaceholder?: React.ReactNode;
1222
2715
  baseElements?: {
1223
2716
  Link: React.ComponentType<any>;
1224
2717
  } | undefined;
1225
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
1226
- * Whether to show the ruler on the graph.
1227
- */
2718
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
1228
2719
  trackInteraction?: ((args: {
1229
2720
  type: string;
1230
2721
  id: string;
1231
2722
  correct?: boolean | undefined;
1232
2723
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
1233
- customKeypad?: boolean | undefined; /**
1234
- * Whether to show tooltips on the graph.
1235
- * (Currently not used, but will be in the future.)
1236
- */
2724
+ customKeypad?: boolean | undefined;
1237
2725
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
1238
2726
  isMobile?: boolean | undefined;
1239
2727
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -1275,8 +2763,15 @@ declare const InteractiveGraph: {
1275
2763
  isLastUsedWidget: boolean;
1276
2764
  linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
1277
2765
  containerSizeClass: SizingUtils.SizeClass;
1278
- }, prevState: any): void;
1279
- _getShouldShowInstructions: (arg1?: (PerseusInteractiveGraphWidgetOptions & {
2766
+ }> & Readonly<{
2767
+ children?: React.ReactNode;
2768
+ }>;
2769
+ state: Readonly<any>;
2770
+ refs: {
2771
+ [key: string]: React.ReactInstance;
2772
+ };
2773
+ componentDidMount?(): void;
2774
+ shouldComponentUpdate?(nextProps: Readonly<PerseusInteractiveGraphWidgetOptions & {
1280
2775
  widgetId: string;
1281
2776
  alignment: string | null | undefined;
1282
2777
  static: boolean | null | undefined;
@@ -1294,114 +2789,26 @@ declare const InteractiveGraph: {
1294
2789
  [widgetId: string]: any;
1295
2790
  }) => void) | undefined;
1296
2791
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
1297
- imagePlaceholder?: React.ReactNode;
1298
- widgetPlaceholder?: React.ReactNode;
1299
- baseElements?: {
1300
- Link: React.ComponentType<any>;
1301
- } | undefined;
1302
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
1303
- * Whether to show the ruler on the graph.
2792
+ imagePlaceholder?: React.ReactNode; /**
2793
+ * The current correct answer for the graph. Updated by this component
2794
+ * when the graph is changed.
2795
+ *
2796
+ * Note that the "Correct answer:" textbox is not an interactive
2797
+ * element. Instead, it is a representation of the correct answer based
2798
+ * on the state of the interactive graph previewed at the bottom of the
2799
+ * editor page.
1304
2800
  */
1305
- trackInteraction?: ((args: {
1306
- type: string;
1307
- id: string;
1308
- correct?: boolean | undefined;
1309
- } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
1310
- customKeypad?: boolean | undefined; /**
1311
- * Whether to show tooltips on the graph.
1312
- * (Currently not used, but will be in the future.)
1313
- */
1314
- nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
1315
- isMobile?: boolean | undefined;
1316
- setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
1317
- useDraftEditor?: boolean | undefined;
1318
- hintProgressColor?: string | undefined;
1319
- canScrollPage?: boolean | undefined;
1320
- inModal?: boolean | undefined;
1321
- crossOutEnabled?: boolean | undefined;
1322
- editorChangeDelay?: number | undefined;
1323
- flags?: Record<string, boolean | Record<string, boolean>> | undefined;
1324
- onWidgetStartProps?: ((widgets: import("@khanacademy/perseus").PerseusWidgetsMap) => import("@khanacademy/perseus").PerseusWidgetsMap) | undefined;
1325
- }> & {
1326
- GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
1327
- baseElements: {
1328
- Link: React.ComponentType<any>;
1329
- };
1330
- canScrollPage: NonNullable<boolean | undefined>;
1331
- crossOutEnabled: NonNullable<boolean | undefined>;
1332
- editorChangeDelay: number;
1333
- groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
1334
- inModal: NonNullable<boolean | undefined>;
1335
- isArticle: NonNullable<boolean | undefined>;
1336
- isMobile: NonNullable<boolean | undefined>;
1337
- onFocusChange: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown;
1338
- onInputError: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
1339
- readOnly: NonNullable<boolean | undefined>;
1340
- setDrawingAreaAvailable: (arg1: boolean) => unknown;
1341
- showAlignmentOptions: NonNullable<boolean | undefined>;
1342
- useDraftEditor: NonNullable<boolean | undefined>;
1343
- }>;
1344
- keypadElement?: any;
1345
- questionCompleted?: boolean | undefined;
1346
- onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
1347
- onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
1348
- findWidgets: (arg1: import("../../../perseus/src/types").FilterCriterion) => readonly any[];
1349
- reviewModeRubric: PerseusInteractiveGraphWidgetOptions;
1350
- onChange: import("@khanacademy/perseus").ChangeHandler;
1351
- trackInteraction: (extraData?: {} | undefined) => void;
1352
- isLastUsedWidget: boolean;
1353
- linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
1354
- containerSizeClass: SizingUtils.SizeClass;
1355
- }) | null | undefined) => boolean;
1356
- deprecatedProps: any;
1357
- setGraphie: (arg1: any) => void;
1358
- handleAddPointsMouseDown: (arg1: import("@khanacademy/perseus").Coord) => void;
1359
- resetGraphie: () => void; /**
1360
- * The range of the graph in the x and y directions.
1361
- */
1362
- setupGraphie: () => void;
1363
- showHairlines: (arg1: import("@khanacademy/perseus").Coord) => void;
1364
- hideHairlines: () => void;
1365
- /**
1366
- * How far apart the tick marks on the axes are in the x and y
1367
- * directions.
1368
- */
1369
- setTrashCanVisibility: (arg1: number) => void;
1370
- isClickToAddPoints: (arg1?: (PerseusInteractiveGraphWidgetOptions & {
1371
- widgetId: string;
1372
- alignment: string | null | undefined;
1373
- static: boolean | null | undefined;
1374
- problemNum: number | null | undefined;
1375
- apiOptions: Readonly<Readonly<{
1376
- isArticle?: boolean | undefined;
1377
- onInputError?: ((widgetId: any, value: string, message?: string | null | undefined) => unknown) | undefined;
1378
- onFocusChange?: ((newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
1379
- GroupMetadataEditor?: React.ComponentType<any> | undefined;
1380
- showAlignmentOptions?: boolean | undefined;
1381
- readOnly?: boolean | undefined;
1382
- answerableCallback?: ((arg1: boolean) => unknown) | undefined;
1383
- getAnotherHint?: (() => unknown) | undefined;
1384
- interactionCallback?: ((widgetData: {
1385
- [widgetId: string]: any;
1386
- }) => void) | undefined;
1387
- groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
1388
- imagePlaceholder?: React.ReactNode;
1389
2801
  widgetPlaceholder?: React.ReactNode;
1390
2802
  baseElements?: {
1391
2803
  Link: React.ComponentType<any>;
1392
2804
  } | undefined;
1393
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
1394
- * Whether to show the ruler on the graph.
1395
- */
2805
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
1396
2806
  trackInteraction?: ((args: {
1397
2807
  type: string;
1398
2808
  id: string;
1399
2809
  correct?: boolean | undefined;
1400
2810
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
1401
- customKeypad?: boolean | undefined; /**
1402
- * Whether to show tooltips on the graph.
1403
- * (Currently not used, but will be in the future.)
1404
- */
2811
+ customKeypad?: boolean | undefined;
1405
2812
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
1406
2813
  isMobile?: boolean | undefined;
1407
2814
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -1443,64 +2850,10 @@ declare const InteractiveGraph: {
1443
2850
  isLastUsedWidget: boolean;
1444
2851
  linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
1445
2852
  containerSizeClass: SizingUtils.SizeClass;
1446
- }) | null | undefined) => boolean;
1447
- areAngleGraphsEqual(prevGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypeAngle, currentGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypeAngle): boolean;
1448
- arePointGraphsEqual(prevGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypePoint, currentGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypePoint): boolean;
1449
- arePolygonGraphsEqual(prevGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypePolygon, currentGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypePolygon): boolean;
1450
- areSegmentGraphsEqual(prevGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypeSegment, currentGraph: import("../../../perseus/src/perseus-types").PerseusGraphTypeSegment): boolean;
1451
- _lineStroke: () => {
1452
- "stroke-width"?: number | undefined; /**
1453
- * The background image to display in the graph area and its properties.
1454
- */
1455
- };
1456
- addLine: (arg1: string) => void;
1457
- removeLine: () => void;
1458
- addLinearControls: () => void;
1459
- removeLinearControls: () => void;
1460
- addQuadraticControls: () => void;
1461
- updateQuadratic: () => void;
1462
- removeQuadraticControls: () => void;
1463
- addSinusoidControls: () => void;
1464
- updateSinusoid: () => void;
1465
- removeSinusoidControls: () => void;
1466
- addCircleControls: () => void;
1467
- removeCircleControls: () => void;
1468
- addLinearSystemControls: () => void;
1469
- removeLinearSystemControls: () => void;
1470
- isCoordInTrash: (arg1: import("@khanacademy/perseus").Coord) => boolean;
1471
- createPointForPointsType: (arg1: import("@khanacademy/perseus").Coord, arg2: number) => any;
1472
- removePoint: (arg1: import("@khanacademy/perseus").Coord) => number | null | undefined;
1473
- /**
1474
- * The label to display on the ruler, if any.
1475
- */
1476
- createPointForPolygonType: (arg1: import("@khanacademy/perseus").Coord, arg2: number) => any;
1477
- updateCoordsFromPoints: () => void;
1478
- clearCoords: () => void;
1479
- onChange: (arg1: any) => void;
1480
- addPointControls: () => void;
1481
- removePointControls: () => void;
1482
- addSegmentControls: () => void;
1483
- removeSegmentControls: () => void;
1484
- addRayControls: () => void;
1485
- removeRayControls: () => void;
1486
- addPolygonControls: () => void;
1487
- updatePolygon: () => void;
1488
- removePolygonControls: () => void;
1489
- addAngleControls: () => void;
1490
- removeAngleControls: () => void;
1491
- toggleShowSides: () => void; /**
1492
- * The locked figures to display in the graph area.
1493
- * Locked figures are graph elements (points, lines, line segmeents,
1494
- * etc.) that are locked in place and not interactive.
1495
- */
1496
- getUserInput: () => import("@khanacademy/perseus").PerseusGraphType;
1497
- simpleValidate: (rubric: PerseusInteractiveGraphWidgetOptions) => import("@khanacademy/perseus").PerseusScore;
1498
- focus: () => void;
1499
- render(): React.ReactNode;
1500
- context: any;
1501
- setState<K extends string | number | symbol>(state: any, callback?: (() => void) | undefined): void;
1502
- forceUpdate(callback?: (() => void) | undefined): void;
1503
- readonly props: Readonly<PerseusInteractiveGraphWidgetOptions & {
2853
+ }>, nextState: Readonly<any>, nextContext: any): boolean;
2854
+ componentWillUnmount?(): void;
2855
+ componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
2856
+ getSnapshotBeforeUpdate?(prevProps: Readonly<PerseusInteractiveGraphWidgetOptions & {
1504
2857
  widgetId: string;
1505
2858
  alignment: string | null | undefined;
1506
2859
  static: boolean | null | undefined;
@@ -1518,23 +2871,26 @@ declare const InteractiveGraph: {
1518
2871
  [widgetId: string]: any;
1519
2872
  }) => void) | undefined;
1520
2873
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
1521
- imagePlaceholder?: React.ReactNode;
2874
+ imagePlaceholder?: React.ReactNode; /**
2875
+ * The current correct answer for the graph. Updated by this component
2876
+ * when the graph is changed.
2877
+ *
2878
+ * Note that the "Correct answer:" textbox is not an interactive
2879
+ * element. Instead, it is a representation of the correct answer based
2880
+ * on the state of the interactive graph previewed at the bottom of the
2881
+ * editor page.
2882
+ */
1522
2883
  widgetPlaceholder?: React.ReactNode;
1523
2884
  baseElements?: {
1524
2885
  Link: React.ComponentType<any>;
1525
2886
  } | undefined;
1526
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
1527
- * Whether to show the ruler on the graph.
1528
- */
2887
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
1529
2888
  trackInteraction?: ((args: {
1530
2889
  type: string;
1531
2890
  id: string;
1532
2891
  correct?: boolean | undefined;
1533
2892
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
1534
- customKeypad?: boolean | undefined; /**
1535
- * Whether to show tooltips on the graph.
1536
- * (Currently not used, but will be in the future.)
1537
- */
2893
+ customKeypad?: boolean | undefined;
1538
2894
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
1539
2895
  isMobile?: boolean | undefined;
1540
2896
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -1576,13 +2932,8 @@ declare const InteractiveGraph: {
1576
2932
  isLastUsedWidget: boolean;
1577
2933
  linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
1578
2934
  containerSizeClass: SizingUtils.SizeClass;
1579
- }> & Readonly<{
1580
- children?: React.ReactNode;
1581
- }>;
1582
- refs: {
1583
- [key: string]: React.ReactInstance;
1584
- };
1585
- shouldComponentUpdate?(nextProps: Readonly<PerseusInteractiveGraphWidgetOptions & {
2935
+ }>, prevState: Readonly<any>): any;
2936
+ componentDidUpdate?(prevProps: Readonly<PerseusInteractiveGraphWidgetOptions & {
1586
2937
  widgetId: string;
1587
2938
  alignment: string | null | undefined;
1588
2939
  static: boolean | null | undefined;
@@ -1600,23 +2951,26 @@ declare const InteractiveGraph: {
1600
2951
  [widgetId: string]: any;
1601
2952
  }) => void) | undefined;
1602
2953
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
1603
- imagePlaceholder?: React.ReactNode;
2954
+ imagePlaceholder?: React.ReactNode; /**
2955
+ * The current correct answer for the graph. Updated by this component
2956
+ * when the graph is changed.
2957
+ *
2958
+ * Note that the "Correct answer:" textbox is not an interactive
2959
+ * element. Instead, it is a representation of the correct answer based
2960
+ * on the state of the interactive graph previewed at the bottom of the
2961
+ * editor page.
2962
+ */
1604
2963
  widgetPlaceholder?: React.ReactNode;
1605
2964
  baseElements?: {
1606
2965
  Link: React.ComponentType<any>;
1607
2966
  } | undefined;
1608
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
1609
- * Whether to show the ruler on the graph.
1610
- */
2967
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
1611
2968
  trackInteraction?: ((args: {
1612
2969
  type: string;
1613
2970
  id: string;
1614
2971
  correct?: boolean | undefined;
1615
2972
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
1616
- customKeypad?: boolean | undefined; /**
1617
- * Whether to show tooltips on the graph.
1618
- * (Currently not used, but will be in the future.)
1619
- */
2973
+ customKeypad?: boolean | undefined;
1620
2974
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
1621
2975
  isMobile?: boolean | undefined;
1622
2976
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -1658,10 +3012,10 @@ declare const InteractiveGraph: {
1658
3012
  isLastUsedWidget: boolean;
1659
3013
  linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
1660
3014
  containerSizeClass: SizingUtils.SizeClass;
1661
- }>, nextState: Readonly<any>, nextContext: any): boolean;
1662
- componentWillUnmount?(): void;
1663
- componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
1664
- getSnapshotBeforeUpdate?(prevProps: Readonly<PerseusInteractiveGraphWidgetOptions & {
3015
+ }>, prevState: Readonly<any>, snapshot?: any): void;
3016
+ componentWillMount?(): void;
3017
+ UNSAFE_componentWillMount?(): void;
3018
+ componentWillReceiveProps?(nextProps: Readonly<PerseusInteractiveGraphWidgetOptions & {
1665
3019
  widgetId: string;
1666
3020
  alignment: string | null | undefined;
1667
3021
  static: boolean | null | undefined;
@@ -1679,23 +3033,26 @@ declare const InteractiveGraph: {
1679
3033
  [widgetId: string]: any;
1680
3034
  }) => void) | undefined;
1681
3035
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
1682
- imagePlaceholder?: React.ReactNode;
3036
+ imagePlaceholder?: React.ReactNode; /**
3037
+ * The current correct answer for the graph. Updated by this component
3038
+ * when the graph is changed.
3039
+ *
3040
+ * Note that the "Correct answer:" textbox is not an interactive
3041
+ * element. Instead, it is a representation of the correct answer based
3042
+ * on the state of the interactive graph previewed at the bottom of the
3043
+ * editor page.
3044
+ */
1683
3045
  widgetPlaceholder?: React.ReactNode;
1684
3046
  baseElements?: {
1685
3047
  Link: React.ComponentType<any>;
1686
3048
  } | undefined;
1687
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
1688
- * Whether to show the ruler on the graph.
1689
- */
3049
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
1690
3050
  trackInteraction?: ((args: {
1691
3051
  type: string;
1692
3052
  id: string;
1693
3053
  correct?: boolean | undefined;
1694
3054
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
1695
- customKeypad?: boolean | undefined; /**
1696
- * Whether to show tooltips on the graph.
1697
- * (Currently not used, but will be in the future.)
1698
- */
3055
+ customKeypad?: boolean | undefined;
1699
3056
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
1700
3057
  isMobile?: boolean | undefined;
1701
3058
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -1737,9 +3094,8 @@ declare const InteractiveGraph: {
1737
3094
  isLastUsedWidget: boolean;
1738
3095
  linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
1739
3096
  containerSizeClass: SizingUtils.SizeClass;
1740
- }>, prevState: Readonly<any>): any;
1741
- componentWillMount?(): void;
1742
- componentWillReceiveProps?(nextProps: Readonly<PerseusInteractiveGraphWidgetOptions & {
3097
+ }>, nextContext: any): void;
3098
+ UNSAFE_componentWillReceiveProps?(nextProps: Readonly<PerseusInteractiveGraphWidgetOptions & {
1743
3099
  widgetId: string;
1744
3100
  alignment: string | null | undefined;
1745
3101
  static: boolean | null | undefined;
@@ -1757,23 +3113,26 @@ declare const InteractiveGraph: {
1757
3113
  [widgetId: string]: any;
1758
3114
  }) => void) | undefined;
1759
3115
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
1760
- imagePlaceholder?: React.ReactNode;
3116
+ imagePlaceholder?: React.ReactNode; /**
3117
+ * The current correct answer for the graph. Updated by this component
3118
+ * when the graph is changed.
3119
+ *
3120
+ * Note that the "Correct answer:" textbox is not an interactive
3121
+ * element. Instead, it is a representation of the correct answer based
3122
+ * on the state of the interactive graph previewed at the bottom of the
3123
+ * editor page.
3124
+ */
1761
3125
  widgetPlaceholder?: React.ReactNode;
1762
3126
  baseElements?: {
1763
3127
  Link: React.ComponentType<any>;
1764
3128
  } | undefined;
1765
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
1766
- * Whether to show the ruler on the graph.
1767
- */
3129
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
1768
3130
  trackInteraction?: ((args: {
1769
3131
  type: string;
1770
3132
  id: string;
1771
3133
  correct?: boolean | undefined;
1772
3134
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
1773
- customKeypad?: boolean | undefined; /**
1774
- * Whether to show tooltips on the graph.
1775
- * (Currently not used, but will be in the future.)
1776
- */
3135
+ customKeypad?: boolean | undefined;
1777
3136
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
1778
3137
  isMobile?: boolean | undefined;
1779
3138
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -1834,23 +3193,26 @@ declare const InteractiveGraph: {
1834
3193
  [widgetId: string]: any;
1835
3194
  }) => void) | undefined;
1836
3195
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
1837
- imagePlaceholder?: React.ReactNode;
3196
+ imagePlaceholder?: React.ReactNode; /**
3197
+ * The current correct answer for the graph. Updated by this component
3198
+ * when the graph is changed.
3199
+ *
3200
+ * Note that the "Correct answer:" textbox is not an interactive
3201
+ * element. Instead, it is a representation of the correct answer based
3202
+ * on the state of the interactive graph previewed at the bottom of the
3203
+ * editor page.
3204
+ */
1838
3205
  widgetPlaceholder?: React.ReactNode;
1839
3206
  baseElements?: {
1840
3207
  Link: React.ComponentType<any>;
1841
3208
  } | undefined;
1842
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
1843
- * Whether to show the ruler on the graph.
1844
- */
3209
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
1845
3210
  trackInteraction?: ((args: {
1846
3211
  type: string;
1847
3212
  id: string;
1848
3213
  correct?: boolean | undefined;
1849
3214
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
1850
- customKeypad?: boolean | undefined; /**
1851
- * Whether to show tooltips on the graph.
1852
- * (Currently not used, but will be in the future.)
1853
- */
3215
+ customKeypad?: boolean | undefined;
1854
3216
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
1855
3217
  isMobile?: boolean | undefined;
1856
3218
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -1911,23 +3273,26 @@ declare const InteractiveGraph: {
1911
3273
  [widgetId: string]: any;
1912
3274
  }) => void) | undefined;
1913
3275
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
1914
- imagePlaceholder?: React.ReactNode;
3276
+ imagePlaceholder?: React.ReactNode; /**
3277
+ * The current correct answer for the graph. Updated by this component
3278
+ * when the graph is changed.
3279
+ *
3280
+ * Note that the "Correct answer:" textbox is not an interactive
3281
+ * element. Instead, it is a representation of the correct answer based
3282
+ * on the state of the interactive graph previewed at the bottom of the
3283
+ * editor page.
3284
+ */
1915
3285
  widgetPlaceholder?: React.ReactNode;
1916
3286
  baseElements?: {
1917
3287
  Link: React.ComponentType<any>;
1918
3288
  } | undefined;
1919
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
1920
- * Whether to show the ruler on the graph.
1921
- */
3289
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
1922
3290
  trackInteraction?: ((args: {
1923
3291
  type: string;
1924
3292
  id: string;
1925
3293
  correct?: boolean | undefined;
1926
3294
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
1927
- customKeypad?: boolean | undefined; /**
1928
- * Whether to show tooltips on the graph.
1929
- * (Currently not used, but will be in the future.)
1930
- */
3295
+ customKeypad?: boolean | undefined;
1931
3296
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
1932
3297
  isMobile?: boolean | undefined;
1933
3298
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -2004,23 +3369,26 @@ declare const InteractiveGraph: {
2004
3369
  [widgetId: string]: any;
2005
3370
  }) => void) | undefined;
2006
3371
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
2007
- imagePlaceholder?: React.ReactNode;
3372
+ imagePlaceholder?: React.ReactNode; /**
3373
+ * The current correct answer for the graph. Updated by this component
3374
+ * when the graph is changed.
3375
+ *
3376
+ * Note that the "Correct answer:" textbox is not an interactive
3377
+ * element. Instead, it is a representation of the correct answer based
3378
+ * on the state of the interactive graph previewed at the bottom of the
3379
+ * editor page.
3380
+ */
2008
3381
  widgetPlaceholder?: React.ReactNode;
2009
3382
  baseElements?: {
2010
3383
  Link: React.ComponentType<any>;
2011
3384
  } | undefined;
2012
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
2013
- * Whether to show the ruler on the graph.
2014
- */
3385
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
2015
3386
  trackInteraction?: ((args: {
2016
3387
  type: string;
2017
3388
  id: string;
2018
3389
  correct?: boolean | undefined;
2019
3390
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
2020
- customKeypad?: boolean | undefined; /**
2021
- * Whether to show tooltips on the graph.
2022
- * (Currently not used, but will be in the future.)
2023
- */
3391
+ customKeypad?: boolean | undefined;
2024
3392
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
2025
3393
  isMobile?: boolean | undefined;
2026
3394
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -2081,23 +3449,26 @@ declare const InteractiveGraph: {
2081
3449
  [widgetId: string]: any;
2082
3450
  }) => void) | undefined;
2083
3451
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
2084
- imagePlaceholder?: React.ReactNode;
3452
+ imagePlaceholder?: React.ReactNode; /**
3453
+ * The current correct answer for the graph. Updated by this component
3454
+ * when the graph is changed.
3455
+ *
3456
+ * Note that the "Correct answer:" textbox is not an interactive
3457
+ * element. Instead, it is a representation of the correct answer based
3458
+ * on the state of the interactive graph previewed at the bottom of the
3459
+ * editor page.
3460
+ */
2085
3461
  widgetPlaceholder?: React.ReactNode;
2086
3462
  baseElements?: {
2087
3463
  Link: React.ComponentType<any>;
2088
3464
  } | undefined;
2089
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
2090
- * Whether to show the ruler on the graph.
2091
- */
3465
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
2092
3466
  trackInteraction?: ((args: {
2093
3467
  type: string;
2094
3468
  id: string;
2095
3469
  correct?: boolean | undefined;
2096
3470
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
2097
- customKeypad?: boolean | undefined; /**
2098
- * Whether to show tooltips on the graph.
2099
- * (Currently not used, but will be in the future.)
2100
- */
3471
+ customKeypad?: boolean | undefined;
2101
3472
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
2102
3473
  isMobile?: boolean | undefined;
2103
3474
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -2158,23 +3529,26 @@ declare const InteractiveGraph: {
2158
3529
  [widgetId: string]: any;
2159
3530
  }) => void) | undefined;
2160
3531
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
2161
- imagePlaceholder?: React.ReactNode;
3532
+ imagePlaceholder?: React.ReactNode; /**
3533
+ * The current correct answer for the graph. Updated by this component
3534
+ * when the graph is changed.
3535
+ *
3536
+ * Note that the "Correct answer:" textbox is not an interactive
3537
+ * element. Instead, it is a representation of the correct answer based
3538
+ * on the state of the interactive graph previewed at the bottom of the
3539
+ * editor page.
3540
+ */
2162
3541
  widgetPlaceholder?: React.ReactNode;
2163
3542
  baseElements?: {
2164
3543
  Link: React.ComponentType<any>;
2165
3544
  } | undefined;
2166
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
2167
- * Whether to show the ruler on the graph.
2168
- */
3545
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
2169
3546
  trackInteraction?: ((args: {
2170
3547
  type: string;
2171
3548
  id: string;
2172
3549
  correct?: boolean | undefined;
2173
3550
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
2174
- customKeypad?: boolean | undefined; /**
2175
- * Whether to show tooltips on the graph.
2176
- * (Currently not used, but will be in the future.)
2177
- */
3551
+ customKeypad?: boolean | undefined;
2178
3552
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
2179
3553
  isMobile?: boolean | undefined;
2180
3554
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -2235,23 +3609,26 @@ declare const InteractiveGraph: {
2235
3609
  [widgetId: string]: any;
2236
3610
  }) => void) | undefined;
2237
3611
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
2238
- imagePlaceholder?: React.ReactNode;
3612
+ imagePlaceholder?: React.ReactNode; /**
3613
+ * The current correct answer for the graph. Updated by this component
3614
+ * when the graph is changed.
3615
+ *
3616
+ * Note that the "Correct answer:" textbox is not an interactive
3617
+ * element. Instead, it is a representation of the correct answer based
3618
+ * on the state of the interactive graph previewed at the bottom of the
3619
+ * editor page.
3620
+ */
2239
3621
  widgetPlaceholder?: React.ReactNode;
2240
3622
  baseElements?: {
2241
3623
  Link: React.ComponentType<any>;
2242
3624
  } | undefined;
2243
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
2244
- * Whether to show the ruler on the graph.
2245
- */
3625
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
2246
3626
  trackInteraction?: ((args: {
2247
3627
  type: string;
2248
3628
  id: string;
2249
3629
  correct?: boolean | undefined;
2250
3630
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
2251
- customKeypad?: boolean | undefined; /**
2252
- * Whether to show tooltips on the graph.
2253
- * (Currently not used, but will be in the future.)
2254
- */
3631
+ customKeypad?: boolean | undefined;
2255
3632
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
2256
3633
  isMobile?: boolean | undefined;
2257
3634
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -2312,23 +3689,26 @@ declare const InteractiveGraph: {
2312
3689
  [widgetId: string]: any;
2313
3690
  }) => void) | undefined;
2314
3691
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
2315
- imagePlaceholder?: React.ReactNode;
3692
+ imagePlaceholder?: React.ReactNode; /**
3693
+ * The current correct answer for the graph. Updated by this component
3694
+ * when the graph is changed.
3695
+ *
3696
+ * Note that the "Correct answer:" textbox is not an interactive
3697
+ * element. Instead, it is a representation of the correct answer based
3698
+ * on the state of the interactive graph previewed at the bottom of the
3699
+ * editor page.
3700
+ */
2316
3701
  widgetPlaceholder?: React.ReactNode;
2317
3702
  baseElements?: {
2318
3703
  Link: React.ComponentType<any>;
2319
3704
  } | undefined;
2320
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
2321
- * Whether to show the ruler on the graph.
2322
- */
3705
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
2323
3706
  trackInteraction?: ((args: {
2324
3707
  type: string;
2325
3708
  id: string;
2326
3709
  correct?: boolean | undefined;
2327
3710
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
2328
- customKeypad?: boolean | undefined; /**
2329
- * Whether to show tooltips on the graph.
2330
- * (Currently not used, but will be in the future.)
2331
- */
3711
+ customKeypad?: boolean | undefined;
2332
3712
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
2333
3713
  isMobile?: boolean | undefined;
2334
3714
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -2389,23 +3769,26 @@ declare const InteractiveGraph: {
2389
3769
  [widgetId: string]: any;
2390
3770
  }) => void) | undefined;
2391
3771
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
2392
- imagePlaceholder?: React.ReactNode;
3772
+ imagePlaceholder?: React.ReactNode; /**
3773
+ * The current correct answer for the graph. Updated by this component
3774
+ * when the graph is changed.
3775
+ *
3776
+ * Note that the "Correct answer:" textbox is not an interactive
3777
+ * element. Instead, it is a representation of the correct answer based
3778
+ * on the state of the interactive graph previewed at the bottom of the
3779
+ * editor page.
3780
+ */
2393
3781
  widgetPlaceholder?: React.ReactNode;
2394
3782
  baseElements?: {
2395
3783
  Link: React.ComponentType<any>;
2396
3784
  } | undefined;
2397
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
2398
- * Whether to show the ruler on the graph.
2399
- */
3785
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
2400
3786
  trackInteraction?: ((args: {
2401
3787
  type: string;
2402
3788
  id: string;
2403
3789
  correct?: boolean | undefined;
2404
3790
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
2405
- customKeypad?: boolean | undefined; /**
2406
- * Whether to show tooltips on the graph.
2407
- * (Currently not used, but will be in the future.)
2408
- */
3791
+ customKeypad?: boolean | undefined;
2409
3792
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
2410
3793
  isMobile?: boolean | undefined;
2411
3794
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -2467,23 +3850,26 @@ declare const InteractiveGraph: {
2467
3850
  [widgetId: string]: any;
2468
3851
  }) => void) | undefined;
2469
3852
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
2470
- imagePlaceholder?: React.ReactNode;
3853
+ imagePlaceholder?: React.ReactNode; /**
3854
+ * The current correct answer for the graph. Updated by this component
3855
+ * when the graph is changed.
3856
+ *
3857
+ * Note that the "Correct answer:" textbox is not an interactive
3858
+ * element. Instead, it is a representation of the correct answer based
3859
+ * on the state of the interactive graph previewed at the bottom of the
3860
+ * editor page.
3861
+ */
2471
3862
  widgetPlaceholder?: React.ReactNode;
2472
3863
  baseElements?: {
2473
3864
  Link: React.ComponentType<any>;
2474
3865
  } | undefined;
2475
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
2476
- * Whether to show the ruler on the graph.
2477
- */
3866
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
2478
3867
  trackInteraction?: ((args: {
2479
3868
  type: string;
2480
3869
  id: string;
2481
3870
  correct?: boolean | undefined;
2482
3871
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
2483
- customKeypad?: boolean | undefined; /**
2484
- * Whether to show tooltips on the graph.
2485
- * (Currently not used, but will be in the future.)
2486
- */
3872
+ customKeypad?: boolean | undefined;
2487
3873
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
2488
3874
  isMobile?: boolean | undefined;
2489
3875
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -2544,23 +3930,26 @@ declare const InteractiveGraph: {
2544
3930
  [widgetId: string]: any;
2545
3931
  }) => void) | undefined;
2546
3932
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
2547
- imagePlaceholder?: React.ReactNode;
3933
+ imagePlaceholder?: React.ReactNode; /**
3934
+ * The current correct answer for the graph. Updated by this component
3935
+ * when the graph is changed.
3936
+ *
3937
+ * Note that the "Correct answer:" textbox is not an interactive
3938
+ * element. Instead, it is a representation of the correct answer based
3939
+ * on the state of the interactive graph previewed at the bottom of the
3940
+ * editor page.
3941
+ */
2548
3942
  widgetPlaceholder?: React.ReactNode;
2549
3943
  baseElements?: {
2550
3944
  Link: React.ComponentType<any>;
2551
3945
  } | undefined;
2552
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
2553
- * Whether to show the ruler on the graph.
2554
- */
3946
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
2555
3947
  trackInteraction?: ((args: {
2556
3948
  type: string;
2557
3949
  id: string;
2558
3950
  correct?: boolean | undefined;
2559
3951
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
2560
- customKeypad?: boolean | undefined; /**
2561
- * Whether to show tooltips on the graph.
2562
- * (Currently not used, but will be in the future.)
2563
- */
3952
+ customKeypad?: boolean | undefined;
2564
3953
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
2565
3954
  isMobile?: boolean | undefined;
2566
3955
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -2621,23 +4010,26 @@ declare const InteractiveGraph: {
2621
4010
  [widgetId: string]: any;
2622
4011
  }) => void) | undefined;
2623
4012
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
2624
- imagePlaceholder?: React.ReactNode;
4013
+ imagePlaceholder?: React.ReactNode; /**
4014
+ * The current correct answer for the graph. Updated by this component
4015
+ * when the graph is changed.
4016
+ *
4017
+ * Note that the "Correct answer:" textbox is not an interactive
4018
+ * element. Instead, it is a representation of the correct answer based
4019
+ * on the state of the interactive graph previewed at the bottom of the
4020
+ * editor page.
4021
+ */
2625
4022
  widgetPlaceholder?: React.ReactNode;
2626
4023
  baseElements?: {
2627
4024
  Link: React.ComponentType<any>;
2628
4025
  } | undefined;
2629
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
2630
- * Whether to show the ruler on the graph.
2631
- */
4026
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
2632
4027
  trackInteraction?: ((args: {
2633
4028
  type: string;
2634
4029
  id: string;
2635
4030
  correct?: boolean | undefined;
2636
4031
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
2637
- customKeypad?: boolean | undefined; /**
2638
- * Whether to show tooltips on the graph.
2639
- * (Currently not used, but will be in the future.)
2640
- */
4032
+ customKeypad?: boolean | undefined;
2641
4033
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
2642
4034
  isMobile?: boolean | undefined;
2643
4035
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -2698,23 +4090,26 @@ declare const InteractiveGraph: {
2698
4090
  [widgetId: string]: any;
2699
4091
  }) => void) | undefined;
2700
4092
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
2701
- imagePlaceholder?: React.ReactNode;
4093
+ imagePlaceholder?: React.ReactNode; /**
4094
+ * The current correct answer for the graph. Updated by this component
4095
+ * when the graph is changed.
4096
+ *
4097
+ * Note that the "Correct answer:" textbox is not an interactive
4098
+ * element. Instead, it is a representation of the correct answer based
4099
+ * on the state of the interactive graph previewed at the bottom of the
4100
+ * editor page.
4101
+ */
2702
4102
  widgetPlaceholder?: React.ReactNode;
2703
4103
  baseElements?: {
2704
4104
  Link: React.ComponentType<any>;
2705
4105
  } | undefined;
2706
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
2707
- * Whether to show the ruler on the graph.
2708
- */
4106
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
2709
4107
  trackInteraction?: ((args: {
2710
4108
  type: string;
2711
4109
  id: string;
2712
4110
  correct?: boolean | undefined;
2713
4111
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
2714
- customKeypad?: boolean | undefined; /**
2715
- * Whether to show tooltips on the graph.
2716
- * (Currently not used, but will be in the future.)
2717
- */
4112
+ customKeypad?: boolean | undefined;
2718
4113
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
2719
4114
  isMobile?: boolean | undefined;
2720
4115
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -2775,23 +4170,26 @@ declare const InteractiveGraph: {
2775
4170
  [widgetId: string]: any;
2776
4171
  }) => void) | undefined;
2777
4172
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
2778
- imagePlaceholder?: React.ReactNode;
4173
+ imagePlaceholder?: React.ReactNode; /**
4174
+ * The current correct answer for the graph. Updated by this component
4175
+ * when the graph is changed.
4176
+ *
4177
+ * Note that the "Correct answer:" textbox is not an interactive
4178
+ * element. Instead, it is a representation of the correct answer based
4179
+ * on the state of the interactive graph previewed at the bottom of the
4180
+ * editor page.
4181
+ */
2779
4182
  widgetPlaceholder?: React.ReactNode;
2780
4183
  baseElements?: {
2781
4184
  Link: React.ComponentType<any>;
2782
4185
  } | undefined;
2783
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
2784
- * Whether to show the ruler on the graph.
2785
- */
4186
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
2786
4187
  trackInteraction?: ((args: {
2787
4188
  type: string;
2788
4189
  id: string;
2789
4190
  correct?: boolean | undefined;
2790
4191
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
2791
- customKeypad?: boolean | undefined; /**
2792
- * Whether to show tooltips on the graph.
2793
- * (Currently not used, but will be in the future.)
2794
- */
4192
+ customKeypad?: boolean | undefined;
2795
4193
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
2796
4194
  isMobile?: boolean | undefined;
2797
4195
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -2852,23 +4250,26 @@ declare const InteractiveGraph: {
2852
4250
  [widgetId: string]: any;
2853
4251
  }) => void) | undefined;
2854
4252
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
2855
- imagePlaceholder?: React.ReactNode;
4253
+ imagePlaceholder?: React.ReactNode; /**
4254
+ * The current correct answer for the graph. Updated by this component
4255
+ * when the graph is changed.
4256
+ *
4257
+ * Note that the "Correct answer:" textbox is not an interactive
4258
+ * element. Instead, it is a representation of the correct answer based
4259
+ * on the state of the interactive graph previewed at the bottom of the
4260
+ * editor page.
4261
+ */
2856
4262
  widgetPlaceholder?: React.ReactNode;
2857
4263
  baseElements?: {
2858
4264
  Link: React.ComponentType<any>;
2859
4265
  } | undefined;
2860
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
2861
- * Whether to show the ruler on the graph.
2862
- */
4266
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
2863
4267
  trackInteraction?: ((args: {
2864
4268
  type: string;
2865
4269
  id: string;
2866
4270
  correct?: boolean | undefined;
2867
4271
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
2868
- customKeypad?: boolean | undefined; /**
2869
- * Whether to show tooltips on the graph.
2870
- * (Currently not used, but will be in the future.)
2871
- */
4272
+ customKeypad?: boolean | undefined;
2872
4273
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
2873
4274
  isMobile?: boolean | undefined;
2874
4275
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -2929,23 +4330,26 @@ declare const InteractiveGraph: {
2929
4330
  [widgetId: string]: any;
2930
4331
  }) => void) | undefined;
2931
4332
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
2932
- imagePlaceholder?: React.ReactNode;
4333
+ imagePlaceholder?: React.ReactNode; /**
4334
+ * The current correct answer for the graph. Updated by this component
4335
+ * when the graph is changed.
4336
+ *
4337
+ * Note that the "Correct answer:" textbox is not an interactive
4338
+ * element. Instead, it is a representation of the correct answer based
4339
+ * on the state of the interactive graph previewed at the bottom of the
4340
+ * editor page.
4341
+ */
2933
4342
  widgetPlaceholder?: React.ReactNode;
2934
4343
  baseElements?: {
2935
4344
  Link: React.ComponentType<any>;
2936
4345
  } | undefined;
2937
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
2938
- * Whether to show the ruler on the graph.
2939
- */
4346
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
2940
4347
  trackInteraction?: ((args: {
2941
4348
  type: string;
2942
4349
  id: string;
2943
4350
  correct?: boolean | undefined;
2944
4351
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
2945
- customKeypad?: boolean | undefined; /**
2946
- * Whether to show tooltips on the graph.
2947
- * (Currently not used, but will be in the future.)
2948
- */
4352
+ customKeypad?: boolean | undefined;
2949
4353
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
2950
4354
  isMobile?: boolean | undefined;
2951
4355
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -3006,23 +4410,26 @@ declare const InteractiveGraph: {
3006
4410
  [widgetId: string]: any;
3007
4411
  }) => void) | undefined;
3008
4412
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
3009
- imagePlaceholder?: React.ReactNode;
4413
+ imagePlaceholder?: React.ReactNode; /**
4414
+ * The current correct answer for the graph. Updated by this component
4415
+ * when the graph is changed.
4416
+ *
4417
+ * Note that the "Correct answer:" textbox is not an interactive
4418
+ * element. Instead, it is a representation of the correct answer based
4419
+ * on the state of the interactive graph previewed at the bottom of the
4420
+ * editor page.
4421
+ */
3010
4422
  widgetPlaceholder?: React.ReactNode;
3011
4423
  baseElements?: {
3012
4424
  Link: React.ComponentType<any>;
3013
4425
  } | undefined;
3014
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
3015
- * Whether to show the ruler on the graph.
3016
- */
4426
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
3017
4427
  trackInteraction?: ((args: {
3018
4428
  type: string;
3019
4429
  id: string;
3020
4430
  correct?: boolean | undefined;
3021
4431
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
3022
- customKeypad?: boolean | undefined; /**
3023
- * Whether to show tooltips on the graph.
3024
- * (Currently not used, but will be in the future.)
3025
- */
4432
+ customKeypad?: boolean | undefined;
3026
4433
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
3027
4434
  isMobile?: boolean | undefined;
3028
4435
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -3083,23 +4490,26 @@ declare const InteractiveGraph: {
3083
4490
  [widgetId: string]: any;
3084
4491
  }) => void) | undefined;
3085
4492
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
3086
- imagePlaceholder?: React.ReactNode;
4493
+ imagePlaceholder?: React.ReactNode; /**
4494
+ * The current correct answer for the graph. Updated by this component
4495
+ * when the graph is changed.
4496
+ *
4497
+ * Note that the "Correct answer:" textbox is not an interactive
4498
+ * element. Instead, it is a representation of the correct answer based
4499
+ * on the state of the interactive graph previewed at the bottom of the
4500
+ * editor page.
4501
+ */
3087
4502
  widgetPlaceholder?: React.ReactNode;
3088
4503
  baseElements?: {
3089
4504
  Link: React.ComponentType<any>;
3090
4505
  } | undefined;
3091
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
3092
- * Whether to show the ruler on the graph.
3093
- */
4506
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
3094
4507
  trackInteraction?: ((args: {
3095
4508
  type: string;
3096
4509
  id: string;
3097
4510
  correct?: boolean | undefined;
3098
4511
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
3099
- customKeypad?: boolean | undefined; /**
3100
- * Whether to show tooltips on the graph.
3101
- * (Currently not used, but will be in the future.)
3102
- */
4512
+ customKeypad?: boolean | undefined;
3103
4513
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
3104
4514
  isMobile?: boolean | undefined;
3105
4515
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -3160,23 +4570,26 @@ declare const InteractiveGraph: {
3160
4570
  [widgetId: string]: any;
3161
4571
  }) => void) | undefined;
3162
4572
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
3163
- imagePlaceholder?: React.ReactNode;
4573
+ imagePlaceholder?: React.ReactNode; /**
4574
+ * The current correct answer for the graph. Updated by this component
4575
+ * when the graph is changed.
4576
+ *
4577
+ * Note that the "Correct answer:" textbox is not an interactive
4578
+ * element. Instead, it is a representation of the correct answer based
4579
+ * on the state of the interactive graph previewed at the bottom of the
4580
+ * editor page.
4581
+ */
3164
4582
  widgetPlaceholder?: React.ReactNode;
3165
4583
  baseElements?: {
3166
4584
  Link: React.ComponentType<any>;
3167
4585
  } | undefined;
3168
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
3169
- * Whether to show the ruler on the graph.
3170
- */
4586
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
3171
4587
  trackInteraction?: ((args: {
3172
4588
  type: string;
3173
4589
  id: string;
3174
4590
  correct?: boolean | undefined;
3175
4591
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
3176
- customKeypad?: boolean | undefined; /**
3177
- * Whether to show tooltips on the graph.
3178
- * (Currently not used, but will be in the future.)
3179
- */
4592
+ customKeypad?: boolean | undefined;
3180
4593
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
3181
4594
  isMobile?: boolean | undefined;
3182
4595
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -3237,23 +4650,26 @@ declare const InteractiveGraph: {
3237
4650
  [widgetId: string]: any;
3238
4651
  }) => void) | undefined;
3239
4652
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
3240
- imagePlaceholder?: React.ReactNode;
4653
+ imagePlaceholder?: React.ReactNode; /**
4654
+ * The current correct answer for the graph. Updated by this component
4655
+ * when the graph is changed.
4656
+ *
4657
+ * Note that the "Correct answer:" textbox is not an interactive
4658
+ * element. Instead, it is a representation of the correct answer based
4659
+ * on the state of the interactive graph previewed at the bottom of the
4660
+ * editor page.
4661
+ */
3241
4662
  widgetPlaceholder?: React.ReactNode;
3242
4663
  baseElements?: {
3243
4664
  Link: React.ComponentType<any>;
3244
4665
  } | undefined;
3245
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
3246
- * Whether to show the ruler on the graph.
3247
- */
4666
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
3248
4667
  trackInteraction?: ((args: {
3249
4668
  type: string;
3250
4669
  id: string;
3251
4670
  correct?: boolean | undefined;
3252
4671
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
3253
- customKeypad?: boolean | undefined; /**
3254
- * Whether to show tooltips on the graph.
3255
- * (Currently not used, but will be in the future.)
3256
- */
4672
+ customKeypad?: boolean | undefined;
3257
4673
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
3258
4674
  isMobile?: boolean | undefined;
3259
4675
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -3314,23 +4730,26 @@ declare const InteractiveGraph: {
3314
4730
  [widgetId: string]: any;
3315
4731
  }) => void) | undefined;
3316
4732
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
3317
- imagePlaceholder?: React.ReactNode;
4733
+ imagePlaceholder?: React.ReactNode; /**
4734
+ * The current correct answer for the graph. Updated by this component
4735
+ * when the graph is changed.
4736
+ *
4737
+ * Note that the "Correct answer:" textbox is not an interactive
4738
+ * element. Instead, it is a representation of the correct answer based
4739
+ * on the state of the interactive graph previewed at the bottom of the
4740
+ * editor page.
4741
+ */
3318
4742
  widgetPlaceholder?: React.ReactNode;
3319
4743
  baseElements?: {
3320
4744
  Link: React.ComponentType<any>;
3321
4745
  } | undefined;
3322
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
3323
- * Whether to show the ruler on the graph.
3324
- */
4746
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
3325
4747
  trackInteraction?: ((args: {
3326
4748
  type: string;
3327
4749
  id: string;
3328
4750
  correct?: boolean | undefined;
3329
4751
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
3330
- customKeypad?: boolean | undefined; /**
3331
- * Whether to show tooltips on the graph.
3332
- * (Currently not used, but will be in the future.)
3333
- */
4752
+ customKeypad?: boolean | undefined;
3334
4753
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
3335
4754
  isMobile?: boolean | undefined;
3336
4755
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -3391,23 +4810,26 @@ declare const InteractiveGraph: {
3391
4810
  [widgetId: string]: any;
3392
4811
  }) => void) | undefined;
3393
4812
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
3394
- imagePlaceholder?: React.ReactNode;
4813
+ imagePlaceholder?: React.ReactNode; /**
4814
+ * The current correct answer for the graph. Updated by this component
4815
+ * when the graph is changed.
4816
+ *
4817
+ * Note that the "Correct answer:" textbox is not an interactive
4818
+ * element. Instead, it is a representation of the correct answer based
4819
+ * on the state of the interactive graph previewed at the bottom of the
4820
+ * editor page.
4821
+ */
3395
4822
  widgetPlaceholder?: React.ReactNode;
3396
4823
  baseElements?: {
3397
4824
  Link: React.ComponentType<any>;
3398
4825
  } | undefined;
3399
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
3400
- * Whether to show the ruler on the graph.
3401
- */
4826
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
3402
4827
  trackInteraction?: ((args: {
3403
4828
  type: string;
3404
4829
  id: string;
3405
4830
  correct?: boolean | undefined;
3406
4831
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
3407
- customKeypad?: boolean | undefined; /**
3408
- * Whether to show tooltips on the graph.
3409
- * (Currently not used, but will be in the future.)
3410
- */
4832
+ customKeypad?: boolean | undefined;
3411
4833
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
3412
4834
  isMobile?: boolean | undefined;
3413
4835
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -3468,23 +4890,26 @@ declare const InteractiveGraph: {
3468
4890
  [widgetId: string]: any;
3469
4891
  }) => void) | undefined;
3470
4892
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
3471
- imagePlaceholder?: React.ReactNode;
4893
+ imagePlaceholder?: React.ReactNode; /**
4894
+ * The current correct answer for the graph. Updated by this component
4895
+ * when the graph is changed.
4896
+ *
4897
+ * Note that the "Correct answer:" textbox is not an interactive
4898
+ * element. Instead, it is a representation of the correct answer based
4899
+ * on the state of the interactive graph previewed at the bottom of the
4900
+ * editor page.
4901
+ */
3472
4902
  widgetPlaceholder?: React.ReactNode;
3473
4903
  baseElements?: {
3474
4904
  Link: React.ComponentType<any>;
3475
4905
  } | undefined;
3476
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
3477
- * Whether to show the ruler on the graph.
3478
- */
4906
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
3479
4907
  trackInteraction?: ((args: {
3480
4908
  type: string;
3481
4909
  id: string;
3482
4910
  correct?: boolean | undefined;
3483
4911
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
3484
- customKeypad?: boolean | undefined; /**
3485
- * Whether to show tooltips on the graph.
3486
- * (Currently not used, but will be in the future.)
3487
- */
4912
+ customKeypad?: boolean | undefined;
3488
4913
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
3489
4914
  isMobile?: boolean | undefined;
3490
4915
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -3545,23 +4970,26 @@ declare const InteractiveGraph: {
3545
4970
  [widgetId: string]: any;
3546
4971
  }) => void) | undefined;
3547
4972
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
3548
- imagePlaceholder?: React.ReactNode;
4973
+ imagePlaceholder?: React.ReactNode; /**
4974
+ * The current correct answer for the graph. Updated by this component
4975
+ * when the graph is changed.
4976
+ *
4977
+ * Note that the "Correct answer:" textbox is not an interactive
4978
+ * element. Instead, it is a representation of the correct answer based
4979
+ * on the state of the interactive graph previewed at the bottom of the
4980
+ * editor page.
4981
+ */
3549
4982
  widgetPlaceholder?: React.ReactNode;
3550
4983
  baseElements?: {
3551
4984
  Link: React.ComponentType<any>;
3552
4985
  } | undefined;
3553
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
3554
- * Whether to show the ruler on the graph.
3555
- */
4986
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
3556
4987
  trackInteraction?: ((args: {
3557
4988
  type: string;
3558
4989
  id: string;
3559
4990
  correct?: boolean | undefined;
3560
4991
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
3561
- customKeypad?: boolean | undefined; /**
3562
- * Whether to show tooltips on the graph.
3563
- * (Currently not used, but will be in the future.)
3564
- */
4992
+ customKeypad?: boolean | undefined;
3565
4993
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
3566
4994
  isMobile?: boolean | undefined;
3567
4995
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -3622,23 +5050,26 @@ declare const InteractiveGraph: {
3622
5050
  [widgetId: string]: any;
3623
5051
  }) => void) | undefined;
3624
5052
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
3625
- imagePlaceholder?: React.ReactNode;
5053
+ imagePlaceholder?: React.ReactNode; /**
5054
+ * The current correct answer for the graph. Updated by this component
5055
+ * when the graph is changed.
5056
+ *
5057
+ * Note that the "Correct answer:" textbox is not an interactive
5058
+ * element. Instead, it is a representation of the correct answer based
5059
+ * on the state of the interactive graph previewed at the bottom of the
5060
+ * editor page.
5061
+ */
3626
5062
  widgetPlaceholder?: React.ReactNode;
3627
5063
  baseElements?: {
3628
5064
  Link: React.ComponentType<any>;
3629
5065
  } | undefined;
3630
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
3631
- * Whether to show the ruler on the graph.
3632
- */
5066
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
3633
5067
  trackInteraction?: ((args: {
3634
5068
  type: string;
3635
5069
  id: string;
3636
5070
  correct?: boolean | undefined;
3637
5071
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
3638
- customKeypad?: boolean | undefined; /**
3639
- * Whether to show tooltips on the graph.
3640
- * (Currently not used, but will be in the future.)
3641
- */
5072
+ customKeypad?: boolean | undefined;
3642
5073
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
3643
5074
  isMobile?: boolean | undefined;
3644
5075
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
@@ -3700,23 +5131,26 @@ declare const InteractiveGraph: {
3700
5131
  [widgetId: string]: any;
3701
5132
  }) => void) | undefined;
3702
5133
  groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
3703
- imagePlaceholder?: React.ReactNode;
5134
+ imagePlaceholder?: React.ReactNode; /**
5135
+ * The current correct answer for the graph. Updated by this component
5136
+ * when the graph is changed.
5137
+ *
5138
+ * Note that the "Correct answer:" textbox is not an interactive
5139
+ * element. Instead, it is a representation of the correct answer based
5140
+ * on the state of the interactive graph previewed at the bottom of the
5141
+ * editor page.
5142
+ */
3704
5143
  widgetPlaceholder?: React.ReactNode;
3705
5144
  baseElements?: {
3706
5145
  Link: React.ComponentType<any>;
3707
5146
  } | undefined;
3708
- imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined; /**
3709
- * Whether to show the ruler on the graph.
3710
- */
5147
+ imagePreloader?: ((dimensions: import("../../../perseus/src/types").Dimensions) => React.ReactNode) | undefined;
3711
5148
  trackInteraction?: ((args: {
3712
5149
  type: string;
3713
5150
  id: string;
3714
5151
  correct?: boolean | undefined;
3715
5152
  } & Partial<import("../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<import("../../../perseus/src/types").TrackingSequenceExtraArguments>) => void) | undefined;
3716
- customKeypad?: boolean | undefined; /**
3717
- * Whether to show tooltips on the graph.
3718
- * (Currently not used, but will be in the future.)
3719
- */
5153
+ customKeypad?: boolean | undefined;
3720
5154
  nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
3721
5155
  isMobile?: boolean | undefined;
3722
5156
  setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;