docs: function() {
  
      /**
       * Abstract Class representing a StackMob Model
       */
      StackMob.Model = Backbone.Model.extend({
        urlRoot : StackMob.getBaseURL(),
  
        getBinaryFields: function() {
          return this.binaryFields || [];
        },
  
        url : function() {
          var base = StackMob.getBaseURL();
          base += this.schemaName;
          return base;
        },
        getPrimaryKeyField : function() {
          return this.schemaName + '_id';
        },
        constructor : function() {
          this.setIDAttribute();
          //have to do this because I want to set this.id before this.set is called in default constructor
          Backbone.Model.prototype.constructor.apply(this, arguments);
        },
        initialize : function(attributes, options) {
          StackMob.getProperty(this, 'schemaName') || StackMob.throwError('A schemaName must be defined');
          this.setIDAttribute();
        },
        setIDAttribute : function() {
          this.idAttribute = this.getPrimaryKeyField();
        },
        parse : function(data, xhr) {
          if(!data || (data && (!data['text'] || data['text'] === '')))
            return data;
  
          var attrs = JSON.parse(data['text']);
  
          return attrs;
        },
        sync : function(method, model, options) {
          StackMob.sync.call(this, method, this, options);
        },
        create : function(options) {
          var newOptions = {};
          newOptions[StackMob.FORCE_CREATE_REQUEST] = true;
          _.extend(newOptions, options);
          this.save(null, newOptions);
        },
        query : function(stackMobQuery, options) {
          options = options || {};
          _.extend(options, {
            query : stackMobQuery
          });
          this.fetch(options);
        },
        fetch : function(options) {
          StackMob.wrapStackMobCallbacks.call(this, options);
          Backbone.Model.prototype.fetch.call(this, options);
        },
        destroy: function(options) {
          StackMob.wrapStackMobCallbacks.call(this, options);
          Backbone.Model.prototype.destroy.call(this, options);
        },
        save : function(key, value) {
          var successFunc = key ? key['success'] : {};
          var errorFunc = key ? key['error'] : {};
          if( typeof value === 'undefined' && (_.isFunction(successFunc) || _.isFunction(errorFunc))) {
            StackMob.wrapStackMobCallbacks.call(this, key);
            Backbone.Model.prototype.save.call(this, null, key);
          } else {
            StackMob.wrapStackMobCallbacks.call(this, value);
            Backbone.Model.prototype.save.call(this, key, value);
          }
        },
        fetchExpanded : function(depth, options) {
          if(depth < 0 || depth > 3)
            StackMob.throwError('Depth must be between 0 and 3 inclusive.');
          var newOptions = {};
          _.extend(newOptions, options);
          newOptions['data'] = newOptions['data'] || {};
          newOptions['data']['_expand'] = depth;
  
          this.fetch(newOptions);
        },
        getAsModel : function(fieldName, model) {
          var obj = this.get(fieldName);
          if(!obj)
            return {};
          else {
            if(_.isArray(obj)) {
              return _.map(obj, function(o) {
                return new model(o);
              });
            } else {
              return new model(obj);
            }
          }
        },
        appendAndCreate : function(fieldName, values, options) {
          this.addRelationship(fieldName, values, options);
        },
        addRelationship : function(fieldName, values, options) {
          options = options || {};
          options[StackMob.ARRAY_FIELDNAME] = fieldName;
          options[StackMob.ARRAY_VALUES] = values;
  
          StackMob.sync.call(this, 'addRelationship', this, options);
        },
        appendAndSave : function(fieldName, values, options) {
          options = options || {};
          options[StackMob.ARRAY_FIELDNAME] = fieldName;
          options[StackMob.ARRAY_VALUES] = values;
          StackMob.sync.call(this, 'appendAndSave', this, options);
        },
        deleteAndSave : function(fieldName, values, cascadeDelete, options) {
          options = options || {};
          options[StackMob.ARRAY_FIELDNAME] = fieldName;
          options[StackMob.ARRAY_VALUES] = values;
          options[StackMob.CASCADE_DELETE] = cascadeDelete;
  
          var model = this;
          options["stackmob_ondeleteAndSave"] = function(){
              var existingValues = model.get(fieldName);
              model.set(fieldName, _.difference(existingValues, values) );
          };
          StackMob.sync.call(this, 'deleteAndSave', this, options);
        },
        setBinaryFile : function(fieldName, filename, filetype, base64EncodedData) {
          var binaryValueString = 'Content-Type: ' + filetype + '\n' + 'Content-Disposition: attachment; ' + 'filename=' + filename + '\n' + 'Content-Transfer-Encoding: base64\n\n' + base64EncodedData;
          this.set(fieldName, binaryValueString);
        },
        incrementOnSave : function(fieldName, value) {
          if(this.attributes[this.idAttribute]) {
            //if we already have a field by this name declared on our object, remove it (because we are going to create a new one with a [inc] appended
            if(this.attributes[fieldName]) {
              delete this.attributes[fieldName];
            }
            this.set(fieldName + '[inc]', value);
          } else {
            StackMob.throwError('Please specify an id for the row you wish to update. When creating a new instance of your object, you need to pass in JSON that includes the id field and value (e.g. var user = new StackMob.User({ username: \'chucknorris\' });)  Or, for custom objects: var todoInstance = new Todo({todo_id : \'1234\'})');
          }
        },
        decrementOnSave : function(fieldName, value) {
          this.incrementOnSave(fieldName, value * -1);
        }
      });
  
    }