import Vector from '../../math/Vector';
import Location from '../../utils/Location';
import Limiter from '../Limiter';
import Steerable from '../Steerable';
import SteeringAcceleration from '../SteeringAcceleration';
import ReachOrientation from './ReachOrientation';
/**
 * The entire steering framework assumes that the direction a character is facing does not have to be its direction of motion. In
 * many cases, however, you would like the character to face in the direction it is moving. To do this you can manually align the
 * orientation of the character to its linear velocity on each frame update or you can use the {@code LookWhereYouAreGoing}
 * behavior.
 * <p>
 * {@code LookWhereYouAreGoing} behavior gives the owner angular acceleration to make it face in the direction it is moving. In
 * this way the owner changes facing gradually, which can look more natural, especially for aerial vehicles such as helicopters or
 * for human characters that can move sideways.
 * <p>
 * This is a process similar to the {@code Face} behavior. The target orientation is calculated using the current velocity of the
 * owner. If there is no velocity, then the target orientation is set to the current orientation. We have no preference in this
 * situation for any orientation.
 *
 * @param <T> Type of vector, either 2D or 3D, implementing the {@link Vector} interface
 *
 * @author davebaol
 */
declare class LookWhereYouAreGoing<T extends Vector<T>> extends ReachOrientation<T> {
    /**
     * Creates a {@code LookWhereYouAreGoing} behavior for the specified owner.
     * @param owner the owner of this behavior.
     */
    constructor(owner: Steerable<T>);
    setOwner(owner: Steerable<T>): LookWhereYouAreGoing<T>;
    setEnabled(enabled: boolean): LookWhereYouAreGoing<T>;
    /**
     * Sets the limiter of this steering behavior. The given limiter must at least take care of the maximum angular speed and
     * acceleration.
     * @return this behavior for chaining.
     */
    setLimiter(limiter: Limiter): LookWhereYouAreGoing<T>;
    /**
     * Sets the target to align to. Notice that this method is inherited from {@link ReachOrientation}, but is completely useless
     * for {@code LookWhereYouAreGoing} because the target orientation is determined by the velocity of the owner itself.
     * @return this behavior for chaining.
     */
    setTarget(target: Location<T>): LookWhereYouAreGoing<T>;
    setAlignTolerance(alignTolerance: number): LookWhereYouAreGoing<T>;
    setDecelerationRadius(decelerationRadius: number): LookWhereYouAreGoing<T>;
    setTimeToTarget(timeToTarget: number): LookWhereYouAreGoing<T>;
    protected calculateRealSteering(steering: SteeringAcceleration<T>): SteeringAcceleration<T>;
}
export default LookWhereYouAreGoing;