quicktype-core 6.1.12 → 7.0.0

package/dist/index.d.ts

@@ -29,7 +29,7 @@ export { removeNullFromUnion, matchType, nullableFromUnion } from "./TypeUtils";
 export { ConvenienceRenderer } from "./ConvenienceRenderer";
 export { uriTypeAttributeKind } from "./attributes/URIAttributes";
 export { CPlusPlusTargetLanguage, CPlusPlusRenderer, cPlusPlusOptions } from "./language/CPlusPlus";
-export { CSharpTargetLanguage, cSharpOptions, CSharpRenderer, NewtonsoftCSharpTargetLanguage, newtonsoftCSharpOptions, NewtonsoftCSharpRenderer } from "./language/CSharp";
+export { CSharpTargetLanguage, cSharpOptions, CSharpRenderer } from "./language/CSharp";
 export { GoTargetLanguage, GoRenderer, goOptions } from "./language/Golang";
 export { ObjectiveCTargetLanguage, ObjectiveCRenderer, objcOptions } from "./language/Objective-C";
 export { JavaTargetLanguage, JavaRenderer, javaOptions } from "./language/Java";

package/dist/index.js

@@ -111,9 +111,6 @@ var CSharp_1 = require("./language/CSharp");
 exports.CSharpTargetLanguage = CSharp_1.CSharpTargetLanguage;
 exports.cSharpOptions = CSharp_1.cSharpOptions;
 exports.CSharpRenderer = CSharp_1.CSharpRenderer;
-exports.NewtonsoftCSharpTargetLanguage = CSharp_1.NewtonsoftCSharpTargetLanguage;
-exports.newtonsoftCSharpOptions = CSharp_1.newtonsoftCSharpOptions;
-exports.NewtonsoftCSharpRenderer = CSharp_1.NewtonsoftCSharpRenderer;
 var Golang_1 = require("./language/Golang");
 exports.GoTargetLanguage = Golang_1.GoTargetLanguage;
 exports.GoRenderer = Golang_1.GoRenderer;

package/dist/language/All.js

