@jbrowse/mobx-state-tree 5.7.0 → 5.8.6

package/esm/types/index.js

@@ -1,35 +0,0 @@
-// we import the types to re-export them inside types.
-import { DatePrimitive, array, boolean, compose, custom, enumeration, finite, float, frozen, identifier, identifierNumber, integer, late, lazy, literal, map, maybe, maybeNull, model, nullType, number, optional, reference, refinement, safeReference, resilient, snapshotProcessor, string, undefinedType, union } from "../internal.js";
-export const types = {
-    enumeration,
-    model,
-    compose,
-    custom,
-    reference,
-    safeReference,
-    union,
-    optional,
-    literal,
-    maybe,
-    maybeNull,
-    refinement,
-    string,
-    boolean,
-    number,
-    integer,
-    float,
-    finite,
-    Date: DatePrimitive,
-    map,
-    array,
-    frozen,
-    identifier,
-    identifierNumber,
-    late,
-    lazy,
-    undefined: undefinedType,
-    null: nullType,
-    snapshotProcessor,
-    resilient
-};
-//# sourceMappingURL=index.js.map

package/esm/types/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,sDAAsD;AACtD,OAAO,EACL,aAAa,EACb,KAAK,EACL,OAAO,EACP,OAAO,EACP,MAAM,EACN,WAAW,EACX,MAAM,EACN,KAAK,EACL,MAAM,EACN,UAAU,EACV,gBAAgB,EAChB,OAAO,EACP,IAAI,EACJ,IAAI,EACJ,OAAO,EACP,GAAG,EACH,KAAK,EACL,SAAS,EACT,KAAK,EACL,QAAQ,EACR,MAAM,EACN,QAAQ,EACR,SAAS,EACT,UAAU,EACV,aAAa,EACb,SAAS,EACT,iBAAiB,EACjB,MAAM,EACN,aAAa,EACb,KAAK,EACN,MAAM,gBAAgB,CAAA;AAEvB,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,WAAW;IACX,KAAK;IACL,OAAO;IACP,MAAM;IACN,SAAS;IACT,aAAa;IACb,KAAK;IACL,QAAQ;IACR,OAAO;IACP,KAAK;IACL,SAAS;IACT,UAAU;IACV,MAAM;IACN,OAAO;IACP,MAAM;IACN,OAAO;IACP,KAAK;IACL,MAAM;IACN,IAAI,EAAE,aAAa;IACnB,GAAG;IACH,KAAK;IACL,MAAM;IACN,UAAU;IACV,gBAAgB;IAChB,IAAI;IACJ,IAAI;IACJ,SAAS,EAAE,aAAa;IACxB,IAAI,EAAE,QAAQ;IACd,iBAAiB;IACjB,SAAS;CACV,CAAA","sourcesContent":["// we import the types to re-export them inside types.\nimport {\n  DatePrimitive,\n  array,\n  boolean,\n  compose,\n  custom,\n  enumeration,\n  finite,\n  float,\n  frozen,\n  identifier,\n  identifierNumber,\n  integer,\n  late,\n  lazy,\n  literal,\n  map,\n  maybe,\n  maybeNull,\n  model,\n  nullType,\n  number,\n  optional,\n  reference,\n  refinement,\n  safeReference,\n  resilient,\n  snapshotProcessor,\n  string,\n  undefinedType,\n  union\n} from \"../internal.ts\"\n\nexport const types = {\n  enumeration,\n  model,\n  compose,\n  custom,\n  reference,\n  safeReference,\n  union,\n  optional,\n  literal,\n  maybe,\n  maybeNull,\n  refinement,\n  string,\n  boolean,\n  number,\n  integer,\n  float,\n  finite,\n  Date: DatePrimitive,\n  map,\n  array,\n  frozen,\n  identifier,\n  identifierNumber,\n  late,\n  lazy,\n  undefined: undefinedType,\n  null: nullType,\n  snapshotProcessor,\n  resilient\n}\n"]}

package/esm/types/primitives.d.ts

@@ -1,125 +0,0 @@
-import { SimpleType } from "../core/type/type.ts";
-import { TypeFlags } from "../internal.ts";
-import type { AnyObjectNode, ISimpleType, IType, IValidationContext, IValidationResult } from "../internal.ts";
-/**
- * @internal
- * @hidden
- */
-export declare class CoreType<C, S, T> extends SimpleType<C, S, T> {
-    readonly flags: TypeFlags;
-    private readonly checker;
-    private readonly initializer;
-    constructor(name: string, flags: TypeFlags, checker: (value: C) => boolean, initializer?: (v: C) => T);
-    describe(): string;
-    instantiate(parent: AnyObjectNode | null, subpath: string, environment: any, initialValue: C): this["N"];
-    createNewInstance(snapshot: C): T;
-    isValidSnapshot(value: C, context: IValidationContext): IValidationResult;
-}
-/**
- * `types.string` - Creates a type that can only contain a string value.
- * This type is used for string values by default
- *
- * Example:
- * ```ts
- * const Person = types.model({
- *   firstName: types.string,
- *   lastName: "Doe"
- * })
- * ```
- */
-export declare const string: ISimpleType<string>;
-/**
- * `types.number` - Creates a type that can only contain a numeric value.
- * This type is used for numeric values by default
- *
- * Example:
- * ```ts
- * const Vector = types.model({
- *   x: types.number,
- *   y: 1.5
- * })
- * ```
- */
-export declare const number: ISimpleType<number>;
-/**
- * `types.integer` - Creates a type that can only contain an integer value.
- *
- * Example:
- * ```ts
- * const Size = types.model({
- *   width: types.integer,
- *   height: 10
- * })
- * ```
- */
-export declare const integer: ISimpleType<number>;
-/**
- * `types.float` - Creates a type that can only contain an float value.
- *
- * Example:
- * ```ts
- * const Size = types.model({
- *   width: types.float,
- *   height: 10
- * })
- * ```
- */
-export declare const float: ISimpleType<number>;
-/**
- * `types.finite` - Creates a type that can only contain an finite value.
- *
- * Example:
- * ```ts
- * const Size = types.model({
- *   width: types.finite,
- *   height: 10
- * })
- * ```
- */
-export declare const finite: ISimpleType<number>;
-/**
- * `types.boolean` - Creates a type that can only contain a boolean value.
- * This type is used for boolean values by default
- *
- * Example:
- * ```ts
- * const Thing = types.model({
- *   isCool: types.boolean,
- *   isAwesome: false
- * })
- * ```
- */
-export declare const boolean: ISimpleType<boolean>;
-/**
- * `types.null` - The type of the value `null`
- */
-export declare const nullType: ISimpleType<null>;
-/**
- * `types.undefined` - The type of the value `undefined`
- */
-export declare const undefinedType: ISimpleType<undefined>;
-/**
- * `types.Date` - Creates a type that can only contain a javascript Date value.
- *
- * Example:
- * ```ts
- * const LogLine = types.model({
- *   timestamp: types.Date,
- * })
- *
- * LogLine.create({ timestamp: new Date() })
- * ```
- */
-export declare const DatePrimitive: IType<number | Date, number, Date>;
-/**
- * @internal
- * @hidden
- */
-export declare function getPrimitiveFactoryFromValue(value: any): ISimpleType<any>;
-/**
- * Returns if a given value represents a primitive type.
- *
- * @param type
- * @returns
- */
-export declare function isPrimitiveType<IT extends ISimpleType<string> | ISimpleType<number> | ISimpleType<boolean> | typeof DatePrimitive>(type: IT): type is IT;

