arrayOf

src/sync/arrayOf.js

arrayOf(t: Type<T>): ArrayOfType<T>

Parameters

t (Type<T>)

Returns

ArrayOfType<T>

ArrayOfType

src/sync/Type.js

new ArrayOfType()

Extends Type

Instance Members

▸ constructor(t, parse)

src/sync/Type.js

constructor(t: Type<T>, parse: function (value: any): Array<T>)

Parameters

t (Type<T>)

parse (function (value: any): Array<T>)

▸ itemType

src/sync/Type.js

itemType

Type: Type<T>

arrayType

src/sync/arrayType.js

arrayType

Type: VType<Array<any>>

asyncArrayOf

src/async/asyncArrayOf.js

asyncArrayOf(t: AsyncType<T>): AsyncArrayOfType<T>

Parameters

t (AsyncType<T>)

Returns

AsyncArrayOfType<T>

AsyncArrayOfType

src/async/asyncArrayOf.js

new AsyncArrayOfType()

Extends AsyncType

Instance Members

▸ constructor(t, parse)

src/async/asyncArrayOf.js

constructor(t: AsyncType<T>, parse: function (value: any): (Array<T> | Promise<Array<T>>))

Parameters

t (AsyncType<T>)

parse (function (value: any): (Array<T> | Promise<Array<T>>))

▸ innerType

src/async/asyncArrayOf.js

innerType

Type: AsyncType<T>

AsyncChainType

src/async/AsyncType.js

new AsyncChainType()

Extends AsyncType

Instance Members

▸ constructor(left, right)

src/async/AsyncType.js

constructor(left: AsyncType<any>, right: AsyncType<T>)

Parameters

left (AsyncType<any>)

right (AsyncType<T>)

▸ left

src/async/AsyncType.js

left

Type: AsyncType<any>

▸ right

src/async/AsyncType.js

right

Type: AsyncType<T>

AsyncComposeLeftType

src/async/AsyncType.js

new AsyncComposeLeftType()

Extends AsyncType

Instance Members

▸ constructor(left, right)

src/async/AsyncType.js

constructor(left: AsyncType<T>, right: function (v: T): Promise<T2>)

Parameters

left (AsyncType<T>)

right (function (v: T): Promise<T2>)

▸ left

src/async/AsyncType.js

left

Type: AsyncType<T>

▸ right

src/async/AsyncType.js

right

Type: function (v: T): Promise<T2>

asyncExpress

src/async/asyncExpress.js

asyncExpress

Static Members

▸ endpoint

src/async/asyncExpress.js

endpoint

▸ endpoint

src/async/asyncExpress.js

endpoint

▸ middleware

src/async/asyncExpress.js

middleware

▸ middleware

src/async/asyncExpress.js

middleware

▸ requestMapping

src/async/asyncExpress.js

requestMapping

▸ requestMapping

src/async/asyncExpress.js

requestMapping

asyncExpress

src/async/asyncExpress.js

asyncExpress

Static Members

▸ endpoint

src/async/asyncExpress.js

endpoint

▸ endpoint

src/async/asyncExpress.js

endpoint

▸ middleware

src/async/asyncExpress.js

middleware

▸ middleware

src/async/asyncExpress.js

middleware

▸ requestMapping

src/async/asyncExpress.js

requestMapping

▸ requestMapping

src/async/asyncExpress.js

requestMapping

asyncIntersection

src/async/asyncIntersection.js

asyncIntersection(a: AsyncType<A>, b: AsyncType<B>): AsyncIntersectionType<A, B>

Parameters

a (AsyncType<A>)

b (AsyncType<B>)

Returns

AsyncIntersectionType<A, B>

AsyncIntersectionType

src/async/AsyncType.js

new AsyncIntersectionType()

Extends AsyncType

Instance Members

▸ constructor(a, b, parse)

src/async/AsyncType.js

constructor(a: AsyncType<A>, b: AsyncType<B>, parse: function (value: any): Promise<any>)

Parameters

a (AsyncType<A>)

b (AsyncType<B>)

parse (function (value: any): Promise<any>)

▸ typeA

src/async/AsyncType.js

typeA

Type: AsyncType<A>

▸ typeB

src/async/AsyncType.js

typeB

Type: AsyncType<B>

asyncMapping

src/async/asyncMapping.js

asyncMapping(keys: AsyncType<K>, values: AsyncType<V>): AsyncMappingType<K, V>

Parameters

keys (AsyncType<K>)

values (AsyncType<V>)

Returns

AsyncMappingType<K, V>

AsyncMappingType

src/async/asyncMapping.js

new AsyncMappingType()

Extends AsyncType

Instance Members

▸ constructor(keys, values, parse)

src/async/asyncMapping.js

constructor(keys: AsyncType<K>, values: AsyncType<V>, parse: function (value: any): Promise<{}>)

Parameters

keys (AsyncType<K>)

values (AsyncType<V>)

parse (function (value: any): Promise<{}>)

▸ keys

src/async/asyncMapping.js

keys

Type: AsyncType<K>

▸ values

src/async/asyncMapping.js

values

Type: AsyncType<V>

asyncObject

src/async/asyncObject.js

asyncObject(s: S): AsyncObjectType<S, $ObjMap<S, function (v: AsyncType<F>): F>>

Parameters

s (S)

Returns

AsyncObjectType<S, $ObjMap<S, function (v: AsyncType<F>): F>>

asyncObjectExact

src/async/asyncObjectExact.js

