@typed/io

Validate the types flowing through your application boundaries.

Index

Namespaces

Interfaces

Type aliases

Variables

Functions

Object literals

Never
Set

Type aliases

DecodeEffect

DecodeEffect<A>: Effects<DecodeFailure, A>

Type parameters

InputOf

InputOf<E>: E extends Encoder<infer R, any> ? R : never

Type parameters

Mixed

Mixed: Type<any, any>

NeverType

NeverType: Type<never>

OutputOf

OutputOf<E>: E extends Encoder<any, infer R> ? R : never

Type parameters

Props

Props: Readonly<Record<PropertyKey, Any>>

TypeOf

TypeOf<A>: A extends Guard<infer R> ? R : never

Type parameters

TypeOf

TypeOf<A>: A extends Decoder<infer R> ? R : never

Type parameters

TypeOf

TypeOf<A>: Of<A>

Type parameters

Variables

Const Any

Any: Any = Type.fromGuard({ is: (_): _ is any => true }, `Any`, `any`)

Const Array

Array: Guard<ReadonlyArray<unknown>> = Guard.is(isArray)

Const Array

Array: Decoder<ReadonlyArray<unknown>> = Decoder.fromGuard(G.Array,'ReadonlyArray<unknown>',)

Const Boolean

Boolean: Guard<boolean> = Guard.is(isBoolean)

Const Boolean

Boolean: Decoder<boolean> = Decoder.fromGuard(G.Boolean, 'boolean')

Const Boolean

Boolean: Type<boolean> = Type.fromGuard(G.Boolean, `Boolean`, `boolean`)

Const Character

Character: Guard<string & { length: 1 } & { __TYPE__: Type }> = refinement(String, isCharacter)

Const Character

Character: Decoder<string & { length: 1 } & { __TYPE__: Type }> = Decoder.fromGuard(G.Character, 'Character')

Const Character

Character: Type<string & { length: 1 } & { __TYPE__: Type }, string & { length: 1 } & { __TYPE__: Type }> = Type.fromGuard(G.Character, 'Character')

Const Date

Date: Guard<Date> = Guard.is(isDate)

Const Date

Date: Decoder<Date> = Decoder.fromGuard(G.Date, `Date`)

Const Date

Date: Type<Date, Date> = Type.fromGuard(G.Date, `Date`)

Const DecodeFailure

DecodeFailure: unique symbol = Symbol.for('DecodeFailure')

Const EmptyString

EmptyString: Guard<string & { length: Zero } & { __TYPE__: Type }> = refinement(String, isEmptyString)

Const EmptyString

EmptyString: Decoder<string & { length: Zero } & { __TYPE__: Type }> = Decoder.fromGuard(G.EmptyString, `EmptyString`)

Const EmptyString

EmptyString: Type<string & { length: Zero } & { __TYPE__: Type }, string & { length: Zero } & { __TYPE__: Type }> = Type.fromGuard(G.EmptyString, 'EmptyString')

Const False

False: Guard<false> = Guard.is(isFalse)

Const False

False: Decoder<boolean> = Decoder.fromGuard(G.False, 'false')

Const False

False: Type<false> = Type.fromGuard(G.False, `False`, `false`)

Const Function

Function: Guard<Function> = Guard.is(isFunction)

Const Function

Function: Decoder<Function> = Decoder.fromGuard(G.Function, 'Function')

Const Function

Function: Type<Function> = Type.fromGuard(G.Function, `Function`)

Const Integer

Integer: Guard<number & { __TYPE__: Type }> = refinement(Number, isInteger)

Const Integer

Integer: Decoder<number & { __TYPE__: Type }> = Decoder.fromGuard(G.Integer, 'Integer')

Const Integer

Integer: Type<number & { __TYPE__: Type }, number & { __TYPE__: Type }> = Type.fromGuard(G.Integer, 'Integer')

Const Map

Map: Guard<ReadonlyMap<unknown, unknown>> = Guard.is(isMap)

Const Map

Map: MapType<Any, Any> = map(Any, Any)

Const Negative

