quicktype 15.0.258 → 15.0.261

package/README.md

@@ -148,7 +148,7 @@ const {
   InputData,
   jsonInputForTargetLanguage,
   JSONSchemaInput,
-  JSONSchemaStore,
+  FetchingJSONSchemaStore,
 } = require("quicktype-core");
 
 async function quicktypeJSON(targetLanguage, typeName, jsonString) {
@@ -172,7 +172,7 @@ async function quicktypeJSON(targetLanguage, typeName, jsonString) {
 }
 
 async function quicktypeJSONSchema(targetLanguage, typeName, jsonSchemaString) {
-  const schemaInput = new JSONSchemaInput(new JSONSchemaStore());
+  const schemaInput = new JSONSchemaInput(new FetchingJSONSchemaStore());
 
   // We could add multiple schemas for multiple types,
   // but here we're just making one type from JSON schema.

package/dist/cli/TypeSource.d.ts

@@ -1,5 +1,5 @@
 import { Readable } from "readable-stream";
-import { JSONSourceData, JSONSchemaSourceData } from "quicktype-core";
+import { JSONSourceData, JSONSchemaSourceData } from "../quicktype-core";
 import { GraphQLSourceData } from "../quicktype-graphql-input";
 export interface JSONTypeSource extends JSONSourceData<Readable> {
     kind: "json";

package/dist/quicktype-core/ConvenienceRenderer.js

@@ -26,9 +26,7 @@ const unionMemberNameOrder = 40;
 function splitDescription(descriptions) {
     if (descriptions === undefined)
         return undefined;
-    const description = Array.from(descriptions)
-        .join("\n\n")
-        .trim();
+    const description = Array.from(descriptions).join("\n\n").trim();
     if (description === "")
         return undefined;
     return wordWrap(description)
@@ -475,9 +473,7 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
         });
     }
     nameForUnionMember(u, t) {
-        return Support_1.defined(Support_1.defined(this._memberNamesStoreView)
-            .get(u)
-            .get(t));
+        return Support_1.defined(Support_1.defined(this._memberNamesStoreView).get(u).get(t));
     }
     nameForEnumCase(e, caseName) {
         const caseNames = Support_1.defined(this._caseNamesStoreView).get(e);

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

@@ -5,7 +5,7 @@ export { JSONSchemaInput, JSONSchemaSourceData } from "./input/JSONSchemaInput";
 export { Ref, JSONSchemaType, JSONSchemaAttributes } from "./input/JSONSchemaInput";
 export { RenderContext } from "./Renderer";
 export { Option, OptionDefinition, getOptionValues } from "./RendererOptions";
-export { TargetLanguage } from "./TargetLanguage";
+export { TargetLanguage, MultiFileRenderResult } from "./TargetLanguage";
 export { all as defaultTargetLanguages, languageNamed } from "./language/All";
 export { MultiWord, Sourcelike, SerializedRenderResult, Annotation, modifySource, singleWord, parenIfNeeded } from "./Source";
 export { Name, funPrefixNamer, Namer } from "./Naming";
@@ -28,7 +28,7 @@ export { StringTypes } from "./attributes/StringTypes";
 export { removeNullFromUnion, matchType, nullableFromUnion } from "./TypeUtils";
 export { ConvenienceRenderer } from "./ConvenienceRenderer";
 export { uriTypeAttributeKind } from "./attributes/URIAttributes";
-export { CPlusPlusTargetLanguage, CPlusPlusRenderer } from "./language/CPlusPlus";
+export { CPlusPlusTargetLanguage, CPlusPlusRenderer, cPlusPlusOptions } from "./language/CPlusPlus";
 export { CSharpTargetLanguage, cSharpOptions, CSharpRenderer, NewtonsoftCSharpTargetLanguage, newtonsoftCSharpOptions, NewtonsoftCSharpRenderer } from "./language/CSharp";
 export { GoTargetLanguage, GoRenderer, goOptions } from "./language/Golang";
 export { ObjectiveCTargetLanguage, ObjectiveCRenderer, objcOptions } from "./language/Objective-C";
@@ -44,3 +44,4 @@ export { RustTargetLanguage, RustRenderer, rustOptions } from "./language/Rust";
 export { RubyTargetLanguage, RubyRenderer, rubyOptions } from "./language/ruby";
 export { CrystalTargetLanguage, CrystalRenderer } from "./language/Crystal";
 export { HaskellTargetLanguage, HaskellRenderer, haskellOptions } from "./language/Haskell";
+export { DartTargetLanguage, DartRenderer, dartOptions } from "./language/Dart";

package/dist/quicktype-core/index.js

@@ -106,6 +106,7 @@ exports.uriTypeAttributeKind = URIAttributes_1.uriTypeAttributeKind;
 var CPlusPlus_1 = require("./language/CPlusPlus");
 exports.CPlusPlusTargetLanguage = CPlusPlus_1.CPlusPlusTargetLanguage;
 exports.CPlusPlusRenderer = CPlusPlus_1.CPlusPlusRenderer;
+exports.cPlusPlusOptions = CPlusPlus_1.cPlusPlusOptions;
 var CSharp_1 = require("./language/CSharp");
 exports.CSharpTargetLanguage = CSharp_1.CSharpTargetLanguage;
 exports.cSharpOptions = CSharp_1.cSharpOptions;
@@ -169,3 +170,7 @@ var Haskell_1 = require("./language/Haskell");
 exports.HaskellTargetLanguage = Haskell_1.HaskellTargetLanguage;
 exports.HaskellRenderer = Haskell_1.HaskellRenderer;
 exports.haskellOptions = Haskell_1.haskellOptions;
+var Dart_1 = require("./language/Dart");
+exports.DartTargetLanguage = Dart_1.DartTargetLanguage;
+exports.DartRenderer = Dart_1.DartRenderer;
+exports.dartOptions = Dart_1.dartOptions;

package/dist/quicktype-core/language/CPlusPlus.d.ts

@@ -21,11 +21,13 @@ export declare const cPlusPlusOptions: {
     memberNamingStyle: EnumOption<NamingStyle>;
     enumeratorNamingStyle: EnumOption<NamingStyle>;
     boost: BooleanOption;
+    hideNullOptional: BooleanOption;
 };
 export declare class CPlusPlusTargetLanguage extends TargetLanguage {
     constructor(displayName?: string, names?: string[], extension?: string);
     protected getOptions(): Option<any>[];
     readonly supportsUnionsWithBothNumberTypes: boolean;
+    readonly supportsOptionalClassProperties: boolean;
     protected makeRenderer(renderContext: RenderContext, untypedOptionValues: {
         [name: string]: any;
     }): CPlusPlusRenderer;
@@ -154,7 +156,7 @@ export declare class CPlusPlusRenderer extends ConvenienceRenderer {
     protected ourQualifier(inJsonNamespace: boolean): Sourcelike;
     protected jsonQualifier(inJsonNamespace: boolean): Sourcelike;
     protected variantIndirection(needIndirection: boolean, typeSrc: Sourcelike): Sourcelike;
-    protected cppType(t: Type, ctx: TypeContext, withIssues: boolean, forceNarrowString: boolean): Sourcelike;
+    protected cppType(t: Type, ctx: TypeContext, withIssues: boolean, forceNarrowString: boolean, isOptional: boolean): Sourcelike;
     /**
      * similar to cppType, it practically gathers all the generated types within
      * 't'. It also records, whether a given sub-type is part of a variant or not.

package/dist/quicktype-core/language/CPlusPlus.js

@@ -55,7 +55,8 @@ exports.cPlusPlusOptions = {
         pascalUpperAcronymsValue,
         camelUpperAcronymsValue
     ]),
-    boost: new RendererOptions_1.BooleanOption("boost", "Require a dependency on boost. Without boost, C++17 is required", true)
+    boost: new RendererOptions_1.BooleanOption("boost", "Require a dependency on boost. Without boost, C++17 is required", true),
+    hideNullOptional: new RendererOptions_1.BooleanOption("hide-null-optional", "Hide null value for optional field", false),
 };
 class CPlusPlusTargetLanguage extends TargetLanguage_1.TargetLanguage {
     constructor(displayName = "C++", names = ["c++", "cpp", "cplusplus"], extension = "cpp") {
@@ -75,12 +76,16 @@ class CPlusPlusTargetLanguage extends TargetLanguage_1.TargetLanguage {
             exports.cPlusPlusOptions.memberNamingStyle,
             exports.cPlusPlusOptions.enumeratorNamingStyle,
             exports.cPlusPlusOptions.enumType,
-            exports.cPlusPlusOptions.boost
+            exports.cPlusPlusOptions.boost,
+            exports.cPlusPlusOptions.hideNullOptional,
         ];
     }
     get supportsUnionsWithBothNumberTypes() {
         return true;
     }
+    get supportsOptionalClassProperties() {
+        return true;
+    }
     makeRenderer(renderContext, untypedOptionValues) {
         return new CPlusPlusRenderer(this, renderContext, RendererOptions_1.getOptionValues(exports.cPlusPlusOptions, untypedOptionValues));
     }
@@ -633,7 +638,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
     }
     cppTypeInOptional(nonNulls, ctx, withIssues, forceNarrowString) {
         if (nonNulls.size === 1) {
-            return this.cppType(Support_1.defined(collection_utils_1.iterableFirst(nonNulls)), ctx, withIssues, forceNarrowString);
+            return this.cppType(Support_1.defined(collection_utils_1.iterableFirst(nonNulls)), ctx, withIssues, forceNarrowString, false);
         }
         const typeList = [];
         for (const t of nonNulls) {
@@ -644,7 +649,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 needsForwardIndirection: true,
                 needsOptionalIndirection: false,
                 inJsonNamespace: ctx.inJsonNamespace
-            }, withIssues, false));
+            }, withIssues, false, false));
         }
         return [this._variantType, "<", typeList, ">"];
     }
@@ -669,9 +674,23 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             return typeSrc;
         return [optionalType, "<", typeSrc, ">"];
     }
-    cppType(t, ctx, withIssues, forceNarrowString) {
+    cppType(t, ctx, withIssues, forceNarrowString, isOptional) {
         const inJsonNamespace = ctx.inJsonNamespace;
-        return TypeUtils_1.matchType(t, _anyType => Source_1.maybeAnnotated(withIssues, Annotation_1.anyTypeIssueAnnotation, [this.jsonQualifier(inJsonNamespace), "json"]), _nullType => Source_1.maybeAnnotated(withIssues, Annotation_1.nullTypeIssueAnnotation, [this.jsonQualifier(inJsonNamespace), "json"]), _boolType => "bool", _integerType => "int64_t", _doubleType => "double", _stringType => {
+        if (isOptional && t instanceof Type_1.UnionType) { // avoid have optionalType<optionalType<Type>>
+            for (const tChild of t.getChildren()) {
+                if (tChild.isNullable) {
+                    isOptional = false;
+                    break;
+                }
+            }
+        }
+        let typeSource = TypeUtils_1.matchType(t, _anyType => {
+            isOptional = false;
+            return Source_1.maybeAnnotated(withIssues, Annotation_1.anyTypeIssueAnnotation, [this.jsonQualifier(inJsonNamespace), "json"]);
+        }, _nullType => {
+            isOptional = false;
+            return Source_1.maybeAnnotated(withIssues, Annotation_1.nullTypeIssueAnnotation, [this.jsonQualifier(inJsonNamespace), "json"]);
+        }, _boolType => "bool", _integerType => "int64_t", _doubleType => "double", _stringType => {
             if (forceNarrowString) {
                 return "std::string";
             }
@@ -680,9 +699,9 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             }
         }, arrayType => [
             "std::vector<",
-            this.cppType(arrayType.items, { needsForwardIndirection: false, needsOptionalIndirection: true, inJsonNamespace }, withIssues, forceNarrowString),
+            this.cppType(arrayType.items, { needsForwardIndirection: false, needsOptionalIndirection: true, inJsonNamespace }, withIssues, forceNarrowString, false),
             ">"
-        ], classType => this.variantIndirection(ctx.needsForwardIndirection && this.isForwardDeclaredType(classType), [
+        ], classType => this.variantIndirection(ctx.needsForwardIndirection && this.isForwardDeclaredType(classType) && !isOptional, [
             this.ourQualifier(inJsonNamespace),
             this.nameForNamedType(classType)
         ]), mapType => {
@@ -694,20 +713,24 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 "std::map<",
                 keyType,
                 ", ",
-                this.cppType(mapType.values, { needsForwardIndirection: false, needsOptionalIndirection: true, inJsonNamespace }, withIssues, forceNarrowString),
+                this.cppType(mapType.values, { needsForwardIndirection: false, needsOptionalIndirection: true, inJsonNamespace }, withIssues, forceNarrowString, false),
                 ">"
             ];
         }, enumType => [this.ourQualifier(inJsonNamespace), this.nameForNamedType(enumType)], unionType => {
             const nullable = TypeUtils_1.nullableFromUnion(unionType);
             if (nullable === null)
                 return [this.ourQualifier(inJsonNamespace), this.nameForNamedType(unionType)];
-            return [
-                optionalType,
-                "<",
-                this.cppType(nullable, { needsForwardIndirection: false, needsOptionalIndirection: false, inJsonNamespace }, withIssues, forceNarrowString),
-                ">"
-            ];
+            isOptional = true;
+            return this.cppType(nullable, { needsForwardIndirection: false, needsOptionalIndirection: false, inJsonNamespace }, withIssues, forceNarrowString, false);
         });
+        if (!isOptional)
+            return typeSource;
+        return [
+            optionalType,
+            "<",
+            typeSource,
+            ">"
+        ];
     }
     /**
      * similar to cppType, it practically gathers all the generated types within
@@ -787,7 +810,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         if (this._options.codeFormat) {
             this.emitLine("private:");
             this.forEachClassProperty(c, "none", (name, jsonName, property) => {
-                this.emitMember(this.cppType(property.type, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: false }, true, false), name);
+                this.emitMember(this.cppType(property.type, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: false }, true, false, property.isOptional), name);
                 if (constraints !== undefined && constraints.has(jsonName)) {
                     /** FIXME!!! NameStyle will/can collide with other Names */
                     const cnst = this.lookupGlobalName(GlobalNames.ClassMemberConstraints);
@@ -800,18 +823,18 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         this.forEachClassProperty(c, "none", (name, jsonName, property) => {
             this.emitDescription(this.descriptionForClassProperty(c, jsonName));
             if (!this._options.codeFormat) {
-                this.emitMember(this.cppType(property.type, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: false }, true, false), name);
+                this.emitMember(this.cppType(property.type, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: false }, true, false, property.isOptional), name);
             }
             else {
                 const [getterName, mutableGetterName, setterName] = Support_1.defined(this._gettersAndSettersForPropertyName.get(name));
-                const rendered = this.cppType(property.type, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: false }, true, false);
+                const rendered = this.cppType(property.type, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: false }, true, false, property.isOptional);
                 /**
                  * fix for optional type -> e.g. unique_ptrs can't be copied
                  * One might as why the "this->xxx = value". Simple if we have
                  * a member called 'value' value = value will screw up the compiler
                  */
                 const checkConst = this.lookupGlobalName(GlobalNames.CheckConstraint);
-                if (property.type instanceof Type_1.UnionType && property.type.findMember("null") !== undefined) {
+                if ((property.type instanceof Type_1.UnionType && property.type.findMember("null") !== undefined) || (property.isOptional && property.type.kind !== "null" && property.type.kind !== "any")) {
                     this.emitLine(rendered, " ", getterName, "() const { return ", name, "; }");
                     if (constraints !== undefined && constraints.has(jsonName)) {
                         this.emitLine("void ", setterName, "(", rendered, " value) { if (value) ", checkConst, "(", this._stringType.createStringLiteral([name]), ", ", this.constraintMember(jsonName), ", *value); this->", name, " = value; }");
@@ -909,8 +932,8 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             let cppType;
             let toType;
             this.emitBlock(["inline void from_json(", this.withConst("json"), " & j, ", ourQualifier, className, "& x)"], false, () => {
-                cppType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, true);
-                toType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, false);
+                cppType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, true, false);
+                toType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, false, false);
                 this.emitLine([
                     "x = ",
                     this._stringType.wrapEncodingChange([ourQualifier], cppType, toType, ["j.get<", cppType, ">()"]),
@@ -918,8 +941,8 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 ]);
             });
             this.emitBlock(["inline void to_json(json & j, ", this.withConst([ourQualifier, className]), " & x)"], false, () => {
-                cppType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, false);
-                toType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, true);
+                cppType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, false, false);
+                toType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, true, false);
                 this.emitLine([
                     "j = ",
                     this._stringType.wrapEncodingChange([ourQualifier], cppType, toType, "x"),
@@ -943,15 +966,34 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 else {
                     assignment = new WrappingCode(["x.", name, " = "], []);
                 }
-                if (t instanceof Type_1.UnionType) {
-                    const [maybeNull, nonNulls] = TypeUtils_1.removeNullFromUnion(t, true);
-                    if (maybeNull !== null) {
-                        cppType = this.cppTypeInOptional(nonNulls, {
+                if (t.kind === "null" || t.kind === "any") {
+                    this.emitLine(assignment.wrap([], [
+                        ourQualifier,
+                        "get_untyped(j, ",
+                        this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([Strings_1.stringEscape(json)])]),
+                        ")"
+                    ]), ";");
+                    return;
+                }
+                if (p.isOptional || t instanceof Type_1.UnionType) {
+                    const [nullOrOptional, typeSet] = function () {
+                        if (t instanceof Type_1.UnionType) {
+                            const [maybeNull, nonNulls] = TypeUtils_1.removeNullFromUnion(t, true);
+                            return [maybeNull !== null || p.isOptional, nonNulls];
+                        }
+                        else {
+                            let set = new Set();
+                            set.add(t);
+                            return [true, set];
+                        }
+                    }();
+                    if (nullOrOptional) {
+                        cppType = this.cppTypeInOptional(typeSet, {
                             needsForwardIndirection: false,
                             needsOptionalIndirection: false,
                             inJsonNamespace: true
                         }, false, true);
-                        toType = this.cppTypeInOptional(nonNulls, {
+                        toType = this.cppTypeInOptional(typeSet, {
                             needsForwardIndirection: false,
                             needsOptionalIndirection: false,
                             inJsonNamespace: true
@@ -969,17 +1011,8 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                         return;
                     }
                 }
-                if (t.kind === "null" || t.kind === "any") {
-                    this.emitLine(assignment.wrap([], [
-                        ourQualifier,
-                        "get_untyped(j, ",
-                        this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([Strings_1.stringEscape(json)])]),
-                        ")"
-                    ]), ";");
-                    return;
-                }
-                cppType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, true);
-                toType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, false);
+                cppType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, true, p.isOptional);
+                toType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, false, p.isOptional);
                 this.emitLine(assignment.wrap([], this._stringType.wrapEncodingChange([ourQualifier], cppType, toType, [
                     "j.at(",
                     this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), this._stringType.createStringLiteral([Strings_1.stringEscape(json)])),
@@ -994,8 +1027,8 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             this.emitLine("j = json::object();");
             this.forEachClassProperty(c, "none", (name, json, p) => {
                 const t = p.type;
-                cppType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, false);
-                toType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, true);
+                cppType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, false, p.isOptional);
+                toType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, true, p.isOptional);
                 const [getterName, ,] = Support_1.defined(this._gettersAndSettersForPropertyName.get(name));
                 let getter;
                 if (this._options.codeFormat) {
@@ -1004,7 +1037,21 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 else {
                     getter = [name];
                 }
-                this.emitLine("j[", this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), this._stringType.createStringLiteral([Strings_1.stringEscape(json)])), "] = ", this._stringType.wrapEncodingChange([ourQualifier], cppType, toType, ["x.", getter]), ";");
+                let assignment = [
+                    "j[",
+                    this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), this._stringType.createStringLiteral([Strings_1.stringEscape(json)])),
+                    "] = ",
+                    this._stringType.wrapEncodingChange([ourQualifier], cppType, toType, ["x.", getter]),
+                    ";"
+                ];
+                if (p.isOptional && this._options.hideNullOptional) {
+                    this.emitBlock(["if (", this._stringType.wrapEncodingChange([ourQualifier], cppType, toType, ["x.", getter]), ")"], false, () => {
+                        this.emitLine(assignment);
+                    });
+                }
+                else {
+                    this.emitLine(assignment);
+                }
             });
         });
     }