asyncObjectExact(s: S): AsyncObjectExactType<S, $Exact<$ObjMap<S, function (v: AsyncType<F>): F>>>

Parameters

s (S)

Returns

AsyncObjectExactType<S, $Exact<$ObjMap<S, function (v: AsyncType<F>): F>>>

AsyncObjectExactType

src/async/asyncObjectExact.js

new AsyncObjectExactType()

Extends AsyncType

Instance Members

▸ constructor(schema, parse)

src/async/asyncObjectExact.js

constructor(schema: S, parse: function (value: any): (T | Promise<T>))

Parameters

schema (S)

parse (function (value: any): (T | Promise<T>))

▸ schema

src/async/asyncObjectExact.js

schema

Type: S

AsyncObjectType

src/async/asyncObject.js

new AsyncObjectType()

Extends AsyncType

Instance Members

▸ constructor(schema, parse)

src/async/asyncObject.js

constructor(schema: S, parse: function (value: any): Promise<T>)

Parameters

schema (S)

parse (function (value: any): Promise<T>)

▸ schema

src/async/asyncObject.js

schema

Type: S

asyncOptional

src/async/asyncOptional.js

asyncOptional(t: AsyncType<T>): AsyncOptionalType<T>

Parameters

t (AsyncType<T>)

Returns

AsyncOptionalType<T>

AsyncOptionalType

src/async/AsyncType.js

new AsyncOptionalType()

Extends AsyncType

Instance Members

▸ constructor(t, validate)

src/async/AsyncType.js

constructor(t: AsyncType<T>, validate: function (value: any): Promise<T?>)

Parameters

t (AsyncType<T>)

validate (function (value: any): Promise<T?>)

▸ innerType

src/async/AsyncType.js

innerType

Type: AsyncType<T>

AsyncRefinedType

src/async/AsyncType.js

new AsyncRefinedType()

Extends AsyncType

Instance Members

▸ base

src/async/AsyncType.js

base

Type: AsyncType<T>

▸ constructor(base, f)

src/async/AsyncType.js

constructor(base: AsyncType<T>, f: function (v: any): (T | Promise<T>))

Parameters

base (AsyncType<T>)

f (function (v: any): (T | Promise<T>))

▸ revalidate()

src/async/AsyncType.js

revalidate(): AsyncType<T>

Returns

AsyncType<T>

asyncReturns

src/async/asyncReturns.js

asyncReturns(t: AsyncType<R>): function (f: function (): Promise<R>): function (): Promise<R>

Parameters

t (AsyncType<R>)

Returns

function (f: function (): Promise<R>): function (): Promise<R>

asyncTakes

src/async/asyncTakes.js

asyncTakes(AsyncTypes: ...Array<AsyncType<any>>): function (f: function (): Promise<R>): function (): Promise<R>

Parameters

AsyncTypes (...Array<AsyncType<any>>)

Returns

function (f: function (): Promise<R>): function (): Promise<R>

asyncTuple

src/async/asyncTuple.js

asyncTuple(s: S): AsyncTupleType<$TupleMap<S, function (v: AsyncType<T>): T>>

Parameters

s (S)

Returns

AsyncTupleType<$TupleMap<S, function (v: AsyncType<T>): T>>

AsyncTupleType

src/async/asyncTuple.js

new AsyncTupleType()

Extends AsyncType

Instance Members

▸ constructor(schema, parse)

src/async/asyncTuple.js

constructor(schema: Array<AsyncType<any>>, parse: function (value: any): (T | Promise<T>))

Parameters

schema (Array<AsyncType<any>>)

parse (function (value: any): (T | Promise<T>))

▸ schema

src/async/asyncTuple.js

schema

Type: Array<AsyncType<any>>

AsyncType

src/async/AsyncType.js

new AsyncType()

Instance Members

▸ and(t2)

src/async/AsyncType.js

and(t2: AsyncType<T2>): AsyncIntersectionType<T, T2>

Parameters

t2 (AsyncType<T2>)

Returns

AsyncIntersectionType<T, T2>

▸ chain(t2)

src/async/AsyncType.js

chain(t2: AsyncType<T2>): AsyncChainType<T2>

Parameters

t2 (AsyncType<T2>)

Returns

AsyncChainType<T2>

▸ compose(f)

src/async/AsyncType.js

compose(f: function (v: T): (T2 | Promise<T2>)): AsyncComposeLeftType<T, T2>

Parameters

f (function (v: T): (T2 | Promise<T2>))

Returns

AsyncComposeLeftType<T, T2>

▸ constructor(name, parse)

src/async/AsyncType.js

constructor(name: string, parse: function (value: any): (T | Promise<T>))

Parameters

name (string)

parse (function (value: any): (T | Promise<T>))

▸ name

src/async/AsyncType.js

name

Type: string

▸ optional()

src/async/AsyncType.js

optional(): AsyncOptionalType<T>

Returns

AsyncOptionalType<T>

▸ or(t2)

src/async/AsyncType.js

or(t2: AsyncType<T2>): AsyncUnionType<T, T2>

Parameters

t2 (AsyncType<T2>)

Returns

AsyncUnionType<T, T2>

▸ parse

src/async/AsyncType.js

parse

Type: function (value: any): Promise<T>

▸ refine(refinement)

src/async/AsyncType.js

refine(refinement: function (v: T, error: function (e: string): ValidationError): (T | Promise<T>)): AsyncRefinedType<T>

Parameters

refinement (function (v: T, error: function (e: string): ValidationError): (T | Promise<T>))