Negative: Guard<number & { __TYPE__: Type }> = refinement(Number, isNegative)

Const Negative

Negative: Decoder<number & { __TYPE__: Type }> = Decoder.fromGuard(G.Negative, 'Negative')

Const Negative

Negative: Type<number & { __TYPE__: Type }, number & { __TYPE__: Type }> = Type.fromGuard(G.Negative, 'Negative')

Const NegativeInteger

NegativeInteger: Guard<number & { __TYPE__: never }> = refinement(Number, isNegativeInteger)

Const NegativeInteger

NegativeInteger: Decoder<number & { __TYPE__: never }> = Decoder.fromGuard(G.NegativeInteger, 'NegativeInteger')

Const NegativeInteger

NegativeInteger: Type<number & { __TYPE__: never }, number & { __TYPE__: never }> = Type.fromGuard(G.NegativeInteger, 'NegativeInteger')

Const Never

Never: Guard = { is: always(false) } as Guard

Const Never

Never: Decoder = Decoder.fromGuard(G.Never, `never`)

Const NonEmptyString

NonEmptyString: Guard<string & { length: PositiveInteger } & { __TYPE__: Type }> = refinement(String, isNonEmptyString)

Const NonEmptyString

NonEmptyString: Decoder<string & { length: PositiveInteger } & { __TYPE__: Type }> = Decoder.fromGuard(G.NonEmptyString, 'NonEmptyString')

Const NonEmptyString

NonEmptyString: Type<string & { length: PositiveInteger } & { __TYPE__: Type }, string & { length: PositiveInteger } & { __TYPE__: Type }> = Type.fromGuard(G.NonEmptyString, 'NonEmptyString')

Const NonNegative

NonNegative: Guard<(number & { __TYPE__: Type }) | (number & { __TYPE__: Type })> = refinement(Number, isNonNegative)

Const NonNegative

NonNegative: Decoder<(number & { __TYPE__: Type }) | (number & { __TYPE__: Type })> = Decoder.fromGuard(G.NonNegative, 'NonNegative')

Const NonNegative

NonNegative: Type<(number & { __TYPE__: Type }) | (number & { __TYPE__: Type }), (number & { __TYPE__: Type }) | (number & { __TYPE__: Type })> = Type.fromGuard(G.NonNegative, 'NonNegative')

Const NonNegativeInteger

NonNegativeInteger: Guard<(number & { __TYPE__: Type }) | (number & { __TYPE__: Type })> = refinement(Number, isNonNegativeInteger)

Const NonNegativeInteger

NonNegativeInteger: Decoder<(number & { __TYPE__: Type }) | (number & { __TYPE__: Type })> = Decoder.fromGuard(G.NonNegativeInteger, 'NonNegativeInteger')

Const NonNegativeInteger

NonNegativeInteger: Type<(number & { __TYPE__: Type }) | (number & { __TYPE__: Type }), (number & { __TYPE__: Type }) | (number & { __TYPE__: Type })> = Type.fromGuard(G.NonNegativeInteger, 'NonNegativeInteger')

Const NonPositive

NonPositive: Guard<(number & { __TYPE__: Type }) | (number & { __TYPE__: Type })> = refinement(Number, isNonPositive)

Const NonPositive

NonPositive: Decoder<(number & { __TYPE__: Type }) | (number & { __TYPE__: Type })> = Decoder.fromGuard(G.NonPositive, 'NonPositive')

Const NonPositive

NonPositive: Type<(number & { __TYPE__: Type }) | (number & { __TYPE__: Type }), (number & { __TYPE__: Type }) | (number & { __TYPE__: Type })> = Type.fromGuard(G.NonPositive, 'NonPositive')

Const NonPositiveInteger

NonPositiveInteger: Guard<(number & { __TYPE__: Type }) | (number & { __TYPE__: Type })> = refinement(Number, isNonPositiveInteger)

Const NonPositiveInteger

NonPositiveInteger: Decoder<(number & { __TYPE__: Type }) | (number & { __TYPE__: Type })> = Decoder.fromGuard(G.NonPositiveInteger, 'NonPositiveInteger')

