Variable: types
const types: object;
Type Declaration
array
array: <T>(itemType) => ArrayType<T[]> = typesArray;
A type that represents an array of values of a given type.
Example:
const numberArrayType = types.array(types.number)
Type Parameters
| Type Parameter | Description |
|---|---|
T extends AnyType | Item type. |
Parameters
| Parameter | Type | Description |
|---|---|---|
itemType | T | Type of inner items. |
Returns
ArrayType<T[]>
arraySet
arraySet: <T>(valueType) => ModelType<ArraySet<TypeToData<T>>> = typesArraySet;
A type that represents an array backed set ArraySet.
Example:
const numberSetType = types.arraySet(types.number)
Type Parameters
| Type Parameter | Description |
|---|---|
T extends AnyType | Value type. |
Parameters
| Parameter | Type | Description |
|---|---|---|
valueType | T | Value type. |
Returns
ModelType<ArraySet<TypeToData<T>>>
bigint
bigint: CodecFromEncoded<StringConstructor, bigint> = typesBigInt;
boolean
boolean: IdentityType<boolean> = typesBoolean;
codec
codec: <TEncodedType, TRuntime>(config) => CodecFromEncoded<TEncodedType, TRuntime> = typesCodec;
Type Parameters
| Type Parameter |
|---|
TEncodedType extends AnyType |
TRuntime |
Parameters
| Parameter | Type |
|---|---|
config | CodecConfig<TEncodedType, TRuntime> |
Returns
CodecFromEncoded<TEncodedType, TRuntime>
dataModelData
dataModelData: <M, K>(modelClass) => IdentityType<
| ModelUntransformedData<K extends M ? M extends AnyDataModel ? M : never : K extends AnyDataModel ? K : never>
| { [k in string | number | symbol]: ModelPropsOf<K extends M ? M extends AnyDataModel ? M : never : K extends AnyDataModel ? K : never>[k]["$transformedValueType"] }> = typesDataModelData;
A type that represents a data model data. The type referenced in the model decorator will be used for type checking.
Example:
const someDataModelDataType = types.dataModelData(SomeModel)
// or for recursive models
const someDataModelDataType = types.dataModelData<SomeModel>(() => SomeModel)
Type Parameters
| Type Parameter | Default type | Description |
|---|---|---|
M | never | Data model type. |
K | M | - |
Parameters
| Parameter | Type | Description |
|---|---|---|
modelClass | _ClassOrObject<M, K> | Model class. |
Returns
IdentityType<
| ModelUntransformedData<K extends M ? M extends AnyDataModel ? M : never : K extends AnyDataModel ? K : never>
| { [k in string | number | symbol]: ModelPropsOf<K extends M ? M extends AnyDataModel ? M : never : K extends AnyDataModel ? K : never>[k]["$transformedValueType"] }>
dateAsIsoString
dateAsIsoString: CodecFromEncoded<StringConstructor, Date> = typesDateAsIsoString;
dateAsTimestamp
dateAsTimestamp: CodecFromEncoded<NumberConstructor, Date> = typesDateAsTimestamp;
dateString
dateString: IdentityType<string> = typesNonEmptyString;
Deprecated
Prefer types.dateAsIsoString instead.
dateTimestamp
dateTimestamp: IdentityType<number> = typesInteger;
Deprecated
Prefer types.dateAsTimestamp instead.
enum
enum: <E>(enumObject) => IdentityType<EnumValues<E>> = typesEnum;
An enum type, based on a TypeScript alike enum object.
Syntactic sugar for types.or(...enum_values.map(types.literal))
Example:
enum Color {
Red = "red",
Green = "green"
}
const colorType = types.enum(Color)
Type Parameters
| Type Parameter | Description |
|---|---|
E extends EnumLike | Enum type. |
Parameters
| Parameter | Type | Description |
|---|---|---|
enumObject | E | - |
Returns
IdentityType<EnumValues<E>>
frozen
frozen: <T>(dataType) => ModelType<Frozen<TypeToData<T>>> = typesFrozen;
A type that represents frozen data.
Example:
const frozenNumberType = types.frozen(types.number)
const frozenAnyType = types.frozen(types.unchecked<any>())
const frozenNumberArrayType = types.frozen(types.array(types.number))
const frozenUncheckedNumberArrayType = types.frozen(types.unchecked<number[]>())
Type Parameters
| Type Parameter | Description |
|---|---|
T extends AnyType | Type. |
Parameters
| Parameter | Type | Description |
|---|---|---|
dataType | T | Type of the frozen data. |
Returns
ModelType<Frozen<TypeToData<T>>>
integer
integer: IdentityType<number> = typesInteger;
literal
literal: <T>(literal) => IdentityType<T> = typesLiteral;
A type that represents a certain value of a primitive (for example an exact number or string).
Example
const hiType = types.literal("hi") // the string with value "hi"
const number5Type = types.literal(5) // the number with value 5
Type Parameters
| Type Parameter | Description |
|---|---|
T extends PrimitiveValue | Literal value type. |
Parameters
| Parameter | Type | Description |
|---|---|---|
literal | T | Literal value. |
Returns
IdentityType<T>
maybe
maybe: <T>(baseType) => IdentityType<undefined> | T = typesMaybe;
A type that represents either a type or undefined.
Syntactic sugar for types.or(baseType, types.undefined)
Example:
const numberOrUndefinedType = types.maybe(types.number)
Type Parameters
| Type Parameter | Description |
|---|---|
T extends AnyType | Type. |
Parameters
| Parameter | Type | Description |
|---|---|---|
baseType | T | Type. |
Returns
IdentityType<undefined> | T
maybeNull
maybeNull: <T>(type) => IdentityType<null> | T = typesMaybeNull;
A type that represents either a type or null.
Syntactic sugar for types.or(baseType, types.null)
- Example:
const numberOrNullType = types.maybeNull(types.number)
Type Parameters
| Type Parameter | Description |
|---|---|
T extends AnyType | Type. |
Parameters
| Parameter | Type | Description |
|---|---|---|
type | T | Type. |
Returns
IdentityType<null> | T
model
model: <M, K>(modelClass) => ModelType<K> = typesModel;
A type that represents a model. The type referenced in the model decorator will be used for type checking.
Example:
const someModelType = types.model(SomeModel)
// or for recursive models
const someModelType = types.model<SomeModel>(() => SomeModel)
Type Parameters
| Type Parameter | Default type | Description |
|---|---|---|
M | never | Model type. |
K | M | - |
Parameters
| Parameter | Type | Description |
|---|---|---|
modelClass | _ClassOrObject<M, K> | Model class. |
Returns
ModelType<K>
nonEmptyString
nonEmptyString: IdentityType<string> = typesNonEmptyString;
null
null: IdentityType<null> = typesNull;
number
number: IdentityType<number> = typesNumber;
object
object: <T>(objectFunction) => T = typesObject;
A type that represents a plain object. Note that the parameter must be a function that returns an object. This is done so objects can support self / cross types.
Example:
// notice the ({ ... }), not just { ... }
const pointType = types.object(() => ({
x: types.number,
y: types.number
}))
Type Parameters
| Type Parameter | Description |
|---|---|
T | Type. |
Parameters
| Parameter | Type | Description |
|---|---|---|
objectFunction | T | Function that generates an object with types. |
Returns
T
objectMap
objectMap: <T>(valueType) => ModelType<ObjectMap<TypeToData<T>>> = typesObjectMap;
A type that represents an object-like map ObjectMap.
Example:
const numberMapType = types.objectMap(types.number)
Type Parameters
| Type Parameter | Description |
|---|---|
T extends AnyType | Value type. |
Parameters
| Parameter | Type | Description |
|---|---|---|
valueType | T | Value type. |
Returns
ModelType<ObjectMap<TypeToData<T>>>
or
or: {
<T> (dispatcher, ...orTypes): T[number];
<T> (...orTypes): T[number];
} = typesOr;
Call Signature
<T>(dispatcher, ...orTypes): T[number];
A type that represents the union of several other types (a | b | c | ...). Accepts a dispatcher that, given a snapshot, returns the type that snapshot is.
Type Parameters
| Type Parameter | Description |
|---|---|
T extends AnyType[] | Type. |
Parameters
| Parameter | Type | Description |
|---|---|---|
dispatcher | (sn) => T[number] | Function that given a snapshot returns the type. |
...orTypes | T | Possible types. |
Returns
T[number]
Call Signature
<T>(...orTypes): T[number];
A type that represents the union of several other types (a | b | c | ...).
Example:
const booleanOrNumberType = types.or(types.boolean, types.number)
Type Parameters
| Type Parameter | Description |
|---|---|
T extends AnyType[] | Type. |
Parameters
| Parameter | Type | Description |
|---|---|---|
...orTypes | T | Possible types. |
Returns
T[number]
record
record: <T>(valueType) => RecordType<T> = typesRecord;
A type that represents an object-like map, an object with string keys and values all of a same given type.
Example:
// { [k: string]: number }
const numberMapType = types.record(types.number)
Type Parameters
| Type Parameter | Description |
|---|---|
T extends AnyType | Type. |
Parameters
| Parameter | Type | Description |
|---|---|---|
valueType | T | Type of the values of the object-like map. |
Returns
RecordType<T>
ref
ref: <O>(refConstructor) => ModelType<Ref<O>> = typesRef;
A type that represents a reference to an object or model.
Example:
const refToSomeObject = types.ref(SomeObject)
Type Parameters
| Type Parameter | Description |
|---|---|
O extends object | Object or model type. |
Parameters
| Parameter | Type | Description |
|---|---|---|
refConstructor | RefConstructor<O> | Ref object type. |
Returns
refinement
refinement: <T>(baseType, checkFn, typeName?) => T = typesRefinement;
A refinement over a given type. This allows you to do extra checks over models, ensure numbers are integers, etc.
Example:
const integerType = types.refinement(types.number, (n) => {
return Number.isInteger(n)
}, "integer")
const sumModelType = types.refinement(types.model(Sum), (sum) => {
// imagine that for some reason sum includes a number 'a', a number 'b'
// and the result
const rightResult = sum.a + sum.b === sum.result
// simple mode that will just return that the whole model is incorrect
return rightResult
// this will return that the result field is wrong
return rightResult ? null : new TypeCheckError({
path: ["result"],
expectedTypeName: "a+b",
actualValue: sum.result,
})
})
Type Parameters
| Type Parameter | Description |
|---|---|
T extends AnyType | Base type. |
Parameters
| Parameter | Type | Description |
|---|---|---|
baseType | T | Base type. |
checkFn | (data) => boolean | TypeCheckError | null | Function that will receive the data (if it passes the base type check) and return null or true if there were no errors or either a TypeCheckError instance or false if there were. |
typeName? | string | - |
Returns
T
skipCheck
skipCheck: <T>(baseType) => T = typesSkipCheck;
A type that wraps another type but skips runtime validation.
Unlike types.unchecked(), this preserves the wrapped type's
runtime/snapshot typing and all processors/codecs/transforms.
Use this when you want codec conversions (e.g. types.dateAsTimestamp,
types.bigint, types.mapFromObject(...)) without paying the cost of
runtime type checking on every change.
Example:
// Date codec with no runtime validation
const dateType = types.skipCheck(types.dateAsTimestamp)
// In a model
class M extends Model({ date: tProp(types.skipCheck(types.dateAsTimestamp)) }) {}
Type Parameters
| Type Parameter | Description |
|---|---|
T extends AnyType | Base type. |
Parameters
| Parameter | Type | Description |
|---|---|---|
baseType | T | The type whose validation should be skipped. |
Returns
T
A type with the same runtime/snapshot behavior but no validation.
string
string: IdentityType<string> = typesString;
tag
tag: <T, A>(baseType, tag, typeName?) => T = typesTag;
Wrap a given type with tag information. This allows you to associate metadata with the type of a prop that you can use at runtime.
Example:
const widthType = types.tag(types.number, { displayName: "Width in Inches", required: true }, "dimension")
const heightType = types.tag(types.number, { displayName: "Height in Inches", required: true }, "dimension")
These can then be accessed at runtime through inspection APIs, e.g.
@model('MyModel')
class MyModel extends Model({
width: tProp(widthType, 10),
height: tProp(heightType, 10)
}) {}
const m = new MyModel({})
const type = types.model<typeof Model>(m.constructor)
const modelTypeInfo = getTypeInfo(type) as ModelTypeInfo
const propTypeInfo = modelTypeInfo.props.width.typeInfo as TagTypeInfo
const displayName = propTypeInfo.displayName
Type Parameters
| Type Parameter | Description |
|---|---|
T extends AnyType | Base type. |
A | Tag object. |
Parameters
| Parameter | Type | Description |
|---|---|---|
baseType | T | Base type. |
tag | A | Abitrary object that can be queried at runtime. |
typeName? | string | - |
Returns
T
tuple
tuple: <T>(...itemTypes) => ArrayType<T> = typesTuple;
A type that represents an tuple of values of a given type.
Example:
const stringNumberTupleType = types.tuple(types.string, types.number)
Type Parameters
| Type Parameter | Description |
|---|---|
T extends AnyType[] | Item types. |
Parameters
| Parameter | Type | Description |
|---|---|---|
...itemTypes | T | Type of inner items. |
Returns
ArrayType<T>
unchecked
unchecked: <T>() => IdentityType<T> = typesUnchecked;
A type that represents a given value that won't be type checked. This is basically a way to bail out of the runtime type checking system.
Example:
const uncheckedSomeModel = types.unchecked<SomeModel>()
const anyType = types.unchecked<any>()
const customUncheckedType = types.unchecked<(A & B) | C>()
Type Parameters
| Type Parameter | Default type | Description |
|---|---|---|
T | never | Type of the value, or unkown if not given. |
Returns
IdentityType<T>
undefined
undefined: IdentityType<undefined> = typesUndefined;
mapArray()
mapArray<T>(valueType): ArrayType<ArrayType<[IdentityType<string>, T]>[]>;
Type Parameters
| Type Parameter |
|---|
T extends AnyType |
Parameters
| Parameter | Type |
|---|---|
valueType | T |
Returns
ArrayType<ArrayType<[IdentityType<string>, T]>[]>
Deprecated
Prefer types.mapFromArray(...) for runtime Map values.
mapFromArray()
mapFromArray<TKeyType, TValueType>(keyType, valueType): CodecFromEncoded<ArrayType<ArrayType<[TKeyType, TValueType]>[]>, Map<TypeToData<TKeyType>, TypeToData<TValueType>>>;
Type Parameters
| Type Parameter |
|---|
TKeyType extends AnyType |
TValueType extends AnyType |
Parameters
| Parameter | Type |
|---|---|
keyType | TKeyType |
valueType | TValueType |
Returns
CodecFromEncoded<ArrayType<ArrayType<[TKeyType, TValueType]>[]>, Map<TypeToData<TKeyType>, TypeToData<TValueType>>>
mapFromObject()
mapFromObject<T>(valueType): CodecFromEncoded<RecordType<T>, Map<string, TypeToData<T>>>;
Type Parameters
| Type Parameter |
|---|
T extends AnyType |
Parameters
| Parameter | Type |
|---|---|
valueType | T |
Returns
CodecFromEncoded<RecordType<T>, Map<string, TypeToData<T>>>
mapObject()
mapObject<T>(valueType): RecordType<T>;
Type Parameters
| Type Parameter |
|---|
T extends AnyType |
Parameters
| Parameter | Type |
|---|---|
valueType | T |
Returns
RecordType<T>
Deprecated
Prefer types.mapFromObject(...) for runtime Map values.
setArray()
setArray<T>(valueType): ArrayType<T[]>;
Type Parameters
| Type Parameter |
|---|
T extends AnyType |
Parameters
| Parameter | Type |
|---|---|
valueType | T |
Returns
ArrayType<T[]>
Deprecated
Prefer types.setFromArray(...) for runtime Set values.
setFromArray()
setFromArray<T>(valueType): CodecFromEncoded<ArrayType<T[]>,
| Set<TypeToData<T>>
| ObservableSet<TypeToData<T>>>;
Type Parameters
| Type Parameter |
|---|
T extends AnyType |
Parameters
| Parameter | Type |
|---|---|
valueType | T |
Returns
CodecFromEncoded<ArrayType<T[]>,
| Set<TypeToData<T>>
| ObservableSet<TypeToData<T>>>