Returns

AsyncRefinedType<T>

▸ to(transformation)

src/async/AsyncType.js

to(transformation: function (v: T, error: function (e: string): ValidationError): (T2 | Promise<T2>)): AsyncType<T2>

Parameters

transformation (function (v: T, error: function (e: string): ValidationError): (T2 | Promise<T2>))

Returns

AsyncType<T2>

▸ toJSON()

src/async/AsyncType.js

toJSON()

▸ type

src/async/AsyncType.js

type

Type: T

asyncUnion

src/async/asyncUnion.js

asyncUnion(a: AsyncType<A>, b: AsyncType<B>): AsyncUnionType<A, B>

Parameters

a (AsyncType<A>)

b (AsyncType<B>)

Returns

AsyncUnionType<A, B>

AsyncUnionType

src/async/AsyncType.js

new AsyncUnionType()

Extends AsyncType

Instance Members

▸ constructor(a, b, validate)

src/async/AsyncType.js

constructor(a: AsyncType<A>, b: AsyncType<B>, validate: function (value: any): Promise<(A | B)>)

Parameters

a (AsyncType<A>)

b (AsyncType<B>)

validate (function (value: any): Promise<(A | B)>)

▸ typeA

src/async/AsyncType.js

typeA

Type: AsyncType<A>

▸ typeB

src/async/AsyncType.js

typeB

Type: AsyncType<B>

asyncVarrayOf

src/async/asyncVarrayOf.js

asyncVarrayOf(t: AsyncVType<T>): AsyncVArrayOfType<T>

Parameters

t (AsyncVType<T>)

Returns

AsyncVArrayOfType<T>

AsyncVArrayOfType

src/async/asyncVarrayOf.js

new AsyncVArrayOfType()

Extends AsyncVType

Instance Members

▸ constructor(t, validate)

src/async/asyncVarrayOf.js

constructor(t: AsyncVType<T>, validate: function (value: any): (Array<T> | Promise<Array<T>>))

Parameters

t (AsyncVType<T>)

validate (function (value: any): (Array<T> | Promise<Array<T>>))

▸ innerType

src/async/asyncVarrayOf.js

innerType

Type: AsyncVType<T>

asyncVintersection

src/async/asyncVintersection.js

asyncVintersection(a: AsyncVType<A>, b: AsyncVType<B>): AsyncVIntersectionType<A, B>

Parameters

a (AsyncVType<A>)

b (AsyncVType<B>)

Returns

AsyncVIntersectionType<A, B>

AsyncVIntersectionType

src/async/AsyncVType.js

new AsyncVIntersectionType()

Extends AsyncVType

Instance Members

▸ constructor(a, b, validate)

src/async/AsyncVType.js

constructor(a: AsyncVType<A>, b: AsyncVType<B>, validate: function (value: any): Promise<any>)

Parameters

a (AsyncVType<A>)

b (AsyncVType<B>)

validate (function (value: any): Promise<any>)

▸ typeA

src/async/AsyncVType.js

typeA

Type: AsyncVType<A>

▸ typeB

src/async/AsyncVType.js

typeB

Type: AsyncVType<B>

asyncVmapping

src/async/asyncVmapping.js

asyncVmapping(keys: AsyncVType<K>, values: AsyncVType<V>): AsyncVMappingType<K, V>

Parameters

keys (AsyncVType<K>)

values (AsyncVType<V>)

Returns

AsyncVMappingType<K, V>

AsyncVMappingType

src/async/asyncVmapping.js

new AsyncVMappingType()

Extends AsyncVType

Instance Members

▸ constructor(keys, values, validate)

src/async/asyncVmapping.js

constructor(keys: AsyncVType<K>, values: AsyncVType<V>, validate: function (value: any): Promise<{}>)

Parameters

keys (AsyncVType<K>)

values (AsyncVType<V>)

validate (function (value: any): Promise<{}>)

▸ keys

src/async/asyncVmapping.js

keys

Type: AsyncVType<K>

▸ values

src/async/asyncVmapping.js

values

Type: AsyncVType<V>

asyncVobject

src/async/asyncVobject.js

asyncVobject(s: S): AsyncVObjectType<S, $ObjMap<S, function (v: AsyncVType<F>): F>>

Parameters

s (S)

Returns

AsyncVObjectType<S, $ObjMap<S, function (v: AsyncVType<F>): F>>

asyncVobjectExact

src/async/asyncVobjectExact.js

asyncVobjectExact(s: S): AsyncVObjectExactType<S, $Exact<$ObjMap<S, function (v: AsyncVType<F>): F>>>

Parameters

s (S)

Returns

AsyncVObjectExactType<S, $Exact<$ObjMap<S, function (v: AsyncVType<F>): F>>>

AsyncVObjectExactType

src/async/asyncVobjectExact.js

new AsyncVObjectExactType()

Extends AsyncVType

Instance Members

▸ constructor(schema, validate)

src/async/asyncVobjectExact.js

constructor(schema: S, validate: function (value: any): Promise<T>)

Parameters

schema (S)

validate (function (value: any): Promise<T>)

▸ schema

src/async/asyncVobjectExact.js

schema

Type: S

AsyncVObjectType

src/async/asyncVobject.js

new AsyncVObjectType()

Extends AsyncVType

Instance Members

▸ constructor(schema, validate)

src/async/asyncVobject.js

constructor(schema: S, validate: function (value: any): Promise<T>)

Parameters

schema (S)

validate (function (value: any): Promise<T>)