Const NonPositiveInteger

NonPositiveInteger: Type<(number & { __TYPE__: Type }) | (number & { __TYPE__: Type }), (number & { __TYPE__: Type }) | (number & { __TYPE__: Type })> = Type.fromGuard(G.NonPositiveInteger, 'NonPositiveInteger')

Const NonZero

NonZero: Guard<number & { __TYPE__: Type }> = refinement(Number, isNonZero)

Const NonZero

NonZero: Decoder<number & { __TYPE__: Type }> = Decoder.fromGuard(G.NonZero, 'NonZero')

Const NonZero

NonZero: Type<number & { __TYPE__: Type }, number & { __TYPE__: Type }> = Type.fromGuard(G.NonZero, 'NonZero')

Const NonZeroInteger

NonZeroInteger: Guard<number & { __TYPE__: never }> = refinement(Number, isNonZeroInteger)

Const NonZeroInteger

NonZeroInteger: Decoder<number & { __TYPE__: never }> = Decoder.fromGuard(G.NonZeroInteger, 'NonZeroInteger')

Const NonZeroInteger

NonZeroInteger: Type<number & { __TYPE__: never }, number & { __TYPE__: never }> = Type.fromGuard(G.NonZeroInteger, 'NonZeroInteger')

Const Null

Null: Guard<null> = Guard.is(isNull)

Const Null

Null: Decoder<null> = Decoder.fromGuard(G.Null, `null`)

Const Null

Null: Type<null> = Type.fromGuard(G.Null, `Null`, `null`)

Const Number

Number: Guard<number> = Guard.is(isNumber)

Const Number

Number: Decoder<number> = Decoder.fromGuard(G.Number, `number`)

Const Number

Number: Type<number> = Type.fromGuard(G.Number, 'Number', 'number')

Const Positive

Positive: Guard<number & { __TYPE__: Type }> = refinement(Number, isPositive)

Const Positive

Positive: Decoder<number & { __TYPE__: Type }> = Decoder.fromGuard(G.Positive, 'Positive')

Const Positive

Positive: Type<number & { __TYPE__: Type }, number & { __TYPE__: Type }> = Type.fromGuard(G.Positive, 'Positive')

Const PositiveInteger

PositiveInteger: Guard<number & { __TYPE__: never }> = refinement(Number, isPositiveInteger)

Const PositiveInteger

PositiveInteger: Decoder<number & { __TYPE__: never }> = Decoder.fromGuard(G.PositiveInteger, 'PositiveInteger')

Const PositiveInteger

PositiveInteger: Type<number & { __TYPE__: never }, number & { __TYPE__: never }> = Type.fromGuard(G.PositiveInteger, 'PositiveInteger')

Const Record

Record: Guard<Readonly<Record<PropertyKey, unknown>>> = Guard.is(isRecord)

Const Record

Record: Decoder<{}> = Decoder.fromGuard(G.Record, 'Record<PropertyKey, unknown>')

Const Set

Set: SetType<Any> = set(Any)

Const String

String: Guard<string> = Guard.is(isString)

Const String

String: Type<string> = Type.fromGuard(G.String, `String`, `string`)

Const True

True: Guard<true> = Guard.is(isTrue)

Const True

True: Decoder<boolean> = Decoder.fromGuard(G.True, 'true')

Const True

True: Type<true> = Type.fromGuard(G.True, `True`, `true`)

Const Undefined

Undefined: Guard<undefined> = Guard.is(isUndefined)

Const Undefined

Undefined: Decoder<undefined> = Decoder.fromGuard(G.Undefined, 'undefined')

Const Undefined

Undefined: Type<undefined> = Type.fromGuard(G.Undefined, `Undefined`, `undefined`)

Const Unknown

Unknown: Unknown = Type.fromGuard({ is: (_): _ is unknown => true },`Unknown`,`unknown`,)

Const Uuid

Uuid: Guard<UUID> = refinement(String, isUuid)

Const Uuid