package/esm/types/primitives.js

@@ -1,177 +0,0 @@
-import { SimpleType } from "../core/type/type.js";
-import { TypeFlags, createScalarNode, fail, identity, isFinite, isFloat, isInteger, isPrimitive, isType, typeCheckFailure, typeCheckSuccess } from "../internal.js";
-// TODO: implement CoreType using types.custom ?
-/**
- * @internal
- * @hidden
- */
-export class CoreType extends SimpleType {
-    flags;
-    checker;
-    initializer;
-    constructor(name, flags, checker, initializer = identity) {
-        super(name);
-        this.flags = flags;
-        this.checker = checker;
-        this.initializer = initializer;
-        this.flags = flags;
-    }
-    describe() {
-        return this.name;
-    }
-    instantiate(parent, subpath, environment, initialValue) {
-        return createScalarNode(this, parent, subpath, environment, initialValue);
-    }
-    createNewInstance(snapshot) {
-        return this.initializer(snapshot);
-    }
-    isValidSnapshot(value, context) {
-        if (isPrimitive(value) && this.checker(value)) {
-            return typeCheckSuccess();
-        }
-        const typeName = this.name === "Date" ? "Date or a unix milliseconds timestamp" : this.name;
-        return typeCheckFailure(context, value, `Value is not a ${typeName}`);
-    }
-}
-/**
- * `types.string` - Creates a type that can only contain a string value.
- * This type is used for string values by default
- *
- * Example:
- * ```ts
- * const Person = types.model({
- *   firstName: types.string,
- *   lastName: "Doe"
- * })
- * ```
- */
-// tslint:disable-next-line:variable-name
-export const string = new CoreType("string", TypeFlags.String, v => typeof v === "string");
-/**
- * `types.number` - Creates a type that can only contain a numeric value.
- * This type is used for numeric values by default
- *
- * Example:
- * ```ts
- * const Vector = types.model({
- *   x: types.number,
- *   y: 1.5
- * })
- * ```
- */
-// tslint:disable-next-line:variable-name
-export const number = new CoreType("number", TypeFlags.Number, v => typeof v === "number");
-/**
- * `types.integer` - Creates a type that can only contain an integer value.
- *
- * Example:
- * ```ts
- * const Size = types.model({
- *   width: types.integer,
- *   height: 10
- * })
- * ```
- */
-// tslint:disable-next-line:variable-name
-export const integer = new CoreType("integer", TypeFlags.Integer, v => isInteger(v));
-/**
- * `types.float` - Creates a type that can only contain an float value.
- *
- * Example:
- * ```ts
- * const Size = types.model({
- *   width: types.float,
- *   height: 10
- * })
- * ```
- */
-// tslint:disable-next-line:variable-name
-export const float = new CoreType("float", TypeFlags.Float, v => isFloat(v));
-/**
- * `types.finite` - Creates a type that can only contain an finite value.
- *
- * Example:
- * ```ts
- * const Size = types.model({
- *   width: types.finite,
- *   height: 10
- * })
- * ```
- */
-// tslint:disable-next-line:variable-name
-export const finite = new CoreType("finite", TypeFlags.Finite, v => isFinite(v));
-/**
- * `types.boolean` - Creates a type that can only contain a boolean value.
- * This type is used for boolean values by default
- *
- * Example:
- * ```ts
- * const Thing = types.model({
- *   isCool: types.boolean,
- *   isAwesome: false
- * })
- * ```
- */
-// tslint:disable-next-line:variable-name
-export const boolean = new CoreType("boolean", TypeFlags.Boolean, v => typeof v === "boolean");
-/**
- * `types.null` - The type of the value `null`
- */
-export const nullType = new CoreType("null", TypeFlags.Null, v => v === null);
-/**
- * `types.undefined` - The type of the value `undefined`
- */
-export const undefinedType = new CoreType("undefined", TypeFlags.Undefined, v => v === undefined);
-const _DatePrimitive = new CoreType("Date", TypeFlags.Date, v => typeof v === "number" || v instanceof Date, v => (v instanceof Date ? v : new Date(v)));
-_DatePrimitive.getSnapshot = function (node) {
-    return node.storedValue.getTime();
-};
-/**
- * `types.Date` - Creates a type that can only contain a javascript Date value.
- *
- * Example:
- * ```ts
- * const LogLine = types.model({
- *   timestamp: types.Date,
- * })
- *
- * LogLine.create({ timestamp: new Date() })
- * ```
- */
-export const DatePrimitive = _DatePrimitive;
-/**
- * @internal
- * @hidden
- */
-export function getPrimitiveFactoryFromValue(value) {
-    switch (typeof value) {
-        case "string":
-            return string;
-        case "number":
-            return number; // In the future, isInteger(value) ? integer : number would be interesting, but would be too breaking for now
-        case "boolean":
-            return boolean;
-        case "object":
-            if (value instanceof Date) {
-                return DatePrimitive;
-            }
-    }
-    throw fail("Cannot determine primitive type from value " + value);
-}
-/**
- * Returns if a given value represents a primitive type.
- *
- * @param type
- * @returns
- */
-export function isPrimitiveType(type) {
-    return (isType(type) &&
-        (type.flags &
-            (TypeFlags.String |
-                TypeFlags.Number |
-                TypeFlags.Integer |
-                TypeFlags.Boolean |
-                TypeFlags.Date)) >
-            0);
-}
-//# sourceMappingURL=primitives.js.map

