quicktype 17.0.4 → 17.0.6

package/dist/quicktype-core/input/JSONSchemaInput.js

@@ -1,10 +1,14 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JSONSchemaInput = exports.schemaTypeDict = exports.Ref = exports.PathElementKind = void 0;
-const urijs_1 = __importDefault(require("urijs"));
+const URI = require("urijs");
 const collection_utils_1 = require("collection-utils");
 const Type_1 = require("../Type");
 const Support_1 = require("../support/Support");
@@ -51,13 +55,13 @@ function withRef(refOrLoc, props) {
 }
 function checkJSONSchemaObject(x, refOrLoc) {
     if (Array.isArray(x)) {
-        return (0, Messages_1.messageError)("SchemaArrayIsInvalidSchema", withRef(refOrLoc));
+        return Messages_1.messageError("SchemaArrayIsInvalidSchema", withRef(refOrLoc));
     }
     if (x === null) {
-        return (0, Messages_1.messageError)("SchemaNullIsInvalidSchema", withRef(refOrLoc));
+        return Messages_1.messageError("SchemaNullIsInvalidSchema", withRef(refOrLoc));
     }
     if (typeof x !== "object") {
-        return (0, Messages_1.messageError)("SchemaInvalidJSONSchemaType", withRef(refOrLoc, { type: typeof x }));
+        return Messages_1.messageError("SchemaInvalidJSONSchemaType", withRef(refOrLoc, { type: typeof x }));
     }
     return x;
 }