@@ -1056,8 +1103,8 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                     continue;
                 this.emitLine(onFirst ? "if" : "else if", " (j.", func, "())");
                 this.indent(() => {
-                    const cppType = this.cppType(typeForKind, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, true);
-                    let toType = this.cppType(typeForKind, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, false);
+                    const cppType = this.cppType(typeForKind, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, true, false);
+                    let toType = this.cppType(typeForKind, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, false, false);
                     this.emitLine("x = ", this._stringType.wrapEncodingChange([ourQualifier], cppType, toType, [
                         "j.get<",
                         cppType,
@@ -1079,12 +1126,12 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                             needsForwardIndirection: true,
                             needsOptionalIndirection: true,
                             inJsonNamespace: true
-                        }, false, false);
+                        }, false, false, false);
                         const toType = this.cppType(t, {
                             needsForwardIndirection: true,
                             needsOptionalIndirection: true,
                             inJsonNamespace: true
-                        }, false, true);
+                        }, false, true, false);
                         this.emitLine("j = ", this._stringType.wrapEncodingChange([ourQualifier], cppType, toType, [
                             this._options.boost ? "boost::get<" : "std::get<",
                             cppType,
@@ -1143,7 +1190,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         });
     }
     emitTopLevelTypedef(t, name) {
-        this.emitLine("using ", name, " = ", this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: false }, true, false), ";");
+        this.emitLine("using ", name, " = ", this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: false }, true, false, false), ";");
     }
     emitAllUnionFunctions() {
         this.forEachUniqueUnion("interposing", u => this.sourcelikeToString(this.cppTypeInOptional(TypeUtils_1.removeNullFromUnion(u, true)[1], { needsForwardIndirection: false, needsOptionalIndirection: false, inJsonNamespace: true }, false, false)), (u) => this.emitUnionFunctions(u));
@@ -1259,7 +1306,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             this.ensureBlankLine();
         }
         const checkConst = this.lookupGlobalName(GlobalNames.CheckConstraint);
