docs: function(value, options){
          // implicitly pass undefined
          var valType = typeof value;
          if(valType === 'undefined') return undefined;
          
          // make sure the default options object exists
          if(typeof this.options !== 'object') this.options = {};
          
          // build up a base config from the pre-defined defaults
          var config = {};
          config.types = validate.isArray(this.options.types) ? this.options.types : [];
          config.inverseMatch = this.options.inverseMatch ? true : false;
          config.message = validateParams.extractValidatorMessage(this, options);
          
          // interpret the passed value
          if(typeof options === 'string'){
              config.types.push(options);
          }else if(validate.isArray(options)){
              config.types = config.types.concat(options);
          }else if(validate.isObject(options)){
              if(validate.isArray(options.types)){
                  config.types = config.types.concat(options.types);
              }
              if(options.inverseMatch) config.inverseMatch = true;
              if(validate.isString(options.message)) config.message = options.message;
          }else{
              throw new Error('invalid options passed - must be a string, an array of strings, or a plain object');
          }
          
          // validate the passed types
          var typeList = [];
          config.types.forEach(function(t){
              if(validateParams.isTypeofString(t) && t !== 'undefined'){
                  typeList.push(t);
              }else{
                  validateParams._warn('ignoring invalid type: ' + String(t));
              }
          });
          if(typeList.length === 0){
              throw new Error('no valid types specified');
          }
          
          // do the actual validation
          var errors = [];
          if(config.inverseMatch){
              // do a reverse match
              typeList.forEach(function(t){
                  if(valType === t){
                      errors.push("can't have type '" + t + "'");
                  }
              });
          }else{
              // do a regular forward match
              var matched = false;
              typeList.forEach(function(t){
                  if(valType === t){
                      matched = true;
                  }
              });
              if(!matched){
                  errors.push("must have one of the following types: " + humanJoin(typeList) + "'");
              }
          }
          
          // return as appropriate
          if(errors.length > 0){
              return config.message ? config.message : errors;
          }
          return undefined;
      }