Uuid: Decoder<UUID> = Decoder.fromGuard(G.Uuid, `Uuid`)

Const Uuid

Uuid: Type<UUID> = Type.fromGuard(G.Uuid, `Uuid`)

Const Void

Void: Guard<void> = Guard.is(isUndefined)

Const Void

Void: Decoder<void> = Decoder.fromGuard(G.Void, 'void')

Const Void

Void: Type<void> = Type.fromGuard(G.Void, `Void`, `void`)

Const Zero

Zero: Guard<number & { __TYPE__: Type }> = refinement(Number, isZero)

Const Zero

Zero: Decoder<number & { __TYPE__: Type }> = Decoder.fromGuard(G.Zero, 'Zero')

Const Zero

Zero: Type<number & { __TYPE__: Type }, number & { __TYPE__: Type }> = Type.fromGuard(G.Zero, 'Zero')

Const composeEncoder

composeEncoder: { <A, B, C>(encoder: Encoder<A, B>, type: Type<C, A>): Type<C, B>; <A, B>(encoder: Encoder<A, B>): <C>(type: Type<C, A>) => Type<C, B> } = curry(__composeEncoder) as {<A, B, C>(encoder: Encoder<A, B>, type: Type<C, A>): Type<C, B><A, B>(encoder: Encoder<A, B>): <C>(type: Type<C, A>) => Type<C, B>}

Composes an encoder with a type through function composition Type >>> Encoder

Type declaration

- <A, B, C>(encoder: Encoder<A, B>, type: Type<C, A>): Type<C, B>
- <A, B>(encoder: Encoder<A, B>): <C>(type: Type<C, A>) => Type<C, B>
- Type parameters
 - A
 - B
 - C
 Parameters
 - encoder: Encoder<A, B>
 - type: Type<C, A>
 Returns Type<C, B>
- Type parameters
 - A
 - B
 Parameters
 - encoder: Encoder<A, B>
 Returns <C>(type: Type<C, A>) => Type<C, B>
 - - <C>(type: Type<C, A>): Type<C, B>
 - Type parameters
 - C
 Parameters
 - type: Type<C, A>
 Returns Type<C, B>

Const decode

decode: { <A>(decoder: Decoder<A>, input: unknown): Effects<DecodeFailure, A>; <A>(decoder: Decoder<A>): (input: unknown) => Effects<DecodeFailure, A> } = curry(__decode)

Type declaration

- <A>(decoder: Decoder<A>, input: unknown): Effects<DecodeFailure, A>
- <A>(decoder: Decoder<A>): (input: unknown) => Effects<DecodeFailure, A>
- Type parameters
 - A
 Parameters
 - decoder: Decoder<A>
 - input: unknown
 Returns Effects<DecodeFailure, A>
- Type parameters
 - A
 Parameters
 - decoder: Decoder<A>
 Returns (input: unknown) => Effects<DecodeFailure, A>
 - - (input: unknown): Effects<DecodeFailure, A>
 - Parameters
 - input: unknown
 Returns Effects<DecodeFailure, A>

Const guard

guard: { <A>(guard: Guard<A>, value: unknown): value is A; <A>(guard: Guard<A>): Is<A> } = curry(__guard) as {<A>(guard: Guard<A>, value: unknown): value is A<A>(guard: Guard<A>): Is<A>}

Type declaration

- <A>(guard: Guard<A>, value: unknown): value is A
- <A>(guard: Guard<A>): Is<A>
- Type parameters
 - A
 Parameters
 - guard: Guard<A>
 - value: unknown
 Returns value is A
- Type parameters
 - A
 Parameters
 - guard: Guard<A>
 Returns Is<A>

Const validateHttpRequest

validateHttpRequest: ValidateHttpRequest = curry(checkHttpRequest)

Functions

Const array

array<G>(g: G): Guard<ReadonlyArray<TypeOf<G>>>

- Defined in packages/io/source/guard/Array.ts:7
Type parameters
- G: Guard
Parameters
- g: G
Returns Guard<ReadonlyArray<TypeOf<G>>>

