docs: function (Vue) {
    var ref = Vue.util;
    var isPlainObject = ref.isPlainObject;
  
    function setError (
      result,
      field,
      validator,
      message,
      prop
    ) {
      var error = { field: field, validator: validator };
      if (message) {
        error.message = message;
      }
      if (prop) {
        error.prop = prop;
      }
      result.errors = result.errors || [];
      result.errors.push(error);
    }
  
    function walkProgresses (keys, target) {
      var progress = '';
      for (var i = 0; i < keys.length; i++) {
        var result = target[keys[i]];
        if (typeof result === 'string' && result) {
          progress = result;
          break
        }
        if (isPlainObject(result)) {
          var nestedKeys = Object.keys(result);
          progress = walkProgresses(nestedKeys, result);
          if (!progress) {
            break
          }
        }
      }
      return progress
    }
  
    function invalid () {
      return !this.valid
    }
  
    function pristine () {
      return !this.dirty
    }
  
    function untouched () {
      return !this.touched
    }
  
    function result () {
      var this$1 = this;
  
      var ret = {
        valid: this.valid,
        invalid: this.invalid,
        dirty: this.dirty,
        pristine: this.pristine,
        touched: this.touched,
        untouched: this.untouched,
        modified: this.modified
      };
  
      var keys = this._keysCached(this._uid.toString(), this.results);
      keys.forEach(function (validator) {
        var result = this$1.results[validator];
        if (typeof result === 'boolean') {
          if (result) {
            ret[validator] = false;
          } else {
            setError(ret, this$1.field, validator);
            ret[validator] = !result;
          }
        } else if (typeof result === 'string') {
          setError(ret, this$1.field, validator, result);
          ret[validator] = result;
        } else if (isPlainObject(result)) { // object
          var props = Object.keys(result);
          props.forEach(function (prop) {
            var propRet = result[prop];
            ret[prop] = ret[prop] || {};
            if (typeof propRet === 'boolean') {
              if (propRet) {
                ret[prop][validator] = false;
              } else {
                setError(ret, this$1.field, validator, undefined, prop);
                ret[prop][validator] = !propRet;
              }
            } else if (typeof propRet === 'string') {
              setError(ret, this$1.field, validator, propRet, prop);
              ret[prop][validator] = propRet;
            } else {
              ret[prop][validator] = false;
            }
          });
        } else {
          ret[validator] = false;
        }
      });
  
      return ret
    }
  
    function progress () {
      var ret = '';
      ret = walkProgresses(
        this._keysCached(this._uid.toString(), this.results),
        this.progresses
      );
      return ret
    }
  
    return {
      invalid: invalid,
      pristine: pristine,
      untouched: untouched,
      result: result,
      progress: progress
    }
  }