▸ schema

src/async/asyncVobject.js

schema

Type: S

asyncVoptional

src/async/asyncVoptional.js

asyncVoptional(t: AsyncVType<T>): AsyncVOptionalType<T>

Parameters

t (AsyncVType<T>)

Returns

AsyncVOptionalType<T>

AsyncVOptionalType

src/async/AsyncVType.js

new AsyncVOptionalType()

Extends AsyncVType

Instance Members

▸ constructor(t, validate)

src/async/AsyncVType.js

constructor(t: AsyncVType<T>, validate: function (value: any): Promise<T?>)

Parameters

t (AsyncVType<T>)

validate (function (value: any): Promise<T?>)

▸ innerType

src/async/AsyncVType.js

innerType

Type: AsyncVType<T>

AsyncVRefinedType

src/async/AsyncVType.js

new AsyncVRefinedType()

Extends AsyncVType

Instance Members

▸ base

src/async/AsyncVType.js

base

Type: AsyncVType<T>

▸ constructor(base, f)

src/async/AsyncVType.js

constructor(base: AsyncVType<T>, f: function (v: any): (T | Promise<T>))

Parameters

base (AsyncVType<T>)

f (function (v: any): (T | Promise<T>))

▸ revalidate()

src/async/AsyncVType.js

revalidate(): AsyncVType<T>

Returns

AsyncVType<T>

asyncVreturns

src/async/asyncReturns.js

asyncVreturns(t: AsyncVType<R>): function (f: function (): Promise<R>): function (): Promise<R>

Parameters

t (AsyncVType<R>)

Returns

function (f: function (): Promise<R>): function (): Promise<R>

asyncVtakes

src/async/asyncTakes.js

asyncVtakes(AsyncTypes: ...Array<AsyncVType<any>>): function (f: function (): Promise<R>): function (): Promise<R>

Parameters

AsyncTypes (...Array<AsyncVType<any>>)

Returns

function (f: function (): Promise<R>): function (): Promise<R>

asyncVtuple

src/async/asyncTuple.js

asyncVtuple(s: S): AsyncVTupleType<$TupleMap<S, function (v: AsyncType<T>): T>>

Parameters

s (S)

Returns

AsyncVTupleType<$TupleMap<S, function (v: AsyncType<T>): T>>

AsyncVTupleType

src/async/asyncTuple.js

new AsyncVTupleType()

Extends AsyncVType

Instance Members

▸ constructor(schema, parse)

src/async/asyncTuple.js

constructor(schema: Array<AsyncVType<any>>, parse: function (value: any): (T | Promise<T>))

Parameters

schema (Array<AsyncVType<any>>)

parse (function (value: any): (T | Promise<T>))

▸ schema

src/async/asyncTuple.js

schema

Type: Array<AsyncVType<any>>

AsyncVType

src/async/AsyncVType.js

new AsyncVType()

Extends AsyncType

Instance Members

▸ constructor(name, validate)

src/async/AsyncVType.js

constructor(name: string, validate: function (value: any): (T | Promise<T>))

Parameters

name (string)

validate (function (value: any): (T | Promise<T>))

▸ validate

src/async/AsyncVType.js

validate

Type: function (value: any): Promise<T>

▸ Vand(t2)

src/async/AsyncVType.js

Vand(t2: AsyncVType<T2>): AsyncVIntersectionType<T, T2>

Parameters

t2 (AsyncVType<T2>)

Returns

AsyncVIntersectionType<T, T2>

▸ Voptional()

src/async/AsyncVType.js

Voptional(): AsyncVOptionalType<T>

Returns

AsyncVOptionalType<T>

▸ Vor(t2)

src/async/AsyncVType.js

Vor(t2: AsyncVType<T2>): AsyncVUnionType<T, T2>

Parameters

t2 (AsyncVType<T2>)

Returns

AsyncVUnionType<T, T2>

▸ Vrefine(refinement)

src/async/AsyncVType.js

Vrefine(refinement: function (v: T, error: function (e: string): ValidationError): (T | Promise<T>)): AsyncVRefinedType<T>

Parameters

refinement (function (v: T, error: function (e: string): ValidationError): (T | Promise<T>))

Returns

AsyncVRefinedType<T>

asyncVunion

src/async/asyncVunion.js

asyncVunion(a: AsyncVType<A>, b: AsyncVType<B>): AsyncVUnionType<A, B>

Parameters

a (AsyncVType<A>)

b (AsyncVType<B>)

Returns

AsyncVUnionType<A, B>

AsyncVUnionType

src/async/AsyncVType.js

new AsyncVUnionType()

Extends AsyncVType

Instance Members

▸ constructor(a, b, validate)

src/async/AsyncVType.js

constructor(a: AsyncVType<A>, b: AsyncVType<B>, validate: function (value: any): Promise<(A | B)>)

Parameters

a (AsyncVType<A>)

b (AsyncVType<B>)

validate (function (value: any): Promise<(A | B)>)

▸ typeA

src/async/AsyncVType.js

typeA

Type: AsyncVType<A>

▸ typeB

src/async/AsyncVType.js

typeB

Type: AsyncVType<B>

boolean

src/sync/base.js

boolean

Type: VType<boolean>

ChainType

src/sync/Type.js

new ChainType()

Extends Type

Instance Members

▸ constructor(left, right)

src/sync/Type.js

constructor(left: Type<any>, right: Type<T>)

Parameters

left (Type<any>)

right (Type<T>)

▸ left

src/sync/Type.js

