Type

Index

Interfaces

• Module
• Parameters

Type Aliases

• TypeOf

Variables

• bigint
• boolean
• number
• Ordering
• RegExp
• string
• unknown

Functions

• Array
• Char
• constant
• define
• ensure
• Int
• Object
• Option
• Record
• Tuple
• union
• URL
• UUID

Interfaces

Module

Module<T>:

Type module interface

---

Type parameters

• T

typeName

Re-exports typeName

inherited__inspect__

__inspect__: Option<(anyValue, depth, options, inspect) => string>

Inherited from Type.__inspect__

When defined, returns a custom string representation. To be useful, it should be bound to a prototype (ex: Struct)

import { inspect } from 'node:util';

interface Foo {
  foo: boolean;
}
const Foo = Struct.define<Foo>({
  typeName: 'Foo',
  __inspect__: (self) => `Foo { ${String(self.foo)} }`,
});
const myStruct = Struct.create(Foo, { foo: true });// 'Foo { true }'
inspect(myStruct);// 'Foo { true }'

inherited__decode__

• __decode__(this, input, context): Result<T, CodecError>

• Inherited from Codec.__decode__

  Returns the decoded input, Result.Ok or Result.Error()

  interface SomeObject {
    foo: string
  }
  const someCodec: Codec<SomeObject> = ...;
  const input: unknown = ...;
  const decoded = Codec.decode(someCodec, input);

inherited__encode__

• __encode__(this, input): unknown

• Inherited from Codec.__encode__

  Returns the encoded input

  interface SomeObject {
    foo: string
  }
  const someCodec: Codec<SomeObject> = ...;
  const someObject: SomeObject = { foo: "bar" }
  const encoded = Codec.decode(someCodec, someObject);

inherited__schema__

• __schema__(this): JSONValue

• Inherited from Codec.__schema__

  Returns the JSONSchema corresponding to the decoded type

  const someCodec: Codec<unknown> = ...;
  const jsonSchema = Codec.schema(someCodec);

inheritedasInstance

• asInstance(this, anyValue): Option<T>

• Inherited from Type.asInstance

  Try to convert anyValue to enum value or else returns Option.None

  const StringType: Type<string>;
  StringType.asInstance('foo'); // Option.Some('foo')
  StringType.asInstance(12); // Option.None

inheritedasString

• asString(this, self): string

• Inherited from AsString.asString

  Converts the given value to a String.

  Number.asString(123); // '123'

inheritedhasInstance

• hasInstance(this, anyValue): anyValue is T

• Inherited from Type.hasInstance

  Return true if the given value is an instance of the class.

  const StringType: Type<string>;
  StringType.hasInstance('foo'); // true
  StringType.hasInstance(42); // false

Parameters

Parameters<T>:

Type module constructor parameters

---

Type parameters

• T

optionalinherited__inspect__

__inspect__?: Option<(anyValue, depth, options, inspect) => string>

Inherited from PartialKeys.__inspect__

When defined, returns a custom string representation. To be useful, it should be bound to a prototype (ex: Struct)

import { inspect } from 'node:util';

interface Foo {
  foo: boolean;
}
const Foo = Struct.define<Foo>({
  typeName: 'Foo',
  __inspect__: (self) => `Foo { ${String(self.foo)} }`,
});
const myStruct = Struct.create(Foo, { foo: true });// 'Foo { true }'
inspect(myStruct);// 'Foo { true }'

hasInstance

hasInstance: (value) => boolean

inheritedtypeName

typeName: string

Inherited from PartialKeys.typeName

Type string representation

StringType.typeName // 'String'
Int.typeName // 'Int'
Person.typeName // 'Person'

optionalinherited__decode__

• __decode__(this, input, context): Result<T, CodecError>

• Inherited from Partial.__decode__

  Returns the decoded input, Result.Ok or Result.Error()

  interface SomeObject {
    foo: string
  }
  const someCodec: Codec<SomeObject> = ...;
  const input: unknown = ...;
  const decoded = Codec.decode(someCodec, input);

optionalinherited__encode__

• __encode__(this, input): unknown

• Inherited from Partial.__encode__

  Returns the encoded input

  interface SomeObject {
    foo: string
  }
  const someCodec: Codec<SomeObject> = ...;
  const someObject: SomeObject = { foo: "bar" }
  const encoded = Codec.decode(someCodec, someObject);

optionalinherited__schema__

• __schema__(this): JSONValue

• Inherited from Partial.__schema__

  Returns the JSONSchema corresponding to the decoded type

  const someCodec: Codec<unknown> = ...;
  const jsonSchema = Codec.schema(someCodec);

optionalinheritedasInstance

• asInstance(this, anyValue): Option<T>