@@ -21,7 +21,7 @@ const Python_1 = require("./Python");
 const Pike_1 = require("./Pike");
 const Haskell_1 = require("./Haskell");
 exports.all = [
-    new CSharp_1.NewtonsoftCSharpTargetLanguage(),
+    new CSharp_1.CSharpTargetLanguage(),
     new Golang_1.GoTargetLanguage(),
     new Rust_1.RustTargetLanguage(),
     new Crystal_1.CrystalTargetLanguage(),

package/dist/language/CSharp.d.ts

@@ -7,6 +7,10 @@ import { StringOption, EnumOption, Option, BooleanOption, OptionValues } from ".
 import { StringTypeMapping } from "../TypeBuilder";
 import { Transformation } from "../Transformers";
 import { RenderContext } from "../Renderer";
+export declare enum Framework {
+    Newtonsoft = 0,
+    SystemTextJson = 1
+}
 export declare type Version = 5 | 6;
 export declare type OutputFeatures = {
     helpers: boolean;
@@ -19,6 +23,7 @@ export declare enum AccessModifier {
 }
 export declare type CSharpTypeForAny = "object" | "dynamic";
 export declare const cSharpOptions: {
+    framework: EnumOption<Framework>;
     useList: EnumOption<boolean>;
     dense: EnumOption<boolean>;
     namespace: StringOption;
@@ -28,6 +33,7 @@ export declare const cSharpOptions: {
     useDecimal: EnumOption<boolean>;
 };
 export declare class CSharpTargetLanguage extends TargetLanguage {
+    constructor();
     protected getOptions(): Option<any>[];
     readonly stringTypeMapping: StringTypeMapping;
     readonly supportsUnionsWithBothNumberTypes: boolean;
@@ -35,7 +41,7 @@ export declare class CSharpTargetLanguage extends TargetLanguage {
     needsTransformerForType(t: Type): boolean;
     protected makeRenderer(renderContext: RenderContext, untypedOptionValues: {
         [name: string]: any;
-    }): CSharpRenderer;
+    }): ConvenienceRenderer;
 }
 export declare class CSharpRenderer extends ConvenienceRenderer {
     private readonly _csOptions;
@@ -69,10 +75,12 @@ export declare class CSharpRenderer extends ConvenienceRenderer {
     protected emitRequiredHelpers(): void;
     private emitTypesAndSupport;
     protected emitDefaultLeadingComments(): void;
+    protected emitDefaultFollowingComments(): void;
     protected needNamespace(): boolean;
     protected emitSourceStructure(): void;
 }
 export declare const newtonsoftCSharpOptions: {
+    framework: EnumOption<Framework>;
     useList: EnumOption<boolean>;
     dense: EnumOption<boolean>;
     namespace: StringOption;
@@ -89,13 +97,6 @@ export declare const newtonsoftCSharpOptions: {
     baseclass: EnumOption<string | undefined>;
     checkRequired: BooleanOption;
 };
-export declare class NewtonsoftCSharpTargetLanguage extends CSharpTargetLanguage {
-    constructor();
-    protected getOptions(): Option<any>[];
-    protected makeRenderer(renderContext: RenderContext, untypedOptionValues: {
-        [name: string]: any;
-    }): NewtonsoftCSharpRenderer;
-}
 export declare class NewtonsoftCSharpRenderer extends CSharpRenderer {
     private readonly _options;
     private readonly _enumExtensionsNames;
@@ -135,3 +136,61 @@ export declare class NewtonsoftCSharpRenderer extends CSharpRenderer {
     protected emitRequiredHelpers(): void;
     protected needNamespace(): boolean;
 }
+export declare const systemTextJsonCSharpOptions: {
+    framework: EnumOption<Framework>;
+    useList: EnumOption<boolean>;
+    dense: EnumOption<boolean>;
+    namespace: StringOption;
+    version: EnumOption<Version>;
+    virtual: BooleanOption;
+    typeForAny: EnumOption<CSharpTypeForAny>;
+    useDecimal: EnumOption<boolean>;
+} & {
+    features: EnumOption<{
+        namespaces: boolean;
+        helpers: boolean;
+        attributes: boolean;
+    }>;
+    baseclass: EnumOption<string | undefined>;
+    checkRequired: BooleanOption;
+};
+export declare class SystemTextJsonCSharpRenderer extends CSharpRenderer {
+    private readonly _options;
+    private readonly _enumExtensionsNames;
+    private readonly _needHelpers;
+    private readonly _needAttributes;
+    private readonly _needNamespaces;
+    constructor(targetLanguage: TargetLanguage, renderContext: RenderContext, _options: OptionValues<typeof systemTextJsonCSharpOptions>);
+    protected forbiddenNamesForGlobalNamespace(): string[];
+    protected forbiddenForObjectProperties(c: ClassType, className: Name): ForbiddenWordsInfo;
+    protected makeNameForTransformation(xf: Transformation, typeName: Name | undefined): Name;
+    protected makeNamedTypeDependencyNames(t: Type, name: Name): DependencyName[];
+    protected emitUsings(): void;
+    protected baseclassForType(_t: Type): Sourcelike | undefined;
+    protected emitDefaultFollowingComments(): void;
+    protected emitDefaultLeadingComments(): void;
+    private converterForType;
+    protected attributesForProperty(property: ClassProperty, _name: Name, _c: ClassType, jsonName: string): Sourcelike[] | undefined;
+    protected blankLinesBetweenAttributes(): boolean;
+    private topLevelResultType;
+    private emitFromJsonForTopLevel;
+    private emitDecoderSwitch;
+    private emitTokenCase;
+    private emitThrow;
+    private deserializeTypeCode;
+    private serializeValueCode;
+    private emitSerializeClass;
+    private emitCanConvert;
+    private emitReadJson;
+    private emitWriteJson;
+    private converterObject;
+    private emitConverterClass;
+    private emitDecoderTransformerCase;
+    private emitConsume;
+    private emitDecodeTransformer;
+    private stringCaseValue;
+    private emitTransformer;
+    private emitTransformation;
+    protected emitRequiredHelpers(): void;
+    protected needNamespace(): boolean;
+}

package/dist/language/CSharp.js

@@ -13,6 +13,11 @@ const RendererOptions_1 = require("../RendererOptions");
 const Annotation_1 = require("../Annotation");
 const Transformers_1 = require("../Transformers");
 const Constraints_1 = require("../attributes/Constraints");
+var Framework;
+(function (Framework) {
+    Framework[Framework["Newtonsoft"] = 0] = "Newtonsoft";
+    Framework[Framework["SystemTextJson"] = 1] = "SystemTextJson";
+})(Framework = exports.Framework || (exports.Framework = {}));
 const unicode = require("@mark.probst/unicode-properties");
 var AccessModifier;
 (function (AccessModifier) {
@@ -73,6 +78,7 @@ function csTypeForTransformedStringType(t) {
     }
 }
 exports.cSharpOptions = {
+    framework: new RendererOptions_1.EnumOption("framework", "Serialization framework", [["NewtonSoft", Framework.Newtonsoft], ["SystemTextJson", Framework.SystemTextJson]], "NewtonSoft"),
     useList: new RendererOptions_1.EnumOption("array-type", "Use T[] or List<T>", [
         ["array", false],
         ["list", true],
@@ -98,8 +104,12 @@ exports.cSharpOptions = {
     ], "double", "secondary"),
 };
 class CSharpTargetLanguage extends TargetLanguage_1.TargetLanguage {
+    constructor() {
+        super("C#", ["cs", "csharp"], "cs");
+    }
     getOptions() {
         return [
+            exports.cSharpOptions.framework,
             exports.cSharpOptions.namespace,
             exports.cSharpOptions.version,
             exports.cSharpOptions.dense,
@@ -131,7 +141,15 @@ class CSharpTargetLanguage extends TargetLanguage_1.TargetLanguage {
         return need !== "none" && need !== "nullable";
     }
     makeRenderer(renderContext, untypedOptionValues) {
-        return new CSharpRenderer(this, renderContext, RendererOptions_1.getOptionValues(exports.cSharpOptions, untypedOptionValues));
+        const options = RendererOptions_1.getOptionValues(exports.cSharpOptions, untypedOptionValues);
+        switch (options.framework) {
+            case Framework.Newtonsoft:
+                return new NewtonsoftCSharpRenderer(this, renderContext, RendererOptions_1.getOptionValues(exports.newtonsoftCSharpOptions, untypedOptionValues));
+            case Framework.SystemTextJson:
+                return new SystemTextJsonCSharpRenderer(this, renderContext, RendererOptions_1.getOptionValues(exports.systemTextJsonCSharpOptions, untypedOptionValues));
+            default:
+                return Support_1.assertNever(options.framework);
+        }
     }
 }
 exports.CSharpTargetLanguage = CSharpTargetLanguage;
@@ -423,6 +441,9 @@ class CSharpRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
     emitDefaultLeadingComments() {
         return;
     }
+    emitDefaultFollowingComments() {
+        return;
+    }
     needNamespace() {
         return true;
     }
@@ -445,6 +466,7 @@ class CSharpRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             this.emitUsings();
             this.emitTypesAndSupport();
         }
+        this.emitDefaultFollowingComments();
     }
 }
 exports.CSharpRenderer = CSharpRenderer;
@@ -461,29 +483,6 @@ exports.newtonsoftCSharpOptions = Object.assign({}, exports.cSharpOptions, {
     ], "Object", "secondary"),
     checkRequired: new RendererOptions_1.BooleanOption("check-required", "Fail if required properties are missing", false),
 });
-class NewtonsoftCSharpTargetLanguage extends CSharpTargetLanguage {
-    constructor() {
-        super("C#", ["cs", "csharp"], "cs");
-    }
-    getOptions() {
-        return [
-            exports.newtonsoftCSharpOptions.namespace,
-            exports.newtonsoftCSharpOptions.version,
-            exports.newtonsoftCSharpOptions.dense,
-            exports.newtonsoftCSharpOptions.useList,
-            exports.newtonsoftCSharpOptions.useDecimal,
-            exports.newtonsoftCSharpOptions.features,
-            exports.newtonsoftCSharpOptions.checkRequired,
-            exports.newtonsoftCSharpOptions.typeForAny,
-            exports.newtonsoftCSharpOptions.baseclass,
-            exports.newtonsoftCSharpOptions.virtual,
-        ];
-    }
-    makeRenderer(renderContext, untypedOptionValues) {
-        return new NewtonsoftCSharpRenderer(this, renderContext, RendererOptions_1.getOptionValues(exports.newtonsoftCSharpOptions, untypedOptionValues));
-    }
-}
-exports.NewtonsoftCSharpTargetLanguage = NewtonsoftCSharpTargetLanguage;
 class NewtonsoftCSharpRenderer extends CSharpRenderer {
     constructor(targetLanguage, renderContext, _options) {
         super(targetLanguage, renderContext, _options);
@@ -1080,3 +1079,765 @@ class NewtonsoftCSharpRenderer extends CSharpRenderer {
     }
 }
 exports.NewtonsoftCSharpRenderer = NewtonsoftCSharpRenderer;
+exports.systemTextJsonCSharpOptions = Object.assign({}, exports.cSharpOptions, {
+    features: new RendererOptions_1.EnumOption("features", "Output features", [
+        ["complete", { namespaces: true, helpers: true, attributes: true }],
+        ["attributes-only", { namespaces: true, helpers: false, attributes: true }],
+        ["just-types-and-namespace", { namespaces: true, helpers: false, attributes: false }],
+        ["just-types", { namespaces: true, helpers: false, attributes: false }],
+    ]),
+    baseclass: new RendererOptions_1.EnumOption("base-class", "Base class", [
+        ["EntityData", "EntityData"],
+        ["Object", undefined],
+    ], "Object", "secondary"),
+    checkRequired: new RendererOptions_1.BooleanOption("check-required", "Fail if required properties are missing", false),
+});
+class SystemTextJsonCSharpRenderer extends CSharpRenderer {
+    constructor(targetLanguage, renderContext, _options) {
+        super(targetLanguage, renderContext, _options);
+        this._options = _options;
+        this._enumExtensionsNames = new Map();
+        this._needHelpers = _options.features.helpers;
+        this._needAttributes = _options.features.attributes;
+        this._needNamespaces = _options.features.namespaces;
+    }
+    forbiddenNamesForGlobalNamespace() {
+        const forbidden = [
+            "Converter",
+            "JsonConverter",
+            "JsonSerializer",
+            "JsonWriter",
+            "JsonToken",
+            "Serialize",
+            "JsonSerializerOptions",
+            // "Newtonsoft",
+            // "MetadataPropertyHandling",
+            // "DateParseHandling",
+            "FromJson",
+            "Required"
+        ];
+        if (this._options.dense) {
+            forbidden.push("J", "R", "N");
+        }
+        if (this._options.baseclass !== undefined) {
+            forbidden.push(this._options.baseclass);
+        }
+        return super.forbiddenNamesForGlobalNamespace().concat(forbidden);
+    }
+    forbiddenForObjectProperties(c, className) {
+        const result = super.forbiddenForObjectProperties(c, className);
+        result.names = result.names.concat(["ToJson", "FromJson", "Required"]);
+        return result;
+    }
+    makeNameForTransformation(xf, typeName) {
+        if (typeName === undefined) {
+            let xfer = xf.transformer;
+            if (xfer instanceof Transformers_1.DecodingTransformer && xfer.consumer !== undefined) {
+                xfer = xfer.consumer;
+            }
+            return new Naming_1.SimpleName([`${xfer.kind}_converter`], namingFunction, ConvenienceRenderer_1.inferredNameOrder + 30);
+        }
+        return new Naming_1.DependencyName(namingFunction, typeName.order + 30, lookup => `${lookup(typeName)}_converter`);
+    }
+    makeNamedTypeDependencyNames(t, name) {
+        if (!(t instanceof Type_1.EnumType))
+            return [];
+        const extensionsName = new Naming_1.DependencyName(namingFunction, name.order + 30, lookup => `${lookup(name)}_extensions`);
+        this._enumExtensionsNames.set(name, extensionsName);
+        return [extensionsName];
+    }
+    emitUsings() {
+        // FIXME: We need System.Collections.Generic whenever we have maps or use List.
+        if (!this._needAttributes && !this._needHelpers)
+            return;
+        super.emitUsings();
+        this.ensureBlankLine();
+        for (const ns of ["System.Text.Json", "System.Text.Json.Serialization", "System.Globalization"]) {
+            this.emitUsing(ns);
+        }
+        if (this._options.dense) {
+            this.emitUsing([denseJsonPropertyName, " = System.Text.Json.Serialization.JsonPropertyNameAttribute"]);
+            // this.emitUsing([denseRequiredEnumName, " = Newtonsoft.Json.Required"]);
+            this.emitUsing([denseNullValueHandlingEnumName, " = System.Text.Json.Serialization.JsonIgnoreCondition"]);
+        }
+        if (this._options.baseclass === "EntityData") {
+            this.emitUsing("Microsoft.Azure.Mobile.Server");
+        }
+    }
+    baseclassForType(_t) {
+        return this._options.baseclass;
+    }
+    emitDefaultFollowingComments() {
+        if (!this._needHelpers)
+            return;
+        this.emitLine("#pragma warning restore CS8618");
+        this.emitLine("#pragma warning restore CS8601");
+        this.emitLine("#pragma warning restore CS8603");
+    }
+    emitDefaultLeadingComments() {
+        if (!this._needHelpers)
+            return;
+        this.emitLine("// <auto-generated />");
+        this.emitLine("//");
+        this.emitLine("// To parse this JSON data, add NuGet 'System.Text.Json' then do", this.topLevels.size === 1 ? "" : " one of these", ":");
+        this.emitLine("//");
+        this.emitLine("//    using ", this._options.namespace, ";");
+        this.emitLine("//");
+        this.forEachTopLevel("none", (t, topLevelName) => {
+            let rhs;
+            if (t instanceof Type_1.EnumType) {
+                rhs = ["JsonSerializer.Deserialize<", topLevelName, ">(jsonString)"];
+            }
+            else {
+                rhs = [topLevelName, ".FromJson(jsonString)"];
+            }
+            this.emitLine("//    var ", Source_1.modifySource(Strings_1.camelCase, topLevelName), " = ", rhs, ";");
+        });
+        // fix: should this be an option? Or respond to an existing option?
+        this.emitLine("#nullable enable");
+        this.emitLine("#pragma warning disable CS8618");
+        this.emitLine("#pragma warning disable CS8601");
+        this.emitLine("#pragma warning disable CS8603");
+    }
+    converterForType(t) {
+        let xf = Transformers_1.transformationForType(t);
+        if (xf === undefined && t instanceof Type_1.UnionType) {
+            const maybeNullable = TypeUtils_1.nullableFromUnion(t);
+            if (maybeNullable !== null) {
+                t = maybeNullable;
+                xf = Transformers_1.transformationForType(t);
+            }
+        }
+        if (xf === undefined)
+            return undefined;
+        if (alwaysApplyTransformation(xf))
+            return undefined;
+        return Support_1.defined(this.nameForTransformation(t));
+    }
+    attributesForProperty(property, _name, _c, jsonName) {
+        if (!this._needAttributes)
+            return undefined;
+        const attributes = [];
+        const jsonPropertyName = this._options.dense ? denseJsonPropertyName : "JsonPropertyName";
+        const escapedName = Strings_1.utf16StringEscape(jsonName);
+        const isNullable = Transformers_1.followTargetType(property.type).isNullable;
+        const isOptional = property.isOptional;
+        if (isOptional && !isNullable) {
+            attributes.push(["[", "JsonIgnore", "(Condition = JsonIgnoreCondition.WhenWritingNull)]"]);
+        }
+        // const requiredClass = this._options.dense ? "R" : "Required";
+        // const nullValueHandlingClass = this._options.dense ? "N" : "NullValueHandling";
+        // const nullValueHandling = isOptional && !isNullable ? [", NullValueHandling = ", nullValueHandlingClass, ".Ignore"] : [];
+        // let required: Sourcelike;
+        // if (!this._options.checkRequired || (isOptional && isNullable)) {
+        //     required = [nullValueHandling];
+        // } else if (isOptional && !isNullable) {
+        //     required = [", Required = ", requiredClass, ".DisallowNull", nullValueHandling];
+        // } else if (!isOptional && isNullable) {
+        //     required = [", Required = ", requiredClass, ".AllowNull"];
+        // } else {
+        //     required = [", Required = ", requiredClass, ".Always", nullValueHandling];
+        // }
+        attributes.push(["[", jsonPropertyName, '("', escapedName, '")]']);
+        const converter = this.converterForType(property.type);
+        if (converter !== undefined) {
+            attributes.push(["[JsonConverter(typeof(", converter, "))]"]);
+        }
+        return attributes;
+    }
+    blankLinesBetweenAttributes() {
+        return this._needAttributes && !this._options.dense;
+    }
+    // The "this" type can't be `dynamic`, so we have to force it to `object`.
+    topLevelResultType(t) {
+        return t.kind === "any" || t.kind === "none" ? "object" : this.csType(t);
+    }
+    emitFromJsonForTopLevel(t, name) {
+        if (t instanceof Type_1.EnumType)
+            return;
+        let partial;
+        let typeKind;
+        const definedType = this.namedTypeToNameForTopLevel(t);
+        if (definedType !== undefined) {
+            partial = "partial ";
+            typeKind = definedType instanceof Type_1.ClassType ? "class" : "struct";
+        }
+        else {
+            partial = "";
+            typeKind = "class";
+        }
+        const csType = this.topLevelResultType(t);
+        this.emitType(undefined, AccessModifier.Public, [partial, typeKind], name, this.baseclassForType(t), () => {
+            // FIXME: Make FromJson a Named
+            this.emitExpressionMember(["public static ", csType, " FromJson(string json)"], ["JsonSerializer.Deserialize<", csType, ">(json, ", this._options.namespace, ".Converter.Settings)"]);
+        });
+    }
+    emitDecoderSwitch(emitBody) {
+        this.emitLine("switch (reader.TokenType)");
+        this.emitBlock(emitBody);
+    }
+    emitTokenCase(tokenType) {
+        this.emitLine("case JsonTokenType.", tokenType, ":");
+    }
+    emitThrow(message) {
+        this.emitLine("throw new Exception(", message, ");");
+    }
+    deserializeTypeCode(typeName) {
+        switch (typeName) {
+            case "bool":
+                return ["reader.GetBoolean()"];
+            case "long":
+                return ["reader.GetInt64()"];
+            case "decimal":
+                return ["reader.GetDecimal()"];
+            case "double":
+                return ["reader.GetDouble()"];
+            case "string":
+                return ["reader.GetString()"];
+            default:
+                return ["JsonSerializer.Deserialize<", typeName, ">(ref reader, options)"];
+        }
+    }
+    serializeValueCode(value) {
+        if (value !== "null")
+            return ["JsonSerializer.Serialize(writer, ", value, ", options)"];
+        else
+            return ["writer.WriteNullValue()"];
+    }
+    emitSerializeClass() {
+        // FIXME: Make Serialize a Named
+        this.emitType(undefined, AccessModifier.Public, "static class", "Serialize", undefined, () => {
+            // Sometimes multiple top-levels will resolve to the same type, so we have to take care
+            // not to emit more than one extension method for the same type.
+            const seenTypes = new Set();
+            this.forEachTopLevel("none", t => {
+                // FIXME: Make ToJson a Named
+                if (!seenTypes.has(t)) {
+                    seenTypes.add(t);
+                    this.emitExpressionMember(["public static string ToJson(this ", this.topLevelResultType(t), " self)"], ["JsonSerializer.Serialize(self, ", this._options.namespace, ".Converter.Settings)"]);
+                }
+            });
+        });
+    }
+    emitCanConvert(expr) {
+        this.emitExpressionMember("public override bool CanConvert(Type t)", expr);
+    }
+    emitReadJson(emitBody, csType) {
+        this.emitLine("public override ", csType, " Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)");
+        this.emitBlock(emitBody);
+    }
+    emitWriteJson(variable, emitBody, csType) {
+        this.emitLine("public override void Write(Utf8JsonWriter writer, ", csType, " ", variable, ", JsonSerializerOptions options)");
+        this.emitBlock(emitBody);
+    }
+    converterObject(converterName) {
+        // FIXME: Get a singleton
+        return [converterName, ".Singleton"];
+    }
+    emitConverterClass() {
+        // FIXME: Make Converter a Named
+        const converterName = ["Converter"];
+        this.emitType(undefined, AccessModifier.Internal, "static class", converterName, undefined, () => {
+            // Do not use .Web as defaults. That turns on caseInsensitive property names and will fail the keywords test.
+            this.emitLine("public static readonly JsonSerializerOptions Settings = new(JsonSerializerDefaults.General)");
+            this.emitBlock(() => {
+                // this.emitLine("MetadataPropertyHandling = MetadataPropertyHandling.Ignore,");
+                // this.emitLine("DateParseHandling = DateParseHandling.None,");
+                this.emitLine("Converters =");
+                this.emitLine("{");
+                this.indent(() => {
+                    for (const [t, converter] of this.typesWithNamedTransformations) {
+                        if (alwaysApplyTransformation(Support_1.defined(Transformers_1.transformationForType(t)))) {
+                            this.emitLine(this.converterObject(converter), ",");
+                        }
+                    }
+                    this.emitLine("new DateOnlyConverter(),");
+                    this.emitLine("new TimeOnlyConverter(),");
+                    this.emitLine("IsoDateTimeOffsetConverter.Singleton");
+                    // this.emitLine("new IsoDateTimeConverter { DateTimeStyles = DateTimeStyles.AssumeUniversal }");
+                });
+                this.emitLine(`},`);
+            }, true);
+        });
+    }
+    emitDecoderTransformerCase(tokenCases, variableName, xfer, targetType, emitFinish) {
+        if (xfer === undefined)
+            return;
+        for (const tokenCase of tokenCases) {
+            this.emitTokenCase(tokenCase);
+        }
+        this.indent(() => {
+            const allHandled = this.emitDecodeTransformer(xfer, targetType, emitFinish, variableName);
+            if (!allHandled) {
+                this.emitLine("break;");
+            }
+        });
+    }
+    emitConsume(value, consumer, targetType, emitFinish) {
+        if (consumer === undefined) {
+            emitFinish(value);
+            return true;
+        }
+        else {
+            return this.emitTransformer(value, consumer, targetType, emitFinish);
+        }
+    }
+    emitDecodeTransformer(xfer, targetType, emitFinish, variableName = "value") {
+        if (xfer instanceof Transformers_1.DecodingTransformer) {
+            const source = xfer.sourceType;
+            const converter = this.converterForType(targetType);
+            if (converter !== undefined) {
+                const typeSource = this.csType(targetType);
+                this.emitLine("var converter = ", this.converterObject(converter), ";");
+                this.emitLine("var ", variableName, " = (", typeSource, ")converter.ReadJson(reader, typeof(", typeSource, "), null, serializer);");
+            }
+            else if (source.kind !== "null") {
+                let output = targetType.kind === "double" ? targetType : source;
+                this.emitLine("var ", variableName, " = ", this.deserializeTypeCode(this.csType(output)), ";");
+            }
+            return this.emitConsume(variableName, xfer.consumer, targetType, emitFinish);
+        }
+        else if (xfer instanceof Transformers_1.ArrayDecodingTransformer) {
+            // FIXME: Consume StartArray
+            if (!(targetType instanceof Type_1.ArrayType)) {
+                return Support_1.panic("Array decoding must produce an array type");
+            }
+            // FIXME: handle EOF
+            this.emitLine("reader.Read();");
+            this.emitLine("var ", variableName, " = new List<", this.csType(targetType.items), ">();");
+            this.emitLine("while (reader.TokenType != JsonToken.EndArray)");
+            this.emitBlock(() => {
+                this.emitDecodeTransformer(xfer.itemTransformer, xfer.itemTargetType, v => this.emitLine(variableName, ".Add(", v, ");"), "arrayItem");
+                // FIXME: handle EOF
+                this.emitLine("reader.Read();");
+            });
+            let result = variableName;
+            if (!this._options.useList) {
+                result = [result, ".ToArray()"];
+            }
+            emitFinish(result);
+            return true;
+        }
+        else if (xfer instanceof Transformers_1.DecodingChoiceTransformer) {
+            this.emitDecoderSwitch(() => {
+                const nullTransformer = xfer.nullTransformer;
+                if (nullTransformer !== undefined) {
+                    this.emitTokenCase("Null");
+                    this.indent(() => {
+                        const allHandled = this.emitDecodeTransformer(nullTransformer, targetType, emitFinish, "null");
+                        if (!allHandled) {
+                            this.emitLine("break");
+                        }
+                    });
+                }
+                this.emitDecoderTransformerCase(["Number"], "integerValue", xfer.integerTransformer, targetType, emitFinish);
+                this.emitDecoderTransformerCase(["Number"], 
+                // xfer.integerTransformer === undefined ? ["Integer", "Float"] : ["Float"],
+                "doubleValue", xfer.doubleTransformer, targetType, emitFinish);
+                this.emitDecoderTransformerCase(["True", "False"], "boolValue", xfer.boolTransformer, targetType, emitFinish);
+                this.emitDecoderTransformerCase(
+                // ["String", "Date"],
+                ["String"], "stringValue", xfer.stringTransformer, targetType, emitFinish);
+                this.emitDecoderTransformerCase(["StartObject"], "objectValue", xfer.objectTransformer, targetType, emitFinish);
+                this.emitDecoderTransformerCase(["StartArray"], "arrayValue", xfer.arrayTransformer, targetType, emitFinish);
+            });
+            return false;
+        }
+        else {
+            return Support_1.panic("Unknown transformer");
+        }
+    }
+    stringCaseValue(t, stringCase) {
+        if (t.kind === "string") {
+            return ['"', Strings_1.utf16StringEscape(stringCase), '"'];
+        }
+        else if (t instanceof Type_1.EnumType) {
+            return [this.nameForNamedType(t), ".", this.nameForEnumCase(t, stringCase)];
+        }
+        return Support_1.panic(`Type ${t.kind} does not have string cases`);
+    }
+    emitTransformer(variable, xfer, targetType, emitFinish) {
+        function directTargetType(continuation) {
+            if (continuation === undefined) {
+                return targetType;
+            }
+            return Transformers_1.followTargetType(continuation.sourceType);
+        }
+        if (xfer instanceof Transformers_1.ChoiceTransformer) {
+            const caseXfers = xfer.transformers;
+            if (caseXfers.length > 1 && caseXfers.every(caseXfer => caseXfer instanceof Transformers_1.StringMatchTransformer)) {
+                this.emitLine("switch (", variable, ")");
+                this.emitBlock(() => {
+                    for (const caseXfer of caseXfers) {
+                        const matchXfer = caseXfer;
+                        const value = this.stringCaseValue(Transformers_1.followTargetType(matchXfer.sourceType), matchXfer.stringCase);
+                        this.emitLine("case ", value, ":");
+                        this.indent(() => {
+                            const allDone = this.emitTransformer(variable, matchXfer.transformer, targetType, emitFinish);
+                            if (!allDone) {
+                                this.emitLine("break;");
+                            }
+                        });
+                    }
+                });
+                // FIXME: Can we check for exhaustiveness?  For enums it should be easy.
+                return false;
+            }
+            else {
+                for (const caseXfer of caseXfers) {
+                    this.emitTransformer(variable, caseXfer, targetType, emitFinish);
+                }
+            }
+        }
+        else if (xfer instanceof Transformers_1.UnionMemberMatchTransformer) {
+            const memberType = xfer.memberType;
+            const maybeNullable = TypeUtils_1.nullableFromUnion(xfer.sourceType);
+            let test;
+            let member;
+            if (maybeNullable !== null) {
+                if (memberType.kind === "null") {
+                    test = [variable, " == null"];
+                    member = "null";
+                }
+                else {
+                    test = [variable, " != null"];
+                    member = variable;
+                }
+            }
+            else if (memberType.kind === "null") {
+                test = [variable, ".IsNull"];
+                member = "null";
+            }
+            else {
+                const memberName = this.nameForUnionMember(xfer.sourceType, memberType);
+                member = [variable, ".", memberName];
+                test = [member, " != null"];
+            }
+            if (memberType.kind !== "null" && isValueType(memberType)) {
+                member = [member, ".Value"];
+            }
+            this.emitLine("if (", test, ")");
+            this.emitBlock(() => this.emitTransformer(member, xfer.transformer, targetType, emitFinish));
+        }
+        else if (xfer instanceof Transformers_1.StringMatchTransformer) {
+            const value = this.stringCaseValue(Transformers_1.followTargetType(xfer.sourceType), xfer.stringCase);
+            this.emitLine("if (", variable, " == ", value, ")");
+            this.emitBlock(() => this.emitTransformer(variable, xfer.transformer, targetType, emitFinish));
+        }
+        else if (xfer instanceof Transformers_1.EncodingTransformer) {
+            const converter = this.converterForType(xfer.sourceType);
+            if (converter !== undefined) {
+                this.emitLine("var converter = ", this.converterObject(converter), ";");
+                this.emitLine("converter.WriteJson(writer, ", variable, ", serializer);");
+            }
+            else {
+                this.emitLine(this.serializeValueCode(variable), ";");
+            }
+            emitFinish([]);
+            return true;
+        }
+        else if (xfer instanceof Transformers_1.ArrayEncodingTransformer) {
+            this.emitLine("writer.WriteStartArray();");
+            const itemVariable = "arrayItem";
+            this.emitLine("foreach (var ", itemVariable, " in ", variable, ")");
+            this.emitBlock(() => {
+                this.emitTransformer(itemVariable, xfer.itemTransformer, xfer.itemTargetType, () => {
+                    return;
+                });
+            });
+            this.emitLine("writer.WriteEndArray();");
+            emitFinish([]);
+            return true;
+        }
+        else if (xfer instanceof Transformers_1.ParseStringTransformer) {
+            const immediateTargetType = xfer.consumer === undefined ? targetType : xfer.consumer.sourceType;
+            switch (immediateTargetType.kind) {
+                case "date-time":
+                    this.emitLine("DateTimeOffset dt;");
+                    this.emitLine("if (DateTimeOffset.TryParse(", variable, ", out dt))");
+                    this.emitBlock(() => this.emitConsume("dt", xfer.consumer, targetType, emitFinish));
+                    break;
+                case "uuid":
+                    this.emitLine("Guid guid;");
+                    this.emitLine("if (Guid.TryParse(", variable, ", out guid))");
+                    this.emitBlock(() => this.emitConsume("guid", xfer.consumer, targetType, emitFinish));
+                    break;
+                case "uri":
+                    this.emitLine("try");
+                    this.emitBlock(() => {
+                        // this.emitLine("var uri = new Uri(", variable, ");");
+                        // The default value about:blank should never happen, but this way we avoid a null reference warning.
+                        this.emitLine("var uri = new Uri(\"about:blank\");");
+                        this.emitLine("if (!string.IsNullOrEmpty(stringValue))");
+                        this.emitBlock(() => {
+                            this.emitLine("uri = new Uri(", variable, ");");
+                        });
+                        this.emitConsume("uri", xfer.consumer, targetType, emitFinish);
+                    });
+                    this.emitLine("catch (UriFormatException) {}");
+                    break;
+                case "integer":
+                    this.emitLine("long l;");
+                    this.emitLine("if (Int64.TryParse(", variable, ", out l))");
+                    this.emitBlock(() => this.emitConsume("l", xfer.consumer, targetType, emitFinish));
+                    break;
+                case "bool":
+                    this.emitLine("bool b;");
+                    this.emitLine("if (Boolean.TryParse(", variable, ", out b))");
+                    this.emitBlock(() => this.emitConsume("b", xfer.consumer, targetType, emitFinish));
+                    break;
+                default:
+                    return Support_1.panic(`Parsing string to ${immediateTargetType.kind} not supported`);
+            }
+        }
+        else if (xfer instanceof Transformers_1.StringifyTransformer) {
+            switch (xfer.sourceType.kind) {
+                case "date-time":
+                    return this.emitConsume([variable, '.ToString("o", System.Globalization.CultureInfo.InvariantCulture)'], xfer.consumer, targetType, emitFinish);
+                case "uuid":
+                    return this.emitConsume([variable, '.ToString("D", System.Globalization.CultureInfo.InvariantCulture)'], xfer.consumer, targetType, emitFinish);
+                case "integer":
+                case "uri":
+                    return this.emitConsume([variable, ".ToString()"], xfer.consumer, targetType, emitFinish);
+                case "bool":
+                    this.emitLine("var boolString = ", variable, ' ? "true" : "false";');
+                    return this.emitConsume("boolString", xfer.consumer, targetType, emitFinish);
+                default:
+                    return Support_1.panic(`Stringifying ${xfer.sourceType.kind} not supported`);
+            }
+        }
+        else if (xfer instanceof Transformers_1.StringProducerTransformer) {
+            const value = this.stringCaseValue(directTargetType(xfer.consumer), xfer.result);
+            return this.emitConsume(value, xfer.consumer, targetType, emitFinish);
+        }
+        else if (xfer instanceof Transformers_1.MinMaxLengthCheckTransformer) {
+            const min = xfer.minLength;
+            const max = xfer.maxLength;
+            const conditions = [];
+            if (min !== undefined) {
+                conditions.push([variable, ".Length >= ", min.toString()]);
+            }
+            if (max !== undefined) {
+                conditions.push([variable, ".Length <= ", max.toString()]);
+            }
+            this.emitLine("if (", collection_utils_1.arrayIntercalate([" && "], conditions), ")");
+            this.emitBlock(() => this.emitConsume(variable, xfer.consumer, targetType, emitFinish));
+            return false;
+        }
+        else if (xfer instanceof Transformers_1.MinMaxValueTransformer) {
+            const min = xfer.minimum;
+            const max = xfer.maximum;
+            const conditions = [];
+            if (min !== undefined) {
+                conditions.push([variable, " >= ", min.toString()]);
+            }
+            if (max !== undefined) {
+                conditions.push([variable, " <= ", max.toString()]);
+            }
+            this.emitLine("if (", collection_utils_1.arrayIntercalate([" && "], conditions), ")");
+            this.emitBlock(() => this.emitConsume(variable, xfer.consumer, targetType, emitFinish));
+            return false;
+        }
+        else if (xfer instanceof Transformers_1.UnionInstantiationTransformer) {
+            if (!(targetType instanceof Type_1.UnionType)) {
+                return Support_1.panic("Union instantiation transformer must produce a union type");
+            }
+            const maybeNullable = TypeUtils_1.nullableFromUnion(targetType);
+            if (maybeNullable !== null) {
+                emitFinish(variable);
+            }
+            else {
+                const unionName = this.nameForNamedType(targetType);
+                let initializer;
+                if (xfer.sourceType.kind === "null") {
+                    initializer = " ";
+                }
+                else {
+                    const memberName = this.nameForUnionMember(targetType, xfer.sourceType);
+                    initializer = [" ", memberName, " = ", variable, " "];
+                }
+                emitFinish(["new ", unionName, " {", initializer, "}"]);
+            }
+            return true;
+        }
+        else {
+            return Support_1.panic("Unknown transformer");
+        }
+        return false;
+    }
+    emitTransformation(converterName, t) {
+        const xf = Support_1.defined(Transformers_1.transformationForType(t));
+        const reverse = xf.reverse;
+        const targetType = xf.targetType;
+        const xfer = xf.transformer;
+        const csType = this.csType(targetType);
+        // const haveNullable = isValueType(targetType);
+        // if (haveNullable) {
+        //     converterName = ['Nullable', converterName];
+        //     csType = [csType, "?"];
+        // }
+        this.emitType(undefined, AccessModifier.Internal, "class", converterName, ["JsonConverter<", csType, ">"], () => {
+            let canConvertExpr = ["t == typeof(", csType, ")"];
+            this.emitCanConvert(canConvertExpr);
+            this.ensureBlankLine();
+            this.emitReadJson(() => {
+                // FIXME: It's unsatisfying that we need this.  The reason is that we not
+                // only match T, but also T?.  If we didn't, then the T in T? would not be
+                // deserialized with our converter but with the default one.  Can we check
+                // whether the type is a nullable?
+                // FIXME: This could duplicate one of the cases handled below in
+                // `emitDecodeTransformer`.
+                // if (haveNullable && !(targetType instanceof UnionType)) {
+                //     this.emitLine("if (reader.TokenType == JsonTokenType.Null) return null;");
+                // }
+                const allHandled = this.emitDecodeTransformer(xfer, targetType, v => this.emitLine("return ", v, ";"));
+                if (!allHandled) {
+                    this.emitThrow(['"Cannot unmarshal type ', csType, '"']);
+                }
+            }, csType);
+            this.ensureBlankLine();
+            this.emitWriteJson("value", () => {
+                // FIXME: See above.
+                // if (haveNullable && !(targetType instanceof UnionType)) {
+                //     this.emitLine("if (value == null)");
+                //     this.emitBlock(() => {
+                //         this.emitLine("writer.WriteNullValue();");
+                //         this.emitLine("return;");
+                //     });
+                // }
+                const allHandled = this.emitTransformer("value", reverse.transformer, reverse.targetType, () => this.emitLine("return;"));
+                if (!allHandled) {
+                    this.emitThrow(['"Cannot marshal type ', csType, '"']);
+                }
+            }, csType);
+            this.ensureBlankLine();
+            this.emitLine("public static readonly ", converterName, " Singleton = new ", converterName, "();");
+        });
+    }
+    emitRequiredHelpers() {
+        if (this._needHelpers) {
+            this.forEachTopLevel("leading-and-interposing", (t, n) => this.emitFromJsonForTopLevel(t, n));
+            this.ensureBlankLine();
+            this.emitSerializeClass();
+        }
+        if (this._needHelpers || (this._needAttributes && (this.haveNamedUnions || this.haveEnums))) {
+            this.ensureBlankLine();
+            this.emitConverterClass();
+            this.forEachTransformation("leading-and-interposing", (n, t) => this.emitTransformation(n, t));
+            this.emitMultiline(`
+public class DateOnlyConverter : JsonConverter<DateOnly>
+{
+    private readonly string serializationFormat;
+    public DateOnlyConverter() : this(null) { }
+
+    public DateOnlyConverter(string? serializationFormat)
+    {
+        this.serializationFormat = serializationFormat ?? "yyyy-MM-dd";
+    }
+
+    public override DateOnly Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        var value = reader.GetString();
+        return DateOnly.Parse(value!);
+    }
+
+    public override void Write(Utf8JsonWriter writer, DateOnly value, JsonSerializerOptions options)
+        => writer.WriteStringValue(value.ToString(serializationFormat));
+}
+
+public class TimeOnlyConverter : JsonConverter<TimeOnly>
+{
+    private readonly string serializationFormat;
+
+    public TimeOnlyConverter() : this(null) { }
+
+    public TimeOnlyConverter(string? serializationFormat)
+    {
+        this.serializationFormat = serializationFormat ?? "HH:mm:ss.fff";
+    }
+
+    public override TimeOnly Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        var value = reader.GetString();
+        return TimeOnly.Parse(value!);
+    }
+
+    public override void Write(Utf8JsonWriter writer, TimeOnly value, JsonSerializerOptions options)
+        => writer.WriteStringValue(value.ToString(serializationFormat));
+}
+
+internal class IsoDateTimeOffsetConverter : JsonConverter<DateTimeOffset>
+{
+    public override bool CanConvert(Type t) => t == typeof(DateTimeOffset);
+
+    private const string DefaultDateTimeFormat = "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK";
+
+    private DateTimeStyles _dateTimeStyles = DateTimeStyles.RoundtripKind;
+    private string? _dateTimeFormat;
+    private CultureInfo? _culture;
+
+    public DateTimeStyles DateTimeStyles
+    {
+        get => _dateTimeStyles;
+        set => _dateTimeStyles = value;
+    }
+
+    public string? DateTimeFormat
+    {
+        get => _dateTimeFormat ?? string.Empty;
+        set => _dateTimeFormat = (string.IsNullOrEmpty(value)) ? null : value;
+    }
+
+    public CultureInfo Culture
+    {
+        get => _culture ?? CultureInfo.CurrentCulture;
+        set => _culture = value;
+    }
+
+    public override void Write(Utf8JsonWriter writer, DateTimeOffset value, JsonSerializerOptions options)
+    {
+        string text;
+
+
+        if ((_dateTimeStyles & DateTimeStyles.AdjustToUniversal) == DateTimeStyles.AdjustToUniversal
+            || (_dateTimeStyles & DateTimeStyles.AssumeUniversal) == DateTimeStyles.AssumeUniversal)
+        {
+            value = value.ToUniversalTime();
+        }
+
+        text = value.ToString(_dateTimeFormat ?? DefaultDateTimeFormat, Culture);
+
+        writer.WriteStringValue(text);
+    }
+
+    public override DateTimeOffset Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        string? dateText = reader.GetString();
+        
+        if (string.IsNullOrEmpty(dateText) == false)
+        {
+            if (!string.IsNullOrEmpty(_dateTimeFormat))
+            {
+                return DateTimeOffset.ParseExact(dateText, _dateTimeFormat, Culture, _dateTimeStyles);
+            }
+            else
+            {
+                return DateTimeOffset.Parse(dateText, Culture, _dateTimeStyles);
+            }
+        }
+        else
+        {
+            return default(DateTimeOffset);
+        }
+    }
+
+
+    public static readonly IsoDateTimeOffsetConverter Singleton = new IsoDateTimeOffsetConverter();
+}`);
+        }
+    }
+    needNamespace() {
+        return this._needNamespaces;
+    }
+}
+exports.SystemTextJsonCSharpRenderer = SystemTextJsonCSharpRenderer;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "quicktype-core",
-    "version": "6.1.12",
+    "version": "7.0.0",
     "description": "The quicktype engine as a library",
     "license": "Apache-2.0",
     "main": "dist/index.js",
@@ -45,6 +45,6 @@
         "fs": false
     },
     "config": {
-        "commit": "7d5b0ce40ada9c206b0808709a6f219051424d98"
+        "commit": "3118cbe3f215406f704558a1e5e07e5160b5fcff"
     }
 }