Const array

array<A>(decoder: A): Decoder<ReadonlyArray<TypeOf<A>>>

- Defined in packages/io/source/decoder/Array.ts:21
Type parameters
- A: Decoder
Parameters
- decoder: A
Returns Decoder<ReadonlyArray<TypeOf<A>>>

array

array<I, O>(items: Encoder<I, O>): Encoder<keyof I[], keyof O[]>

- Defined in packages/io/source/encoder/Encoder.ts:59
Type parameters
- I
- O
Parameters
- items: Encoder<I, O>
Returns Encoder<keyof I[], keyof O[]>

array

array<A>(type: A, name?: string): ArrayType<A>

- Defined in packages/io/source/types/Array.ts:13
Type parameters
- A: Any
Parameters
- type: A
- Default value name: string = `ReadonlyArray<${type.name}>`
Returns ArrayType<A>

catchDecodeFailure

catchDecodeFailure<A>(effect: DecodeEffect<A>): PureEffect<Either<DecodeError, A>>
catchDecodeFailure<A, B>(effect: DecodeEffect<A>, onError: (error: DecodeError) => B): PureEffect<Either<keyof [DecodeError, B], A>>

- Defined in packages/io/source/decoder/Decoder.ts:69
Type parameters
- A
Parameters
- effect: DecodeEffect<A>
Returns PureEffect<Either<DecodeError, A>>
- Defined in packages/io/source/decoder/Decoder.ts:70
Type parameters
- A
- B
Parameters
- effect: DecodeEffect<A>
- onError: (error: DecodeError) => B
 - - (error: DecodeError): B
 - Parameters
 - error: DecodeError
 Returns B
Returns PureEffect<Either<keyof [DecodeError, B], A>>

Const decodeFailure

decodeFailure(e: DecodeError): Effects<{}, any>

- Defined in packages/io/source/decoder/Decoder.ts:67
Parameters
- e: DecodeError
Returns Effects<{}, any>

Const either

either<L, R>(left: L, right: R): Guard<Either<TypeOf<L>, TypeOf<R>>>

- Defined in packages/io/source/guard/Either.ts:13
Type parameters
- L: Guard
- R: Guard
Parameters
- left: L
- right: R
Returns Guard<Either<TypeOf<L>, TypeOf<R>>>

Const either

either<A, B>(left: Decoder<A>, right: Decoder): Decoder<Either<A, B>>

- Defined in packages/io/source/decoder/Either.ts:11
Type parameters
- A
- B
Parameters
- left: Decoder<A>
- right: Decoder
Returns Decoder<Either<A, B>>

Const either

either<A, B>(left: A, right: B): EitherType<A, B>

- Defined in packages/io/source/types/Either.ts:11
Type parameters
- A: Type
- B: Type
Parameters
- left: A
- right: B
Returns EitherType<A, B>

Const intersection

intersection<A>(guards: A): Guard<IntersectionType<A>>

- Defined in packages/io/source/guard/Intersection.ts:4
Type parameters
- A: ReadonlyArray<Guard>
Parameters
- guards: A
Returns Guard<IntersectionType<A>>

Const intersection

intersection<A>(decoders: A): Decoder<IntersectionType<A>>

- Defined in packages/io/source/decoder/Intersection.ts:7
Type parameters
- A: ReadonlyArray<Decoder<any>>
Parameters
- decoders: A
Returns Decoder<IntersectionType<A>>

intersection

intersection<A>(encoders: A): Encoder<InputIntersection<A>, OutputIntersection<A>>

- Defined in packages/io/source/encoder/Encoder.ts:76
Type parameters
- A: ReadonlyArray<Encoder>
Parameters
- encoders: A
Returns Encoder<InputIntersection<A>, OutputIntersection<A>>

intersection

intersection<A>(types: A, name?: string): IntersectionType<A>

- Defined in packages/io/source/types/Intersection.ts:17
Type parameters
- A: ReadonlyArray<Any>
Parameters
- types: A
- Default value name: string = getIntersectionName(types)
Returns IntersectionType<A>