package/esm/types/primitives.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"primitives.js","sourceRoot":"","sources":["../../src/types/primitives.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACjD,OAAO,EACL,SAAS,EACT,gBAAgB,EAChB,IAAI,EACJ,QAAQ,EACR,QAAQ,EACR,OAAO,EACP,SAAS,EACT,WAAW,EACX,MAAM,EACN,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,gBAAgB,CAAA;AAWvB,gDAAgD;AAChD;;;GAGG;AACH,MAAM,OAAO,QAAkB,SAAQ,UAAmB;IAG7C;IACQ;IACA;IAJnB,YACE,IAAY,EACH,KAAgB,EACR,OAA8B,EAC9B,cAA2B,QAAQ;QAEpD,KAAK,CAAC,IAAI,CAAC,CAAA;QAJF,UAAK,GAAL,KAAK,CAAW;QACR,YAAO,GAAP,OAAO,CAAuB;QAC9B,gBAAW,GAAX,WAAW,CAAwB;QAGpD,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;IACpB,CAAC;IAED,QAAQ;QACN,OAAO,IAAI,CAAC,IAAI,CAAA;IAClB,CAAC;IAED,WAAW,CACT,MAA4B,EAC5B,OAAe,EACf,WAAgB,EAChB,YAAe;QAEf,OAAO,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,YAAY,CAAC,CAAA;IAC3E,CAAC;IAED,iBAAiB,CAAC,QAAW;QAC3B,OAAO,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAA;IACnC,CAAC;IAED,eAAe,CAAC,KAAQ,EAAE,OAA2B;QACnD,IAAI,WAAW,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,KAAY,CAAC,EAAE,CAAC;YACrD,OAAO,gBAAgB,EAAE,CAAA;QAC3B,CAAC;QACD,MAAM,QAAQ,GACZ,IAAI,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,uCAAuC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAA;QAC5E,OAAO,gBAAgB,CAAC,OAAO,EAAE,KAAK,EAAE,kBAAkB,QAAQ,EAAE,CAAC,CAAA;IACvE,CAAC;CACF;AAED;;;;;;;;;;;GAWG;AACH,yCAAyC;AACzC,MAAM,CAAC,MAAM,MAAM,GAAwB,IAAI,QAAQ,CACrD,QAAQ,EACR,SAAS,CAAC,MAAM,EAChB,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAC3B,CAAA;AAED;;;;;;;;;;;GAWG;AACH,yCAAyC;AACzC,MAAM,CAAC,MAAM,MAAM,GAAwB,IAAI,QAAQ,CACrD,QAAQ,EACR,SAAS,CAAC,MAAM,EAChB,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAC3B,CAAA;AAED;;;;;;;;;;GAUG;AACH,yCAAyC;AACzC,MAAM,CAAC,MAAM,OAAO,GAAwB,IAAI,QAAQ,CAItD,SAAS,EAAE,SAAS,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAA;AAElD;;;;;;;;;;GAUG;AACH,yCAAyC;AACzC,MAAM,CAAC,MAAM,KAAK,GAAwB,IAAI,QAAQ,CACpD,OAAO,EACP,SAAS,CAAC,KAAK,EACf,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,CAChB,CAAA;AAED;;;;;;;;;;GAUG;AACH,yCAAyC;AACzC,MAAM,CAAC,MAAM,MAAM,GAAwB,IAAI,QAAQ,CACrD,QAAQ,EACR,SAAS,CAAC,MAAM,EAChB,CAAC,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,CACjB,CAAA;AAED;;;;;;;;;;;GAWG;AACH,yCAAyC;AACzC,MAAM,CAAC,MAAM,OAAO,GAAyB,IAAI,QAAQ,CAIvD,SAAS,EAAE,SAAS,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,KAAK,SAAS,CAAC,CAAA;AAE5D;;GAEG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAsB,IAAI,QAAQ,CACrD,MAAM,EACN,SAAS,CAAC,IAAI,EACd,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,IAAI,CAChB,CAAA;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,aAAa,GAA2B,IAAI,QAAQ,CAI/D,WAAW,EAAE,SAAS,CAAC,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,SAAS,CAAC,CAAA;AAEzD,MAAM,cAAc,GAAG,IAAI,QAAQ,CACjC,MAAM,EACN,SAAS,CAAC,IAAI,EACd,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,YAAY,IAAI,EAC/C,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,YAAY,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,CAC3C,CAAA;AACD,cAAc,CAAC,WAAW,GAAG,UAAU,IAAa;IAClD,OAAO,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,CAAA;AACnC,CAAC,CAAA;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,aAAa,GAAuC,cAAc,CAAA;AAE/E;;;GAGG;AACH,MAAM,UAAU,4BAA4B,CAAC,KAAU;IACrD,QAAQ,OAAO,KAAK,EAAE,CAAC;QACrB,KAAK,QAAQ;YACX,OAAO,MAAM,CAAA;QACf,KAAK,QAAQ;YACX,OAAO,MAAM,CAAA,CAAC,6GAA6G;QAC7H,KAAK,SAAS;YACZ,OAAO,OAAO,CAAA;QAChB,KAAK,QAAQ;YACX,IAAI,KAAK,YAAY,IAAI,EAAE,CAAC;gBAC1B,OAAO,aAAa,CAAA;YACtB,CAAC;IACL,CAAC;IACD,MAAM,IAAI,CAAC,6CAA6C,GAAG,KAAK,CAAC,CAAA;AACnE,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,eAAe,CAM7B,IAAQ;IACR,OAAO,CACL,MAAM,CAAC,IAAI,CAAC;QACZ,CAAC,IAAI,CAAC,KAAK;YACT,CAAC,SAAS,CAAC,MAAM;gBACf,SAAS,CAAC,MAAM;gBAChB,SAAS,CAAC,OAAO;gBACjB,SAAS,CAAC,OAAO;gBACjB,SAAS,CAAC,IAAI,CAAC,CAAC;YAClB,CAAC,CACJ,CAAA;AACH,CAAC","sourcesContent":["import { SimpleType } from \"../core/type/type.ts\"\nimport {\n  TypeFlags,\n  createScalarNode,\n  fail,\n  identity,\n  isFinite,\n  isFloat,\n  isInteger,\n  isPrimitive,\n  isType,\n  typeCheckFailure,\n  typeCheckSuccess\n} from \"../internal.ts\"\n\nimport type {\n  AnyNode,\n  AnyObjectNode,\n  ISimpleType,\n  IType,\n  IValidationContext,\n  IValidationResult\n} from \"../internal.ts\"\n\n// TODO: implement CoreType using types.custom ?\n/**\n * @internal\n * @hidden\n */\nexport class CoreType<C, S, T> extends SimpleType<C, S, T> {\n  constructor(\n    name: string,\n    readonly flags: TypeFlags,\n    private readonly checker: (value: C) => boolean,\n    private readonly initializer: (v: C) => T = identity\n  ) {\n    super(name)\n    this.flags = flags\n  }\n\n  describe() {\n    return this.name\n  }\n\n  instantiate(\n    parent: AnyObjectNode | null,\n    subpath: string,\n    environment: any,\n    initialValue: C\n  ): this[\"N\"] {\n    return createScalarNode(this, parent, subpath, environment, initialValue)\n  }\n\n  createNewInstance(snapshot: C) {\n    return this.initializer(snapshot)\n  }\n\n  isValidSnapshot(value: C, context: IValidationContext): IValidationResult {\n    if (isPrimitive(value) && this.checker(value as any)) {\n      return typeCheckSuccess()\n    }\n    const typeName =\n      this.name === \"Date\" ? \"Date or a unix milliseconds timestamp\" : this.name\n    return typeCheckFailure(context, value, `Value is not a ${typeName}`)\n  }\n}\n\n/**\n * `types.string` - Creates a type that can only contain a string value.\n * This type is used for string values by default\n *\n * Example:\n * ```ts\n * const Person = types.model({\n *   firstName: types.string,\n *   lastName: \"Doe\"\n * })\n * ```\n */\n// tslint:disable-next-line:variable-name\nexport const string: ISimpleType<string> = new CoreType<string, string, string>(\n  \"string\",\n  TypeFlags.String,\n  v => typeof v === \"string\"\n)\n\n/**\n * `types.number` - Creates a type that can only contain a numeric value.\n * This type is used for numeric values by default\n *\n * Example:\n * ```ts\n * const Vector = types.model({\n *   x: types.number,\n *   y: 1.5\n * })\n * ```\n */\n// tslint:disable-next-line:variable-name\nexport const number: ISimpleType<number> = new CoreType<number, number, number>(\n  \"number\",\n  TypeFlags.Number,\n  v => typeof v === \"number\"\n)\n\n/**\n * `types.integer` - Creates a type that can only contain an integer value.\n *\n * Example:\n * ```ts\n * const Size = types.model({\n *   width: types.integer,\n *   height: 10\n * })\n * ```\n */\n// tslint:disable-next-line:variable-name\nexport const integer: ISimpleType<number> = new CoreType<\n  number,\n  number,\n  number\n>(\"integer\", TypeFlags.Integer, v => isInteger(v))\n\n/**\n * `types.float` - Creates a type that can only contain an float value.\n *\n * Example:\n * ```ts\n * const Size = types.model({\n *   width: types.float,\n *   height: 10\n * })\n * ```\n */\n// tslint:disable-next-line:variable-name\nexport const float: ISimpleType<number> = new CoreType<number, number, number>(\n  \"float\",\n  TypeFlags.Float,\n  v => isFloat(v)\n)\n\n/**\n * `types.finite` - Creates a type that can only contain an finite value.\n *\n * Example:\n * ```ts\n * const Size = types.model({\n *   width: types.finite,\n *   height: 10\n * })\n * ```\n */\n// tslint:disable-next-line:variable-name\nexport const finite: ISimpleType<number> = new CoreType<number, number, number>(\n  \"finite\",\n  TypeFlags.Finite,\n  v => isFinite(v)\n)\n\n/**\n * `types.boolean` - Creates a type that can only contain a boolean value.\n * This type is used for boolean values by default\n *\n * Example:\n * ```ts\n * const Thing = types.model({\n *   isCool: types.boolean,\n *   isAwesome: false\n * })\n * ```\n */\n// tslint:disable-next-line:variable-name\nexport const boolean: ISimpleType<boolean> = new CoreType<\n  boolean,\n  boolean,\n  boolean\n>(\"boolean\", TypeFlags.Boolean, v => typeof v === \"boolean\")\n\n/**\n * `types.null` - The type of the value `null`\n */\nexport const nullType: ISimpleType<null> = new CoreType<null, null, null>(\n  \"null\",\n  TypeFlags.Null,\n  v => v === null\n)\n\n/**\n * `types.undefined` - The type of the value `undefined`\n */\nexport const undefinedType: ISimpleType<undefined> = new CoreType<\n  undefined,\n  undefined,\n  undefined\n>(\"undefined\", TypeFlags.Undefined, v => v === undefined)\n\nconst _DatePrimitive = new CoreType<number | Date, number, Date>(\n  \"Date\",\n  TypeFlags.Date,\n  v => typeof v === \"number\" || v instanceof Date,\n  v => (v instanceof Date ? v : new Date(v))\n)\n_DatePrimitive.getSnapshot = function (node: AnyNode) {\n  return node.storedValue.getTime()\n}\n\n/**\n * `types.Date` - Creates a type that can only contain a javascript Date value.\n *\n * Example:\n * ```ts\n * const LogLine = types.model({\n *   timestamp: types.Date,\n * })\n *\n * LogLine.create({ timestamp: new Date() })\n * ```\n */\nexport const DatePrimitive: IType<number | Date, number, Date> = _DatePrimitive\n\n/**\n * @internal\n * @hidden\n */\nexport function getPrimitiveFactoryFromValue(value: any): ISimpleType<any> {\n  switch (typeof value) {\n    case \"string\":\n      return string\n    case \"number\":\n      return number // In the future, isInteger(value) ? integer : number would be interesting, but would be too breaking for now\n    case \"boolean\":\n      return boolean\n    case \"object\":\n      if (value instanceof Date) {\n        return DatePrimitive\n      }\n  }\n  throw fail(\"Cannot determine primitive type from value \" + value)\n}\n\n/**\n * Returns if a given value represents a primitive type.\n *\n * @param type\n * @returns\n */\nexport function isPrimitiveType<\n  IT extends\n    | ISimpleType<string>\n    | ISimpleType<number>\n    | ISimpleType<boolean>\n    | typeof DatePrimitive\n>(type: IT): type is IT {\n  return (\n    isType(type) &&\n    (type.flags &\n      (TypeFlags.String |\n        TypeFlags.Number |\n        TypeFlags.Integer |\n        TypeFlags.Boolean |\n        TypeFlags.Date)) >\n      0\n  )\n}\n"]}

