import { vec } from "mafs";
import type { PerseusStrings } from "../../../strings";
import type { PairOfPoints } from "../types";
import type { Coord } from "@khanacademy/perseus-core";
import type { Interval } from "mafs";
/**
 * Given a ray and a rectangular box, find the point where the ray intersects
 * the edge of the box. Assumes the `initialPoint` is inside the box.
 * @param initialPoint - The starting point of the ray.
 * @param throughPoint - A point that the ray passes through. Must be different from initialPoint.
 * @param box - The box with which to intersect the ray, in the form [[xMin, xMax], [yMin, yMax]]
 */
export declare const getIntersectionOfRayWithBox: (initialPoint: vec.Vector2, throughPoint: vec.Vector2, box: [x: Interval, y: Interval]) => [number, number];
export declare function getArrayWithoutDuplicates(array: Array<Coord>): Array<Coord>;
export declare function getSlopeStringForLine(line: PairOfPoints, strings: PerseusStrings): string;
export declare function getInterceptStringForLine(line: PairOfPoints, strings: PerseusStrings, locale: string): string;
export declare function getQuadraticVertexString(vertex: Coord, strings: PerseusStrings): string;
export declare function getQuadraticPointString(pointNumber: any, coord: Coord, strings: PerseusStrings, locale: string): string;
export declare function getQuadraticXIntercepts(a: number, b: number, c: number): number[];
/**
 * Given a list of points, return the angle made by the point at index i
 * with the points at indices i - 1 and i + 1.
 */
export declare function getAngleFromPoints(points: Coord[], i: number): number | null;
export declare function getSideLengthsFromPoints(points: Coord[], i: number, isPolygonOpen?: boolean): Array<{
    pointIndex: number;
    sideLength: number;
}>;
/**
 * Determine whether to determine the string with the
 * exact side length or the approximate side length.
 */
export declare function getPolygonSideString(sideLength: number, pointIndex: number, strings: PerseusStrings, locale: string): string;
/**
 * Calculate an appropriate radius for angle arcs based on the graph range.
 * The radius scales with the range so it's visible at all graph sizes.
 */
export declare function calculateScaledRadius(range: [Interval, Interval]): number;
/**
 * Shared keyboard constraint logic for asymptote-based graph points
 * (exponential, logarithm). Computes the next valid position for each
 * arrow-key direction, skipping up to 3 snap steps to avoid positions
 * rejected by the caller's `isValidPosition` predicate.
 *
 * The per-graph validity rules differ (exponential checks Y vs asymptote and
 * X vs other point; logarithm checks X vs asymptote and Y vs other point),
 * so they are injected via the callback.
 */
export declare function getAsymptoteGraphKeyboardConstraint(coords: ReadonlyArray<Coord>, snapStep: vec.Vector2, pointIndex: number, isValidPosition: (coord: vec.Vector2) => boolean): {
    up: vec.Vector2;
    down: vec.Vector2;
    left: vec.Vector2;
    right: vec.Vector2;
};
/**
 * Position of the asymptote's drag handle in graph-space. For a horizontal
 * asymptote (exponential), this sits at the midpoint of the x-range on
 * the asymptote's y-value. For a vertical asymptote (logarithm), it sits
 * on the asymptote's x-value at the midpoint of the y-range.
 */
export declare function getAsymptoteHandleCoord(orientation: "horizontal" | "vertical", range: [Interval, Interval], asymptote: number): vec.Vector2;
/**
 * Keyboard snap + skip for the asymptote drag handle. `useDraggable`'s
 * function-form constraint expects the returned point to be snap-aligned;
 * it searches along the direction of travel until the returned point is
 * far enough from the current asymptote to register as a move. After
 * snapping, if the proposed position would put the handle on one of the
 * curve points, we step further in the direction of travel until we find
 * a valid position (up to 3 attempts).
 */
export declare function skipAsymptoteKeyboardOverPoint(proposed: vec.Vector2, currentAsymptote: number, coords: ReadonlyArray<Coord>, handleCoord: vec.Vector2, snapStep: vec.Vector2, orientation: "horizontal" | "vertical"): vec.Vector2;
