quicktype 16.0.42 → 17.0.0

package/dist/quicktype-core/Type.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnionType = exports.IntersectionType = exports.SetOperationType = exports.intersectionTypeIdentity = exports.unionTypeIdentity = exports.setOperationTypeIdentity = exports.setOperationCasesEqual = exports.EnumType = exports.enumTypeIdentity = exports.MapType = exports.ClassType = exports.ObjectType = exports.mapTypeIdentify = exports.classTypeIdentity = exports.ClassProperty = exports.GenericClassProperty = exports.ArrayType = exports.arrayTypeIdentity = exports.PrimitiveType = exports.primitiveTypeIdentity = exports.Type = exports.TypeIdentity = exports.isPrimitiveTypeKind = exports.isNumberTypeKind = exports.targetTypeKindForTransformedStringTypeKind = exports.isPrimitiveStringTypeKind = exports.transformedStringTypeKinds = exports.transformedStringTypeTargetTypeKindsMap = void 0;
 const collection_utils_1 = require("collection-utils");
 const Support_1 = require("./support/Support");
 const TypeNames_1 = require("./attributes/TypeNames");
@@ -21,10 +22,10 @@ const transformedStringTypeTargetTypeKinds = {
     "integer-string": { jsonSchema: "integer", primitive: "integer" },
     "bool-string": { jsonSchema: "boolean", primitive: "bool" }
 };
