docs: function (model, data, action, options) {
                  var schema = model.schema,
                      schemaDefinition,
                      schemaType,
                      value,
                      factory,
                      newData = {};
  
                  // convert top level properties to Models respective to there schema
                  for (var key in schema) {
                      if (schema.hasOwnProperty(key)) {
  
                          schemaDefinition = schema[key];
                          schemaType = schemaDefinition.type;
                          value = this._getValueForKey(data, key, schemaType, schemaDefinition);
  
                          factory = null;
                          var typeResolver,
                              entity,
                              i,
                              list;
                          if (schemaType instanceof Array) {
                              if (schemaType.length === 1) {
                                  typeResolver = schemaType[0];
                              } else if (schemaType.length === 0) {
                                  this.log('ModelFactory for ListItem for "' + key + '" not defined', 'warn');
                                  factory = Entity;
                              } else {
                                  throw "Cannot determinate ModelFactory. Multiple factories defined for '" + key + "'.";
                              }
  
                              if (typeResolver instanceof Function) {
                                  factory = typeResolver;
                                  typeResolver = null;
                              }
  
                              if (value && value instanceof Array) {
                                  // only create the list if items are there
                                  list = newData[key] = new List();
  
                                  for (i = 0; i < value.length; i++) {
  
                                      if (typeResolver) {
                                          factory = typeResolver.resolve(value[i], key);
                                      }
  
                                      if ((factory && factory.classof(Entity))) {
                                          entity = this.$dataSource._getContext(factory, model, value[i]).createEntity(factory, this._getIdForValue(value[i], factory));
                                          if (entity instanceof Entity && !(entity instanceof Model)) {
                                              entity.$parent = model;
                                              entity.$parentEntity = model;
                                          }
                                          entity.set(this._parseModel(entity, value[i], action, options));
  
                                          list.add(entity);
                                      } else {
                                          list.add(value[i]);
                                      }
  
                                  }
                              }
  
  
                          } else if (Collection && schemaType.classof(Collection)) {
                              var contextForChildren = this.$dataSource._getContext(schemaType, model, value);
                              if (contextForChildren) {
                                  if (model.$[key] instanceof Collection) {
                                      newData[key] = model.$[key];
                                      list = model.$[key];
                                  } else {
                                      list = newData[key] = contextForChildren.createCollection(schemaType, (value instanceof Object) && !(value instanceof Array) ? value : null);
                                      list.$parent = contextForChildren.$contextModel;
                                  }
                                  if (value && value instanceof Array) {
                                      list.reset(this.parseCollection(list, value, action, options));
                                  }
  
                              }
                          } else if (schemaType === Date && value && !(value instanceof Date)) {
                              newData[key] = moment(value, this.$dataSource.$.dateFormat).toDate();
                          } else if (schemaType.classof(Entity)) {
                              var id;
                              if (value && schemaType instanceof TypeResolver) {
                                  factory = schemaType.resolve(value, key);
                              } else {
                                  factory = schemaType || Entity;
                              }
  
                              if (!(factory && factory.classof(Entity))) {
                                  throw "Factory for type '" + key + "' isn't an instance of Entity";
                              }
  
                              if (factory.classof(Model) && factory.prototype.$isDependentObject) {
                                  id = key;
                                  value = value || {};
                              } else if (value) {
                                  id = this._getIdForValue(value, factory);
                              }
                              if (value) {
                                  newData[key] = entity = this.$dataSource._getContext(factory, model, value).createEntity(factory, id);
                                  if (entity instanceof Entity && !(entity instanceof Model)) {
                                      entity.$parent = model;
                                      entity.$parentEntity = model;
                                  }
                                  entity.set(this._parseModel(entity, value, action, options));
                              }
  
                          }
                      }
                  }
  
                  // add all values that are not defined in schema ...
                  _.defaults(newData, data);
  
                  return model.parse(newData);
              }