• Inherited from PartialKeys.asInstance

  Try to convert anyValue to enum value or else returns Option.None

  const StringType: Type<string>;
  StringType.asInstance('foo'); // Option.Some('foo')
  StringType.asInstance(12); // Option.None

optionalinheritedasString

• asString(this, self): string

• Inherited from Partial.asString

  Converts the given value to a String.

  Number.asString(123); // '123'

Type Aliases

TypeOf

TypeOf<V>: V extends Type<infer T> ? T : never

Extract the type of object from its module

---

Type parameters

• V

Variables

bigint

bigint: Module<bigint>

boolean

boolean: Module<boolean>

number

number: Module<number>

Ordering

Ordering: Enum<{ Equal: 0; Greater: 1; Less: -1; typeName: Ordering }>

RegExp

RegExp: { typeName: any; __inspect__: Option<(anyValue, depth, options, inspect) => string>; parse: (expression) => Option<RegExp>; __decode__: any; __encode__: any; __schema__: any; asInstance: any; asString: any; hasInstance: any }

string

string: Module<string>

unknown

unknown: Module<unknown>

Functions

Array

• Array<V>(Item): Type.Module<Array<V>>

• Returns a codec for Array<V>.

  const codec = Type.Array(dateISO);
  const encoded = Codec.encode(codec, [new Date('1970-01-01T00:00:00.000Z')]);// ['1970-01-01T00:00:00.000Z']
  const decoded = Codec.decode(codec, ['1970-01-01T00:00:00.000Z']);// Result.Ok([Date('1970-01-01T00:00:00.000Z')])

Char

• Char(value): Char

• Convert an underlying type to a tagged type Alias to wrap(value)

__call__

Re-exports __call__

__decode__

Re-exports __decode__

__encode__

Re-exports __encode__

__inspect__

Re-exports __inspect__

__schema__

Re-exports __schema__

asInstance

Re-exports asInstance

asString

Re-exports asString

hasInstance

Re-exports hasInstance

typeName

Re-exports typeName

unwrap

Re-exports unwrap

wrap

Re-exports wrap

constant

• constant<Value>(value, encodedValue): Type.Module<Value>
• constant<Value>(value, encodedValue): Type.Module<Value>

• A type for constant value. An encoded value can be specified as second argument.

  const constantType = Type.constant('_'); // Encoded and decoded value are '_'

  const someSymbol = Symbol('someSymbol');
  const someSymbolType = Type.constant(someSymbol, '__someSymbol__'); // Encoded value is '__someSymbol__'

define

• define<T>(parameters): Type.Module<T>

• Define a new Type module

  interface NewType {
    foo: boolean;
  }
  const NewType = Type.define<NewType>({
    typeName: 'NewType',
    hasInstance(value) {
      return typeof value.foo === 'boolean';
    },
  });

ensure

• ensure<T>(Type, anyValue): asserts anyValue is T

• Ensure that value is a valid T. Throw a TypeError otherwise.

  Type.ensure(Type.String, 'foo'); // void
  Type.ensure(Type.String, 42); // throw new Error('42 is not a valid String')

Int

• Int(value): Int

• Convert an underlying type to a tagged type Alias to wrap(value)

__call__

Re-exports __call__

__decode__

Re-exports __decode__

__encode__

Re-exports __encode__

__inspect__

Re-exports __inspect__

__schema__

Re-exports __schema__

asInstance

Re-exports asInstance

asString

Re-exports asString

hasInstance

Re-exports hasInstance

typeName

Re-exports typeName

unwrap

Re-exports unwrap

wrap

Re-exports wrap

Object

• Object<P>(Properties, typeName): Type.Module<Readonly<P>>

• Returns a new Type for P.

  const SomeType = Type.Object({ created: dateISO }, 'SomeType');
  const encoded = Codec.encode(SomeType, { created: new Date('1970-01-01T00:00:00.000Z') });// { created: '1970-01-01T00:00:00.000Z' }
  const decoded = Codec.decode(SomeType, { created: '1970-01-01T00:00:00.000Z' });// Result.Ok({ created: Date('1970-01-01T00:00:00.000Z') })

Option

• Option<T>(Value): Type.Module<OptionType<T>>

• Return a new optional type from Value

  const OptionString = Type.Option(Type.String);

Record

• Record<Key, Value>(Key, Value): Type.Module<Record<Type.TypeOf<Key>, Type.TypeOf<Value>>>

Tuple

• Tuple<C>(...items): Type.Module<{ readonly [ K in keyof C ]: Type.TypeOf<C[K]> }>

union

• union<Types>(...types): Type.Module<Type.TypeOf<Types[number]>>

