Javascript – Typescript keyboard event : argument of type ‘Event’ is not assignable to parameter of type ‘KeyboardEvent’

I'have the following error even if the code run perfectly:

"TS2345: Argument of type 'Event' is not assignable to parameter of type 'KeyboardEvent'.
  Property 'altKey' is missing in type 'Event'." 
// In a Class
public listenTo = (window: Window) => {
  ['keydown', 'keyup'].forEach(eventName => {
     window.addEventListener(eventName, e => {
       this.handleEvent(e); // <- error here
public handleEvent = (event: KeyboardEvent) => {
    const { key } = event;
    //...
I tried to define the event type to KeyboardEvent, but I have the following error :
 window.addEventListener(eventName, (e:KeyboardEvent) => {
           this.handleEvent(e); // <- error here
 TS2345: Argument of type '(event: KeyboardEvent) => void' is not assignable to parameter of type 'EventListenerOrEventListenerObject'.
  Type '(event: KeyboardEvent) => void' is not assignable to type 'EventListenerObject'.
 Property 'handleEvent' is missing in type '(event: KeyboardEvent) => void'.
Is there a way to pass through or resolve the issue ?
TypeScript isn't able to make the full leap here, because all it knows is the event name will be a string, so the most general event type is used.
Examples below converted to a stand alone running example - so I've taken things "out of a class" for the demo...
While the strings are keydown and keyup you can guarantee the type safety, and overrule the compiler:
let listenTo = (window: Window) => {
  ['keydown', 'keyup'].forEach(eventName => {
     window.addEventListener(eventName, e => {
       handleEvent(<any>e);
let handleEvent = (event: KeyboardEvent) => {
    const { key } = event;
    //...
This would fall down if some other string was added to your array of event names.
Full type safety is available when using a string directly, due to specialized signatures:
  window.addEventListener('keydown', e => {
     handleEvent(e); // e is KeyboardEvent
So you could type your array more strongly to get the correct types goodness:
type KeyboardEventNames = 'keydown' | 'keyup';
let listenTo = (window: Window) => {
  const eventNames: KeyboardEventNames[] = ['keydown', 'keyup']; 
  eventNames.forEach(eventName => {
     window.addEventListener(eventName, e => {
       handleEvent(e);
let handleEvent = (event: KeyboardEvent) => {
    const { key } = event;
    //...
In this last example, we restict the type of elements in the array to only keyboard event names, so the compiler now knows it isn't dealing with just any old string, and can infer the event type.
Related Solutions
Typescript – error TS2345: Argument of type ‘T’ is not assignable to parameter of type ‘object’

Change signature of the function, so that generic type T extends type object, introduced in Typescript 2.2. Use this syntax - <T extends object>:
function create<T extends object>(prototype: T, pojo: Object): T {
    return Object.create(prototype, descriptors) as T;
    
Javascript – Argument of type ‘(e: CustomEvent) => void’ is not assignable to parameter of type ‘EventListenerOrEventListenerObject’

This is due to the behavior of the --strictFunctionTypes compiler flag added in TypeScript v2.6.  A function of type (e: CustomEvent) => void is no longer considered to be a valid instance of EventListener, which takes an Event parameter, not a CustomEvent.  
So one way to fix it is to turn off --strictFunctionTypes.
Another way is to pass in a function that takes an Event and then narrows to CustomEvent via a type guard:
function isCustomEvent(event: Event): event is CustomEvent {
  return 'detail' in event;
window.addEventListener('OnRewards', (e: Event) => {
  if (!isCustomEvent(e))
    throw new Error('not a custom event');
  // e is now narrowed to CustomEvent ...
  // my code here 
A third way is to use the other overload of addEventListener():
addEventListener<K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, useCapture?: boolean): void;
If the type parameter is the name of a known event type (K extends keyof WindowEventMap) like "onclick", then the listener function will expect its parameter to be of that narrowed event type (WindowEventMap[K]).  The problem is that "OnRewards" is not a known event type... unless you use declaration merging to make it known:
// merge into WindowEventMap
interface WindowEventMap {
    OnRewards: CustomEvent
Or, if you're inside a module (anything with export in it), use global augmentation:
// merge into WindowEventMap
declare global {
  interface WindowEventMap {
    OnRewards: CustomEvent
Then use your code as before:
// no error!
window.addEventListener('OnRewards', (e: CustomEvent) => {
    // my code here