Variable typesConst

Type declaration

• array: <T extends AnyType>(itemType: T) => ArrayType<T[]>

• arraySet: <T extends AnyType>(valueType: T) => ModelType<ArraySet<TypeToData<T>>>

• boolean: IdentityType<boolean>

• dataModelData: <M = never, K = M>(
      modelClass: _ClassOrObject<M, K>,
  ) => IdentityType<
      | ModelUntransformedData<
          K extends M
              ? M extends AnyDataModel ? M : never
              : K extends AnyDataModel ? K : never,
      >
      | ModelData<
          K extends M
              ? M extends AnyDataModel ? M : never
              : K extends AnyDataModel ? K : never,
      >,
  >

• dateString: IdentityType<string>

• dateTimestamp: IdentityType<number>

• enum: <E extends EnumLike>(enumObject: E) => IdentityType<EnumValues<E>>

• frozen: <T extends AnyType>(dataType: T) => ModelType<Frozen<TypeToData<T>>>

• integer: IdentityType<number>

• literal: <T extends PrimitiveValue>(literal: T) => IdentityType<T>

• maybe: <T extends AnyType>(baseType: T) => T | IdentityType<undefined>

• maybeNull: <T extends AnyType>(type: T) => T | IdentityType<null>

• model: <M = never, K = M>(modelClass: _ClassOrObject<M, K>) => ModelType<K>

• nonEmptyString: IdentityType<string>

• null: IdentityType<null>

• number: IdentityType<number>

• object: <T>(objectFunction: T) => T

• objectMap: <T extends AnyType>(valueType: T) => ModelType<ObjectMap<TypeToData<T>>>

• or: {
      <T extends AnyType[]>(
          dispatcher: (sn: any) => T[number],
          ...orTypes: T,
      ): T[number];
      <T extends AnyType[]>(...orTypes: T): T[number];
  }

• record: <T extends AnyType>(valueType: T) => RecordType<T>

• ref: <O extends object>(refConstructor: RefConstructor<O>) => ModelType<Ref<O>>

• refinement: <T extends AnyType>(
      baseType: T,
      checkFn: (data: TypeToData<T>) => null | boolean | TypeCheckError,
      typeName?: string,
  ) => T

• string: IdentityType<string>

• tag: <T extends AnyType, A>(baseType: T, tag: A, typeName?: string) => T

• tuple: <T extends AnyType[]>(...itemTypes: T) => ArrayType<T>

• unchecked: <T = never>() => IdentityType<T>

• undefined: IdentityType<undefined>

• mapArray:function

  • mapArray<T extends AnyType>(
        valueType: T,
    ): ArrayType<ArrayType<[IdentityType<string>, T]>[]>

  • Type Parameters

    • T extends AnyType

    Parameters

    • valueType: T

    Returns ArrayType<ArrayType<[IdentityType<string>, T]>[]>

• mapObject:function

  • mapObject<T extends AnyType>(valueType: T): RecordType<T>

  • Type Parameters

    • T extends AnyType

    Parameters

    • valueType: T

    Returns RecordType<T>

• setArray:function

  • setArray<T extends AnyType>(valueType: T): ArrayType<T[]>

  • Type Parameters

    • T extends AnyType

    Parameters

    • valueType: T

    Returns ArrayType<T[]>