import '../../assert/js/assert.js';
import '../../globals.js';
/**
 * Controls a specific animated value for an Animation.
 *
 * @author Jonathan Olson <jonathan.olson@colorado.edu>
 */
import TProperty from '../../axon/js/TProperty.js';
import Vector2 from '../../dot/js/Vector2.js';
import Vector3 from '../../dot/js/Vector3.js';
import Vector4 from '../../dot/js/Vector4.js';
import KeysMatching from '../../phet-core/js/types/KeysMatching.js';
import { Color } from '../../scenery/js/imports.js';
import Easing from './Easing.js';
type BlendFunction<T> = (a: T, b: T, fraction: number) => T;
type DistanceFunction<T> = (a: T, b: T) => number;
type AddFunction<T> = (a: T, b: T) => T;
type InternalAnimationTargetOptions<T, Obj = unknown> = {
    setValue?: ((value: T) => void) | null;
    getValue?: (() => T) | null;
    property?: TProperty<T> | null;
    object?: Obj | null;
    attribute?: KeysMatching<Obj, T> | null;
    to?: T | null;
    delta?: T | null;
    speed?: number | null;
    from?: T | null;
    easing?: Easing;
    blend?: BlendFunction<T>;
    distance?: DistanceFunction<T>;
    add?: AddFunction<T>;
};
export type AnimationTargetOptions<T = unknown, Obj = unknown> = InternalAnimationTargetOptions<T, Obj>;
declare class AnimationTarget<T, Obj = unknown> {
    private readonly setValue;
    private readonly getValue;
    private readonly easing;
    private readonly to;
    private readonly from;
    private readonly delta;
    private readonly speed;
    private readonly blend;
    private readonly distance;
    private readonly add;
    private startingValue;
    private endingValue;
    /**
     * NOTE: Generally don't use this directly. Instead, use Animation, providing config for one or more targets.
     *
     * Every animation target needs two things:
     *
     * 1. A way of getting/setting the animated value (`setValue`/`getValue`, `property`, or `object`/`attribute`).
     * 2. A way of determining the value to animate toward (`to` or `delta`).
     */
    constructor(providedConfig: AnimationTargetOptions<T, Obj>);
    /**
     * Default blending function for the `blend` function.
     */
    static DEFAULT_BLEND(a: number, b: number, ratio: number): number;
    static DEFAULT_BLEND(a: Color, b: Color, ratio: number): Color;
    static DEFAULT_BLEND(a: Vector2, b: Vector2, ratio: number): Vector2;
    static DEFAULT_BLEND(a: Vector3, b: Vector3, ratio: number): Vector3;
    static DEFAULT_BLEND(a: Vector4, b: Vector4, ratio: number): Vector4;
    /**
     * Default distance function for the `distance` option (used for the `speed` option)
     */
    static DEFAULT_DISTANCE(a: number, b: number): number;
    static DEFAULT_DISTANCE(a: Vector2, b: Vector2): number;
    static DEFAULT_DISTANCE(a: Vector3, b: Vector3): number;
    static DEFAULT_DISTANCE(a: Vector4, b: Vector4): number;
    /**
     * Default addition function for the `add` option (used for the `delta` option)
     */
    static DEFAULT_ADD(a: number, b: number): number;
    static DEFAULT_ADD(a: Vector2, b: Vector2): Vector2;
    static DEFAULT_ADD(a: Vector3, b: Vector3): Vector3;
    static DEFAULT_ADD(a: Vector4, b: Vector4): Vector4;
    /**
     * Helper function for creating a setter closure for object[ attribute ].
     */
    private static OBJECT_SET;
    /**
     * Helper function for creating a getter closure for object[ attribute ].
     */
    private static OBJECT_GET;
    /**
     * Helper function for creating a setter closure for Properties
     */
    private static PROPERTY_SET;
    /**
     * Helper function for creating a getter closure for Properties
     */
    private static PROPERTY_GET;
    /**
     * Computes the starting and ending values of this target.
     *
     * Generally called when the animation is just about to begin, so it can look up the current value if necessary.
     */
    computeStartEnd(): void;
    /**
     * Updates the value of this target.
     *
     * @param ratio - How far along (from 0 to 1) in the animation.
     */
    update(ratio: number): void;
    /**
     * Whether this target can define the duration of an animation.
     */
    hasPreferredDuration(): boolean;
    /**
     * Returns the preferred duration of this target (or null if not defined).
     */
    getPreferredDuration(): number | null;
}
export default AnimationTarget;
//# sourceMappingURL=AnimationTarget.d.ts.map