objectMembers herein are indirectly accessed and/or exposed through the RTV.js Public Interface.
objectProvides the externally-facing API. It wraps the implementation, adding a bit of syntactic sugar, and adds the configuration facilities.
object
object
* [.Enumeration](#rtvref.Enumeration)
* [new Enumeration(map, [name])](#new_rtvref.Enumeration_new)
* [.$name](#rtvref.Enumeration+$name) : string
* [.$values](#rtvref.Enumeration+$values) : Array.<String>
* [.check(value)](#rtvref.Enumeration+check) ⇒ \* \| undefined
* [.verify(value, [silent])](#rtvref.Enumeration+verify) ⇒ \*
* [.toString()](#rtvref.Enumeration+toString) ⇒ string
* [.RtvError](#rtvref.RtvError) ⇐ [JS\_Error](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error)
* [new RtvError(value, typeset, path, mismatch, [rootCause])](#new_rtvref.RtvError_new)
* [.valid](#rtvref.RtvError+valid) : boolean
* [.value](#rtvref.RtvError+value) : \*
* [.typeset](#rtvref.RtvError+typeset) : [typeset](#rtvref.types.typeset)
* [.path](#rtvref.RtvError+path) : Array.<string>
* [.mismatch](#rtvref.RtvError+mismatch) : [fully\_qualified\_typeset](#rtvref.types.fully_qualified_typeset)
* [.rootCause](#rtvref.RtvError+rootCause) : Error \| undefined
* [.toString()](#rtvref.RtvError+toString) ⇒ string
* [.RtvSuccess](#rtvref.RtvSuccess)
* [new RtvSuccess(params)](#new_rtvref.RtvSuccess_new)
* [.valid](#rtvref.RtvSuccess+valid) : boolean
* [.mvv](#rtvref.RtvSuccess+mvv) : \*
* [.toString()](#rtvref.RtvSuccess+toString) ⇒ string
* [.impl](#rtvref.impl) : object
* [.getQualifier(typeset)](#rtvref.impl.getQualifier) ⇒ string
* [.toTypeset(type, [qualifier], [args], [fullyQualified])](#rtvref.impl.toTypeset) ⇒ [typeset](#rtvref.types.typeset)
* [.fullyQualify(typeset, [qualifier])](#rtvref.impl.fullyQualify) ⇒ [fully\_qualified\_typeset](#rtvref.types.fully_qualified_typeset)
* [.extractNextType(typeset, [qualifier])](#rtvref.impl.extractNextType) ⇒ [typeset](#rtvref.types.typeset) \| Array
* [.checkWithType(value, singleType, [context])](#rtvref.impl.checkWithType) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.checkWithShape(value, shape, [context])](#rtvref.impl.checkWithShape) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.checkWithArray(value, arrayTs, [context])](#rtvref.impl.checkWithArray) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.check(value, typeset, [context])](#rtvref.impl.check) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.qualifiers](#rtvref.qualifiers) : object
* [.REQUIRED](#rtvref.qualifiers.REQUIRED)
* [.EXPECTED](#rtvref.qualifiers.EXPECTED)
* [.OPTIONAL](#rtvref.qualifiers.OPTIONAL)
* [.TRUTHY](#rtvref.qualifiers.TRUTHY)
* [.qualifiers](#rtvref.qualifiers.qualifiers) : [Enumeration](#rtvref.Enumeration)
* [.DEFAULT_QUALIFIER](#rtvref.qualifiers.DEFAULT_QUALIFIER) : string
* [.valuePermitted(v, [q])](#rtvref.qualifiers.valuePermitted) ⇒ boolean
* [.restricted_values](#rtvref.qualifiers.restricted_values) : void
* [.types](#rtvref.types) : object
* [.objTypes](#rtvref.types.objTypes) : [Enumeration](#rtvref.Enumeration)
* [.argTypes](#rtvref.types.argTypes) : [Enumeration](#rtvref.Enumeration)
* [.types](#rtvref.types.types) : [Enumeration](#rtvref.Enumeration)
* [.ANY](#rtvref.types.ANY) : string
* [.NULL](#rtvref.types.NULL) : string
* [.STRING](#rtvref.types.STRING) : string
* [.BOOLEAN](#rtvref.types.BOOLEAN) : string
* [.SYMBOL](#rtvref.types.SYMBOL) : string
* [.NUMBER](#rtvref.types.NUMBER) : string
* [.FINITE](#rtvref.types.FINITE) : string
* [.INT](#rtvref.types.INT) : string
* [.SAFE_INT](#rtvref.types.SAFE_INT) : string
* [.FLOAT](#rtvref.types.FLOAT) : string
* [.FUNCTION](#rtvref.types.FUNCTION) : string
* [.REGEXP](#rtvref.types.REGEXP) : string
* [.DATE](#rtvref.types.DATE) : string
* [.ERROR](#rtvref.types.ERROR) : string
* [.PROMISE](#rtvref.types.PROMISE) : string
* [.ARRAY](#rtvref.types.ARRAY) : string
* [.ANY_OBJECT](#rtvref.types.ANY_OBJECT) : string
* [.OBJECT](#rtvref.types.OBJECT) : string
* [.PLAIN_OBJECT](#rtvref.types.PLAIN_OBJECT) : string
* [.CLASS_OBJECT](#rtvref.types.CLASS_OBJECT) : string
* [.HASH_MAP](#rtvref.types.HASH_MAP) : string
* [.MAP](#rtvref.types.MAP) : string
* [.WEAK_MAP](#rtvref.types.WEAK_MAP) : string
* [.SET](#rtvref.types.SET) : string
* [.WEAK_SET](#rtvref.types.WEAK_SET) : string
* [.JSON](#rtvref.types.JSON) : string
* [.DEFAULT_OBJECT_TYPE](#rtvref.types.DEFAULT_OBJECT_TYPE) : string
* [.primitives](#rtvref.types.primitives) : void
* [.falsy_values](#rtvref.types.falsy_values) : void
* [.qualifier_rules](#rtvref.types.qualifier_rules) : void
* [.shape_descriptor](#rtvref.types.shape_descriptor) : Object
* [.type_arguments](#rtvref.types.type_arguments) : Object
* [.STRING_args](#rtvref.types.STRING_args) : Object
* [.SYMBOL_args](#rtvref.types.SYMBOL_args) : Object
* [.numeric_args](#rtvref.types.numeric_args) : Object
* [.shape_object_args](#rtvref.types.shape_object_args) : Object
* [.ARRAY_args](#rtvref.types.ARRAY_args) : Object
* [.collection_args](#rtvref.types.collection_args) : Object
* [.typeset](#rtvref.types.typeset) : Object \| string \| Array \| function
* [.fully_qualified_typeset](#rtvref.types.fully_qualified_typeset) : Array
* [.custom_validator](#rtvref.types.custom_validator) ⇒ \*
* [.util](#rtvref.util) : object
* [.print(printValue, printOptions)](#rtvref.util.print) ⇒ string
* [.hasOwnProp(obj, prop)](#rtvref.util.hasOwnProp) ⇒ boolean
* [.validation](#rtvref.validation) : object
* [.method(value)](#rtvref.validation.method) ⇒ boolean
* [.isAny](#rtvref.validation.isAny) : Module
* [.type](#rtvref.validation.isAny.type) : string
* [.check(v)](#rtvref.validation.isAny.check) ⇒ boolean
* [.isAnyObject](#rtvref.validation.isAnyObject) : Module
* [.type](#rtvref.validation.isAnyObject.type) : string
* [.check(v)](#rtvref.validation.isAnyObject.check) ⇒ boolean
* [.isArray](#rtvref.validation.isArray) : Module
* [.type](#rtvref.validation.isArray.type) : string
* [.check(v)](#rtvref.validation.isArray.check) ⇒ boolean
* [.isBoolean](#rtvref.validation.isBoolean) : Module
* [.type](#rtvref.validation.isBoolean.type) : string
* [.check(v)](#rtvref.validation.isBoolean.check) ⇒ boolean
* [.isClassObject](#rtvref.validation.isClassObject) : Module
* [.type](#rtvref.validation.isClassObject.type) : string
* [.check(v)](#rtvref.validation.isClassObject.check) ⇒ boolean
* [.isCustomValidator](#rtvref.validation.isCustomValidator) : Module
* [.type](#rtvref.validation.isCustomValidator.type) : string
* [.check(v)](#rtvref.validation.isCustomValidator.check) ⇒ boolean
* [.isDate](#rtvref.validation.isDate) : Module
* [.type](#rtvref.validation.isDate.type) : string
* [.check(v)](#rtvref.validation.isDate.check) ⇒ boolean
* [.isError](#rtvref.validation.isError) : Module
* [.type](#rtvref.validation.isError.type) : string
* [.check(v)](#rtvref.validation.isError.check) ⇒ boolean
* [.isFalsy](#rtvref.validation.isFalsy) : Module
* [.type](#rtvref.validation.isFalsy.type) : string
* [.check(v)](#rtvref.validation.isFalsy.check) ⇒ boolean
* [.isFinite](#rtvref.validation.isFinite) : Module
* [.type](#rtvref.validation.isFinite.type) : string
* [.check(v)](#rtvref.validation.isFinite.check) ⇒ boolean
* [.isFloat](#rtvref.validation.isFloat) : Module
* [.type](#rtvref.validation.isFloat.type) : string
* [.check(v)](#rtvref.validation.isFloat.check) ⇒ boolean
* [.isFunction](#rtvref.validation.isFunction) : Module
* [.type](#rtvref.validation.isFunction.type) : string
* [.check(v)](#rtvref.validation.isFunction.check) ⇒ boolean
* [.isHashMap](#rtvref.validation.isHashMap) : Module
* [.type](#rtvref.validation.isHashMap.type) : string
* [.check(v)](#rtvref.validation.isHashMap.check) ⇒ boolean
* [.isInt](#rtvref.validation.isInt) : Module
* [.type](#rtvref.validation.isInt.type) : string
* [.check(v)](#rtvref.validation.isInt.check) ⇒ boolean
* [.isJson](#rtvref.validation.isJson) : Module
* [.type](#rtvref.validation.isJson.type) : string
* [.check(v)](#rtvref.validation.isJson.check) ⇒ boolean
* [.isMap](#rtvref.validation.isMap) : Module
* [.type](#rtvref.validation.isMap.type) : string
* [.check(v)](#rtvref.validation.isMap.check) ⇒ boolean
* [.isNull](#rtvref.validation.isNull) : Module
* [.type](#rtvref.validation.isNull.type) : string
* [.check(v)](#rtvref.validation.isNull.check) ⇒ boolean
* [.isNumber](#rtvref.validation.isNumber) : Module
* [.type](#rtvref.validation.isNumber.type) : string
* [.check(v)](#rtvref.validation.isNumber.check) ⇒ boolean
* [.isObject](#rtvref.validation.isObject) : Module
* [.type](#rtvref.validation.isObject.type) : string
* [.check(v)](#rtvref.validation.isObject.check) ⇒ boolean
* [.isPlainObject](#rtvref.validation.isPlainObject) : Module
* [.type](#rtvref.validation.isPlainObject.type) : string
* [.check(v)](#rtvref.validation.isPlainObject.check) ⇒ boolean
* [.isPrimitive](#rtvref.validation.isPrimitive) : Module
* [.type](#rtvref.validation.isPrimitive.type) : string
* [.check(v)](#rtvref.validation.isPrimitive.check) ⇒ boolean
* [.isPromise](#rtvref.validation.isPromise) : Module
* [.type](#rtvref.validation.isPromise.type) : string
* [.check(v)](#rtvref.validation.isPromise.check) ⇒ boolean
* [.isRegExp](#rtvref.validation.isRegExp) : Module
* [.type](#rtvref.validation.isRegExp.type) : string
* [.check(v)](#rtvref.validation.isRegExp.check) ⇒ boolean
* [.isSafeInt](#rtvref.validation.isSafeInt) : Module
* [.type](#rtvref.validation.isSafeInt.type) : string
* [.check(v)](#rtvref.validation.isSafeInt.check) ⇒ boolean
* [.isSet](#rtvref.validation.isSet) : Module
* [.type](#rtvref.validation.isSet.type) : string
* [.check(v)](#rtvref.validation.isSet.check) ⇒ boolean
* [.isShape](#rtvref.validation.isShape) : Module
* [.type](#rtvref.validation.isShape.type) : string
* [.check(v)](#rtvref.validation.isShape.check) ⇒ boolean
* [.isString](#rtvref.validation.isString) : Module
* [.type](#rtvref.validation.isString.type) : string
* [.check(v, [options])](#rtvref.validation.isString.check) ⇒ boolean
* [.isSymbol](#rtvref.validation.isSymbol) : Module
* [.type](#rtvref.validation.isSymbol.type) : string
* [.check(v)](#rtvref.validation.isSymbol.check) ⇒ boolean
* [.isTypeArgs](#rtvref.validation.isTypeArgs) : Module
* [.type](#rtvref.validation.isTypeArgs.type) : string
* [.check(v)](#rtvref.validation.isTypeArgs.check) ⇒ boolean
* [.isTypeset](#rtvref.validation.isTypeset) : Module
* [.type](#rtvref.validation.isTypeset.type) : string
* [.check(v, [options])](#rtvref.validation.isTypeset.check) ⇒ boolean
* [.isWeakMap](#rtvref.validation.isWeakMap) : Module
* [.type](#rtvref.validation.isWeakMap.type) : string
* [.check(v)](#rtvref.validation.isWeakMap.check) ⇒ boolean
* [.isWeakSet](#rtvref.validation.isWeakSet) : Module
* [.type](#rtvref.validation.isWeakSet.type) : string
* [.check(v)](#rtvref.validation.isWeakSet.check) ⇒ boolean
* [.validator](#rtvref.validator) : object
* [.type_validator(value, qualifier, args, context)](#rtvref.validator.type_validator) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.validator_config(settings)](#rtvref.validator.validator_config)
* [.valAny](#rtvref.validator.valAny) : Module
* [.type](#rtvref.validator.valAny.type) : string
* [.config(settings)](#rtvref.validator.valAny.config)
* [.validate(v, [q])](#rtvref.validator.valAny.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valAnyObject](#rtvref.validator.valAnyObject) : Module
* [.type](#rtvref.validator.valAnyObject.type) : string
* [.config(settings)](#rtvref.validator.valAnyObject.config)
* [.validate(v, [q], [args], [context])](#rtvref.validator.valAnyObject.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valArray](#rtvref.validator.valArray) : Module
* [.type](#rtvref.validator.valArray.type) : string
* [.config(settings)](#rtvref.validator.valArray.config)
* [.validate(v, [q], [args], [context])](#rtvref.validator.valArray.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valBoolean](#rtvref.validator.valBoolean) : Module
* [.type](#rtvref.validator.valBoolean.type) : string
* [.config(settings)](#rtvref.validator.valBoolean.config)
* [.validate(v, [q])](#rtvref.validator.valBoolean.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valClassObject](#rtvref.validator.valClassObject) : Module
* [.type](#rtvref.validator.valClassObject.type) : string
* [.config(settings)](#rtvref.validator.valClassObject.config)
* [.validate(v, [q], [args], [context])](#rtvref.validator.valClassObject.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valDate](#rtvref.validator.valDate) : Module
* [.type](#rtvref.validator.valDate.type) : string
* [.config(settings)](#rtvref.validator.valDate.config)
* [.validate(v, [q])](#rtvref.validator.valDate.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valError](#rtvref.validator.valError) : Module
* [.type](#rtvref.validator.valError.type) : string
* [.config(settings)](#rtvref.validator.valError.config)
* [.validate(v, [q])](#rtvref.validator.valError.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valFinite](#rtvref.validator.valFinite) : Module
* [.type](#rtvref.validator.valFinite.type) : string
* [.config(settings)](#rtvref.validator.valFinite.config)
* [.validate(v, [q], [args])](#rtvref.validator.valFinite.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valFloat](#rtvref.validator.valFloat) : Module
* [.type](#rtvref.validator.valFloat.type) : string
* [.config(settings)](#rtvref.validator.valFloat.config)
* [.validate(v, [q], [args])](#rtvref.validator.valFloat.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valFunction](#rtvref.validator.valFunction) : Module
* [.type](#rtvref.validator.valFunction.type) : string
* [.config(settings)](#rtvref.validator.valFunction.config)
* [.validate(v, [q])](#rtvref.validator.valFunction.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valHashMap](#rtvref.validator.valHashMap) : Module
* [.type](#rtvref.validator.valHashMap.type) : string
* [.config(settings)](#rtvref.validator.valHashMap.config)
* [.validate(v, [q], [args], [context])](#rtvref.validator.valHashMap.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.type_validator_context_options](#rtvref.validator.type_validator_context_options) : Object
* [.type_validator_context](#rtvref.validator.type_validator_context) : Object
* [.validator_config_settings](#rtvref.validator.validator_config_settings) : Object
* [.valInt](#rtvref.validator.valInt) : Module
* [.type](#rtvref.validator.valInt.type) : string
* [.config(settings)](#rtvref.validator.valInt.config)
* [.validate(v, [q], [args])](#rtvref.validator.valInt.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valJson](#rtvref.validator.valJson) : Module
* [.type](#rtvref.validator.valJson.type) : string
* [.config(settings)](#rtvref.validator.valJson.config)
* [.validate(v, [q])](#rtvref.validator.valJson.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valMap](#rtvref.validator.valMap) : Module
* [.type](#rtvref.validator.valMap.type) : string
* [.config(settings)](#rtvref.validator.valMap.config)
* [.validate(v, [q], [args], [context])](#rtvref.validator.valMap.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valNull](#rtvref.validator.valNull) : Module
* [.type](#rtvref.validator.valNull.type) : string
* [.config(settings)](#rtvref.validator.valNull.config)
* [.validate(v, [q])](#rtvref.validator.valNull.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valNumber](#rtvref.validator.valNumber) : Module
* [.type](#rtvref.validator.valNumber.type) : string
* [.config(settings)](#rtvref.validator.valNumber.config)
* [.validate(v, [q], [args])](#rtvref.validator.valNumber.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valObject](#rtvref.validator.valObject) : Module
* [.type](#rtvref.validator.valObject.type) : string
* [.config(settings)](#rtvref.validator.valObject.config)
* [.validate(v, [q], [args], [context])](#rtvref.validator.valObject.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valPlainObject](#rtvref.validator.valPlainObject) : Module
* [.type](#rtvref.validator.valPlainObject.type) : string
* [.config(settings)](#rtvref.validator.valPlainObject.config)
* [.validate(v, [q], [args], [context])](#rtvref.validator.valPlainObject.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valPromise](#rtvref.validator.valPromise) : Module
* [.type](#rtvref.validator.valPromise.type) : string
* [.config(settings)](#rtvref.validator.valPromise.config)
* [.validate(v, [q])](#rtvref.validator.valPromise.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valRegExp](#rtvref.validator.valRegExp) : Module
* [.type](#rtvref.validator.valRegExp.type) : string
* [.config(settings)](#rtvref.validator.valRegExp.config)
* [.validate(v, [q])](#rtvref.validator.valRegExp.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valSafeInt](#rtvref.validator.valSafeInt) : Module
* [.type](#rtvref.validator.valSafeInt.type) : string
* [.config(settings)](#rtvref.validator.valSafeInt.config)
* [.validate(v, [q], [args])](#rtvref.validator.valSafeInt.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valSet](#rtvref.validator.valSet) : Module
* [.type](#rtvref.validator.valSet.type) : string
* [.config(settings)](#rtvref.validator.valSet.config)
* [.validate(v, [q], [args], [context])](#rtvref.validator.valSet.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valString](#rtvref.validator.valString) : Module
* [.type](#rtvref.validator.valString.type) : string
* [.config(settings)](#rtvref.validator.valString.config)
* [.validate(v, [q], [args])](#rtvref.validator.valString.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valSymbol](#rtvref.validator.valSymbol) : Module
* [.type](#rtvref.validator.valSymbol.type) : string
* [.config(settings)](#rtvref.validator.valSymbol.config)
* [.validate(v, [q], [args])](#rtvref.validator.valSymbol.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valWeakMap](#rtvref.validator.valWeakMap) : Module
* [.type](#rtvref.validator.valWeakMap.type) : string
* [.config(settings)](#rtvref.validator.valWeakMap.config)
* [.validate(v, [q])](#rtvref.validator.valWeakMap.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valWeakSet](#rtvref.validator.valWeakSet) : Module
* [.type](#rtvref.validator.valWeakSet.type) : string
* [.config(settings)](#rtvref.validator.valWeakSet.config)
* [.validate(v, [q])](#rtvref.validator.valWeakSet.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
## rtvref.Enumeration
**Kind**: static class of [rtvref](#rtvref)
* [.Enumeration](#rtvref.Enumeration)
* [new Enumeration(map, [name])](#new_rtvref.Enumeration_new)
* [.$name](#rtvref.Enumeration+$name) : string
* [.$values](#rtvref.Enumeration+$values) : Array.<String>
* [.check(value)](#rtvref.Enumeration+check) ⇒ \* \| undefined
* [.verify(value, [silent])](#rtvref.Enumeration+verify) ⇒ \*
* [.toString()](#rtvref.Enumeration+toString) ⇒ string
### new Enumeration(map, [name])
Simple enumeration type. Own-properties on an instance are the keys in the
specified `map`, with their associated values. Key names cannot start with
"$".
const state = new Enumeration({
READY: 1,
RUNNING: 2,
STOPPED: 3,
COMPLETE: 4
});
state.RUNNING; // 2
state.verify(3); // 3 (returns the value since found in enumeration)
state.verify(5); // ERROR thrown
state.check(3); // 3 (same as verify(3) since found in enumeration)
state.check(5); // undefined (silent failure)
state.$values; // [1, 2, 3, 4] (special non-enumerable own-property)
Error If `map` is falsy or empty.
- Error If `map` has a key that maps to `undefined`.
- Error If `map` contains a duplicate value.
- Error If `map` has a key that is a restricted property (starts with
"$").
| Param | Type | Description |
| --- | --- | --- |
| map | Object.<String, \*> | Object mapping keys to values. Values cannot be `undefined`. |
| [name] | string | Friendly name used to identify this enumeration, especially in validation error messages. |
### enumeration.$name : string
Friendly name (not necessarily unique among all enumeration instances)
used to identify this enumeration, especially in validation error
messages. Empty string if not specified during construction.
Note that this own-property is non-enumerable on purpose. Enumerable
properties on this instance are the keys in this enumeration.
**Kind**: instance property of [Enumeration](#rtvref.Enumeration)
**Read only**: true
### enumeration.$values : Array.<String>
List of enumeration values. Values are _references_ to values in this
enumeration.
Note that this own-property is non-enumerable on purpose. Enumerable
properties on this instance are the keys in this enumeration.
**Kind**: instance property of [Enumeration](#rtvref.Enumeration)
**Read only**: true
### enumeration.check(value) ⇒ \* \| undefined
Checks if a value is in this enumeration.
**Kind**: instance method of [Enumeration](#rtvref.Enumeration)
**Returns**: \* \| undefined - The specified value if it is in this enumeration, or `undefined`
if not. An exception is __not__ thrown if the value is not in this enumeration.
**See**: [verify](#rtvref.Enumeration+verify)
| Param | Type | Description |
| --- | --- | --- |
| value | \* | Value to check. Cannot be undefined. |
### enumeration.verify(value, [silent]) ⇒ \*
Validates a value as being in this enumeration. Throws an exception if the value
is not in this enumeration, unless `silent` is true.
**Kind**: instance method of [Enumeration](#rtvref.Enumeration)
**Returns**: \* - The specified value if it is in this enumeration, or `undefined` if
`silent` is true and the value is not in this enumeration.
**Throws**:
- Error If not `silent` and the value is not in this enumeration.
**See**: [check](#rtvref.Enumeration+check)
| Param | Type | Default | Description |
| --- | --- | --- | --- |
| value | \* | | Value to check. Cannot be undefined. |
| [silent] | boolean | false | If truthy, returns `undefined` instead of throwing an exception if the specified value is not in this enumeration. |
### enumeration.toString() ⇒ string
A string representation of this Enumeration.
**Kind**: instance method of [Enumeration](#rtvref.Enumeration)
**Returns**: string - String representation.
## rtvref.RtvError ⇐ [JS\_Error](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error)
**Kind**: static class of [rtvref](#rtvref)
**Extends**: [JS\_Error](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error)
* [.RtvError](#rtvref.RtvError) ⇐ [JS\_Error](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error)
* [new RtvError(value, typeset, path, mismatch, [rootCause])](#new_rtvref.RtvError_new)
* [.valid](#rtvref.RtvError+valid) : boolean
* [.value](#rtvref.RtvError+value) : \*
* [.typeset](#rtvref.RtvError+typeset) : [typeset](#rtvref.types.typeset)
* [.path](#rtvref.RtvError+path) : Array.<string>
* [.mismatch](#rtvref.RtvError+mismatch) : [fully\_qualified\_typeset](#rtvref.types.fully_qualified_typeset)
* [.rootCause](#rtvref.RtvError+rootCause) : Error \| undefined
* [.toString()](#rtvref.RtvError+toString) ⇒ string
### new RtvError(value, typeset, path, mismatch, [rootCause])
Runtime Verification Error Indicator
Describes a failed runtime verification of a value against a given
[shape](#rtvref.types.shape_descriptor) or [typeset](#rtvref.types.typeset)
(note that a shape is a type of typeset).
**Throws**:
- Error If `typeset`, `path`, or `mismatch` is invalid.
| Param | Type | Description |
| --- | --- | --- |
| value | \* | The value being verified. |
| typeset | [typeset](#rtvref.types.typeset) | The typeset used for verification. |
| path | Array.<string> | The path deep into `value` where the failure occurred. An empty array signifies the _root_ (top-level) value that was checked. |
| mismatch | [fully\_qualified\_typeset](#rtvref.types.fully_qualified_typeset) | The fully-qualified typeset that resulted in the failed validation. This is normally the fully-qualified version of `typeset`, but could be a subtype if `typeset` is an Array typeset or a [shape descriptor](#rtvref.types.shape_descriptor). |
| [rootCause] | [RtvError](#rtvref.RtvError) \| Error | [Custom Validator](#rtvref.types.custom_validator) error, if the `RtvError` is a result of a failed custom validation and the validator threw an exception; or some other nested error that was the root cause for the failed validation. |
### rtvError.valid : boolean
Flag indicating the validation failed. Always `false`.
**Kind**: instance property of [RtvError](#rtvref.RtvError)
**Read only**: true
**See**: [valid](#rtvref.RtvSuccess+valid)
### rtvError.value : \*
Value that failed verification against the
[typeset](#rtvref.RtvError+typeset).
**Kind**: instance property of [RtvError](#rtvref.RtvError)
**Read only**: true
### rtvError.typeset : [typeset](#rtvref.types.typeset)
Reference to the typeset used for verification.
**Kind**: instance property of [RtvError](#rtvref.RtvError)
**Read only**: true
### rtvError.path : Array.<string>
Path from [value](#rtvref.RtvError+value) to the nested property that
caused the failure.
Note that paths into collections such as [HASH_MAP](#rtvref.types.HASH_MAP)
or ES6 structures such as [MAP](#rtvref.types.MAP), where it's possible
to specify arguments to verify keys vs values, will have elements with special
prefixes to differentiate whether the path points to a key ("`key={key-name}`")
or a value ("`valueKey={key-name}`").
For example, given the has map `{hello: 'world'}`, if all keys were supposed to be
numerical, then the path for the validation error would be `["key=hello"]`, indicating
that the problem occurred with the __key__ named "hello", not the associated __value__.
If, however, keys could be anything, but values had to be numerical, then the path
would be `["valueKey=hello"]`, indicating that the problem occurred with the __value__
associated to the key rather than the key itself.
RtvError](#rtvref.RtvError)
**Read only**: true
### rtvError.mismatch : [fully\_qualified\_typeset](#rtvref.types.fully_qualified_typeset)
[Fully-qualified typeset](#rtvref.types.fully_qualified_typeset) that caused the
validation error (i.e. the mismatched subtype). This will be a subset/subtype of the
[typeset](#rtvref.RtvError+typeset), and possibly of a nested typeset within it,
expressing only the direct cause of the error.
For example, of `typeset` is `[[rtv.STRING]]` (a required array of required strings),
and `value` is `['a', 2]`, this property would be `[rtv.REQUIRED, rtv.STRING]`
because the validation error would ultimately have been caused by the nested
`rtv.STRING` typeset.
Remember that the fully-qualified `typeset` would be
`[rtv.REQUIRED, rtv.ARRAY, {$: [rtv.REQUIRED, rtv.STRING]}]`, which demonstrates
that `[rtv.REQUIRED, rtv.STRING]` is indeed a subset/subtype.
**Kind**: instance property of [RtvError](#rtvref.RtvError)
**Read only**: true
### rtvError.rootCause : Error \| undefined
Validation error thrown by a [Custom Validator](#rtvref.types.custom_validator),
which resulted in this `RtvError`. `undefined` if this error was not the result
of a failed custom validation. If the custom validator throws an error, this will
be a reference to the error it threw; otherwise, it'll be a generic `Error`
generated by the library.
**Kind**: instance property of [RtvError](#rtvref.RtvError)
**Read only**: true
### rtvError.toString() ⇒ string
A string representation of this instance.
**Kind**: instance method of [RtvError](#rtvref.RtvError)
**Returns**: string - String representation.
## rtvref.RtvSuccess
**Kind**: static class of [rtvref](#rtvref)
* [.RtvSuccess](#rtvref.RtvSuccess)
* [new RtvSuccess(params)](#new_rtvref.RtvSuccess_new)
* [.valid](#rtvref.RtvSuccess+valid) : boolean
* [.mvv](#rtvref.RtvSuccess+mvv) : \*
* [.toString()](#rtvref.RtvSuccess+toString) ⇒ string
### new RtvSuccess(params)
Runtime Verification Success Indicator
Describes a successful runtime verification of a value against a given
[shape](#rtvref.types.shape_descriptor) or [typeset](#rtvref.types.typeset)
(note that a shape is a type of typeset).
| Param | Type | Description |
| --- | --- | --- |
| params | Object | |
| params.mvv | \* | Minimum Viable Value representing the smallest version of the original value checked that satisfies the original Typeset against which it was checked. See the [mvv](#rtvref.RtvSuccess+mvv) property for more information. |
### rtvSuccess.valid : boolean
Flag indicating the validation succeeded. Always `true`.
**Kind**: instance property of [RtvSuccess](#rtvref.RtvSuccess)
**Read only**: true
**See**: [valid](#rtvref.RtvError+valid)
### rtvSuccess.mvv : \*
Minimum Viable Value (MVV). If the original value checked is one that can be deeply checked
(see list below of supported types), this is essentially a __representation__ (stressing
it is __not__ necessarily a clone) of the original value, __filtered__ by removing any
parts of it that were not specifically checked (i.e. extra properties in an object that
were not included in a shape, however deep it was nested, even in the key of a `Map`).
Otherwise, it's a reference to the original value.
Validating this value (instead of the original value) against the same Typeset would
yield the same successful result.
This property is most useful when checking a plain array or object (e.g. JSON API response)
against an expected shape when the shape you care about is much smaller than the payload
itself. Once the the check is complete, keep the minimum viable value instead of the larger
original payload to reduce the overall memory footprint of your code.
The following types are deeply checked and so will produce an MVV, but note the stated
exceptions to types that are not plain objects (`{}`) or arrays (`[]`):
- [ARRAY](#rtvref.types.ARRAY): Note that none of the
[ARRAY_args](#rtvref.types.ARRAY_args) except for the typeset (`$`) are used,
which means items won't be removed if the array is longer than a stated `length`
or `max` length.
- [PLAIN_OBJECT](#rtvref.types.PLAIN_OBJECT)
- [OBJECT](#rtvref.types.OBJECT): Interpreted as an object (`{}`).
- [CLASS_OBJECT](#rtvref.types.CLASS_OBJECT): Interpreted as an object (`{}`).
- [HASH_MAP](#rtvref.types.HASH_MAP): Interpreted as an object (`{}`).
- [ANY_OBJECT](#rtvref.types.ANY_OBJECT): Interpreted as an object (`{}`) because
it's essentially treated as one when it's being checked.
- [MAP](#rtvref.types.MAP): Interpreted as the native `Map` type.
- [SET](#rtvref.types.SET): Interpreted as the native `Set` type.
All other types will be referenced, not interpreted.
__NOTE:__ The MVV will based on the [Typeset](#rtvref.types.typeset) that validates
the original value. If you use an Array Typeset with multiple possibilities for an
object value to check (e.g. `[OBJECT, { $: { foo: NUMBER } }, OBJECT, { $: { bar: STRING } }]`),
the resulting MVV will use the matching sub-Typeset. Checking `{ foo: 1, bar: 'a' }` would
result in `{ foo: 1 }` as the MVV because `OBJECT, { $: { foo: NUMBER } }` is the first
sub-Typeset in the list, and so the first match.
**Kind**: instance property of [RtvSuccess](#rtvref.RtvSuccess)
**Read only**: true
### rtvSuccess.toString() ⇒ string
A string representation of this instance.
**Kind**: instance method of [RtvSuccess](#rtvref.RtvSuccess)
**Returns**: string - String representation.
## rtvref.impl : object
rtvref](#rtvref)
* [.impl](#rtvref.impl) : object
* [.getQualifier(typeset)](#rtvref.impl.getQualifier) ⇒ string
* [.toTypeset(type, [qualifier], [args], [fullyQualified])](#rtvref.impl.toTypeset) ⇒ [typeset](#rtvref.types.typeset)
* [.fullyQualify(typeset, [qualifier])](#rtvref.impl.fullyQualify) ⇒ [fully\_qualified\_typeset](#rtvref.types.fully_qualified_typeset)
* [.extractNextType(typeset, [qualifier])](#rtvref.impl.extractNextType) ⇒ [typeset](#rtvref.types.typeset) \| Array
* [.checkWithType(value, singleType, [context])](#rtvref.impl.checkWithType) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.checkWithShape(value, shape, [context])](#rtvref.impl.checkWithShape) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.checkWithArray(value, arrayTs, [context])](#rtvref.impl.checkWithArray) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.check(value, typeset, [context])](#rtvref.impl.check) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
### impl.getQualifier(typeset) ⇒ string
Get the qualifier given any kind of typeset.
The typeset's validity is __not__ checked. The function attempts to get a
qualifier, and defaults to the [default qualifier](qualifiers.DEFAULT_QUALIFIER)
if it cannot.
**Kind**: static method of [impl](#rtvref.impl)
**Returns**: string - The applicable [qualifier](#rtvref.qualifiers) for the
specified typeset, which is assumed to be valid.
| Param | Type | Description |
| --- | --- | --- |
| typeset | [typeset](#rtvref.types.typeset) | The typeset in question. |
### impl.toTypeset(type, [qualifier], [args], [fullyQualified]) ⇒ [typeset](#rtvref.types.typeset)
Convert a type, qualifier, and args into a typeset.
While the `qualifier`, `args`, and `fullyQualified` parameters are all
optional and may be omitted, their order must be maintained: If needed,
the `qualifier` must always be before `args`, and `args` before
`fullyQualified`. Parameters with `undefined` values will be ignored.
**Kind**: static method of [impl](#rtvref.impl)
**Returns**: [typeset](#rtvref.types.typeset) - The simplest typeset that represents the
combination of the specified type, qualifier, and args, unless `fullyQualified`
was set to `true`, in which case it'll always be an array typeset and
fully-qualified.
**Throws**:
- Error If `type`, `qualifier`, or `args` is invalid.
| Param | Type | Default | Description |
| --- | --- | --- | --- |
| type | string | | A single type from [types](#rtvref.types.types). |
| [qualifier] | string \| Object \| boolean | "rtvref.qualifiers.DEFAULT_QUALIFIER" | Optional qualifier from [qualifiers](#rtvref.qualifiers.qualifiers). Can also be either the `args` parameter, or the `fullyQualified` parameter if the default qualifier is being used. |
| [args] | Object \| boolean | | Optional [type arguments](#rtvref.types.type_arguments). If specified, this parameter must be an [object](#rtvref.types.OBJECT), however the properties of the object are not validated against the specified `type` (i.e. they are not guaranteed to be valid for that type). Can also be the `fullyQualified` parameter if type arguments aren't applicable. |
| [fullyQualified] | boolean | false | If _truthy_, the generated typeset will always be [fully-qualified](#rtvref.types.fully_qualified_typeset). Otherwise, it'll be the simplest typeset possible. |
### impl.fullyQualify(typeset, [qualifier]) ⇒ [fully\_qualified\_typeset](#rtvref.types.fully_qualified_typeset)
Fully-qualifies a typeset, shallow (i.e. the first level only; nested typesets
are not fully-qualified).
This function does not modify the input `typeset`.
**Kind**: static method of [impl](#rtvref.impl)
**Returns**: [fully\_qualified\_typeset](#rtvref.types.fully_qualified_typeset) - A new, fully-qualified typeset
representing the input `typeset`. Only the first/immediate level of the
input typeset is fully-qualified. The new array returned contains references
to elements within the input typeset.
**Throws**:
- Error If `typeset` or `qualifier` is not a valid.
| Param | Type | Description |
| --- | --- | --- |
| typeset | [typeset](#rtvref.types.typeset) | Typeset to fully-qualify. |
| [qualifier] | [qualifiers](#rtvref.qualifiers) | Optional qualifier to be used. If the typeset is a simple [type](#rtvref.types), a [shape](#rtvref.types.shape_descriptor), or a [custom validator](#rtvref.types.custom_validator) that was cherry-picked out of a typeset whose qualifier should be used instead of the [default](#rtvref.qualifiers.DEFAULT_QUALIFIER) one. If `typeset` is an Array typeset, specifying this parameter will __override__ the typeset's qualifier (otherwise, its own qualifier will be used). |
### impl.extractNextType(typeset, [qualifier]) ⇒ [typeset](#rtvref.types.typeset) \| Array
Extracts (modifies) the next complete type from an Array typeset.
For example, if the given `typeset` is `[EXPECTED, STRING, {string_args}, FINITE]`,
the returned array would be `[EXPECTED, STRING, {string_args}]` and `typeset`
would then be `[FINITE]`.
**Kind**: static method of [impl](#rtvref.impl)
**Returns**: [typeset](#rtvref.types.typeset) \| Array - The extracted __Array typeset__ as a
new Array, which is a sub-type of the given `typeset`. This sub-typeset is
not necessarily fully-qualified. If `typeset` was an empty array, an empty
array is returned (which is the only case where an invalid Array typeset
is tolerated, so that this function is easy to use in loops, checking for
the stopping condition where the returned sub-typeset is empty).
**Throws**:
- Error If `typeset` is not empty and not a valid Array typeset.
- Error If `qualifier` is specified but not valid.
| Param | Type | Description |
| --- | --- | --- |
| typeset | [typeset](#rtvref.types.typeset) \| Array | An Array typeset from which to extract the next complete type. __This Array will be modified.__ Can also be an empty array (which is not a valid typeset, but is tolerated; see the return value for more information). |
| [qualifier] | [qualifiers](#rtvref.qualifiers) \| boolean | Optional, and can either be a valid qualifier, `true`, or `false`. RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
Checks a value using a single type.
**Kind**: static method of [impl](#rtvref.impl)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - A success indicator if the
`value` is compliant to the type; an error indicator if not.
**Throws**:
- Error If `singleType` is not a valid simple type or single type.
- Error If the specified `context` is not valid.
**See**: [types](#rtvref.types)
| Param | Type | Description |
| --- | --- | --- |
| value | \* | Value to check. |
| singleType | string \| Array \| Object | Either a simple type name (one of [types](#rtvref.types.types)), a [shape descriptor](#rtvref.types.shape_descriptor), or an Array [typeset](#rtvref.types.typeset) which represents a single type. In the string/simple case, the [default qualifier](#rtvref.qualifiers.DEFAULT_QUALIFIER) is assumed. In the shape descriptor case, the [default object type](#rtvref.types.DEFAULT_OBJECT_TYPE) is assumed. In the Array case, the qualifier is optional, and a type, along with args, if any, is expected (e.g. `[type]`, `[qualifier, type]`, `[type, args]`, or `[qualifier, type, args]`). Note that the type may be implied if the shorthand notation is being used for an ARRAY, or if the [default object type](#rtvref.types.DEFAULT_OBJECT_TYPE) is being implied for a shape, e.g. `[{foo: rtv.STRING}]`. NOTE: A [custom validator](#rtvref.types.custom_validator) is not considered a valid single type. It's also considered a __separate type__ if it were passed-in via an Array, e.g. `[STRING, validator]`, which would violate the fact that `singleType` should be one type, and therefore cause an exception to be thrown. |
| [context] | [type\_validator\_context](#rtvref.validator.type_validator_context) \| undefined | Additional context for the check. If _falsy_, a new context will be created for all downstream checks using `value` as the original value, and `undefined` as the parent. |
### impl.checkWithShape(value, shape, [context]) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
Checks a value using a [shape descriptor](#rtvref.types.shape_descriptor) and
ensure the value's type is the default object type.
**Kind**: static method of [impl](#rtvref.impl)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - A success indicator if the
`value` is compliant to the shape; an error indicator if not.
**Throws**:
- Error If `shape` is not an [OBJECT](#rtvref.types.OBJECT).
- Error If the specified `context` is not valid.
| Param | Type | Description |
| --- | --- | --- |
| value | Object | Value to check. Must be of the [default](#rtvref.types.DEFAULT_OBJECT_TYPE) object type. |
| shape | Object | Expected shape of the `value`. Must be an [OBJECT](#rtvref.types.OBJECT). |
| [context] | [type\_validator\_context](#rtvref.validator.type_validator_context) \| undefined | Additional context for the check. If _falsy_, a new context will be created for all downstream checks using `value` as the original value, and an empty/root path. |
### impl.checkWithArray(value, arrayTs, [context]) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
Checks a value using an Array typeset.
**Kind**: static method of [impl](#rtvref.impl)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - Success indicator if the `value`
is compliant to the `typeset`; error indicator otherwise. An exception is
__not__ thrown if the `value` is non-compliant.
**Throws**:
- Error If `typeset` is not a valid Array typeset.
- Error If the specified `context` is not valid.
| Param | Type | Description |
| --- | --- | --- |
| value | \* | Value to check. |
| arrayTs | Array | The Array [typeset](#rtvref.types.typeset) to check against. |
| [context] | [type\_validator\_context](#rtvref.validator.type_validator_context) \| undefined | Additional context for the check. If _falsy_, a new context will be created for all downstream checks using `value` as the original value, and an empty/root path. |
### impl.check(value, typeset, [context]) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
Checks a value against a typeset.
**Kind**: static method of [impl](#rtvref.impl)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - Success indicator if the `value`
is compliant to the `typeset`; error indicator otherwise. An exception is
__not__ thrown if the `value` is non-compliant.
**Throws**:
- Error If `typeset` is not a valid typeset.
- Error If the specified `context` is not valid.
| Param | Type | Description |
| --- | --- | --- |
| value | \* | Value to check. |
| typeset | [typeset](#rtvref.types.typeset) | Expected shape/type of the value. |
| [context] | [type\_validator\_context](#rtvref.validator.type_validator_context) \| undefined | Additional context for the check. If _falsy_, a new context will be created for all downstream checks using `value` as the original value, and an empty/root path. |
## rtvref.qualifiers : object
rtvref](#rtvref)
* [.qualifiers](#rtvref.qualifiers) : object
* [.REQUIRED](#rtvref.qualifiers.REQUIRED)
* [.EXPECTED](#rtvref.qualifiers.EXPECTED)
* [.OPTIONAL](#rtvref.qualifiers.OPTIONAL)
* [.TRUTHY](#rtvref.qualifiers.TRUTHY)
* [.qualifiers](#rtvref.qualifiers.qualifiers) : [Enumeration](#rtvref.Enumeration)
* [.DEFAULT_QUALIFIER](#rtvref.qualifiers.DEFAULT_QUALIFIER) : string
* [.valuePermitted(v, [q])](#rtvref.qualifiers.valuePermitted) ⇒ boolean
* [.restricted_values](#rtvref.qualifiers.restricted_values) : void
### qualifiers.REQUIRED
Required qualifier: The value __must__ be of the expected type. Depending on
the type, additional requirements may be enforced.
Unless otherwise stated in type-specific rules, this qualifier does not
permit the value to be `null` or `undefined`.
Note the fact the value cannot be `undefined` implicitly requires a
[shape](#rtvref.types.shape_descriptor)'s property to be defined _somewhere_
its prototype chain (if it weren't, then its value would be `undefined`,
violating the requirements). For example, the shape `{name: [EXPECTED, STRING]}`
would require the `name` property to exist and not be `undefined`, but would
permit it to be `null` or even an empty string.
See specific type for additional rules.
**Kind**: static property of [qualifiers](#rtvref.qualifiers)
**See**
- [types](#rtvref.types)
- [STRING](#rtvref.types.STRING)
### qualifiers.EXPECTED
Expected qualifier: The value _should_ be of the expected type. Depending on
the type, additional requirements may be enforced.
Unless otherwise stated in type-specific rules, this qualifier does _not_ permit
the value to be `undefined`, but does _permit_ it to be `null`.
Note the fact the value cannot be `undefined` implicitly requires a
[shape](#rtvref.types.shape_descriptor)'s property to be defined _somewhere_
its prototype chain (if it weren't, then its value would be `undefined`,
violating the requirements). For example, the shape `{name: [EXPECTED, STRING]}`
would require the `name` property to exist and not be `undefined`, but would
permit it to be `null` or even an empty string.
See specific type for additional rules.
**Kind**: static property of [qualifiers](#rtvref.qualifiers)
**See**
- [types](#rtvref.types)
- [STRING](#rtvref.types.STRING)
### qualifiers.OPTIONAL
Optional qualifier: The value _may_ be of the expected type. Depending on
the type, additional requirements may be enforced.
Unless otherwise stated in type-specific rules, this qualifier _permits_ a
the value to be `null` as well as `undefined`.
Note the fact the value can be `undefined` implies it does _not_ require a
[shape](#rtvref.types.shape_descriptor)'s property to be defined anywhere in
its prototype chain.
See specific type for additional rules.
**Kind**: static property of [qualifiers](#rtvref.qualifiers)
**See**: [types](#rtvref.types)
### qualifiers.TRUTHY
Truthy qualifier: If the value is _truthy_, it must be of the expected type.
Depending on the type, additional requirements may be enforced.
Think of this qualifier as, "if _truthy_, the value is
[required](#rtvref.qualifiers.REQUIRED) to be of the specified type."
Unless otherwise stated in type-specific rules, this qualifier does _permit_
the value to be any [falsy value](#rtvref.types.falsy_values).
Note the fact the value can be `undefined` implies it does _not_ require a
[shape](#rtvref.types.shape_descriptor)'s property to be defined anywhere in
its prototype chain.
See specific type for additional rules.
**Kind**: static property of [qualifiers](#rtvref.qualifiers)
**See**: [types](#rtvref.types)
### qualifiers.qualifiers : [Enumeration](#rtvref.Enumeration)
Enumeration (`string -> string`) of all qualifiers:
- [REQUIRED](#rtvref.qualifiers.REQUIRED)
- [EXPECTED](#rtvref.qualifiers.EXPECTED)
- [OPTIONAL](#rtvref.qualifiers.OPTIONAL)
- [TRUTHY](#rtvref.qualifiers.TRUTHY)
**Kind**: static property of [qualifiers](#rtvref.qualifiers)
### qualifiers.DEFAULT\_QUALIFIER : string
Default qualifier: [REQUIRED](#rtvref.qualifiers.REQUIRED)
**Kind**: static constant of [qualifiers](#rtvref.qualifiers)
### qualifiers.valuePermitted(v, [q]) ⇒ boolean
Convenience function to check if a value is permitted under basic qualifier rules:
- REQUIRED: Cannot be any [falsy value](#rtvref.types.falsy_values), including
`undefined` and `null`.
- EXPECTED: Can be `null`.
- OPTIONAL: Can be either `undefined` or `null`.
- TRUTHY: Can be any [falsy value](#rtvref.types.falsy_values).
**Kind**: static method of [qualifiers](#rtvref.qualifiers)
**Returns**: boolean - `true` if the value is _falsy_ and the specific value
is permitted by the basic qualifier's rules; `false` otherwise.
For example,
- `valuePermitted(null, REQUIRED) === false`
- `valuePermitted(null, EXPECTED) === true`
- `valuePermitted(1, *) === false` because the value `1` is not any of the
permitted _falsy_ values for any qualifier
- `valuePermitted(false, OPTIONAL) === false` because the value `false` is
not permitted by OPTIONAL
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to check. |
| [q] | string | Validation qualifier. Defaults to [REQUIRED](#rtvref.qualifiers.REQUIRED). |
### qualifiers.restricted\_values : void
qualifiers](#rtvref.qualifiers)
**See**: [valuePermitted](#rtvref.qualifiers.valuePermitted)
## rtvref.types : object
rtvref](#rtvref)
* [.types](#rtvref.types) : object
* [.objTypes](#rtvref.types.objTypes) : [Enumeration](#rtvref.Enumeration)
* [.argTypes](#rtvref.types.argTypes) : [Enumeration](#rtvref.Enumeration)
* [.types](#rtvref.types.types) : [Enumeration](#rtvref.Enumeration)
* [.ANY](#rtvref.types.ANY) : string
* [.NULL](#rtvref.types.NULL) : string
* [.STRING](#rtvref.types.STRING) : string
* [.BOOLEAN](#rtvref.types.BOOLEAN) : string
* [.SYMBOL](#rtvref.types.SYMBOL) : string
* [.NUMBER](#rtvref.types.NUMBER) : string
* [.FINITE](#rtvref.types.FINITE) : string
* [.INT](#rtvref.types.INT) : string
* [.SAFE_INT](#rtvref.types.SAFE_INT) : string
* [.FLOAT](#rtvref.types.FLOAT) : string
* [.FUNCTION](#rtvref.types.FUNCTION) : string
* [.REGEXP](#rtvref.types.REGEXP) : string
* [.DATE](#rtvref.types.DATE) : string
* [.ERROR](#rtvref.types.ERROR) : string
* [.PROMISE](#rtvref.types.PROMISE) : string
* [.ARRAY](#rtvref.types.ARRAY) : string
* [.ANY_OBJECT](#rtvref.types.ANY_OBJECT) : string
* [.OBJECT](#rtvref.types.OBJECT) : string
* [.PLAIN_OBJECT](#rtvref.types.PLAIN_OBJECT) : string
* [.CLASS_OBJECT](#rtvref.types.CLASS_OBJECT) : string
* [.HASH_MAP](#rtvref.types.HASH_MAP) : string
* [.MAP](#rtvref.types.MAP) : string
* [.WEAK_MAP](#rtvref.types.WEAK_MAP) : string
* [.SET](#rtvref.types.SET) : string
* [.WEAK_SET](#rtvref.types.WEAK_SET) : string
* [.JSON](#rtvref.types.JSON) : string
* [.DEFAULT_OBJECT_TYPE](#rtvref.types.DEFAULT_OBJECT_TYPE) : string
* [.primitives](#rtvref.types.primitives) : void
* [.falsy_values](#rtvref.types.falsy_values) : void
* [.qualifier_rules](#rtvref.types.qualifier_rules) : void
* [.shape_descriptor](#rtvref.types.shape_descriptor) : Object
* [.type_arguments](#rtvref.types.type_arguments) : Object
* [.STRING_args](#rtvref.types.STRING_args) : Object
* [.SYMBOL_args](#rtvref.types.SYMBOL_args) : Object
* [.numeric_args](#rtvref.types.numeric_args) : Object
* [.shape_object_args](#rtvref.types.shape_object_args) : Object
* [.ARRAY_args](#rtvref.types.ARRAY_args) : Object
* [.collection_args](#rtvref.types.collection_args) : Object
* [.typeset](#rtvref.types.typeset) : Object \| string \| Array \| function
* [.fully_qualified_typeset](#rtvref.types.fully_qualified_typeset) : Array
* [.custom_validator](#rtvref.types.custom_validator) ⇒ \*
### types.objTypes : [Enumeration](#rtvref.Enumeration)
Enumeration (`string -> string`) of __object__ types:
- [ANY_OBJECT](#rtvref.types.ANY_OBJECT)
- [OBJECT](#rtvref.types.OBJECT)
- [PLAIN_OBJECT](#rtvref.types.PLAIN_OBJECT)
- [CLASS_OBJECT](#rtvref.types.CLASS_OBJECT)
**Kind**: static property of [types](#rtvref.types)
### types.argTypes : [Enumeration](#rtvref.Enumeration)
Enumeration (`string -> string`) of types that accept arguments:
- [STRING](#rtvref.types.STRING)
- [SYMBOL](#rtvref.types.SYMBOL)
- [NUMBER](#rtvref.types.NUMBER)
- [FINITE](#rtvref.types.FINITE)
- [INT](#rtvref.types.INT)
- [SAFE_INT](#rtvref.types.SAFE_INT)
- [FLOAT](#rtvref.types.FLOAT)
- [ARRAY](#rtvref.types.ARRAY)
- [ANY_OBJECT](#rtvref.types.ANY_OBJECT)
- [OBJECT](#rtvref.types.OBJECT)
- [PLAIN_OBJECT](#rtvref.types.PLAIN_OBJECT)
- [CLASS_OBJECT](#rtvref.types.CLASS_OBJECT)
- [HASH_MAP](#rtvref.types.HASH_MAP)
- [MAP](#rtvref.types.MAP)
- [SET](#rtvref.types.SET)
**Kind**: static property of [types](#rtvref.types)
### types.types : [Enumeration](#rtvref.Enumeration)
Enumeration (`string -> string`) of all types:
- [ANY](#rtvref.types.ANY)
- [NULL](#rtvref.types.NULL)
- [STRING](#rtvref.types.STRING)
- [BOOLEAN](#rtvref.types.BOOLEAN)
- [SYMBOL](#rtvref.types.SYMBOL)
- [NUMBER](#rtvref.types.NUMBER)
- [FINITE](#rtvref.types.FINITE)
- [INT](#rtvref.types.INT)
- [SAFE_INT](#rtvref.types.SAFE_INT)
- [FLOAT](#rtvref.types.FLOAT)
- [FUNCTION](#rtvref.types.FUNCTION)
- [REGEXP](#rtvref.types.REGEXP)
- [DATE](#rtvref.types.DATE)
- [ERROR](#rtvref.types.ERROR)
- [PROMISE](#rtvref.types.PROMISE)
- [ARRAY](#rtvref.types.ARRAY)
- [ANY_OBJECT](#rtvref.types.ANY_OBJECT)
- [OBJECT](#rtvref.types.OBJECT)
- [PLAIN_OBJECT](#rtvref.types.PLAIN_OBJECT)
- [CLASS_OBJECT](#rtvref.types.CLASS_OBJECT)
- [HASH_MAP](#rtvref.types.HASH_MAP)
- [MAP](#rtvref.types.MAP)
- [WEAK_MAP](#rtvref.types.WEAK_MAP)
- [SET](#rtvref.types.SET)
- [WEAK_SET](#rtvref.types.WEAK_SET)
- [JSON](#rtvref.types.JSON)
**Kind**: static property of [types](#rtvref.types)
### types.ANY : string
The any type is special in that it allows _anything_, which includes `null`
and `undefined` values. Because of this, it's the most liberal in terms of
types as well as in its interaction with qualifiers. A more specific type
should be used whenever possible to ensure a higher degree of confidence
in the value being validated.
Any rules per qualifiers:
- REQUIRED: Can be any value, including `null` and `undefined`.
- EXPECTED: Same rules as REQUIRED.
- OPTIONAL: Same rules as EXPECTED.
- TRUTHY: Same rules as OPTIONAL.
Since this type removes the property's need for existence in the prototype
chain, it renders the verification moot (i.e. the property of this type might
as well not be included in a [shape descriptor](#rtvref.types.shape_descriptor)
unless a [custom validator](#rtvref.types.custom_validator) is being
used to do customized verification.
**Kind**: static constant of [types](#rtvref.types)
**See**: [qualifiers](#rtvref.qualifiers)
### types.NULL : string
Null rules per qualifiers: Must be the `null` [primitive](#rtvref.types.primitives).
Use this special type to explicitly test for a `null` value. For example,
a [shape](#rtvref.types.shape_descriptor)'s property may be required to be
`null` under certain circumstances.
**Kind**: static constant of [types](#rtvref.types)
**See**: [qualifiers](#rtvref.qualifiers)
### types.STRING : string
String rules per qualifiers:
- REQUIRED: Must be a non-empty string, unless an argument allows it.
- EXPECTED | OPTIONAL: May be an empty string, unless an argument disallows it.
Note that the value `null` (for EXPECTED and OPTIONAL) or `undefined` (for OPTIONAL)
will not be subject to any restrictions imposed by arguments (i.e. the arguments will be
ignored; for example, `rtv.verify(null, [EXPECTED, STRING, {min: 1}])` would
_pass_ verification because `null` is permitted with EXPECTED).
- TRUTHY: May be an empty string _regardless_ of arguments, since an empty
string is _falsy_, and this qualifier permits all _falsy_ values. Therefore,
`rtv.verify("", [TRUTHY, STRING, {min: 1}])` would still _pass_ verification
because an empty string is permitted with TRUTHY.
In all cases, the value must be a string [primitive](#rtvref.types.primitives).
Note that `new String('hello') !== 'hello'` because the former is an _object_, not a string.
Arguments (optional): [STRING_args](#rtvref.types.STRING_args)
**Kind**: static constant of [types](#rtvref.types)
**See**: [qualifiers](#rtvref.qualifiers)
### types.BOOLEAN : string
Boolean rules per qualifiers: Must be a boolean [primitive](#rtvref.types.primitives).
Note that `new Boolean(true) !== true` because the former is an _object_, not a boolean.
**Kind**: static constant of [types](#rtvref.types)
**See**: [qualifiers](#rtvref.qualifiers)
### types.SYMBOL : string
Symbol rules per qualifiers: Must be a symbol [primitive](#rtvref.types.primitives).
Arguments (optional): [SYMBOL_args](#rtvref.types.SYMBOL_args).
**Kind**: static constant of [types](#rtvref.types)
**See**: [qualifiers](#rtvref.qualifiers)
### types.NUMBER : string
Number rules per qualifiers:
- REQUIRED: Cannot be `NaN`, but could be `+Infinity`, `-Infinity`.
- EXPECTED | OPTIONAL: Could be `NaN`, `+Infinity`, `-Infinity`.
- TRUTHY: Could be `NaN` (since that is a [falsy value](#rtvref.types.falsy_values)),
`+Infinity`, `-Infinity`.
In all cases, the value must be a number [primitive](#rtvref.types.primitives).
Note that `new Number(1) !== 1` because the former is an _object_, not a number.
An number is not guaranteed to be a
[safe integer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger).
Arguments (optional): [numeric_args](#rtvref.types.numeric_args)
**Kind**: static constant of [types](#rtvref.types)
**See**
- [qualifiers](#rtvref.qualifiers)
- [FINITE](#rtvref.types.FINITE)
- [INT](#rtvref.types.INT)
- [SAFE_INT](#rtvref.types.SAFE_INT)
- [FLOAT](#rtvref.types.FLOAT)
### types.FINITE : string
Finite rules per qualifiers: Cannot be `NaN` (unless the qualifier is TRUTHY),
`+Infinity`, `-Infinity`. The value can be either an [integer](#rtvref.types.INT),
or a [floating point number](#rtvref.types.FLOAT). It must also be a
number [primitive](#rtvref.types.primitives).
A finite number is not guaranteed to be a
[safe integer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger).
Arguments (optional): [numeric_args](#rtvref.types.numeric_args)
**Kind**: static constant of [types](#rtvref.types)
**See**
- [qualifiers](#rtvref.qualifiers)
- [NUMBER](#rtvref.types.NUMBER)
- [INT](#rtvref.types.INT)
- [SAFE_INT](#rtvref.types.SAFE_INT)
- [FLOAT](#rtvref.types.FLOAT)
### types.INT : string
Int rules per qualifiers: Must be a [finite](#rtvref.types.FINITE) number,
an integer, and a number [primitive](#rtvref.types.primitives). `NaN`,
however, is permitted if the qualifier is TRUTHY.
An integer is not guaranteed to be a
[safe integer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger).
Arguments (optional): [numeric_args](#rtvref.types.numeric_args)
**Kind**: static constant of [types](#rtvref.types)
**See**
- [qualifiers](#rtvref.qualifiers)
- [NUMBER](#rtvref.types.NUMBER)
- [FINITE](#rtvref.types.FINITE)
- [SAFE_INT](#rtvref.types.SAFE_INT)
- [FLOAT](#rtvref.types.FLOAT)
### types.SAFE\_INT : string
Int rules per qualifiers: Must be a [finite](#rtvref.types.FINITE) number, a
[safe integer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger),
and a number [primitive](#rtvref.types.primitives). `NaN`, however, is
permitted if the qualifier is TRUTHY.
An integer is safe if it's an IEEE-754 double precision number which isn't
the result of a rounded unsafe integer. For example, `2^53 - 1` is safe,
but `2^53` is not because `2^53 + 1` would be rounded to `2^53`.
Arguments (optional): [numeric_args](#rtvref.types.numeric_args)
**Kind**: static constant of [types](#rtvref.types)
**See**
- [qualifiers](#rtvref.qualifiers)
- [NUMBER](#rtvref.types.NUMBER)
- [FINITE](#rtvref.types.FINITE)
- [INT](#rtvref.types.INT)
- [FLOAT](#rtvref.types.FLOAT)
### types.FLOAT : string
Float rules per qualifiers: Must be a [finite](#rtvref.types.FINITE)
floating point number, and a number [primitive](#rtvref.types.primitives).
Per IEEE 754, zero (`0`) is considered a float. Note that `NaN` is permitted
if the qualifier is TRUTHY.
Arguments (optional): [numeric_args](#rtvref.types.numeric_args)
**Kind**: static constant of [types](#rtvref.types)
**See**
- [qualifiers](#rtvref.qualifiers)
- [NUMBER](#rtvref.types.NUMBER)
- [FINITE](#rtvref.types.FINITE)
- [INT](#rtvref.types.INT)
- [SAFE_INT](#rtvref.types.SAFE_INT)
### types.FUNCTION : string
Function rules per qualifiers: Must be a `function`.
**Kind**: static constant of [types](#rtvref.types)
**See**: [qualifiers](#rtvref.qualifiers)
### types.REGEXP : string
RegExp rules per qualifiers: Must be a `RegExp` instance.
**Kind**: static constant of [types](#rtvref.types)
**See**
- [qualifiers](#rtvref.qualifiers)
- https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp
### types.DATE : string
Date rules per qualifiers: Must be a `Date` instance.
**Kind**: static constant of [types](#rtvref.types)
**See**
- [qualifiers](#rtvref.qualifiers)
- https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date
### types.ERROR : string
Error rules per qualifiers: Must be an `Error` instance, which includes `TypeError`,
`RangeError`, `ReferenceError`, etc.
**Kind**: static constant of [types](#rtvref.types)
**See**
- [qualifiers](#rtvref.qualifiers)
- https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error
### types.PROMISE : string
Promise rules per qualifiers: Must be a `Promise` instance.
**Kind**: static constant of [types](#rtvref.types)
**See**
- [qualifiers](#rtvref.qualifiers)
- https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise
### types.ARRAY : string
Array rules per qualifiers: Must be an `Array`. Empty arrays are permitted,
unless arguments prevent them.
Arguments (optional): [ARRAY_args](#rtvref.types.ARRAY_args). Note that the `ARRAY`
type must be specified when using arguments (i.e. the shorthand notation cannot
be used).
When describing arrays, either _shorthand_ or _full_ notation may be used.
In the shorthand notation, the `ARRAY` type isn't necessary, but it's only
possible to specify the Array typeset to use to validate each array element,
and [arguments](#rtvref.types.ARRAY_args) can't be specified. In the
[fully-qualified](#rtvref.types.fully_qualified_typeset) notation, the
`ARRAY` type is required, but the Array typeset must be moved into the
`typeset` argument (along with any other argument necessary).
__NOTE__: It's important to realize that arrays (as in the JavaScript Array
type) are essentially nested [Array typesets](#rtvref.types.typeset).
They represent a set of types that will be used to validate each element
of an array using a short-circuit OR conjunction, looking for the first type that matches.
{
value: [ARRAY]
}
{
value: [[FINITE]]
}
{
value: [BOOLEAN, [FINITE, STRING]]
}
{
value: [REQUIRED, ARRAY, {min: 1}]
}
{
value: [REQUIRED, ARRAY, {$: [FINITE]}]
}
{
value: [REQUIRED, BOOLEAN, ARRAY, {$: [FINITE, STRING]}]
}
types](#rtvref.types)
**See**: [qualifiers](#rtvref.qualifiers)
### types.ANY\_OBJECT : string
An _any_ object is anything that is __not__ a [primitive](#rtvref.types), which
means it includes the `Array` type, as well as functions and arguments, and
other JavaScript _object_ types. To test for an array, use the
[ARRAY](#rtvref.types.ARRAY) type. To test for a function, use the
[FUNCTION](#rtvref.types.FUNCTION) type.
The following values __are considered__ any objects:
- `{}`
- `new Object()`
- `new (function() {}) | new (class {})()` (class instance) (also see
[CLASS_OBJECT](#rtvref.types.CLASS_OBJECT))
- `new String('')`
- `new Boolean(true)`
- `new Number(1)`
- `[]` (also see [ARRAY](#rtvref.types.ARRAY))
- `new Array()` (also see [ARRAY](#rtvref.types.ARRAY))
- `/re/` (also see [REGEXP](#rtvref.types.REGEXP))
- `new RegExp('re')` (also see [REGEXP](#rtvref.types.REGEXP))
- `new Date()` (also see [DATE](#rtvref.types.DATE))
- `new Error()` (also see [ERROR](#rtvref.types.ERROR))
- `new Promise()` (also see [PROMISE](#rtvref.types.PROMISE))
- `function(){}` (also see [FUNCTION](#rtvref.types.FUNCTION))
- `arguments` (function arguments)
- `new Map()` (also see [MAP](#rtvref.types.MAP))
- `new WeakMap()` (also see [WEAK_MAP](#rtvref.types.WEAK_MAP))
- `new Set()` (also see [SET](#rtvref.types.SET))
- `new WeakSet()` (also see [WEAK_SET](#rtvref.types.WEAK_SET))
[Primitive](#rtvref.types.primitives) values __are not__ considered any objects,
especially when the qualifier is [REQUIRED](#rtvref.qualifiers.REQUIRED).
Note that `typeof null === 'object'` in JavaScript; the `ANY_OBJECT` type
allows testing for this undesirable fact.
Any object rules per qualifiers:
- REQUIRED: Per the lists above.
- EXPECTED: `null` is allowed.
- OPTIONAL: `undefined` is allowed.
Arguments (optional): [shape_object_args](#rtvref.types.shape_object_args)
**Kind**: static constant of [types](#rtvref.types)
**See**
- [qualifiers](#rtvref.qualifiers)
- [OBJECT](#rtvref.types.OBJECT)
- [PLAIN_OBJECT](#rtvref.types.PLAIN_OBJECT)
- [CLASS_OBJECT](#rtvref.types.CLASS_OBJECT)
### types.OBJECT : string
An object is one that extends from `JavaScript.Object` (i.e. an _instance_
of _something_ that extends from Object) and is not a
[function](#rtvref.types.FUNCTION), [array](#rtvref.types.ARRAY),
[regular expression](#rtvref.types.REGEXP), [DATE](#rtvref.types.DATE),
function arguments object,
[map](#rtvref.types.MAP), [weak map](#rtvref.types.WEAK_MAP),
[set](#rtvref.types.SET), [weak set](#rtvref.types.WEAK_SET), nor a
[primitive](#rtvref.types).
This is the __default__ (imputed) type for
[shape descriptors](#rtvref.types.shape_descriptor), which means the object itself
(the value being tested), prior to being checked against its shape, will be
tested according to this type.
The following values are considered objects:
- `{}`
- `new Object()`
- `new (function() {}) | new (class {})()` (class instance) (also see
[CLASS_OBJECT](#rtvref.types.CLASS_OBJECT))
The following values __are not__ considered objects:
- `new String('')`
- `new Boolean(true)`
- `new Number(1)`
- `[]` (also see [ARRAY](#rtvref.types.ARRAY))
- `new Array()` (also see [ARRAY](#rtvref.types.ARRAY))
- `/re/` (also see [REGEXP](#rtvref.types.REGEXP))
- `new RegExp('re')` (also see [REGEXP](#rtvref.types.REGEXP))
- `new Date()` (also see [DATE](#rtvref.types.DATE))
- `new Error()` (also see [ERROR](#rtvref.types.ERROR))
- `new Promise()` (also see [PROMISE](#rtvref.types.PROMISE))
- `function(){}` (also see [FUNCTION](#rtvref.types.FUNCTION))
- `arguments` (function arguments)
- `new Map()` (also see [MAP](#rtvref.types.MAP))
- `new WeakMap()` (also see [WEAK_MAP](#rtvref.types.WEAK_MAP))
- `new Set()` (also see [SET](#rtvref.types.SET))
- `new WeakSet()` (also see [WEAK_SET](#rtvref.types.WEAK_SET))
- all [primitives](#rtvref.types.primitives)
Object rules per qualifiers:
- REQUIRED: Per the lists above.
- EXPECTED: `null` is allowed.
- OPTIONAL: `undefined` is allowed.
Arguments (optional): [shape_object_args](#rtvref.types.shape_object_args)
**Kind**: static constant of [types](#rtvref.types)
**See**
- [qualifiers](#rtvref.qualifiers)
- [ANY_OBJECT](#rtvref.types.ANY_OBJECT)
- [PLAIN_OBJECT](#rtvref.types.PLAIN_OBJECT)
- [CLASS_OBJECT](#rtvref.types.CLASS_OBJECT)
### types.PLAIN\_OBJECT : string
A _plain_ object is one that is created directly from the `Object` constructor,
whether using `new Object()` or the literal `{}`.
The following values are considered plain objects:
- `{}`
- `new Object()`
The following values __are not__ considered plain objects:
- `new (function() {}) | new (class {})()` (class instance) (also see
[CLASS_OBJECT](#rtvref.types.CLASS_OBJECT))
- `new String('')`
- `new Boolean(true)`
- `new Number(1)`
- `[]` (also see [ARRAY](#rtvref.types.ARRAY))
- `new Array()` (also see [ARRAY](#rtvref.types.ARRAY))
- `/re/` (also see [REGEXP](#rtvref.types.REGEXP))
- `new RegExp('re')` (also see [REGEXP](#rtvref.types.REGEXP))
- `new Date()` (also see [DATE](#rtvref.types.DATE))
- `new Error()` (also see [ERROR](#rtvref.types.ERROR))
- `new Promise()` (also see [PROMISE](#rtvref.types.PROMISE))
- `function(){}` (also see [FUNCTION](#rtvref.types.FUNCTION))
- `arguments` (function arguments)
- `new Map()` (also see [MAP](#rtvref.types.MAP))
- `new WeakMap()` (also see [WEAK_MAP](#rtvref.types.WEAK_MAP))
- `new Set()` (also see [SET](#rtvref.types.SET))
- `new WeakSet()` (also see [WEAK_SET](#rtvref.types.WEAK_SET))
- all [primitives](#rtvref.types.primitives)
Plain object rules per qualifiers:
- REQUIRED: Per the lists above.
- EXPECTED: `null` is allowed.
- OPTIONAL: `undefined` is allowed.
Arguments (optional): [shape_object_args](#rtvref.types.shape_object_args)
**Kind**: static constant of [types](#rtvref.types)
**See**
- [qualifiers](#rtvref.qualifiers)
- [ANY_OBJECT](#rtvref.types.ANY_OBJECT)
- [OBJECT](#rtvref.types.OBJECT)
- [CLASS_OBJECT](#rtvref.types.CLASS_OBJECT)
### types.CLASS\_OBJECT : string
A _class_ object is one that is created by invoking the `new` operator on a
function (other than a primitive type function), generating a new object,
commonly referred to as a _class instance_. This object's prototype
(`__proto__`) is a reference to that function's `prototype` and has a
`constructor` property that is `===` to the function.
The following values are considered class objects:
- `new (function() {}) | new (class {})()` (tip: use the `ctor`
[argument](#rtvref.types.shape_object_args) to test for a specific class)
The following values __are not__ considered class objects:
- `{}`
- `new Object()`
- `new String('')`
- `new Boolean(true)`
- `new Number(1)`
- `[]` (also see [ARRAY](#rtvref.types.ARRAY))
- `new Array()` (also see [ARRAY](#rtvref.types.ARRAY))
- `/re/` (also see [REGEXP](#rtvref.types.REGEXP))
- `new RegExp('re')` (also see [REGEXP](#rtvref.types.REGEXP))
- `new Date()` (also see [DATE](#rtvref.types.DATE))
- `new Error()` (also see [ERROR](#rtvref.types.ERROR))
- `new Promise()` (also see [PROMISE](#rtvref.types.PROMISE))
- `function(){}` (also see [FUNCTION](#rtvref.types.FUNCTION))
- `arguments` (function arguments)
- `new Map()` (also see [MAP](#rtvref.types.MAP))
- `new WeakMap()` (also see [WEAK_MAP](#rtvref.types.WEAK_MAP))
- `new Set()` (also see [SET](#rtvref.types.SET))
- `new WeakSet()` (also see [WEAK_SET](#rtvref.types.WEAK_SET))
- all [primitives](#rtvref.types.primitives)
Class object rules per qualifiers:
- REQUIRED: Per the lists above.
- EXPECTED: `null` is allowed.
- OPTIONAL: `undefined` is allowed.
Arguments (optional): [shape_object_args](#rtvref.types.shape_object_args)
**Kind**: static constant of [types](#rtvref.types)
**See**
- [qualifiers](#rtvref.qualifiers)
- [ANY_OBJECT](#rtvref.types.ANY_OBJECT)
- [OBJECT](#rtvref.types.OBJECT)
- [PLAIN_OBJECT](#rtvref.types.PLAIN_OBJECT)
### types.HASH\_MAP : string
A simple [OBJECT](#rtvref.types.OBJECT) that is treated as a hash map
with an expected set of keys (forcibly strings due to the nature of the
native JavaScript `Object` type) and values. Keys are __own-properties only__,
and can be described using a regular expression. Values can be described using a
[typeset](#rtvref.types.typeset). Empty maps are permitted.
Map object rules per qualifiers: Same as [OBJECT](#rtvref.types.OBJECT) rules.
Arguments (optional): [collection_args](#rtvref.types.collection_args)
**Kind**: static constant of [types](#rtvref.types)
**See**
- [qualifiers](#rtvref.qualifiers)
- [ANY_OBJECT](#rtvref.types.ANY_OBJECT)
- [OBJECT](#rtvref.types.OBJECT)
- [PLAIN_OBJECT](#rtvref.types.PLAIN_OBJECT)
- [CLASS_OBJECT](#rtvref.types.CLASS_OBJECT)
- [MAP](#rtvref.types.MAP)
- [WEAK_MAP](#rtvref.types.WEAK_MAP)
### types.MAP : string
An ES6 map supports any value as its keys, unlike a
[HASH_MAP](#rtvref.types.HASH_MAP) that only supports strings. Keys can
be described using a regular expression (if they are strings), and values can
be described using a [typeset](#rtvref.types.typeset). Empty maps are permitted
by default.
Map rules per qualifiers: Must be a `Map` instance.
Arguments (optional): [collection_args](#rtvref.types.collection_args)
**Kind**: static constant of [types](#rtvref.types)
**See**
- [qualifiers](#rtvref.qualifiers)
- [HASH_MAP](#rtvref.types.HASH_MAP)
- [WEAK_MAP](#rtvref.types.WEAK_MAP)
### types.WEAK\_MAP : string
An ES6 weak map supports any _object_ as its keys, unlike a
[HASH_MAP](#rtvref.types.HASH_MAP) that only supports strings,
and a [MAP](#rtvref.types.MAP) that supports any type of value.
Weak map rules per qualifiers: Must be a `WeakMap` instance.
**Kind**: static constant of [types](#rtvref.types)
**See**
- [qualifiers](#rtvref.qualifiers)
- [HASH_MAP](#rtvref.types.HASH_MAP)
- [MAP](#rtvref.types.MAP)
### types.SET : string
An ES6 set is a collection of _unique_ values without associated keys. Values can
be described using a [typeset](#rtvref.types.typeset). Empty sets are permitted
by default.
Set rules per qualifiers: Must be a `Set` instance.
Arguments (optional): [collection_args](#rtvref.types.collection_args)
**Kind**: static constant of [types](#rtvref.types)
**See**
- [qualifiers](#rtvref.qualifiers)
- [WEAK_SET](#rtvref.types.WEAK_SET)
### types.WEAK\_SET : string
An ES6 weak set is a collection of weakly held _unique_ _objects_ without
associated keys.
Weak set rules per qualifiers: Must be a `WeakSet` instance.
**Kind**: static constant of [types](#rtvref.types)
**See**
- [qualifiers](#rtvref.qualifiers)
- [SET](#rtvref.types.SET)
### types.JSON : string
JSON rules per qualifiers: Must be a JSON value:
- [null](#rtvref.types.NULL)
- [string](#rtvref.types.STRING), however __empty strings are permitted__,
even if the qualifier is `REQUIRED`
- [boolean](#rtvref.types.BOOLEAN)
- [finite number](#rtvref.types.FINITE), however `NaN` __is permitted__
if the qualifier is TRUTHY since it is a [falsy value](#rtvref.types.falsy_values).
- [plain object](#rtvref.types.PLAIN_OBJECT)
- [array](#rtvref.types.ARRAY)
Since this type checks for _any_ valid JSON value, empty string and `null`
values are permitted, even when the typeset is qualified as `REQUIRED`.
Therefore, the `REQUIRED` qualifier has the same effect as the `EXPECTED`
qualifier.
Also note that if the qualifier is `OPTIONAL` or `TRUTHY`, then `undefined`
will be a permitted value, even though it is not a JSON value.
**Kind**: static constant of [types](#rtvref.types)
**See**: [qualifiers](#rtvref.qualifiers)
### types.DEFAULT\_OBJECT\_TYPE : string
Default object type: [OBJECT](#rtvref.types.OBJECT). This type is associated
with an un-qualified [shape descriptor](#rtvref.types.shape_descriptor).
**Kind**: static constant of [types](#rtvref.types)
### types.primitives : void
types](#rtvref.types)
**See**: [isPrimitive](#rtvref.validation.isPrimitive)
### types.falsy\_values : void
types](#rtvref.types)
**See**: [isFalsy](#rtvref.validation.isFalsy)
### types.qualifier\_rules : void
types](#rtvref.types)
### types.shape\_descriptor : Object
types](#rtvref.types)
**See**
- [isShape](#rtvref.validation.isShape)
- [typeset](#rtvref.types.typeset)
### types.type\_arguments : Object
types](#rtvref.types)
**See**: [isTypeArgs](#rtvref.validation.isTypeArgs)
### types.STRING\_args : Object
types](#rtvref.types)
**See**: [STRING](#rtvref.types.STRING)
**Properties**
| Name | Type | Description |
| --- | --- | --- |
| [oneOf] | string \| Array.<string> | An exact string to match (`===`). Can also be a list of strings, one of which must be an exact match. An empty string is allowed, and will override the normal rules of the `REQUIRED` [qualifier](#rtvref.qualifiers) which would otherwise require a non-empty string as the value. The list may contain an empty string. __An empty list will be ignored__. This argument is ignored if `exp` is specified. |
| [partial] | string | A partial value to match (must be somewhere within the string). Ignored if not a string, an empty string, or `oneOf` or `exp` is specified. `min` and `max` take __precedence__ over this argument (min/max will be validated first, then a partial match will be attempted). |
| [min] | number | Minimum inclusive length. Defaults to 1 for a `REQUIRED` string, and 0 for an `EXPECTED` or `OPTIONAL` string. Ignored if `oneOf` or `exp` is specified, or `min` is not a [FINITE](#rtvref.types.FINITE) number >= 0. |
| [max] | number | Maximum inclusive length. Negative means no maximum. Ignored if `oneOf` or `exp` is specified, `max` is not a [FINITE](#rtvref.types.FINITE) number, or `max` is less than `min`. Defaults to -1 (unlimited length). Can be set to zero to require a zero-length string. |
| [exp] | string | A string-based regular expression describing the string. For example, to require a string of numbers with a minimum length of 1, the following expression could be used: `"^\\d+$"`. |
| [expFlags] | string | A string specifying any flags to use with the regular expression specified in `exp`. Ignored if _falsy_ or if `exp` is not specified. See the [RegExp#flags](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp) parameter for more information. |
### types.SYMBOL\_args : Object
types](#rtvref.types)
**See**: [SYMBOL](#rtvref.types.SYMBOL)
**Properties**
| Name | Type | Description |
| --- | --- | --- |
| [oneOf] | symbol \| Array.<symbol> | An exact symbol to match (`===`). Can also be a list of symbols, one of which must be an exact match. Values to match are ignored if they are not symbols. An empty list will be ignored. |
### types.numeric\_args : Object
types](#rtvref.types)
**See**
- [NUMBER](#rtvref.types.NUMBER)
- [FINITE](#rtvref.types.FINITE)
- [INT](#rtvref.types.INT)
- [SAFE_INT](#rtvref.types.SAFE_INT)
- [FLOAT](#rtvref.types.FLOAT)
- [qualifiers](#rtvref.qualifiers)
**Properties**
| Name | Type | Description |
| --- | --- | --- |
| [oneOf] | number \| Array.<number> | An exact number to match (`===`). Can also be a list of numbers, one of which must be an exact match. An empty list will be ignored. Values to match are ignored if they are not within normal range of the type (e.g. for `NUMBER`, could be `+Infinity`, or even `NaN` if the qualifier is not `REQUIRED`; but these values would be ignored by `FINITE` since they aren't part of the `FINITE` range), or not numbers at all. Note that `0` and `NaN` are permitted when the qualifier is `TRUTHY` even if they aren't part of the list or aren't the single match. |
| [min] | number | Minimum inclusive value. Ignored if `oneOf` is specified, `min` is `NaN`, or `min` is not within normal range of the type. Note that `0` is permitted when the qualifier is `TRUTHY` even if the minimum does not permit it. |
| [max] | number | Maximum inclusive value. Ignored if `oneOf` is specified, `max` is `NaN`, `max` is not within normal range of the type, or `max` is less than `min`. Note that `0` is permitted when the qualifier is `TRUTHY` even if the minimum does not permit it. |
### types.shape\_object\_args : Object
types](#rtvref.types)
**See**
- [ANY_OBJECT](#rtvref.types.ANY_OBJECT)
- [OBJECT](#rtvref.types.OBJECT)
- [PLAIN_OBJECT](#rtvref.types.PLAIN_OBJECT)
- [CLASS_OBJECT](#rtvref.types.CLASS_OBJECT)
**Properties**
| Name | Type | Description |
| --- | --- | --- |
| [$] | Object | The [shape descriptor](#rtvref.types.shape_descriptor) describing the expected interface of the value being verified. If not specified, none of the value's properties will be verified, and the `exact` flag (as well as the `exactShapes` verification option) will be ignored. __NOTE:__ Any properties in the shape itself that are `undefined` will be ignored. This facilitates merging shapes with destructuring when combining shapes into larger ones. Applies to all shape object types. |
| [ctor] | function | A reference to a constructor function. If specified, the class object (instance) must have this class function in its inheritance chain such that `boolean | If `true`, this will restrict the __immediate__ object being verified to having the exact set of own-properties as those specified on the shape. By default, _additional_ own-properties on the object are ignored. In other words, the object must always have all of the shape's properties, but (by default) it may also have additional properties that are not in the shape. Setting `exact: true` would cause the verification to fail if the object has more properties than those specified in the shape. If specified, whether `true` or `false`, this flag overrides the `exactShapes` option for the verification __for this shape only__. Nested shapes will not be affected. The `exactShapes` flag that may be set in the verification's [context options](#rtvref.validator.type_validator_context_options) via a call to [check](#rtv.check) or [verify](#rtv.verify). __NOTE:__ If this flag is `true` and the shape is __empty__, it will restrict the object being verified to an empty object (i.e. no own-properties). __NOTE:__ If this flag is `true` and the shape is not specified, the flag will be ignored, not verifying the value being checked has any specific own-properties. Applies to all shape object types. |
### types.ARRAY\_args : Object
types](#rtvref.types)
**See**: [ARRAY](#rtvref.types.ARRAY)
**Properties**
| Name | Type | Description |
| --- | --- | --- |
| [$] | [typeset](#rtvref.types.typeset) | The typeset which every value in the array must match. Defaults to [ANY](#rtvref.types.ANY) which means any value will match. |
| [length] | number | Exact length. Ignored if not a [FINITE](#rtvref.types.FINITE) number >= 0. |
| [min] | number | Minimum inclusive length. Ignored if `length` is specified, or `min` is not a [FINITE](#rtvref.types.FINITE) number >= 0. Defaults to 0. |
| [max] | number | Maximum inclusive length. Negative means no maximum. Ignored if `length` is specified, `max` is not a [FINITE](#rtvref.types.FINITE) number, or `max` is less than `min`. Defaults to -1 (unlimited). |
### types.collection\_args : Object
types](#rtvref.types)
**See**
- [HASH_MAP](#rtvref.types.HASH_MAP)
- [MAP](#rtvref.types.MAP)
- [SET](#rtvref.types.SET)
**Properties**
| Name | Type | Description |
| --- | --- | --- |
| [length] | number | The exact number of elements required in the collection. A negative value allows for any number of entries. Zero requires an empty collection. Ignored if not a [FINITE](#rtvref.types.FINITE) number. Applies to: All collection types. |
| [$keys] | [typeset](#rtvref.types.typeset) | A typeset describing each key in the collection. If the type is [HASH_MAP](#rtvref.types.HASH_MAP), this argument is ignored due to the nature of its JavaScript `Object`-based implementation which requires that all keys be non-empty [strings](#rtvref.types.STRING). Applies to: [MAP](#rtvref.types.MAP). |
| [keyExp] | string | A string-based regular expression describing the names of keys found in the collection. By default, there are no restrictions on key names. Ignored if the key type is not [STRING](#rtvref.types.STRING), as specified in `$keys` (when `$keys` is applicable to the collection type). For example, to require numerical keys, the following expression could be used: `"^\\d+$"`. Applies to: [HASH_MAP](#rtvref.types.HASH_MAP), [MAP](#rtvref.types.MAP). |
| [keyFlags] | string | A string specifying any flags to use with the regular expression specified in `keyExp`. Ignored if _falsy_, or if `keyExp` is not specified or irrelevant. See the [RegExp#flags](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp) parameter for more information. Applies to: [HASH_MAP](#rtvref.types.HASH_MAP), [MAP](#rtvref.types.MAP). |
| [$values] | [typeset](#rtvref.types.typeset) | A typeset describing each value in the collection. If specified, all values must match this typeset (but the collection is not required to have any elements to be considered valid, unless `length` is specified). If not specified, no validation is performed on values. For example, to require arrays of non-empty string values as values in the collection, the following typeset could be used: `[[types.STRING]]`. Applies to: All collection types. |
| [deep] | boolean | If `true`, the property value being tested does not match the `$values` typeset, and the property value [is a hash map](#rtvref.types.HASH_MAP), then verification will recurse into the property value and will attempt to verify its properties against the typeset in `$values`. If `false` (default), the property value must match the `$values` typeset. Applies to: [HASH_MAP](#rtvref.types.HASH_MAP). |
### types.typeset : Object \| string \| Array \| function
const contactShape = {
name: rtv.STRING, // required, non-empty, string
tags: [rtv.ARRAY, [rtv.STRING]], // required array of non-empty strings
// tags: [[rtv.STRING]], // same as above, but using shortcut array format
details: { // required nested object of type `OBJECT` (default)
birthday: [rtv.EXPECTED, rtv.DATE] // Date (could be null)
},
notes: [rtv.OPTIONAL, rtv.STRING, function(value) { // optional string...
if (value && !value.test(/^[A-Z].+\.$/)) {
throw new Error('Note must start with a capital letter, end with a ' +
period, and have something in between, if specified.');
}
}]
};
const contact = {
name: 'John Doe',
tags: ['colleagues', 'sports'],
details: {
birthday: null // not specified
}
};
rtv.verify(contact, contactShape); // OK
const walletShape = {
contacts: [[contactShape]], // list of contacts using nested shape
address: {
street: rtv.STRING
// ...
},
money: rtv.FINITE
};
rtv.verify({
contacts: [contact],
address: {street: '123 Main St'},
money: 100
}, walletShape); // OK
rtv.verify('foo', rtv.STRING); // OK
rtv.verify('foo', rtv.FINITE); // ERROR
const typeset = [rtv.STRING, rtv.FINITE]; // non-empty string, or finite number
rtv.verify('foo', typeset); // OK
rtv.verify(1, typeset); // OK
const validator = (v) => {
if (v % 10) {
throw new Error('Number must be a factor of 10.');
}
};
rtv.verify(100, validator); // OK
rtv.verify(120, [rtv.INT, validator]); // OK
const person = {
name: rtv.STRING, // required, non-empty
age: [rtv.OPTIONAL, rtv.FINITE, (v) => { // 18 or older, if specified
if (v < 18) {
throw new Error('Must be 18 or older.');
}
}]
};
rtv.verify({name: 'Bob'}, person); // OK
rtv.verify({name: ''}, person); // ERROR
rtv.verify({name: 'Steve', age: 17}, person); // ERROR
rtv.verify({name: 'Steve', age: null}, person); // OK
types](#rtvref.types)
### types.fully\_qualified\_typeset : Array
types](#rtvref.types)
### types.custom\_validator ⇒ \*
types](#rtvref.types)
**Returns**: \* - Either `undefined` or a _truthy_ value to __pass__ the verification, or a _falsy_
value to fail it. The validator may also throw an `Error` to fail the verification.
If a _falsy_ value (other than `undefined`) is returned, an `Error` will be generated and
included in the resulting `RtvError` as its [failure](rtvref.RtvError#failure) property,
as well as part of its `message`.
While `undefined` is _falsy_, it's also the result of a function that did not return anything,
which is interpreted as indicating the validator found no fault with the value.
It's recommend to throw an `Error` with a helpful message rather than simply returning a
_falsy_ value to fail the verification.
**Throws**:
- Error (Optional) If the validation fails. This error will fail the overall
verification, and will be included in the resulting `RtvError` as its
[failure](rtvref.RtvError#failure) property, as well as part of its
`message`.
Although not required, it's recommended to throw an error with a message that will
help the developer determine why the custom validation failed, while avoiding exposing
any sensitive information that may be found in the `value` (such as passwords).
**See**: [isCustomValidator](#rtvref.validation.isCustomValidator)
| Param | Type | Description |
| --- | --- | --- |
| value | \* | The value being verified. This value differs from `context.originalValue` in that it is the value currently being verified, closest to the custom validator itself, e.g. the value of element in an array, as opposed to the array itself, or the value of a property in an object, as opposed to the object itself. |
| match | Array | A [fully-qualified](#rtvref.types.fully_qualified_typeset) typeset describing the __sub-type within__ the `typeset` parameter that matched, resulting in the custom validator being called (if no sub-types matched, it would not get called). For example, if the typeset used for verification was `[PLAIN_OBJECT, {$: {note: STRING}}, validator]`, this parameter would be a new Array typeset `[REQUIRED, PLAIN_OBJECT, {$: {note: STRING}}]`, and the `typeset` parameter would be a reference to the original `[PLAIN_OBJECT, {$: {note: STRING}}, validator]`. If the verification typeset was `[STRING, FINITE, validator]` and FINITE matched, this parameter would be `[REQUIRED, FINITE]` and the `typeset` parameter would be a reference to the original `[STRING, FINITE, validator]`. If the verification typeset was `[{message: STRING}, validator]` and the shape matched, this parameter would be `[REQUIRED, OBJECT, {$: {message: STRING}}]` (because of the [default object type](#rtvref.types.DEFAULT_OBJECT_TYPE)) and the `typeset` parameter would be a reference to the original `[{message: STRING}, validator]`. If the verification typeset was simply `validator` (just the validator itself), this parameter would be `[REQUIRED, ANY]` (because of the implied [ANY](#rtvref.types.ANY) type) and the `typeset` would be a reference to the original `validator`. |
| typeset | [typeset](#rtvref.types.typeset) | Reference to the typeset used for verification. Note the typeset may contain nested typeset(s), and may be part of a larger parent typeset (though there would be no reference to the parent typeset, if any). |
| context | [type\_validator\_context](#rtvref.validator.type_validator_context) | Additional context for the validation. |
## rtvref.util : object
rtvref](#rtvref)
* [.util](#rtvref.util) : object
* [.print(printValue, printOptions)](#rtvref.util.print) ⇒ string
* [.hasOwnProp(obj, prop)](#rtvref.util.hasOwnProp) ⇒ boolean
### util.print(printValue, printOptions) ⇒ string
Pretty-print a value.
**Kind**: static method of [util](#rtvref.util)
**Returns**: string - Pretty-printed value. It's not perfect and may not catch
all types, but attempts to be good enough.
| Param | Type | Default | Description |
| --- | --- | --- | --- |
| printValue | \* | | Value to print. |
| printOptions | Object | | Print options. |
| [printOptions.isTypeset] | boolean | false | `true` if the value being printed is a [typeset](#rtvref.types.typeset); `false` otherwise. |
### util.hasOwnProp(obj, prop) ⇒ boolean
Safely determines if a property is an own-property of an object.
**Kind**: static method of [util](#rtvref.util)
**Returns**: boolean - `true` if it is; `false` otherwise. Also `false` if `obj`
is _falsy_.
| Param | Type | Description |
| --- | --- | --- |
| obj | Object | Object to check. Can be _falsy_. |
| prop | string | Own-property to check. |
## rtvref.validation : object
rtvref](#rtvref)
* [.validation](#rtvref.validation) : object
* [.method(value)](#rtvref.validation.method) ⇒ boolean
* [.isAny](#rtvref.validation.isAny) : Module
* [.type](#rtvref.validation.isAny.type) : string
* [.check(v)](#rtvref.validation.isAny.check) ⇒ boolean
* [.isAnyObject](#rtvref.validation.isAnyObject) : Module
* [.type](#rtvref.validation.isAnyObject.type) : string
* [.check(v)](#rtvref.validation.isAnyObject.check) ⇒ boolean
* [.isArray](#rtvref.validation.isArray) : Module
* [.type](#rtvref.validation.isArray.type) : string
* [.check(v)](#rtvref.validation.isArray.check) ⇒ boolean
* [.isBoolean](#rtvref.validation.isBoolean) : Module
* [.type](#rtvref.validation.isBoolean.type) : string
* [.check(v)](#rtvref.validation.isBoolean.check) ⇒ boolean
* [.isClassObject](#rtvref.validation.isClassObject) : Module
* [.type](#rtvref.validation.isClassObject.type) : string
* [.check(v)](#rtvref.validation.isClassObject.check) ⇒ boolean
* [.isCustomValidator](#rtvref.validation.isCustomValidator) : Module
* [.type](#rtvref.validation.isCustomValidator.type) : string
* [.check(v)](#rtvref.validation.isCustomValidator.check) ⇒ boolean
* [.isDate](#rtvref.validation.isDate) : Module
* [.type](#rtvref.validation.isDate.type) : string
* [.check(v)](#rtvref.validation.isDate.check) ⇒ boolean
* [.isError](#rtvref.validation.isError) : Module
* [.type](#rtvref.validation.isError.type) : string
* [.check(v)](#rtvref.validation.isError.check) ⇒ boolean
* [.isFalsy](#rtvref.validation.isFalsy) : Module
* [.type](#rtvref.validation.isFalsy.type) : string
* [.check(v)](#rtvref.validation.isFalsy.check) ⇒ boolean
* [.isFinite](#rtvref.validation.isFinite) : Module
* [.type](#rtvref.validation.isFinite.type) : string
* [.check(v)](#rtvref.validation.isFinite.check) ⇒ boolean
* [.isFloat](#rtvref.validation.isFloat) : Module
* [.type](#rtvref.validation.isFloat.type) : string
* [.check(v)](#rtvref.validation.isFloat.check) ⇒ boolean
* [.isFunction](#rtvref.validation.isFunction) : Module
* [.type](#rtvref.validation.isFunction.type) : string
* [.check(v)](#rtvref.validation.isFunction.check) ⇒ boolean
* [.isHashMap](#rtvref.validation.isHashMap) : Module
* [.type](#rtvref.validation.isHashMap.type) : string
* [.check(v)](#rtvref.validation.isHashMap.check) ⇒ boolean
* [.isInt](#rtvref.validation.isInt) : Module
* [.type](#rtvref.validation.isInt.type) : string
* [.check(v)](#rtvref.validation.isInt.check) ⇒ boolean
* [.isJson](#rtvref.validation.isJson) : Module
* [.type](#rtvref.validation.isJson.type) : string
* [.check(v)](#rtvref.validation.isJson.check) ⇒ boolean
* [.isMap](#rtvref.validation.isMap) : Module
* [.type](#rtvref.validation.isMap.type) : string
* [.check(v)](#rtvref.validation.isMap.check) ⇒ boolean
* [.isNull](#rtvref.validation.isNull) : Module
* [.type](#rtvref.validation.isNull.type) : string
* [.check(v)](#rtvref.validation.isNull.check) ⇒ boolean
* [.isNumber](#rtvref.validation.isNumber) : Module
* [.type](#rtvref.validation.isNumber.type) : string
* [.check(v)](#rtvref.validation.isNumber.check) ⇒ boolean
* [.isObject](#rtvref.validation.isObject) : Module
* [.type](#rtvref.validation.isObject.type) : string
* [.check(v)](#rtvref.validation.isObject.check) ⇒ boolean
* [.isPlainObject](#rtvref.validation.isPlainObject) : Module
* [.type](#rtvref.validation.isPlainObject.type) : string
* [.check(v)](#rtvref.validation.isPlainObject.check) ⇒ boolean
* [.isPrimitive](#rtvref.validation.isPrimitive) : Module
* [.type](#rtvref.validation.isPrimitive.type) : string
* [.check(v)](#rtvref.validation.isPrimitive.check) ⇒ boolean
* [.isPromise](#rtvref.validation.isPromise) : Module
* [.type](#rtvref.validation.isPromise.type) : string
* [.check(v)](#rtvref.validation.isPromise.check) ⇒ boolean
* [.isRegExp](#rtvref.validation.isRegExp) : Module
* [.type](#rtvref.validation.isRegExp.type) : string
* [.check(v)](#rtvref.validation.isRegExp.check) ⇒ boolean
* [.isSafeInt](#rtvref.validation.isSafeInt) : Module
* [.type](#rtvref.validation.isSafeInt.type) : string
* [.check(v)](#rtvref.validation.isSafeInt.check) ⇒ boolean
* [.isSet](#rtvref.validation.isSet) : Module
* [.type](#rtvref.validation.isSet.type) : string
* [.check(v)](#rtvref.validation.isSet.check) ⇒ boolean
* [.isShape](#rtvref.validation.isShape) : Module
* [.type](#rtvref.validation.isShape.type) : string
* [.check(v)](#rtvref.validation.isShape.check) ⇒ boolean
* [.isString](#rtvref.validation.isString) : Module
* [.type](#rtvref.validation.isString.type) : string
* [.check(v, [options])](#rtvref.validation.isString.check) ⇒ boolean
* [.isSymbol](#rtvref.validation.isSymbol) : Module
* [.type](#rtvref.validation.isSymbol.type) : string
* [.check(v)](#rtvref.validation.isSymbol.check) ⇒ boolean
* [.isTypeArgs](#rtvref.validation.isTypeArgs) : Module
* [.type](#rtvref.validation.isTypeArgs.type) : string
* [.check(v)](#rtvref.validation.isTypeArgs.check) ⇒ boolean
* [.isTypeset](#rtvref.validation.isTypeset) : Module
* [.type](#rtvref.validation.isTypeset.type) : string
* [.check(v, [options])](#rtvref.validation.isTypeset.check) ⇒ boolean
* [.isWeakMap](#rtvref.validation.isWeakMap) : Module
* [.type](#rtvref.validation.isWeakMap.type) : string
* [.check(v)](#rtvref.validation.isWeakMap.check) ⇒ boolean
* [.isWeakSet](#rtvref.validation.isWeakSet) : Module
* [.type](#rtvref.validation.isWeakSet.type) : string
* [.check(v)](#rtvref.validation.isWeakSet.check) ⇒ boolean
### validation.method(value) ⇒ boolean
validation](#rtvref.validation)
**Returns**: boolean - `true` if the value matches the type; `false` otherwise.
| Param | Type | Description |
| --- | --- | --- |
| value | \* | The value to validate. |
### validation.isAny : Module
Validation Module: isAny
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isAny](#rtvref.validation.isAny) : Module
* [.type](#rtvref.validation.isAny.type) : string
* [.check(v)](#rtvref.validation.isAny.check) ⇒ boolean
#### isAny.type : string
Type: [ANY](#rtvref.types.ANY)
**Kind**: static constant of [isAny](#rtvref.validation.isAny)
#### isAny.check(v) ⇒ boolean
[Validation](#rtvref.validation.method) for the
[ANY](#rtvref.types.ANY) type.
**Kind**: static method of [isAny](#rtvref.validation.isAny)
**Returns**: boolean - `true` if validated; `false` otherwise.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
### validation.isAnyObject : Module
Validation Module: isAnyObject
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isAnyObject](#rtvref.validation.isAnyObject) : Module
* [.type](#rtvref.validation.isAnyObject.type) : string
* [.check(v)](#rtvref.validation.isAnyObject.check) ⇒ boolean
#### isAnyObject.type : string
Type: [ANY_OBJECT](#rtvref.types.ANY_OBJECT)
**Kind**: static constant of [isAnyObject](#rtvref.validation.isAnyObject)
#### isAnyObject.check(v) ⇒ boolean
[Validation](#rtvref.validation.method) for the
[ANY_OBJECT](#rtvref.types.ANY_OBJECT) type.
**Kind**: static method of [isAnyObject](#rtvref.validation.isAnyObject)
**Returns**: boolean - `true` if validated; `false` otherwise.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
### validation.isArray : Module
Validation Module: isArray
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isArray](#rtvref.validation.isArray) : Module
* [.type](#rtvref.validation.isArray.type) : string
* [.check(v)](#rtvref.validation.isArray.check) ⇒ boolean
#### isArray.type : string
Type: [ARRAY](#rtvref.types.ARRAY)
**Kind**: static constant of [isArray](#rtvref.validation.isArray)
#### isArray.check(v) ⇒ boolean
[Validation](#rtvref.validation.method) for the
[ARRAY](#rtvref.types.ARRAY) type.
**Kind**: static method of [isArray](#rtvref.validation.isArray)
**Returns**: boolean - `true` if validated; `false` otherwise.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
### validation.isBoolean : Module
Validation Module: isBoolean
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isBoolean](#rtvref.validation.isBoolean) : Module
* [.type](#rtvref.validation.isBoolean.type) : string
* [.check(v)](#rtvref.validation.isBoolean.check) ⇒ boolean
#### isBoolean.type : string
Type: [BOOLEAN](#rtvref.types.BOOLEAN)
**Kind**: static constant of [isBoolean](#rtvref.validation.isBoolean)
#### isBoolean.check(v) ⇒ boolean
[Validation](#rtvref.validation.method) for the
[BOOLEAN](#rtvref.types.BOOLEAN) type.
Determines if a value is a boolean literal __only__ (i.e. a
[primitive](#rtvref.types.primitives)). It does not validate
`new Boolean(true)`, which is an object that is a boolean.
**Kind**: static method of [isBoolean](#rtvref.validation.isBoolean)
**Returns**: boolean - `true` if validated; `false` otherwise.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
### validation.isClassObject : Module
Validation Module: isClassObject
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isClassObject](#rtvref.validation.isClassObject) : Module
* [.type](#rtvref.validation.isClassObject.type) : string
* [.check(v)](#rtvref.validation.isClassObject.check) ⇒ boolean
#### isClassObject.type : string
Type: [CLASS_OBJECT](#rtvref.types.CLASS_OBJECT)
**Kind**: static constant of [isClassObject](#rtvref.validation.isClassObject)
#### isClassObject.check(v) ⇒ boolean
[Validation](#rtvref.validation.method) for the
[CLASS_OBJECT](#rtvref.types.CLASS_OBJECT) type.
**Kind**: static method of [isClassObject](#rtvref.validation.isClassObject)
**Returns**: boolean - `true` if validated; `false` otherwise.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
### validation.isCustomValidator : Module
Validation Module: isCustomValidator
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isCustomValidator](#rtvref.validation.isCustomValidator) : Module
* [.type](#rtvref.validation.isCustomValidator.type) : string
* [.check(v)](#rtvref.validation.isCustomValidator.check) ⇒ boolean
#### isCustomValidator.type : string
Type: `undefined`, [custom validator](#rtvref.types.custom_validator) pseudo-type.
**Kind**: static constant of [isCustomValidator](#rtvref.validation.isCustomValidator)
#### isCustomValidator.check(v) ⇒ boolean
Determines if a value is a [custom validator](#rtvref.types.custom_validator).
**Kind**: static method of [isCustomValidator](#rtvref.validation.isCustomValidator)
**Returns**: boolean - `true` if it is; `false` otherwise.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
### validation.isDate : Module
Validation Module: isDate
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isDate](#rtvref.validation.isDate) : Module
* [.type](#rtvref.validation.isDate.type) : string
* [.check(v)](#rtvref.validation.isDate.check) ⇒ boolean
#### isDate.type : string
Type: [DATE](#rtvref.types.DATE)
**Kind**: static constant of [isDate](#rtvref.validation.isDate)
#### isDate.check(v) ⇒ boolean
[Validation](#rtvref.validation.method) for the
[DATE](#rtvref.types.DATE) type.
**Kind**: static method of [isDate](#rtvref.validation.isDate)
**Returns**: boolean - `true` if validated; `false` otherwise.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
### validation.isError : Module
Validation Module: isError
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isError](#rtvref.validation.isError) : Module
* [.type](#rtvref.validation.isError.type) : string
* [.check(v)](#rtvref.validation.isError.check) ⇒ boolean
#### isError.type : string
Type: [ERROR](#rtvref.types.ERROR)
**Kind**: static constant of [isError](#rtvref.validation.isError)
#### isError.check(v) ⇒ boolean
[Validation](#rtvref.validation.method) for the
[ERROR](#rtvref.types.ERROR) type.
**Kind**: static method of [isError](#rtvref.validation.isError)
**Returns**: boolean - `true` if validated; `false` otherwise.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
### validation.isFalsy : Module
Validation Module: isFalsy
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isFalsy](#rtvref.validation.isFalsy) : Module
* [.type](#rtvref.validation.isFalsy.type) : string
* [.check(v)](#rtvref.validation.isFalsy.check) ⇒ boolean
#### isFalsy.type : string
Type: `undefined`, [falsy value](#rtvref.types.falsy_values) pseudo-type.
**Kind**: static constant of [isFalsy](#rtvref.validation.isFalsy)
#### isFalsy.check(v) ⇒ boolean
Determines if a value is a JavaScript [falsy value](#rtvref.types.falsy_values).
**Kind**: static method of [isFalsy](#rtvref.validation.isFalsy)
**Returns**: boolean - `true` if it is; `false` otherwise.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
### validation.isFinite : Module
Validation Module: isFinite
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isFinite](#rtvref.validation.isFinite) : Module
* [.type](#rtvref.validation.isFinite.type) : string
* [.check(v)](#rtvref.validation.isFinite.check) ⇒ boolean
#### isFinite.type : string
Type: [FINITE](#rtvref.types.FINITE)
**Kind**: static constant of [isFinite](#rtvref.validation.isFinite)
#### isFinite.check(v) ⇒ boolean
[Validation](#rtvref.validation.method) for the
[FINITE](#rtvref.types.FINITE) type.
Determines if a value is a finite number literal __only__ (i.e. a
[primitive](#rtvref.types.primitives)). It does not validate
`new Number(1)`, which is an object that is a number.
**Kind**: static method of [isFinite](#rtvref.validation.isFinite)
**Returns**: boolean - `true` if validated; `false` otherwise.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
### validation.isFloat : Module
Validation Module: isFloat
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isFloat](#rtvref.validation.isFloat) : Module
* [.type](#rtvref.validation.isFloat.type) : string
* [.check(v)](#rtvref.validation.isFloat.check) ⇒ boolean
#### isFloat.type : string
Type: [FLOAT](#rtvref.types.FLOAT)
**Kind**: static constant of [isFloat](#rtvref.validation.isFloat)
#### isFloat.check(v) ⇒ boolean
[Validation](#rtvref.validation.method) for the
[FLOAT](#rtvref.types.FLOAT) type.
Determines if a value is a floating point literal __only__ (i.e. a
[primitive](#rtvref.types.primitives)). It does not validate
`new Number(1.5)`, which is an object that is a number.
**Kind**: static method of [isFloat](#rtvref.validation.isFloat)
**Returns**: boolean - `true` if validated; `false` otherwise.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
### validation.isFunction : Module
Validation Module: isFunction
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isFunction](#rtvref.validation.isFunction) : Module
* [.type](#rtvref.validation.isFunction.type) : string
* [.check(v)](#rtvref.validation.isFunction.check) ⇒ boolean
#### isFunction.type : string
Type: [FUNCTION](#rtvref.types.FUNCTION)
**Kind**: static constant of [isFunction](#rtvref.validation.isFunction)
#### isFunction.check(v) ⇒ boolean
[Validation](#rtvref.validation.method) for the
[FUNCTION](#rtvref.types.FUNCTION) type.
**Kind**: static method of [isFunction](#rtvref.validation.isFunction)
**Returns**: boolean - `true` if validated; `false` otherwise.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
### validation.isHashMap : Module
Validation Module: isHashMap
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isHashMap](#rtvref.validation.isHashMap) : Module
* [.type](#rtvref.validation.isHashMap.type) : string
* [.check(v)](#rtvref.validation.isHashMap.check) ⇒ boolean
#### isHashMap.type : string
Type: [HASH_MAP](#rtvref.types.HASH_MAP)
**Kind**: static constant of [isHashMap](#rtvref.validation.isHashMap)
#### isHashMap.check(v) ⇒ boolean
[Validation](#rtvref.validation.method) for the
[HASH_MAP](#rtvref.types.HASH_MAP) type.
**Kind**: static method of [isHashMap](#rtvref.validation.isHashMap)
**Returns**: boolean - `true` if validated; `false` otherwise.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
### validation.isInt : Module
Validation Module: isInt
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isInt](#rtvref.validation.isInt) : Module
* [.type](#rtvref.validation.isInt.type) : string
* [.check(v)](#rtvref.validation.isInt.check) ⇒ boolean
#### isInt.type : string
Type: [INT](#rtvref.types.INT)
**Kind**: static constant of [isInt](#rtvref.validation.isInt)
#### isInt.check(v) ⇒ boolean
[Validation](#rtvref.validation.method) for the
[INT](#rtvref.types.INT) type.
Determines if a value is an integer literal __only__ (i.e. a
[primitive](#rtvref.types.primitives)). It does not validate
`new Number(1)`, which is an object that is a number.
**Kind**: static method of [isInt](#rtvref.validation.isInt)
**Returns**: boolean - `true` if validated; `false` otherwise.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
### validation.isJson : Module
Validation Module: isJson
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isJson](#rtvref.validation.isJson) : Module
* [.type](#rtvref.validation.isJson.type) : string
* [.check(v)](#rtvref.validation.isJson.check) ⇒ boolean
#### isJson.type : string
Type: [JSON](#rtvref.types.JSON)
**Kind**: static constant of [isJson](#rtvref.validation.isJson)
#### isJson.check(v) ⇒ boolean
[Validation](#rtvref.validation.method) for the
[JSON](#rtvref.types.JSON) type.
**Kind**: static method of [isJson](#rtvref.validation.isJson)
**Returns**: boolean - `true` if validated; `false` otherwise.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
### validation.isMap : Module
Validation Module: isMap
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isMap](#rtvref.validation.isMap) : Module
* [.type](#rtvref.validation.isMap.type) : string
* [.check(v)](#rtvref.validation.isMap.check) ⇒ boolean
#### isMap.type : string
Type: [MAP](#rtvref.types.MAP)
**Kind**: static constant of [isMap](#rtvref.validation.isMap)
#### isMap.check(v) ⇒ boolean
[Validation](#rtvref.validation.method) for the
[MAP](#rtvref.types.MAP) type.
**Kind**: static method of [isMap](#rtvref.validation.isMap)
**Returns**: boolean - `true` if validated; `false` otherwise.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
### validation.isNull : Module
Validation Module: isNull
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isNull](#rtvref.validation.isNull) : Module
* [.type](#rtvref.validation.isNull.type) : string
* [.check(v)](#rtvref.validation.isNull.check) ⇒ boolean
#### isNull.type : string
Type: [NULL](#rtvref.types.NULL)
**Kind**: static constant of [isNull](#rtvref.validation.isNull)
#### isNull.check(v) ⇒ boolean
[Validation](#rtvref.validation.method) for the
[NULL](#rtvref.types.NULL) type.
**Kind**: static method of [isNull](#rtvref.validation.isNull)
**Returns**: boolean - `true` if validated; `false` otherwise.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
### validation.isNumber : Module
Validation Module: isNumber
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isNumber](#rtvref.validation.isNumber) : Module
* [.type](#rtvref.validation.isNumber.type) : string
* [.check(v)](#rtvref.validation.isNumber.check) ⇒ boolean
#### isNumber.type : string
Type: [NUMBER](#rtvref.types.NUMBER)
**Kind**: static constant of [isNumber](#rtvref.validation.isNumber)
#### isNumber.check(v) ⇒ boolean
[Validation](#rtvref.validation.method) for the
[NUMBER](#rtvref.types.NUMBER) type.
Determines if a value is a number literal __only__ (i.e. a
[primitive](#rtvref.types.primitives)). It does not validate
`new Number(1)`, which is an object that is a number, neither does it
validate `NaN`.
**Kind**: static method of [isNumber](#rtvref.validation.isNumber)
**Returns**: boolean - `true` if validated; `false` otherwise.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
### validation.isObject : Module
Validation Module: isObject
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isObject](#rtvref.validation.isObject) : Module
* [.type](#rtvref.validation.isObject.type) : string
* [.check(v)](#rtvref.validation.isObject.check) ⇒ boolean
#### isObject.type : string
Type: [OBJECT](#rtvref.types.OBJECT)
**Kind**: static constant of [isObject](#rtvref.validation.isObject)
#### isObject.check(v) ⇒ boolean
[Validation](#rtvref.validation.method) for the
[OBJECT](#rtvref.types.OBJECT) type.
**Kind**: static method of [isObject](#rtvref.validation.isObject)
**Returns**: boolean - `true` if validated; `false` otherwise.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
### validation.isPlainObject : Module
Validation Module: isPlainObject
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isPlainObject](#rtvref.validation.isPlainObject) : Module
* [.type](#rtvref.validation.isPlainObject.type) : string
* [.check(v)](#rtvref.validation.isPlainObject.check) ⇒ boolean
#### isPlainObject.type : string
Type: [PLAIN_OBJECT](#rtvref.types.PLAIN_OBJECT)
**Kind**: static constant of [isPlainObject](#rtvref.validation.isPlainObject)
#### isPlainObject.check(v) ⇒ boolean
[Validation](#rtvref.validation.method) for the
[PLAIN_OBJECT](#rtvref.types.PLAIN_OBJECT) type.
**Kind**: static method of [isPlainObject](#rtvref.validation.isPlainObject)
**Returns**: boolean - `true` if validated; `false` otherwise.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
### validation.isPrimitive : Module
Validation Module: isPrimitive
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isPrimitive](#rtvref.validation.isPrimitive) : Module
* [.type](#rtvref.validation.isPrimitive.type) : string
* [.check(v)](#rtvref.validation.isPrimitive.check) ⇒ boolean
#### isPrimitive.type : string
Type: `undefined`, [primitive](#rtvref.types.primitives) pseudo-type.
**Kind**: static constant of [isPrimitive](#rtvref.validation.isPrimitive)
#### isPrimitive.check(v) ⇒ boolean
Determines if a value is a JavaScript [primitive](#rtvref.types.primitives).
**Kind**: static method of [isPrimitive](#rtvref.validation.isPrimitive)
**Returns**: boolean - `true` if it is; `false` otherwise.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
### validation.isPromise : Module
Validation Module: isPromise
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isPromise](#rtvref.validation.isPromise) : Module
* [.type](#rtvref.validation.isPromise.type) : string
* [.check(v)](#rtvref.validation.isPromise.check) ⇒ boolean
#### isPromise.type : string
Type: [PROMISE](#rtvref.types.PROMISE)
**Kind**: static constant of [isPromise](#rtvref.validation.isPromise)
#### isPromise.check(v) ⇒ boolean
[Validation](#rtvref.validation.method) for the
[PROMISE](#rtvref.types.PROMISE) type.
**Kind**: static method of [isPromise](#rtvref.validation.isPromise)
**Returns**: boolean - `true` if validated; `false` otherwise.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
### validation.isRegExp : Module
Validation Module: isRegExp
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isRegExp](#rtvref.validation.isRegExp) : Module
* [.type](#rtvref.validation.isRegExp.type) : string
* [.check(v)](#rtvref.validation.isRegExp.check) ⇒ boolean
#### isRegExp.type : string
Type: [REGEXP](#rtvref.types.REGEXP)
**Kind**: static constant of [isRegExp](#rtvref.validation.isRegExp)
#### isRegExp.check(v) ⇒ boolean
[Validation](#rtvref.validation.method) for the
[REGEXP](#rtvref.types.REGEXP) type.
**Kind**: static method of [isRegExp](#rtvref.validation.isRegExp)
**Returns**: boolean - `true` if validated; `false` otherwise.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
### validation.isSafeInt : Module
Validation Module: isSafeInt
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isSafeInt](#rtvref.validation.isSafeInt) : Module
* [.type](#rtvref.validation.isSafeInt.type) : string
* [.check(v)](#rtvref.validation.isSafeInt.check) ⇒ boolean
#### isSafeInt.type : string
Type: [SAFE_INT](#rtvref.types.SAFE_INT)
**Kind**: static constant of [isSafeInt](#rtvref.validation.isSafeInt)
#### isSafeInt.check(v) ⇒ boolean
[Validation](#rtvref.validation.method) for the
[SAFE_INT](#rtvref.types.SAFE_INT) type.
Determines if a value is an integer literal __only__ (i.e. a
[primitive](#rtvref.types.primitives)). It does not validate
`new Number(1)`, which is an object that is a number.
**Kind**: static method of [isSafeInt](#rtvref.validation.isSafeInt)
**Returns**: boolean - `true` if validated; `false` otherwise.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
### validation.isSet : Module
Validation Module: isSet
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isSet](#rtvref.validation.isSet) : Module
* [.type](#rtvref.validation.isSet.type) : string
* [.check(v)](#rtvref.validation.isSet.check) ⇒ boolean
#### isSet.type : string
Type: [SET](#rtvref.types.SET)
**Kind**: static constant of [isSet](#rtvref.validation.isSet)
#### isSet.check(v) ⇒ boolean
[Validation](#rtvref.validation.method) for the
[SET](#rtvref.types.SET) type.
**Kind**: static method of [isSet](#rtvref.validation.isSet)
**Returns**: boolean - `true` if validated; `false` otherwise.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
### validation.isShape : Module
Validation Module: isShape
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isShape](#rtvref.validation.isShape) : Module
* [.type](#rtvref.validation.isShape.type) : string
* [.check(v)](#rtvref.validation.isShape.check) ⇒ boolean
#### isShape.type : string
Type: `undefined`, [shape](#rtvref.types.shape_descriptor) pseudo-type.
**Kind**: static constant of [isShape](#rtvref.validation.isShape)
#### isShape.check(v) ⇒ boolean
Determines if a value is a [shape](#rtvref.types.shape_descriptor).
**Kind**: static method of [isShape](#rtvref.validation.isShape)
**Returns**: boolean - `true` if it is; `false` otherwise.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
### validation.isString : Module
Validation Module: isString
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isString](#rtvref.validation.isString) : Module
* [.type](#rtvref.validation.isString.type) : string
* [.check(v, [options])](#rtvref.validation.isString.check) ⇒ boolean
#### isString.type : string
Type: [STRING](#rtvref.types.STRING)
**Kind**: static constant of [isString](#rtvref.validation.isString)
#### isString.check(v, [options]) ⇒ boolean
[Validation](#rtvref.validation.method) for the
[STRING](#rtvref.types.STRING) type.
Determines if a value is a string literal __only__ (i.e. a
[primitive](#rtvref.types.primitives)), __including an empty string__.
It does not validate `new String('value')`, which is an object that is a
string.
**Kind**: static method of [isString](#rtvref.validation.isString)
**Returns**: boolean - `true` if validated; `false` otherwise.
| Param | Type | Default | Description |
| --- | --- | --- | --- |
| v | \* | | Value to validate. |
| [options] | Object | | Validation options. |
| [options.allowEmpty] | boolean | false | If truthy, empty strings are permitted. |
### validation.isSymbol : Module
Validation Module: isSymbol
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isSymbol](#rtvref.validation.isSymbol) : Module
* [.type](#rtvref.validation.isSymbol.type) : string
* [.check(v)](#rtvref.validation.isSymbol.check) ⇒ boolean
#### isSymbol.type : string
Type: [SYMBOL](#rtvref.types.SYMBOL)
**Kind**: static constant of [isSymbol](#rtvref.validation.isSymbol)
#### isSymbol.check(v) ⇒ boolean
[Validation](#rtvref.validation.method) for the
[SYMBOL](#rtvref.types.SYMBOL) type.
**Kind**: static method of [isSymbol](#rtvref.validation.isSymbol)
**Returns**: boolean - `true` if validated; `false` otherwise.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
### validation.isTypeArgs : Module
Validation Module: isTypeArgs
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isTypeArgs](#rtvref.validation.isTypeArgs) : Module
* [.type](#rtvref.validation.isTypeArgs.type) : string
* [.check(v)](#rtvref.validation.isTypeArgs.check) ⇒ boolean
#### isTypeArgs.type : string
Type: `undefined`, [type arguments](#rtvref.types.type_arguments) pseudo-type.
**Kind**: static constant of [isTypeArgs](#rtvref.validation.isTypeArgs)
#### isTypeArgs.check(v) ⇒ boolean
Determines if a value is a [type arguments](#rtvref.types.type_arguments)
object.
**Kind**: static method of [isTypeArgs](#rtvref.validation.isTypeArgs)
**Returns**: boolean - `true` if it is; `false` otherwise.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
### validation.isTypeset : Module
Validation Module: isTypeset
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isTypeset](#rtvref.validation.isTypeset) : Module
* [.type](#rtvref.validation.isTypeset.type) : string
* [.check(v, [options])](#rtvref.validation.isTypeset.check) ⇒ boolean
#### isTypeset.type : string
Type: `undefined`, [typeset](#rtvref.types.typeset) pseudo-type.
**Kind**: static constant of [isTypeset](#rtvref.validation.isTypeset)
#### isTypeset.check(v, [options]) ⇒ boolean
Determines if a value is a typeset.
**Kind**: static method of [isTypeset](#rtvref.validation.isTypeset)
**Returns**: boolean - `true` if it is; `false` otherwise.
**See**: [typeset](#rtvref.types.typeset)
| Param | Type | Default | Description |
| --- | --- | --- | --- |
| v | \* | | Value to validate. |
| [options] | Object | | Validation options. |
| [options.deep] | boolean | false | If truthy, deeply-validates any nested typesets. Note that typesets in nested shapes are also deeply-validated. |
| [options.fullyQualified] | boolean | false | If truthy, the typeset must be fully-qualified to be valid. |
| [options.rootCause] | string \| undefined | | (Output property) If an options object is specified, this property will be added and set to a failure message IIF the validation fails. |
### validation.isWeakMap : Module
Validation Module: isWeakMap
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isWeakMap](#rtvref.validation.isWeakMap) : Module
* [.type](#rtvref.validation.isWeakMap.type) : string
* [.check(v)](#rtvref.validation.isWeakMap.check) ⇒ boolean
#### isWeakMap.type : string
Type: [WEAK_MAP](#rtvref.types.WEAK_MAP)
**Kind**: static constant of [isWeakMap](#rtvref.validation.isWeakMap)
#### isWeakMap.check(v) ⇒ boolean
[Validation](#rtvref.validation.method) for the
[WEAK_MAP](#rtvref.types.WEAK_MAP) type.
**Kind**: static method of [isWeakMap](#rtvref.validation.isWeakMap)
**Returns**: boolean - `true` if validated; `false` otherwise.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
### validation.isWeakSet : Module
Validation Module: isWeakSet
**Kind**: static typedef of [validation](#rtvref.validation)
* [.isWeakSet](#rtvref.validation.isWeakSet) : Module
* [.type](#rtvref.validation.isWeakSet.type) : string
* [.check(v)](#rtvref.validation.isWeakSet.check) ⇒ boolean
#### isWeakSet.type : string
Type: [WEAK_SET](#rtvref.types.WEAK_SET)
**Kind**: static constant of [isWeakSet](#rtvref.validation.isWeakSet)
#### isWeakSet.check(v) ⇒ boolean
[Validation](#rtvref.validation.method) for the
[WEAK_SET](#rtvref.types.WEAK_SET) type.
**Kind**: static method of [isWeakSet](#rtvref.validation.isWeakSet)
**Returns**: boolean - `true` if validated; `false` otherwise.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
## rtvref.validator : object
rtvref](#rtvref)
* [.validator](#rtvref.validator) : object
* [.type_validator(value, qualifier, args, context)](#rtvref.validator.type_validator) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.validator_config(settings)](#rtvref.validator.validator_config)
* [.valAny](#rtvref.validator.valAny) : Module
* [.type](#rtvref.validator.valAny.type) : string
* [.config(settings)](#rtvref.validator.valAny.config)
* [.validate(v, [q])](#rtvref.validator.valAny.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valAnyObject](#rtvref.validator.valAnyObject) : Module
* [.type](#rtvref.validator.valAnyObject.type) : string
* [.config(settings)](#rtvref.validator.valAnyObject.config)
* [.validate(v, [q], [args], [context])](#rtvref.validator.valAnyObject.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valArray](#rtvref.validator.valArray) : Module
* [.type](#rtvref.validator.valArray.type) : string
* [.config(settings)](#rtvref.validator.valArray.config)
* [.validate(v, [q], [args], [context])](#rtvref.validator.valArray.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valBoolean](#rtvref.validator.valBoolean) : Module
* [.type](#rtvref.validator.valBoolean.type) : string
* [.config(settings)](#rtvref.validator.valBoolean.config)
* [.validate(v, [q])](#rtvref.validator.valBoolean.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valClassObject](#rtvref.validator.valClassObject) : Module
* [.type](#rtvref.validator.valClassObject.type) : string
* [.config(settings)](#rtvref.validator.valClassObject.config)
* [.validate(v, [q], [args], [context])](#rtvref.validator.valClassObject.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valDate](#rtvref.validator.valDate) : Module
* [.type](#rtvref.validator.valDate.type) : string
* [.config(settings)](#rtvref.validator.valDate.config)
* [.validate(v, [q])](#rtvref.validator.valDate.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valError](#rtvref.validator.valError) : Module
* [.type](#rtvref.validator.valError.type) : string
* [.config(settings)](#rtvref.validator.valError.config)
* [.validate(v, [q])](#rtvref.validator.valError.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valFinite](#rtvref.validator.valFinite) : Module
* [.type](#rtvref.validator.valFinite.type) : string
* [.config(settings)](#rtvref.validator.valFinite.config)
* [.validate(v, [q], [args])](#rtvref.validator.valFinite.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valFloat](#rtvref.validator.valFloat) : Module
* [.type](#rtvref.validator.valFloat.type) : string
* [.config(settings)](#rtvref.validator.valFloat.config)
* [.validate(v, [q], [args])](#rtvref.validator.valFloat.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valFunction](#rtvref.validator.valFunction) : Module
* [.type](#rtvref.validator.valFunction.type) : string
* [.config(settings)](#rtvref.validator.valFunction.config)
* [.validate(v, [q])](#rtvref.validator.valFunction.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valHashMap](#rtvref.validator.valHashMap) : Module
* [.type](#rtvref.validator.valHashMap.type) : string
* [.config(settings)](#rtvref.validator.valHashMap.config)
* [.validate(v, [q], [args], [context])](#rtvref.validator.valHashMap.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.type_validator_context_options](#rtvref.validator.type_validator_context_options) : Object
* [.type_validator_context](#rtvref.validator.type_validator_context) : Object
* [.validator_config_settings](#rtvref.validator.validator_config_settings) : Object
* [.valInt](#rtvref.validator.valInt) : Module
* [.type](#rtvref.validator.valInt.type) : string
* [.config(settings)](#rtvref.validator.valInt.config)
* [.validate(v, [q], [args])](#rtvref.validator.valInt.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valJson](#rtvref.validator.valJson) : Module
* [.type](#rtvref.validator.valJson.type) : string
* [.config(settings)](#rtvref.validator.valJson.config)
* [.validate(v, [q])](#rtvref.validator.valJson.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valMap](#rtvref.validator.valMap) : Module
* [.type](#rtvref.validator.valMap.type) : string
* [.config(settings)](#rtvref.validator.valMap.config)
* [.validate(v, [q], [args], [context])](#rtvref.validator.valMap.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valNull](#rtvref.validator.valNull) : Module
* [.type](#rtvref.validator.valNull.type) : string
* [.config(settings)](#rtvref.validator.valNull.config)
* [.validate(v, [q])](#rtvref.validator.valNull.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valNumber](#rtvref.validator.valNumber) : Module
* [.type](#rtvref.validator.valNumber.type) : string
* [.config(settings)](#rtvref.validator.valNumber.config)
* [.validate(v, [q], [args])](#rtvref.validator.valNumber.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valObject](#rtvref.validator.valObject) : Module
* [.type](#rtvref.validator.valObject.type) : string
* [.config(settings)](#rtvref.validator.valObject.config)
* [.validate(v, [q], [args], [context])](#rtvref.validator.valObject.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valPlainObject](#rtvref.validator.valPlainObject) : Module
* [.type](#rtvref.validator.valPlainObject.type) : string
* [.config(settings)](#rtvref.validator.valPlainObject.config)
* [.validate(v, [q], [args], [context])](#rtvref.validator.valPlainObject.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valPromise](#rtvref.validator.valPromise) : Module
* [.type](#rtvref.validator.valPromise.type) : string
* [.config(settings)](#rtvref.validator.valPromise.config)
* [.validate(v, [q])](#rtvref.validator.valPromise.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valRegExp](#rtvref.validator.valRegExp) : Module
* [.type](#rtvref.validator.valRegExp.type) : string
* [.config(settings)](#rtvref.validator.valRegExp.config)
* [.validate(v, [q])](#rtvref.validator.valRegExp.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valSafeInt](#rtvref.validator.valSafeInt) : Module
* [.type](#rtvref.validator.valSafeInt.type) : string
* [.config(settings)](#rtvref.validator.valSafeInt.config)
* [.validate(v, [q], [args])](#rtvref.validator.valSafeInt.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valSet](#rtvref.validator.valSet) : Module
* [.type](#rtvref.validator.valSet.type) : string
* [.config(settings)](#rtvref.validator.valSet.config)
* [.validate(v, [q], [args], [context])](#rtvref.validator.valSet.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valString](#rtvref.validator.valString) : Module
* [.type](#rtvref.validator.valString.type) : string
* [.config(settings)](#rtvref.validator.valString.config)
* [.validate(v, [q], [args])](#rtvref.validator.valString.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valSymbol](#rtvref.validator.valSymbol) : Module
* [.type](#rtvref.validator.valSymbol.type) : string
* [.config(settings)](#rtvref.validator.valSymbol.config)
* [.validate(v, [q], [args])](#rtvref.validator.valSymbol.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valWeakMap](#rtvref.validator.valWeakMap) : Module
* [.type](#rtvref.validator.valWeakMap.type) : string
* [.config(settings)](#rtvref.validator.valWeakMap.config)
* [.validate(v, [q])](#rtvref.validator.valWeakMap.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.valWeakSet](#rtvref.validator.valWeakSet) : Module
* [.type](#rtvref.validator.valWeakSet.type) : string
* [.config(settings)](#rtvref.validator.valWeakSet.config)
* [.validate(v, [q])](#rtvref.validator.valWeakSet.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
### validator.type\_validator(value, qualifier, args, context) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
validator](#rtvref.validator)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - An `RtvSuccess` if valid;
`RtvError` if not.
| Param | Type | Description |
| --- | --- | --- |
| value | \* | The value to validate. |
| qualifier | string | The validation qualifier from the immediate [typeset](#rtvref.types.typeset) in which the pertaining type was specified. Validators should always explicitly default to [REQUIRED](#rtvref.qualifiers.REQUIRED) to maintain consistent behavior. |
| args | Object | The arguments object, if any/applicable, for the type being validated. For example, [string args](#rtvref.types.STRING_args) in a typeset such as `[rtv.STRING, {min: 5}]` (a required string of at least 5 characters in length). |
| context | [type\_validator\_context](#rtvref.validator.type_validator_context) | Additional context for the validation. |
### validator.validator\_config(settings)
validator](#rtvref.validator)
| Param | Type | Description |
| --- | --- | --- |
| settings | [validator\_config\_settings](#rtvref.validator.validator_config_settings) | Configuration settings. |
### validator.valAny : Module
Validator Module: valAny
**Kind**: static typedef of [validator](#rtvref.validator)
* [.valAny](#rtvref.validator.valAny) : Module
* [.type](#rtvref.validator.valAny.type) : string
* [.config(settings)](#rtvref.validator.valAny.config)
* [.validate(v, [q])](#rtvref.validator.valAny.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
#### valAny.type : string
Type: [ANY](#rtvref.types.ANY)
**Kind**: static constant of [valAny](#rtvref.validator.valAny)
#### valAny.config(settings)
[Configuration Function](#rtvref.validator.validator_config)
**Kind**: static method of [valAny](#rtvref.validator.valAny)
| Param | Type | Description |
| --- | --- | --- |
| settings | [validator\_config\_settings](#rtvref.validator.validator_config_settings) | Configuration settings. |
#### valAny.validate(v, [q]) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
[Validator](#rtvref.validator.type_validator) for the
[ANY](#rtvref.types.ANY) type.
**Kind**: static method of [valAny](#rtvref.validator.valAny)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - An `RtvSuccess` if valid; `RtvError` if not.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
| [q] | string | Validation qualifier. Defaults to [REQUIRED](#rtvref.qualifiers.REQUIRED). |
### validator.valAnyObject : Module
Validator Module: valAnyObject
**Kind**: static typedef of [validator](#rtvref.validator)
* [.valAnyObject](#rtvref.validator.valAnyObject) : Module
* [.type](#rtvref.validator.valAnyObject.type) : string
* [.config(settings)](#rtvref.validator.valAnyObject.config)
* [.validate(v, [q], [args], [context])](#rtvref.validator.valAnyObject.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
#### valAnyObject.type : string
Type: [ANY_OBJECT](#rtvref.types.ANY_OBJECT)
**Kind**: static constant of [valAnyObject](#rtvref.validator.valAnyObject)
#### valAnyObject.config(settings)
[Configuration Function](#rtvref.validator.validator_config)
**Kind**: static method of [valAnyObject](#rtvref.validator.valAnyObject)
| Param | Type | Description |
| --- | --- | --- |
| settings | [validator\_config\_settings](#rtvref.validator.validator_config_settings) | Configuration settings. |
#### valAnyObject.validate(v, [q], [args], [context]) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
[Validator](#rtvref.validator.type_validator) for the
[ANY_OBJECT](#rtvref.types.ANY_OBJECT) type.
**Kind**: static method of [valAnyObject](#rtvref.validator.valAnyObject)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - An `RtvSuccess` if valid; `RtvError` if not.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
| [q] | string | Validation qualifier. Defaults to [REQUIRED](#rtvref.qualifiers.REQUIRED). |
| [args] | [shape\_object\_args](#rtvref.types.shape_object_args) | Type arguments. |
| [context] | [type\_validator\_context](#rtvref.validator.type_validator_context) | Validation context. |
### validator.valArray : Module
Validator Module: valArray
**Kind**: static typedef of [validator](#rtvref.validator)
* [.valArray](#rtvref.validator.valArray) : Module
* [.type](#rtvref.validator.valArray.type) : string
* [.config(settings)](#rtvref.validator.valArray.config)
* [.validate(v, [q], [args], [context])](#rtvref.validator.valArray.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
#### valArray.type : string
Type: [ARRAY](#rtvref.types.ARRAY)
**Kind**: static constant of [valArray](#rtvref.validator.valArray)
#### valArray.config(settings)
[Configuration Function](#rtvref.validator.validator_config)
**Kind**: static method of [valArray](#rtvref.validator.valArray)
| Param | Type | Description |
| --- | --- | --- |
| settings | [validator\_config\_settings](#rtvref.validator.validator_config_settings) | Configuration settings. |
#### valArray.validate(v, [q], [args], [context]) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
[Validator](#rtvref.validator.type_validator) for the
[ARRAY](#rtvref.types.ARRAY) type.
**Kind**: static method of [valArray](#rtvref.validator.valArray)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - An `RtvSuccess` if valid; `RtvError` if not.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
| [q] | string | Validation qualifier. Defaults to [REQUIRED](#rtvref.qualifiers.REQUIRED). |
| [args] | [ARRAY\_args](#rtvref.types.ARRAY_args) | Type arguments. |
| [context] | [type\_validator\_context](#rtvref.validator.type_validator_context) | Validation context. |
### validator.valBoolean : Module
Validator Module: valBoolean
**Kind**: static typedef of [validator](#rtvref.validator)
* [.valBoolean](#rtvref.validator.valBoolean) : Module
* [.type](#rtvref.validator.valBoolean.type) : string
* [.config(settings)](#rtvref.validator.valBoolean.config)
* [.validate(v, [q])](#rtvref.validator.valBoolean.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
#### valBoolean.type : string
Type: [BOOLEAN](#rtvref.types.BOOLEAN)
**Kind**: static constant of [valBoolean](#rtvref.validator.valBoolean)
#### valBoolean.config(settings)
[Configuration Function](#rtvref.validator.validator_config)
**Kind**: static method of [valBoolean](#rtvref.validator.valBoolean)
| Param | Type | Description |
| --- | --- | --- |
| settings | [validator\_config\_settings](#rtvref.validator.validator_config_settings) | Configuration settings. |
#### valBoolean.validate(v, [q]) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
[Validator](#rtvref.validator.type_validator) for the
[BOOLEAN](#rtvref.types.BOOLEAN) type.
Determines if a value is a boolean literal __only__ (i.e. a
[primitive](#rtvref.types.primitives)). It does not validate
`new Boolean(true)`, which is an object that is a boolean.
**Kind**: static method of [valBoolean](#rtvref.validator.valBoolean)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - An `RtvSuccess` if valid; `RtvError` if not.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
| [q] | string | Validation qualifier. Defaults to [REQUIRED](#rtvref.qualifiers.REQUIRED). |
### validator.valClassObject : Module
Validator Module: valClassObject
**Kind**: static typedef of [validator](#rtvref.validator)
* [.valClassObject](#rtvref.validator.valClassObject) : Module
* [.type](#rtvref.validator.valClassObject.type) : string
* [.config(settings)](#rtvref.validator.valClassObject.config)
* [.validate(v, [q], [args], [context])](#rtvref.validator.valClassObject.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
#### valClassObject.type : string
Type: [CLASS_OBJECT](#rtvref.types.CLASS_OBJECT)
**Kind**: static constant of [valClassObject](#rtvref.validator.valClassObject)
#### valClassObject.config(settings)
[Configuration Function](#rtvref.validator.validator_config)
**Kind**: static method of [valClassObject](#rtvref.validator.valClassObject)
| Param | Type | Description |
| --- | --- | --- |
| settings | [validator\_config\_settings](#rtvref.validator.validator_config_settings) | Configuration settings. |
#### valClassObject.validate(v, [q], [args], [context]) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
[Validator](#rtvref.validator.type_validator) for the
[CLASS_OBJECT](#rtvref.types.CLASS_OBJECT) type.
**Kind**: static method of [valClassObject](#rtvref.validator.valClassObject)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - An `RtvSuccess` if valid; `RtvError` if not.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
| [q] | string | Validation qualifier. Defaults to [REQUIRED](#rtvref.qualifiers.REQUIRED). |
| [args] | [shape\_object\_args](#rtvref.types.shape_object_args) | Type arguments. |
| [context] | [type\_validator\_context](#rtvref.validator.type_validator_context) | Validation context. |
### validator.valDate : Module
Validator Module: valDate
**Kind**: static typedef of [validator](#rtvref.validator)
* [.valDate](#rtvref.validator.valDate) : Module
* [.type](#rtvref.validator.valDate.type) : string
* [.config(settings)](#rtvref.validator.valDate.config)
* [.validate(v, [q])](#rtvref.validator.valDate.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
#### valDate.type : string
Type: [DATE](#rtvref.types.DATE)
**Kind**: static constant of [valDate](#rtvref.validator.valDate)
#### valDate.config(settings)
[Configuration Function](#rtvref.validator.validator_config)
**Kind**: static method of [valDate](#rtvref.validator.valDate)
| Param | Type | Description |
| --- | --- | --- |
| settings | [validator\_config\_settings](#rtvref.validator.validator_config_settings) | Configuration settings. |
#### valDate.validate(v, [q]) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
[Validator](#rtvref.validator.type_validator) for the
[DATE](#rtvref.types.DATE) type.
**Kind**: static method of [valDate](#rtvref.validator.valDate)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - An `RtvSuccess` if valid; `RtvError` if not.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
| [q] | string | Validation qualifier. Defaults to [REQUIRED](#rtvref.qualifiers.REQUIRED). |
### validator.valError : Module
Validator Module: valError
**Kind**: static typedef of [validator](#rtvref.validator)
* [.valError](#rtvref.validator.valError) : Module
* [.type](#rtvref.validator.valError.type) : string
* [.config(settings)](#rtvref.validator.valError.config)
* [.validate(v, [q])](#rtvref.validator.valError.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
#### valError.type : string
Type: [ERROR](#rtvref.types.ERROR)
**Kind**: static constant of [valError](#rtvref.validator.valError)
#### valError.config(settings)
[Configuration Function](#rtvref.validator.validator_config)
**Kind**: static method of [valError](#rtvref.validator.valError)
| Param | Type | Description |
| --- | --- | --- |
| settings | [validator\_config\_settings](#rtvref.validator.validator_config_settings) | Configuration settings. |
#### valError.validate(v, [q]) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
[Validator](#rtvref.validator.type_validator) for the
[ERROR](#rtvref.types.ERROR) type.
**Kind**: static method of [valError](#rtvref.validator.valError)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - An `RtvSuccess` if valid; `RtvError` if not.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
| [q] | string | Validation qualifier. Defaults to [REQUIRED](#rtvref.qualifiers.REQUIRED). |
### validator.valFinite : Module
Validator Module: valFinite
**Kind**: static typedef of [validator](#rtvref.validator)
* [.valFinite](#rtvref.validator.valFinite) : Module
* [.type](#rtvref.validator.valFinite.type) : string
* [.config(settings)](#rtvref.validator.valFinite.config)
* [.validate(v, [q], [args])](#rtvref.validator.valFinite.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
#### valFinite.type : string
Type: [FINITE](#rtvref.types.FINITE)
**Kind**: static constant of [valFinite](#rtvref.validator.valFinite)
#### valFinite.config(settings)
[Configuration Function](#rtvref.validator.validator_config)
**Kind**: static method of [valFinite](#rtvref.validator.valFinite)
| Param | Type | Description |
| --- | --- | --- |
| settings | [validator\_config\_settings](#rtvref.validator.validator_config_settings) | Configuration settings. |
#### valFinite.validate(v, [q], [args]) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
[Validator](#rtvref.validator.type_validator) for the
[FINITE](#rtvref.types.FINITE) type.
Determines if a value is a number literal __only__ (i.e. a
[primitive](#rtvref.types.primitives)). It does not validate
`new Number(1)`, which is an object that is a number.
**Kind**: static method of [valFinite](#rtvref.validator.valFinite)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - An `RtvSuccess` if valid; `RtvError` if not.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
| [q] | string | Validation qualifier. Defaults to [REQUIRED](#rtvref.qualifiers.REQUIRED). |
| [args] | [numeric\_args](#rtvref.types.numeric_args) | Type arguments. |
### validator.valFloat : Module
Validator Module: valFloat
**Kind**: static typedef of [validator](#rtvref.validator)
* [.valFloat](#rtvref.validator.valFloat) : Module
* [.type](#rtvref.validator.valFloat.type) : string
* [.config(settings)](#rtvref.validator.valFloat.config)
* [.validate(v, [q], [args])](#rtvref.validator.valFloat.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
#### valFloat.type : string
Type: [FLOAT](#rtvref.types.FLOAT)
**Kind**: static constant of [valFloat](#rtvref.validator.valFloat)
#### valFloat.config(settings)
[Configuration Function](#rtvref.validator.validator_config)
**Kind**: static method of [valFloat](#rtvref.validator.valFloat)
| Param | Type | Description |
| --- | --- | --- |
| settings | [validator\_config\_settings](#rtvref.validator.validator_config_settings) | Configuration settings. |
#### valFloat.validate(v, [q], [args]) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
[Validator](#rtvref.validator.type_validator) for the
[FLOAT](#rtvref.types.FLOAT) type.
Determines if a value is a number literal __only__ (i.e. a
[primitive](#rtvref.types.primitives)). It does not validate
`new Number(1.5)`, which is an object that is a number.
**Kind**: static method of [valFloat](#rtvref.validator.valFloat)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - An `RtvSuccess` if valid; `RtvError` if not.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
| [q] | string | Validation qualifier. Defaults to [REQUIRED](#rtvref.qualifiers.REQUIRED). |
| [args] | [numeric\_args](#rtvref.types.numeric_args) | Type arguments. |
### validator.valFunction : Module
Validator Module: valFunction
**Kind**: static typedef of [validator](#rtvref.validator)
* [.valFunction](#rtvref.validator.valFunction) : Module
* [.type](#rtvref.validator.valFunction.type) : string
* [.config(settings)](#rtvref.validator.valFunction.config)
* [.validate(v, [q])](#rtvref.validator.valFunction.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
#### valFunction.type : string
Type: [FUNCTION](#rtvref.types.FUNCTION)
**Kind**: static constant of [valFunction](#rtvref.validator.valFunction)
#### valFunction.config(settings)
[Configuration Function](#rtvref.validator.validator_config)
**Kind**: static method of [valFunction](#rtvref.validator.valFunction)
| Param | Type | Description |
| --- | --- | --- |
| settings | [validator\_config\_settings](#rtvref.validator.validator_config_settings) | Configuration settings. |
#### valFunction.validate(v, [q]) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
[Validator](#rtvref.validator.type_validator) for the
[FUNCTION](#rtvref.types.FUNCTION) type.
**Kind**: static method of [valFunction](#rtvref.validator.valFunction)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - An `RtvSuccess` if valid; `RtvError` if not.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
| [q] | string | Validation qualifier. Defaults to [REQUIRED](#rtvref.qualifiers.REQUIRED). |
### validator.valHashMap : Module
Validator Module: valHashMap
**Kind**: static typedef of [validator](#rtvref.validator)
* [.valHashMap](#rtvref.validator.valHashMap) : Module
* [.type](#rtvref.validator.valHashMap.type) : string
* [.config(settings)](#rtvref.validator.valHashMap.config)
* [.validate(v, [q], [args], [context])](#rtvref.validator.valHashMap.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
#### valHashMap.type : string
Type: [HASH_MAP](#rtvref.types.HASH_MAP)
**Kind**: static constant of [valHashMap](#rtvref.validator.valHashMap)
#### valHashMap.config(settings)
[Configuration Function](#rtvref.validator.validator_config)
**Kind**: static method of [valHashMap](#rtvref.validator.valHashMap)
| Param | Type | Description |
| --- | --- | --- |
| settings | [validator\_config\_settings](#rtvref.validator.validator_config_settings) | Configuration settings. |
#### valHashMap.validate(v, [q], [args], [context]) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
[Validator](#rtvref.validator.type_validator) for the
[HASH_MAP](#rtvref.types.HASH_MAP) type.
**Kind**: static method of [valHashMap](#rtvref.validator.valHashMap)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - An `RtvSuccess` if valid; `RtvError` if not.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
| [q] | string | Validation qualifier. Defaults to [REQUIRED](#rtvref.qualifiers.REQUIRED). |
| [args] | [collection\_args](#rtvref.types.collection_args) | Type arguments. |
| [context] | [type\_validator\_context](#rtvref.validator.type_validator_context) | Validation context. |
### validator.type\_validator\_context\_options : Object
validator](#rtvref.validator)
**Properties**
| Name | Type | Description |
| --- | --- | --- |
| [exactShapes] | boolean | If `true`, any [shape](#rtvref.types.shape_descriptor) encountered, top-level or nested, unless specifically configured not to, will require that the related object's own-properties be _exactly_ those specified in the shape, no more, no less, as long as a shape is specified. By default, extra properties on the object (i.e. not in the shape) being verified are ignored. If a shape isn't specified on a given object-related typeset, this flag will be ignored for that typeset. This flag can be overridden on an individual shape basis with the shape's [exact argument](#rtvref.types.shape_object_args). |
### validator.type\_validator\_context : Object
{
originalValue: {foo: 1},
parent: {foo: 1},
parentKey: 'foo'
}
// and here, the validator's `value` parameter would be set to 1.
validator](#rtvref.validator)
**Properties**
| Name | Type | Description |
| --- | --- | --- |
| originalValue | \* | The original/first value given to [rtv.check()](#rtv.check) or [rtv.verify()](#rtv.verify). |
| parent | Object \| Array \| Map \| Set \| undefined | Reference to the immediate parent of the property or element being validated. For example, if we have this object: const foods = { fruits: ['apple', 'orange', 'banana'], vegetables: ['celery', 'cucumber', 'kale'] } [rtv.HASH_MAP, { keyExp: '\\w+', $values: [[rtv.STRING, (value, match, typeset, context) => { // called for each element of both arrays value; // 'apple', 'orange', ..., 'cucumber', 'kale' context.originalValue; // `foods` context.parent; // first `fruits`, then `vegetables` }]] }] [ rtv.HASH_MAP, { keyExp: '\\w+', $values: [[rtv.STRING]] }, (value, match, typeset, context) => { // called once for the hash map itself value; // `foods` context.originalValue; // `foods` context.parent; // `undefined` } ] \* | Reference to the key/index in the `parent` that is being validated. The associated value is provided as the first parameter to the [custom validator](#rtvref.types.custom_validator). `parentKey` differs depending on the type of `parent`: - `Set`: `undefined` since Sets do not have indexes. Use the `value` parameter provided to the [custom validator](#rtvref.types.custom_validator) as the key into the `parent` in this case. - `Map`: When validating __keys__, always `undefined`. Use the `value` parameter provided to the [custom validator](#rtvref.types.custom_validator) to know which key is being validated. When validating __values__, `parentKey` will be any value that is a valid key in a `Map`. - `Object` (i.e. [HASH_MAP](#rtvref.types.HASH_MAP)): `string`, the key name. - `Array`: `number`, the element's index. - `undefined`: `undefined`. |
| [options] | [type\_validator\_context\_options](#rtvref.validator.type_validator_context_options) | Configuration options. |
### validator.validator\_config\_settings : Object
validator](#rtvref.validator)
**Properties**
| Name | Type | Description |
| --- | --- | --- |
| impl | [impl](#rtvref.impl) | Reference to the `impl` module. |
### validator.valInt : Module
Validator Module: valInt
**Kind**: static typedef of [validator](#rtvref.validator)
* [.valInt](#rtvref.validator.valInt) : Module
* [.type](#rtvref.validator.valInt.type) : string
* [.config(settings)](#rtvref.validator.valInt.config)
* [.validate(v, [q], [args])](#rtvref.validator.valInt.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
#### valInt.type : string
Type: [INT](#rtvref.types.INT)
**Kind**: static constant of [valInt](#rtvref.validator.valInt)
#### valInt.config(settings)
[Configuration Function](#rtvref.validator.validator_config)
**Kind**: static method of [valInt](#rtvref.validator.valInt)
| Param | Type | Description |
| --- | --- | --- |
| settings | [validator\_config\_settings](#rtvref.validator.validator_config_settings) | Configuration settings. |
#### valInt.validate(v, [q], [args]) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
[Validator](#rtvref.validator.type_validator) for the
[INT](#rtvref.types.INT) type.
Determines if a value is a number literal __only__ (i.e. a
[primitive](#rtvref.types.primitives)). It does not validate
`new Number(1)`, which is an object that is a number.
**Kind**: static method of [valInt](#rtvref.validator.valInt)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - An `RtvSuccess` if valid; `RtvError` if not.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
| [q] | string | Validation qualifier. Defaults to [REQUIRED](#rtvref.qualifiers.REQUIRED). |
| [args] | [numeric\_args](#rtvref.types.numeric_args) | Type arguments. |
### validator.valJson : Module
Validator Module: valJson
**Kind**: static typedef of [validator](#rtvref.validator)
* [.valJson](#rtvref.validator.valJson) : Module
* [.type](#rtvref.validator.valJson.type) : string
* [.config(settings)](#rtvref.validator.valJson.config)
* [.validate(v, [q])](#rtvref.validator.valJson.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
#### valJson.type : string
Type: [JSON](#rtvref.types.JSON)
**Kind**: static constant of [valJson](#rtvref.validator.valJson)
#### valJson.config(settings)
[Configuration Function](#rtvref.validator.validator_config)
**Kind**: static method of [valJson](#rtvref.validator.valJson)
| Param | Type | Description |
| --- | --- | --- |
| settings | [validator\_config\_settings](#rtvref.validator.validator_config_settings) | Configuration settings. |
#### valJson.validate(v, [q]) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
[Validator](#rtvref.validator.type_validator) for the
[JSON](#rtvref.types.JSON) type.
**Kind**: static method of [valJson](#rtvref.validator.valJson)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - An `RtvSuccess` if valid; `RtvError` if not.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
| [q] | string | Validation qualifier. Defaults to [REQUIRED](#rtvref.qualifiers.REQUIRED). |
### validator.valMap : Module
Validator Module: valMap
**Kind**: static typedef of [validator](#rtvref.validator)
* [.valMap](#rtvref.validator.valMap) : Module
* [.type](#rtvref.validator.valMap.type) : string
* [.config(settings)](#rtvref.validator.valMap.config)
* [.validate(v, [q], [args], [context])](#rtvref.validator.valMap.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
#### valMap.type : string
Type: [MAP](#rtvref.types.MAP)
**Kind**: static constant of [valMap](#rtvref.validator.valMap)
#### valMap.config(settings)
[Configuration Function](#rtvref.validator.validator_config)
**Kind**: static method of [valMap](#rtvref.validator.valMap)
| Param | Type | Description |
| --- | --- | --- |
| settings | [validator\_config\_settings](#rtvref.validator.validator_config_settings) | Configuration settings. |
#### valMap.validate(v, [q], [args], [context]) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
[Validator](#rtvref.validator.type_validator) for the
[MAP](#rtvref.types.MAP) type.
**Kind**: static method of [valMap](#rtvref.validator.valMap)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - An `RtvSuccess` if valid; `RtvError` if not.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
| [q] | string | Validation qualifier. Defaults to [REQUIRED](#rtvref.qualifiers.REQUIRED). |
| [args] | [collection\_args](#rtvref.types.collection_args) | Type arguments. |
| [context] | [type\_validator\_context](#rtvref.validator.type_validator_context) | Validation context. |
### validator.valNull : Module
Validator Module: valNull
**Kind**: static typedef of [validator](#rtvref.validator)
* [.valNull](#rtvref.validator.valNull) : Module
* [.type](#rtvref.validator.valNull.type) : string
* [.config(settings)](#rtvref.validator.valNull.config)
* [.validate(v, [q])](#rtvref.validator.valNull.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
#### valNull.type : string
Type: [NULL](#rtvref.types.NULL)
**Kind**: static constant of [valNull](#rtvref.validator.valNull)
#### valNull.config(settings)
[Configuration Function](#rtvref.validator.validator_config)
**Kind**: static method of [valNull](#rtvref.validator.valNull)
| Param | Type | Description |
| --- | --- | --- |
| settings | [validator\_config\_settings](#rtvref.validator.validator_config_settings) | Configuration settings. |
#### valNull.validate(v, [q]) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
[Validator](#rtvref.validator.type_validator) for the
[NULL](#rtvref.types.NULL) type.
**Kind**: static method of [valNull](#rtvref.validator.valNull)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - An `RtvSuccess` if valid; `RtvError` if not.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
| [q] | string | Validation qualifier. Defaults to [REQUIRED](#rtvref.qualifiers.REQUIRED). |
### validator.valNumber : Module
Validator Module: valNumber
**Kind**: static typedef of [validator](#rtvref.validator)
* [.valNumber](#rtvref.validator.valNumber) : Module
* [.type](#rtvref.validator.valNumber.type) : string
* [.config(settings)](#rtvref.validator.valNumber.config)
* [.validate(v, [q], [args])](#rtvref.validator.valNumber.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
#### valNumber.type : string
Type: [NUMBER](#rtvref.types.NUMBER)
**Kind**: static constant of [valNumber](#rtvref.validator.valNumber)
#### valNumber.config(settings)
[Configuration Function](#rtvref.validator.validator_config)
**Kind**: static method of [valNumber](#rtvref.validator.valNumber)
| Param | Type | Description |
| --- | --- | --- |
| settings | [validator\_config\_settings](#rtvref.validator.validator_config_settings) | Configuration settings. |
#### valNumber.validate(v, [q], [args]) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
[Validator](#rtvref.validator.type_validator) for the
[NUMBER](#rtvref.types.NUMBER) type.
Determines if a value is a number literal __only__ (i.e. a
[primitive](#rtvref.types.primitives)). It does not validate
`new Number(1)`, which is an object that is a number.
**Kind**: static method of [valNumber](#rtvref.validator.valNumber)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - An `RtvSuccess` if valid; `RtvError` if not.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
| [q] | string | Validation qualifier. Defaults to [REQUIRED](#rtvref.qualifiers.REQUIRED). |
| [args] | [numeric\_args](#rtvref.types.numeric_args) | Type arguments. |
### validator.valObject : Module
Validator Module: valObject
**Kind**: static typedef of [validator](#rtvref.validator)
* [.valObject](#rtvref.validator.valObject) : Module
* [.type](#rtvref.validator.valObject.type) : string
* [.config(settings)](#rtvref.validator.valObject.config)
* [.validate(v, [q], [args], [context])](#rtvref.validator.valObject.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
#### valObject.type : string
Type: [OBJECT](#rtvref.types.OBJECT)
**Kind**: static constant of [valObject](#rtvref.validator.valObject)
#### valObject.config(settings)
[Configuration Function](#rtvref.validator.validator_config)
**Kind**: static method of [valObject](#rtvref.validator.valObject)
| Param | Type | Description |
| --- | --- | --- |
| settings | [validator\_config\_settings](#rtvref.validator.validator_config_settings) | Configuration settings. |
#### valObject.validate(v, [q], [args], [context]) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
[Validator](#rtvref.validator.type_validator) for the
[OBJECT](#rtvref.types.OBJECT) type.
**Kind**: static method of [valObject](#rtvref.validator.valObject)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - An `RtvSuccess` if valid; `RtvError` if not.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
| [q] | string | Validation qualifier. Defaults to [REQUIRED](#rtvref.qualifiers.REQUIRED). |
| [args] | [shape\_object\_args](#rtvref.types.shape_object_args) | Type arguments. |
| [context] | [type\_validator\_context](#rtvref.validator.type_validator_context) | Validation context. |
### validator.valPlainObject : Module
Validator Module: valPlainObject
**Kind**: static typedef of [validator](#rtvref.validator)
* [.valPlainObject](#rtvref.validator.valPlainObject) : Module
* [.type](#rtvref.validator.valPlainObject.type) : string
* [.config(settings)](#rtvref.validator.valPlainObject.config)
* [.validate(v, [q], [args], [context])](#rtvref.validator.valPlainObject.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
#### valPlainObject.type : string
Type: [PLAIN_OBJECT](#rtvref.types.PLAIN_OBJECT)
**Kind**: static constant of [valPlainObject](#rtvref.validator.valPlainObject)
#### valPlainObject.config(settings)
[Configuration Function](#rtvref.validator.validator_config)
**Kind**: static method of [valPlainObject](#rtvref.validator.valPlainObject)
| Param | Type | Description |
| --- | --- | --- |
| settings | [validator\_config\_settings](#rtvref.validator.validator_config_settings) | Configuration settings. |
#### valPlainObject.validate(v, [q], [args], [context]) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
[Validator](#rtvref.validator.type_validator) for the
[PLAIN_OBJECT](#rtvref.types.PLAIN_OBJECT) type.
**Kind**: static method of [valPlainObject](#rtvref.validator.valPlainObject)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - An `RtvSuccess` if valid; `RtvError` if not.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
| [q] | string | Validation qualifier. Defaults to [REQUIRED](#rtvref.qualifiers.REQUIRED). |
| [args] | [shape\_object\_args](#rtvref.types.shape_object_args) | Type arguments. |
| [context] | [type\_validator\_context](#rtvref.validator.type_validator_context) | Validation context. |
### validator.valPromise : Module
Validator Module: valPromise
**Kind**: static typedef of [validator](#rtvref.validator)
* [.valPromise](#rtvref.validator.valPromise) : Module
* [.type](#rtvref.validator.valPromise.type) : string
* [.config(settings)](#rtvref.validator.valPromise.config)
* [.validate(v, [q])](#rtvref.validator.valPromise.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
#### valPromise.type : string
Type: [PROMISE](#rtvref.types.PROMISE)
**Kind**: static constant of [valPromise](#rtvref.validator.valPromise)
#### valPromise.config(settings)
[Configuration Function](#rtvref.validator.validator_config)
**Kind**: static method of [valPromise](#rtvref.validator.valPromise)
| Param | Type | Description |
| --- | --- | --- |
| settings | [validator\_config\_settings](#rtvref.validator.validator_config_settings) | Configuration settings. |
#### valPromise.validate(v, [q]) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
[Validator](#rtvref.validator.type_validator) for the
[PROMISE](#rtvref.types.PROMISE) type.
**Kind**: static method of [valPromise](#rtvref.validator.valPromise)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - An `RtvSuccess` if valid; `RtvError` if not.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
| [q] | string | Validation qualifier. Defaults to [REQUIRED](#rtvref.qualifiers.REQUIRED). |
### validator.valRegExp : Module
Validator Module: valRegExp
**Kind**: static typedef of [validator](#rtvref.validator)
* [.valRegExp](#rtvref.validator.valRegExp) : Module
* [.type](#rtvref.validator.valRegExp.type) : string
* [.config(settings)](#rtvref.validator.valRegExp.config)
* [.validate(v, [q])](#rtvref.validator.valRegExp.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
#### valRegExp.type : string
Type: [REGEXP](#rtvref.types.REGEXP)
**Kind**: static constant of [valRegExp](#rtvref.validator.valRegExp)
#### valRegExp.config(settings)
[Configuration Function](#rtvref.validator.validator_config)
**Kind**: static method of [valRegExp](#rtvref.validator.valRegExp)
| Param | Type | Description |
| --- | --- | --- |
| settings | [validator\_config\_settings](#rtvref.validator.validator_config_settings) | Configuration settings. |
#### valRegExp.validate(v, [q]) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
[Validator](#rtvref.validator.type_validator) for the
[REGEXP](#rtvref.types.REGEXP) type.
**Kind**: static method of [valRegExp](#rtvref.validator.valRegExp)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - An `RtvSuccess` if valid; `RtvError` if not.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
| [q] | string | Validation qualifier. Defaults to [REQUIRED](#rtvref.qualifiers.REQUIRED). |
### validator.valSafeInt : Module
Validator Module: valSafeInt
**Kind**: static typedef of [validator](#rtvref.validator)
* [.valSafeInt](#rtvref.validator.valSafeInt) : Module
* [.type](#rtvref.validator.valSafeInt.type) : string
* [.config(settings)](#rtvref.validator.valSafeInt.config)
* [.validate(v, [q], [args])](#rtvref.validator.valSafeInt.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
#### valSafeInt.type : string
Type: [SAFE_INT](#rtvref.types.SAFE_INT)
**Kind**: static constant of [valSafeInt](#rtvref.validator.valSafeInt)
#### valSafeInt.config(settings)
[Configuration Function](#rtvref.validator.validator_config)
**Kind**: static method of [valSafeInt](#rtvref.validator.valSafeInt)
| Param | Type | Description |
| --- | --- | --- |
| settings | [validator\_config\_settings](#rtvref.validator.validator_config_settings) | Configuration settings. |
#### valSafeInt.validate(v, [q], [args]) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
[Validator](#rtvref.validator.type_validator) for the
[SAFE_INT](#rtvref.types.SAFE_INT) type.
Determines if a value is a number literal __only__ (i.e. a
[primitive](#rtvref.types.primitives)). It does not validate
`new Number(1)`, which is an object that is a number.
**Kind**: static method of [valSafeInt](#rtvref.validator.valSafeInt)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - An `RtvSuccess` if valid; `RtvError` if not.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
| [q] | string | Validation qualifier. Defaults to [REQUIRED](#rtvref.qualifiers.REQUIRED). |
| [args] | [numeric\_args](#rtvref.types.numeric_args) | Type arguments. |
### validator.valSet : Module
Validator Module: valSet
**Kind**: static typedef of [validator](#rtvref.validator)
* [.valSet](#rtvref.validator.valSet) : Module
* [.type](#rtvref.validator.valSet.type) : string
* [.config(settings)](#rtvref.validator.valSet.config)
* [.validate(v, [q], [args], [context])](#rtvref.validator.valSet.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
#### valSet.type : string
Type: [SET](#rtvref.types.SET)
**Kind**: static constant of [valSet](#rtvref.validator.valSet)
#### valSet.config(settings)
[Configuration Function](#rtvref.validator.validator_config)
**Kind**: static method of [valSet](#rtvref.validator.valSet)
| Param | Type | Description |
| --- | --- | --- |
| settings | [validator\_config\_settings](#rtvref.validator.validator_config_settings) | Configuration settings. |
#### valSet.validate(v, [q], [args], [context]) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
[Validator](#rtvref.validator.type_validator) for the
[SET](#rtvref.types.SET) type.
**Kind**: static method of [valSet](#rtvref.validator.valSet)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - An `RtvSuccess` if valid; `RtvError` if not.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
| [q] | string | Validation qualifier. Defaults to [REQUIRED](#rtvref.qualifiers.REQUIRED). |
| [args] | [collection\_args](#rtvref.types.collection_args) | Type arguments. |
| [context] | [type\_validator\_context](#rtvref.validator.type_validator_context) | Validation context. |
### validator.valString : Module
Validator Module: valString
**Kind**: static typedef of [validator](#rtvref.validator)
* [.valString](#rtvref.validator.valString) : Module
* [.type](#rtvref.validator.valString.type) : string
* [.config(settings)](#rtvref.validator.valString.config)
* [.validate(v, [q], [args])](#rtvref.validator.valString.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
#### valString.type : string
Type: [STRING](#rtvref.types.STRING)
**Kind**: static constant of [valString](#rtvref.validator.valString)
#### valString.config(settings)
[Configuration Function](#rtvref.validator.validator_config)
**Kind**: static method of [valString](#rtvref.validator.valString)
| Param | Type | Description |
| --- | --- | --- |
| settings | [validator\_config\_settings](#rtvref.validator.validator_config_settings) | Configuration settings. |
#### valString.validate(v, [q], [args]) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
[Validator](#rtvref.validator.type_validator) for the
[STRING](#rtvref.types.STRING) type.
Determines if a value is a string literal __only__ (i.e. a
[primitive](#rtvref.types.primitives)). It does not validate
`new String('value')`, which is an object that is a string.
**Kind**: static method of [valString](#rtvref.validator.valString)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - An `RtvSuccess` if valid; `RtvError` if not.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
| [q] | string | Validation qualifier. Defaults to [REQUIRED](#rtvref.qualifiers.REQUIRED). |
| [args] | [STRING\_args](#rtvref.types.STRING_args) | Type arguments. |
### validator.valSymbol : Module
Validator Module: valSymbol
**Kind**: static typedef of [validator](#rtvref.validator)
* [.valSymbol](#rtvref.validator.valSymbol) : Module
* [.type](#rtvref.validator.valSymbol.type) : string
* [.config(settings)](#rtvref.validator.valSymbol.config)
* [.validate(v, [q], [args])](#rtvref.validator.valSymbol.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
#### valSymbol.type : string
Type: [SYMBOL](#rtvref.types.SYMBOL)
**Kind**: static constant of [valSymbol](#rtvref.validator.valSymbol)
#### valSymbol.config(settings)
[Configuration Function](#rtvref.validator.validator_config)
**Kind**: static method of [valSymbol](#rtvref.validator.valSymbol)
| Param | Type | Description |
| --- | --- | --- |
| settings | [validator\_config\_settings](#rtvref.validator.validator_config_settings) | Configuration settings. |
#### valSymbol.validate(v, [q], [args]) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
[Validator](#rtvref.validator.type_validator) for the
[SYMBOL](#rtvref.types.SYMBOL) type.
**Kind**: static method of [valSymbol](#rtvref.validator.valSymbol)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - An `RtvSuccess` if valid; `RtvError` if not.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
| [q] | string | Validation qualifier. Defaults to [REQUIRED](#rtvref.qualifiers.REQUIRED). |
| [args] | [numeric\_args](#rtvref.types.numeric_args) | Type arguments. |
### validator.valWeakMap : Module
Validator Module: valWeakMap
**Kind**: static typedef of [validator](#rtvref.validator)
* [.valWeakMap](#rtvref.validator.valWeakMap) : Module
* [.type](#rtvref.validator.valWeakMap.type) : string
* [.config(settings)](#rtvref.validator.valWeakMap.config)
* [.validate(v, [q])](#rtvref.validator.valWeakMap.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
#### valWeakMap.type : string
Type: [WEAK_MAP](#rtvref.types.WEAK_MAP)
**Kind**: static constant of [valWeakMap](#rtvref.validator.valWeakMap)
#### valWeakMap.config(settings)
[Configuration Function](#rtvref.validator.validator_config)
**Kind**: static method of [valWeakMap](#rtvref.validator.valWeakMap)
| Param | Type | Description |
| --- | --- | --- |
| settings | [validator\_config\_settings](#rtvref.validator.validator_config_settings) | Configuration settings. |
#### valWeakMap.validate(v, [q]) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
[Validator](#rtvref.validator.type_validator) for the
[WEAK_MAP](#rtvref.types.WEAK_MAP) type.
**Kind**: static method of [valWeakMap](#rtvref.validator.valWeakMap)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - An `RtvSuccess` if valid; `RtvError` if not.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
| [q] | string | Validation qualifier. Defaults to [REQUIRED](#rtvref.qualifiers.REQUIRED). |
### validator.valWeakSet : Module
Validator Module: valWeakSet
**Kind**: static typedef of [validator](#rtvref.validator)
* [.valWeakSet](#rtvref.validator.valWeakSet) : Module
* [.type](#rtvref.validator.valWeakSet.type) : string
* [.config(settings)](#rtvref.validator.valWeakSet.config)
* [.validate(v, [q])](#rtvref.validator.valWeakSet.validate) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
#### valWeakSet.type : string
Type: [WEAK_SET](#rtvref.types.WEAK_SET)
**Kind**: static constant of [valWeakSet](#rtvref.validator.valWeakSet)
#### valWeakSet.config(settings)
[Configuration Function](#rtvref.validator.validator_config)
**Kind**: static method of [valWeakSet](#rtvref.validator.valWeakSet)
| Param | Type | Description |
| --- | --- | --- |
| settings | [validator\_config\_settings](#rtvref.validator.validator_config_settings) | Configuration settings. |
#### valWeakSet.validate(v, [q]) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
[Validator](#rtvref.validator.type_validator) for the
[WEAK_SET](#rtvref.types.WEAK_SET) type.
**Kind**: static method of [valWeakSet](#rtvref.validator.valWeakSet)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - An `RtvSuccess` if valid; `RtvError` if not.
| Param | Type | Description |
| --- | --- | --- |
| v | \* | Value to validate. |
| [q] | string | Validation qualifier. Defaults to [REQUIRED](#rtvref.qualifiers.REQUIRED). |
# rtv : object
object
* [.types](#rtv.types) : [Enumeration](#rtvref.Enumeration)
* [.qualifiers](#rtv.qualifiers) : [Enumeration](#rtvref.Enumeration)
* [.version](#rtv.version) : string
* [.config](#rtv.config) : object
* [.enabled](#rtv.config.enabled) : boolean
* [.isTypeset()](#rtv.isTypeset)
* [.fullyQualify()](#rtv.fullyQualify)
* [.RtvSuccess()](#rtv.RtvSuccess)
* [.RtvError()](#rtv.RtvError)
* [.check(value, typeset, [options])](#rtv.check) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
* [.verify(value, typeset, [options])](#rtv.verify) ⇒ [RtvSuccess](#rtvref.RtvSuccess)
## rtv.types : [Enumeration](#rtvref.Enumeration)
Enumeration of [types](#rtvref.types.types).
__For convenience, each type is also available directly from this module__,
e.g. `STRING`, `FINITE`, etc.
The Enumeration can be used to perform additional validations (e.g.
`types.verify('foo')` would throw because "foo" is not a valid type),
however whether the type is referenced as `STRING` or `types.STRING`
makes no difference to typeset validation.
**Kind**: static property of [rtv](#rtv)
**Read only**: true
## rtv.qualifiers : [Enumeration](#rtvref.Enumeration)
Enumeration of [qualifiers](#rtvref.qualifiers.qualifiers).
__For convenience, each qualifier is also available directly from this module__,
e.g. `EXPECTED`, `OPTIONAL`, etc.
The Enumeration can be used to perform additional validations (e.g.
`qualifiers.verify('x')` would throw because "x" is not a valid qualifier),
however whether the qualifier is referenced as `EXPECTED` or
`qualifiers.EXPECTED`` makes no difference to typeset validation.
**Kind**: static property of [rtv](#rtv)
**Read only**: true
## rtv.version : string
Library version.
**Kind**: static property of [rtv](#rtv)
**Read only**: true
## rtv.config : object
rtv](#rtv)
### config.enabled : boolean
Globally enables or disables [verify](#rtv.verify) and [check](#rtv.check). When set
to `false`, these methods are no-ops and always return success.
Use this to enable code optimization when building source with a bundler that supports
_tree shaking_, like [Rollup](https://rollupjs.org/) or
[Webpack](https://webpack.js.org/).
The following plugins can redefine the statement `rtv.config.enabled`
as `false` prior to code optimizations that remove unreachable code:
- Rollup: [rollup-plugin-replace](https://github.com/rollup/rollup-plugin-replace)
- Webpack: [DefinePlugin](https://webpack.js.org/plugins/define-plugin/)
...
if (rtv.config.enabled) {
rtv.verify(jsonResult, expectedShape);
}
rtv.config.enabled && rtv.verify(jsonResult, expectedShape); // a bit shorter
...
const replacePlugin = require('rollup-plugin-replace');
module.exports = {
...
plugins: [
// invoke this plugin _before_ any other plugins
replacePlugin({
'rtv.config.enabled': JSON.stringify(false)
}),
...
]
};
...
DO_TYPE_CHECKS && rtv.verify(...);
const replacePlugin = require('rollup-plugin-replace');
module.exports = {
...
plugins: [
// invoke this plugin _before_ any other plugins
replacePlugin({
DO_TYPE_CHECKS: JSON.stringify(false)
}),
...
]
};
config](#rtv.config)
**See**
- [check](#rtv.check)
- [verify](#rtv.verify)
## rtv.isTypeset()
Determines if a value is a typeset.
**Kind**: static method of [rtv](#rtv)
**See**: [isTypeset](#rtvref.validation.isTypeset)
## rtv.fullyQualify()
Fully-qualifies a given typeset.
**Kind**: static method of [rtv](#rtv)
**See**: [fullyQualify](#rtvref.impl.fullyQualify)
## rtv.RtvSuccess()
Reference to the [RtvSuccess](#rtvref.RtvSuccess) class/constructor.
This can be used to determine, for example, if the result of [rtv.check()](#rtv.check)
is the success indicator: `if (result instanceof rtv.RtvSuccess) ...` Note that both
[RtvSuccess](#rtvref.RtvSuccess) and [RtvError](#rtvref.RtvError) have a
`valid: boolean` property which you can also use to easily test for success or failure.
**Kind**: static method of [rtv](#rtv)
**See**: [RtvSuccess](#rtvref.RtvSuccess)
## rtv.RtvError()
Reference to the [RtvError](#rtvref.RtvError) class/constructor.
This is useful if you need to determine whether an `Error` is an `RtvError`
using the `instanceof` operator: `if (err instanceof rtv.RtvError) ...`
**Kind**: static method of [rtv](#rtv)
**See**: [RtvError](#rtvref.RtvError)
## rtv.check(value, typeset, [options]) ⇒ [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError)
Checks a value against a typeset for compliance.
**Kind**: static method of [rtv](#rtv)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) \| [RtvError](#rtvref.RtvError) - Success indicator if the
`value` is compliant to the `shape`; `RtvError` if not. __Unlike
[verify()](#rtv.verify), an exception is not thrown__ if the
`value` is non-compliant.
Since both [RtvSuccess](#rtvref.RtvSuccess) (returned when
the check succeeds) as well as [RtvError](#rtvref.RtvError) (returned
when the check fails) have a `valid: boolean` property in common, it's
easy to test for success/failure like this:
`if (rtv.check(2, rtv.FINITE).valid) {...}`.
__NOTE:__ This method always returns a success indicator if RTV.js is currently
[disabled](#rtv.config.enabled).
**Throws**:
- Error If `typeset` is not a valid typeset.
**See**
- [verify](#rtv.verify)
- [enabled](#rtv.config.enabled)
- [types](#rtvref.types)
- [shape_descriptor](#rtvref.types.shape_descriptor)
| Param | Type | Description |
| --- | --- | --- |
| value | \* | Value to check. |
| typeset | [typeset](#rtvref.types.typeset) | Expected shape of (or typeset describing) the `value`. A shape is a kind of typeset. Normally, this is a [shape descriptor](#rtvref.types.shape_descriptor). |
| [options] | [type\_validator\_context\_options](#rtvref.validator.type_validator_context_options) | Configuration options. |
## rtv.verify(value, typeset, [options]) ⇒ [RtvSuccess](#rtvref.RtvSuccess)
__Requires__ a value to be compliant to a shape.
__NOTE:__ This method always returns a success indicator if RTV.js is currently
[disabled](#rtv.config.enabled).
**Kind**: static method of [rtv](#rtv)
**Returns**: [RtvSuccess](#rtvref.RtvSuccess) - Success indicator IIF the `value` is compliant
to the `shape`. Otherwise, an [RtvError](#rtvref.RtvError) __is thrown__.
**Throws**:
- [RtvError](#rtvref.RtvError) If the `value` is not compliant to the `shape`.
- Error If `typeset` is not a valid typeset.
**See**
- [check](#rtv.check)
- [enabled](#rtv.config.enabled)
- [types](#rtvref.types)
- [shape_descriptor](#rtvref.types.shape_descriptor)
| Param | Type | Description |
| --- | --- | --- |
| value | \* | Value to check. |
| typeset | [typeset](#rtvref.types.typeset) | Expected shape of (or typeset describing) the `value`. A shape is a kind of typeset. Normally, this is a [shape descriptor](#rtvref.types.shape_descriptor). |
| [options] | [type\_validator\_context\_options](#rtvref.validator.type_validator_context_options) | Configuration options. |