code: function DefaultChangeRequestInterceptor(saveContext, saveBundle) {
      /**
       Prepare and return the save data for an entity change-set.
  
       The adapter calls this method for each entity in the change-set,
       after it has prepared a "change request" for that object.
  
       The method can do anything to the request but it must return a valid, non-null request.
       @example
       this.getRequest = function (request, entity, index) {
              // alter the request that the adapter prepared for this entity
              // based on the entity, saveContext, and saveBundle
              // e.g., add a custom header or prune the originalValuesMap
              return request;
          };
       @method getRequest
       @param request {Object} The object representing the adapter's request to save this entity.
       @param entity {Entity} The entity-to-be-save as it is in cache
       @param index {Integer} The zero-based index of this entity in the change-set array
       @return {Function} The potentially revised request.
       **/
      this.getRequest = function (request, entity, index) {
        return request;
      };
  
      /**
       Last chance to change anything about the 'requests' array
       after it has been built with requests for all of the entities-to-be-saved.
  
       The 'requests' array is the same as 'saveBundle.entities' in many implementations
  
       This method can do anything to the array including add and remove requests.
       It's up to you to ensure that server will accept the requests array data as valid.
  
       Returned value is ignored.
       @example
       this.done = function (requests) {
              // alter the array of requests representing the entire change-set
              // based on the saveContext and saveBundle
          };
       @method done
       @param requests {Array of Object} The adapter's array of request for this changeset.
       **/
      this.done = function (requests) {
      };
    }
docs: This is a default, no-op implementation that developers can replace.