left

Type: Type<any>

▸ right

src/sync/Type.js

right

Type: Type<T>

classOf

src/sync/base.js

classOf(c: Class<T>): ClassOfType<Class<T>>

Parameters

c (Class<T>)

Returns

ClassOfType<Class<T>>

ClassOfType

src/sync/VType.js

new ClassOfType()

Extends VType

Instance Members

▸ class

src/sync/VType.js

class

Type: T

▸ constructor(c, validate)

src/sync/VType.js

constructor(c: T, validate: function (value: any): T)

Parameters

c (T)

validate (function (value: any): T)

composeLeft

src/sync/composeLeft.js

composeLeft(a: Type<T1>, b: function (v: T1): T2): ComposeLeftType<T1, T2>

Parameters

a (Type<T1>)

b (function (v: T1): T2)

Returns

ComposeLeftType<T1, T2>

ComposeLeftType

src/sync/Type.js

new ComposeLeftType()

Extends Type

Instance Members

▸ constructor(left, right)

src/sync/Type.js

constructor(left: Type<T>, right: function (v: T): T2)

Parameters

left (Type<T>)

right (function (v: T): T2)

▸ left

src/sync/Type.js

left

Type: Type<T>

▸ right

src/sync/Type.js

right

Type: function (v: T): T2

composeRight

src/sync/composeRight.js

composeRight(a: function (v: T1): T2, b: Type<T1>): ComposeRightType<T1, T2>

Parameters

a (function (v: T1): T2)

b (Type<T1>)

Returns

ComposeRightType<T1, T2>

ComposeRightType

src/sync/Type.js

new ComposeRightType()

Extends Type

Instance Members

▸ constructor(left, right)

src/sync/Type.js

constructor(left: function (v: T): T2, right: Type<T>)

Parameters

left (function (v: T): T2)

right (Type<T>)

▸ left

src/sync/Type.js

left

Type: function (v: T): T2

▸ right

src/sync/Type.js

right

Type: Type<T>

empty

src/sync/base.js

empty

Type: VType<(void | null)>

Errors

src/sync/ValidationError.js

Errors

Type: {}

express

src/sync/express.js

express

Static Members

▸ endpoint

src/sync/express.js

endpoint

▸ endpoint

src/sync/express.js

endpoint

▸ middleware

src/sync/express.js

middleware

▸ middleware

src/sync/express.js

middleware

▸ requestMapping

src/sync/express.js

requestMapping

▸ requestMapping

src/sync/express.js

requestMapping

express

src/sync/express.js

express

Static Members

▸ endpoint

src/sync/express.js

endpoint

▸ endpoint

src/sync/express.js

endpoint

▸ middleware

src/sync/express.js

middleware

▸ middleware

src/sync/express.js

middleware

▸ requestMapping

src/sync/express.js

requestMapping

▸ requestMapping

src/sync/express.js

requestMapping

falsy

src/sync/base.js

falsy

Type: Type<false>

functionType

src/sync/base.js

functionType

Type: VType<Function>

instanceOf

src/sync/base.js

instanceOf(c: Class<T>): InstanceOfType<T>

Parameters

c (Class<T>)

Returns

InstanceOfType<T>

InstanceOfType

src/sync/VType.js

new InstanceOfType()

Extends VType

Instance Members

▸ class

src/sync/VType.js

class

Type: Class<T>

▸ constructor(c, validate)

src/sync/VType.js

constructor(c: Class<T>, validate: function (value: any): T)

Parameters

c (Class<T>)

validate (function (value: any): T)

intersection

src/sync/intersection.js

intersection(a: Type<A>, b: Type<B>): IntersectionType<A, B>

Parameters

a (Type<A>)

b (Type<B>)

Returns

IntersectionType<A, B>

IntersectionType

src/sync/Type.js

new IntersectionType()

Extends Type

Instance Members

▸ constructor(a, b, parse)

src/sync/Type.js

constructor(a: Type<A>, b: Type<B>, parse: function (value: any))

Parameters

a (Type<A>)

b (Type<B>)

parse (function (value: any))

▸ typeA

src/sync/Type.js

typeA

Type: Type<A>

▸ typeB

src/sync/Type.js

typeB

Type: Type<B>

isAny

src/sync/base.js

isAny

Type: VType<any>

isMixed

src/sync/base.js

isMixed

Type: VType<any>

isNull

src/sync/base.js

isNull

Type: VType<null>

isUndefined

src/sync/base.js

isUndefined

Type: VType<void>

literal

src/sync/base.js

literal(value: T): LiteralType<T>

Parameters

value (T)

Returns

LiteralType<T>

LiteralType

src/sync/VType.js

new LiteralType()

Extends VType

Instance Members

▸ constructor(t, validate)

src/sync/VType.js

constructor(t: T, validate: function (value: any): T)

Parameters

t (T)

validate (function (value: any): T)

▸ value

src/sync/VType.js

value

Type: T

mapping

src/sync/mapping.js

mapping(keys: Type<K>, values: Type<V>): MappingType<K, V>

Parameters

keys (Type<K>)

values (Type<V>)

Returns

MappingType<K, V>

MappingType

src/sync/Type.js

new MappingType()

Extends Type

Instance Members

▸ constructor(keys, values, parse)

src/sync/Type.js

constructor(keys: Type<K>, values: Type<V>, parse: function (value: any): {})

Parameters

keys (Type<K>)

values (Type<V>)

parse (function (value: any): {})

▸ keys

src/sync/Type.js

