overloading.ts

import { EventEmitter } from 'events'

interface MyEvent {
	payload: any
}

type MyOpenEvent = MyEvent & { type: 'open' }
type MyCloseEvent = MyEvent & { type: 'close' }

type MyOpenHandler = (event: MyOpenEvent) => void
type MyCloseHandler = (event: MyCloseEvent) => void
type MyEventHandler = MyOpenHandler | MyCloseHandler

class Xxx {
	private ee: EventEmitter = new EventEmitter()

	on(name: 'open', callback: (event: MyOpenEvent) => void): void
	on(name: 'close', callback: (event: MyCloseEvent) => void): void
	on(name: 'close' | 'open', callback: MyEventHandler): void {
        this.ee.emit(name, callback)
        if (name === 'open') {
            const event:MyOpenEvent = {type:'open',payload:"open for bizz"}
            // this is ok
            openHandler(event)
            // this fails .. WHY?
            callback(event)
        } else {
            const event:MyCloseEvent = {type:'close',payload:"closed for holidayz"}
            // this fails .. WHY?
            callback(event)
        }
	}
}


const closeHandler = (event: MyCloseEvent) => {
	console.log("lol I'm closing")
	return 'ev:' + event.type
}
const openHandler = (event: MyOpenEvent) => {
	console.log("I'm open for bizz!")
	return 'ev:' + event.type
}

const xxx = new Xxx()
xxx.on('open', openHandler) // works
xxx.on('close', closeHandler) // works
// xxx.on('close', openHandler) // << fail
// xxx.on('open', closeHandler) // << fail