import Evented = require("../Evented");

declare namespace fx {
    /* dojo/_base/fx */

    interface Line {
        /**
         * Returns the point on the line
         * @param {number} n a floating point number greater than 0 and less than 1
         */
        getValue(n: number): number;
    }

    /**
     * Object used to generate values from a start value to an end value
     */
    interface LineConstructor {
        new(start: number, end: number): Line;
    }

    interface EasingFunction {
        (n?: number): number;
    }

    interface Animation extends Evented {
        /**
         * The time in milliseconds the animation will take to run
         */
        duration: number;

        /**
         * A two element array of start and end values, or a `_Line` instance to be
         * used in the Animation.
         */
        curve: Line | [number, number];

        /**
         * A Function to adjust the acceleration (or deceleration) of the progress
         * across a _Line
         */
        easing?: EasingFunction;

        /**
         * The number of times to loop the animation
         */
        repeat: number;

        /**
         * the time in milliseconds to wait before advancing to next frame
         * (used as a fps timer: 1000/rate = fps)
         */
        rate: number;

        /**
         * The time in milliseconds to wait before starting animation after it
         * has been .play()'ed
         */
        delay?: number;

        /**
         * Synthetic event fired before a Animation begins playing (synchronous)
         */
        beforeBegin?: Event;

        /**
         * Synthetic event fired as a Animation begins playing (useful?)
         */
        onBegin?: Event;

        /**
         * Synthetic event fired at each interval of the Animation
         */
        onAnimate?: Event;

        /**
         * Synthetic event fired after the final frame of the Animation
         */
        onEnd?: Event;

        /**
         * Synthetic event fired any time the Animation is play()'ed
         */
        onPlay?: Event;

        /**
         * Synthetic event fired when the Animation is paused
         */
        onPause?: Event;

        /**
         * Synthetic event fires when the Animation is stopped
         */
        onStop?: Event;

        _precent: number;
        _startRepeatCount: number;
        _getStep(): number;

        /**
         * Convenience function.  Fire event "evt" and pass it the
         * arguments specified in "args".
         */
        _fire(evt: Event, args?: any[]): this;

        /**
         * Start the animation.
         */
        play(delay?: number, gotoStart?: boolean): this;

        _play(gotoStart?: boolean): this;

        /**
         * Pauses a running animation.
         */
        pause(): this;

        /**
         * Sets the progress of the animation.
         */
        gotoPercent(precent: number, andPlay?: boolean): this;

        /**
         * Stops a running animation.
         */
        stop(gotoEnd?: boolean): Animation;

        /**
         * cleanup the animation
         */
        destroy(): void;

        /**
         * Returns a string token representation of the status of
         * the animation, one of: "paused", "playing", "stopped"
         */
        status(): string;

        _cycle(): Animation;
        _clearTimer(): void;
        _startTimer(): void;
        _stopTimer(): void;
    }

    /**
     * A generic animation class that fires callbacks into its handlers
     * object at various states.
     */
    interface AnimationConstructor {
        new(args: any): Animation;
        prototype: Animation;
    }

    interface AnimationCallback {
        (node: HTMLElement): void;
    }

    interface FadeArguments {
        node: HTMLElement | string;
        duration?: number;
        easing?: EasingFunction;

        start?: Function;
        end?: Function;
    }

    interface AnimationArgumentsProperties {
        [name: string]: any;
    }

    interface AnimationArguments extends FadeArguments {
        properties?: AnimationArgumentsProperties;
        onEnd?: AnimationCallback;
    }

    interface Fx {
        _Line: LineConstructor;

        Animation: AnimationConstructor;

        _fade(args: any): Animation;

        /**
         * Returns an animation that will fade node defined in 'args' from
         * its current opacity to fully opaque.
         */
        fadeIn(args: FadeArguments): Animation;

        /**
         * Returns an animation that will fade node defined in 'args'
         * from its current opacity to fully transparent.
         */
        fadeOut(args: FadeArguments): Animation;

        _defaultEasing(n?: number): number;

        /**
         * Returns an animation that will transition the properties of
         * node defined in `args` depending how they are defined in
         * `args.properties`
         */
        animateProperty(args: AnimationArguments): Animation;

        /**
         * A simpler interface to `animateProperty()`, also returns
         * an instance of `Animation` but begins the animation
         * immediately, unlike nearly every other Dojo animation API.
         */
        anim(
            node: HTMLElement | string,
            properties: { [name: string]: any },
            duration?: number,
            easing?: Function,
            onEnd?: AnimationCallback,
            delay?: number): Animation;
    }
}
declare const fx: fx.Fx;
export = fx;