Introduction of inferred event types

[Kamilczak020]

Currently, inner events are typed with a generic Event interface:

interface IObservable<T> {
    /**
     * Observes specified event
     * @param eventName Event name (eg. 'after:render')
     * @param handler Function that receives a notification when an event of the specified type occurs
     */
    on(eventName: string, handler: (e: IEvent) => void): T;

    /**
     * Stops event observing for a particular event handler. Calling this method
     * without arguments removes all handlers for all events
     * @param eventName Event name (eg. 'after:render') or object with key/value pairs (eg. {'after:render': handler, 'selection:cleared': handler})
     * @param handler Function to be deleted from EventListeners
     */
    off(eventName?: string | any, handler?: (e: IEvent) => void): T;

    /**
     * Fires event with an optional options object
     * @memberOf fabric.Observable
     * @param {String} eventName Event name to fire
     * @param {Object} [options] Options object
     * @return {Self} thisArg
     * @chainable
     */
    fire(eventName: string, options?: any): T;
}

interface IEvent {
    e: Event; // Generic event
    target?: Object;
    subTargets?: Object[];
    button?: number;
    isClick?: boolean;
    pointer?: Point;
    absolutePointer?: Point;
    transform?: { corner: string; original: Object; originX: string; originY: string; width: number };
}

This means that for Typescript users who want to access properties specific to certain events (example: wheel events' deltaY) need to manually cast the event type.

After a short browse through the repo, these seem to always be native DOM events, (unless I missed something) which should make this fix even less involving.

NOTE: (I will update this post with possible solutions after work)

[asturur]

Typed where? In definetely typed?