): 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);
};

 linodeBoot(id, configId).then(response => {
   events$.next(genEvent('linode_boot', id, label));
   resetEventsPolling();
 });

 .then(response => {
   events$.next(genEvent('linode_reboot', id, label));
   resetEventsPolling();
 })

 linodeShutdown(id).then(response => {
   events$.next(genEvent('linode_shutdown', id, label));
   resetEventsPolling();
 });

 it('resets both the request deadline and poll multiplier', () => {
   resetEventsPolling();
   expect(eventRequestDeadline).toBe(1234567890 + INTERVAL);
   expect(pollIteration).toBe(1);
 });