-        this.emitBlock(["void ", checkConst, "(", this._stringType.getConstType(), " name, ", this.withConst(classConstraint), " & c, int64_t value)"], false, () => {
+        this.emitBlock(["inline void ", checkConst, "(", this._stringType.getConstType(), " name, ", this.withConst(classConstraint), " & c, int64_t value)"], false, () => {
             this.emitBlock(["if (c.", getterMinValue, "() != ", this._nulloptType, " && value < *c.", getterMinValue, "())"], false, () => {
                 this.emitLine("throw ", this.lookupGlobalName(GlobalNames.ValueTooLowException), " (", this._stringType.createStringLiteral(["Value too low for "]), " + name + ", this._stringType.createStringLiteral([" ("]), " + ", this._stringType.wrapToString(["value"]), " + ", this._stringType.createStringLiteral(["<"]), " + ", this._stringType.wrapToString(["*c.", getterMinValue, "()"]), " + ", this._stringType.createStringLiteral([")"]), ");");
             });
@@ -1270,7 +1317,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             this.ensureBlankLine();
         });
         this.ensureBlankLine();
-        this.emitBlock(["void ", checkConst, "(", this._stringType.getConstType(), " name, ", this.withConst(classConstraint), " & c, ", this._stringType.getConstType(), " value)"], false, () => {
+        this.emitBlock(["inline void ", checkConst, "(", this._stringType.getConstType(), " name, ", this.withConst(classConstraint), " & c, ", this._stringType.getConstType(), " value)"], false, () => {
             this.emitBlock(["if (c.", getterMinLength, "() != ", this._nulloptType, " && value.length() < *c.", getterMinLength, "())"], false, () => {
                 this.emitLine("throw ", this.lookupGlobalName(GlobalNames.ValueTooShortException), " (", this._stringType.createStringLiteral(["Value too short for "]), " + name + ", this._stringType.createStringLiteral([" ("]), " + ", this._stringType.wrapToString(["value.length()"]), " + ", this._stringType.createStringLiteral(["<"]), " + ", this._stringType.wrapToString(["*c.", getterMinLength, "()"]), " + ", this._stringType.createStringLiteral([")"]), ");");
             });
@@ -1311,7 +1358,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             this.emitLine("return get_untyped(j, property.data());");
         });
         this.ensureBlankLine();
-        if (this.haveUnions) {
+        if (this.haveUnions || this.haveOptionalProperties) {
             this.emitLine("template <typename T>");
             this.emitBlock(["inline ", optionalType, "<T> get_optional(", this.withConst("json"), " & j, ", this.withConst("char"), " * property)"], false, () => {
                 this.emitBlock(["if (j.find(property) != j.end())"], false, () => {
@@ -1359,7 +1406,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             this.ensureBlankLine();
             this.emitHelperFunctions();
         });
-        if (this.haveUnions) {
+        if (this.haveUnions || this.haveOptionalProperties) {
             this.ensureBlankLine();
             this.emitOptionalHelpers();
         }
@@ -1415,7 +1462,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             this.emitTypes();
         }
         else {
-            if (!this._options.justTypes && this.haveNamedTypes && this.haveUnions) {
+            if (!this._options.justTypes && this.haveNamedTypes && (this.haveUnions || this.haveOptionalProperties)) {
                 this.emitOptionalHelpers();
                 this.ensureBlankLine();
             }
@@ -1611,7 +1658,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                             needsForwardIndirection: false,
                             needsOptionalIndirection: false,
                             inJsonNamespace: false
-                        }, true, false))
+                        }, true, false, false))
                     ]);
                 }
                 return null;
@@ -1626,8 +1673,8 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         }
     }
     isConversionRequired(t) {
-        let originalType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, false);
-        let newType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, true);
+        let originalType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, false, false);
+        let newType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, true, false);
         return originalType !== newType;
     }
 }