literal

literal<A>(...values: A): Guard<A[number]>

- Defined in packages/io/source/guard/Literal.ts:4
Type parameters
- A: ReadonlyArray<ComparableValues>
Parameters
- Rest ...values: A
Returns Guard<A[number]>

literal

literal<A>(...values: A): Decoder<A[number]>

- Defined in packages/io/source/decoder/Literal.ts:6
Type parameters
- A: ReadonlyArray<ComparableValues>
Parameters
- Rest ...values: A
Returns Decoder<A[number]>

literal

literal<A>(value: A, name?: string): LiteralType<A>

- Defined in packages/io/source/types/Literal.ts:9
Type parameters
- A: ComparableValues
Parameters
- value: A
- Default value name: string = typeof value
Returns LiteralType<A>

Const map

map<K, V>(key: K, value: V): Guard<ReadonlyMap<TypeOf<K>, TypeOf<V>>>

- Defined in packages/io/source/guard/Map.ts:8
Type parameters
- K: Guard
- V: Guard
Parameters
- key: K
- value: V
Returns Guard<ReadonlyMap<TypeOf<K>, TypeOf<V>>>

Const map

map<K, V>(key: K, value: V): Decoder<ReadonlyMap<TypeOf<K>, TypeOf<V>>>

- Defined in packages/io/source/decoder/Map.ts:22
Type parameters
- K: Decoder
- V: Decoder
Parameters
- key: K
- value: V
Returns Decoder<ReadonlyMap<TypeOf<K>, TypeOf<V>>>

map

map<K, V>(key: K, value: V, name?: string, expected?: string): MapType<K, V>

- Defined in packages/io/source/types/Map.ts:10
Type parameters
- K: Any
- V: Any
Parameters
- key: K
- value: V
- Default value name: string = `ReadonlyMap<${key.name}, ${value.name}>`
- Default value expected: string = `ReadonlyMap<${key.expected}, ${value.expected}>`
Returns MapType<K, V>

Const maybe

maybe<A>(guard: Guard<A>): Guard<Maybe<A>>

- Defined in packages/io/source/guard/Maybe.ts:12
Type parameters
- A
Parameters
- guard: Guard<A>
Returns Guard<Maybe<A>>

Const maybe

maybe<A>(a: A): Decoder<Maybe<TypeOf<A>>>

- Defined in packages/io/source/decoder/Maybe.ts:12
Type parameters
- A: Decoder
Parameters
- a: A
Returns Decoder<Maybe<TypeOf<A>>>

Const maybe

maybe<A>(justType: A, name?: string, expected?: string): MaybeType<A>

- Defined in packages/io/source/types/Maybe.ts:9
Type parameters
- A: Any
Parameters
- justType: A
- Default value name: string = `Maybe<${justType.name}>`
- Default value expected: string = `Maybe<${justType.expected}>`
Returns MaybeType<A>

Const nullable

nullable<A>(g: A): Guard<TypeOf<A> | null>

- Defined in packages/io/source/guard/Null.ts:6
Type parameters
- A: Guard<any>
Parameters
- g: A
Returns Guard<TypeOf<A> | null>

Const nullable

nullable<A>(d: A): Decoder<TypeOf<A> | null>

- Defined in packages/io/source/decoder/Null.ts:7
Type parameters
- A: Decoder
Parameters
- d: A
Returns Decoder<TypeOf<A> | null>

Const nullable

nullable<A>(type: A): Type<null | Of<A>>

- Defined in packages/io/source/types/Null.ts:6
Type parameters
- A: Type
Parameters
- type: A
Returns Type<null | Of<A>>

partial

partial<R>(props: R): Guard<{}>

- Defined in packages/io/source/guard/Partial.ts:5
Type parameters
- R: Readonly<Record<PropertyKey, Guard>>
Parameters
- props: R
Returns Guard<{}>

Const partial

partial<A>(decoders: A, expected?: string): Decoder<{}>