@@ -74,14 +78,23 @@ function normalizeURI(uri) {
     // JSONSchemaStore should take a URI, not a string, and if it reads from
     // a file it can decode by itself.
     if (typeof uri === "string") {
-        uri = new urijs_1.default(uri);
+        uri = new URI(uri);
     }
-    return new urijs_1.default(urijs_1.default.decode(uri.clone().normalize().toString()));
+    return new URI(URI.decode(uri.clone().normalize().toString()));
 }
 class Ref {
-    path;
+    constructor(addressURI, path) {
+        this.path = path;
+        if (addressURI !== undefined) {
+            Support_1.assert(addressURI.fragment() === "", `Ref URI with fragment is not allowed: ${addressURI.toString()}`);
+            this.addressURI = normalizeURI(addressURI);
+        }
+        else {
+            this.addressURI = undefined;
+        }
+    }
     static root(address) {
-        const uri = (0, collection_utils_1.definedMap)(address, a => new urijs_1.default(a));
+        const uri = collection_utils_1.definedMap(address, a => new URI(a));
         return new Ref(uri, []);
     }
     static parsePath(path) {
@@ -111,24 +124,13 @@ class Ref {
         return new Ref(uri, elements);
     }
     static parse(ref) {
-        return Ref.parseURI(new urijs_1.default(ref), true);
-    }
-    addressURI;
-    constructor(addressURI, path) {
-        this.path = path;
-        if (addressURI !== undefined) {
-            (0, Support_1.assert)(addressURI.fragment() === "", `Ref URI with fragment is not allowed: ${addressURI.toString()}`);
-            this.addressURI = normalizeURI(addressURI);
-        }
-        else {
-            this.addressURI = undefined;
-        }
+        return Ref.parseURI(new URI(ref), true);
     }
     get hasAddress() {
         return this.addressURI !== undefined;
     }
     get address() {
-        return (0, Support_1.defined)(this.addressURI).toString();
+        return Support_1.defined(this.addressURI).toString();
     }
     get isRoot() {
         return this.path.length === 1 && this.path[0].kind === PathElementKind.Root;
@@ -181,18 +183,18 @@ class Ref {
                     break;
                 case PathElementKind.Type:
                 case PathElementKind.Object:
-                    return (0, Support_1.panic)("We shouldn't try to get the name of Type or Object refs");
+                    return Support_1.panic("We shouldn't try to get the name of Type or Object refs");
                 default:
-                    return (0, Support_1.assertNever)(e);
+                    return Support_1.assertNever(e);
             }
         }
     }
     get definitionName() {
-        const pe = (0, collection_utils_1.arrayGetFromEnd)(this.path, 2);
+        const pe = collection_utils_1.arrayGetFromEnd(this.path, 2);
         if (pe === undefined)
             return undefined;
         if (keyOrIndex(pe) === "definitions")
-            return keyOrIndex((0, Support_1.defined)((0, collection_utils_1.arrayLast)(this.path)));
+            return keyOrIndex(Support_1.defined(collection_utils_1.arrayLast(this.path)));
         return undefined;
     }
     toString() {
@@ -207,7 +209,7 @@ class Ref {
                 case PathElementKind.KeyOrIndex:
                     return e.key;
                 default:
-                    return (0, Support_1.assertNever)(e);
+                    return Support_1.assertNever(e);
             }
         }
         const address = this.addressURI === undefined ? "" : this.addressURI.toString();
@@ -227,26 +229,26 @@ class Ref {
                 const key = first.key;
                 if (Array.isArray(local)) {
                     if (!/^\d+$/.test(key)) {
-                        return (0, Messages_1.messageError)("SchemaCannotIndexArrayWithNonNumber", withRef(refMaker, { actual: key }));
+                        return Messages_1.messageError("SchemaCannotIndexArrayWithNonNumber", withRef(refMaker, { actual: key }));
                     }
                     const index = parseInt(first.key, 10);
                     if (index >= local.length) {
-                        return (0, Messages_1.messageError)("SchemaIndexNotInArray", withRef(refMaker, { index }));
+                        return Messages_1.messageError("SchemaIndexNotInArray", withRef(refMaker, { index }));
                     }
                     return this.lookup(local[index], rest, root);
                 }
                 else {
-                    if (!(0, collection_utils_1.hasOwnProperty)(local, key)) {
-                        return (0, Messages_1.messageError)("SchemaKeyNotInObject", withRef(refMaker, { key }));
+                    if (!collection_utils_1.hasOwnProperty(local, key)) {
+                        return Messages_1.messageError("SchemaKeyNotInObject", withRef(refMaker, { key }));
                     }
                     return this.lookup(checkJSONSchemaObject(local, refMaker)[first.key], rest, root);
                 }
             case PathElementKind.Type:
-                return (0, Support_1.panic)('Cannot look up path that indexes "type"');
+                return Support_1.panic('Cannot look up path that indexes "type"');
             case PathElementKind.Object:
-                return (0, Support_1.panic)('Cannot look up path that indexes "object"');
+                return Support_1.panic('Cannot look up path that indexes "object"');
             default:
-                return (0, Support_1.assertNever)(first);
+                return Support_1.assertNever(first);
         }
     }
     lookupRef(root) {
@@ -273,15 +275,15 @@ class Ref {
         return true;
     }
     hashCode() {
-        let acc = (0, collection_utils_1.hashCodeOf)((0, collection_utils_1.definedMap)(this.addressURI, u => u.toString()));
+        let acc = collection_utils_1.hashCodeOf(collection_utils_1.definedMap(this.addressURI, u => u.toString()));
         for (const pe of this.path) {
-            acc = (0, collection_utils_1.addHashCode)(acc, pe.kind);
+            acc = collection_utils_1.addHashCode(acc, pe.kind);
             switch (pe.kind) {
                 case PathElementKind.Type:
-                    acc = (0, collection_utils_1.addHashCode)(acc, pe.index);
+                    acc = collection_utils_1.addHashCode(acc, pe.index);
                     break;
                 case PathElementKind.KeyOrIndex:
-                    acc = (0, collection_utils_1.addHashCode)(acc, (0, collection_utils_1.hashString)(pe.key));
+                    acc = collection_utils_1.addHashCode(acc, collection_utils_1.hashString(pe.key));
                     break;
                 default:
                     break;
@@ -292,9 +294,6 @@ class Ref {
 }
 exports.Ref = Ref;
 class Location {
-    haveID;
-    canonicalRef;
-    virtualRef;
     constructor(canonicalRef, virtualRef, haveID = false) {
         this.haveID = haveID;
         this.canonicalRef = canonicalRef;
@@ -306,7 +305,7 @@ class Location {
         const parsed = Ref.parse(id);
         const virtual = this.haveID ? parsed.resolveAgainst(this.virtualRef) : parsed;
         if (!this.haveID) {
-            (0, Messages_1.messageAssert)(virtual.hasAddress, "SchemaIDMustHaveAddress", withRef(this, { id }));
+            Messages_1.messageAssert(virtual.hasAddress, "SchemaIDMustHaveAddress", withRef(this, { id }));
         }
         return new Location(this.canonicalRef, virtual, true);
     }
@@ -324,11 +323,10 @@ class Location {
     }
 }
 class Canonizer {
-    _ctx;
-    _map = new collection_utils_1.EqualityMap();
-    _schemaAddressesAdded = new Set();
     constructor(_ctx) {
         this._ctx = _ctx;
+        this._map = new collection_utils_1.EqualityMap();
+        this._schemaAddressesAdded = new Set();
     }
     addIDs(schema, loc) {
         if (schema === null)
@@ -384,30 +382,30 @@ function checkTypeList(typeOrTypes, loc) {
         const arr = [];
         for (const t of typeOrTypes) {
             if (typeof t !== "string") {
-                return (0, Messages_1.messageError)("SchemaTypeElementMustBeString", withRef(loc, { element: t }));
+                return Messages_1.messageError("SchemaTypeElementMustBeString", withRef(loc, { element: t }));
             }
             arr.push(t);
         }
         set = new Set(arr);
     }
     else {
-        return (0, Messages_1.messageError)("SchemaTypeMustBeStringOrStringArray", withRef(loc, { actual: typeOrTypes }));
+        return Messages_1.messageError("SchemaTypeMustBeStringOrStringArray", withRef(loc, { actual: typeOrTypes }));
     }
-    (0, Messages_1.messageAssert)(set.size > 0, "SchemaNoTypeSpecified", withRef(loc));
+    Messages_1.messageAssert(set.size > 0, "SchemaNoTypeSpecified", withRef(loc));
     const validTypes = ["null", "boolean", "object", "array", "number", "string", "integer"];
-    const maybeInvalid = (0, collection_utils_1.iterableFind)(set, s => validTypes.indexOf(s) < 0);
+    const maybeInvalid = collection_utils_1.iterableFind(set, s => validTypes.indexOf(s) < 0);
     if (maybeInvalid !== undefined) {
-        return (0, Messages_1.messageError)("SchemaInvalidType", withRef(loc, { type: maybeInvalid }));
+        return Messages_1.messageError("SchemaInvalidType", withRef(loc, { type: maybeInvalid }));
     }
     return set;
 }
 function checkRequiredArray(arr, loc) {
     if (!Array.isArray(arr)) {
-        return (0, Messages_1.messageError)("SchemaRequiredMustBeStringOrStringArray", withRef(loc, { actual: arr }));
+        return Messages_1.messageError("SchemaRequiredMustBeStringOrStringArray", withRef(loc, { actual: arr }));
     }
     for (const e of arr) {
         if (typeof e !== "string") {
-            return (0, Messages_1.messageError)("SchemaRequiredElementMustBeString", withRef(loc, { element: e }));
+            return Messages_1.messageError("SchemaRequiredElementMustBeString", withRef(loc, { element: e }));
         }
     }
     return arr;
@@ -423,410 +421,429 @@ exports.schemaTypeDict = {
 };
 const schemaTypes = Object.getOwnPropertyNames(exports.schemaTypeDict);
 function typeKindForJSONSchemaFormat(format) {
-    const target = (0, collection_utils_1.iterableFind)(Type_1.transformedStringTypeTargetTypeKindsMap, ([_, { jsonSchema }]) => jsonSchema === format);
+    const target = collection_utils_1.iterableFind(Type_1.transformedStringTypeTargetTypeKindsMap, ([_, { jsonSchema }]) => jsonSchema === format);
     if (target === undefined)
         return undefined;
     return target[0];
 }
 function schemaFetchError(base, address) {
     if (base === undefined) {
-        return (0, Messages_1.messageError)("SchemaFetchErrorTopLevel", { address });
+        return Messages_1.messageError("SchemaFetchErrorTopLevel", { address });
     }
     else {
-        return (0, Messages_1.messageError)("SchemaFetchError", { address, base: base.canonicalRef });
+        return Messages_1.messageError("SchemaFetchError", { address, base: base.canonicalRef });
     }
 }
 class Resolver {
-    _ctx;
-    _store;
-    _canonizer;
     constructor(_ctx, _store, _canonizer) {
         this._ctx = _ctx;
         this._store = _store;
         this._canonizer = _canonizer;
     }
-    async tryResolveVirtualRef(fetchBase, lookupBase, virtualRef) {
-        let didAdd = false;
-        // If we are resolving into a schema file that we haven't seen yet then
-        // we don't know its $id mapping yet, which means we don't know where we
-        // will end up.  What we do if we encounter a new schema is add all its
-        // IDs first, and then try to canonize again.
-        for (;;) {
-            const loc = this._canonizer.canonize(fetchBase, virtualRef);
-            const canonical = loc.canonicalRef;
-            (0, Support_1.assert)(canonical.hasAddress, "Canonical ref can't be resolved without an address");
-            const address = canonical.address;
-            let schema = canonical.addressURI === undefined
-                ? undefined
-                : await this._store.get(address, this._ctx.debugPrintSchemaResolving);
-            if (schema === undefined) {
-                return [undefined, loc];
-            }
-            if (this._canonizer.addSchema(schema, address)) {
-                (0, Support_1.assert)(!didAdd, "We can't add a schema twice");
-                didAdd = true;
-            }
-            else {
-                let lookupLoc = this._canonizer.canonize(lookupBase, virtualRef);
-                if (fetchBase !== undefined) {
-                    lookupLoc = new Location(new Ref(loc.canonicalRef.addressURI, lookupLoc.canonicalRef.path), lookupLoc.virtualRef, lookupLoc.haveID);
+    tryResolveVirtualRef(fetchBase, lookupBase, virtualRef) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let didAdd = false;
+            // If we are resolving into a schema file that we haven't seen yet then
+            // we don't know its $id mapping yet, which means we don't know where we
+            // will end up.  What we do if we encounter a new schema is add all its
+            // IDs first, and then try to canonize again.
+            for (;;) {
+                const loc = this._canonizer.canonize(fetchBase, virtualRef);
+                const canonical = loc.canonicalRef;
+                Support_1.assert(canonical.hasAddress, "Canonical ref can't be resolved without an address");
+                const address = canonical.address;
+                let schema = canonical.addressURI === undefined
+                    ? undefined
+                    : yield this._store.get(address, this._ctx.debugPrintSchemaResolving);
+                if (schema === undefined) {
+                    return [undefined, loc];
+                }
+                if (this._canonizer.addSchema(schema, address)) {
+                    Support_1.assert(!didAdd, "We can't add a schema twice");
+                    didAdd = true;
+                }
+                else {
+                    let lookupLoc = this._canonizer.canonize(lookupBase, virtualRef);
+                    if (fetchBase !== undefined) {
+                        lookupLoc = new Location(new Ref(loc.canonicalRef.addressURI, lookupLoc.canonicalRef.path), lookupLoc.virtualRef, lookupLoc.haveID);
+                    }
+                    return [lookupLoc.canonicalRef.lookupRef(schema), lookupLoc];
                 }
-                return [lookupLoc.canonicalRef.lookupRef(schema), lookupLoc];
             }
-        }
+        });
     }
-    async resolveVirtualRef(base, virtualRef) {
-        if (this._ctx.debugPrintSchemaResolving) {
-            console.log(`resolving ${virtualRef.toString()} relative to ${base.toString()}`);
-        }
-        // Try with the virtual base first.  If that doesn't work, use the
-        // canonical ref's address with the virtual base's path.
-        let result = await this.tryResolveVirtualRef(base, base, virtualRef);
-        let schema = result[0];
-        if (schema !== undefined) {
+    resolveVirtualRef(base, virtualRef) {
+        return __awaiter(this, void 0, void 0, function* () {
             if (this._ctx.debugPrintSchemaResolving) {
-                console.log(`resolved to ${result[1].toString()}`);
+                console.log(`resolving ${virtualRef.toString()} relative to ${base.toString()}`);
             }
-            return [schema, result[1]];
-        }
-        const altBase = new Location(base.canonicalRef, new Ref(base.canonicalRef.addressURI, base.virtualRef.path), base.haveID);
-        result = await this.tryResolveVirtualRef(altBase, base, virtualRef);
-        schema = result[0];
-        if (schema !== undefined) {
-            if (this._ctx.debugPrintSchemaResolving) {
-                console.log(`resolved to ${result[1].toString()}`);
+            // Try with the virtual base first.  If that doesn't work, use the
+            // canonical ref's address with the virtual base's path.
+            let result = yield this.tryResolveVirtualRef(base, base, virtualRef);
+            let schema = result[0];
+            if (schema !== undefined) {
+                if (this._ctx.debugPrintSchemaResolving) {
+                    console.log(`resolved to ${result[1].toString()}`);
+                }
+                return [schema, result[1]];
             }
-            return [schema, result[1]];
-        }
-        return schemaFetchError(base, virtualRef.address);
-    }
-    async resolveTopLevelRef(ref) {
-        return await this.resolveVirtualRef(new Location(new Ref(ref.addressURI, [])), new Ref(undefined, ref.path));
-    }
-}
-async function addTypesInSchema(resolver, typeBuilder, references, attributeProducers) {
-    let typeForCanonicalRef = new collection_utils_1.EqualityMap();
-    function setTypeForLocation(loc, t) {
-        const maybeRef = typeForCanonicalRef.get(loc.canonicalRef);
-        if (maybeRef !== undefined) {
-            (0, Support_1.assert)(maybeRef === t, "Trying to set path again to different type");
-        }
-        typeForCanonicalRef.set(loc.canonicalRef, t);
+            const altBase = new Location(base.canonicalRef, new Ref(base.canonicalRef.addressURI, base.virtualRef.path), base.haveID);
+            result = yield this.tryResolveVirtualRef(altBase, base, virtualRef);
+            schema = result[0];
+            if (schema !== undefined) {
+                if (this._ctx.debugPrintSchemaResolving) {
+                    console.log(`resolved to ${result[1].toString()}`);
+                }
+                return [schema, result[1]];
+            }
+            return schemaFetchError(base, virtualRef.address);
+        });
     }
-    async function makeObject(loc, attributes, properties, requiredArray, additionalProperties, sortKey = (k) => k.toLowerCase()) {
-        const required = new Set(requiredArray);
-        const propertiesMap = (0, collection_utils_1.mapSortBy)((0, collection_utils_1.mapFromObject)(properties), (_, k) => sortKey(k));
-        const props = await (0, collection_utils_1.mapMapSync)(propertiesMap, async (propSchema, propName) => {
-            const propLoc = loc.push("properties", propName);
-            const t = await toType(checkJSONSchema(propSchema, propLoc.canonicalRef), propLoc, (0, TypeNames_2.makeNamesTypeAttributes)(propName, true));
-            const isOptional = !required.has(propName);
-            return typeBuilder.makeClassProperty(t, isOptional);
+    resolveTopLevelRef(ref) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.resolveVirtualRef(new Location(new Ref(ref.addressURI, [])), new Ref(undefined, ref.path));
         });
-        let additionalPropertiesType;
-        if (additionalProperties === undefined || additionalProperties === true) {
-            additionalPropertiesType = typeBuilder.getPrimitiveType("any");
-        }
-        else if (additionalProperties === false) {
-            additionalPropertiesType = undefined;
-        }
-        else {
-            const additionalLoc = loc.push("additionalProperties");
-            additionalPropertiesType = await toType(checkJSONSchema(additionalProperties, additionalLoc.canonicalRef), additionalLoc, (0, TypeNames_2.singularizeTypeNames)(attributes));
-        }
-        const additionalRequired = (0, collection_utils_1.setSubtract)(required, props.keys());
-        if (additionalRequired.size > 0) {
-            const t = additionalPropertiesType;
-            if (t === undefined) {
-                return (0, Messages_1.messageError)("SchemaAdditionalTypesForbidRequired", withRef(loc));
-            }
-            const additionalProps = (0, collection_utils_1.mapFromIterable)(additionalRequired, _name => typeBuilder.makeClassProperty(t, false));
-            (0, collection_utils_1.mapMergeInto)(props, additionalProps);
-        }
-        return typeBuilder.getUniqueObjectType(attributes, props, additionalPropertiesType);
     }
-    async function convertToType(schema, loc, typeAttributes) {
-        const enumArray = Array.isArray(schema.enum) ? schema.enum : undefined;
-        const typeSet = (0, collection_utils_1.definedMap)(schema.type, t => checkTypeList(t, loc));
-        function isTypeIncluded(name) {
-            if (typeSet !== undefined && !typeSet.has(name)) {
-                return false;
+}
+function addTypesInSchema(resolver, typeBuilder, references, attributeProducers) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let typeForCanonicalRef = new collection_utils_1.EqualityMap();
+        function setTypeForLocation(loc, t) {
+            const maybeRef = typeForCanonicalRef.get(loc.canonicalRef);
+            if (maybeRef !== undefined) {
+                Support_1.assert(maybeRef === t, "Trying to set path again to different type");
             }
-            if (enumArray !== undefined) {
-                let predicate;
-                switch (name) {
-                    case "null":
-                        predicate = (x) => x === null;
-                        break;
-                    case "integer":
-                        predicate = (x) => typeof x === "number" && x === Math.floor(x);
-                        break;
-                    default:
-                        predicate = (x) => typeof x === name;
-                        break;
+            typeForCanonicalRef.set(loc.canonicalRef, t);
+        }
+        function makeObject(loc, attributes, properties, requiredArray, additionalProperties, sortKey = (k) => k.toLowerCase()) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const required = new Set(requiredArray);
+                const propertiesMap = collection_utils_1.mapSortBy(collection_utils_1.mapFromObject(properties), (_, k) => sortKey(k));
+                const props = yield collection_utils_1.mapMapSync(propertiesMap, (propSchema, propName) => __awaiter(this, void 0, void 0, function* () {
+                    const propLoc = loc.push("properties", propName);
+                    const t = yield toType(checkJSONSchema(propSchema, propLoc.canonicalRef), propLoc, TypeNames_2.makeNamesTypeAttributes(propName, true));
+                    const isOptional = !required.has(propName);
+                    return typeBuilder.makeClassProperty(t, isOptional);
+                }));
+                let additionalPropertiesType;
+                if (additionalProperties === undefined || additionalProperties === true) {
+                    additionalPropertiesType = typeBuilder.getPrimitiveType("any");
                 }
-                return enumArray.find(predicate) !== undefined;
-            }
-            return true;
-        }
-        const includedTypes = (0, collection_utils_1.setFilter)(schemaTypes, isTypeIncluded);
-        let producedAttributesForNoCases = undefined;
-        function forEachProducedAttribute(cases, f) {
-            let attributes;
-            if (cases === undefined && producedAttributesForNoCases !== undefined) {
-                attributes = producedAttributesForNoCases;
-            }
-            else {
-                attributes = [];
-                for (const producer of attributeProducers) {
-                    const newAttributes = producer(schema, loc.canonicalRef, includedTypes, cases);
-                    if (newAttributes === undefined)
-                        continue;
-                    attributes.push(newAttributes);
+                else if (additionalProperties === false) {
+                    additionalPropertiesType = undefined;
                 }
-                if (cases === undefined) {
-                    producedAttributesForNoCases = attributes;
+                else {
+                    const additionalLoc = loc.push("additionalProperties");
+                    additionalPropertiesType = yield toType(checkJSONSchema(additionalProperties, additionalLoc.canonicalRef), additionalLoc, TypeNames_2.singularizeTypeNames(attributes));
                 }
-            }
-            for (const a of attributes) {
-                f(a);
-            }
-        }
-        function combineProducedAttributes(f) {
-            let result = TypeAttributes_1.emptyTypeAttributes;
-            forEachProducedAttribute(undefined, attr => {
-                const maybeAttributes = f(attr);
-                if (maybeAttributes === undefined)
-                    return;
-                result = (0, TypeAttributes_1.combineTypeAttributes)("union", result, maybeAttributes);
+                const additionalRequired = collection_utils_1.setSubtract(required, props.keys());
+                if (additionalRequired.size > 0) {
+                    const t = additionalPropertiesType;
+                    if (t === undefined) {
+                        return Messages_1.messageError("SchemaAdditionalTypesForbidRequired", withRef(loc));
+                    }
+                    const additionalProps = collection_utils_1.mapFromIterable(additionalRequired, _name => typeBuilder.makeClassProperty(t, false));
+                    collection_utils_1.mapMergeInto(props, additionalProps);
+                }
+                return typeBuilder.getUniqueObjectType(attributes, props, additionalPropertiesType);
             });
-            return result;
         }
-        function makeAttributes(attributes) {
-            if (schema.oneOf === undefined) {
-                attributes = (0, TypeAttributes_1.combineTypeAttributes)("union", attributes, combineProducedAttributes(({ forType, forUnion, forCases }) => {
-                    (0, Support_1.assert)(forUnion === undefined && forCases === undefined, "We can't have attributes for unions and cases if we don't have a union");
-                    return forType;
-                }));
-            }
-            return (0, TypeNames_2.modifyTypeNames)(attributes, maybeTypeNames => {
-                const typeNames = (0, Support_1.defined)(maybeTypeNames);
-                if (!typeNames.areInferred) {
-                    return typeNames;
-                }
-                let title = schema.title;
-                if (typeof title !== "string") {
-                    title = loc.canonicalRef.definitionName;
+        function convertToType(schema, loc, typeAttributes) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const enumArray = Array.isArray(schema.enum) ? schema.enum : undefined;
+                const typeSet = collection_utils_1.definedMap(schema.type, t => checkTypeList(t, loc));
+                function isTypeIncluded(name) {
+                    if (typeSet !== undefined && !typeSet.has(name)) {
+                        return false;
+                    }
+                    if (enumArray !== undefined) {
+                        let predicate;
+                        switch (name) {
+                            case "null":
+                                predicate = (x) => x === null;
+                                break;
+                            case "integer":
+                                predicate = (x) => typeof x === "number" && x === Math.floor(x);
+                                break;
+                            default:
+                                predicate = (x) => typeof x === name;
+                                break;
+                        }
+                        return enumArray.find(predicate) !== undefined;
+                    }
+                    return true;
                 }
-                if (typeof title === "string") {
-                    return TypeNames_1.TypeNames.make(new Set([title]), new Set(), schema.$ref !== undefined);
+                const includedTypes = collection_utils_1.setFilter(schemaTypes, isTypeIncluded);
+                let producedAttributesForNoCases = undefined;
+                function forEachProducedAttribute(cases, f) {
+                    let attributes;
+                    if (cases === undefined && producedAttributesForNoCases !== undefined) {
+                        attributes = producedAttributesForNoCases;
+                    }
+                    else {
+                        attributes = [];
+                        for (const producer of attributeProducers) {
+                            const newAttributes = producer(schema, loc.canonicalRef, includedTypes, cases);
+                            if (newAttributes === undefined)
+                                continue;
+                            attributes.push(newAttributes);
+                        }
+                        if (cases === undefined) {
+                            producedAttributesForNoCases = attributes;
+                        }
+                    }
+                    for (const a of attributes) {
+                        f(a);
+                    }
                 }
-                else {
-                    return typeNames.makeInferred();
+                function combineProducedAttributes(f) {
+                    let result = TypeAttributes_1.emptyTypeAttributes;
+                    forEachProducedAttribute(undefined, attr => {
+                        const maybeAttributes = f(attr);
+                        if (maybeAttributes === undefined)
+                            return;
+                        result = TypeAttributes_1.combineTypeAttributes("union", result, maybeAttributes);
+                    });
+                    return result;
                 }
-            });
-        }
-        typeAttributes = makeAttributes(typeAttributes);
-        const inferredAttributes = (0, TypeAttributes_1.makeTypeAttributesInferred)(typeAttributes);
-        function makeStringType(attributes) {
-            const kind = typeKindForJSONSchemaFormat(schema.format);
-            if (kind === undefined) {
-                return typeBuilder.getStringType(attributes, StringTypes_1.StringTypes.unrestricted);
-            }
-            else {
-                return typeBuilder.getPrimitiveType(kind, attributes);
-            }
-        }
-        async function makeArrayType() {
-            const singularAttributes = (0, TypeNames_2.singularizeTypeNames)(typeAttributes);
-            const items = schema.items;
-            let itemType;
-            if (Array.isArray(items)) {
-                const itemsLoc = loc.push("items");
-                const itemTypes = await (0, collection_utils_1.arrayMapSync)(items, async (item, i) => {
-                    const itemLoc = itemsLoc.push(i.toString());
-                    return await toType(checkJSONSchema(item, itemLoc.canonicalRef), itemLoc, singularAttributes);
-                });
-                itemType = typeBuilder.getUnionType(TypeAttributes_1.emptyTypeAttributes, new Set(itemTypes));
-            }
-            else if (typeof items === "object") {
-                const itemsLoc = loc.push("items");
-                itemType = await toType(checkJSONSchema(items, itemsLoc.canonicalRef), itemsLoc, singularAttributes);
-            }
-            else if (items !== undefined) {
-                return (0, Messages_1.messageError)("SchemaArrayItemsMustBeStringOrArray", withRef(loc, { actual: items }));
-            }
-            else {
-                itemType = typeBuilder.getPrimitiveType("any");
-            }
-            typeBuilder.addAttributes(itemType, singularAttributes);
-            return typeBuilder.getArrayType(TypeAttributes_1.emptyTypeAttributes, itemType);
-        }
-        async function makeObjectType() {
-            let required;
-            if (schema.required === undefined || typeof schema.required === "boolean") {
-                required = [];
-            }
-            else {
-                required = Array.from(checkRequiredArray(schema.required, loc));
-            }
-            let properties;
-            if (schema.properties === undefined) {
-                properties = {};
-            }
-            else {
-                properties = checkJSONSchemaObject(schema.properties, loc.canonicalRef);
-            }
-            // In Schema Draft 3, `required` is `true` on a property that's required.
-            for (const p of Object.getOwnPropertyNames(properties)) {
-                if (properties[p].required === true && required.indexOf(p) < 0) {
-                    required.push(p);
+                function makeAttributes(attributes) {
+                    if (schema.oneOf === undefined) {
+                        attributes = TypeAttributes_1.combineTypeAttributes("union", attributes, combineProducedAttributes(({ forType, forUnion, forCases }) => {
+                            Support_1.assert(forUnion === undefined && forCases === undefined, "We can't have attributes for unions and cases if we don't have a union");
+                            return forType;
+                        }));
+                    }
+                    return TypeNames_2.modifyTypeNames(attributes, maybeTypeNames => {
+                        const typeNames = Support_1.defined(maybeTypeNames);
+                        if (!typeNames.areInferred) {
+                            return typeNames;
+                        }
+                        let title = schema.title;
+                        if (typeof title !== "string") {
+                            title = loc.canonicalRef.definitionName;
+                        }
+                        if (typeof title === "string") {
+                            return TypeNames_1.TypeNames.make(new Set([title]), new Set(), schema.$ref !== undefined);
+                        }
+                        else {
+                            return typeNames.makeInferred();
+                        }
+                    });
                 }
-            }
-            let additionalProperties = schema.additionalProperties;
-            // This is an incorrect hack to fix an issue with a Go->Schema generator:
-            // https://github.com/quicktype/quicktype/issues/976
-            if (additionalProperties === undefined &&
-                typeof schema.patternProperties === "object" &&
-                (0, collection_utils_1.hasOwnProperty)(schema.patternProperties, ".*")) {
-                additionalProperties = schema.patternProperties[".*"];
-            }
-            const objectAttributes = (0, TypeAttributes_1.combineTypeAttributes)("union", inferredAttributes, combineProducedAttributes(({ forObject }) => forObject));
-            const order = schema.quicktypePropertyOrder ? schema.quicktypePropertyOrder : [];
-            const orderKey = (propertyName) => {
-                // use the index of the order array
-                const index = order.indexOf(propertyName);
-                // if no index then use the property name
-                return index !== -1 ? index : propertyName.toLowerCase();
-            };
-            return await makeObject(loc, objectAttributes, properties, required, additionalProperties, orderKey);
-        }
-        async function makeTypesFromCases(cases, kind) {
-            const kindLoc = loc.push(kind);
-            if (!Array.isArray(cases)) {
-                return (0, Messages_1.messageError)("SchemaSetOperationCasesIsNotArray", withRef(kindLoc, { operation: kind, cases }));
-            }
-            // FIXME: This cast shouldn't be necessary, but TypeScript forces our hand.
-            return await (0, collection_utils_1.arrayMapSync)(cases, async (t, index) => {
-                const caseLoc = kindLoc.push(index.toString());
-                return await toType(checkJSONSchema(t, caseLoc.canonicalRef), caseLoc, (0, TypeAttributes_1.makeTypeAttributesInferred)(typeAttributes));
-            });
-        }
-        const intersectionType = typeBuilder.getUniqueIntersectionType(typeAttributes, undefined);
-        setTypeForLocation(loc, intersectionType);
-        async function convertOneOrAnyOf(cases, kind) {
-            const typeRefs = await makeTypesFromCases(cases, kind);
-            let unionAttributes = (0, TypeAttributes_1.makeTypeAttributesInferred)(typeAttributes);
-            if (kind === "oneOf") {
-                forEachProducedAttribute(cases, ({ forType, forUnion, forCases }) => {
-                    if (forType !== undefined) {
-                        typeBuilder.addAttributes(intersectionType, forType);
+                typeAttributes = makeAttributes(typeAttributes);
+                const inferredAttributes = TypeAttributes_1.makeTypeAttributesInferred(typeAttributes);
+                function makeStringType(attributes) {
+                    const kind = typeKindForJSONSchemaFormat(schema.format);
+                    if (kind === undefined) {
+                        return typeBuilder.getStringType(attributes, StringTypes_1.StringTypes.unrestricted);
                     }
-                    if (forUnion !== undefined) {
-                        unionAttributes = (0, TypeAttributes_1.combineTypeAttributes)("union", unionAttributes, forUnion);
+                    else {
+                        return typeBuilder.getPrimitiveType(kind, attributes);
                     }
-                    if (forCases !== undefined) {
-                        (0, Support_1.assert)(forCases.length === typeRefs.length, "Number of case attributes doesn't match number of cases");
-                        for (let i = 0; i < typeRefs.length; i++) {
-                            typeBuilder.addAttributes(typeRefs[i], forCases[i]);
+                }
+                function makeArrayType() {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        const singularAttributes = TypeNames_2.singularizeTypeNames(typeAttributes);
+                        const items = schema.items;
+                        let itemType;
+                        if (Array.isArray(items)) {
+                            const itemsLoc = loc.push("items");
+                            const itemTypes = yield collection_utils_1.arrayMapSync(items, (item, i) => __awaiter(this, void 0, void 0, function* () {
+                                const itemLoc = itemsLoc.push(i.toString());
+                                return yield toType(checkJSONSchema(item, itemLoc.canonicalRef), itemLoc, singularAttributes);
+                            }));
+                            itemType = typeBuilder.getUnionType(TypeAttributes_1.emptyTypeAttributes, new Set(itemTypes));
+                        }
+                        else if (typeof items === "object") {
+                            const itemsLoc = loc.push("items");
+                            itemType = yield toType(checkJSONSchema(items, itemsLoc.canonicalRef), itemsLoc, singularAttributes);
+                        }
+                        else if (items !== undefined) {
+                            return Messages_1.messageError("SchemaArrayItemsMustBeStringOrArray", withRef(loc, { actual: items }));
+                        }
+                        else {
+                            itemType = typeBuilder.getPrimitiveType("any");
+                        }
+                        typeBuilder.addAttributes(itemType, singularAttributes);
+                        return typeBuilder.getArrayType(TypeAttributes_1.emptyTypeAttributes, itemType);
+                    });
+                }
+                function makeObjectType() {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        let required;
+                        if (schema.required === undefined || typeof schema.required === "boolean") {
+                            required = [];
+                        }
+                        else {
+                            required = Array.from(checkRequiredArray(schema.required, loc));
+                        }
+                        let properties;
+                        if (schema.properties === undefined) {
+                            properties = {};
+                        }
+                        else {
+                            properties = checkJSONSchemaObject(schema.properties, loc.canonicalRef);
+                        }
+                        // In Schema Draft 3, `required` is `true` on a property that's required.
+                        for (const p of Object.getOwnPropertyNames(properties)) {
+                            if (properties[p].required === true && required.indexOf(p) < 0) {
+                                required.push(p);
+                            }
+                        }
+                        let additionalProperties = schema.additionalProperties;
+                        // This is an incorrect hack to fix an issue with a Go->Schema generator:
+                        // https://github.com/quicktype/quicktype/issues/976
+                        if (additionalProperties === undefined &&
+                            typeof schema.patternProperties === "object" &&
+                            collection_utils_1.hasOwnProperty(schema.patternProperties, ".*")) {
+                            additionalProperties = schema.patternProperties[".*"];
+                        }
+                        const objectAttributes = TypeAttributes_1.combineTypeAttributes("union", inferredAttributes, combineProducedAttributes(({ forObject }) => forObject));
+                        const order = schema.quicktypePropertyOrder ? schema.quicktypePropertyOrder : [];
+                        const orderKey = (propertyName) => {
+                            // use the index of the order array
+                            const index = order.indexOf(propertyName);
+                            // if no index then use the property name
+                            return index !== -1 ? index : propertyName.toLowerCase();
+                        };
+                        return yield makeObject(loc, objectAttributes, properties, required, additionalProperties, orderKey);
+                    });
+                }
+                function makeTypesFromCases(cases, kind) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        const kindLoc = loc.push(kind);
+                        if (!Array.isArray(cases)) {
+                            return Messages_1.messageError("SchemaSetOperationCasesIsNotArray", withRef(kindLoc, { operation: kind, cases }));
+                        }
+                        // FIXME: This cast shouldn't be necessary, but TypeScript forces our hand.
+                        return yield collection_utils_1.arrayMapSync(cases, (t, index) => __awaiter(this, void 0, void 0, function* () {
+                            const caseLoc = kindLoc.push(index.toString());
+                            return yield toType(checkJSONSchema(t, caseLoc.canonicalRef), caseLoc, TypeAttributes_1.makeTypeAttributesInferred(typeAttributes));
+                        }));
+                    });
+                }
+                const intersectionType = typeBuilder.getUniqueIntersectionType(typeAttributes, undefined);
+                setTypeForLocation(loc, intersectionType);
+                function convertOneOrAnyOf(cases, kind) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        const typeRefs = yield makeTypesFromCases(cases, kind);
+                        let unionAttributes = TypeAttributes_1.makeTypeAttributesInferred(typeAttributes);
+                        if (kind === "oneOf") {
+                            forEachProducedAttribute(cases, ({ forType, forUnion, forCases }) => {
+                                if (forType !== undefined) {
+                                    typeBuilder.addAttributes(intersectionType, forType);
+                                }
+                                if (forUnion !== undefined) {
+                                    unionAttributes = TypeAttributes_1.combineTypeAttributes("union", unionAttributes, forUnion);
+                                }
+                                if (forCases !== undefined) {
+                                    Support_1.assert(forCases.length === typeRefs.length, "Number of case attributes doesn't match number of cases");
+                                    for (let i = 0; i < typeRefs.length; i++) {
+                                        typeBuilder.addAttributes(typeRefs[i], forCases[i]);
+                                    }
+                                }
+                            });
                         }
+                        const unionType = typeBuilder.getUniqueUnionType(unionAttributes, undefined);
+                        typeBuilder.setSetOperationMembers(unionType, new Set(typeRefs));
+                        return unionType;
+                    });
+                }
+                const includeObject = enumArray === undefined && (typeSet === undefined || typeSet.has("object"));
+                const includeArray = enumArray === undefined && (typeSet === undefined || typeSet.has("array"));
+                const needStringEnum = includedTypes.has("string") &&
+                    enumArray !== undefined &&
+                    enumArray.find((x) => typeof x === "string") !== undefined;
+                const needUnion = typeSet !== undefined ||
+                    schema.properties !== undefined ||
+                    schema.additionalProperties !== undefined ||
+                    schema.items !== undefined ||
+                    schema.required !== undefined ||
+                    enumArray !== undefined;
+                const types = [];
+                if (needUnion) {
+                    const unionTypes = [];
+                    const numberAttributes = combineProducedAttributes(({ forNumber }) => forNumber);
+                    for (const [name, kind] of [
+                        ["null", "null"],
+                        ["number", "double"],
+                        ["integer", "integer"],
+                        ["boolean", "bool"]
+                    ]) {
+                        if (!includedTypes.has(name))
+                            continue;
+                        const attributes = Type_1.isNumberTypeKind(kind) ? numberAttributes : undefined;
+                        unionTypes.push(typeBuilder.getPrimitiveType(kind, attributes));
                     }
-                });
-            }
-            const unionType = typeBuilder.getUniqueUnionType(unionAttributes, undefined);
-            typeBuilder.setSetOperationMembers(unionType, new Set(typeRefs));
-            return unionType;
-        }
-        const includeObject = enumArray === undefined && (typeSet === undefined || typeSet.has("object"));
-        const includeArray = enumArray === undefined && (typeSet === undefined || typeSet.has("array"));
-        const needStringEnum = includedTypes.has("string") &&
-            enumArray !== undefined &&
-            enumArray.find((x) => typeof x === "string") !== undefined;
-        const needUnion = typeSet !== undefined ||
-            schema.properties !== undefined ||
-            schema.additionalProperties !== undefined ||
-            schema.items !== undefined ||
-            schema.required !== undefined ||
-            enumArray !== undefined;
-        const types = [];
-        if (needUnion) {
-            const unionTypes = [];
-            const numberAttributes = combineProducedAttributes(({ forNumber }) => forNumber);
-            for (const [name, kind] of [
-                ["null", "null"],
-                ["number", "double"],
-                ["integer", "integer"],
-                ["boolean", "bool"]
-            ]) {
-                if (!includedTypes.has(name))
-                    continue;
-                const attributes = (0, Type_1.isNumberTypeKind)(kind) ? numberAttributes : undefined;
-                unionTypes.push(typeBuilder.getPrimitiveType(kind, attributes));
-            }
-            const stringAttributes = (0, TypeAttributes_1.combineTypeAttributes)("union", inferredAttributes, combineProducedAttributes(({ forString }) => forString));
-            if (needStringEnum) {
-                const cases = enumArray.filter(x => typeof x === "string");
-                unionTypes.push(typeBuilder.getStringType(stringAttributes, StringTypes_1.StringTypes.fromCases(cases)));
-            }
-            else if (includedTypes.has("string")) {
-                unionTypes.push(makeStringType(stringAttributes));
-            }
-            if (includeArray) {
-                unionTypes.push(await makeArrayType());
-            }
-            if (includeObject) {
-                unionTypes.push(await makeObjectType());
-            }
-            types.push(typeBuilder.getUniqueUnionType(inferredAttributes, new Set(unionTypes)));
-        }
-        if (schema.$ref !== undefined) {
-            if (typeof schema.$ref !== "string") {
-                return (0, Messages_1.messageError)("SchemaRefMustBeString", withRef(loc, { actual: typeof schema.$ref }));
-            }
-            const virtualRef = Ref.parse(schema.$ref);
-            const [target, newLoc] = await resolver.resolveVirtualRef(loc, virtualRef);
-            const attributes = (0, TypeNames_2.modifyTypeNames)(typeAttributes, tn => {
-                if (!(0, Support_1.defined)(tn).areInferred)
-                    return tn;
-                return TypeNames_1.TypeNames.make(new Set([newLoc.canonicalRef.name]), new Set(), true);
+                    const stringAttributes = TypeAttributes_1.combineTypeAttributes("union", inferredAttributes, combineProducedAttributes(({ forString }) => forString));
+                    if (needStringEnum) {
+                        const cases = enumArray.filter(x => typeof x === "string");
+                        unionTypes.push(typeBuilder.getStringType(stringAttributes, StringTypes_1.StringTypes.fromCases(cases)));
+                    }
+                    else if (includedTypes.has("string")) {
+                        unionTypes.push(makeStringType(stringAttributes));
+                    }
+                    if (includeArray) {
+                        unionTypes.push(yield makeArrayType());
+                    }
+                    if (includeObject) {
+                        unionTypes.push(yield makeObjectType());
+                    }
+                    types.push(typeBuilder.getUniqueUnionType(inferredAttributes, new Set(unionTypes)));
+                }
+                if (schema.$ref !== undefined) {
+                    if (typeof schema.$ref !== "string") {
+                        return Messages_1.messageError("SchemaRefMustBeString", withRef(loc, { actual: typeof schema.$ref }));
+                    }
+                    const virtualRef = Ref.parse(schema.$ref);
+                    const [target, newLoc] = yield resolver.resolveVirtualRef(loc, virtualRef);
+                    const attributes = TypeNames_2.modifyTypeNames(typeAttributes, tn => {
+                        if (!Support_1.defined(tn).areInferred)
+                            return tn;
+                        return TypeNames_1.TypeNames.make(new Set([newLoc.canonicalRef.name]), new Set(), true);
+                    });
+                    types.push(yield toType(target, newLoc, attributes));
+                }
+                if (schema.allOf !== undefined) {
+                    types.push(...(yield makeTypesFromCases(schema.allOf, "allOf")));
+                }
+                if (schema.oneOf !== undefined) {
+                    types.push(yield convertOneOrAnyOf(schema.oneOf, "oneOf"));
+                }
+                if (schema.anyOf !== undefined) {
+                    types.push(yield convertOneOrAnyOf(schema.anyOf, "anyOf"));
+                }
+                typeBuilder.setSetOperationMembers(intersectionType, new Set(types));
+                return intersectionType;
             });
-            types.push(await toType(target, newLoc, attributes));
-        }
-        if (schema.allOf !== undefined) {
-            types.push(...(await makeTypesFromCases(schema.allOf, "allOf")));
-        }
-        if (schema.oneOf !== undefined) {
-            types.push(await convertOneOrAnyOf(schema.oneOf, "oneOf"));
         }
-        if (schema.anyOf !== undefined) {
-            types.push(await convertOneOrAnyOf(schema.anyOf, "anyOf"));
-        }
-        typeBuilder.setSetOperationMembers(intersectionType, new Set(types));
-        return intersectionType;
-    }
-    async function toType(schema, loc, typeAttributes) {
-        const maybeType = typeForCanonicalRef.get(loc.canonicalRef);
-        if (maybeType !== undefined) {
-            return maybeType;
-        }
-        let result;
-        if (typeof schema === "boolean") {
-            // FIXME: Empty union.  We'd have to check that it's supported everywhere,
-            // in particular in union flattening.
-            (0, Messages_1.messageAssert)(schema === true, "SchemaFalseNotSupported", withRef(loc));
-            result = typeBuilder.getPrimitiveType("any");
+        function toType(schema, loc, typeAttributes) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const maybeType = typeForCanonicalRef.get(loc.canonicalRef);
+                if (maybeType !== undefined) {
+                    return maybeType;
+                }
+                let result;
+                if (typeof schema === "boolean") {
+                    // FIXME: Empty union.  We'd have to check that it's supported everywhere,
+                    // in particular in union flattening.
+                    Messages_1.messageAssert(schema === true, "SchemaFalseNotSupported", withRef(loc));
+                    result = typeBuilder.getPrimitiveType("any");
+                }
+                else {
+                    loc = loc.updateWithID(schema["$id"]);
+                    result = yield convertToType(schema, loc, typeAttributes);
+                }
+                setTypeForLocation(loc, result);
+                return result;
+            });
         }
-        else {
-            loc = loc.updateWithID(schema["$id"]);
-            result = await convertToType(schema, loc, typeAttributes);
+        for (const [topLevelName, topLevelRef] of references) {
+            const [target, loc] = yield resolver.resolveTopLevelRef(topLevelRef);
+            const t = yield toType(target, loc, TypeNames_2.makeNamesTypeAttributes(topLevelName, false));
+            typeBuilder.addTopLevel(topLevelName, t);
         }
-        setTypeForLocation(loc, result);
-        return result;
-    }
-    for (const [topLevelName, topLevelRef] of references) {
-        const [target, loc] = await resolver.resolveTopLevelRef(topLevelRef);
-        const t = await toType(target, loc, (0, TypeNames_2.makeNamesTypeAttributes)(topLevelName, false));
-        typeBuilder.addTopLevel(topLevelName, t);
-    }
+    });
 }
 function removeExtension(fn) {
     const lower = fn.toLowerCase();
@@ -857,69 +874,68 @@ function nameFromURI(uri) {
     if (filename !== "") {
         return removeExtension(filename);
     }
-    return (0, Messages_1.messageError)("DriverCannotInferNameForSchema", { uri: uri.toString() });
+    return Messages_1.messageError("DriverCannotInferNameForSchema", { uri: uri.toString() });
 }
-async function refsInSchemaForURI(resolver, uri, defaultName) {
-    const fragment = uri.fragment();
-    let propertiesAreTypes = fragment.endsWith("/");
-    if (propertiesAreTypes) {
-        uri = uri.clone().fragment(fragment.slice(0, -1));
-    }
-    const ref = Ref.parseURI(uri);
-    if (ref.isRoot) {
-        propertiesAreTypes = false;
-    }
-    const schema = (await resolver.resolveTopLevelRef(ref))[0];
-    if (propertiesAreTypes) {
-        if (typeof schema !== "object") {
-            return (0, Messages_1.messageError)("SchemaCannotGetTypesFromBoolean", { ref: ref.toString() });
-        }
-        return (0, collection_utils_1.mapMap)((0, collection_utils_1.mapFromObject)(schema), (_, name) => ref.push(name));
-    }
-    else {
-        let name;
-        if (typeof schema === "object" && typeof schema.title === "string") {
-            name = schema.title;
+function refsInSchemaForURI(resolver, uri, defaultName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const fragment = uri.fragment();
+        let propertiesAreTypes = fragment.endsWith("/");
+        if (propertiesAreTypes) {
+            uri = uri.clone().fragment(fragment.slice(0, -1));
+        }
+        const ref = Ref.parseURI(uri);
+        if (ref.isRoot) {
+            propertiesAreTypes = false;
+        }
+        const schema = (yield resolver.resolveTopLevelRef(ref))[0];
+        if (propertiesAreTypes) {
+            if (typeof schema !== "object") {
+                return Messages_1.messageError("SchemaCannotGetTypesFromBoolean", { ref: ref.toString() });
+            }
+            return collection_utils_1.mapMap(collection_utils_1.mapFromObject(schema), (_, name) => ref.push(name));
         }
         else {
-            const maybeName = nameFromURI(uri);
-            name = maybeName !== undefined ? maybeName : defaultName;
+            let name;
+            if (typeof schema === "object" && typeof schema.title === "string") {
+                name = schema.title;
+            }
+            else {
+                const maybeName = nameFromURI(uri);
+                name = maybeName !== undefined ? maybeName : defaultName;
+            }
+            return [name, ref];
         }
-        return [name, ref];
-    }
+    });
 }
 class InputJSONSchemaStore extends JSONSchemaStore_1.JSONSchemaStore {
-    _inputs;
-    _delegate;
     constructor(_inputs, _delegate) {
         super();
         this._inputs = _inputs;
         this._delegate = _delegate;
     }
-    async fetch(address) {
-        const maybeInput = this._inputs.get(address);
-        if (maybeInput !== undefined) {
-            return checkJSONSchema((0, Support_1.parseJSON)(maybeInput, "JSON Schema", address), () => Ref.root(address));
-        }
-        if (this._delegate === undefined) {
-            return (0, Support_1.panic)(`Schema URI ${address} requested, but no store given`);
-        }
-        return await this._delegate.fetch(address);
+    fetch(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const maybeInput = this._inputs.get(address);
+            if (maybeInput !== undefined) {
+                return checkJSONSchema(Support_1.parseJSON(maybeInput, "JSON Schema", address), () => Ref.root(address));
+            }
+            if (this._delegate === undefined) {
+                return Support_1.panic(`Schema URI ${address} requested, but no store given`);
+            }
+            return yield this._delegate.fetch(address);
+        });
     }
 }
 class JSONSchemaInput {
-    _schemaStore;
-    _additionalSchemaAddresses;
-    kind = "schema";
-    needSchemaProcessing = true;
-    _attributeProducers;
-    _schemaInputs = new Map();
-    _schemaSources = [];
-    _topLevels = new Map();
-    _needIR = false;
     constructor(_schemaStore, additionalAttributeProducers = [], _additionalSchemaAddresses = []) {
         this._schemaStore = _schemaStore;
         this._additionalSchemaAddresses = _additionalSchemaAddresses;
+        this.kind = "schema";
+        this.needSchemaProcessing = true;
+        this._schemaInputs = new Map();
+        this._schemaSources = [];
+        this._topLevels = new Map();
+        this._needIR = false;
         this._attributeProducers = [
             Description_1.descriptionAttributeProducer,
             AccessorNames_1.accessorNamesAttributeProducer,
@@ -936,54 +952,58 @@ class JSONSchemaInput {
     addTopLevel(name, ref) {
         this._topLevels.set(name, ref);
     }
-    async addTypes(ctx, typeBuilder) {
-        if (this._schemaSources.length === 0)
-            return;
-        let maybeSchemaStore = this._schemaStore;
-        if (this._schemaInputs.size === 0) {
-            if (maybeSchemaStore === undefined) {
-                return (0, Support_1.panic)("Must have a schema store to process JSON Schema");
+    addTypes(ctx, typeBuilder) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._schemaSources.length === 0)
+                return;
+            let maybeSchemaStore = this._schemaStore;
+            if (this._schemaInputs.size === 0) {
+                if (maybeSchemaStore === undefined) {
+                    return Support_1.panic("Must have a schema store to process JSON Schema");
+                }
             }
-        }
-        else {
-            maybeSchemaStore = this._schemaStore = new InputJSONSchemaStore(this._schemaInputs, maybeSchemaStore);
-        }
-        const schemaStore = maybeSchemaStore;
-        const canonizer = new Canonizer(ctx);
-        for (const address of this._additionalSchemaAddresses) {
-            const schema = await schemaStore.get(address, ctx.debugPrintSchemaResolving);
-            if (schema === undefined) {
-                return (0, Messages_1.messageError)("SchemaFetchErrorAdditional", { address });
+            else {
+                maybeSchemaStore = this._schemaStore = new InputJSONSchemaStore(this._schemaInputs, maybeSchemaStore);
             }
-            canonizer.addSchema(schema, address);
-        }
-        const resolver = new Resolver(ctx, (0, Support_1.defined)(this._schemaStore), canonizer);
-        for (const [normalizedURI, source] of this._schemaSources) {
-            const givenName = source.name;
-            const refs = await refsInSchemaForURI(resolver, normalizedURI, givenName);
-            if (Array.isArray(refs)) {
-                let name;
-                if (this._schemaSources.length === 1) {
-                    name = givenName;
+            const schemaStore = maybeSchemaStore;
+            const canonizer = new Canonizer(ctx);
+            for (const address of this._additionalSchemaAddresses) {
+                const schema = yield schemaStore.get(address, ctx.debugPrintSchemaResolving);
+                if (schema === undefined) {
+                    return Messages_1.messageError("SchemaFetchErrorAdditional", { address });
                 }
-                else {
-                    name = refs[0];
-                }
-                this.addTopLevel(name, refs[1]);
+                canonizer.addSchema(schema, address);
             }
-            else {
-                for (const [refName, ref] of refs) {
-                    this.addTopLevel(refName, ref);
+            const resolver = new Resolver(ctx, Support_1.defined(this._schemaStore), canonizer);
+            for (const [normalizedURI, source] of this._schemaSources) {
+                const givenName = source.name;
+                const refs = yield refsInSchemaForURI(resolver, normalizedURI, givenName);
+                if (Array.isArray(refs)) {
+                    let name;
+                    if (this._schemaSources.length === 1) {
+                        name = givenName;
+                    }
+                    else {
+                        name = refs[0];
+                    }
+                    this.addTopLevel(name, refs[1]);
+                }
+                else {
+                    for (const [refName, ref] of refs) {
+                        this.addTopLevel(refName, ref);
+                    }
                 }
             }
-        }
-        await addTypesInSchema(resolver, typeBuilder, this._topLevels, this._attributeProducers);
+            yield addTypesInSchema(resolver, typeBuilder, this._topLevels, this._attributeProducers);
+        });
     }
     addTypesSync() {
-        return (0, Support_1.panic)("addTypesSync not supported in JSONSchemaInput");
+        return Support_1.panic("addTypesSync not supported in JSONSchemaInput");
     }
-    async addSource(schemaSource) {
-        return this.addSourceSync(schemaSource);
+    addSource(schemaSource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.addSourceSync(schemaSource);
+        });
     }
     addSourceSync(schemaSource) {
         const { name, uris, schema, isConverted } = schemaSource;
@@ -992,7 +1012,7 @@ class JSONSchemaInput {
         }
         let normalizedURIs;
         if (uris === undefined) {
-            normalizedURIs = [new urijs_1.default(name)];
+            normalizedURIs = [new URI(name)];
         }
         else {
             normalizedURIs = uris.map(uri => {
@@ -1004,7 +1024,7 @@ class JSONSchemaInput {
             });
         }
         if (schema === undefined) {
-            (0, Support_1.assert)(uris !== undefined, "URIs must be given if schema source is not specified");
+            Support_1.assert(uris !== undefined, "URIs must be given if schema source is not specified");
         }
         else {
             for (let i = 0; i < normalizedURIs.length; i++) {
@@ -1033,7 +1053,7 @@ class JSONSchemaInput {
         }
         const set = new Set(this._schemaSources.map(([_, { schema }]) => schema));
         if (set.size === 1) {
-            return (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(set));
+            return Support_1.defined(collection_utils_1.iterableFirst(set));
         }
         return undefined;
     }