package/esm/types/utility-types/custom.d.ts

@@ -1,75 +0,0 @@
-import { SimpleType } from "../../core/type/type.ts";
-import { type AnyObjectNode, type IType, type IValidationContext, type IValidationResult, TypeFlags } from "../../internal.ts";
-export interface CustomTypeOptions<S, T> {
-    /** Friendly name */
-    name: string;
-    /** given a serialized value and environment, how to turn it into the target type */
-    fromSnapshot(snapshot: S, env?: any): T;
-    /** return the serialization of the current value */
-    toSnapshot(value: T): S;
-    /** if true, this is a converted value, if false, it's a snapshot */
-    isTargetType(value: T | S): boolean;
-    /** a non empty string is assumed to be a validation error */
-    getValidationMessage(snapshot: S): string;
-}
-/**
- * `types.custom` - Creates a custom type. Custom types can be used for arbitrary immutable values, that have a serializable representation. For example, to create your own Date representation, Decimal type etc.
- *
- * The signature of the options is:
- * ```ts
- * export interface CustomTypeOptions<S, T> {
- *     // Friendly name
- *     name: string
- *     // given a serialized value and environment, how to turn it into the target type
- *     fromSnapshot(snapshot: S, env: any): T
- *     // return the serialization of the current value
- *     toSnapshot(value: T): S
- *     // if true, this is a converted value, if false, it's a snapshot
- *     isTargetType(value: T | S): value is T
- *     // a non empty string is assumed to be a validation error
- *     getValidationMessage?(snapshot: S): string
- * }
- * ```
- *
- * Example:
- * ```ts
- * const DecimalPrimitive = types.custom<string, Decimal>({
- *     name: "Decimal",
- *     fromSnapshot(value: string) {
- *         return new Decimal(value)
- *     },
- *     toSnapshot(value: Decimal) {
- *         return value.toString()
- *     },
- *     isTargetType(value: string | Decimal): boolean {
- *         return value instanceof Decimal
- *     },
- *     getValidationMessage(value: string): string {
- *         if (/^-?\d+\.\d+$/.test(value)) return "" // OK
- *         return `'${value}' doesn't look like a valid decimal number`
- *     }
- * })
- *
- * const Wallet = types.model({
- *     balance: DecimalPrimitive
- * })
- * ```
- *
- * @param options
- * @returns
- */
-export declare function custom<S, T>(options: CustomTypeOptions<S, T>): IType<S | T, S, T>;
-/**
- * @internal
- * @hidden
- */
-export declare class CustomType<S, T> extends SimpleType<S | T, S, T> {
-    protected readonly options: CustomTypeOptions<S, T>;
-    readonly flags = TypeFlags.Custom;
-    constructor(options: CustomTypeOptions<S, T>);
-    describe(): string;
-    isValidSnapshot(value: this["C"], context: IValidationContext): IValidationResult;
-    getSnapshot(node: this["N"]): S;
-    instantiate(parent: AnyObjectNode | null, subpath: string, environment: any, initialValue: S | T): this["N"];
-    reconcile(current: this["N"], value: S | T, parent: AnyObjectNode, subpath: string): this["N"];
-}