• Return a union of all types

  const ABType = Type.anyOf(AType, BType);

URL

• URL(value): URL

• Convert an underlying type to a tagged type Alias to wrap(value)

typeName

Re-exports typeName

__call__

__call__: (value) => URL

Callable property

__inspect__

__inspect__: Option<(anyValue, depth, options, inspect) => string>

When defined, returns a custom string representation. To be useful, it should be bound to a prototype (ex: Struct)

import { inspect } from 'node:util';

interface Foo {
  foo: boolean;
}
const Foo = Struct.define<Foo>({
  typeName: 'Foo',
  __inspect__: (self) => `Foo { ${String(self.foo)} }`,
});
const myStruct = Struct.create(Foo, { foo: true });// 'Foo { true }'
inspect(myStruct);// 'Foo { true }'

__decode__

• __decode__(this, input, context): Result<URL, CodecError>

• Returns the decoded input, Result.Ok or Result.Error()

  interface SomeObject {
    foo: string
  }
  const someCodec: Codec<SomeObject> = ...;
  const input: unknown = ...;
  const decoded = Codec.decode(someCodec, input);

__encode__

• __encode__(this, input): unknown

• Returns the encoded input

  interface SomeObject {
    foo: string
  }
  const someCodec: Codec<SomeObject> = ...;
  const someObject: SomeObject = { foo: "bar" }
  const encoded = Codec.decode(someCodec, someObject);

__schema__

• __schema__(this): JSONValue

• Returns the JSONSchema corresponding to the decoded type

  const someCodec: Codec<unknown> = ...;
  const jsonSchema = Codec.schema(someCodec);

asInstance

• asInstance(this, anyValue): Option<URL>

• Try to convert anyValue to enum value or else returns Option.None

  const StringType: Type<string>;
  StringType.asInstance('foo'); // Option.Some('foo')
  StringType.asInstance(12); // Option.None

asString

• asString(this, self): string

• Converts the given value to a String.

  Number.asString(123); // '123'

hasInstance

• hasInstance(this, anyValue): anyValue is URL

• Return true if the given value is an instance of the class.

  const StringType: Type<string>;
  StringType.hasInstance('foo'); // true
  StringType.hasInstance(42); // false

unwrap

• unwrap(value): string

• Convert a tagged value to the underlying type

wrap

• wrap(value): URL

• Convert an underlying type to a tagged type

UUID

• UUID(value): UUID

• Convert an underlying type to a tagged type Alias to wrap(value)

typeName

Re-exports typeName

__call__

__call__: (value) => UUID

Callable property

__inspect__

__inspect__: Option<(anyValue, depth, options, inspect) => string>

When defined, returns a custom string representation. To be useful, it should be bound to a prototype (ex: Struct)

import { inspect } from 'node:util';

interface Foo {
  foo: boolean;
}
const Foo = Struct.define<Foo>({
  typeName: 'Foo',
  __inspect__: (self) => `Foo { ${String(self.foo)} }`,
});
const myStruct = Struct.create(Foo, { foo: true });// 'Foo { true }'
inspect(myStruct);// 'Foo { true }'

__decode__

• __decode__(this, input, context): Result<UUID, CodecError>

• Returns the decoded input, Result.Ok or Result.Error()

  interface SomeObject {
    foo: string
  }
  const someCodec: Codec<SomeObject> = ...;
  const input: unknown = ...;
  const decoded = Codec.decode(someCodec, input);

__encode__

• __encode__(this, input): unknown

• Returns the encoded input

  interface SomeObject {
    foo: string
  }
  const someCodec: Codec<SomeObject> = ...;
  const someObject: SomeObject = { foo: "bar" }
  const encoded = Codec.decode(someCodec, someObject);

__schema__

• __schema__(this): JSONValue

• Returns the JSONSchema corresponding to the decoded type

  const someCodec: Codec<unknown> = ...;
  const jsonSchema = Codec.schema(someCodec);

asInstance

• asInstance(this, anyValue): Option<UUID>

• Try to convert anyValue to enum value or else returns Option.None

  const StringType: Type<string>;
  StringType.asInstance('foo'); // Option.Some('foo')
  StringType.asInstance(12); // Option.None

asString

• asString(this, self): string

• Converts the given value to a String.

  Number.asString(123); // '123'

hasInstance

• hasInstance(this, anyValue): anyValue is UUID

• Return true if the given value is an instance of the class.

  const StringType: Type<string>;
  StringType.hasInstance('foo'); // true
  StringType.hasInstance(42); // false

unwrap

• unwrap(value): `${string}-${string}-${string}-${string}-${string}`

• Convert a tagged value to the underlying type

wrap

• wrap(value): UUID

• Convert an underlying type to a tagged type