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>>>;
        bigint: CodecFromEncoded<StringConstructor, bigint>;
        boolean: IdentityType<boolean>;
        codec: <TEncodedType extends AnyType, TRuntime>(
            config: CodecConfig<TEncodedType, TRuntime>,
        ) => CodecFromEncoded<TEncodedType, TRuntime>;
        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,
            >,
        >;
        dateAsIsoString: CodecFromEncoded<StringConstructor, Date>;
        dateAsTimestamp: CodecFromEncoded<NumberConstructor, Date>;
        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>) => boolean | TypeCheckError | null,
            typeName?: string,
        ) => T;
        skipCheck: <T extends AnyType>(baseType: T) => 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]>[]>;
        mapFromArray<TKeyType extends AnyType, TValueType extends AnyType>(
            keyType: TKeyType,
            valueType: TValueType,
        ): CodecFromEncoded<
            ArrayType<ArrayType<[TKeyType, TValueType]>[]>,
            Map<TypeToData<TKeyType>, TypeToData<TValueType>>,
        >;
        mapFromObject<T extends AnyType>(
            valueType: T,
        ): CodecFromEncoded<RecordType<T>, Map<string, TypeToData<T>>>;
        mapObject<T extends AnyType>(valueType: T): RecordType<T>;
        setArray<T extends AnyType>(valueType: T): ArrayType<T[]>;
        setFromArray<T extends AnyType>(
            valueType: T,
        ): CodecFromEncoded<
            ArrayType<T[]>,
            Set<TypeToData<T>> | ObservableSet<TypeToData<T>>,
        >;
    } = ...

    Type Declaration

    Settings

    Member Visibility