package/esm/types/utility-types/custom.js

@@ -1,106 +0,0 @@
-import { SimpleType } from "../../core/type/type.js";
-import { TypeFlags, createScalarNode, typeCheckFailure, typeCheckSuccess } from "../../internal.js";
-/**
- * `types.custom` - Creates a custom type. Custom types can be used for arbitrary immutable values, that have a serializable representation. For example, to create your own Date representation, Decimal type etc.
- *
- * The signature of the options is:
- * ```ts
- * export interface CustomTypeOptions<S, T> {
- *     // Friendly name
- *     name: string
- *     // given a serialized value and environment, how to turn it into the target type
- *     fromSnapshot(snapshot: S, env: any): T
- *     // return the serialization of the current value
- *     toSnapshot(value: T): S
- *     // if true, this is a converted value, if false, it's a snapshot
- *     isTargetType(value: T | S): value is T
- *     // a non empty string is assumed to be a validation error
- *     getValidationMessage?(snapshot: S): string
- * }
- * ```
- *
- * Example:
- * ```ts
- * const DecimalPrimitive = types.custom<string, Decimal>({
- *     name: "Decimal",
- *     fromSnapshot(value: string) {
- *         return new Decimal(value)
- *     },
- *     toSnapshot(value: Decimal) {
- *         return value.toString()
- *     },
- *     isTargetType(value: string | Decimal): boolean {
- *         return value instanceof Decimal
- *     },
- *     getValidationMessage(value: string): string {
- *         if (/^-?\d+\.\d+$/.test(value)) return "" // OK
- *         return `'${value}' doesn't look like a valid decimal number`
- *     }
- * })
- *
- * const Wallet = types.model({
- *     balance: DecimalPrimitive
- * })
- * ```
- *
- * @param options
- * @returns
- */
-export function custom(options) {
-    return new CustomType(options);
-}
-/**
- * @internal
- * @hidden
- */
-export class CustomType extends SimpleType {
-    options;
-    flags = TypeFlags.Custom;
-    constructor(options) {
-        super(options.name);
-        this.options = options;
-    }
-    describe() {
-        return this.name;
-    }
-    isValidSnapshot(value, context) {
-        if (this.options.isTargetType(value)) {
-            return typeCheckSuccess();
-        }
-        const typeError = this.options.getValidationMessage(value);
-        if (typeError) {
-            return typeCheckFailure(context, value, `Invalid value for type '${this.name}': ${typeError}`);
-        }
-        return typeCheckSuccess();
-    }
-    getSnapshot(node) {
-        return this.options.toSnapshot(node.storedValue);
-    }
-    instantiate(parent, subpath, environment, initialValue) {
-        const valueToStore = this.options.isTargetType(initialValue)
-            ? initialValue
-            : this.options.fromSnapshot(initialValue, parent && parent.root.environment);
-        return createScalarNode(this, parent, subpath, environment, valueToStore);
-    }
-    reconcile(current, value, parent, subpath) {
-        const isSnapshot = !this.options.isTargetType(value);
-        // in theory customs use scalar nodes which cannot be detached, but still...
-        if (!current.isDetaching) {
-            const unchanged = current.type === this &&
-                (isSnapshot
-                    ? value === current.snapshot
-                    : value === current.storedValue);
-            if (unchanged) {
-                current.setParent(parent, subpath);
-                return current;
-            }
-        }
-        const valueToStore = isSnapshot
-            ? this.options.fromSnapshot(value, parent.root.environment)
-            : value;
-        const newNode = this.instantiate(parent, subpath, undefined, valueToStore);
-        current.die(); // noop if detaching
-        return newNode;
-    }
-}
-//# sourceMappingURL=custom.js.map