keys

Type: Type<K>

▸ values

src/sync/Type.js

values

Type: Type<V>

match

src/sync/match.js

match(patterns: ...any)

Parameters

patterns (...any)

noProperty

src/sync/base.js

noProperty

Type: VType<void>

number

src/sync/base.js

number

Type: VType<number>

object

src/sync/object.js

object(s: S): ObjectType<S, $ObjMap<S, function (v: Type<F>): F>>

Parameters

s (S)

Returns

ObjectType<S, $ObjMap<S, function (v: Type<F>): F>>

objectExact

src/sync/objectExact.js

objectExact(s: S): ObjectExactType<S, $Exact<$ObjMap<S, function (v: Type<F>): F>>>

Parameters

s (S)

Returns

ObjectExactType<S, $Exact<$ObjMap<S, function (v: Type<F>): F>>>

ObjectExactType

src/sync/Type.js

new ObjectExactType()

Extends Type

Instance Members

▸ constructor(schema, parse)

src/sync/Type.js

constructor(schema: S, parse: function (value: any): T)

Parameters

schema (S)

parse (function (value: any): T)

▸ schema

src/sync/Type.js

schema

Type: S

ObjectType

src/sync/Type.js

new ObjectType()

Extends Type

Instance Members

▸ constructor(schema, parse)

src/sync/Type.js

constructor(schema: S, parse: function (value: any): T)

Parameters

schema (S)

parse (function (value: any): T)

▸ schema

src/sync/Type.js

schema

Type: S

objectType

src/sync/base.js

objectType

Type: VType<Object>

optional

src/sync/optional.js

optional(t: Type<T>): OptionalType<T>

Parameters

t (Type<T>)

Returns

OptionalType<T>

OptionalType

src/sync/Type.js

new OptionalType()

Extends Type

Instance Members

▸ constructor(t, validate)

src/sync/Type.js

constructor(t: Type<T>, validate: function (value: any): T?)

Parameters

t (Type<T>)

validate (function (value: any): T?)

▸ innerType

src/sync/Type.js

innerType

Type: Type<T>

RefinedType

src/sync/Type.js

new RefinedType()

Extends Type

Instance Members

▸ base

src/sync/Type.js

base

Type: Type<T>

▸ constructor(base, f)

src/sync/Type.js

constructor(base: Type<T>, f: function (v: any): T)

Parameters

base (Type<T>)

f (function (v: any): T)

▸ revalidate()

src/sync/Type.js

revalidate(): Type<T>

Returns

Type<T>

returns

src/sync/returns.js

returns(t: Type<R>): function (f: function (): R): function (): R

Parameters

t (Type<R>)

Returns

function (f: function (): R): function (): R

string

src/sync/string.js

string

Type: StringType

StringType

src/sync/string.js

new StringType()

Extends VType

Instance Members

▸ constructor(parse)

src/sync/string.js

constructor(parse: function (value: any): string)

Parameters

parse (function (value: any): string)

▸ isEmail()

src/sync/string.js

isEmail(): StringType

Returns

StringType

▸ isValidDate()

src/sync/string.js

isValidDate(): StringType

Returns

StringType

▸ maxLength(length)

src/sync/string.js

maxLength(length: number): StringType

Parameters

length (number)

Returns

StringType

▸ minLength(length)

src/sync/string.js

minLength(length: number): StringType

Parameters

length (number)

Returns

StringType

▸ regexp(regularExpression)

src/sync/string.js

regexp(regularExpression: RegExp): StringType

Parameters

regularExpression (RegExp)

Returns

StringType

▸ toDate()

src/sync/string.js

toDate(): Type<Date>

Returns

Type<Date>

syncFunctionToAsync

src/async/syncFunctionToAsync.js

syncFunctionToAsync(f: function (value: any): (T | Promise<T>)): function (value: any): Promise<T>

Parameters

f (function (value: any): (T | Promise<T>))

Returns

function (value: any): Promise<T>

takes

src/sync/takes.js

takes(types: ...Array<Type<any>>): function (f: function (): R): function (): R

Parameters

types (...Array<Type<any>>)

Returns

function (f: function (): R): function (): R

truthy

src/sync/base.js

truthy

Type: Type<true>

tuple

src/sync/tuple.js

tuple(s: S): TupleType<$TupleMap<S, function (v: Type<T>): T>>

Parameters

s (S)

Returns

TupleType<$TupleMap<S, function (v: Type<T>): T>>

TupleType

src/sync/Type.js

new TupleType()

Extends Type

Instance Members

▸ constructor(schema, parse)

src/sync/Type.js

constructor(schema: Array<Type<any>>, parse: function (value: any): T)

Parameters

schema (Array<Type<any>>)

parse (function (value: any): T)

▸ schema

src/sync/Type.js

schema

Type: Array<Type<any>>

Type

src/sync/Type.js

new Type()

Instance Members

▸ and(t2)

src/sync/Type.js

and(t2: Type<T2>): IntersectionType<T, T2>

Parameters

t2 (Type<T2>)

Returns

IntersectionType<T, T2>

▸ async()

src/sync/Type.js

async(): AsyncType<T>

Returns

AsyncType<T>

▸ chain(t2)

src/sync/Type.js

chain(t2: Type<T2>): ChainType<T2>

Parameters

t2 (Type<T2>)

Returns

ChainType<T2>

▸ compose(f)

src/sync/Type.js

compose(f: function (v: T): T2): ComposeLeftType<T, T2>

Parameters