- Defined in packages/io/source/decoder/Partial.ts:10
Type parameters
- A: Readonly<Record<PropertyKey, Decoder>>
Parameters
- decoders: A
- Default value expected: string = getDefaultPartialExpected(decoders)
Returns Decoder<{}>

partial

partial(properties: P): Encoder<Partial<{}>, Partial<{}>>

- Defined in packages/io/source/encoder/Encoder.ts:17
Type parameters
- P: Readonly<Record<PropertyKey, Encoder<any, any>>>
Parameters
- properties: P
Returns Encoder<Partial<{}>, Partial<{}>>

Const partial

partial<A>(properties: A, name: string, expected?: string): PartialType<A>

- Defined in packages/io/source/types/Partial.ts:12
Type parameters
- A: Props
Parameters
- properties: A
- name: string
- Default value expected: string = name
Returns PartialType<A>

Const record

record<R>(props: R): Guard<{}>

- Defined in packages/io/source/guard/Record.ts:7
Type parameters
- R: Readonly<Record<PropertyKey, Guard>>
Parameters
- props: R
Returns Guard<{}>

Const record

record<A>(decoders: A, expected?: string): Decoder<{}>

- Defined in packages/io/source/decoder/Record.ts:12
Type parameters
- A: Readonly<Record<PropertyKey, Decoder>>
Parameters
- decoders: A
- Default value expected: string = getDefaultRecordExpected(decoders)
Returns Decoder<{}>

record

record(properties: P): Encoder<{}, {}>

- Defined in packages/io/source/encoder/Encoder.ts:39
Type parameters
- P: Readonly<Record<PropertyKey, Encoder<any, any>>>
Parameters
- properties: P
Returns Encoder<{}, {}>

Const record

record<A>(properties: A, name?: string, expected?: string): RecordType<A>

- Defined in packages/io/source/types/Record.ts:16
Type parameters
- A: Props
Parameters
- properties: A
- Default value name: string = getDefaultRecordName(properties)
- Default value expected: string = getDefaultRecordExpected(properties)
Returns RecordType<A>

refinement

refinement<A, B>(from: Guard<A>, refinement: Refinement<A, B>): Guard

- Defined in packages/io/source/guard/refinement.ts:4
Type parameters
- A
- B: A
Parameters
- from: Guard<A>
- refinement: Refinement<A, B>
Returns Guard

Const refinement

refinement<A, B>(decoder: A, refined: (value: TypeOf<A>) => DecodeEffect, expected: string): Decoder

- Defined in packages/io/source/decoder/refinement.ts:12
Type parameters
- A: Decoder<any>
- B: TypeOf<A>
Parameters
- decoder: A
- refined: (value: TypeOf<A>) => DecodeEffect
 - - (value: TypeOf<A>): DecodeEffect
 - Parameters
 - value: TypeOf<A>
 Returns DecodeEffect
- expected: string
Returns Decoder

refinement

refinement<A, B>(type: A, refinementF: Refinement<Of<A>, B>, name?: string): Type<B, Type.Encoding<A> extends Type.Of<A> ? B : Type.Encoding<A>>

- Defined in packages/io/source/types/refinement.ts:5
Type parameters
- A: Any
- B: Of<A>
Parameters
- type: A
- refinementF: Refinement<Of<A>, B>
- Default value name: string = type.name
Returns Type<B, Type.Encoding<A> extends Type.Of<A> ? B : Type.Encoding<A>>

remoteData

remoteData<L, R>(left: L, right: R): Guard<RemoteData<TypeOf<L>, TypeOf<R>>>

- Defined in packages/io/source/guard/RemoteData.ts:30
Type parameters
- L: Guard
- R: Guard
Parameters
- left: L
- right: R
Returns Guard<RemoteData<TypeOf<L>, TypeOf<R>>>

Const remoteData

remoteData<L, R>(l: L, r: R): Decoder<RemoteData<TypeOf<L>, TypeOf<R>>>

- Defined in packages/io/source/decoder/RemoteData.ts:15
Type parameters
- L: Decoder
- R: Decoder
Parameters
- l: L
- r: R
Returns Decoder<RemoteData<TypeOf<L>, TypeOf<R>>>