package/esm/types/utility-types/custom.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"custom.js","sourceRoot":"","sources":["../../../src/types/utility-types/custom.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AACpD,OAAO,EAKL,SAAS,EACT,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,mBAAmB,CAAA;AAiB1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,UAAU,MAAM,CACpB,OAAgC;IAEhC,OAAO,IAAI,UAAU,CAAO,OAAO,CAAC,CAAA;AACtC,CAAC;AAED;;;GAGG;AACH,MAAM,OAAO,UAAiB,SAAQ,UAAuB;IAG5B;IAFtB,KAAK,GAAG,SAAS,CAAC,MAAM,CAAA;IAEjC,YAA+B,OAAgC;QAC7D,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;QADU,YAAO,GAAP,OAAO,CAAyB;IAE/D,CAAC;IAED,QAAQ;QACN,OAAO,IAAI,CAAC,IAAI,CAAA;IAClB,CAAC;IAED,eAAe,CACb,KAAgB,EAChB,OAA2B;QAE3B,IAAI,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC;YACrC,OAAO,gBAAgB,EAAE,CAAA;QAC3B,CAAC;QAED,MAAM,SAAS,GAAW,IAAI,CAAC,OAAO,CAAC,oBAAoB,CAAC,KAAU,CAAC,CAAA;QACvE,IAAI,SAAS,EAAE,CAAC;YACd,OAAO,gBAAgB,CACrB,OAAO,EACP,KAAK,EACL,2BAA2B,IAAI,CAAC,IAAI,MAAM,SAAS,EAAE,CACtD,CAAA;QACH,CAAC;QACD,OAAO,gBAAgB,EAAE,CAAA;IAC3B,CAAC;IAED,WAAW,CAAC,IAAe;QACzB,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,WAAW,CAAC,CAAA;IAClD,CAAC;IAED,WAAW,CACT,MAA4B,EAC5B,OAAe,EACf,WAAgB,EAChB,YAAmB;QAEnB,MAAM,YAAY,GAAM,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,YAAY,CAAC;YAC7D,CAAC,CAAE,YAAkB;YACrB,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,CACvB,YAAiB,EACjB,MAAM,IAAI,MAAM,CAAC,IAAI,CAAC,WAAW,CAClC,CAAA;QACL,OAAO,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,YAAY,CAAC,CAAA;IAC3E,CAAC;IAED,SAAS,CACP,OAAkB,EAClB,KAAY,EACZ,MAAqB,EACrB,OAAe;QAEf,MAAM,UAAU,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC,CAAA;QACpD,4EAA4E;QAC5E,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC;YACzB,MAAM,SAAS,GACb,OAAO,CAAC,IAAI,KAAK,IAAI;gBACrB,CAAC,UAAU;oBACT,CAAC,CAAC,KAAK,KAAK,OAAO,CAAC,QAAQ;oBAC5B,CAAC,CAAC,KAAK,KAAK,OAAO,CAAC,WAAW,CAAC,CAAA;YACpC,IAAI,SAAS,EAAE,CAAC;gBACd,OAAO,CAAC,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;gBAClC,OAAO,OAAO,CAAA;YAChB,CAAC;QACH,CAAC;QACD,MAAM,YAAY,GAAM,UAAU;YAChC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,KAAU,EAAE,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC;YAChE,CAAC,CAAE,KAAW,CAAA;QAChB,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,YAAY,CAAC,CAAA;QAC1E,OAAO,CAAC,GAAG,EAAE,CAAA,CAAC,oBAAoB;QAClC,OAAO,OAAO,CAAA;IAChB,CAAC;CACF","sourcesContent":["import { SimpleType } from \"../../core/type/type.ts\"\nimport {\n  type AnyObjectNode,\n  type IType,\n  type IValidationContext,\n  type IValidationResult,\n  TypeFlags,\n  createScalarNode,\n  typeCheckFailure,\n  typeCheckSuccess\n} from \"../../internal.ts\"\n\nexport interface CustomTypeOptions<S, T> {\n  /** Friendly name */\n  name: string\n  /** given a serialized value and environment, how to turn it into the target type */\n  fromSnapshot(snapshot: S, env?: any): T\n  /** return the serialization of the current value */\n  toSnapshot(value: T): S\n  /** if true, this is a converted value, if false, it's a snapshot */\n  isTargetType(value: T | S): boolean\n  /** a non empty string is assumed to be a validation error */\n  getValidationMessage(snapshot: S): string\n  // TODO: isSnapshotEqual\n  // TODO: isValueEqual\n}\n\n/**\n * `types.custom` - Creates a custom type. Custom types can be used for arbitrary immutable values, that have a serializable representation. For example, to create your own Date representation, Decimal type etc.\n *\n * The signature of the options is:\n * ```ts\n * export interface CustomTypeOptions<S, T> {\n *     // Friendly name\n *     name: string\n *     // given a serialized value and environment, how to turn it into the target type\n *     fromSnapshot(snapshot: S, env: any): T\n *     // return the serialization of the current value\n *     toSnapshot(value: T): S\n *     // if true, this is a converted value, if false, it's a snapshot\n *     isTargetType(value: T | S): value is T\n *     // a non empty string is assumed to be a validation error\n *     getValidationMessage?(snapshot: S): string\n * }\n * ```\n *\n * Example:\n * ```ts\n * const DecimalPrimitive = types.custom<string, Decimal>({\n *     name: \"Decimal\",\n *     fromSnapshot(value: string) {\n *         return new Decimal(value)\n *     },\n *     toSnapshot(value: Decimal) {\n *         return value.toString()\n *     },\n *     isTargetType(value: string | Decimal): boolean {\n *         return value instanceof Decimal\n *     },\n *     getValidationMessage(value: string): string {\n *         if (/^-?\\d+\\.\\d+$/.test(value)) return \"\" // OK\n *         return `'${value}' doesn't look like a valid decimal number`\n *     }\n * })\n *\n * const Wallet = types.model({\n *     balance: DecimalPrimitive\n * })\n * ```\n *\n * @param options\n * @returns\n */\nexport function custom<S, T>(\n  options: CustomTypeOptions<S, T>\n): IType<S | T, S, T> {\n  return new CustomType<S, T>(options)\n}\n\n/**\n * @internal\n * @hidden\n */\nexport class CustomType<S, T> extends SimpleType<S | T, S, T> {\n  readonly flags = TypeFlags.Custom\n\n  constructor(protected readonly options: CustomTypeOptions<S, T>) {\n    super(options.name)\n  }\n\n  describe() {\n    return this.name\n  }\n\n  isValidSnapshot(\n    value: this[\"C\"],\n    context: IValidationContext\n  ): IValidationResult {\n    if (this.options.isTargetType(value)) {\n      return typeCheckSuccess()\n    }\n\n    const typeError: string = this.options.getValidationMessage(value as S)\n    if (typeError) {\n      return typeCheckFailure(\n        context,\n        value,\n        `Invalid value for type '${this.name}': ${typeError}`\n      )\n    }\n    return typeCheckSuccess()\n  }\n\n  getSnapshot(node: this[\"N\"]): S {\n    return this.options.toSnapshot(node.storedValue)\n  }\n\n  instantiate(\n    parent: AnyObjectNode | null,\n    subpath: string,\n    environment: any,\n    initialValue: S | T\n  ): this[\"N\"] {\n    const valueToStore: T = this.options.isTargetType(initialValue)\n      ? (initialValue as T)\n      : this.options.fromSnapshot(\n          initialValue as S,\n          parent && parent.root.environment\n        )\n    return createScalarNode(this, parent, subpath, environment, valueToStore)\n  }\n\n  reconcile(\n    current: this[\"N\"],\n    value: S | T,\n    parent: AnyObjectNode,\n    subpath: string\n  ): this[\"N\"] {\n    const isSnapshot = !this.options.isTargetType(value)\n    // in theory customs use scalar nodes which cannot be detached, but still...\n    if (!current.isDetaching) {\n      const unchanged =\n        current.type === this &&\n        (isSnapshot\n          ? value === current.snapshot\n          : value === current.storedValue)\n      if (unchanged) {\n        current.setParent(parent, subpath)\n        return current\n      }\n    }\n    const valueToStore: T = isSnapshot\n      ? this.options.fromSnapshot(value as S, parent.root.environment)\n      : (value as T)\n    const newNode = this.instantiate(parent, subpath, undefined, valueToStore)\n    current.die() // noop if detaching\n    return newNode\n  }\n}\n"]}

