docs: function (options, callback) {
      if (!callback) {
        callback = options;
        options = {};
      }
  
      var self = this;
  
      this.sagaStore.getTimeoutedSagas(options, function (err, sagas) {
        if (err) {
          debug(err);
          return callback(err);
        }
  
        var sagaModels = [];
        sagas.forEach(function (s) {
          var sagaModel = new SagaModel(s.id);
          sagaModel.set(s);
          sagaModel.actionOnCommit = 'update';
  
          var calledAddCommandToSend = false;
          sagaModel.addCommandToSend = function (cmd) {
            calledAddCommandToSend = true;
            sagaModel.addUnsentCommand(cmd);
          };
          var calledRemoveTimeout = false;
          var orgRemoveTimeout = sagaModel.removeTimeout;
          sagaModel.removeTimeout = function () {
            calledRemoveTimeout = true;
            orgRemoveTimeout.bind(sagaModel)();
          };
          sagaModel.commit = function (clb) {
            var cmds = calledAddCommandToSend ? sagaModel.getUndispatchedCommands() : [];
  
            function onAfterCommit(err) {
              if (err) return clb(err);
  
              function setCommandToDispatched (c, cb) {
                debug('set command to dispatched');
                self.setCommandToDispatched(dotty.get(c, self.definitions.command.id), sagaModel.id, function (err) {
                  if (err) {
                    return cb(err);
                  }
                  sagaModel.removeUnsentCommand(c);
                  cb(null);
                });
              }
  
              if (!self.onCommandHandle) return clb(null);
  
              async.each(sagaModel.getUndispatchedCommands(), function (cmd, callback) {
                debug('publish a command');
                self.onCommandHandle(cmd, function (err) {
                  if (err) {
                    debug(err);
                    return callback(err);
                  }
                  setCommandToDispatched(cmd, callback);
                });
              }, clb);
            }
  
            async.each(cmds, function (cmd, fn) {
              if (dotty.exists(cmd, self.definitions.command.id)) {
                return fn(null);
              }
  
              self.getNewId(function (err, id) {
                if (err) {
                  debug(err);
                  return fn(err);
                }
                dotty.put(cmd, self.definitions.command.id, id);
                fn(null);
              });
            }, function (err) {
              if (err) {
                debug(err);
                return callback(err);
              }
  
              if (sagaModel.isDestroyed()) {
                self.removeSaga(sagaModel, onAfterCommit);
              } else if (calledAddCommandToSend) {
                sagaModel.setCommitStamp(new Date());
                var undispCmds = _.map(sagaModel.getUndispatchedCommands(), function (c) {
                  return { id: dotty.get(c, self.definitions.command.id), payload: c };
                });
                self.sagaStore.save(sagaModel.toJSON(), undispCmds, onAfterCommit);
              } else if (calledRemoveTimeout) {
                sagaModel.setCommitStamp(new Date());
                self.sagaStore.save(sagaModel.toJSON(), [], onAfterCommit);
              } else {
                var err = new Error('Use commit only to remove a saga or to addCommandToSend!');
                debug(err);
                if (clb) { return clb(err); }
                throw err;
              }
            });
          };
          sagaModels.push(sagaModel);
        });
  
        callback(null, sagaModels);
      });
    }