quicktype 15.0.261 → 16.0.0

package/README.md

@@ -1,40 +1,35 @@
 ![](https://raw.githubusercontent.com/quicktype/quicktype/master/quicktype-logo.svg?sanitize=true)
 
 [![npm version](https://badge.fury.io/js/quicktype.svg)](https://badge.fury.io/js/quicktype)
-[![Build status](https://badge.buildkite.com/147309f9f492c2af1ea53df922be7140ba4035dbb31f61ee1e.svg)](https://buildkite.com/typeguard/quicktype-master)
-[![Join us in Slack](http://slack.quicktype.io/badge.svg)](http://slack.quicktype.io/)
+![Build status](https://github.com/quicktype/quicktype/actions/workflows/master.yaml/badge.svg)
 
 `quicktype` generates strongly-typed models and serializers from JSON, JSON Schema, TypeScript, and [GraphQL queries](https://blog.quicktype.io/graphql-with-quicktype/), making it a breeze to work with JSON type-safely in many programming languages.
 
-- [Try `quicktype` in your browser](https://app.quicktype.io).
-- Read ['A first look at quicktype'](http://blog.quicktype.io/first-look/) for more introduction.
-- If you have any questions, check out the [FAQ](FAQ.md) first.
+-   [Try `quicktype` in your browser](https://app.quicktype.io).
+-   Read ['A first look at quicktype'](http://blog.quicktype.io/first-look/) for more introduction.
+-   If you have any questions, check out the [FAQ](FAQ.md) first.
 
 ### Supported Inputs
 
 | JSON | JSON API URLs | [JSON Schema](https://app.quicktype.io/#s=coordinate) |
 | ---- | ------------- | ----------------------------------------------------- |
 
-
 | TypeScript | GraphQL queries |
 | ---------- | --------------- |
 
-
 ### Target Languages
 
-| [Ruby](https://app.quicktype.io/#l=ruby) | [JavaScript](https://app.quicktype.io/#l=js) | [Flow](https://app.quicktype.io/#l=flow) | [Rust](https://app.quicktype.io/#l=rust) | [Kotlin](https://app.quicktype.io/#l=kotlin) | 
+| [Ruby](https://app.quicktype.io/#l=ruby) | [JavaScript](https://app.quicktype.io/#l=js) | [Flow](https://app.quicktype.io/#l=flow) | [Rust](https://app.quicktype.io/#l=rust) | [Kotlin](https://app.quicktype.io/#l=kotlin) |
 | ---------------------------------------- | -------------------------------------------- | ---------------------------------------- | ---------------------------------------- | -------------------------------------------- |
 
-
-| [Dart](https://app.quicktype.io/#l=dart) | [Python](https://app.quicktype.io/#l=python) | [C#](https://app.quicktype.io/#l=cs) | [Go](https://app.quicktype.io/#l=go) | [C++](https://app.quicktype.io/#l=cpp) | 
-| -------------------------------------------- | ------------------------------------ | ------------------------------------ | -------------------------------------- | ---------------------------------------- |
-
+| [Dart](https://app.quicktype.io/#l=dart) | [Python](https://app.quicktype.io/#l=python) | [C#](https://app.quicktype.io/#l=cs) | [Go](https://app.quicktype.io/#l=go) | [C++](https://app.quicktype.io/#l=cpp) |
+| ---------------------------------------- | -------------------------------------------- | ------------------------------------ | ------------------------------------ | -------------------------------------- |
 
 | [Java](https://app.quicktype.io/#l=java) | [TypeScript](https://app.quicktype.io/#l=ts) | [Swift](https://app.quicktype.io/#l=swift) | [Objective-C](https://app.quicktype.io/#l=objc) | [Elm](https://app.quicktype.io/#l=elm) |
-| ------------------------------------------ | ----------------------------------------------- | -------------------------------------- | ------------------------------------------------- | ---------------------------------------- |
+| ---------------------------------------- | -------------------------------------------- | ------------------------------------------ | ----------------------------------------------- | -------------------------------------- |
 
-| [JSON Schema](https://app.quicktype.io/#l=schema) | [Pike](https://app.quicktype.io/#l=pike) | [Prop-Types](https://app.quicktype.io/#l=javascript-prop-types) | [Haskell](https://app.quicktype.io/#l=haskell) |  |
-| ------------------------------------------ | ----------------------------------------------- | -------------------------------------- | ------------------------------------------------- | ---------------------------------------- |
+| [JSON Schema](https://app.quicktype.io/#l=schema) | [Pike](https://app.quicktype.io/#l=pike) | [Prop-Types](https://app.quicktype.io/#l=javascript-prop-types) | [Haskell](https://app.quicktype.io/#l=haskell) |     |
+| ------------------------------------------------- | ---------------------------------------- | --------------------------------------------------------------- | ---------------------------------------------- | --- |
 
 _Missing your favorite language? Please implement it!_
 
@@ -50,10 +45,10 @@ npm install -g quicktype
 
 Other options:
 
-- [Homebrew](http://formulae.brew.sh/formula/quicktype) _(infrequently updated)_
-- [Xcode extension](https://itunes.apple.com/us/app/paste-json-as-code-quicktype/id1330801220?mt=12)\*
-- [VSCode extension](https://marketplace.visualstudio.com/items/quicktype.quicktype)\*
-- [Visual Studio extension](https://marketplace.visualstudio.com/items?itemName=typeguard.quicktype-vs)\*
+-   [Homebrew](http://formulae.brew.sh/formula/quicktype) _(infrequently updated)_
+-   [Xcode extension](https://itunes.apple.com/us/app/paste-json-as-code-quicktype/id1330801220?mt=12)\*
+-   [VSCode extension](https://marketplace.visualstudio.com/items/quicktype.quicktype)\*
+-   [Visual Studio extension](https://marketplace.visualstudio.com/items?itemName=typeguard.quicktype-vs)\*
 
 <small>\* limited functionality</small>
 
@@ -117,9 +112,9 @@ You can achieve a similar result by writing or generating a [TypeScript](http://
 
 ```typescript
 interface Person {
-  name: string;
-  nickname?: string; // an optional property
-  luckyNumber: number;
+    name: string;
+    nickname?: string; // an optional property
+    luckyNumber: number;
 }
 ```
 
@@ -144,63 +139,55 @@ In general, first you create an `InputData` value with one or more JSON samples,
 
 ```javascript
 const {
-  quicktype,
-  InputData,
-  jsonInputForTargetLanguage,
-  JSONSchemaInput,
-  FetchingJSONSchemaStore,
+    quicktype,
+    InputData,
+    jsonInputForTargetLanguage,
+    JSONSchemaInput,
+    FetchingJSONSchemaStore
 } = require("quicktype-core");
 
 async function quicktypeJSON(targetLanguage, typeName, jsonString) {
-  const jsonInput = jsonInputForTargetLanguage(targetLanguage);
-
-  // We could add multiple samples for the same desired
-  // type, or many sources for other types. Here we're
-  // just making one type from one piece of sample JSON.
-  await jsonInput.addSource({
-    name: typeName,
-    samples: [jsonString],
-  });
-
-  const inputData = new InputData();
-  inputData.addInput(jsonInput);
-
-  return await quicktype({
-    inputData,
-    lang: targetLanguage,
-  });
+    const jsonInput = jsonInputForTargetLanguage(targetLanguage);
+
+    // We could add multiple samples for the same desired
+    // type, or many sources for other types. Here we're
+    // just making one type from one piece of sample JSON.
+    await jsonInput.addSource({
+        name: typeName,
+        samples: [jsonString]
+    });
+
+    const inputData = new InputData();
+    inputData.addInput(jsonInput);
+
+    return await quicktype({
+        inputData,
+        lang: targetLanguage
+    });
 }
 
 async function quicktypeJSONSchema(targetLanguage, typeName, jsonSchemaString) {
-  const schemaInput = new JSONSchemaInput(new FetchingJSONSchemaStore());
+    const schemaInput = new JSONSchemaInput(new FetchingJSONSchemaStore());
 
-  // We could add multiple schemas for multiple types,
-  // but here we're just making one type from JSON schema.
-  await schemaInput.addSource({ name: typeName, schema: jsonSchemaString });
+    // We could add multiple schemas for multiple types,
+    // but here we're just making one type from JSON schema.
+    await schemaInput.addSource({ name: typeName, schema: jsonSchemaString });
 
-  const inputData = new InputData();
-  inputData.addInput(schemaInput);
+    const inputData = new InputData();
+    inputData.addInput(schemaInput);
 
-  return await quicktype({
-    inputData,
-    lang: targetLanguage,
-  });
+    return await quicktype({
+        inputData,
+        lang: targetLanguage
+    });
 }
 
 async function main() {
-  const { lines: swiftPerson } = await quicktypeJSON(
-    "swift",
-    "Person",
-    jsonString
-  );
-  console.log(swiftPerson.join("\n"));
-
-  const { lines: pythonPerson } = await quicktypeJSONSchema(
-    "python",
-    "Person",
-    jsonSchemaString
-  );
-  console.log(pythonPerson.join("\n"));
+    const { lines: swiftPerson } = await quicktypeJSON("swift", "Person", jsonString);
+    console.log(swiftPerson.join("\n"));
+
+    const { lines: pythonPerson } = await quicktypeJSONSchema("python", "Person", jsonSchemaString);
+    console.log(pythonPerson.join("\n"));
 }
 
 main();
@@ -223,6 +210,7 @@ Clone this repo and do:
 #### macOS / Linux
 
 ```bash
+nvm use
 npm install
 script/quicktype # rebuild (slow) and run (fast)
 ```
@@ -264,18 +252,18 @@ files, URLs, or add other options.
 
 `quicktype` has many complex test dependencies:
 
-- `crystal` compiler
-- `dotnetcore` SDK
-- Java, Maven
-- `elm` tools
-- `g++` C++ compiler
-- `golang` stack
-- `swift` compiler
-- `clang` and Objective-C Foundation (must be tested separately on macOS)
-- `rust` tools
-- `pike` interpreter
-- [Bundler](https://bundler.io) for Ruby
-- `haskell` [stack](https://docs.haskellstack.org/)
+-   `crystal` compiler
+-   `dotnetcore` SDK
+-   Java, Maven
+-   `elm` tools
+-   `g++` C++ compiler
+-   `golang` stack
+-   `swift` compiler
+-   `clang` and Objective-C Foundation (must be tested separately on macOS)
+-   `rust` tools
+-   `pike` interpreter
+-   [Bundler](https://bundler.io) for Ruby
+-   `haskell` [stack](https://docs.haskellstack.org/)
 
 We've assembled all of these tools in a Docker container that you build and test within:
 

package/dist/cli/index.js

@@ -34,7 +34,7 @@ function sourceFromFileOrUrlArray(name, filesOrUrls, httpHeaders) {
 }
 function typeNameFromFilename(filename) {
     const name = path.basename(filename);
-    return name.substr(0, name.lastIndexOf("."));
+    return name.substring(0, name.lastIndexOf("."));
 }
 function samplesFromDirectory(dataDir, httpHeaders) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -149,7 +149,7 @@ function inferLang(options, defaultLanguage) {
         if (extension === "") {
             return quicktype_core_1.messageError("DriverNoLanguageOrExtension", {});
         }
-        return extension.substr(1);
+        return extension.slice(1);
     }
     return defaultLanguage;
 }
@@ -232,7 +232,7 @@ function makeLangTypeLabel(targetLanguages) {
 function negatedInferenceFlagName(name) {
     const prefix = "infer";
     if (name.startsWith(prefix)) {
-        name = name.substr(prefix.length);
+        name = name.slice(prefix.length);
     }
     return "no" + quicktype_core_1.capitalize(name);
 }

package/dist/quicktype-core/MarkovChain.js

@@ -61,7 +61,7 @@ function train(lines, depth) {
     const trie = makeTrie();
     for (const l of lines) {
         for (let i = depth; i <= l.length; i++) {
-            increment(trie, l.substr(i - depth, depth), 0);
+            increment(trie, l.slice(i - depth, i), 0);
         }
     }
     return { trie, depth };
@@ -79,7 +79,7 @@ function evaluateFull(mc, word) {
     let p = 1;
     const scores = [];
     for (let i = depth; i <= word.length; i++) {
-        let cp = lookup(trie, word.substr(i - depth, depth), 0);
+        let cp = lookup(trie, word.slice(i - depth, i), 0);
         if (typeof cp === "object") {
             return Support_1.panic("Did we mess up the depth?");
         }

package/dist/quicktype-core/attributes/Description.js

@@ -27,7 +27,7 @@ class DescriptionTypeAttributeKind extends TypeAttributes_1.TypeAttributeKind {
         if (result === undefined)
             return undefined;
         if (result.length > 5 + 3) {
-            result = `${result.substr(0, 5)}...`;
+            result = `${result.slice(0, 5)}...`;
         }
         if (descriptions.size > 1) {
             result = `${result}, ...`;

package/dist/quicktype-core/attributes/TypeNames.js

@@ -60,8 +60,8 @@ function combineNames(names) {
             }
         }
     }
-    const prefix = prefixLength > 2 ? first.substr(0, prefixLength) : "";
-    const suffix = suffixLength > 2 ? first.substr(first.length - suffixLength) : "";
+    const prefix = prefixLength > 2 ? first.slice(0, prefixLength) : "";
+    const suffix = suffixLength > 2 ? first.slice(first.length - suffixLength) : "";
     const combined = prefix + suffix;
     if (combined.length > 2) {
         return combined;

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

@@ -4,7 +4,7 @@ export { Input, InputData, JSONInput, JSONSourceData, jsonInputForTargetLanguage
 export { JSONSchemaInput, JSONSchemaSourceData } from "./input/JSONSchemaInput";
 export { Ref, JSONSchemaType, JSONSchemaAttributes } from "./input/JSONSchemaInput";
 export { RenderContext } from "./Renderer";
-export { Option, OptionDefinition, getOptionValues } from "./RendererOptions";
+export { Option, OptionDefinition, getOptionValues, OptionValues } from "./RendererOptions";
 export { TargetLanguage, MultiFileRenderResult } from "./TargetLanguage";
 export { all as defaultTargetLanguages, languageNamed } from "./language/All";
 export { MultiWord, Sourcelike, SerializedRenderResult, Annotation, modifySource, singleWord, parenIfNeeded } from "./Source";

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

@@ -104,7 +104,7 @@ class Ref {
         const elements = [];
         if (path.startsWith("/")) {
             elements.push({ kind: PathElementKind.Root });
-            path = path.substr(1);
+            path = path.slice(1);
         }
         if (path !== "") {
             const parts = path.split("/");
@@ -171,7 +171,7 @@ class Ref {
                 let name = this.addressURI !== undefined ? this.addressURI.filename() : "";
                 const suffix = this.addressURI !== undefined ? this.addressURI.suffix() : "";
                 if (name.length > suffix.length + 1) {
-                    name = name.substr(0, name.length - suffix.length - 1);
+                    name = name.slice(0, name.length - suffix.length - 1);
                 }
                 if (name === "") {
                     return "Something";
@@ -853,7 +853,7 @@ function removeExtension(fn) {
     const extensions = [".json", ".schema"];
     for (const ext of extensions) {
         if (lower.endsWith(ext)) {
-            const base = fn.substr(0, fn.length - ext.length);
+            const base = fn.slice(0, fn.length - ext.length);
             if (base.length > 0) {
                 return base;
             }
@@ -884,7 +884,7 @@ function refsInSchemaForURI(resolver, uri, defaultName) {
         const fragment = uri.fragment();
         let propertiesAreTypes = fragment.endsWith("/");
         if (propertiesAreTypes) {
-            uri = uri.clone().fragment(fragment.substr(0, fragment.length - 1));
+            uri = uri.clone().fragment(fragment.slice(0, -1));
         }
         const ref = Ref.parseURI(uri);
         if (ref.isRoot) {

package/dist/quicktype-core/input/io/NodeIO.js

@@ -35,19 +35,22 @@ function parseHeaders(httpHeaders) {
 function readableFromFileOrURL(fileOrURL, httpHeaders) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
-            if (browser_or_node_1.isNode && fileOrURL === "-") {
-                // Cast node readable to isomorphic readable from readable-stream
-                return process.stdin;
-            }
-            else if (isURL(fileOrURL)) {
+            if (isURL(fileOrURL)) {
                 const response = yield fetch(fileOrURL, {
                     headers: parseHeaders(httpHeaders)
                 });
                 return response.body;
             }
-            else if (browser_or_node_1.isNode && fs.existsSync(fileOrURL)) {
-                // Cast node readable to isomorphic readable from readable-stream
-                return fs.createReadStream(fileOrURL, "utf8");
+            else if (browser_or_node_1.isNode) {
+                if (fileOrURL === "-") {
+                    // Cast node readable to isomorphic readable from readable-stream
+                    return process.stdin;
+                }
+                const filePath = fs.lstatSync(fileOrURL).isSymbolicLink() ? fs.readlinkSync(fileOrURL) : fileOrURL;
+                if (fs.existsSync(filePath)) {
+                    // Cast node readable to isomorphic readable from readable-stream
+                    return fs.createReadStream(filePath, "utf8");
+                }
             }
         }
         catch (e) {

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

@@ -438,13 +438,13 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 name: MemberNames.MinValue,
                 getter: MemberNames.GetMinValue,
                 setter: MemberNames.SetMinValue,
-                cppType: "int"
+                cppType: "int64_t"
             },
             {
                 name: MemberNames.MaxValue,
                 getter: MemberNames.GetMaxValue,
                 setter: MemberNames.SetMaxValue,
-                cppType: "int"
+                cppType: "int64_t"
             },
             {
                 name: MemberNames.MinLength,

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

@@ -349,7 +349,7 @@ class DartRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 this.emitLine(className, "({");
                 this.indent(() => {
                     this.forEachClassProperty(c, "none", (name, _, _p) => {
-                        this.emitLine(this._options.requiredProperties ? "@required " : "", "this.", name, ",");
+                        this.emitLine(this._options.requiredProperties ? "required " : "", "this.", name, ",");
                     });
                 });
                 this.emitLine("});");

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

@@ -70,6 +70,7 @@ const javaKeywords = [
     "Double",
     "Boolean",
     "String",
+    "List",
     "Map",
     "UUID",
     "Exception",

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

@@ -5,6 +5,7 @@ import { Sourcelike } from "../Source";
 import { TargetLanguage } from "../TargetLanguage";
 import { ArrayType, ClassType, EnumType, MapType, ObjectType, PrimitiveType, Type, UnionType } from "../Type";
 import { RenderContext } from "../Renderer";
+import { AcronymStyleOptions } from "../support/Acronyms";
 export declare enum Framework {
     None = 0,
     Jackson = 1,
@@ -13,6 +14,7 @@ export declare enum Framework {
 }
 export declare const kotlinOptions: {
     framework: EnumOption<Framework>;
+    acronymStyle: EnumOption<AcronymStyleOptions>;
     packageName: StringOption;
 };
 export declare class KotlinTargetLanguage extends TargetLanguage {

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

@@ -11,6 +11,7 @@ const Support_1 = require("../support/Support");
 const TargetLanguage_1 = require("../TargetLanguage");
 const Type_1 = require("../Type");
 const TypeUtils_1 = require("../TypeUtils");
+const Acronyms_1 = require("../support/Acronyms");
 var Framework;
 (function (Framework) {
     Framework[Framework["None"] = 0] = "None";
@@ -20,6 +21,7 @@ var Framework;
 })(Framework = exports.Framework || (exports.Framework = {}));
 exports.kotlinOptions = {
     framework: new RendererOptions_1.EnumOption("framework", "Serialization framework", [["just-types", Framework.None], ["jackson", Framework.Jackson], ["klaxon", Framework.Klaxon], ["kotlinx", Framework.KotlinX]], "klaxon"),
+    acronymStyle: Acronyms_1.acronymOption(Acronyms_1.AcronymStyleOptions.Pascal),
     packageName: new RendererOptions_1.StringOption("package", "Package", "PACKAGE", "quicktype")
 };
 class KotlinTargetLanguage extends TargetLanguage_1.TargetLanguage {
@@ -27,7 +29,7 @@ class KotlinTargetLanguage extends TargetLanguage_1.TargetLanguage {
         super("Kotlin", ["kotlin"], "kt");
     }
     getOptions() {
-        return [exports.kotlinOptions.framework, exports.kotlinOptions.packageName];
+        return [exports.kotlinOptions.framework, exports.kotlinOptions.acronymStyle, exports.kotlinOptions.packageName];
     }
     get supportsOptionalClassProperties() {
         return true;
@@ -110,9 +112,9 @@ function isStartCharacter(codePoint) {
     return isPartCharacter(codePoint) && !Strings_1.isDigit(codePoint);
 }
 const legalizeName = Strings_1.legalizeCharacters(isPartCharacter);
-function kotlinNameStyle(isUpper, original) {
+function kotlinNameStyle(isUpper, original, acronymsStyle = Strings_1.allUpperWordStyle) {
     const words = Strings_1.splitIntoWords(original);
-    return 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);
+    return Strings_1.combineWords(words, legalizeName, isUpper ? Strings_1.firstUpperWordStyle : Strings_1.allLowerWordStyle, Strings_1.firstUpperWordStyle, isUpper ? Strings_1.allUpperWordStyle : Strings_1.allLowerWordStyle, acronymsStyle, "", isStartCharacter);
 }
 function unicodeEscape(codePoint) {
     return "\\u" + Strings_1.intToHex(codePoint, 4);
@@ -122,8 +124,6 @@ function stringEscape(s) {
     // "$this" is a template string in Kotlin so we have to escape $
     return _stringEscape(s).replace(/\$/g, "\\$");
 }
-const upperNamingFunction = Naming_1.funPrefixNamer("upper", s => kotlinNameStyle(true, s));
-const lowerNamingFunction = Naming_1.funPrefixNamer("lower", s => kotlinNameStyle(false, s));
 class KotlinRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
     constructor(targetLanguage, renderContext, _kotlinOptions) {
         super(targetLanguage, renderContext);
@@ -145,16 +145,16 @@ class KotlinRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         return kotlinNameStyle(true, rawName);
     }
     makeNamedTypeNamer() {
-        return upperNamingFunction;
+        return Naming_1.funPrefixNamer("upper", s => kotlinNameStyle(true, s, Acronyms_1.acronymStyle(this._kotlinOptions.acronymStyle)));
     }
     namerForObjectProperty() {
-        return lowerNamingFunction;
+        return Naming_1.funPrefixNamer("lower", s => kotlinNameStyle(false, s, Acronyms_1.acronymStyle(this._kotlinOptions.acronymStyle)));
     }
     makeUnionMemberNamer() {
         return Naming_1.funPrefixNamer("upper", s => kotlinNameStyle(true, s) + "Value");
     }
     makeEnumCaseNamer() {
-        return upperNamingFunction;
+        return Naming_1.funPrefixNamer("upper", s => kotlinNameStyle(true, s, Acronyms_1.acronymStyle(this._kotlinOptions.acronymStyle)));
     }
     emitDescriptionBlock(lines) {
         this.emitCommentLines(lines, " * ", "/**", " */");
@@ -735,12 +735,12 @@ class KotlinXRenderer extends KotlinRenderer {
         super(targetLanguage, renderContext, _kotlinOptions);
     }
     anySourceType(optional) {
-        return ["JsonObject", optional];
+        return ["JsonElement", optional];
     }
     arrayType(arrayType, withIssues = false, noOptional = false) {
         const valType = this.kotlinType(arrayType.items, withIssues, true);
         const name = this.sourcelikeToString(valType);
-        if (name === "JsonObject") {
+        if (name === "JsonObject" || name === "JsonElement") {
             return "JsonArray";
         }
         return super.arrayType(arrayType, withIssues, noOptional);
@@ -748,7 +748,7 @@ class KotlinXRenderer extends KotlinRenderer {
     mapType(mapType, withIssues = false, noOptional = false) {
         const valType = this.kotlinType(mapType.values, withIssues, true);
         const name = this.sourcelikeToString(valType);
-        if (name === "JsonObject") {
+        if (name === "JsonObject" || name === "JsonElement") {
             return "JsonObject";
         }
         return super.mapType(mapType, withIssues, noOptional);
@@ -802,28 +802,12 @@ class KotlinXRenderer extends KotlinRenderer {
     }
     emitEnumDefinition(e, enumName) {
         this.emitDescription(this.descriptionForType(e));
-        this.emitLine(["@Serializable(with = ", enumName, ".Companion::class)"]);
+        this.emitLine(["@Serializable"]);
         this.emitBlock(["enum class ", enumName, "(val value: String)"], () => {
             let count = e.cases.size;
             this.forEachEnumCase(e, "none", (name, json) => {
-                this.emitLine(name, `("${stringEscape(json)}")`, --count === 0 ? ";" : ",");
-            });
-            this.ensureBlankLine();
-            this.emitBlock(["companion object : KSerializer<", enumName, ">"], () => {
-                this.emitBlock("override val descriptor: SerialDescriptor get()", () => {
-                    this.emitLine("return PrimitiveSerialDescriptor(\"", this._kotlinOptions.packageName, ".", enumName, "\", PrimitiveKind.STRING)");
-                });
-                this.emitBlock(["override fun deserialize(decoder: Decoder): ", enumName, " = when (val value = decoder.decodeString())"], () => {
-                    let table = [];
-                    this.forEachEnumCase(e, "none", (name, json) => {
-                        table.push([[`"${stringEscape(json)}"`], [" -> ", name]]);
-                    });
-                    table.push([["else"], [" -> throw IllegalArgumentException(\"", enumName, " could not parse: $value\")"]]);
-                    this.emitTable(table);
-                });
-                this.emitBlock(["override fun serialize(encoder: Encoder, value: ", enumName, ")"], () => {
-                    this.emitLine(["return encoder.encodeString(value.value)"]);
-                });
+                const jsonEnum = stringEscape(json);
+                this.emitLine(`@SerialName("${jsonEnum}") `, name, `("${jsonEnum}")`, --count === 0 ? ";" : ",");
             });
         });
     }

package/dist/quicktype-core/language/Objective-C.js

@@ -162,7 +162,7 @@ const forbiddenForEnumCases = ["new", staticEnumValuesIdentifier];
 function splitExtension(filename) {
     const i = filename.lastIndexOf(".");
     const extension = i !== -1 ? filename.split(".").pop() : "m";
-    filename = i !== -1 ? filename.substr(0, i) : filename;
+    filename = i !== -1 ? filename.slice(0, i) : filename;
     return [filename, extension === undefined ? "m" : extension];
 }
 class ObjectiveCRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
@@ -186,7 +186,7 @@ class ObjectiveCRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         }
         if (firstNonUpper < 2)
             return DEFAULT_CLASS_PREFIX;
-        return name.substr(0, firstNonUpper - 1);
+        return name.slice(0, firstNonUpper - 1);
     }
     forbiddenNamesForGlobalNamespace() {
         return keywords;
@@ -605,7 +605,7 @@ class ObjectiveCRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
     variableNameForTopLevel(name) {
         const camelCaseName = Source_1.modifySource(serialized => {
             // 1. remove class prefix
-            serialized = serialized.substr(this._classPrefix.length);
+            serialized = serialized.slice(this._classPrefix.length);
             // 2. camel case
             return Strings_1.camelCase(serialized);
         }, name);

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

@@ -43,7 +43,13 @@ class RustTargetLanguage extends TargetLanguage_1.TargetLanguage {
         super("Rust", ["rust", "rs", "rustlang"], "rs");
     }
     getOptions() {
-        return [exports.rustOptions.density, exports.rustOptions.visibility, exports.rustOptions.deriveDebug];
+        return [
+            exports.rustOptions.density,
+            exports.rustOptions.visibility,
+            exports.rustOptions.deriveDebug,
+            exports.rustOptions.edition2018,
+            exports.rustOptions.leadingComments
+        ];
     }
 }
 exports.RustTargetLanguage = RustTargetLanguage;

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

@@ -12,7 +12,6 @@ export declare const swiftOptions: {
     justTypes: BooleanOption;
     convenienceInitializers: BooleanOption;
     explicitCodingKeys: BooleanOption;
-    urlSession: BooleanOption;
     alamofire: BooleanOption;
     namedTypePrefix: StringOption;
     useClasses: EnumOption<boolean>;
@@ -92,6 +91,5 @@ export declare class SwiftRenderer extends ConvenienceRenderer {
     private emitConvenienceMutator;
     protected emitMark(line: Sourcelike, horizontalLine?: boolean): void;
     protected emitSourceStructure(): void;
-    private emitURLSessionExtension;
     private emitAlamofireExtension;
 }

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

@@ -19,18 +19,26 @@ exports.swiftOptions = {
     justTypes: new RendererOptions_1.BooleanOption("just-types", "Plain types only", false),
     convenienceInitializers: new RendererOptions_1.BooleanOption("initializers", "Generate initializers and mutators", true),
     explicitCodingKeys: new RendererOptions_1.BooleanOption("coding-keys", "Explicit CodingKey values in Codable types", true),
-    urlSession: new RendererOptions_1.BooleanOption("url-session", "URLSession task extensions", false),
     alamofire: new RendererOptions_1.BooleanOption("alamofire", "Alamofire extensions", false),
     namedTypePrefix: new RendererOptions_1.StringOption("type-prefix", "Prefix for type names", "PREFIX", "", "secondary"),
-    useClasses: new RendererOptions_1.EnumOption("struct-or-class", "Structs or classes", [["struct", false], ["class", true]]),
+    useClasses: new RendererOptions_1.EnumOption("struct-or-class", "Structs or classes", [
+        ["struct", false],
+        ["class", true]
+    ]),
     mutableProperties: new RendererOptions_1.BooleanOption("mutable-properties", "Use var instead of let for object properties", false),
     acronymStyle: Acronyms_1.acronymOption(Acronyms_1.AcronymStyleOptions.Pascal),
-    dense: new RendererOptions_1.EnumOption("density", "Code density", [["dense", true], ["normal", false]], "dense", "secondary"),
+    dense: new RendererOptions_1.EnumOption("density", "Code density", [
+        ["dense", true],
+        ["normal", false]
+    ], "dense", "secondary"),
     linux: new RendererOptions_1.BooleanOption("support-linux", "Support Linux", false, "secondary"),
     objcSupport: new RendererOptions_1.BooleanOption("objective-c-support", "Objects inherit from NSObject and @objcMembers is added to classes", false),
     swift5Support: new RendererOptions_1.BooleanOption("swift-5-support", "Renders output in a Swift 5 compatible mode", false),
     multiFileOutput: new RendererOptions_1.BooleanOption("multi-file-output", "Renders each top-level object in its own Swift file", false),
-    accessLevel: new RendererOptions_1.EnumOption("access-level", "Access level", [["internal", "internal"], ["public", "public"]], "internal", "secondary"),
+    accessLevel: new RendererOptions_1.EnumOption("access-level", "Access level", [
+        ["internal", "internal"],
+        ["public", "public"]
+    ], "internal", "secondary"),
     protocol: new RendererOptions_1.EnumOption("protocol", "Make types implement protocol", [
         ["none", { equatable: false, hashable: false }],
         ["equatable", { equatable: true, hashable: false }],
@@ -65,7 +73,6 @@ class SwiftTargetLanguage extends TargetLanguage_1.TargetLanguage {
             exports.swiftOptions.convenienceInitializers,
             exports.swiftOptions.explicitCodingKeys,
             exports.swiftOptions.accessLevel,
-            exports.swiftOptions.urlSession,
             exports.swiftOptions.alamofire,
             exports.swiftOptions.linux,
             exports.swiftOptions.namedTypePrefix,
@@ -97,6 +104,7 @@ class SwiftTargetLanguage extends TargetLanguage_1.TargetLanguage {
 }
 exports.SwiftTargetLanguage = SwiftTargetLanguage;
 const keywords = [
+    "await",
     "associatedtype",
     "class",
     "deinit",
@@ -227,20 +235,12 @@ class SwiftRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 this.ensureBlankLine();
                 this.forEachTopLevel("leading-and-interposing", (t, name) => this.emitTopLevelMapAndArrayConvenienceInitializerExtensions(t, name));
             }
-            if ((!this._options.justTypes && this._options.convenienceInitializers) ||
-                this._options.urlSession ||
-                this._options.alamofire) {
+            if ((!this._options.justTypes && this._options.convenienceInitializers) || this._options.alamofire) {
                 this.ensureBlankLine();
                 this.emitMark("Helper functions for creating encoders and decoders", true);
                 this.ensureBlankLine();
                 this.emitNewEncoderDecoder();
             }
-            if (this._options.urlSession) {
-                this.ensureBlankLine();
-                this.emitMark("URLSession response handlers", true);
-                this.ensureBlankLine();
-                this.emitURLSessionExtension();
-            }
             if (this._options.alamofire) {
                 this.ensureBlankLine();
                 this.emitMark("Alamofire response handlers", true);
@@ -641,18 +641,6 @@ class SwiftRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                     this.emitLine("//   let ", Source_1.modifySource(Strings_1.camelCase, name), " = ", "try? newJSONDecoder().decode(", name, ".self, from: jsonData)");
                 }
             }
-            if (this._options.urlSession) {
-                this.emitLine("//");
-                this.emitLine("// To read values from URLs:");
-                const lowerName = Source_1.modifySource(Strings_1.camelCase, name);
-                this.emitLine("//");
-                this.emitLine("//   let task = URLSession.shared.", lowerName, "Task(with: url) { ", lowerName, ", response, error in");
-                this.emitLine("//     if let ", lowerName, " = ", lowerName, " {");
-                this.emitLine("//       ...");
-                this.emitLine("//     }");
-                this.emitLine("//   }");
-                this.emitLine("//   task.resume()");
-            }
             if (this._options.alamofire) {
                 this.emitLine("//");
                 this.emitLine("// To parse values from Alamofire responses:");
@@ -756,7 +744,13 @@ class SwiftRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
     }
     propertyLinesDefinition(name, parameter) {
         const useMutableProperties = this._options.mutableProperties;
-        return [this.accessLevel, useMutableProperties ? "var " : "let ", name, ": ", this.swiftPropertyType(parameter)];
+        return [
+            this.accessLevel,
+            useMutableProperties ? "var " : "let ",
+            name,
+            ": ",
+            this.swiftPropertyType(parameter)
+        ];
     }
     renderClassDefinition(c, className) {
         this.startFile(className);
@@ -853,7 +847,7 @@ class SwiftRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 }
                 if (this.propertyCount(c) === 0 && this._options.objcSupport) {
                     this.emitBlockWithAccess(["override init()"], () => {
-                        "";
+                        return "";
                     });
                 }
                 else {
@@ -1152,33 +1146,6 @@ encoder.dateEncodingStrategy = .formatted(formatter)`);
             this.emitSupportFunctions4();
         }
     }
-    emitURLSessionExtension() {
-        this.ensureBlankLine();
-        this.emitBlockWithAccess("extension URLSession", () => {
-            this
-                .emitMultiline(`fileprivate func codableTask<T: Codable>(with url: URL, completionHandler: @escaping (T?, URLResponse?, Error?) -> Void) -> URLSessionDataTask {
-    return self.dataTask(with: url) { data, response, error in
-        guard let data = data, error == nil else {
-            completionHandler(nil, response, error)
-            return
-        }
-        completionHandler(try? newJSONDecoder().decode(T.self, from: data), response, nil)
-    }
-}`);
-            this.ensureBlankLine();
-            this.forEachTopLevel("leading-and-interposing", (_, name) => {
-                this.emitBlock([
-                    "func ",
-                    Source_1.modifySource(Strings_1.camelCase, name),
-                    "Task(with url: URL, completionHandler: @escaping (",
-                    name,
-                    "?, URLResponse?, Error?) -> Void) -> URLSessionDataTask"
-                ], () => {
-                    this.emitLine(`return self.codableTask(with: url, completionHandler: completionHandler)`);
-                });
-            });
-        });
-    }
     emitAlamofireExtension() {
         this.ensureBlankLine();
         this.emitBlockWithAccess("extension DataRequest", () => {

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

@@ -119,6 +119,10 @@ class TypeScriptFlowBaseRenderer extends JavaScript_1.JavaScriptRenderer {
                 [this.sourceFor(t).source, ";"]
             ];
         });
+        const additionalProperties = c.getAdditionalProperties();
+        if (additionalProperties) {
+            this.emitTable([["[property: string]", ": ", this.sourceFor(additionalProperties).source, ";"]]);
+        }
     }
     emitClass(c, className) {
         this.emitDescription(this.descriptionForType(c));

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

@@ -247,7 +247,7 @@ function trimEnd(str) {
     }
     if (firstWS === l)
         return str;
-    return str.substr(0, firstWS);
+    return str.slice(0, firstWS);
 }
 exports.trimEnd = trimEnd;
 function modifyFirstChar(f, s) {

package/dist/quicktype-typescript-input/index.js

@@ -107,7 +107,7 @@ function schemaForTypeScriptSources(sources) {
                 continue;
             }
             const index = quicktype_core_1.defined(matches.index);
-            definition.description = description.substr(0, index) + description.substr(index + matches[0].length);
+            definition.description = description.slice(0, index) + description.slice(index + matches[0].length);
             uris.push(`#/definitions/${name}`);
             if (topLevelName === undefined) {
                 if (typeof definition.title === "string") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quicktype",
-  "version": "15.0.261",
+  "version": "16.0.0",
   "license": "Apache-2.0",
   "main": "dist/cli/index.js",
   "types": "dist/cli/index.d.ts",
@@ -13,7 +13,8 @@
     "start": "script/watch",
     "pkg": "script/make-pkgs.sh",
     "tslint": "tslint --project src/cli --exclude 'src/__tests__/**' --exclude 'src/quicktype-core/input/io/get-stream/**'",
-    "clean": "rm -rf dist node_modules *~"
+    "clean": "rm -rf dist node_modules *~",
+    "publish": "script/publish.sh"
   },
   "dependencies": {
     "chalk": "^2.4.1",
@@ -33,7 +34,7 @@
     "typescript": "~3.2.1",
     "@mark.probst/typescript-json-schema": "~0.32.0",
     "@mark.probst/unicode-properties": "~1.1.0",
-    "urijs": "^1.19.6",
+    "urijs": "^1.19.11",
     "uuid": "^3.2.1",
     "wordwrap": "^1.0.0",
     "yaml": "^1.5.0",
@@ -52,16 +53,13 @@
     "@types/yaml": "^1.0.2",
     "ajv": "^5.5.2",
     "deep-equal": "^1.0.1",
-    "elm": "0.18.0-exp5",
     "exit": "^0.1.2",
-    "flow-bin": "^0.66.0",
-    "flow-remove-types": "^1.2.3",
     "jest": "^23.1.0",
     "promise-timeout": "^1.3.0",
     "semver": "^5.5.0",
-    "shelljs": "^0.7.8",
+    "shelljs": "^0.8.5",
     "ts-jest": "^23.1.3",
-    "ts-node": "^3.3.0",
+    "ts-node": "^10.9.1",
     "tslint": "^5.11.0",
     "uglify-js": "^3.3.22",
     "watch": "^1.0.2",

package/dist/cli/ci.d.ts

@@ -1,5 +0,0 @@
-export declare function tryHash(envs: Array<string | undefined>): string | undefined;
-export declare function getProvider(environment?: any): {
-    provider: string;
-    userId: string;
-} | undefined;

package/dist/cli/ci.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const process = require("process");
-const crypto_1 = require("crypto");
-// A map from CI providers to environment variables that uniquely identify a project.
-// If present, these variables are hashed to produce a unique userId for quicktype in CI.
-function getProviders(env = process.env) {
-    return [
-        ["Travis", [env.TRAVIS_REPO_SLUG]],
-        ["Jenkins", [env.JENKINS_URL]],
-        ["TeamCity", [env.TEAMCITY_PROJECT_NAME]],
-        ["CircleCI", [env.CIRCLE_PROJECT_USERNAME, env.CIRCLE_PROJECT_REPONAME]],
-        ["Codeship", [env.CI_REPO_NAME]],
-        ["GitLab", [env.GITLAB_CI, env.CI_REPOSITORY_URL, env.CI_PROJECT_ID]],
-        ["VSTS", [env.SYSTEM_TEAMFOUNDATIONCOLLECTIONURI, env.BUILD_REPOSITORY_NAME]],
-        ["App Center", [env.SYSTEM_TEAMFOUNDATIONCOLLECTIONURI, env.BUILD_REPOSITORY_NAME]],
-        // We intentionally collapse users with env.CI to prevent over-counting for unidentified CI
-        ["Other", [env.CI]]
-    ];
-}
-function tryHash(envs) {
-    if (envs.some(s => s === undefined)) {
-        return undefined;
-    }
-    const hash = crypto_1.createHash("sha256");
-    envs.forEach(s => hash.update(s));
-    return hash.digest("base64");
-}
-exports.tryHash = tryHash;
-function getProvider(environment) {
-    for (const [provider, vars] of getProviders(environment)) {
-        const hash = tryHash(vars);
-        if (hash !== undefined) {
-            return { provider, userId: hash };
-        }
-    }
-    return undefined;
-}
-exports.getProvider = getProvider;