quicktype-core 23.0.7 → 23.0.9

package/dist/index.d.ts

@@ -39,6 +39,8 @@ export { JavaScriptPropTypesTargetLanguage, JavaScriptPropTypesRenderer, javaScr
 export { TypeScriptTargetLanguage, TypeScriptRenderer, FlowTargetLanguage, FlowRenderer, tsFlowOptions } from "./language/TypeScriptFlow";
 export { SwiftTargetLanguage, SwiftRenderer, swiftOptions } from "./language/Swift";
 export { KotlinTargetLanguage, KotlinRenderer, kotlinOptions } from "./language/Kotlin";
+export { Scala3TargetLanguage, Scala3Renderer, scala3Options } from "./language/Scala3";
+export { SmithyTargetLanguage, Smithy4sRenderer, SmithyOptions } from "./language/Smithy4s";
 export { ElmTargetLanguage, ElmRenderer, elmOptions } from "./language/Elm";
 export { JSONSchemaTargetLanguage, JSONSchemaRenderer } from "./language/JSONSchema";
 export { RustTargetLanguage, RustRenderer, rustOptions } from "./language/Rust";

package/dist/index.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClassType = exports.ArrayType = exports.PrimitiveType = exports.Type = exports.messageAssert = exports.messageError = exports.QuickTypeError = exports.trainMarkovChain = exports.isLetterOrDigit = exports.legalizeCharacters = exports.allUpperWordStyle = exports.firstUpperWordStyle = exports.combineWords = exports.capitalize = exports.splitIntoWords = exports.inflateBase64 = exports.checkArray = exports.checkStringMap = exports.parseJSON = exports.assertNever = exports.defined = exports.assert = exports.panic = exports.IssueAnnotationData = exports.Namer = exports.funPrefixNamer = exports.Name = exports.parenIfNeeded = exports.singleWord = exports.modifySource = exports.languageNamed = exports.defaultTargetLanguages = exports.TargetLanguage = exports.getOptionValues = exports.Option = exports.Ref = exports.JSONSchemaInput = exports.jsonInputForTargetLanguage = exports.JSONInput = exports.InputData = exports.CompressedJSON = exports.inferenceFlagsObject = exports.defaultInferenceFlags = exports.inferenceFlagNames = exports.inferenceFlags = exports.combineRenderResults = exports.quicktype = exports.quicktypeMultiFileSync = exports.quicktypeMultiFile = exports.getTargetLanguage = void 0;
 exports.TypeScriptRenderer = exports.TypeScriptTargetLanguage = exports.javaScriptPropTypesOptions = exports.JavaScriptPropTypesRenderer = exports.JavaScriptPropTypesTargetLanguage = exports.javaScriptOptions = exports.JavaScriptRenderer = exports.JavaScriptTargetLanguage = exports.javaOptions = exports.JavaRenderer = exports.JavaTargetLanguage = exports.objcOptions = exports.ObjectiveCRenderer = exports.ObjectiveCTargetLanguage = exports.goOptions = exports.GoRenderer = exports.GoTargetLanguage = exports.pythonOptions = exports.PythonRenderer = exports.PythonTargetLanguage = exports.CSharpRenderer = exports.cSharpOptions = exports.CSharpTargetLanguage = exports.cPlusPlusOptions = exports.CPlusPlusRenderer = exports.CPlusPlusTargetLanguage = exports.uriTypeAttributeKind = exports.ConvenienceRenderer = exports.nullableFromUnion = exports.matchType = exports.removeNullFromUnion = exports.StringTypes = exports.namesTypeAttributeKind = exports.makeNamesTypeAttributes = exports.TypeNames = exports.emptyTypeAttributes = exports.TypeAttributeKind = exports.derefTypeRef = exports.TypeBuilder = exports.sourcesFromPostmanCollection = exports.JSONSchemaStore = exports.FetchingJSONSchemaStore = exports.readFromFileOrURL = exports.readableFromFileOrURL = exports.getStream = exports.ObjectType = exports.UnionType = exports.MapType = exports.EnumType = exports.ClassProperty = void 0;
-exports.dartOptions = exports.DartRenderer = exports.DartTargetLanguage = exports.haskellOptions = exports.HaskellRenderer = exports.HaskellTargetLanguage = exports.CrystalRenderer = exports.CrystalTargetLanguage = exports.rubyOptions = exports.RubyRenderer = exports.RubyTargetLanguage = exports.rustOptions = exports.RustRenderer = exports.RustTargetLanguage = exports.JSONSchemaRenderer = exports.JSONSchemaTargetLanguage = exports.elmOptions = exports.ElmRenderer = exports.ElmTargetLanguage = exports.kotlinOptions = exports.KotlinRenderer = exports.KotlinTargetLanguage = exports.swiftOptions = exports.SwiftRenderer = exports.SwiftTargetLanguage = exports.tsFlowOptions = exports.FlowRenderer = exports.FlowTargetLanguage = void 0;
+exports.dartOptions = exports.DartRenderer = exports.DartTargetLanguage = exports.haskellOptions = exports.HaskellRenderer = exports.HaskellTargetLanguage = exports.CrystalRenderer = exports.CrystalTargetLanguage = exports.rubyOptions = exports.RubyRenderer = exports.RubyTargetLanguage = exports.rustOptions = exports.RustRenderer = exports.RustTargetLanguage = exports.JSONSchemaRenderer = exports.JSONSchemaTargetLanguage = exports.elmOptions = exports.ElmRenderer = exports.ElmTargetLanguage = exports.SmithyOptions = exports.Smithy4sRenderer = exports.SmithyTargetLanguage = exports.scala3Options = exports.Scala3Renderer = exports.Scala3TargetLanguage = exports.kotlinOptions = exports.KotlinRenderer = exports.KotlinTargetLanguage = exports.swiftOptions = exports.SwiftRenderer = exports.SwiftTargetLanguage = exports.tsFlowOptions = exports.FlowRenderer = exports.FlowTargetLanguage = void 0;
 var Run_1 = require("./Run");
 Object.defineProperty(exports, "getTargetLanguage", { enumerable: true, get: function () { return Run_1.getTargetLanguage; } });
 Object.defineProperty(exports, "quicktypeMultiFile", { enumerable: true, get: function () { return Run_1.quicktypeMultiFile; } });
@@ -152,6 +152,14 @@ var Kotlin_1 = require("./language/Kotlin");
 Object.defineProperty(exports, "KotlinTargetLanguage", { enumerable: true, get: function () { return Kotlin_1.KotlinTargetLanguage; } });
 Object.defineProperty(exports, "KotlinRenderer", { enumerable: true, get: function () { return Kotlin_1.KotlinRenderer; } });
 Object.defineProperty(exports, "kotlinOptions", { enumerable: true, get: function () { return Kotlin_1.kotlinOptions; } });
+var Scala3_1 = require("./language/Scala3");
+Object.defineProperty(exports, "Scala3TargetLanguage", { enumerable: true, get: function () { return Scala3_1.Scala3TargetLanguage; } });
+Object.defineProperty(exports, "Scala3Renderer", { enumerable: true, get: function () { return Scala3_1.Scala3Renderer; } });
+Object.defineProperty(exports, "scala3Options", { enumerable: true, get: function () { return Scala3_1.scala3Options; } });
+var Smithy4s_1 = require("./language/Smithy4s");
+Object.defineProperty(exports, "SmithyTargetLanguage", { enumerable: true, get: function () { return Smithy4s_1.SmithyTargetLanguage; } });
+Object.defineProperty(exports, "Smithy4sRenderer", { enumerable: true, get: function () { return Smithy4s_1.Smithy4sRenderer; } });
+Object.defineProperty(exports, "SmithyOptions", { enumerable: true, get: function () { return Smithy4s_1.SmithyOptions; } });
 var Elm_1 = require("./language/Elm");
 Object.defineProperty(exports, "ElmTargetLanguage", { enumerable: true, get: function () { return Elm_1.ElmTargetLanguage; } });
 Object.defineProperty(exports, "ElmRenderer", { enumerable: true, get: function () { return Elm_1.ElmRenderer; } });

package/dist/language/All.js

@@ -12,6 +12,8 @@ const JavaScriptPropTypes_1 = require("./JavaScriptPropTypes");
 const TypeScriptFlow_1 = require("./TypeScriptFlow");
 const Swift_1 = require("./Swift");
 const Kotlin_1 = require("./Kotlin");
+const Scala3_1 = require("./Scala3");
+const Smithy4s_1 = require("./Smithy4s");
 const Elm_1 = require("./Elm");
 const JSONSchema_1 = require("./JSONSchema");
 const Rust_1 = require("./Rust");
@@ -35,6 +37,8 @@ exports.all = [
     new JavaScriptPropTypes_1.JavaScriptPropTypesTargetLanguage(),
     new TypeScriptFlow_1.FlowTargetLanguage(),
     new Swift_1.SwiftTargetLanguage(),
+    new Scala3_1.Scala3TargetLanguage(),
+    new Smithy4s_1.SmithyTargetLanguage(),
     new Kotlin_1.KotlinTargetLanguage(),
     new Elm_1.ElmTargetLanguage(),
     new JSONSchema_1.JSONSchemaTargetLanguage(),

package/dist/language/CPlusPlus.js

@@ -1654,7 +1654,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             optionalMacroName += "_";
         });
         untypedMacroName += "HELPER";
