docs: function(referenceArgs) {
              // use initiatedOnce format so model prop names can be changed (or multiple can be used)
              // for example, to get all model change monitoring with models set as "foo" and "bar" props, simply use
              // this will not render as a result of 2 way binding (unless the bind attribute is not === true)
              // mixins: ['modelAware("foo", "bar")', 'modelChangeAware']
              var rtn = {
                  getInitialState: function() {
                      return {};
                  },
                  componentWillReceiveProps: function() {
                      // watch for model or collection changes by property so it can be un/rebound
                      this.state[typeData.cachedKey] = undefined;
                  }
              };
              rtn[getThings] = function(callback, props) {
                  // normally we wouldn't keep this kind of thing in state but we are clearing
                  // this state value any time the properties change
                  var _cached = !props && this.state && this.state[typeData.cachedKey];
                  if (!_cached) {
                      _cached = {};
  
                      var _referenceArgs = referenceArgs,
                          propsProvided = !!props;
                      props = props || this.props;
                      if (!_referenceArgs || _referenceArgs.length === 0) {
                          _referenceArgs = typeData.defaultParams;
                      }
  
                      var singleReferenceArgs;
                      for (var i=0; i<_referenceArgs.length; i++) {
                          singleReferenceArgs = _referenceArgs[i];
                          for (var j=0; j<singleReferenceArgs.length; j++) {
                              var propName = singleReferenceArgs[j],
                                  obj = getState(propName, this) || props[propName];
                              if (obj) {
                                  _cached[propName] = obj;
  
  
                              } else if (propsProvided && callback && propName) {
                                  // make callback anyway to let callers know of the prop transition
                                  callback.call(this, undefined, propName);
                              }
                          }
                      }
  
                      // if appropriate, set the cache
                      if (!propsProvided && this.state) {
                          this.state[typeData.cachedKey] = _cached;
                      }
                  }
  
                  var firstModel;
                  _.each(_cached, function(obj, propName) {
                      firstModel = firstModel || obj;
                      if (callback) {
                          callback.call(this, obj, propName);
                      } 
                  }, this);
  
                  return firstModel;
              };
              return rtn;
          }