f (function (v: T): T2)

Returns

ComposeLeftType<T, T2>

▸ constructor(name, parse)

src/sync/Type.js

constructor(name: string, parse: function (value: any): T)

Parameters

name (string)

parse (function (value: any): T)

▸ default(value)

src/sync/Type.js

default(value: T): Type<T>

Parameters

value (T)

Returns

Type<T>

▸ force(value)

src/sync/Type.js

force(value: T): Type<T>

Parameters

value (T)

Returns

Type<T>

▸ name

src/sync/Type.js

name

Type: string

▸ optional()

src/sync/Type.js

optional(): OptionalType<T>

Returns

OptionalType<T>

▸ or(t2)

src/sync/Type.js

or(t2: Type<T2>): UnionType<T, T2>

Parameters

t2 (Type<T2>)

Returns

UnionType<T, T2>

▸ parse

src/sync/Type.js

parse

Type: function (value: any): T

▸ parseResult(v)

src/sync/Type.js

parseResult(v: any): ({value: T} | {error: ValidationError})

Parameters

v (any)

Returns

({value: T} | {error: ValidationError})

▸ refine(refinement)

src/sync/Type.js

refine(refinement: function (v: T, error: function (e: string): ValidationError): T): RefinedType<T>

Parameters

refinement (function (v: T, error: function (e: string): ValidationError): T)

Returns

RefinedType<T>

▸ to(transformation)

src/sync/Type.js

to(transformation: function (v: T, error: function (e: string): ValidationError): T2): Type<T2>

Parameters

transformation (function (v: T, error: function (e: string): ValidationError): T2)

Returns

Type<T2>

▸ toJSON()

src/sync/Type.js

toJSON()

▸ type

src/sync/Type.js

type

Type: T

union

src/sync/union.js

union(a: Type<A>, b: Type<B>): UnionType<A, B>

Parameters

a (Type<A>)

b (Type<B>)

Returns

UnionType<A, B>

unionFromObjectKeys

src/sync/unionFromObjectKeys.js

unionFromObjectKeys(o: O): Type<$Keys<O>>

Parameters

o (O)

Returns

Type<$Keys<O>>

UnionType

src/sync/Type.js

new UnionType()

Extends Type

Instance Members

▸ constructor(a, b, validate)

src/sync/Type.js

constructor(a: Type<A>, b: Type<B>, validate: function (value: any): (A | B))

Parameters

a (Type<A>)

b (Type<B>)

validate (function (value: any): (A | B))

▸ typeA

src/sync/Type.js

typeA

Type: Type<A>

▸ typeB

src/sync/Type.js

typeB

Type: Type<B>

ValidationError

src/sync/ValidationError.js

new ValidationError()

Extends Error

Instance Members

▸ constructor(payload)

src/sync/ValidationError.js

constructor(payload: ValidationErrorPayload)

Parameters

payload (ValidationErrorPayload)

▸ payload

src/sync/ValidationError.js

payload

Type: ValidationErrorPayload

▸ toJSON()

src/sync/ValidationError.js

toJSON(): ValidationErrorJSONPayload

Returns

ValidationErrorJSONPayload

ValidationErrorJSONPayload

src/sync/ValidationError.js

ValidationErrorJSONPayload

Type: {expected: {name: string}, description: string?, got: any, errors: {}?}

ValidationErrorPayload

src/sync/ValidationError.js

ValidationErrorPayload

Type: {expected: (Type<any> | AsyncType<any>), got: any, errors: Errors?, description: string?}

VarrayOf

src/sync/VarrayOf.js

new VarrayOf(t: VType<T>): VArrayOfType<T>

Parameters

t (VType<T>)

Returns

VArrayOfType<T>

VArrayOfType

src/sync/VType.js

new VArrayOfType()

Extends VType

Instance Members

▸ constructor(t, validate)

src/sync/VType.js

constructor(t: VType<T>, validate: function (value: any): Array<T>)

Parameters

t (VType<T>)

validate (function (value: any): Array<T>)

▸ itemType

src/sync/VType.js

itemType

Type: VType<T>

Vintersection

src/sync/Vintersection.js

new Vintersection(a: VType<A>, b: VType<B>): VIntersectionType<A, B>

Parameters

a (VType<A>)

b (VType<B>)

Returns

VIntersectionType<A, B>

VIntersectionType

src/sync/VType.js

new VIntersectionType()

Extends VType

Instance Members

▸ constructor(a, b, validate)

src/sync/VType.js

constructor(a: VType<A>, b: VType<B>, validate: function (value: any))

Parameters

a (VType<A>)

b (VType<B>)

validate (function (value: any))

▸ typeA

src/sync/VType.js

typeA

Type: VType<A>

▸ typeB

src/sync/VType.js

typeB

Type: VType<B>

Vmapping

src/sync/Vmapping.js

new Vmapping(keys: VType<K>, values: VType<V>): VMappingType<K, V>

Parameters

keys (VType<K>)

values (VType<V>)

Returns

VMappingType<K, V>

VMappingType

src/sync/VType.js

new VMappingType()

Extends VType

Instance Members

▸ constructor(keys, values, validate)

src/sync/VType.js

constructor(keys: VType<K>, values: VType<V>, validate: function (value: any): {})

Parameters

keys (VType<K>)

values (VType<V>)

validate (function (value: any): {})

▸ keys

src/sync/VType.js

keys

Type: VType<K>

▸ values

src/sync/VType.js

values

Type: VType<V>

Vobject

src/sync/Vobject.js

