Pasted

type PickMembers<T, K extends keyof T> = {
    [P in K]: T[P]
};
 
type BadCallback = (arg?: any) => void;
 
class FakeEventEmitter {
    data: {
        [key: string]: BadCallback[];
    } = {};
 
    on(name: string, callback: BadCallback) {
        if (!this.data[name]) {
            this.data[name] = [];
        }
 
        this.data[name].push(callback);
    }
 
    emit(name: string, data?: any) {
        if (!this.data[name]) {
            return;
        }
 
        this.data[name].forEach(cb => {
            cb(data);
        });
    }
}
 
type KeysOfType<
    Terface,
    Filter,
    K extends keyof Terface = keyof Terface
> = K extends (Terface[K] extends Filter ? K : never) ? K : never;
 
interface TypedEventEmitter<
    Events,
    VoidKeys extends KeysOfType<Events, void> = KeysOfType<Events, void>,
    NotVoidKeys extends Exclude<keyof Events, VoidKeys> = Exclude<keyof Events, VoidKeys>
> {
    on<K extends NotVoidKeys>(
        eventName: K,
        callback: (payload: Events[K]) => void
    ) : void;
    emit<K extends NotVoidKeys>(eventName: K, payload: Events[K]) : void;
 
    on<K extends VoidKeys>(
        eventName: K,
        callback: () => void
    ) : void;
    emit<K extends VoidKeys>(eventName: K) : void;
}
 
type StrictEventEmitter<Events,EventEmitter> = TypedEventEmitter<Events> &
    PickMembers<
        EventEmitter,
        Exclude<keyof EventEmitter, keyof TypedEventEmitter<Events>>
    >;
 
interface Point {
    x: number;
    y: number;
}
 
interface Events {
    BasicMessage: string;
    NumberMessage: number;
    PosMsg: Point;
    VoidMsg: void;
}
 
const ee: StrictEventEmitter<Events, FakeEventEmitter> = new FakeEventEmitter();
 
ee.emit("VoidMsg");
 
ee.emit("PosMsg", 145);
ee.emit("PosMsg", { x: 1, y: 2 });