package/dist/quicktype-core/language/CSharp.d.ts

@@ -23,6 +23,7 @@ export declare const cSharpOptions: {
     dense: EnumOption<boolean>;
     namespace: StringOption;
     version: EnumOption<Version>;
+    virtual: BooleanOption;
     typeForAny: EnumOption<CSharpTypeForAny>;
     useDecimal: EnumOption<boolean>;
 };
@@ -76,6 +77,7 @@ export declare const newtonsoftCSharpOptions: {
     dense: EnumOption<boolean>;
     namespace: StringOption;
     version: EnumOption<Version>;
+    virtual: BooleanOption;
     typeForAny: EnumOption<CSharpTypeForAny>;
     useDecimal: EnumOption<boolean>;
 } & {

package/dist/quicktype-core/language/CSharp.js

@@ -87,6 +87,7 @@ exports.cSharpOptions = {
         ["5", 5],
         ["6", 6],
     ], "6", "secondary"),
+    virtual: new RendererOptions_1.BooleanOption("virtual", "Generate virtual properties", false),
     typeForAny: new RendererOptions_1.EnumOption("any-type", 'Type to use for "any"', [
         ["object", "object"],
         ["dynamic", "dynamic"],
@@ -105,6 +106,7 @@ class CSharpTargetLanguage extends TargetLanguage_1.TargetLanguage {
             exports.cSharpOptions.useList,
             exports.cSharpOptions.useDecimal,
             exports.cSharpOptions.typeForAny,
+            exports.cSharpOptions.virtual,
         ];
     }
     get stringTypeMapping() {
@@ -222,12 +224,12 @@ class CSharpRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         return TypeUtils_1.matchType(actualType, (_anyType) => Source_1.maybeAnnotated(withIssues, Annotation_1.anyTypeIssueAnnotation, this._csOptions.typeForAny), (_nullType) => Source_1.maybeAnnotated(withIssues, Annotation_1.nullTypeIssueAnnotation, this._csOptions.typeForAny), (_boolType) => "bool", (_integerType) => "long", (_doubleType) => this.doubleType, (_stringType) => "string", (arrayType) => {
             const itemsType = this.csType(arrayType.items, follow, withIssues);
             if (this._csOptions.useList) {
-                return ["List<", itemsType, ">"];
+                return ["System.Collections.Generic.List<", itemsType, ">"];
             }
             else {
                 return [itemsType, "[]"];
             }
-        }, (classType) => this.nameForNamedType(classType), (mapType) => ["Dictionary<string, ", this.csType(mapType.values, follow, withIssues), ">"], (enumType) => this.nameForNamedType(enumType), (unionType) => {
+        }, (classType) => this.nameForNamedType(classType), (mapType) => ["System.Collections.Generic.Dictionary<string, ", this.csType(mapType.values, follow, withIssues), ">"], (enumType) => this.nameForNamedType(enumType), (unionType) => {
             const nullable = TypeUtils_1.nullableFromUnion(unionType);
             if (nullable !== null)
                 return this.nullableCSType(nullable, noFollow);
@@ -275,7 +277,10 @@ class CSharpRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         const csType = property.isOptional
             ? this.nullableCSType(t, Transformers_1.followTargetType, true)
             : this.csType(t, Transformers_1.followTargetType, true);
-        return ["public ", csType, " ", name, " { get; set; }"];
+        const propertyArray = ["public "];
+        if (this._csOptions.virtual)
+            propertyArray.push("virtual ");
+        return [...propertyArray, csType, " ", name, " { get; set; }"];
     }
     emitDescriptionBlock(lines) {
         const start = "/// <summary>";
@@ -471,6 +476,7 @@ class NewtonsoftCSharpTargetLanguage extends CSharpTargetLanguage {
             exports.newtonsoftCSharpOptions.checkRequired,
             exports.newtonsoftCSharpOptions.typeForAny,
             exports.newtonsoftCSharpOptions.baseclass,
+            exports.newtonsoftCSharpOptions.virtual,
         ];
     }
     makeRenderer(renderContext, untypedOptionValues) {

package/dist/quicktype-core/language/Dart.d.ts

@@ -4,7 +4,7 @@ import { StringTypeMapping } from "../TypeBuilder";
 import { Name, Namer, DependencyName } from "../Naming";
 import { ConvenienceRenderer, ForbiddenWordsInfo } from "../ConvenienceRenderer";
 import { TargetLanguage } from "../TargetLanguage";
-import { Option, BooleanOption, OptionValues } from "../RendererOptions";
+import { Option, BooleanOption, OptionValues, StringOption } from "../RendererOptions";
 import { RenderContext } from "../Renderer";
 export declare const dartOptions: {
     justTypes: BooleanOption;
@@ -13,6 +13,9 @@ export declare const dartOptions: {
     requiredProperties: BooleanOption;
     finalProperties: BooleanOption;
     generateCopyWith: BooleanOption;
+    useFreezed: BooleanOption;
+    useHive: BooleanOption;
+    partName: StringOption;
 };
 export declare class DartTargetLanguage extends TargetLanguage {
     constructor();
@@ -27,6 +30,8 @@ export declare class DartRenderer extends ConvenienceRenderer {
     private readonly _options;
     private readonly _gettersAndSettersForPropertyName;
     private _needEnumValues;
+    private classCounter;
+    private classPropertyCounter;
     private readonly _topLevelDependents;
     private readonly _enumValues;
     constructor(targetLanguage: TargetLanguage, renderContext: RenderContext, _options: OptionValues<typeof dartOptions>);
@@ -53,6 +58,7 @@ export declare class DartRenderer extends ConvenienceRenderer {
     protected fromDynamicExpression(t: Type, ...dynamic: Sourcelike[]): Sourcelike;
     protected toDynamicExpression(t: Type, ...dynamic: Sourcelike[]): Sourcelike;
     protected emitClassDefinition(c: ClassType, className: Name): void;
+    protected emitFreezedClassDefinition(c: ClassType, className: Name): void;
     protected emitEnumDefinition(e: EnumType, enumName: Name): void;
     protected emitEnumValues(): void;
     protected emitSourceStructure(): void;

package/dist/quicktype-core/language/Dart.js

@@ -17,7 +17,10 @@ exports.dartOptions = {
     methodNamesWithMap: new RendererOptions_1.BooleanOption("from-map", "Use method names fromMap() & toMap()", false),
     requiredProperties: new RendererOptions_1.BooleanOption("required-props", "Make all properties required", false),
     finalProperties: new RendererOptions_1.BooleanOption("final-props", "Make all properties final", false),
-    generateCopyWith: new RendererOptions_1.BooleanOption("copy-with", "Generate CopyWith method", false)
+    generateCopyWith: new RendererOptions_1.BooleanOption("copy-with", "Generate CopyWith method", false),
+    useFreezed: new RendererOptions_1.BooleanOption("use-freezed", "Generate class definitions with @freezed compatibility", false),
+    useHive: new RendererOptions_1.BooleanOption("use-hive", "Generate annotations for Hive type adapters", false),
+    partName: new RendererOptions_1.StringOption("part-name", "Use this name in `part` directive", "NAME", "")
 };
 class DartTargetLanguage extends TargetLanguage_1.TargetLanguage {
     constructor() {
@@ -30,7 +33,10 @@ class DartTargetLanguage extends TargetLanguage_1.TargetLanguage {
             exports.dartOptions.methodNamesWithMap,
             exports.dartOptions.requiredProperties,
             exports.dartOptions.finalProperties,
-            exports.dartOptions.generateCopyWith
+            exports.dartOptions.generateCopyWith,
+            exports.dartOptions.useFreezed,
+            exports.dartOptions.useHive,
+            exports.dartOptions.partName
         ];
     }
     get supportsUnionsWithBothNumberTypes() {
@@ -154,6 +160,8 @@ class DartRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         this._options = _options;
         this._gettersAndSettersForPropertyName = new Map();
         this._needEnumValues = false;
+        this.classCounter = 0;
+        this.classPropertyCounter = 0;
         this._topLevelDependents = new Map();
         this._enumValues = new Map();
     }
@@ -229,7 +237,25 @@ class DartRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         if (this._options.requiredProperties) {
             this.emitLine("import 'package:meta/meta.dart';");
         }
+        if (this._options.useFreezed) {
+            this.emitLine("import 'package:freezed_annotation/freezed_annotation.dart';");
+        }
+        if (this._options.useHive) {
+            this.emitLine("import 'package:hive/hive.dart';");
+        }
         this.emitLine("import 'dart:convert';");
+        if (this._options.useFreezed || this._options.useHive) {
+            this.ensureBlankLine();
+            const optionNameIsEmpty = this._options.partName.length === 0;
+            // FIXME: This should use a `Name`, not `modifySource`
+            const name = Source_1.modifySource(Strings_1.snakeCase, optionNameIsEmpty ? [...this.topLevels.keys()][0] : this._options.partName);
+            if (this._options.useFreezed) {
+                this.emitLine("part '", name, ".freezed.dart';");
+            }
+            if (!this._options.justTypes) {
+                this.emitLine("part '", name, ".g.dart';");
+            }
+        }
     }
     emitDescriptionBlock(lines) {
         this.emitCommentLines(lines, " * ", "/**", " */");
@@ -310,6 +336,11 @@ class DartRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
     }
     emitClassDefinition(c, className) {
         this.emitDescription(this.descriptionForType(c));
+        if (this._options.useHive) {
+            this.classCounter++;
+            this.emitLine(`@HiveType(typeId: ${this.classCounter})`);
+            this.classPropertyCounter = 0;
+        }
         this.emitBlock(["class ", className], () => {
             if (c.getProperties().size === 0) {
                 this.emitLine(className, "();");
@@ -323,7 +354,15 @@ class DartRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 });
                 this.emitLine("});");
                 this.ensureBlankLine();
-                this.forEachClassProperty(c, "none", (name, _, p) => {
+                this.forEachClassProperty(c, "none", (name, jsonName, p) => {
+                    const description = this.descriptionForClassProperty(c, jsonName);
+                    if (description !== undefined) {
+                        this.emitDescription(description);
+                    }
+                    if (this._options.useHive) {
+                        this.classPropertyCounter++;
+                        this.emitLine(`@HiveField(${this.classPropertyCounter})`);
+                    }
                     this.emitLine(this._options.finalProperties ? "final " : "", this.dartType(p.type, true), " ", name, ";");
                 });
             }
@@ -372,6 +411,30 @@ class DartRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             this.emitLine("};");
         });
     }
+    emitFreezedClassDefinition(c, className) {
+        this.emitDescription(this.descriptionForType(c));
+        this.emitLine("@freezed");
+        this.emitBlock(["class ", className, " with _$", className], () => {
+            if (c.getProperties().size === 0) {
+                this.emitLine("const factory ", className, "() = _", className, ";");
+            }
+            else {
+                this.emitLine("const factory ", className, "({");
+                this.indent(() => {
+                    this.forEachClassProperty(c, "none", (name, _, _p) => {
+                        this.emitLine(this._options.requiredProperties ? "required " : "", this.dartType(_p.type, true), this._options.requiredProperties ? "" : "?", " ", name, ",");
+                    });
+                });
+                this.emitLine("}) = _", className, ";");
+            }
+            if (this._options.justTypes)
+                return;
+            this.ensureBlankLine();
+            this.emitLine(
+            // factory PublicAnswer.fromJson(Map<String, dynamic> json) => _$PublicAnswerFromJson(json);
+            "factory ", className, ".fromJson(Map<String, dynamic> json) => ", "_$", className, "FromJson(json);");
+        });
+    }
     emitEnumDefinition(e, enumName) {
         const caseNames = Array.from(e.cases).map(c => this.nameForEnumCase(e, c));
         this.emitDescription(this.descriptionForType(e));
@@ -418,7 +481,7 @@ class DartRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 // });
             });
         }
-        this.forEachNamedType("leading-and-interposing", (c, n) => this.emitClassDefinition(c, n), (e, n) => this.emitEnumDefinition(e, n), (_e, _n) => {
+        this.forEachNamedType("leading-and-interposing", (c, n) => this._options.useFreezed ? this.emitFreezedClassDefinition(c, n) : this.emitClassDefinition(c, n), (e, n) => this.emitEnumDefinition(e, n), (_e, _n) => {
             // We don't support this yet.
         });
         if (this._needEnumValues) {

package/dist/quicktype-core/language/Java.js

@@ -515,7 +515,7 @@ class JavaRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
     javaTypeWithoutGenerics(reference, t) {
         if (t instanceof Type_1.ArrayType) {
             if (this._options.useList) {
-                return ["List<", this.javaTypeWithoutGenerics(true, t.items), ">"];
+                return ["List"];
             }
             else {
                 return [this.javaTypeWithoutGenerics(false, t.items), "[]"];
@@ -1055,6 +1055,7 @@ class JacksonRenderer extends JavaRenderer {
                     const renderedForClass = this.javaTypeWithoutGenerics(false, topLevelType);
                     this.emitLine("ObjectMapper mapper = new ObjectMapper();");
                     this.emitLine("mapper.findAndRegisterModules();");
+                    this.emitLine("mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);");
                     this.emitLine("mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);");
                     this.emitOffsetDateTimeConverterModule();
                     this.emitLine(readerName, " = mapper.readerFor(", renderedForClass, ".class);");

package/dist/quicktype-core/language/JavaScript.js

@@ -17,7 +17,7 @@ exports.javaScriptOptions = {
     runtimeTypecheck: new RendererOptions_1.BooleanOption("runtime-typecheck", "Verify JSON.parse results at runtime", true),
     runtimeTypecheckIgnoreUnknownProperties: new RendererOptions_1.BooleanOption("runtime-typecheck-ignore-unknown-properties", "Ignore unknown properties when verifying at runtime", false, "secondary"),
     converters: Converters_1.convertersOption(),
-    rawType: new RendererOptions_1.EnumOption("raw-type", "Type to raw input (json by default)", [
+    rawType: new RendererOptions_1.EnumOption("raw-type", "Type of raw input (json by default)", [
         ["json", "json"],
         ["any", "any"]
     ], "json", "secondary")

package/dist/quicktype-core/language/Kotlin.d.ts

@@ -38,7 +38,7 @@ export declare class KotlinRenderer extends ConvenienceRenderer {
     protected makeEnumCaseNamer(): Namer;
     protected emitDescriptionBlock(lines: Sourcelike[]): void;
     protected emitBlock(line: Sourcelike, f: () => void, delimiter?: "curly" | "paren" | "lambda"): void;
-    protected anyType(withIssues?: boolean, noOptional?: boolean): Sourcelike;
+    protected anySourceType(optional: string): Sourcelike;
     protected arrayType(arrayType: ArrayType, withIssues?: boolean, _noOptional?: boolean): Sourcelike;
     protected mapType(mapType: MapType, withIssues?: boolean, _noOptional?: boolean): Sourcelike;
     protected kotlinType(t: Type, withIssues?: boolean, noOptional?: boolean): Sourcelike;
@@ -47,12 +47,12 @@ export declare class KotlinRenderer extends ConvenienceRenderer {
     protected emitTopLevelArray(t: ArrayType, name: Name): void;
     protected emitTopLevelMap(t: MapType, name: Name): void;
     protected emitEmptyClassDefinition(c: ClassType, className: Name): void;
-    private emitClassDefinition;
+    protected emitClassDefinition(c: ClassType, className: Name): void;
     protected emitClassDefinitionMethods(_c: ClassType, _className: Name): void;
-    protected emitClassAnnotations(_c: ClassType, _className: Name): void;
+    protected emitClassAnnotations(_c: Type, _className: Name): void;
     protected renameAttribute(_name: Name, _jsonName: string, _required: boolean, _meta: Array<() => void>): void;
     protected emitEnumDefinition(e: EnumType, enumName: Name): void;
-    private emitUnionDefinition;
+    protected emitUnionDefinition(u: UnionType, unionName: Name): void;
     protected emitUnionDefinitionMethods(_u: UnionType, _nonNulls: ReadonlySet<Type>, _maybeNull: PrimitiveType | null, _unionName: Name): void;
     protected emitSourceStructure(): void;
 }
@@ -93,14 +93,14 @@ export declare class KotlinJacksonRenderer extends KotlinRenderer {
  */
 export declare class KotlinXRenderer extends KotlinRenderer {
     constructor(targetLanguage: TargetLanguage, renderContext: RenderContext, _kotlinOptions: OptionValues<typeof kotlinOptions>);
-    protected anyType(_withIssues?: boolean, _noOptional?: boolean): Sourcelike;
+    protected anySourceType(optional: string): Sourcelike;
     protected arrayType(arrayType: ArrayType, withIssues?: boolean, noOptional?: boolean): Sourcelike;
     protected mapType(mapType: MapType, withIssues?: boolean, noOptional?: boolean): Sourcelike;
     protected emitTopLevelMap(t: MapType, name: Name): void;
     protected emitTopLevelArray(t: ArrayType, name: Name): void;
     protected emitUsageHeader(): void;
     protected emitHeader(): void;
-    protected emitClassAnnotations(_c: ClassType, _className: Name): void;
+    protected emitClassAnnotations(_c: Type, _className: Name): void;
     protected renameAttribute(name: Name, jsonName: string, _required: boolean, meta: Array<() => void>): void;
     private _rename;
     protected emitEnumDefinition(e: EnumType, enumName: Name): void;

package/dist/quicktype-core/language/Kotlin.js

@@ -165,12 +165,11 @@ class KotlinRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         this.indent(f);
         this.emitLine(close);
     }
-    // (asarazan): I've broken out the following three functions
-    // because some renderers, such as kotlinx, can cope with `any`, while some get mad.
-    anyType(withIssues = false, noOptional = false) {
-        const optional = noOptional ? "" : "?";
-        return Source_1.maybeAnnotated(withIssues, Annotation_1.anyTypeIssueAnnotation, ["Any", optional]);
+    anySourceType(optional) {
+        return ["Any", optional];
     }
+    // (asarazan): I've broken out the following two functions
+    // because some renderers, such as kotlinx, can cope with `any`, while some get mad.
     arrayType(arrayType, withIssues = false, _noOptional = false) {
         return ["List<", this.kotlinType(arrayType.items, withIssues), ">"];
     }
@@ -179,8 +178,10 @@ class KotlinRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
     }
     kotlinType(t, withIssues = false, noOptional = false) {
         const optional = noOptional ? "" : "?";
-        return TypeUtils_1.matchType(t, _anyType => this.anyType(withIssues, noOptional), _nullType => {
-            return Source_1.maybeAnnotated(withIssues, Annotation_1.nullTypeIssueAnnotation, ["Any", optional]);
+        return TypeUtils_1.matchType(t, _anyType => {
+            return Source_1.maybeAnnotated(withIssues, Annotation_1.anyTypeIssueAnnotation, this.anySourceType(optional));
+        }, _nullType => {
+            return Source_1.maybeAnnotated(withIssues, Annotation_1.nullTypeIssueAnnotation, this.anySourceType(optional));
         }, _boolType => "Boolean", _integerType => "Long", _doubleType => "Double", _stringType => "String", arrayType => this.arrayType(arrayType, withIssues), classType => this.nameForNamedType(classType), mapType => this.mapType(mapType, withIssues), enumType => this.nameForNamedType(enumType), unionType => {
             const nullable = TypeUtils_1.nullableFromUnion(unionType);
             if (nullable !== null)
@@ -212,6 +213,7 @@ class KotlinRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
     }
     emitEmptyClassDefinition(c, className) {
         this.emitDescription(this.descriptionForType(c));
+        this.emitClassAnnotations(c, className);
         this.emitLine("class ", className, "()");
     }
     emitClassDefinition(c, className) {
@@ -285,6 +287,7 @@ class KotlinRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         }
         this.emitDescription(this.descriptionForType(u));
         const [maybeNull, nonNulls] = TypeUtils_1.removeNullFromUnion(u, sortBy);
+        this.emitClassAnnotations(u, unionName);
         this.emitBlock(["sealed class ", unionName], () => {
             {
                 let table = [];
@@ -731,8 +734,8 @@ class KotlinXRenderer extends KotlinRenderer {
     constructor(targetLanguage, renderContext, _kotlinOptions) {
         super(targetLanguage, renderContext, _kotlinOptions);
     }
-    anyType(_withIssues = false, _noOptional = false) {
-        return "JsonObject";
+    anySourceType(optional) {
+        return ["JsonObject", optional];
     }
     arrayType(arrayType, withIssues = false, noOptional = false) {
         const valType = this.kotlinType(arrayType.items, withIssues, true);
@@ -767,7 +770,7 @@ class KotlinXRenderer extends KotlinRenderer {
         this.emitLine("// To parse the JSON, install kotlin's serialization plugin and do:");
         this.emitLine("//");
         const table = [];
-        table.push(["// val ", "json", " = Json(JsonConfiguration.Stable)"]);
+        table.push(["// val ", "json", " = Json { allowStructuredMapKeys = true }"]);
         this.forEachTopLevel("none", (_, name) => {
             table.push(["// val ", Source_1.modifySource(Strings_1.camelCase, name), ` = json.parse(${this.sourcelikeToString(name)}.serializer(), jsonString)`]);
         });
@@ -777,7 +780,8 @@ class KotlinXRenderer extends KotlinRenderer {
         super.emitHeader();
         this.emitLine("import kotlinx.serialization.*");
         this.emitLine("import kotlinx.serialization.json.*");
-        this.emitLine("import kotlinx.serialization.internal.*");
+        this.emitLine("import kotlinx.serialization.descriptors.*");
+        this.emitLine("import kotlinx.serialization.encoding.*");
     }
     emitClassAnnotations(_c, _className) {
         this.emitLine("@Serializable");
@@ -807,7 +811,7 @@ class KotlinXRenderer extends KotlinRenderer {
             this.ensureBlankLine();
             this.emitBlock(["companion object : KSerializer<", enumName, ">"], () => {
                 this.emitBlock("override val descriptor: SerialDescriptor get()", () => {
-                    this.emitLine("return PrimitiveDescriptor(\"", this._kotlinOptions.packageName, ".", enumName, "\", PrimitiveKind.STRING)");
+                    this.emitLine("return PrimitiveSerialDescriptor(\"", this._kotlinOptions.packageName, ".", enumName, "\", PrimitiveKind.STRING)");
                 });
                 this.emitBlock(["override fun deserialize(decoder: Decoder): ", enumName, " = when (val value = decoder.decodeString())"], () => {
                     let table = [];

package/dist/quicktype-core/language/Swift.js

@@ -621,7 +621,7 @@ class SwiftRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 this.emitLineOnce("//   let ", Source_1.modifySource(Strings_1.camelCase, topLevelName), " = try ", topLevelName, "(json)");
             }
             else {
-                this.emitLineOnce("//   let ", Source_1.modifySource(Strings_1.camelCase, topLevelName), " = ", "try? newJSONDecoder().decode(", topLevelName, ".self, from: jsonData)");
+                this.emitLineOnce("//   let ", Source_1.modifySource(Strings_1.camelCase, topLevelName), " = ", "try? JSONDecoder().decode(", topLevelName, ".self, from: jsonData)");
             }
         });
     }

package/dist/quicktype-core/language/TypeScriptFlow.d.ts

@@ -15,6 +15,7 @@ export declare const tsFlowOptions: {
     justTypes: BooleanOption;
     nicePropertyNames: BooleanOption;
     declareUnions: BooleanOption;
+    preferUnions: BooleanOption;
 };
 export declare abstract class TypeScriptFlowBaseTargetLanguage extends JavaScriptTargetLanguage {
     protected getOptions(): Option<any>[];

package/dist/quicktype-core/language/TypeScriptFlow.js

@@ -12,7 +12,8 @@ const JavaScriptUnicodeMaps_1 = require("./JavaScriptUnicodeMaps");
 exports.tsFlowOptions = Object.assign({}, JavaScript_1.javaScriptOptions, {
     justTypes: new RendererOptions_1.BooleanOption("just-types", "Interfaces only", false),
     nicePropertyNames: new RendererOptions_1.BooleanOption("nice-property-names", "Transform property names to be JavaScripty", false),
-    declareUnions: new RendererOptions_1.BooleanOption("explicit-unions", "Explicitly name unions", false)
+    declareUnions: new RendererOptions_1.BooleanOption("explicit-unions", "Explicitly name unions", false),
+    preferUnions: new RendererOptions_1.BooleanOption("prefer-unions", "Use union type instead of enum", false)
 });
 const tsFlowTypeAnnotations = {
     any: ": any",
@@ -32,7 +33,8 @@ class TypeScriptFlowBaseTargetLanguage extends JavaScript_1.JavaScriptTargetLang
             exports.tsFlowOptions.runtimeTypecheckIgnoreUnknownProperties,
             exports.tsFlowOptions.acronymStyle,
             exports.tsFlowOptions.converters,
-            exports.tsFlowOptions.rawType
+            exports.tsFlowOptions.rawType,
+            exports.tsFlowOptions.preferUnions
         ];
     }
     get supportsOptionalClassProperties() {
@@ -207,11 +209,24 @@ class TypeScriptRenderer extends TypeScriptFlowBaseRenderer {
     }
     emitEnum(e, enumName) {
         this.emitDescription(this.descriptionForType(e));
-        this.emitBlock(["export enum ", enumName, " "], "", () => {
-            this.forEachEnumCase(e, "none", (name, jsonName) => {
-                this.emitLine(name, ` = "${Strings_1.utf16StringEscape(jsonName)}",`);
+        if (this._tsFlowOptions.preferUnions) {
+            let items = "";
+            e.cases.forEach((item) => {
+                if (items === "") {
+                    items += `"${Strings_1.utf16StringEscape(item)}"`;
+                    return;
+                }
+                items += ` | "${Strings_1.utf16StringEscape(item)}"`;
             });
-        });
+            this.emitLine("export type ", enumName, " = ", items, ";");
+        }
+        else {
+            this.emitBlock(["export enum ", enumName, " "], "", () => {
+                this.forEachEnumCase(e, "none", (name, jsonName) => {
+                    this.emitLine(name, ` = "${Strings_1.utf16StringEscape(jsonName)}",`);
+                });
+            });
+        }
     }
     emitClassBlock(c, className) {
         this.emitBlock(["export interface ", className, " "], "", () => {

package/dist/quicktype-core/language/ruby/index.js

@@ -13,10 +13,6 @@ const Strings_1 = require("../../support/Strings");
 function unicodeEscape(codePoint) {
     return "\\u{" + Strings_1.intToHex(codePoint, 0) + "}";
 }
-function snakeCase(str) {
-    const words = Strings_1.splitIntoWords(str).map(({ word }) => word.toLowerCase());
-    return words.join("_");
-}
 const stringEscape = Strings_1.utf32ConcatMap(Strings_1.escapeNonPrintableMapper(Strings_1.isPrintable, unicodeEscape));
 var Strictness;
 (function (Strictness) {
@@ -284,11 +280,17 @@ class RubyRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                             : // This will raise a runtime error if the key is not found in the hash
                                 `d.fetch("${stringEscape(jsonName)}")`;
                         if (this.propertyTypeMarshalsImplicitlyFromDynamic(p.type)) {
-                            inits.push([[name, ": "], [dynamic, ","]]);
+                            inits.push([
+                                [name, ": "],
+                                [dynamic, ","]
+                            ]);
                         }
                         else {
                             const expression = this.fromDynamic(p.type, dynamic, p.isOptional);
-                            inits.push([[name, ": "], [expression, ","]]);
+                            inits.push([
+                                [name, ": "],
+                                [expression, ","]
+                            ]);
                         }
                     });
                     this.emitTable(inits);
@@ -452,7 +454,7 @@ class RubyRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             this.emitLine("# To parse this JSON, add 'dry-struct' and 'dry-types' gems, then do:");
             this.emitLine("#");
             this.forEachTopLevel("none", (topLevel, name) => {
-                const variable = Source_1.modifySource(snakeCase, name);
+                const variable = Source_1.modifySource(Strings_1.snakeCase, name);
                 this.emitLine("#   ", variable, " = ", name, ".from_json! ", this.jsonSample(topLevel));
                 this.emitLine("#   puts ", this.exampleUse(topLevel, variable));
                 this.emitLine("#");
@@ -474,7 +476,7 @@ class RubyRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         this.forEachNamedType("leading-and-interposing", (c, n) => this.emitClass(c, n), (e, n) => this.emitEnum(e, n), (u, n) => this.emitUnion(u, n));
         if (!this._options.justTypes) {
             this.forEachTopLevel("leading-and-interposing", (topLevel, name) => {
-                const self = Source_1.modifySource(snakeCase, name);
+                const self = Source_1.modifySource(Strings_1.snakeCase, name);
                 // The json gem defines to_json on maps and primitives, so we only need to supply
                 // it for arrays.
                 const needsToJsonDefined = "array" === topLevel.kind;

package/dist/quicktype-core/support/Strings.d.ts

@@ -24,6 +24,7 @@ export declare function capitalize(str: string): string;
 export declare function decapitalize(str: string): string;
 export declare function pascalCase(str: string): string;
 export declare function camelCase(str: string): string;
+export declare function snakeCase(str: string): string;
 export declare function startWithLetter(isAllowedStart: (codePoint: number) => boolean, // FIXME: technically, this operates on UTF16 units
 upper: boolean, str: string): string;
 export declare type WordInName = {

package/dist/quicktype-core/support/Strings.js

@@ -273,6 +273,11 @@ function camelCase(str) {
     return decapitalize(pascalCase(str));
 }
 exports.camelCase = camelCase;
+function snakeCase(str) {
+    const words = splitIntoWords(str).map(({ word }) => word.toLowerCase());
+    return words.join("_");
+}
+exports.snakeCase = snakeCase;
 function startWithLetter(isAllowedStart, // FIXME: technically, this operates on UTF16 units
 upper, str) {
     const modify = upper ? capitalize : decapitalize;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quicktype",
-  "version": "15.0.258",
+  "version": "15.0.261",
   "license": "Apache-2.0",
   "main": "dist/cli/index.js",
   "types": "dist/cli/index.d.ts",
@@ -23,9 +23,9 @@
     "graphql": "^0.11.7",
     "is-url": "^1.2.4",
     "js-base64": "^2.4.3",
-    "lodash": "^4.17.19",
+    "lodash": "^4.17.21",
     "moment": "^2.22.1",
-    "node-fetch": "^1.7.1",
+    "node-fetch": "^2.6.1",
     "pako": "^1.0.6",
     "pluralize": "^7.0.0",
     "stream-json": "1.1.3",
@@ -33,7 +33,7 @@
     "typescript": "~3.2.1",
     "@mark.probst/typescript-json-schema": "~0.32.0",
     "@mark.probst/unicode-properties": "~1.1.0",
-    "urijs": "^1.19.1",
+    "urijs": "^1.19.6",
     "uuid": "^3.2.1",
     "wordwrap": "^1.0.0",
     "yaml": "^1.5.0",