package/esm/types/utility-types/enumeration.d.ts

@@ -1,5 +0,0 @@
-import { type ISimpleType } from "../../internal.ts";
-/** @hidden */
-export type UnionStringArray<T extends readonly string[]> = T[number];
-export declare function enumeration<T extends readonly string[]>(options: T): ISimpleType<UnionStringArray<T>>;
-export declare function enumeration<T extends string>(name: string, options: T[]): ISimpleType<UnionStringArray<T[]>>;

package/esm/types/utility-types/enumeration.js

@@ -1,31 +0,0 @@
-import { assertIsString, devMode, literal, union } from "../../internal.js";
-/**
- * `types.enumeration` - Can be used to create an string based enumeration.
- * (note: this methods is just sugar for a union of string literals)
- *
- * Example:
- * ```ts
- * const TrafficLight = types.model({
- *   color: types.enumeration("Color", ["Red", "Orange", "Green"])
- * })
- * ```
- *
- * @param name descriptive name of the enumeration (optional)
- * @param options possible values this enumeration can have
- * @returns
- */
-export function enumeration(name, options) {
-    const realOptions = typeof name === "string" ? options : name;
-    // check all options
-    if (devMode()) {
-        realOptions.forEach((option, i) => {
-            assertIsString(option, i + 1);
-        });
-    }
-    const type = union(...realOptions.map(option => literal("" + option)));
-    if (typeof name === "string") {
-        type.name = name;
-    }
-    return type;
-}
-//# sourceMappingURL=enumeration.js.map

