mobx-keystone
    Preparing search index...

    Variable typesConst

    types: {
        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<M> : never
                    : K extends AnyDataModel ? K<K> : never,
            >
            | ModelData<
                K extends M
                    ? M extends AnyDataModel ? M<M> : never
                    : K extends AnyDataModel ? K<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) => IdentityType<undefined> | T;
        maybeNull: <T extends AnyType>(type: T) => IdentityType<null> | T;
        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<T extends AnyType>(
            valueType: T,
        ): ArrayType<ArrayType<[IdentityType<string>, T]>[]>;
        mapObject<T extends AnyType>(valueType: T): RecordType<T>;
        setArray<T extends AnyType>(valueType: T): ArrayType<T[]>;
    } = ...

    Type declaration

    Settings

    Member Visibility