): Middleware => ({ dispatch, getState }) => next => (action: any) => {
  if (isType(action, addEvents)) {
    const { payload } = action;
    /**
     * We never want to dispatch actions for intial events, so filter them out.
     * We also need to only deal with one event per entity at a time, so uniqueEntityEvents
     * handles filtering for unique events. Notably linode_create/linode_boot and others.
     */
    const eventsToDispatch = compose(
      uniqueEntityEvents,
      filterInitial
    )(payload);

    /**
     * The incoming events is an array, usually of one but potentially many, so we have
     * to handle each one.
     */
    for (const event of eventsToDispatch) {
      /**
       * We can bail immediately if there is no associated entity since we need an entity
       * to update the store.
       */
      if (!isEntityEvent(event)) {
        return;
      }

      /**
       * Having an event we care about, we can call the handlers with the event and dispatch.
       */
      for (const handler of eventHandlers) {
        handler(event, dispatch, getState);
      }

      /**
       * Finally, if any of these events were in-progress we want to reset the events polling
       * interval to keep things moving quickly.
       */
      if (isInProgressEvent(event)) {
        // If the event is in_progress, we poll more aggressively
        resetEventsPolling();
      }
    }
  }

  next(action);
};

 (events) => {
   let idx = 0
   const len = events.length;
   for (; idx < len; idx += 1) {
     const event = events[idx];
     const { entity } = event;
     if (isInProgressEvent(event) && entity && entity.type === 'linode' && entity.id === linodeId) {
       return event;
     }
   }
   return undefined;
 },

 (events) => events.filter(e => isInProgressEvent(e) && e.entity && e.entity.type === type)

 e => isInProgressEvent(e) && e.entity && e.entity.type === type