package/esm/types/utility-types/enumeration.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"enumeration.js","sourceRoot":"","sources":["../../../src/types/utility-types/enumeration.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,cAAc,EACd,OAAO,EACP,OAAO,EACP,KAAK,EACN,MAAM,mBAAmB,CAAA;AAkB1B;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,WAAW,CACzB,IAAuB,EACvB,OAAa;IAEb,MAAM,WAAW,GAAa,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,OAAQ,CAAC,CAAC,CAAC,IAAI,CAAA;IACxE,oBAAoB;IACpB,IAAI,OAAO,EAAE,EAAE,CAAC;QACd,WAAW,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAChC,cAAc,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAA;QAC/B,CAAC,CAAC,CAAA;IACJ,CAAC;IACD,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAA;IACtE,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC7B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;IAClB,CAAC;IACD,OAAO,IAAI,CAAA;AACb,CAAC","sourcesContent":["import {\n  type ISimpleType,\n  assertIsString,\n  devMode,\n  literal,\n  union\n} from \"../../internal.ts\"\n\n/** @hidden */\nexport type UnionStringArray<T extends readonly string[]> = T[number]\n\n// strongly typed enumeration forms for plain and readonly string arrays (when passed directly to the function).\n// with these overloads, we get correct typing for native TS string enums when we use Object.values(Enum) as Enum[] as options.\n// these overloads also allow both mutable and immutable arrays, making types.enumeration<Enum>(Object.values(Enum)) possible.\n// the only case where this doesn't work is when passing to the function an array variable with a mutable type constraint;\n// for these cases, it will just fallback and assume the type is a generic string.\nexport function enumeration<T extends readonly string[]>(\n  options: T\n): ISimpleType<UnionStringArray<T>>\nexport function enumeration<T extends string>(\n  name: string,\n  options: T[]\n): ISimpleType<UnionStringArray<T[]>>\n\n/**\n * `types.enumeration` - Can be used to create an string based enumeration.\n * (note: this methods is just sugar for a union of string literals)\n *\n * Example:\n * ```ts\n * const TrafficLight = types.model({\n *   color: types.enumeration(\"Color\", [\"Red\", \"Orange\", \"Green\"])\n * })\n * ```\n *\n * @param name descriptive name of the enumeration (optional)\n * @param options possible values this enumeration can have\n * @returns\n */\nexport function enumeration(\n  name: string | string[],\n  options?: any\n): ISimpleType<string> {\n  const realOptions: string[] = typeof name === \"string\" ? options! : name\n  // check all options\n  if (devMode()) {\n    realOptions.forEach((option, i) => {\n      assertIsString(option, i + 1)\n    })\n  }\n  const type = union(...realOptions.map(option => literal(\"\" + option)))\n  if (typeof name === \"string\") {\n    type.name = name\n  }\n  return type\n}\n"]}

package/esm/types/utility-types/frozen.d.ts

@@ -1,24 +0,0 @@
-import { SimpleType } from "../../core/type/type.ts";
-import { type AnyObjectNode, type IAnyType, type IType, type IValidationContext, type IValidationResult, TypeFlags } from "../../internal.ts";
-/**
- * @internal
- * @hidden
- */
-export declare class Frozen<T> extends SimpleType<T, T, T> {
-    private subType?;
-    flags: TypeFlags;
-    constructor(subType?: IAnyType | undefined);
-    describe(): string;
-    instantiate(parent: AnyObjectNode | null, subpath: string, environment: any, value: this["C"]): this["N"];
-    isValidSnapshot(value: this["C"], context: IValidationContext): IValidationResult;
-}
-export declare function frozen<C>(subType: IType<C, any, any>): IType<C, C, C>;
-export declare function frozen<T>(defaultValue: T): IType<T | undefined | null, T, T>;
-export declare function frozen<T = any>(): IType<T, T, T>;
-/**
- * Returns if a given value represents a frozen type.
- *
- * @param type
- * @returns
- */
-export declare function isFrozenType<IT extends IType<T | any, T, T>, T = any>(type: IT): type is IT;