new Vobject(s: S): VObjectType<S, $ObjMap<S, function (v: VType<F>): F>>

Parameters

s (S)

Returns

VObjectType<S, $ObjMap<S, function (v: VType<F>): F>>

VobjectExact

src/sync/VobjectExact.js

new VobjectExact(s: S): VObjectExactType<S, $Exact<$ObjMap<S, function (v: VType<F>): F>>>

Parameters

s (S)

Returns

VObjectExactType<S, $Exact<$ObjMap<S, function (v: VType<F>): F>>>

VObjectExactType

src/sync/VType.js

new VObjectExactType()

Extends VType

Instance Members

▸ constructor(schema, validate)

src/sync/VType.js

constructor(schema: S, validate: function (value: any): T)

Parameters

schema (S)

validate (function (value: any): T)

▸ schema

src/sync/VType.js

schema

Type: S

VObjectType

src/sync/VType.js

new VObjectType()

Extends VType

Instance Members

▸ constructor(schema, validate)

src/sync/VType.js

constructor(schema: S, validate: function (value: any): T)

Parameters

schema (S)

validate (function (value: any): T)

▸ schema

src/sync/VType.js

schema

Type: S

Voptional

src/sync/Voptional.js

new Voptional(t: VType<T>): VOptionalType<T>

Parameters

t (VType<T>)

Returns

VOptionalType<T>

VOptionalType

src/sync/VType.js

new VOptionalType()

Extends VType

Instance Members

▸ constructor(t, validate)

src/sync/VType.js

constructor(t: VType<T>, validate: function (value: any): T?)

Parameters

t (VType<T>)

validate (function (value: any): T?)

▸ innerType

src/sync/VType.js

innerType

Type: VType<T>

VRefinedType

src/sync/VType.js

new VRefinedType()

Extends VType

Instance Members

▸ base

src/sync/VType.js

base

Type: VType<T>

▸ constructor(base, f)

src/sync/VType.js

constructor(base: VType<T>, f: function (v: any): T)

Parameters

base (VType<T>)

f (function (v: any): T)

▸ revalidate()

src/sync/VType.js

revalidate(): VType<T>

Returns

VType<T>

Vreturns

src/sync/returns.js

new Vreturns(t: VType<R>): function (f: function (): R): function (): R

Parameters

t (VType<R>)

Returns

function (f: function (): R): function (): R

Vtakes

src/sync/takes.js

new Vtakes(types: ...Array<VType<any>>): function (f: function (): R): function (): R

Parameters

types (...Array<VType<any>>)

Returns

function (f: function (): R): function (): R

Vtuple

src/sync/tuple.js

new Vtuple(s: S): VTupleType<$TupleMap<S, function (v: Type<T>): T>>

Parameters

s (S)

Returns

VTupleType<$TupleMap<S, function (v: Type<T>): T>>

VTupleType

src/sync/VType.js

new VTupleType()

Extends VType

Instance Members

▸ constructor(schema, validate)

src/sync/VType.js

constructor(schema: Array<VType<any>>, validate: function (value: any): T)

Parameters

schema (Array<VType<any>>)

validate (function (value: any): T)

▸ schema

src/sync/VType.js

schema

Type: Array<VType<any>>

VType

src/sync/VType.js

new VType()

Extends Type

Instance Members

▸ constructor(name, validate)

src/sync/VType.js

constructor(name: string, validate: function (value: any): T)

Parameters

name (string)

validate (function (value: any): T)

▸ isValid(v)

src/sync/VType.js

isValid(v: any): boolean

Parameters

v (any)

Returns

boolean

▸ validate

src/sync/VType.js

validate

Type: function (value: any): T

▸ validateResult(v)

src/sync/VType.js

validateResult(v: any): ({value: T} | {error: ValidationError})

Parameters

v (any)

Returns

({value: T} | {error: ValidationError})

▸ Vand(t2)

src/sync/VType.js

Vand(t2: VType<T2>): VIntersectionType<T, T2>

Parameters

t2 (VType<T2>)

Returns

VIntersectionType<T, T2>

▸ Vasync()

src/sync/VType.js

Vasync(): AsyncVType<T>

Returns

AsyncVType<T>

▸ Voptional()

src/sync/VType.js

Voptional(): VOptionalType<T>

Returns

VOptionalType<T>

▸ Vor(t2)

src/sync/VType.js

Vor(t2: VType<T2>): VUnionType<T, T2>

Parameters

t2 (VType<T2>)

Returns

VUnionType<T, T2>

▸ Vrefine(refinement)

src/sync/VType.js

Vrefine(refinement: function (v: T, error: function (err: string): ValidationError): T): VRefinedType<T>

Parameters

refinement (function (v: T, error: function (err: string): ValidationError): T)

Returns

VRefinedType<T>

Vunion

src/sync/Vunion.js

new Vunion(a: VType<A>, b: VType<B>): VUnionType<A, B>

Parameters

a (VType<A>)

b (VType<B>)

Returns

VUnionType<A, B>

VUnionType

src/sync/VType.js

new VUnionType()

Extends VType

Instance Members

▸ constructor(a, b, validate)

src/sync/VType.js

constructor(a: VType<A>, b: VType<B>, validate: function (value: any): (A | B))

Parameters

a (VType<A>)

b (VType<B>)

validate (function (value: any): (A | B))

▸ typeA

src/sync/VType.js

typeA

Type: VType<A>

▸ typeB

src/sync/VType.js

typeB

Type: VType<B>