import { type LockedFigure, type PerseusImageBackground, type PerseusInteractiveGraphWidgetOptions, type PerseusGraphType, type MarkingsType, type InteractiveGraphDefaultWidgetOptions, type AxisLabelLocation, type ShowAxisArrows, type ShowAxisTicks } from "@khanacademy/perseus-core";
import * as React from "react";
import type { APIOptionsWithDefaults } from "@khanacademy/perseus";
import type { PropsFor } from "@khanacademy/wonder-blocks-core";
declare const InteractiveGraph: {
    new (props: import("../../../../perseus/src/widgets/interactive-graphs/interactive-graph").Props): {
        context: React.ContextType<typeof import("@khanacademy/perseus").PerseusI18nContext>;
        mafsRef: React.RefObject<import("../../../../perseus/src/widgets/interactive-graphs/stateful-mafs-graph").StatefulMafsGraphType>;
        getUserInput(): import("@khanacademy/perseus-core").PerseusInteractiveGraphUserInput;
        getPromptJSON(): import("@khanacademy/perseus").InteractiveGraphPromptJSON | import("@khanacademy/perseus").UnsupportedWidgetPromptJSON;
        getSerializedState(): {
            graph: PerseusGraphType;
            step: [number, number];
            gridStep?: [x: number, y: number];
            snapStep?: [x: number, y: number];
            backgroundImage?: PerseusImageBackground;
            markings: MarkingsType;
            labels: string[];
            labelLocation: AxisLabelLocation;
            showProtractor: boolean;
            showRuler?: boolean;
            showTooltips?: boolean;
            rulerLabel?: string;
            rulerTicks?: number;
            range: import("@khanacademy/perseus-core").GraphRange;
            showAxisArrows: ShowAxisArrows;
            showAxisTicks: ShowAxisTicks;
            correct?: PerseusGraphType;
            lockedFigures: LockedFigure[];
            fullGraphAriaLabel?: string;
            fullGraphAriaDescription?: string;
            trackInteraction: (extraData?: Empty | undefined) => void;
            widgetId: string;
            widgetIndex: number;
            alignment: string | null | undefined;
            static: boolean | null | undefined;
            graded?: boolean | null;
            problemNum: number | null | undefined;
            apiOptions: Readonly<Readonly<{
                isArticle?: boolean;
                onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
                showAlignmentOptions?: boolean;
                readOnly?: boolean;
                editingDisabled?: boolean;
                answerableCallback?: (arg1: boolean) => unknown;
                getAnotherHint?: () => unknown;
                interactionCallback?: (widgetData: {
                    [widgetId: string]: any;
                }) => void;
                imagePlaceholder?: React.ReactNode;
                widgetPlaceholder?: React.ReactNode;
                baseElements?: {
                    Link: React.ComponentType<any>;
                };
                trackInteraction?: (args: {
                    type: string;
                    id: string;
                    correct?: boolean;
                } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
                    visible: number;
                }>) => void;
                customKeypad?: boolean;
                isMobile?: boolean;
                isMobileApp?: boolean;
                hintProgressColor?: string;
                flags?: Record<"input-number-to-numeric-input" | "perseus-renderer-upgrade" | "grapher-to-interactive-graph" | "desmos-calculator" | "perseus-enable-point-label-field", boolean>;
            }> & {
                baseElements: NonNullable<Readonly<{
                    isArticle?: boolean;
                    onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
                    showAlignmentOptions?: boolean;
                    readOnly?: boolean;
                    editingDisabled?: boolean;
                    answerableCallback?: (arg1: boolean) => unknown;
                    getAnotherHint?: () => unknown;
                    interactionCallback?: (widgetData: {
                        [widgetId: string]: any;
                    }) => void;
                    imagePlaceholder?: React.ReactNode;
                    widgetPlaceholder?: React.ReactNode;
                    baseElements?: {
                        Link: React.ComponentType<any>;
                    };
                    trackInteraction?: (args: {
                        type: string;
                        id: string;
                        correct?: boolean;
                    } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
                        visible: number;
                    }>) => void;
                    customKeypad?: boolean;
                    isMobile?: boolean;
                    isMobileApp?: boolean;
                    hintProgressColor?: string;
                    flags?: Record<"input-number-to-numeric-input" | "perseus-renderer-upgrade" | "grapher-to-interactive-graph" | "desmos-calculator" | "perseus-enable-point-label-field", boolean>;
                }>["baseElements"]>;
                isArticle: NonNullable<Readonly<{
                    isArticle?: boolean;
                    onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
                    showAlignmentOptions?: boolean;
                    readOnly?: boolean;
                    editingDisabled?: boolean;
                    answerableCallback?: (arg1: boolean) => unknown;
                    getAnotherHint?: () => unknown;
                    interactionCallback?: (widgetData: {
                        [widgetId: string]: any;
                    }) => void;
                    imagePlaceholder?: React.ReactNode;
                    widgetPlaceholder?: React.ReactNode;
                    baseElements?: {
                        Link: React.ComponentType<any>;
                    };
                    trackInteraction?: (args: {
                        type: string;
                        id: string;
                        correct?: boolean;
                    } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
                        visible: number;
                    }>) => void;
                    customKeypad?: boolean;
                    isMobile?: boolean;
                    isMobileApp?: boolean;
                    hintProgressColor?: string;
                    flags?: Record<"input-number-to-numeric-input" | "perseus-renderer-upgrade" | "grapher-to-interactive-graph" | "desmos-calculator" | "perseus-enable-point-label-field", boolean>;
                }>["isArticle"]>;
                isMobile: NonNullable<Readonly<{
                    isArticle?: boolean;
                    onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
                    showAlignmentOptions?: boolean;
                    readOnly?: boolean;
                    editingDisabled?: boolean;
                    answerableCallback?: (arg1: boolean) => unknown;
                    getAnotherHint?: () => unknown;
                    interactionCallback?: (widgetData: {
                        [widgetId: string]: any;
                    }) => void;
                    imagePlaceholder?: React.ReactNode;
                    widgetPlaceholder?: React.ReactNode;
                    baseElements?: {
                        Link: React.ComponentType<any>;
                    };
                    trackInteraction?: (args: {
                        type: string;
                        id: string;
                        correct?: boolean;
                    } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
                        visible: number;
                    }>) => void;
                    customKeypad?: boolean;
                    isMobile?: boolean;
                    isMobileApp?: boolean;
                    hintProgressColor?: string;
                    flags?: Record<"input-number-to-numeric-input" | "perseus-renderer-upgrade" | "grapher-to-interactive-graph" | "desmos-calculator" | "perseus-enable-point-label-field", boolean>;
                }>["isMobile"]>;
                isMobileApp: NonNullable<Readonly<{
                    isArticle?: boolean;
                    onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
                    showAlignmentOptions?: boolean;
                    readOnly?: boolean;
                    editingDisabled?: boolean;
                    answerableCallback?: (arg1: boolean) => unknown;
                    getAnotherHint?: () => unknown;
                    interactionCallback?: (widgetData: {
                        [widgetId: string]: any;
                    }) => void;
                    imagePlaceholder?: React.ReactNode;
                    widgetPlaceholder?: React.ReactNode;
                    baseElements?: {
                        Link: React.ComponentType<any>;
                    };
                    trackInteraction?: (args: {
                        type: string;
                        id: string;
                        correct?: boolean;
                    } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
                        visible: number;
                    }>) => void;
                    customKeypad?: boolean;
                    isMobile?: boolean;
                    isMobileApp?: boolean;
                    hintProgressColor?: string;
                    flags?: Record<"input-number-to-numeric-input" | "perseus-renderer-upgrade" | "grapher-to-interactive-graph" | "desmos-calculator" | "perseus-enable-point-label-field", boolean>;
                }>["isMobileApp"]>;
                editingDisabled: NonNullable<Readonly<{
                    isArticle?: boolean;
                    onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
                    showAlignmentOptions?: boolean;
                    readOnly?: boolean;
                    editingDisabled?: boolean;
                    answerableCallback?: (arg1: boolean) => unknown;
                    getAnotherHint?: () => unknown;
                    interactionCallback?: (widgetData: {
                        [widgetId: string]: any;
                    }) => void;
                    imagePlaceholder?: React.ReactNode;
                    widgetPlaceholder?: React.ReactNode;
                    baseElements?: {
                        Link: React.ComponentType<any>;
                    };
                    trackInteraction?: (args: {
                        type: string;
                        id: string;
                        correct?: boolean;
                    } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
                        visible: number;
                    }>) => void;
                    customKeypad?: boolean;
                    isMobile?: boolean;
                    isMobileApp?: boolean;
                    hintProgressColor?: string;
                    flags?: Record<"input-number-to-numeric-input" | "perseus-renderer-upgrade" | "grapher-to-interactive-graph" | "desmos-calculator" | "perseus-enable-point-label-field", boolean>;
                }>["editingDisabled"]>;
                onFocusChange: NonNullable<Readonly<{
                    isArticle?: boolean;
                    onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
                    showAlignmentOptions?: boolean;
                    readOnly?: boolean;
                    editingDisabled?: boolean;
                    answerableCallback?: (arg1: boolean) => unknown;
                    getAnotherHint?: () => unknown;
                    interactionCallback?: (widgetData: {
                        [widgetId: string]: any;
                    }) => void;
                    imagePlaceholder?: React.ReactNode;
                    widgetPlaceholder?: React.ReactNode;
                    baseElements?: {
                        Link: React.ComponentType<any>;
                    };
                    trackInteraction?: (args: {
                        type: string;
                        id: string;
                        correct?: boolean;
                    } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
                        visible: number;
                    }>) => void;
                    customKeypad?: boolean;
                    isMobile?: boolean;
                    isMobileApp?: boolean;
                    hintProgressColor?: string;
                    flags?: Record<"input-number-to-numeric-input" | "perseus-renderer-upgrade" | "grapher-to-interactive-graph" | "desmos-calculator" | "perseus-enable-point-label-field", boolean>;
                }>["onFocusChange"]>;
                readOnly: NonNullable<Readonly<{
                    isArticle?: boolean;
                    onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
                    showAlignmentOptions?: boolean;
                    readOnly?: boolean;
                    editingDisabled?: boolean;
                    answerableCallback?: (arg1: boolean) => unknown;
                    getAnotherHint?: () => unknown;
                    interactionCallback?: (widgetData: {
                        [widgetId: string]: any;
                    }) => void;
                    imagePlaceholder?: React.ReactNode;
                    widgetPlaceholder?: React.ReactNode;
                    baseElements?: {
                        Link: React.ComponentType<any>;
                    };
                    trackInteraction?: (args: {
                        type: string;
                        id: string;
                        correct?: boolean;
                    } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
                        visible: number;
                    }>) => void;
                    customKeypad?: boolean;
                    isMobile?: boolean;
                    isMobileApp?: boolean;
                    hintProgressColor?: string;
                    flags?: Record<"input-number-to-numeric-input" | "perseus-renderer-upgrade" | "grapher-to-interactive-graph" | "desmos-calculator" | "perseus-enable-point-label-field", boolean>;
                }>["readOnly"]>;
                showAlignmentOptions: NonNullable<Readonly<{
                    isArticle?: boolean;
                    onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
                    showAlignmentOptions?: boolean;
                    readOnly?: boolean;
                    editingDisabled?: boolean;
                    answerableCallback?: (arg1: boolean) => unknown;
                    getAnotherHint?: () => unknown;
                    interactionCallback?: (widgetData: {
                        [widgetId: string]: any;
                    }) => void;
                    imagePlaceholder?: React.ReactNode;
                    widgetPlaceholder?: React.ReactNode;
                    baseElements?: {
                        Link: React.ComponentType<any>;
                    };
                    trackInteraction?: (args: {
                        type: string;
                        id: string;
                        correct?: boolean;
                    } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
                        visible: number;
                    }>) => void;
                    customKeypad?: boolean;
                    isMobile?: boolean;
                    isMobileApp?: boolean;
                    hintProgressColor?: string;
                    flags?: Record<"input-number-to-numeric-input" | "perseus-renderer-upgrade" | "grapher-to-interactive-graph" | "desmos-calculator" | "perseus-enable-point-label-field", boolean>;
                }>["showAlignmentOptions"]>;
            }>;
            keypadElement?: any;
            onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
            onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
            findWidgets: import("../../../../perseus/src/types").FindWidgetsFunction;
            reviewMode: boolean;
            showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
            handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
            linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
            containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
        };
        render(): React.JSX.Element;
        setState<K extends string | number | symbol>(state: any, callback?: (() => void) | undefined): void;
        forceUpdate(callback?: (() => void) | undefined): void;
        readonly props: Readonly<import("../../../../perseus/src/widgets/interactive-graphs/interactive-graph").Props>;
        state: Readonly<any>;
        refs: {
            [key: string]: React.ReactInstance;
        };
        componentDidMount?(): void;
        shouldComponentUpdate?(nextProps: Readonly<import("../../../../perseus/src/widgets/interactive-graphs/interactive-graph").Props>, nextState: Readonly<any>, nextContext: any): boolean;
        componentWillUnmount?(): void;
        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
        getSnapshotBeforeUpdate?(prevProps: Readonly<import("../../../../perseus/src/widgets/interactive-graphs/interactive-graph").Props>, prevState: Readonly<any>): any;
        componentDidUpdate?(prevProps: Readonly<import("../../../../perseus/src/widgets/interactive-graphs/interactive-graph").Props>, prevState: Readonly<any>, snapshot?: any): void;
        componentWillMount?(): void;
        UNSAFE_componentWillMount?(): void;
        componentWillReceiveProps?(nextProps: Readonly<import("../../../../perseus/src/widgets/interactive-graphs/interactive-graph").Props>, nextContext: any): void;
        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("../../../../perseus/src/widgets/interactive-graphs/interactive-graph").Props>, nextContext: any): void;
        componentWillUpdate?(nextProps: Readonly<import("../../../../perseus/src/widgets/interactive-graphs/interactive-graph").Props>, nextState: Readonly<any>, nextContext: any): void;
        UNSAFE_componentWillUpdate?(nextProps: Readonly<import("../../../../perseus/src/widgets/interactive-graphs/interactive-graph").Props>, nextState: Readonly<any>, nextContext: any): void;
    };
    new (props: import("../../../../perseus/src/widgets/interactive-graphs/interactive-graph").Props, context: any): {
        context: React.ContextType<typeof import("@khanacademy/perseus").PerseusI18nContext>;
        mafsRef: React.RefObject<import("../../../../perseus/src/widgets/interactive-graphs/stateful-mafs-graph").StatefulMafsGraphType>;
        getUserInput(): import("@khanacademy/perseus-core").PerseusInteractiveGraphUserInput;
        getPromptJSON(): import("@khanacademy/perseus").InteractiveGraphPromptJSON | import("@khanacademy/perseus").UnsupportedWidgetPromptJSON;
        getSerializedState(): {
            graph: PerseusGraphType;
            step: [number, number];
            gridStep?: [x: number, y: number];
            snapStep?: [x: number, y: number];
            backgroundImage?: PerseusImageBackground;
            markings: MarkingsType;
            labels: string[];
            labelLocation: AxisLabelLocation;
            showProtractor: boolean;
            showRuler?: boolean;
            showTooltips?: boolean;
            rulerLabel?: string;
            rulerTicks?: number;
            range: import("@khanacademy/perseus-core").GraphRange;
            showAxisArrows: ShowAxisArrows;
            showAxisTicks: ShowAxisTicks;
            correct?: PerseusGraphType;
            lockedFigures: LockedFigure[];
            fullGraphAriaLabel?: string;
            fullGraphAriaDescription?: string;
            trackInteraction: (extraData?: Empty | undefined) => void;
            widgetId: string;
            widgetIndex: number;
            alignment: string | null | undefined;
            static: boolean | null | undefined;
            graded?: boolean | null;
            problemNum: number | null | undefined;
            apiOptions: Readonly<Readonly<{
                isArticle?: boolean;
                onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
                showAlignmentOptions?: boolean;
                readOnly?: boolean;
                editingDisabled?: boolean;
                answerableCallback?: (arg1: boolean) => unknown;
                getAnotherHint?: () => unknown;
                interactionCallback?: (widgetData: {
                    [widgetId: string]: any;
                }) => void;
                imagePlaceholder?: React.ReactNode;
                widgetPlaceholder?: React.ReactNode;
                baseElements?: {
                    Link: React.ComponentType<any>;
                };
                trackInteraction?: (args: {
                    type: string;
                    id: string;
                    correct?: boolean;
                } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
                    visible: number;
                }>) => void;
                customKeypad?: boolean;
                isMobile?: boolean;
                isMobileApp?: boolean;
                hintProgressColor?: string;
                flags?: Record<"input-number-to-numeric-input" | "perseus-renderer-upgrade" | "grapher-to-interactive-graph" | "desmos-calculator" | "perseus-enable-point-label-field", boolean>;
            }> & {
                baseElements: NonNullable<Readonly<{
                    isArticle?: boolean;
                    onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
                    showAlignmentOptions?: boolean;
                    readOnly?: boolean;
                    editingDisabled?: boolean;
                    answerableCallback?: (arg1: boolean) => unknown;
                    getAnotherHint?: () => unknown;
                    interactionCallback?: (widgetData: {
                        [widgetId: string]: any;
                    }) => void;
                    imagePlaceholder?: React.ReactNode;
                    widgetPlaceholder?: React.ReactNode;
                    baseElements?: {
                        Link: React.ComponentType<any>;
                    };
                    trackInteraction?: (args: {
                        type: string;
                        id: string;
                        correct?: boolean;
                    } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
                        visible: number;
                    }>) => void;
                    customKeypad?: boolean;
                    isMobile?: boolean;
                    isMobileApp?: boolean;
                    hintProgressColor?: string;
                    flags?: Record<"input-number-to-numeric-input" | "perseus-renderer-upgrade" | "grapher-to-interactive-graph" | "desmos-calculator" | "perseus-enable-point-label-field", boolean>;
                }>["baseElements"]>;
                isArticle: NonNullable<Readonly<{
                    isArticle?: boolean;
                    onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
                    showAlignmentOptions?: boolean;
                    readOnly?: boolean;
                    editingDisabled?: boolean;
                    answerableCallback?: (arg1: boolean) => unknown;
                    getAnotherHint?: () => unknown;
                    interactionCallback?: (widgetData: {
                        [widgetId: string]: any;
                    }) => void;
                    imagePlaceholder?: React.ReactNode;
                    widgetPlaceholder?: React.ReactNode;
                    baseElements?: {
                        Link: React.ComponentType<any>;
                    };
                    trackInteraction?: (args: {
                        type: string;
                        id: string;
                        correct?: boolean;
                    } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
                        visible: number;
                    }>) => void;
                    customKeypad?: boolean;
                    isMobile?: boolean;
                    isMobileApp?: boolean;
                    hintProgressColor?: string;
                    flags?: Record<"input-number-to-numeric-input" | "perseus-renderer-upgrade" | "grapher-to-interactive-graph" | "desmos-calculator" | "perseus-enable-point-label-field", boolean>;
                }>["isArticle"]>;
                isMobile: NonNullable<Readonly<{
                    isArticle?: boolean;
                    onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
                    showAlignmentOptions?: boolean;
                    readOnly?: boolean;
                    editingDisabled?: boolean;
                    answerableCallback?: (arg1: boolean) => unknown;
                    getAnotherHint?: () => unknown;
                    interactionCallback?: (widgetData: {
                        [widgetId: string]: any;
                    }) => void;
                    imagePlaceholder?: React.ReactNode;
                    widgetPlaceholder?: React.ReactNode;
                    baseElements?: {
                        Link: React.ComponentType<any>;
                    };
                    trackInteraction?: (args: {
                        type: string;
                        id: string;
                        correct?: boolean;
                    } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
                        visible: number;
                    }>) => void;
                    customKeypad?: boolean;
                    isMobile?: boolean;
                    isMobileApp?: boolean;
                    hintProgressColor?: string;
                    flags?: Record<"input-number-to-numeric-input" | "perseus-renderer-upgrade" | "grapher-to-interactive-graph" | "desmos-calculator" | "perseus-enable-point-label-field", boolean>;
                }>["isMobile"]>;
                isMobileApp: NonNullable<Readonly<{
                    isArticle?: boolean;
                    onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
                    showAlignmentOptions?: boolean;
                    readOnly?: boolean;
                    editingDisabled?: boolean;
                    answerableCallback?: (arg1: boolean) => unknown;
                    getAnotherHint?: () => unknown;
                    interactionCallback?: (widgetData: {
                        [widgetId: string]: any;
                    }) => void;
                    imagePlaceholder?: React.ReactNode;
                    widgetPlaceholder?: React.ReactNode;
                    baseElements?: {
                        Link: React.ComponentType<any>;
                    };
                    trackInteraction?: (args: {
                        type: string;
                        id: string;
                        correct?: boolean;
                    } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
                        visible: number;
                    }>) => void;
                    customKeypad?: boolean;
                    isMobile?: boolean;
                    isMobileApp?: boolean;
                    hintProgressColor?: string;
                    flags?: Record<"input-number-to-numeric-input" | "perseus-renderer-upgrade" | "grapher-to-interactive-graph" | "desmos-calculator" | "perseus-enable-point-label-field", boolean>;
                }>["isMobileApp"]>;
                editingDisabled: NonNullable<Readonly<{
                    isArticle?: boolean;
                    onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
                    showAlignmentOptions?: boolean;
                    readOnly?: boolean;
                    editingDisabled?: boolean;
                    answerableCallback?: (arg1: boolean) => unknown;
                    getAnotherHint?: () => unknown;
                    interactionCallback?: (widgetData: {
                        [widgetId: string]: any;
                    }) => void;
                    imagePlaceholder?: React.ReactNode;
                    widgetPlaceholder?: React.ReactNode;
                    baseElements?: {
                        Link: React.ComponentType<any>;
                    };
                    trackInteraction?: (args: {
                        type: string;
                        id: string;
                        correct?: boolean;
                    } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
                        visible: number;
                    }>) => void;
                    customKeypad?: boolean;
                    isMobile?: boolean;
                    isMobileApp?: boolean;
                    hintProgressColor?: string;
                    flags?: Record<"input-number-to-numeric-input" | "perseus-renderer-upgrade" | "grapher-to-interactive-graph" | "desmos-calculator" | "perseus-enable-point-label-field", boolean>;
                }>["editingDisabled"]>;
                onFocusChange: NonNullable<Readonly<{
                    isArticle?: boolean;
                    onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
                    showAlignmentOptions?: boolean;
                    readOnly?: boolean;
                    editingDisabled?: boolean;
                    answerableCallback?: (arg1: boolean) => unknown;
                    getAnotherHint?: () => unknown;
                    interactionCallback?: (widgetData: {
                        [widgetId: string]: any;
                    }) => void;
                    imagePlaceholder?: React.ReactNode;
                    widgetPlaceholder?: React.ReactNode;
                    baseElements?: {
                        Link: React.ComponentType<any>;
                    };
                    trackInteraction?: (args: {
                        type: string;
                        id: string;
                        correct?: boolean;
                    } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
                        visible: number;
                    }>) => void;
                    customKeypad?: boolean;
                    isMobile?: boolean;
                    isMobileApp?: boolean;
                    hintProgressColor?: string;
                    flags?: Record<"input-number-to-numeric-input" | "perseus-renderer-upgrade" | "grapher-to-interactive-graph" | "desmos-calculator" | "perseus-enable-point-label-field", boolean>;
                }>["onFocusChange"]>;
                readOnly: NonNullable<Readonly<{
                    isArticle?: boolean;
                    onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
                    showAlignmentOptions?: boolean;
                    readOnly?: boolean;
                    editingDisabled?: boolean;
                    answerableCallback?: (arg1: boolean) => unknown;
                    getAnotherHint?: () => unknown;
                    interactionCallback?: (widgetData: {
                        [widgetId: string]: any;
                    }) => void;
                    imagePlaceholder?: React.ReactNode;
                    widgetPlaceholder?: React.ReactNode;
                    baseElements?: {
                        Link: React.ComponentType<any>;
                    };
                    trackInteraction?: (args: {
                        type: string;
                        id: string;
                        correct?: boolean;
                    } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
                        visible: number;
                    }>) => void;
                    customKeypad?: boolean;
                    isMobile?: boolean;
                    isMobileApp?: boolean;
                    hintProgressColor?: string;
                    flags?: Record<"input-number-to-numeric-input" | "perseus-renderer-upgrade" | "grapher-to-interactive-graph" | "desmos-calculator" | "perseus-enable-point-label-field", boolean>;
                }>["readOnly"]>;
                showAlignmentOptions: NonNullable<Readonly<{
                    isArticle?: boolean;
                    onFocusChange?: (newFocusPath: import("@khanacademy/perseus").FocusPath, oldFocusPath: import("@khanacademy/perseus").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
                    showAlignmentOptions?: boolean;
                    readOnly?: boolean;
                    editingDisabled?: boolean;
                    answerableCallback?: (arg1: boolean) => unknown;
                    getAnotherHint?: () => unknown;
                    interactionCallback?: (widgetData: {
                        [widgetId: string]: any;
                    }) => void;
                    imagePlaceholder?: React.ReactNode;
                    widgetPlaceholder?: React.ReactNode;
                    baseElements?: {
                        Link: React.ComponentType<any>;
                    };
                    trackInteraction?: (args: {
                        type: string;
                        id: string;
                        correct?: boolean;
                    } & Partial<import("../../../../perseus/src/types").TrackingGradedGroupExtraArguments> & Partial<{
                        visible: number;
                    }>) => void;
                    customKeypad?: boolean;
                    isMobile?: boolean;
                    isMobileApp?: boolean;
                    hintProgressColor?: string;
                    flags?: Record<"input-number-to-numeric-input" | "perseus-renderer-upgrade" | "grapher-to-interactive-graph" | "desmos-calculator" | "perseus-enable-point-label-field", boolean>;
                }>["showAlignmentOptions"]>;
            }>;
            keypadElement?: any;
            onFocus: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
            onBlur: (blurPath: import("@khanacademy/perseus").FocusPath) => void;
            findWidgets: import("../../../../perseus/src/types").FindWidgetsFunction;
            reviewMode: boolean;
            showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
            handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
            linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
            containerSizeClass: import("../../../../perseus/src/util/sizing-utils").SizeClass;
        };
        render(): React.JSX.Element;
        setState<K extends string | number | symbol>(state: any, callback?: (() => void) | undefined): void;
        forceUpdate(callback?: (() => void) | undefined): void;
        readonly props: Readonly<import("../../../../perseus/src/widgets/interactive-graphs/interactive-graph").Props>;
        state: Readonly<any>;
        refs: {
            [key: string]: React.ReactInstance;
        };
        componentDidMount?(): void;
        shouldComponentUpdate?(nextProps: Readonly<import("../../../../perseus/src/widgets/interactive-graphs/interactive-graph").Props>, nextState: Readonly<any>, nextContext: any): boolean;
        componentWillUnmount?(): void;
        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
        getSnapshotBeforeUpdate?(prevProps: Readonly<import("../../../../perseus/src/widgets/interactive-graphs/interactive-graph").Props>, prevState: Readonly<any>): any;
        componentDidUpdate?(prevProps: Readonly<import("../../../../perseus/src/widgets/interactive-graphs/interactive-graph").Props>, prevState: Readonly<any>, snapshot?: any): void;
        componentWillMount?(): void;
        UNSAFE_componentWillMount?(): void;
        componentWillReceiveProps?(nextProps: Readonly<import("../../../../perseus/src/widgets/interactive-graphs/interactive-graph").Props>, nextContext: any): void;
        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("../../../../perseus/src/widgets/interactive-graphs/interactive-graph").Props>, nextContext: any): void;
        componentWillUpdate?(nextProps: Readonly<import("../../../../perseus/src/widgets/interactive-graphs/interactive-graph").Props>, nextState: Readonly<any>, nextContext: any): void;
        UNSAFE_componentWillUpdate?(nextProps: Readonly<import("../../../../perseus/src/widgets/interactive-graphs/interactive-graph").Props>, nextState: Readonly<any>, nextContext: any): void;
    };
    contextType: React.Context<import("../../../../perseus/src/components/i18n-context").I18nContextType>;
    defaultProps: {
        labels: string[];
        labelLocation: import("../../../../perseus/src/widgets/interactive-graphs/interactive-graph").Props["labelLocation"];
        range: import("../../../../perseus/src/widgets/interactive-graphs/interactive-graph").Props["range"];
        showAxisArrows: import("../../../../perseus/src/widgets/interactive-graphs/interactive-graph").Props["showAxisArrows"];
        showAxisTicks: import("../../../../perseus/src/widgets/interactive-graphs/interactive-graph").Props["showAxisTicks"];
        step: import("../../../../perseus/src/widgets/interactive-graphs/interactive-graph").Props["step"];
        backgroundImage: import("../../../../perseus/src/widgets/interactive-graphs/interactive-graph").Props["backgroundImage"];
        markings: import("../../../../perseus/src/widgets/interactive-graphs/interactive-graph").Props["markings"];
        showTooltips: import("../../../../perseus/src/widgets/interactive-graphs/interactive-graph").Props["showTooltips"];
        showProtractor: import("../../../../perseus/src/widgets/interactive-graphs/interactive-graph").Props["showProtractor"];
        userInput: import("../../../../perseus/src/widgets/interactive-graphs/interactive-graph").Props["userInput"];
    };
    getEquationString(props: import("../../../../perseus/src/widgets/interactive-graphs/interactive-graph").Props): string;
};
type InteractiveGraphProps = PropsFor<typeof InteractiveGraph>;
type Range = [min: number, max: number];
export type Props = {
    apiOptions: APIOptionsWithDefaults;
    /**
     * The labels for the x and y axes.
     */
    labels: ReadonlyArray<string>;
    /**
     * Specifies the location of the labels on the graph.  default: "onAxis".
     * - "onAxis": Labels are positioned on the axis at the right (x) and top (y) of the graph.
     * - "alongEdge": Labels are centered along the bottom (x) and left (y) edges of the graph.
     *    The y label is rotated. Typically used when the range min is near 0 with longer labels.
     */
    labelLocation?: AxisLabelLocation;
    /**
     * The range of the graph in the x and y directions.
     */
    range: [x: Range, y: Range];
    /**
     * Whether the graph is bounded on the x and y axes.
     */
    showAxisArrows: ShowAxisArrows;
    /**
     * Whether to show tick marks and tick numbers per axis.
     */
    showAxisTicks: ShowAxisTicks;
    /**
     * How far apart the tick marks on the axes are in the x and y
     * directions.
     */
    step: [x: number, y: number];
    /**
     * How far apart the grid lines are in the x and y directions.
     */
    gridStep: [x: number, y: number];
    /**
     * How far apart the snap-to points are in the x and y directions.
     */
    snapStep: [x: number, y: number];
    /**
     * The size of the graph in pixels.
     */
    box: [x: number, y: number];
    /**
     * An error message to display in the graph area, or true if the
     * graph is valid.
     */
    valid: true | string;
    /**
     * The background image to display in the graph area and its properties.
     */
    backgroundImage: PerseusImageBackground;
    /**
     * The type of markings to display on the graph.
     * - graph: shows the axes and the grid lines
     * - grid: shows only the grid lines
     * - none: shows no markings
     */
    markings: MarkingsType;
    /**
     * Whether to show the protractor on the graph.
     */
    showProtractor: boolean;
    /**
     * Whether to show tooltips on the graph.
     * (Currently not used, but will be in the future.)
     */
    showTooltips: boolean;
    /**
     * The current correct answer for the graph. Updated by this component
     * when the graph is changed.
     *
     * Note that the "Correct answer:" textbox is not an interactive
     * element. Instead, it is a representation of the correct answer based
     * on the state of the interactive graph previewed at the bottom of the
     * editor page.
     */
    correct: PerseusGraphType;
    /**
     * The locked figures to display in the graph area.
     * Locked figures are graph elements (points, lines, line segmeents,
     * etc.) that are locked in place and not interactive.
     */
    lockedFigures?: Array<LockedFigure>;
    fullGraphAriaLabel?: string;
    fullGraphAriaDescription?: string;
    /**
     * The graph to display in the graph area.
     */
    graph: InteractiveGraphProps["userInput"];
    onChange: (props: Partial<Props>) => void;
    static?: boolean;
    /**
     * Whether this widget is graded.
     */
    graded?: boolean;
};
/**
 * An editor for the InteractiveGraph widget, which allows the user to
 * specify the graph's properties and the correct answer.
 *
 * Used in the exercise editor.
 */
declare class InteractiveGraphEditor extends React.Component<Props> {
    static widgetName: string;
    static bestPractices: {
        url: string;
        label: string;
    };
    displayName: string;
    className: string;
    static defaultProps: InteractiveGraphDefaultWidgetOptions & {
        valid: true | string;
    };
    changeStartCoords: (coords: any) => void;
    changePointLabels: (pointLabels: ReadonlyArray<string>) => void;
    changeShowPointLabels: (showPointLabels: boolean) => void;
    serialize(): PerseusInteractiveGraphWidgetOptions;
    getSaveWarnings: () => any[];
    render(): React.JSX.Element;
}
export default InteractiveGraphEditor;