Const remoteData

remoteData<L, R>(left: L, right: R, name?: string): RemoteDataType<L, R>

- Defined in packages/io/source/types/RemoteData.ts:13
Type parameters
- L: Type
- R: Type
Parameters
- left: L
- right: R
- Default value name: string = `RemoteData<${left.name}, ${right.name}>`
Returns RemoteDataType<L, R>

Const set

set<A>(g: A): Guard<ReadonlySet<A extends Guard<R> ? R : never>>

- Defined in packages/io/source/guard/Set.ts:7
Type parameters
- A: Guard
Parameters
- g: A
Returns Guard<ReadonlySet<A extends Guard<R> ? R : never>>

Const set

set<A>(d: A): Decoder<ReadonlySet<TypeOf<A>>>

- Defined in packages/io/source/decoder/Set.ts:10
Type parameters
- A: Decoder
Parameters
- d: A
Returns Decoder<ReadonlySet<TypeOf<A>>>

Const set

set<A>(member: A, name?: string): SetType<A>

- Defined in packages/io/source/types/Set.ts:10
Type parameters
- A: Type
Parameters
- member: A
- Default value name: string = `ReadonlySet<${member.name}>`
Returns SetType<A>

Const shouldUseIdentity

shouldUseIdentity(types: keyof Any[]): boolean

- Defined in packages/io/source/types/helpers.ts:5
Parameters
- types: keyof Any[]
Returns boolean

Const tuple

tuple<A>(types: A): Guard<{}>

- Defined in packages/io/source/guard/Tuple.ts:5
Type parameters
- A: ReadonlyArray<Guard>
Parameters
- types: A
Returns Guard<{}>

Const tuple

tuple<A>(decoders: A): Decoder<{}>

- Defined in packages/io/source/decoder/Tuple.ts:7
Type parameters
- A: ReadonlyArray<Decoder>
Parameters
- decoders: A
Returns Decoder<{}>

tuple

tuple<A>(encoders: A): Encoder<{}, {}>

- Defined in packages/io/source/encoder/Encoder.ts:65
Type parameters
- A: ReadonlyArray<Encoder>
Parameters
- encoders: A
Returns Encoder<{}, {}>

Const tuple

tuple<A>(members: A): TupleType<A>

- Defined in packages/io/source/types/Tuple.ts:14
Type parameters
- A: ReadonlyArray<Type>
Parameters
- members: A
Returns TupleType<A>

Const union

union<A>(guards: A): Guard<TypeOf<A[number]>>

- Defined in packages/io/source/guard/Union.ts:4
Type parameters
- A: ReadonlyArray<Guard<any>>
Parameters
- guards: A
Returns Guard<TypeOf<A[number]>>

Const union

union<A>(decoders: A, expected?: string): Decoder<TypeOf<A[number]>>

- Defined in packages/io/source/decoder/Union.ts:5
Type parameters
- A: ReadonlyArray<Decoder>
Parameters
- decoders: A
- Default value expected: string = decoders.map((d) => d.expected).join(' | ')
Returns Decoder<TypeOf<A[number]>>

Const union

union<A>(members: A, name?: string): UnionType<A>

- Defined in packages/io/source/types/Union.ts:11
Type parameters
- A: ReadonlyArray<Type>
Parameters
- members: A
- Default value name: string = getUnionName(members)
Returns UnionType<A>

Object literals

Const Never

Never: object

encode

encode: <A>(value: A) => A = id

Type declaration

- <A>(value: A): A
- Type parameters
 - A
 Parameters
 - value: A
 Returns A

expected

expected: string = "never"

name

name: string = "Never"

decode

decode(i: unknown): Effects<DecodeFailure, never>

- Defined in packages/io/source/types/Never.ts:11
Parameters
- i: unknown
Returns Effects<DecodeFailure, never>

is

is(_: unknown): _ is never

- Defined in packages/io/source/types/Never.ts:10
Parameters
- _: unknown
Returns _ is never

Const Set

Set: object

is

is: isSet = isSet