-        untypedMacroName += "HELPER";
+        optionalMacroName += "HELPER";
         this.emitLine("#ifndef " + untypedMacroName);
         this.emitLine("#define " + untypedMacroName);
         this.emitBlock(["inline json get_untyped(", this.withConst("json"), " & j, ", this.withConst("char"), " * property)"], false, () => {

package/dist/language/Scala3.d.ts

@@ -0,0 +1,77 @@
+import { ConvenienceRenderer, ForbiddenWordsInfo } from "../ConvenienceRenderer";
+import { Name, Namer } from "../Naming";
+import { EnumOption, Option, StringOption, OptionValues } from "../RendererOptions";
+import { Sourcelike } from "../Source";
+import { TargetLanguage } from "../TargetLanguage";
+import { ArrayType, ClassType, EnumType, MapType, ObjectType, Type, UnionType } from "../Type";
+import { RenderContext } from "../Renderer";
+export declare enum Framework {
+    None = 0,
+    Upickle = 1,
+    Circe = 2
+}
+export declare const scala3Options: {
+    framework: EnumOption<Framework>;
+    packageName: StringOption;
+};
+export declare class Scala3Renderer extends ConvenienceRenderer {
+    protected readonly _scalaOptions: OptionValues<typeof scala3Options>;
+    constructor(targetLanguage: TargetLanguage, renderContext: RenderContext, _scalaOptions: OptionValues<typeof scala3Options>);
+    protected forbiddenNamesForGlobalNamespace(): string[];
+    protected forbiddenForObjectProperties(_: ObjectType, _classNamed: Name): ForbiddenWordsInfo;
+    protected forbiddenForEnumCases(_: EnumType, _enumName: Name): ForbiddenWordsInfo;
+    protected forbiddenForUnionMembers(_u: UnionType, _unionName: Name): ForbiddenWordsInfo;
+    protected topLevelNameStyle(rawName: string): string;
+    protected makeNamedTypeNamer(): Namer;
+    protected namerForObjectProperty(): Namer;
+    protected makeUnionMemberNamer(): Namer;
+    protected makeEnumCaseNamer(): Namer;
+    protected emitDescriptionBlock(lines: Sourcelike[]): void;
+    protected emitBlock(line: Sourcelike, f: () => void, delimiter?: "curly" | "paren" | "lambda" | "none"): void;
+    protected anySourceType(optional: boolean): Sourcelike;
+    protected arrayType(arrayType: ArrayType, withIssues?: boolean): Sourcelike;
+    protected mapType(mapType: MapType, withIssues?: boolean): Sourcelike;
+    protected scalaType(t: Type, withIssues?: boolean, noOptional?: boolean): Sourcelike;
+    protected emitUsageHeader(): void;
+    protected emitHeader(): void;
+    protected emitTopLevelArray(t: ArrayType, name: Name): void;
+    protected emitTopLevelMap(t: MapType, name: Name): void;
+    protected emitEmptyClassDefinition(c: ClassType, className: Name): void;
+    protected emitClassDefinition(c: ClassType, className: Name): void;
+    protected emitClassDefinitionMethods(): void;
+    protected emitEnumDefinition(e: EnumType, enumName: Name): void;
+    protected emitUnionDefinition(u: UnionType, unionName: Name): void;
+    protected emitSourceStructure(): void;
+}
+export declare class UpickleRenderer extends Scala3Renderer {
+    protected emitClassDefinitionMethods(): void;
+    protected emitHeader(): void;
+}
+export declare class Smithy4sRenderer extends Scala3Renderer {
+    protected emitHeader(): void;
+    protected emitTopLevelArray(t: ArrayType, name: Name): void;
+    protected emitTopLevelMap(t: MapType, name: Name): void;
+    protected emitEmptyClassDefinition(c: ClassType, className: Name): void;
+    protected emitEnumDefinition(e: EnumType, enumName: Name): void;
+}
+export declare class CirceRenderer extends Scala3Renderer {
+    seenUnionTypes: Array<string>;
+    protected circeEncoderForType(t: Type, _?: boolean, noOptional?: boolean, paramName?: string): Sourcelike;
+    protected emitEmptyClassDefinition(c: ClassType, className: Name): void;
+    protected anySourceType(optional: boolean): Sourcelike;
+    protected emitClassDefinitionMethods(): void;
+    protected emitEnumDefinition(e: EnumType, enumName: Name): void;
+    protected emitHeader(): void;
+    protected emitTopLevelArray(t: ArrayType, name: Name): void;
+    protected emitTopLevelMap(t: MapType, name: Name): void;
+    protected emitUnionDefinition(u: UnionType, unionName: Name): void;
+}
+export declare class Scala3TargetLanguage extends TargetLanguage {
+    constructor();
+    protected getOptions(): Option<any>[];
+    get supportsOptionalClassProperties(): boolean;
+    get supportsUnionsWithBothNumberTypes(): boolean;
+    protected makeRenderer(renderContext: RenderContext, untypedOptionValues: {
+        [name: string]: any;
+    }): ConvenienceRenderer;
+}

package/dist/language/Scala3.js

@@ -0,0 +1,586 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scala3TargetLanguage = exports.CirceRenderer = exports.Smithy4sRenderer = exports.UpickleRenderer = exports.Scala3Renderer = exports.scala3Options = exports.Framework = void 0;
+const Annotation_1 = require("../Annotation");
+const ConvenienceRenderer_1 = require("../ConvenienceRenderer");
+const Naming_1 = require("../Naming");
+const RendererOptions_1 = require("../RendererOptions");
+const Source_1 = require("../Source");
+const Strings_1 = require("../support/Strings");
+const Support_1 = require("../support/Support");
+const TargetLanguage_1 = require("../TargetLanguage");
+const Type_1 = require("../Type");
+const TypeUtils_1 = require("../TypeUtils");
+var Framework;
+(function (Framework) {
+    Framework[Framework["None"] = 0] = "None";
+    Framework[Framework["Upickle"] = 1] = "Upickle";
+    Framework[Framework["Circe"] = 2] = "Circe";
+})(Framework = exports.Framework || (exports.Framework = {}));
+exports.scala3Options = {
+    framework: new RendererOptions_1.EnumOption("framework", "Serialization framework", [
+        ["just-types", Framework.None],
+        ["circe", Framework.Circe],
+        ["upickle", Framework.Upickle],
+    ], undefined),
+    packageName: new RendererOptions_1.StringOption("package", "Package", "PACKAGE", "quicktype")
+};
+// Use backticks for param names with symbols
+const invalidSymbols = [
+    ":",
+    "-",
+    "+",
+    "!",
+    "@",
+    "#",
+    "$",
+    "%",
+    "^",
+    "&",
+    "*",
+    "(",
+    ")",
+    ">",
+    "<",
+    "/",
+    ";",
+    "'",
+    '"',
+    "{",
+    "}",
+    ":",
+    "~",
+    "`",
+    "."
+];
+const keywords = [
+    "abstract",
+    "case",
+    "catch",
+    "class",
+    "def",
+    "do",
+    "else",
+    "enum",
+    "extends",
+    "export",
+    "false",
+    "final",
+    "finally",
+    "for",
+    "forSome",
+    "if",
+    "implicit",
+    "import",
+    "lazy",
+    "match",
+    "new",
+    "null",
+    "object",
+    "override",
+    "package",
+    "private",
+    "protected",
+    "return",
+    "sealed",
+    "super",
+    "this",
+    "then",
+    "throw",
+    "trait",
+    "try",
+    "true",
+    "type",
+    "val",
+    "var",
+    "while",
+    "with",
+    "yield",
+    "Any",
+    "Boolean",
+    "Double",
+    "Float",
+    "Long",
+    "Int",
+    "Short",
+    "System",
+    "Byte",
+    "String",
+    "Array",
+    "List",
+    "Map",
+    "Enum"
+];
+/**
+ * Check if given parameter name should be wrapped in a backtick
+ * @param paramName
+ */
+const shouldAddBacktick = (paramName) => {
+    return keywords.some(s => paramName === s) || invalidSymbols.some(s => paramName.includes(s)) || !isNaN(+parseFloat(paramName)) || !isNaN(parseInt(paramName.charAt(0)));
+};
+const wrapOption = (s, optional) => {
+    if (optional) {
+        return "Option[" + s + "]";
+    }
+    else {
+        return s;
+    }
+};
+function isPartCharacter(codePoint) {
+    return (0, Strings_1.isLetterOrUnderscore)(codePoint) || (0, Strings_1.isNumeric)(codePoint);
+}
+function isStartCharacter(codePoint) {
+    return isPartCharacter(codePoint) && !(0, Strings_1.isDigit)(codePoint);
+}
+const legalizeName = (0, Strings_1.legalizeCharacters)(isPartCharacter);
+function scalaNameStyle(isUpper, original) {
+    const words = (0, Strings_1.splitIntoWords)(original);
+    return (0, Strings_1.combineWords)(words, legalizeName, isUpper ? Strings_1.firstUpperWordStyle : Strings_1.allLowerWordStyle, Strings_1.firstUpperWordStyle, isUpper ? Strings_1.allUpperWordStyle : Strings_1.allLowerWordStyle, Strings_1.allUpperWordStyle, "", isStartCharacter);
+}
+/* function unicodeEscape(codePoint: number): string {
+    return "\\u" + intToHex(codePoint, 4);
+} */
+//const _stringEscape = utf32ConcatMap(escapeNonPrintableMapper(isPrintable, unicodeEscape));
+/* function stringEscape(s: string): string {
+    // "$this" is a template string in Kotlin so we have to escape $
+    return _stringEscape(s).replace(/\$/g, "\\$");
+} */
+const upperNamingFunction = (0, Naming_1.funPrefixNamer)("upper", s => scalaNameStyle(true, s));
+const lowerNamingFunction = (0, Naming_1.funPrefixNamer)("lower", s => scalaNameStyle(false, s));
+class Scala3Renderer extends ConvenienceRenderer_1.ConvenienceRenderer {
+    constructor(targetLanguage, renderContext, _scalaOptions) {
+        super(targetLanguage, renderContext);
+        this._scalaOptions = _scalaOptions;
+    }
+    forbiddenNamesForGlobalNamespace() {
+        return keywords;
+    }
+    forbiddenForObjectProperties(_, _classNamed) {
+        return { names: [], includeGlobalForbidden: true };
+    }
+    forbiddenForEnumCases(_, _enumName) {
+        return { names: [], includeGlobalForbidden: true };
+    }
+    forbiddenForUnionMembers(_u, _unionName) {
+        return { names: [], includeGlobalForbidden: false };
+    }
+    topLevelNameStyle(rawName) {
+        return scalaNameStyle(true, rawName);
+    }
+    makeNamedTypeNamer() {
+        return upperNamingFunction;
+    }
+    namerForObjectProperty() {
+        return lowerNamingFunction;
+    }
+    makeUnionMemberNamer() {
+        return (0, Naming_1.funPrefixNamer)("upper", s => scalaNameStyle(true, s) + "Value");
+    }
+    makeEnumCaseNamer() {
+        return (0, Naming_1.funPrefixNamer)("upper", s => s.replace(" ", "")); // TODO - add backticks where appropriate
+    }
+    emitDescriptionBlock(lines) {
+        this.emitCommentLines(lines, " * ", "/**", " */");
+    }
+    emitBlock(line, f, delimiter = "curly") {
+        const [open, close] = delimiter === "curly"
+            ? ["{", "}"]
+            : delimiter === "paren"
+                ? ["(", ")"]
+                : delimiter === "none"
+                    ? ["", ""]
+                    : ["{", "})"];
+        this.emitLine(line, " ", open);
+        this.indent(f);
+        this.emitLine(close);
+    }
+    anySourceType(optional) {
+        return [wrapOption("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) {
+        return ["Seq[", this.scalaType(arrayType.items, withIssues), "]"];
+    }
+    mapType(mapType, withIssues = false) {
+        return ["Map[String, ", this.scalaType(mapType.values, withIssues), "]"];
+    }
+    scalaType(t, withIssues = false, noOptional = false) {
+        return (0, TypeUtils_1.matchType)(t, _anyType => {
+            return (0, Source_1.maybeAnnotated)(withIssues, Annotation_1.anyTypeIssueAnnotation, this.anySourceType(!noOptional));
+        }, _nullType => {
+            //return "None.type"
+            return (0, Source_1.maybeAnnotated)(withIssues, Annotation_1.nullTypeIssueAnnotation, this.anySourceType(!noOptional));
+        }, _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 = (0, TypeUtils_1.nullableFromUnion)(unionType);
+            if (nullable !== null) {
+                if (noOptional) {
+                    return [this.scalaType(nullable, withIssues)];
+                }
+                else {
+                    return ["Option[", this.scalaType(nullable, withIssues), "]"];
+                }
+            }
+            return this.nameForNamedType(unionType);
+        });
+    }
+    emitUsageHeader() {
+        // To be overridden
+    }
+    emitHeader() {
+        if (this.leadingComments !== undefined) {
+            this.emitCommentLines(this.leadingComments);
+        }
+        else {
+            this.emitUsageHeader();
+        }
+        this.ensureBlankLine();
+        this.emitLine("package ", this._scalaOptions.packageName);
+        this.ensureBlankLine();
+    }
+    emitTopLevelArray(t, name) {
+        const elementType = this.scalaType(t.items);
+        this.emitLine(["type ", name, " = List[", elementType, "]"]);
+    }
+    emitTopLevelMap(t, name) {
+        const elementType = this.scalaType(t.values);
+        this.emitLine(["type ", name, " = Map[String, ", elementType, "]"]);
+    }
+    emitEmptyClassDefinition(c, className) {
+        this.emitDescription(this.descriptionForType(c));
+        this.emitLine("case class ", className, "()");
+    }
+    emitClassDefinition(c, className) {
+        if (c.getProperties().size === 0) {
+            this.emitEmptyClassDefinition(c, className);
+            return;
+        }
+        const scalaType = (p) => {
+            if (p.isOptional) {
+                return ["Option[", this.scalaType(p.type, true, true), "]"];
+            }
+            else {
+                return this.scalaType(p.type, true);
+            }
+        };
+        this.emitDescription(this.descriptionForType(c));
+        this.emitLine("case class ", className, " (");
+        this.indent(() => {
+            let count = c.getProperties().size;
+            let first = true;
+            this.forEachClassProperty(c, "none", (_, jsonName, p) => {
+                const nullable = p.type.kind === "union" && (0, TypeUtils_1.nullableFromUnion)(p.type) !== null;
+                const nullableOrOptional = p.isOptional || p.type.kind === "null" || nullable;
+                const last = --count === 0;
+                const meta = [];
+                const description = this.descriptionForClassProperty(c, jsonName);
+                if (description !== undefined) {
+                    meta.push(() => this.emitDescription(description));
+                }
+                if (meta.length > 0 && !first) {
+                    this.ensureBlankLine();
+                }
+                for (const emit of meta) {
+                    emit();
+                }
+                const nameNeedsBackticks = jsonName.endsWith("_") || shouldAddBacktick(jsonName);
+                const nameWithBackticks = nameNeedsBackticks ? "`" + jsonName + "`" : jsonName;
+                this.emitLine("val ", nameWithBackticks, " : ", scalaType(p), p.isOptional ? " = None" : nullableOrOptional ? " = None" : "", last ? "" : ",");
+                if (meta.length > 0 && !last) {
+                    this.ensureBlankLine();
+                }
+                first = false;
+            });
+        });
+        this.emitClassDefinitionMethods();
+    }
+    emitClassDefinitionMethods() {
+        this.emitLine(")");
+    }
+    emitEnumDefinition(e, enumName) {
+        this.emitDescription(this.descriptionForType(e));
+        this.emitBlock(["enum ", enumName, " : "], () => {
+            let count = e.cases.size;
+            if (count > 0) {
+                this.emitItem("\t case ");
+            }
+            ;
+            this.forEachEnumCase(e, "none", (name, jsonName) => {
+                if (!(jsonName == "")) {
+                    const backticks = shouldAddBacktick(jsonName) ||
+                        jsonName.includes(" ") ||
+                        !isNaN(parseInt(jsonName.charAt(0)));
+                    if (backticks) {
+                        this.emitItem("`");
+                    }
+                    this.emitItemOnce([name]);
+                    if (backticks) {
+                        this.emitItem("`");
+                    }
+                    if (--count > 0)
+                        this.emitItem([","]);
+                }
+                else {
+                    --count;
+                }
+            });
+        }, "none");
+    }
+    emitUnionDefinition(u, unionName) {
+        function sortBy(t) {
+            const kind = t.kind;
+            if (kind === "class")
+                return kind;
+            return "_" + kind;
+        }
+        this.emitDescription(this.descriptionForType(u));
+        const [maybeNull, nonNulls] = (0, TypeUtils_1.removeNullFromUnion)(u, sortBy);
+        const theTypes = [];
+        this.forEachUnionMember(u, nonNulls, "none", null, (_, t) => {
+            theTypes.push(this.scalaType(t));
+        });
+        if (maybeNull !== null) {
+            theTypes.push(this.nameForUnionMember(u, maybeNull));
+        }
+        this.emitItem(["type ", unionName, " = "]);
+        theTypes.forEach((t, i) => {
+            this.emitItem(i === 0 ? t : [" | ", t]);
+        });
+        this.ensureBlankLine();
+    }
+    emitSourceStructure() {
+        this.emitHeader();
+        // Top-level arrays, maps
+        this.forEachTopLevel("leading", (t, name) => {
+            if (t instanceof Type_1.ArrayType) {
+                this.emitTopLevelArray(t, name);
+            }
+            else if (t instanceof Type_1.MapType) {
+                this.emitTopLevelMap(t, name);
+            }
+        });
+        this.forEachNamedType("leading-and-interposing", (c, n) => this.emitClassDefinition(c, n), (e, n) => this.emitEnumDefinition(e, n), (u, n) => this.emitUnionDefinition(u, n));
+    }
+}
+exports.Scala3Renderer = Scala3Renderer;
+class UpickleRenderer extends Scala3Renderer {
+    emitClassDefinitionMethods() {
+        this.emitLine(") derives ReadWriter ");
+    }
+    emitHeader() {
+        super.emitHeader();
+        this.emitLine("import upickle.default.*");
+        this.ensureBlankLine();
+    }
+}
+exports.UpickleRenderer = UpickleRenderer;
+class Smithy4sRenderer extends Scala3Renderer {
+    emitHeader() {
+        if (this.leadingComments !== undefined) {
+            this.emitCommentLines(this.leadingComments);
+        }
+        else {
+            this.emitUsageHeader();
+        }
+        this.ensureBlankLine();
+        this.emitLine("namespace ", this._scalaOptions.packageName);
+        this.ensureBlankLine();
+    }
+    emitTopLevelArray(t, name) {
+        const elementType = this.scalaType(t.items);
+        this.emitLine(["list ", name, " { member : ", elementType, "}"]);
+    }
+    emitTopLevelMap(t, name) {
+        const elementType = this.scalaType(t.values);
+        this.emitLine(["map ", name, " { map[ key : String , value : ", elementType, "}"]);
+    }
+    emitEmptyClassDefinition(c, className) {
+        this.emitDescription(this.descriptionForType(c));
+        this.emitLine("structure ", className, "{}");
+    }
+    emitEnumDefinition(e, enumName) {
+        this.emitDescription(this.descriptionForType(e));
+        this.ensureBlankLine();
+        this.emitItem(["enum ", enumName, " { "]);
+        let count = e.cases.size;
+        this.forEachEnumCase(e, "none", (name, jsonName) => {
+            // if (!(jsonName == "")) { 
+            /*                 const backticks =
+                                shouldAddBacktick(jsonName) ||
+                                jsonName.includes(" ") ||
+                                !isNaN(parseInt(jsonName.charAt(0)))
+                            if (backticks) {this.emitItem("`")} else  */
+            this.emitLine();
+            this.emitItem([name, " = \"", jsonName, "\""]);
+            //                if (backticks) {this.emitItem("`")}
+            if (--count > 0)
+                this.emitItem([","]);
+            //} else {
+            //--count
+            //} 
+        });
+        this.ensureBlankLine();
+        this.emitItem(["}"]);
+    }
+}
+exports.Smithy4sRenderer = Smithy4sRenderer;
+class CirceRenderer extends Scala3Renderer {
+    constructor() {
+        super(...arguments);
+        this.seenUnionTypes = [];
+    }
+    circeEncoderForType(t, _ = false, noOptional = false, paramName = "") {
+        return (0, TypeUtils_1.matchType)(t, _anyType => ["Encoder.encodeJson(", paramName, ")"], _nullType => ["Encoder.encodeNone(", paramName, ")"], _boolType => ["Encoder.encodeBoolean(", paramName, ")"], _integerType => ["Encoder.encodeLong(", paramName, ")"], _doubleType => ["Encoder.encodeDouble(", paramName, ")"], _stringType => ["Encoder.encodeString(", paramName, ")"], arrayType => ["Encoder.encodeSeq[", this.scalaType(arrayType.items), "].apply(", paramName, ")"], classType => ["Encoder.AsObject[", this.scalaType(classType), "].apply(", paramName, ")"], mapType => ["Encoder.encodeMap[String,", this.scalaType(mapType.values), "].apply(", paramName, ")"], _ => ["Encoder.encodeString(", paramName, ")"], unionType => {
+            const nullable = (0, TypeUtils_1.nullableFromUnion)(unionType);
+            if (nullable !== null) {
+                if (noOptional) {
+                    return ["Encoder.AsObject[", this.nameForNamedType(nullable), "]"];
+                }
+                else {
+                    return ["Encoder.AsObject[Option[", this.nameForNamedType(nullable), "]]"];
+                }
+            }
+            return ["Encoder.AsObject[", this.nameForNamedType(unionType), "]"];
+        });
+    }
+    emitEmptyClassDefinition(c, className) {
+        this.emitDescription(this.descriptionForType(c));
+        this.ensureBlankLine();
+        this.emitLine("case class ", className, "()  derives Encoder.AsObject, Decoder");
+    }
+    anySourceType(optional) {
+        return [wrapOption("Json", optional)];
+    }
+    emitClassDefinitionMethods() {
+        this.emitLine(") derives Encoder.AsObject, Decoder");
+    }
+    emitEnumDefinition(e, enumName) {
+        this.emitDescription(this.descriptionForType(e));
+        this.ensureBlankLine();
+        this.emitItem(["type ", enumName, " = "]);
+        let count = e.cases.size;
+        this.forEachEnumCase(e, "none", (_, jsonName) => {
+            // if (!(jsonName == "")) {
+            /*                 const backticks =
+                                shouldAddBacktick(jsonName) ||
+                                jsonName.includes(" ") ||
+                                !isNaN(parseInt(jsonName.charAt(0)))
+                            if (backticks) {this.emitItem("`")} else  */
+            this.emitItem(["\"", jsonName, "\""]);
+            //                if (backticks) {this.emitItem("`")}
+            if (--count > 0)
+                this.emitItem([" | "]);
+            //} else {
+            //--count
+            //} 
+        });
+        this.ensureBlankLine();
+    }
+    emitHeader() {
+        super.emitHeader();
+        this.emitLine("import scala.util.Try");
+        this.emitLine("import io.circe.syntax._");
+        this.emitLine("import io.circe._");
+        this.emitLine("import cats.syntax.functor._");
+        this.ensureBlankLine();
+        this.emitLine("// For serialising string unions");
+        this.emitLine("given [A <: Singleton](using A <:< String): Decoder[A] = Decoder.decodeString.emapTry(x => Try(x.asInstanceOf[A])) ");
+        this.emitLine("given [A <: Singleton](using ev: A <:< String): Encoder[A] = Encoder.encodeString.contramap(ev) ");
+        this.ensureBlankLine();
+        this.emitLine("// If a union has a null in, then we'll need this too... ");
+        this.emitLine("type NullValue = None.type");
+    }
+    emitTopLevelArray(t, name) {
+        super.emitTopLevelArray(t, name);
+        const elementType = this.scalaType(t.items);
+        this.emitLine(["given (using ev : ", elementType, "): Encoder[Map[String,", elementType, "]] = Encoder.encodeMap[String, ", elementType, "]"]);
+    }
+    emitTopLevelMap(t, name) {
+        super.emitTopLevelMap(t, name);
+        const elementType = this.scalaType(t.values);
+        this.ensureBlankLine();
+        this.emitLine(["given (using ev : ", elementType, "): Encoder[Map[String, ", elementType, "]] = Encoder.encodeMap[String, ", elementType, "]"]);
+    }
+    emitUnionDefinition(u, unionName) {
+        function sortBy(t) {
+            const kind = t.kind;
+            if (kind === "class")
+                return kind;
+            return "_" + kind;
+        }
+        this.emitDescription(this.descriptionForType(u));
+        const [maybeNull, nonNulls] = (0, TypeUtils_1.removeNullFromUnion)(u, sortBy);
+        const theTypes = [];
+        this.forEachUnionMember(u, nonNulls, "none", null, (_, t) => {
+            theTypes.push(this.scalaType(t));
+        });
+        if (maybeNull !== null) {
+            theTypes.push(this.nameForUnionMember(u, maybeNull));
+        }
+        this.emitItem(["type ", unionName, " = "]);
+        theTypes.forEach((t, i) => {
+            this.emitItem(i === 0 ? t : [" | ", t]);
+        });
+        const thisUnionType = theTypes.map(x => this.sourcelikeToString(x)).join(" | ");
+        this.ensureBlankLine();
+        if (!this.seenUnionTypes.some(y => y === thisUnionType)) {
+            this.seenUnionTypes.push(thisUnionType);
+            const sourceLikeTypes = [];
+            this.forEachUnionMember(u, nonNulls, "none", null, (_, t) => {
+                sourceLikeTypes.push([this.scalaType(t), t]);
+            });
+            if (maybeNull !== null) {
+                sourceLikeTypes.push([this.nameForUnionMember(u, maybeNull), maybeNull]);
+            }
+            this.emitLine(["given Decoder[", unionName, "] = {"]);
+            this.indent(() => {
+                this.emitLine(["List[Decoder[", unionName, "]]("]);
+                this.indent(() => {
+                    sourceLikeTypes.forEach((t) => {
+                        this.emitLine(["Decoder[", t[0], "].widen,"]);
+                    });
+                });
+                this.emitLine(").reduceLeft(_ or _)");
+            });
+            this.emitLine(["}"]);
+            this.ensureBlankLine();
+            this.emitLine(["given Encoder[", unionName, "] = Encoder.instance {"]);
+            this.indent(() => {
+                sourceLikeTypes.forEach((t, i) => {
+                    const paramTemp = `enc${i.toString()}`;
+                    this.emitLine(["case ", paramTemp, " : ", t[0], " => ", this.circeEncoderForType(t[1], false, false, paramTemp)]);
+                });
+            });
+            this.emitLine("}");
+        }
+    }
+}
+exports.CirceRenderer = CirceRenderer;
+class Scala3TargetLanguage extends TargetLanguage_1.TargetLanguage {
+    constructor() {
+        super("Scala3", ["scala3"], "scala");
+    }
+    getOptions() {
+        return [exports.scala3Options.framework, exports.scala3Options.packageName];
+    }
+    get supportsOptionalClassProperties() {
+        return true;
+    }
+    get supportsUnionsWithBothNumberTypes() {
+        return true;
+    }
+    makeRenderer(renderContext, untypedOptionValues) {
+        const options = (0, RendererOptions_1.getOptionValues)(exports.scala3Options, untypedOptionValues);
+        switch (options.framework) {
+            case Framework.None:
+                return new Scala3Renderer(this, renderContext, options);
+            case Framework.Upickle:
+                return new UpickleRenderer(this, renderContext, options);
+            case Framework.Circe:
+                return new CirceRenderer(this, renderContext, options);
+            default:
+                return (0, Support_1.assertNever)(options.framework);
+        }
+    }
+}
+exports.Scala3TargetLanguage = Scala3TargetLanguage;

package/dist/language/Smithy4s.d.ts

@@ -0,0 +1,53 @@
+import { ConvenienceRenderer, ForbiddenWordsInfo } from "../ConvenienceRenderer";
+import { Name, Namer } from "../Naming";
+import { EnumOption, Option, StringOption, OptionValues } from "../RendererOptions";
+import { Sourcelike } from "../Source";
+import { TargetLanguage } from "../TargetLanguage";
+import { ArrayType, ClassProperty, ClassType, EnumType, MapType, ObjectType, Type, UnionType } from "../Type";
+import { RenderContext } from "../Renderer";
+export declare enum Framework {
+    None = 0
+}
+export declare const SmithyOptions: {
+    framework: EnumOption<Framework>;
+    packageName: StringOption;
+};
+export declare class Smithy4sRenderer extends ConvenienceRenderer {
+    protected readonly _scalaOptions: OptionValues<typeof SmithyOptions>;
+    constructor(targetLanguage: TargetLanguage, renderContext: RenderContext, _scalaOptions: OptionValues<typeof SmithyOptions>);
+    protected forbiddenNamesForGlobalNamespace(): string[];
+    protected forbiddenForObjectProperties(_: ObjectType, _classNamed: Name): ForbiddenWordsInfo;
+    protected forbiddenForEnumCases(_: EnumType, _enumName: Name): ForbiddenWordsInfo;
+    protected forbiddenForUnionMembers(_u: UnionType, _unionName: Name): ForbiddenWordsInfo;
+    protected topLevelNameStyle(rawName: string): string;
+    protected makeNamedTypeNamer(): Namer;
+    protected namerForObjectProperty(): Namer;
+    protected makeUnionMemberNamer(): Namer;
+    protected makeEnumCaseNamer(): Namer;
+    protected emitDescriptionBlock(lines: Sourcelike[]): void;
+    protected emitBlock(line: Sourcelike, f: () => void, delimiter?: "curly" | "paren" | "lambda" | "none"): void;
+    protected anySourceType(_: boolean): Sourcelike;
+    protected arrayType(arrayType: ArrayType, _?: boolean): Sourcelike;
+    protected emitArrayType(_: ArrayType, smithyType: Sourcelike): void;
+    protected mapType(mapType: MapType, _?: boolean): Sourcelike;
+    protected scalaType(t: Type, withIssues?: boolean, noOptional?: boolean): Sourcelike;
+    protected emitUsageHeader(): void;
+    protected emitHeader(): void;
+    protected emitTopLevelArray(t: ArrayType, name: Name): void;
+    protected emitTopLevelMap(t: MapType, name: Name): void;
+    protected emitEmptyClassDefinition(c: ClassType, className: Name): void;
+    protected emitClassDefinition(c: ClassType, className: Name): void;
+    protected emitClassDefinitionMethods(arrayTypes: ClassProperty[]): void;
+    protected emitEnumDefinition(e: EnumType, enumName: Name): void;
+    protected emitUnionDefinition(u: UnionType, unionName: Name): void;
+    protected emitSourceStructure(): void;
+}
+export declare class SmithyTargetLanguage extends TargetLanguage {
+    constructor();
+    protected getOptions(): Option<any>[];
+    get supportsOptionalClassProperties(): boolean;
+    get supportsUnionsWithBothNumberTypes(): boolean;
+    protected makeRenderer(renderContext: RenderContext, untypedOptionValues: {
+        [name: string]: any;
+    }): ConvenienceRenderer;
+}

package/dist/language/Smithy4s.js

@@ -0,0 +1,390 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmithyTargetLanguage = exports.Smithy4sRenderer = exports.SmithyOptions = exports.Framework = void 0;
+const Annotation_1 = require("../Annotation");
+const ConvenienceRenderer_1 = require("../ConvenienceRenderer");
+const Naming_1 = require("../Naming");
+const RendererOptions_1 = require("../RendererOptions");
+const Source_1 = require("../Source");
+const Strings_1 = require("../support/Strings");
+const Support_1 = require("../support/Support");
+const TargetLanguage_1 = require("../TargetLanguage");
+const Type_1 = require("../Type");
+const TypeUtils_1 = require("../TypeUtils");
+var Framework;
+(function (Framework) {
+    Framework[Framework["None"] = 0] = "None";
+})(Framework = exports.Framework || (exports.Framework = {}));
+exports.SmithyOptions = {
+    framework: new RendererOptions_1.EnumOption("framework", "Serialization framework", [
+        ["just-types", Framework.None]
+    ], undefined),
+    packageName: new RendererOptions_1.StringOption("package", "Package", "PACKAGE", "quicktype")
+};
+// Use backticks for param names with symbols
+const invalidSymbols = [
+    ":",
+    "-",
+    "+",
+    "!",
+    "@",
+    "#",
+    "%",
+    "^",
+    "&",
+    "*",
+    "(",
+    ")",
+    ">",
+    "<",
+    "/",
+    ";",
+    "'",
+    '"',
+    "{",
+    "}",
+    ":",
+    "~",
+    "`",
+    "."
+];
+const keywords = [
+    "abstract",
+    "case",
+    "catch",
+    "do",
+    "else",
+    "export",
+    "false",
+    "final",
+    "finally",
+    "for",
+    "forSome",
+    "if",
+    "implicit",
+    "import",
+    "new",
+    "override",
+    "package",
+    "private",
+    "protected",
+    "return",
+    "sealed",
+    "super",
+    "this",
+    "then",
+    "throw",
+    "trait",
+    "try",
+    "true",
+    "val",
+    "var",
+    "while",
+    "with",
+    "yield",
+    "Any",
+    "Boolean",
+    "Double",
+    "Float",
+    "Long",
+    "Int",
+    "Short",
+    "System",
+    "Byte",
+    "String",
+    "Array",
+    "List",
+    "Map",
+    "Enum"
+];
+/**
+ * Check if given parameter name should be wrapped in a backtick
+ * @param paramName
+ */
+const shouldAddBacktick = (paramName) => {
+    return keywords.some(s => paramName === s) || invalidSymbols.some(s => paramName.includes(s)) || !isNaN(parseFloat(paramName)) || !isNaN(parseInt(paramName.charAt(0)));
+};
+function isPartCharacter(codePoint) {
+    return (0, Strings_1.isLetterOrUnderscore)(codePoint) || (0, Strings_1.isNumeric)(codePoint);
+}
+function isStartCharacter(codePoint) {
+    return isPartCharacter(codePoint) && !(0, Strings_1.isDigit)(codePoint);
+}
+const legalizeName = (0, Strings_1.legalizeCharacters)(isPartCharacter);
+function scalaNameStyle(isUpper, original) {
+    const words = (0, Strings_1.splitIntoWords)(original);
+    return (0, Strings_1.combineWords)(words, legalizeName, isUpper ? Strings_1.firstUpperWordStyle : Strings_1.allLowerWordStyle, Strings_1.firstUpperWordStyle, isUpper ? Strings_1.allUpperWordStyle : Strings_1.allLowerWordStyle, Strings_1.allUpperWordStyle, "", isStartCharacter);
+}
+const upperNamingFunction = (0, Naming_1.funPrefixNamer)("upper", s => scalaNameStyle(true, s));
+const lowerNamingFunction = (0, Naming_1.funPrefixNamer)("lower", s => scalaNameStyle(false, s));
+class Smithy4sRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
+    constructor(targetLanguage, renderContext, _scalaOptions) {
+        super(targetLanguage, renderContext);
+        this._scalaOptions = _scalaOptions;
+    }
+    forbiddenNamesForGlobalNamespace() {
+        return keywords;
+    }
+    forbiddenForObjectProperties(_, _classNamed) {
+        return { names: [], includeGlobalForbidden: true };
+    }
+    forbiddenForEnumCases(_, _enumName) {
+        return { names: [], includeGlobalForbidden: true };
+    }
+    forbiddenForUnionMembers(_u, _unionName) {
+        return { names: [], includeGlobalForbidden: false };
+    }
+    topLevelNameStyle(rawName) {
+        return scalaNameStyle(true, rawName);
+    }
+    makeNamedTypeNamer() {
+        return upperNamingFunction;
+    }
+    namerForObjectProperty() {
+        return lowerNamingFunction;
+    }
+    makeUnionMemberNamer() {
+        return (0, Naming_1.funPrefixNamer)("upper", s => scalaNameStyle(true, s) + "Value");
+    }
+    makeEnumCaseNamer() {
+        return (0, Naming_1.funPrefixNamer)("upper", s => s.replace(" ", "")); // TODO - add backticks where appropriate
+    }
+    emitDescriptionBlock(lines) {
+        this.emitCommentLines(lines, " * ", "/**", " */");
+    }
+    emitBlock(line, f, delimiter = "curly") {
+        const [open, close] = delimiter === "curly"
+            ? ["{", "}"]
+            : delimiter === "paren"
+                ? ["(", ")"]
+                : delimiter === "none"
+                    ? ["", ""]
+                    : ["{", "})"];
+        this.emitLine(line, " ", open);
+        this.indent(f);
+        this.emitLine(close);
+    }
+    anySourceType(_) {
+        return ["Document"];
+    }
+    // (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, _ = false) {
+        //this.emitTopLevelArray(arrayType, new Name(arrayType.getCombinedName().toString() + "List"))
+        return arrayType.getCombinedName().toString() + "List";
+    }
+    emitArrayType(_, smithyType) {
+        this.emitLine(["list ", smithyType, " { member : ", "}"]);
+    }
+    mapType(mapType, _ = false) {
+        return mapType.getCombinedName().toString() + "Map";
+        //return [this.scalaType(mapType.values, withIssues), "Map"];
+    }
+    scalaType(t, withIssues = false, noOptional = false) {
+        return (0, TypeUtils_1.matchType)(t, _anyType => {
+            return (0, Source_1.maybeAnnotated)(withIssues, Annotation_1.anyTypeIssueAnnotation, this.anySourceType(!noOptional));
+        }, _nullType => {
+            //return "None.type"
+            return (0, Source_1.maybeAnnotated)(withIssues, Annotation_1.nullTypeIssueAnnotation, this.anySourceType(!noOptional));
+        }, _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 = (0, TypeUtils_1.nullableFromUnion)(unionType);
+            if (nullable !== null) {
+                return [this.scalaType(nullable, withIssues)];
+            }
+            return this.nameForNamedType(unionType);
+        });
+    }
+    emitUsageHeader() {
+        // To be overridden
+    }
+    emitHeader() {
+        if (this.leadingComments !== undefined) {
+            this.emitCommentLines(this.leadingComments);
+        }
+        else {
+            this.emitUsageHeader();
+        }
+        this.ensureBlankLine();
+        this.emitLine("$version: \"2\"");
+        this.emitLine("namespace ", this._scalaOptions.packageName);
+        this.ensureBlankLine();
+        this.emitLine("document NullValue");
+        this.ensureBlankLine();
+    }
+    emitTopLevelArray(t, name) {
+        const elementType = this.scalaType(t.items);
+        this.emitLine(["list ", name, " { member : ", elementType, "}"]);
+    }
+    emitTopLevelMap(t, name) {
+        const elementType = this.scalaType(t.values);
+        this.emitLine(["map ", name, " { map[ key : String , value : ", elementType, "}"]);
+    }
+    emitEmptyClassDefinition(c, className) {
+        this.emitDescription(this.descriptionForType(c));
+        this.emitLine("structure ", className, "{}");
+    }
+    emitClassDefinition(c, className) {
+        if (c.getProperties().size === 0) {
+            this.emitEmptyClassDefinition(c, className);
+            return;
+        }
+        const scalaType = (p) => {
+            if (p.isOptional) {
+                return [this.scalaType(p.type, true, true)];
+            }
+            else {
+                return [this.scalaType(p.type, true)];
+            }
+        };
+        const emitLater = [];
+        this.emitDescription(this.descriptionForType(c));
+        this.emitLine("structure ", className, " {");
+        this.indent(() => {
+            let count = c.getProperties().size;
+            let first = true;
+            this.forEachClassProperty(c, "none", (_, jsonName, p) => {
+                const nullable = p.type.kind === "union" && (0, TypeUtils_1.nullableFromUnion)(p.type) !== null;
+                const nullableOrOptional = p.isOptional || p.type.kind === "null" || nullable;
+                const last = --count === 0;
+                const meta = [];
+                const laterType = p.type.kind === "array" || p.type.kind === "map";
+                if (laterType) {
+                    emitLater.push(p);
+                }
+                const description = this.descriptionForClassProperty(c, jsonName);
+                if (description !== undefined) {
+                    meta.push(() => this.emitDescription(description));
+                }
+                if (meta.length > 0 && !first) {
+                    this.ensureBlankLine();
+                }
+                for (const emit of meta) {
+                    emit();
+                }
+                const nameNeedsBackticks = jsonName.endsWith("_") || shouldAddBacktick(jsonName);
+                const nameWithBackticks = nameNeedsBackticks ? "`" + jsonName + "`" : jsonName;
+                this.emitLine(p.isOptional ? "" : nullableOrOptional ? "" : "@required ", nameWithBackticks, " : ", scalaType(p), last ? "" : ",");
+                if (meta.length > 0 && !last) {
+                    this.ensureBlankLine();
+                }
+                first = false;
+            });
+        });
+        this.emitClassDefinitionMethods(emitLater);
+    }
+    emitClassDefinitionMethods(arrayTypes) {
+        this.emitLine("}");
+        arrayTypes.forEach(p => {
+            function ignore(_) {
+                return;
+            }
+            (0, TypeUtils_1.matchCompoundType)(p.type, at => {
+                this.emitLine(["list ", this.scalaType(at, true), "{ member: ", this.scalaType(at.items, true), "}"]);
+            }, ignore, mt => {
+                this.emitLine(["map ", this.scalaType(mt, true), "{ key: String , value: ", this.scalaType(mt.values, true), "}"]);
+            }, ignore, ignore);
+        });
+    }
+    emitEnumDefinition(e, enumName) {
+        this.emitDescription(this.descriptionForType(e));
+        this.ensureBlankLine();
+        this.emitItem(["enum ", enumName, " { "]);
+        let count = e.cases.size;
+        this.forEachEnumCase(e, "none", (name, jsonName) => {
+            // if (!(jsonName == "")) { 
+            /*                 const backticks =
+                                shouldAddBacktick(jsonName) ||
+                                jsonName.includes(" ") ||
+                                !isNaN(parseInt(jsonName.charAt(0)))
+                            if (backticks) {this.emitItem("`")} else  */
+            this.emitLine();
+            this.emitItem([name, " = \"", jsonName, "\""]);
+            //                if (backticks) {this.emitItem("`")}
+            if (--count > 0)
+                this.emitItem([","]);
+            //} else {
+            //--count
+            //} 
+        });
+        this.ensureBlankLine();
+        this.emitItem(["}"]);
+    }
+    emitUnionDefinition(u, unionName) {
+        function sortBy(t) {
+            const kind = t.kind;
+            if (kind === "class")
+                return kind;
+            return "_" + kind;
+        }
+        const emitLater = [];
+        this.emitDescription(this.descriptionForType(u));
+        const [maybeNull, nonNulls] = (0, TypeUtils_1.removeNullFromUnion)(u, sortBy);
+        const theTypes = [];
+        this.forEachUnionMember(u, nonNulls, "none", null, (_, t) => {
+            const laterType = t.kind === "array" || t.kind === "map";
+            if (laterType) {
+                emitLater.push(t);
+            }
+            theTypes.push(this.scalaType(t));
+        });
+        if (maybeNull !== null) {
+            theTypes.push(this.nameForUnionMember(u, maybeNull));
+        }
+        this.emitLine(["@untagged union ", unionName, " { "]);
+        this.indent(() => {
+            theTypes.forEach((t, i) => {
+                this.emitLine([String.fromCharCode(i + 65), " : ", t]);
+            });
+        });
+        this.emitLine("}");
+        this.ensureBlankLine();
+        emitLater.forEach(p => {
+            function ignore(_) {
+                return;
+            }
+            (0, TypeUtils_1.matchCompoundType)(p, at => {
+                this.emitLine(["list ", this.scalaType(at, true), "{ member: ", this.scalaType(at.items, true), "}"]);
+            }, ignore, mt => {
+                this.emitLine(["map ", this.scalaType(mt, true), "{ key: String , value: ", this.scalaType(mt.values, true), "}"]);
+            }, ignore, ignore);
+        });
+    }
+    emitSourceStructure() {
+        this.emitHeader();
+        // Top-level arrays, maps
+        this.forEachTopLevel("leading", (t, name) => {
+            if (t instanceof Type_1.ArrayType) {
+                this.emitTopLevelArray(t, name);
+            }
+            else if (t instanceof Type_1.MapType) {
+                this.emitTopLevelMap(t, name);
+            }
+        });
+        this.forEachNamedType("leading-and-interposing", (c, n) => this.emitClassDefinition(c, n), (e, n) => this.emitEnumDefinition(e, n), (u, n) => this.emitUnionDefinition(u, n));
+    }
+}
+exports.Smithy4sRenderer = Smithy4sRenderer;
+class SmithyTargetLanguage extends TargetLanguage_1.TargetLanguage {
+    constructor() {
+        super("Smithy", ["Smithy"], "smithy");
+    }
+    getOptions() {
+        return [exports.SmithyOptions.framework, exports.SmithyOptions.packageName];
+    }
+    get supportsOptionalClassProperties() {
+        return true;
+    }
+    get supportsUnionsWithBothNumberTypes() {
+        return true;
+    }
+    makeRenderer(renderContext, untypedOptionValues) {
+        const options = (0, RendererOptions_1.getOptionValues)(exports.SmithyOptions, untypedOptionValues);
+        switch (options.framework) {
+            case Framework.None:
+                return new Smithy4sRenderer(this, renderContext, options);
+            default:
+                return (0, Support_1.assertNever)(options.framework);
+        }
+    }
+}
+exports.SmithyTargetLanguage = SmithyTargetLanguage;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "quicktype-core",
-    "version": "23.0.7",
+    "version": "23.0.9",
     "description": "The quicktype engine as a library",
     "license": "Apache-2.0",
     "main": "dist/index.js",