-exports.transformedStringTypeTargetTypeKindsMap = collection_utils_1.mapFromObject(transformedStringTypeTargetTypeKinds);
+exports.transformedStringTypeTargetTypeKindsMap = (0, collection_utils_1.mapFromObject)(transformedStringTypeTargetTypeKinds);
 exports.transformedStringTypeKinds = new Set(Object.getOwnPropertyNames(transformedStringTypeTargetTypeKinds));
 function isPrimitiveStringTypeKind(kind) {
-    return kind === "string" || collection_utils_1.hasOwnProperty(transformedStringTypeTargetTypeKinds, kind);
+    return kind === "string" || (0, collection_utils_1.hasOwnProperty)(transformedStringTypeTargetTypeKinds, kind);
 }
 exports.isPrimitiveStringTypeKind = isPrimitiveStringTypeKind;
 function targetTypeKindForTransformedStringTypeKind(kind) {
@@ -54,13 +55,16 @@ function triviallyStructurallyCompatible(x, y) {
     return false;
 }
 class TypeIdentity {
+    _kind;
+    _components;
+    _hashCode;
     constructor(_kind, _components) {
         this._kind = _kind;
         this._components = _components;
         let h = collection_utils_1.hashCodeInit;
-        h = collection_utils_1.addHashCode(h, collection_utils_1.hashCodeOf(this._kind));
+        h = (0, collection_utils_1.addHashCode)(h, (0, collection_utils_1.hashCodeOf)(this._kind));
         for (const c of _components) {
-            h = collection_utils_1.addHashCode(h, collection_utils_1.hashCodeOf(c));
+            h = (0, collection_utils_1.addHashCode)(h, (0, collection_utils_1.hashCodeOf)(c));
         }
         this._hashCode = h;
     }
@@ -70,9 +74,9 @@ class TypeIdentity {
         if (this._kind !== other._kind)
             return false;
         const n = this._components.length;
-        Support_1.assert(n === other._components.length, "Components of a type kind's identity must have the same length");
+        (0, Support_1.assert)(n === other._components.length, "Components of a type kind's identity must have the same length");
         for (let i = 0; i < n; i++) {
-            if (!collection_utils_1.areEqual(this._components[i], other._components[i]))
+            if (!(0, collection_utils_1.areEqual)(this._components[i], other._components[i]))
                 return false;
         }
         return true;
@@ -83,31 +87,32 @@ class TypeIdentity {
 }
 exports.TypeIdentity = TypeIdentity;
 class Type {
-    constructor(typeRef, graph, kind) {
+    typeRef;
+    graph;
+    constructor(typeRef, graph) {
         this.typeRef = typeRef;
         this.graph = graph;
-        this.kind = kind;
     }
     get index() {
-        return TypeGraph_1.typeRefIndex(this.typeRef);
+        return (0, TypeGraph_1.typeRefIndex)(this.typeRef);
     }
     getChildren() {
         let result = this.getNonAttributeChildren();
         for (const [k, v] of this.getAttributes()) {
             if (k.children === undefined)
                 continue;
-            collection_utils_1.setUnionInto(result, k.children(v));
+            (0, collection_utils_1.setUnionInto)(result, k.children(v));
         }
         return result;
     }
     getAttributes() {
-        return TypeGraph_1.attributesForTypeRef(this.typeRef, this.graph);
+        return (0, TypeGraph_1.attributesForTypeRef)(this.typeRef, this.graph);
     }
     get hasNames() {
         return TypeNames_1.namesTypeAttributeKind.tryGetInAttributes(this.getAttributes()) !== undefined;
     }
     getNames() {
-        return Support_1.defined(TypeNames_1.namesTypeAttributeKind.tryGetInAttributes(this.getAttributes()));
+        return (0, Support_1.defined)(TypeNames_1.namesTypeAttributeKind.tryGetInAttributes(this.getAttributes()));
     }
     getCombinedName() {
         return this.getNames().combinedName;
@@ -121,7 +126,7 @@ class Type {
         return this.typeRef === other.typeRef;
     }
     hashCode() {
-        return collection_utils_1.hashCodeOf(this.typeRef);
+        return (0, collection_utils_1.hashCodeOf)(this.typeRef);
     }
     structurallyCompatible(other, conflateNumbers = false) {
         function kindsCompatible(kind1, kind2) {
@@ -156,7 +161,7 @@ class Type {
             return true;
         };
         while (workList.length > 0) {
-            let [a, b] = Support_1.defined(workList.pop());
+            let [a, b] = (0, Support_1.defined)(workList.pop());
             if (a.index > b.index) {
                 [a, b] = [b, a];
             }
@@ -214,10 +219,10 @@ class Type {
 }
 exports.Type = Type;
 function hasUniqueIdentityAttributes(attributes) {
-    return collection_utils_1.mapSome(attributes, (v, ta) => ta.requiresUniqueIdentity(v));
+    return (0, collection_utils_1.mapSome)(attributes, (v, ta) => ta.requiresUniqueIdentity(v));
 }
 function identityAttributes(attributes) {
-    return collection_utils_1.mapFilter(attributes, (_, kind) => kind.inIdentity);
+    return (0, collection_utils_1.mapFilter)(attributes, (_, kind) => kind.inIdentity);
 }
 function primitiveTypeIdentity(kind, attributes) {
     if (hasUniqueIdentityAttributes(attributes))
@@ -226,6 +231,11 @@ function primitiveTypeIdentity(kind, attributes) {
 }
 exports.primitiveTypeIdentity = primitiveTypeIdentity;
 class PrimitiveType extends Type {
+    kind;
+    constructor(typeRef, graph, kind) {
+        super(typeRef, graph);
+        this.kind = kind;
+    }
     get isNullable() {
         return this.kind === "null" || this.kind === "any" || this.kind === "none";
     }
@@ -253,24 +263,26 @@ function arrayTypeIdentity(attributes, itemsRef) {
 }
 exports.arrayTypeIdentity = arrayTypeIdentity;
 class ArrayType extends Type {
+    _itemsRef;
+    kind = "array";
     constructor(typeRef, graph, _itemsRef) {
-        super(typeRef, graph, "array");
+        super(typeRef, graph);
         this._itemsRef = _itemsRef;
     }
     setItems(itemsRef) {
         if (this._itemsRef !== undefined) {
-            return Support_1.panic("Can only set array items once");
+            return (0, Support_1.panic)("Can only set array items once");
         }
         this._itemsRef = itemsRef;
     }
     getItemsRef() {
         if (this._itemsRef === undefined) {
-            return Support_1.panic("Array items accessed before they were set");
+            return (0, Support_1.panic)("Array items accessed before they were set");
         }
         return this._itemsRef;
     }
     get items() {
-        return TypeGraph_1.derefTypeRef(this.getItemsRef(), this.graph);
+        return (0, TypeGraph_1.derefTypeRef)(this.getItemsRef(), this.graph);
     }
     getNonAttributeChildren() {
         return new Set([this.items]);
@@ -301,6 +313,8 @@ class ArrayType extends Type {
 }
 exports.ArrayType = ArrayType;
 class GenericClassProperty {
+    typeData;
+    isOptional;
     constructor(typeData, isOptional) {
         this.typeData = typeData;
         this.isOptional = isOptional;
@@ -309,14 +323,15 @@ class GenericClassProperty {
         if (!(other instanceof GenericClassProperty)) {
             return false;
         }
-        return collection_utils_1.areEqual(this.typeData, other.typeData) && this.isOptional === other.isOptional;
+        return (0, collection_utils_1.areEqual)(this.typeData, other.typeData) && this.isOptional === other.isOptional;
     }
     hashCode() {
-        return collection_utils_1.hashCodeOf(this.typeData) + (this.isOptional ? 17 : 23);
+        return (0, collection_utils_1.hashCodeOf)(this.typeData) + (this.isOptional ? 17 : 23);
     }
 }
 exports.GenericClassProperty = GenericClassProperty;
 class ClassProperty extends GenericClassProperty {
+    graph;
     constructor(typeRef, graph, isOptional) {
         super(typeRef, isOptional);
         this.graph = graph;
@@ -325,7 +340,7 @@ class ClassProperty extends GenericClassProperty {
         return this.typeData;
     }
     get type() {
-        return TypeGraph_1.derefTypeRef(this.typeRef, this.graph);
+        return (0, TypeGraph_1.derefTypeRef)(this.typeRef, this.graph);
     }
 }
 exports.ClassProperty = ClassProperty;
@@ -343,53 +358,58 @@ function mapTypeIdentify(attributes, additionalPropertiesRef) {
 }
 exports.mapTypeIdentify = mapTypeIdentify;
 class ObjectType extends Type {
+    kind;
+    isFixed;
+    _properties;
+    _additionalPropertiesRef;
     constructor(typeRef, graph, kind, isFixed, _properties, _additionalPropertiesRef) {
-        super(typeRef, graph, kind);
+        super(typeRef, graph);
+        this.kind = kind;
         this.isFixed = isFixed;
         this._properties = _properties;
         this._additionalPropertiesRef = _additionalPropertiesRef;
         if (kind === "map") {
             if (_properties !== undefined) {
-                Support_1.assert(_properties.size === 0);
+                (0, Support_1.assert)(_properties.size === 0);
             }
-            Support_1.assert(!isFixed);
+            (0, Support_1.assert)(!isFixed);
         }
         else if (kind === "class") {
-            Support_1.assert(_additionalPropertiesRef === undefined);
+            (0, Support_1.assert)(_additionalPropertiesRef === undefined);
         }
         else {
-            Support_1.assert(isFixed);
+            (0, Support_1.assert)(isFixed);
         }
     }
     setProperties(properties, additionalPropertiesRef) {
-        Support_1.assert(this._properties === undefined, "Tried to set object properties twice");
+        (0, Support_1.assert)(this._properties === undefined, "Tried to set object properties twice");
         if (this instanceof MapType) {
-            Support_1.assert(properties.size === 0, "Cannot set properties on map type");
+            (0, Support_1.assert)(properties.size === 0, "Cannot set properties on map type");
         }
         if (this instanceof ClassType) {
-            Support_1.assert(additionalPropertiesRef === undefined, "Cannot set additional properties of class type");
+            (0, Support_1.assert)(additionalPropertiesRef === undefined, "Cannot set additional properties of class type");
         }
         this._properties = properties;
         this._additionalPropertiesRef = additionalPropertiesRef;
     }
     getProperties() {
-        return Support_1.defined(this._properties);
+        return (0, Support_1.defined)(this._properties);
     }
     getSortedProperties() {
-        return collection_utils_1.mapSortByKey(this.getProperties());
+        return (0, collection_utils_1.mapSortByKey)(this.getProperties());
     }
     getAdditionalPropertiesRef() {
-        Support_1.assert(this._properties !== undefined, "Properties are not set yet");
+        (0, Support_1.assert)(this._properties !== undefined, "Properties are not set yet");
         return this._additionalPropertiesRef;
     }
     getAdditionalProperties() {
         const tref = this.getAdditionalPropertiesRef();
         if (tref === undefined)
             return undefined;
-        return TypeGraph_1.derefTypeRef(tref, this.graph);
+        return (0, TypeGraph_1.derefTypeRef)(tref, this.graph);
     }
     getNonAttributeChildren() {
-        const types = collection_utils_1.mapSortToArray(this.getProperties(), (_, k) => k).map(([_, p]) => p.type);
+        const types = (0, collection_utils_1.mapSortToArray)(this.getProperties(), (_, k) => k).map(([_, p]) => p.type);
         const additionalProperties = this.getAdditionalProperties();
         if (additionalProperties !== undefined) {
             types.push(additionalProperties);
@@ -410,18 +430,18 @@ class ObjectType extends Type {
     reconstitute(builder, canonicalOrder) {
         const sortedProperties = this.getSortedProperties();
         const propertiesInNewOrder = canonicalOrder ? sortedProperties : this.getProperties();
-        const maybePropertyTypes = builder.lookupMap(collection_utils_1.mapMap(sortedProperties, cp => cp.typeRef));
-        const maybeAdditionalProperties = collection_utils_1.definedMap(this._additionalPropertiesRef, r => builder.lookup(r));
+        const maybePropertyTypes = builder.lookupMap((0, collection_utils_1.mapMap)(sortedProperties, cp => cp.typeRef));
+        const maybeAdditionalProperties = (0, collection_utils_1.definedMap)(this._additionalPropertiesRef, r => builder.lookup(r));
         if (maybePropertyTypes !== undefined &&
             (maybeAdditionalProperties !== undefined || this._additionalPropertiesRef === undefined)) {
-            const properties = collection_utils_1.mapMap(propertiesInNewOrder, (cp, n) => builder.makeClassProperty(Support_1.defined(maybePropertyTypes.get(n)), cp.isOptional));
+            const properties = (0, collection_utils_1.mapMap)(propertiesInNewOrder, (cp, n) => builder.makeClassProperty((0, Support_1.defined)(maybePropertyTypes.get(n)), cp.isOptional));
             switch (this.kind) {
                 case "object":
-                    Support_1.assert(this.isFixed);
+                    (0, Support_1.assert)(this.isFixed);
                     builder.getObjectType(properties, maybeAdditionalProperties);
                     break;
                 case "map":
-                    builder.getMapType(Support_1.defined(maybeAdditionalProperties));
+                    builder.getMapType((0, Support_1.defined)(maybeAdditionalProperties));
                     break;
                 case "class":
                     if (this.isFixed) {
@@ -432,13 +452,13 @@ class ObjectType extends Type {
                     }
                     break;
                 default:
-                    return Support_1.panic(`Invalid object type kind ${this.kind}`);
+                    return (0, Support_1.panic)(`Invalid object type kind ${this.kind}`);
             }
         }
         else {
             switch (this.kind) {
                 case "object":
-                    Support_1.assert(this.isFixed);
+                    (0, Support_1.assert)(this.isFixed);
                     builder.getUniqueObjectType(undefined, undefined);
                     break;
                 case "map":
@@ -448,11 +468,11 @@ class ObjectType extends Type {
                     builder.getUniqueClassType(this.isFixed, undefined);
                     break;
                 default:
-                    return Support_1.panic(`Invalid object type kind ${this.kind}`);
+                    return (0, Support_1.panic)(`Invalid object type kind ${this.kind}`);
             }
-            const reconstitutedTypes = collection_utils_1.mapMap(sortedProperties, cp => builder.reconstitute(cp.typeRef));
-            const properties = collection_utils_1.mapMap(propertiesInNewOrder, (cp, n) => builder.makeClassProperty(Support_1.defined(reconstitutedTypes.get(n)), cp.isOptional));
-            const additionalProperties = collection_utils_1.definedMap(this._additionalPropertiesRef, r => builder.reconstitute(r));
+            const reconstitutedTypes = (0, collection_utils_1.mapMap)(sortedProperties, cp => builder.reconstitute(cp.typeRef));
+            const properties = (0, collection_utils_1.mapMap)(propertiesInNewOrder, (cp, n) => builder.makeClassProperty((0, Support_1.defined)(reconstitutedTypes.get(n)), cp.isOptional));
+            const additionalProperties = (0, collection_utils_1.definedMap)(this._additionalPropertiesRef, r => builder.reconstitute(r));
             builder.setObjectProperties(properties, additionalProperties);
         }
     }
@@ -489,11 +509,11 @@ class ClassType extends ObjectType {
 exports.ClassType = ClassType;
 class MapType extends ObjectType {
     constructor(typeRef, graph, valuesRef) {
-        super(typeRef, graph, "map", false, collection_utils_1.definedMap(valuesRef, () => new Map()), valuesRef);
+        super(typeRef, graph, "map", false, (0, collection_utils_1.definedMap)(valuesRef, () => new Map()), valuesRef);
     }
     // FIXME: Remove and use `getAdditionalProperties()` instead.
     get values() {
-        return Support_1.defined(this.getAdditionalProperties());
+        return (0, Support_1.defined)(this.getAdditionalProperties());
     }
 }
 exports.MapType = MapType;
@@ -504,8 +524,10 @@ function enumTypeIdentity(attributes, cases) {
 }
 exports.enumTypeIdentity = enumTypeIdentity;
 class EnumType extends Type {
+    cases;
+    kind = "enum";
     constructor(typeRef, graph, cases) {
-        super(typeRef, graph, "enum");
+        super(typeRef, graph);
         this.cases = cases;
     }
     get isNullable() {
@@ -524,25 +546,25 @@ class EnumType extends Type {
         builder.getEnumType(this.cases);
     }
     structuralEqualityStep(other, _conflateNumbers, _queue) {
-        return collection_utils_1.areEqual(this.cases, other.cases);
+        return (0, collection_utils_1.areEqual)(this.cases, other.cases);
     }
 }
 exports.EnumType = EnumType;
 function setOperationCasesEqual(typesA, typesB, conflateNumbers, membersEqual) {
-    const ma = collection_utils_1.toReadonlySet(typesA);
-    const mb = collection_utils_1.toReadonlySet(typesB);
+    const ma = (0, collection_utils_1.toReadonlySet)(typesA);
+    const mb = (0, collection_utils_1.toReadonlySet)(typesB);
     if (ma.size !== mb.size)
         return false;
-    return collection_utils_1.iterableEvery(ma, ta => {
-        const tb = collection_utils_1.iterableFind(mb, t => t.kind === ta.kind);
+    return (0, collection_utils_1.iterableEvery)(ma, ta => {
+        const tb = (0, collection_utils_1.iterableFind)(mb, t => t.kind === ta.kind);
         if (tb !== undefined) {
             if (membersEqual(ta, tb))
                 return true;
         }
         if (conflateNumbers) {
-            if (ta.kind === "integer" && collection_utils_1.iterableSome(mb, t => t.kind === "double"))
+            if (ta.kind === "integer" && (0, collection_utils_1.iterableSome)(mb, t => t.kind === "double"))
                 return true;
-            if (ta.kind === "double" && collection_utils_1.iterableSome(mb, t => t.kind === "integer"))
+            if (ta.kind === "double" && (0, collection_utils_1.iterableSome)(mb, t => t.kind === "integer"))
                 return true;
         }
         return false;
@@ -564,31 +586,34 @@ function intersectionTypeIdentity(attributes, memberRefs) {
 }
 exports.intersectionTypeIdentity = intersectionTypeIdentity;
 class SetOperationType extends Type {
+    kind;
+    _memberRefs;
     constructor(typeRef, graph, kind, _memberRefs) {
-        super(typeRef, graph, kind);
+        super(typeRef, graph);
+        this.kind = kind;
         this._memberRefs = _memberRefs;
     }
     setMembers(memberRefs) {
         if (this._memberRefs !== undefined) {
-            return Support_1.panic("Can only set map members once");
+            return (0, Support_1.panic)("Can only set map members once");
         }
         this._memberRefs = memberRefs;
     }
     getMemberRefs() {
         if (this._memberRefs === undefined) {
-            return Support_1.panic("Map members accessed before they were set");
+            return (0, Support_1.panic)("Map members accessed before they were set");
         }
         return this._memberRefs;
     }
     get members() {
-        return collection_utils_1.setMap(this.getMemberRefs(), tref => TypeGraph_1.derefTypeRef(tref, this.graph));
+        return (0, collection_utils_1.setMap)(this.getMemberRefs(), tref => (0, TypeGraph_1.derefTypeRef)(tref, this.graph));
     }
     get sortedMembers() {
         return this.getNonAttributeChildren();
     }
     getNonAttributeChildren() {
         // FIXME: We're assuming no two members of the same kind.
-        return collection_utils_1.setSortBy(this.members, t => t.kind);
+        return (0, collection_utils_1.setSortBy)(this.members, t => t.kind);
     }
     isPrimitive() {
         return false;
@@ -597,16 +622,16 @@ class SetOperationType extends Type {
         return setOperationTypeIdentity(this.kind, this.getAttributes(), this.getMemberRefs());
     }
     reconstituteSetOperation(builder, canonicalOrder, getType) {
-        const sortedMemberRefs = collection_utils_1.mapMap(this.sortedMembers.entries(), t => t.typeRef);
+        const sortedMemberRefs = (0, collection_utils_1.mapMap)(this.sortedMembers.entries(), t => t.typeRef);
         const membersInOrder = canonicalOrder ? this.sortedMembers : this.members;
         const maybeMembers = builder.lookupMap(sortedMemberRefs);
         if (maybeMembers === undefined) {
             getType(undefined);
             const reconstituted = builder.reconstituteMap(sortedMemberRefs);
-            builder.setSetOperationMembers(collection_utils_1.setMap(membersInOrder, t => Support_1.defined(reconstituted.get(t))));
+            builder.setSetOperationMembers((0, collection_utils_1.setMap)(membersInOrder, t => (0, Support_1.defined)(reconstituted.get(t))));
         }
         else {
-            getType(collection_utils_1.setMap(membersInOrder, t => Support_1.defined(maybeMembers.get(t))));
+            getType((0, collection_utils_1.setMap)(membersInOrder, t => (0, Support_1.defined)(maybeMembers.get(t))));
         }
     }
     structuralEqualityStep(other, conflateNumbers, queue) {
@@ -619,7 +644,7 @@ class IntersectionType extends SetOperationType {
         super(typeRef, graph, "intersection", memberRefs);
     }
     get isNullable() {
-        return Support_1.panic("isNullable not implemented for IntersectionType");
+        return (0, Support_1.panic)("isNullable not implemented for IntersectionType");
     }
     reconstitute(builder, canonicalOrder) {
         this.reconstituteSetOperation(builder, canonicalOrder, members => {
@@ -637,18 +662,18 @@ class UnionType extends SetOperationType {
     constructor(typeRef, graph, memberRefs) {
         super(typeRef, graph, "union", memberRefs);
         if (memberRefs !== undefined) {
-            Messages_1.messageAssert(memberRefs.size > 0, "IRNoEmptyUnions", {});
+            (0, Messages_1.messageAssert)(memberRefs.size > 0, "IRNoEmptyUnions", {});
         }
     }
     setMembers(memberRefs) {
-        Messages_1.messageAssert(memberRefs.size > 0, "IRNoEmptyUnions", {});
+        (0, Messages_1.messageAssert)(memberRefs.size > 0, "IRNoEmptyUnions", {});
         super.setMembers(memberRefs);
     }
     get stringTypeMembers() {
-        return collection_utils_1.setFilter(this.members, t => isPrimitiveStringTypeKind(t.kind) || t.kind === "enum");
+        return (0, collection_utils_1.setFilter)(this.members, t => isPrimitiveStringTypeKind(t.kind) || t.kind === "enum");
     }
     findMember(kind) {
-        return collection_utils_1.iterableFind(this.members, t => t.kind === kind);
+        return (0, collection_utils_1.iterableFind)(this.members, t => t.kind === kind);
     }
     get isNullable() {
         return this.findMember("null") !== undefined;
@@ -657,7 +682,7 @@ class UnionType extends SetOperationType {
         const members = this.members;
         if (members.size <= 1)
             return false;
-        const kinds = collection_utils_1.setMap(members, t => t.kind);
+        const kinds = (0, collection_utils_1.setMap)(members, t => t.kind);
         if (kinds.size < members.size)
             return false;
         if (kinds.has("union") || kinds.has("intersection"))

package/dist/quicktype-core/TypeBuilder.d.ts

@@ -3,7 +3,7 @@ import { TypeGraph, TypeRef } from "./TypeGraph";
 import { TypeAttributes, TypeAttributeKind } from "./attributes/TypeAttributes";
 import { StringTypes } from "./attributes/StringTypes";
 export declare const provenanceTypeAttributeKind: TypeAttributeKind<Set<number>>;
-export declare type StringTypeMapping = ReadonlyMap<TransformedStringTypeKind, PrimitiveStringTypeKind>;
+export type StringTypeMapping = ReadonlyMap<TransformedStringTypeKind, PrimitiveStringTypeKind>;
 export declare function stringTypeMappingGet(stm: StringTypeMapping, kind: TransformedStringTypeKind): PrimitiveStringTypeKind;
 export declare function getNoStringTypeMapping(): StringTypeMapping;
 export declare class TypeBuilder {
@@ -32,7 +32,7 @@ export declare class TypeBuilder {
     protected forwardIfNecessary(forwardingRef: TypeRef | undefined, tref: undefined): undefined;
     protected forwardIfNecessary(forwardingRef: TypeRef | undefined, tref: TypeRef): TypeRef;
     protected forwardIfNecessary(forwardingRef: TypeRef | undefined, tref: TypeRef | undefined): TypeRef | undefined;
-    readonly didAddForwardingIntersection: boolean;
+    get didAddForwardingIntersection(): boolean;
     private readonly _typeForIdentity;
     private registerTypeForIdentity;
     protected makeIdentity(maker: () => MaybeTypeIdentity): MaybeTypeIdentity;