diff --git a/head/schema-cjson/test/inputs/schema/coding-keys.schema/default/TopLevel.c b/head/schema-cjson/test/inputs/schema/coding-keys.schema/default/TopLevel.c new file mode 100644 index 0000000..00e80f8 --- /dev/null +++ b/head/schema-cjson/test/inputs/schema/coding-keys.schema/default/TopLevel.c @@ -0,0 +1,145 @@ +/** + * TopLevel.c + * This file has been autogenerated using quicktype https://github.com/quicktype/quicktype - DO NOT EDIT + */ + +#include "TopLevel.h" + +struct CodingKeys * cJSON_ParseCodingKeys(const char * s) { + struct CodingKeys * x = NULL; + if (NULL != s) { + cJSON * j = cJSON_Parse(s); + if (NULL != j) { + x = cJSON_GetCodingKeysValue(j); + cJSON_Delete(j); + } + } + return x; +} + +struct CodingKeys * cJSON_GetCodingKeysValue(const cJSON * j) { + struct CodingKeys * x = NULL; + if (NULL != j) { + if (NULL != (x = cJSON_malloc(sizeof(struct CodingKeys)))) { + memset(x, 0, sizeof(struct CodingKeys)); + if (cJSON_HasObjectItem(j, "foo")) { + x->foo = strdup(cJSON_GetStringValue(cJSON_GetObjectItemCaseSensitive(j, "foo"))); + } + else { + if (NULL != (x->foo = cJSON_malloc(sizeof(char)))) { + x->foo[0] = '\0'; + } + } + } + } + return x; +} + +cJSON * cJSON_CreateCodingKeys(const struct CodingKeys * x) { + cJSON * j = NULL; + if (NULL != x) { + if (NULL != (j = cJSON_CreateObject())) { + if (NULL != x->foo) { + cJSON_AddStringToObject(j, "foo", x->foo); + } + else { + cJSON_AddStringToObject(j, "foo", ""); + } + } + } + return j; +} + +char * cJSON_PrintCodingKeys(const struct CodingKeys * x) { + char * s = NULL; + if (NULL != x) { + cJSON * j = cJSON_CreateCodingKeys(x); + if (NULL != j) { + s = cJSON_Print(j); + cJSON_Delete(j); + } + } + return s; +} + +void cJSON_DeleteCodingKeys(struct CodingKeys * x) { + if (NULL != x) { + if (NULL != x->foo) { + cJSON_free(x->foo); + } + cJSON_free(x); + } +} + +struct TopLevel * cJSON_ParseTopLevel(const char * s) { + struct TopLevel * x = NULL; + if (NULL != s) { + cJSON * j = cJSON_Parse(s); + if (NULL != j) { + x = cJSON_GetTopLevelValue(j); + cJSON_Delete(j); + } + } + return x; +} + +struct TopLevel * cJSON_GetTopLevelValue(const cJSON * j) { + struct TopLevel * x = NULL; + if (NULL != j) { + if (NULL != (x = cJSON_malloc(sizeof(struct TopLevel)))) { + memset(x, 0, sizeof(struct TopLevel)); + if (cJSON_HasObjectItem(j, "coding-keys")) { + x->coding_keys = cJSON_GetCodingKeysValue(cJSON_GetObjectItemCaseSensitive(j, "coding-keys")); + } + if (cJSON_HasObjectItem(j, "name")) { + x->name = strdup(cJSON_GetStringValue(cJSON_GetObjectItemCaseSensitive(j, "name"))); + } + else { + if (NULL != (x->name = cJSON_malloc(sizeof(char)))) { + x->name[0] = '\0'; + } + } + } + } + return x; +} + +cJSON * cJSON_CreateTopLevel(const struct TopLevel * x) { + cJSON * j = NULL; + if (NULL != x) { + if (NULL != (j = cJSON_CreateObject())) { + cJSON_AddItemToObject(j, "coding-keys", cJSON_CreateCodingKeys(x->coding_keys)); + if (NULL != x->name) { + cJSON_AddStringToObject(j, "name", x->name); + } + else { + cJSON_AddStringToObject(j, "name", ""); + } + } + } + return j; +} + +char * cJSON_PrintTopLevel(const struct TopLevel * x) { + char * s = NULL; + if (NULL != x) { + cJSON * j = cJSON_CreateTopLevel(x); + if (NULL != j) { + s = cJSON_Print(j); + cJSON_Delete(j); + } + } + return s; +} + +void cJSON_DeleteTopLevel(struct TopLevel * x) { + if (NULL != x) { + if (NULL != x->coding_keys) { + cJSON_DeleteCodingKeys(x->coding_keys); + } + if (NULL != x->name) { + cJSON_free(x->name); + } + cJSON_free(x); + } +} diff --git a/head/schema-cjson/test/inputs/schema/coding-keys.schema/default/TopLevel.h b/head/schema-cjson/test/inputs/schema/coding-keys.schema/default/TopLevel.h new file mode 100644 index 0000000..4864be5 --- /dev/null +++ b/head/schema-cjson/test/inputs/schema/coding-keys.schema/default/TopLevel.h @@ -0,0 +1,62 @@ +/** + * TopLevel.h + * This file has been autogenerated using quicktype https://github.com/quicktype/quicktype - DO NOT EDIT + * This file depends of https://github.com/DaveGamble/cJSON, https://github.com/joelguittet/c-list and https://github.com/joelguittet/c-hashtable + * To parse json data from json string use the following: struct * data = cJSON_Parse(); + * To get json data from cJSON object use the following: struct * data = cJSON_GetValue(); + * To get cJSON object from json data use the following: cJSON * cjson = cJSON_Create(); + * To print json string from json data use the following: char * string = cJSON_Print(); + * To delete json data use the following: cJSON_Delete(); + */ + +#ifndef __TOPLEVEL_H__ +#define __TOPLEVEL_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include +#include +#include +#include +#include + +#ifndef cJSON_Bool +#define cJSON_Bool (cJSON_True | cJSON_False) +#endif +#ifndef cJSON_Map +#define cJSON_Map (1 << 16) +#endif +#ifndef cJSON_Enum +#define cJSON_Enum (1 << 17) +#endif + +struct CodingKeys { + char * foo; +}; + +struct TopLevel { + struct CodingKeys * coding_keys; + char * name; +}; + +struct CodingKeys * cJSON_ParseCodingKeys(const char * s); +struct CodingKeys * cJSON_GetCodingKeysValue(const cJSON * j); +cJSON * cJSON_CreateCodingKeys(const struct CodingKeys * x); +char * cJSON_PrintCodingKeys(const struct CodingKeys * x); +void cJSON_DeleteCodingKeys(struct CodingKeys * x); + +struct TopLevel * cJSON_ParseTopLevel(const char * s); +struct TopLevel * cJSON_GetTopLevelValue(const cJSON * j); +cJSON * cJSON_CreateTopLevel(const struct TopLevel * x); +char * cJSON_PrintTopLevel(const struct TopLevel * x); +void cJSON_DeleteTopLevel(struct TopLevel * x); + +#ifdef __cplusplus +} +#endif + +#endif /* __TOPLEVEL_H__ */ diff --git a/head/schema-cplusplus/test/inputs/schema/coding-keys.schema/default/quicktype.hpp b/head/schema-cplusplus/test/inputs/schema/coding-keys.schema/default/quicktype.hpp new file mode 100644 index 0000000..8e9ec55 --- /dev/null +++ b/head/schema-cplusplus/test/inputs/schema/coding-keys.schema/default/quicktype.hpp @@ -0,0 +1,94 @@ +// To parse this JSON data, first install +// +// json.hpp https://github.com/nlohmann/json +// +// Then include this file, and then do +// +// TopLevel data = nlohmann::json::parse(jsonString); + +#pragma once + +#include "json.hpp" + +#include +#include +#include + +namespace quicktype { + using nlohmann::json; + + #ifndef NLOHMANN_UNTYPED_quicktype_HELPER + #define NLOHMANN_UNTYPED_quicktype_HELPER + inline json get_untyped(const json & j, const char * property) { + if (j.find(property) != j.end()) { + return j.at(property).get(); + } + return json(); + } + + inline json get_untyped(const json & j, std::string property) { + return get_untyped(j, property.data()); + } + #endif + + class CodingKeys { + public: + CodingKeys() = default; + virtual ~CodingKeys() = default; + + private: + std::string foo; + + public: + const std::string & get_foo() const { return foo; } + std::string & get_mutable_foo() { return foo; } + void set_foo(const std::string & value) { this->foo = value; } + }; + + class TopLevel { + public: + TopLevel() = default; + virtual ~TopLevel() = default; + + private: + CodingKeys coding_keys; + std::string name; + + public: + const CodingKeys & get_coding_keys() const { return coding_keys; } + CodingKeys & get_mutable_coding_keys() { return coding_keys; } + void set_coding_keys(const CodingKeys & value) { this->coding_keys = value; } + + const std::string & get_name() const { return name; } + std::string & get_mutable_name() { return name; } + void set_name(const std::string & value) { this->name = value; } + }; +} + +namespace quicktype { + void from_json(const json & j, CodingKeys & x); + void to_json(json & j, const CodingKeys & x); + + void from_json(const json & j, TopLevel & x); + void to_json(json & j, const TopLevel & x); + + inline void from_json(const json & j, CodingKeys& x) { + x.set_foo(j.at("foo").get()); + } + + inline void to_json(json & j, const CodingKeys & x) { + j = json::object(); + j["foo"] = x.get_foo(); + } + + inline void from_json(const json & j, TopLevel& x) { + x.set_coding_keys(j.at("coding-keys").get()); + x.set_name(j.at("name").get()); + } + + inline void to_json(json & j, const TopLevel & x) { + j = json::object(); + j["coding-keys"] = x.get_coding_keys(); + j["name"] = x.get_name(); + } +} diff --git a/head/schema-csharp/test/inputs/schema/coding-keys.schema/default/QuickType.cs b/head/schema-csharp/test/inputs/schema/coding-keys.schema/default/QuickType.cs new file mode 100644 index 0000000..cf8fa03 --- /dev/null +++ b/head/schema-csharp/test/inputs/schema/coding-keys.schema/default/QuickType.cs @@ -0,0 +1,70 @@ +// +// +// To parse this JSON data, add NuGet 'Newtonsoft.Json' then do: +// +// using QuickType; +// +// var topLevel = TopLevel.FromJson(jsonString); +#nullable enable +#pragma warning disable CS8618 +#pragma warning disable CS8601 +#pragma warning disable CS8602 +#pragma warning disable CS8603 +#pragma warning disable CS8604 +#pragma warning disable CS8625 +#pragma warning disable CS8765 + +namespace QuickType +{ + using System; + using System.Collections.Generic; + + using System.Globalization; + using Newtonsoft.Json; + using Newtonsoft.Json.Converters; + + public partial class TopLevel + { + [JsonProperty("coding-keys", Required = Required.Always)] + public CodingKeys CodingKeys { get; set; } + + [JsonProperty("name", Required = Required.Always)] + public string Name { get; set; } + } + + public partial class CodingKeys + { + [JsonProperty("foo", Required = Required.Always)] + public string Foo { get; set; } + } + + public partial class TopLevel + { + public static TopLevel FromJson(string json) => JsonConvert.DeserializeObject(json, QuickType.Converter.Settings); + } + + public static partial class Serialize + { + public static string ToJson(this TopLevel self) => JsonConvert.SerializeObject(self, QuickType.Converter.Settings); + } + + internal static partial class Converter + { + public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings + { + MetadataPropertyHandling = MetadataPropertyHandling.Ignore, + DateParseHandling = DateParseHandling.None, + Converters = + { + new IsoDateTimeConverter { DateTimeStyles = DateTimeStyles.AssumeUniversal } + }, + }; + } +} +#pragma warning restore CS8618 +#pragma warning restore CS8601 +#pragma warning restore CS8602 +#pragma warning restore CS8603 +#pragma warning restore CS8604 +#pragma warning restore CS8625 +#pragma warning restore CS8765 diff --git a/head/schema-csharp-SystemTextJson/test/inputs/schema/coding-keys.schema/default/QuickType.cs b/head/schema-csharp-SystemTextJson/test/inputs/schema/coding-keys.schema/default/QuickType.cs new file mode 100644 index 0000000..26c9352 --- /dev/null +++ b/head/schema-csharp-SystemTextJson/test/inputs/schema/coding-keys.schema/default/QuickType.cs @@ -0,0 +1,177 @@ +// +// +// To parse this JSON data, add NuGet 'System.Text.Json' then do: +// +// using QuickType; +// +// var topLevel = TopLevel.FromJson(jsonString); +#nullable enable +#pragma warning disable CS8618 +#pragma warning disable CS8601 +#pragma warning disable CS8602 +#pragma warning disable CS8603 + +namespace QuickType +{ + using System; + using System.Collections.Generic; + + using System.Text.Json; + using System.Text.Json.Serialization; + using System.Globalization; + + public partial class TopLevel + { + [JsonRequired] + [JsonPropertyName("coding-keys")] + public CodingKeys CodingKeys { get; set; } + + [JsonRequired] + [JsonPropertyName("name")] + public string Name { get; set; } + } + + public partial class CodingKeys + { + [JsonRequired] + [JsonPropertyName("foo")] + public string Foo { get; set; } + } + + public partial class TopLevel + { + public static TopLevel FromJson(string json) => JsonSerializer.Deserialize(json, QuickType.Converter.Settings); + } + + public static partial class Serialize + { + public static string ToJson(this TopLevel self) => JsonSerializer.Serialize(self, QuickType.Converter.Settings); + } + + internal static partial class Converter + { + public static readonly JsonSerializerOptions Settings = new(JsonSerializerDefaults.General) + { + Converters = + { + new DateOnlyConverter(), + new TimeOnlyConverter(), + IsoDateTimeOffsetConverter.Singleton + }, + }; + } + + public class DateOnlyConverter : JsonConverter + { + private readonly string serializationFormat; + public DateOnlyConverter() : this(null) { } + + public DateOnlyConverter(string? serializationFormat) + { + this.serializationFormat = serializationFormat ?? "yyyy-MM-dd"; + } + + public override DateOnly Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) + { + var value = reader.GetString(); + return DateOnly.Parse(value!); + } + + public override void Write(Utf8JsonWriter writer, DateOnly value, JsonSerializerOptions options) + => writer.WriteStringValue(value.ToString(serializationFormat)); + } + + public class TimeOnlyConverter : JsonConverter + { + private readonly string serializationFormat; + + public TimeOnlyConverter() : this(null) { } + + public TimeOnlyConverter(string? serializationFormat) + { + this.serializationFormat = serializationFormat ?? "HH:mm:ss.fff"; + } + + public override TimeOnly Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) + { + var value = reader.GetString(); + return TimeOnly.Parse(value!); + } + + public override void Write(Utf8JsonWriter writer, TimeOnly value, JsonSerializerOptions options) + => writer.WriteStringValue(value.ToString(serializationFormat)); + } + + internal class IsoDateTimeOffsetConverter : JsonConverter + { + public override bool CanConvert(Type t) => t == typeof(DateTimeOffset); + + private const string DefaultDateTimeFormat = "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK"; + + private DateTimeStyles _dateTimeStyles = DateTimeStyles.RoundtripKind; + private string? _dateTimeFormat; + private CultureInfo? _culture; + + public DateTimeStyles DateTimeStyles + { + get => _dateTimeStyles; + set => _dateTimeStyles = value; + } + + public string? DateTimeFormat + { + get => _dateTimeFormat ?? string.Empty; + set => _dateTimeFormat = (string.IsNullOrEmpty(value)) ? null : value; + } + + public CultureInfo Culture + { + get => _culture ?? CultureInfo.CurrentCulture; + set => _culture = value; + } + + public override void Write(Utf8JsonWriter writer, DateTimeOffset value, JsonSerializerOptions options) + { + string text; + + + if ((_dateTimeStyles & DateTimeStyles.AdjustToUniversal) == DateTimeStyles.AdjustToUniversal + || (_dateTimeStyles & DateTimeStyles.AssumeUniversal) == DateTimeStyles.AssumeUniversal) + { + value = value.ToUniversalTime(); + } + + text = value.ToString(_dateTimeFormat ?? DefaultDateTimeFormat, Culture); + + writer.WriteStringValue(text); + } + + public override DateTimeOffset Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) + { + string? dateText = reader.GetString(); + + if (string.IsNullOrEmpty(dateText) == false) + { + if (!string.IsNullOrEmpty(_dateTimeFormat)) + { + return DateTimeOffset.ParseExact(dateText, _dateTimeFormat, Culture, _dateTimeStyles); + } + else + { + return DateTimeOffset.Parse(dateText, Culture, _dateTimeStyles); + } + } + else + { + return default(DateTimeOffset); + } + } + + + public static readonly IsoDateTimeOffsetConverter Singleton = new IsoDateTimeOffsetConverter(); + } +} +#pragma warning restore CS8618 +#pragma warning restore CS8601 +#pragma warning restore CS8602 +#pragma warning restore CS8603 diff --git a/head/schema-csharp-records/test/inputs/schema/coding-keys.schema/default/QuickType.cs b/head/schema-csharp-records/test/inputs/schema/coding-keys.schema/default/QuickType.cs new file mode 100644 index 0000000..5512b78 --- /dev/null +++ b/head/schema-csharp-records/test/inputs/schema/coding-keys.schema/default/QuickType.cs @@ -0,0 +1,70 @@ +// +// +// To parse this JSON data, add NuGet 'Newtonsoft.Json' then do: +// +// using QuickType; +// +// var topLevel = TopLevel.FromJson(jsonString); +#nullable enable +#pragma warning disable CS8618 +#pragma warning disable CS8601 +#pragma warning disable CS8602 +#pragma warning disable CS8603 +#pragma warning disable CS8604 +#pragma warning disable CS8625 +#pragma warning disable CS8765 + +namespace QuickType +{ + using System; + using System.Collections.Generic; + + using System.Globalization; + using Newtonsoft.Json; + using Newtonsoft.Json.Converters; + + public partial record TopLevel + { + [JsonProperty("coding-keys", Required = Required.Always)] + public CodingKeys CodingKeys { get; set; } + + [JsonProperty("name", Required = Required.Always)] + public string Name { get; set; } + } + + public partial record CodingKeys + { + [JsonProperty("foo", Required = Required.Always)] + public string Foo { get; set; } + } + + public partial record TopLevel + { + public static TopLevel FromJson(string json) => JsonConvert.DeserializeObject(json, QuickType.Converter.Settings); + } + + public static partial class Serialize + { + public static string ToJson(this TopLevel self) => JsonConvert.SerializeObject(self, QuickType.Converter.Settings); + } + + internal static partial class Converter + { + public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings + { + MetadataPropertyHandling = MetadataPropertyHandling.Ignore, + DateParseHandling = DateParseHandling.None, + Converters = + { + new IsoDateTimeConverter { DateTimeStyles = DateTimeStyles.AssumeUniversal } + }, + }; + } +} +#pragma warning restore CS8618 +#pragma warning restore CS8601 +#pragma warning restore CS8602 +#pragma warning restore CS8603 +#pragma warning restore CS8604 +#pragma warning restore CS8625 +#pragma warning restore CS8765 diff --git a/head/schema-dart/test/inputs/schema/coding-keys.schema/default/TopLevel.dart b/head/schema-dart/test/inputs/schema/coding-keys.schema/default/TopLevel.dart new file mode 100644 index 0000000..87e2dfd --- /dev/null +++ b/head/schema-dart/test/inputs/schema/coding-keys.schema/default/TopLevel.dart @@ -0,0 +1,45 @@ +// To parse this JSON data, do +// +// final topLevel = topLevelFromJson(jsonString); + +import 'dart:convert'; + +TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str)); + +String topLevelToJson(TopLevel data) => json.encode(data.toJson()); + +class TopLevel { + final CodingKeys codingKeys; + final String name; + + TopLevel({ + required this.codingKeys, + required this.name, + }); + + factory TopLevel.fromJson(Map json) => TopLevel( + codingKeys: CodingKeys.fromJson(json["coding-keys"]), + name: json["name"], + ); + + Map toJson() => { + "coding-keys": codingKeys.toJson(), + "name": name, + }; +} + +class CodingKeys { + final String foo; + + CodingKeys({ + required this.foo, + }); + + factory CodingKeys.fromJson(Map json) => CodingKeys( + foo: json["foo"], + ); + + Map toJson() => { + "foo": foo, + }; +} diff --git a/head/schema-elixir/test/inputs/schema/coding-keys.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/coding-keys.schema/default/QuickType.ex new file mode 100644 index 0000000..abd7ca4 --- /dev/null +++ b/head/schema-elixir/test/inputs/schema/coding-keys.schema/default/QuickType.ex @@ -0,0 +1,75 @@ +# This file was autogenerated using quicktype https://github.com/quicktype/quicktype +# +# Add Jason to your mix.exs +# +# Decode a JSON string: TopLevel.from_json(data) +# Encode into a JSON string: TopLevel.to_json(struct) + +defmodule CodingKeys do + @enforce_keys [:foo] + defstruct [:foo] + + @type t :: %__MODULE__{ + foo: String.t() + } + + def from_map(m) do + %CodingKeys{ + foo: m["foo"], + } + end + + def from_json(json) do + json + |> Jason.decode!() + |> from_map() + end + + def to_map(struct) do + %{ + "foo" => struct.foo, + } + end + + def to_json(struct) do + struct + |> to_map() + |> Jason.encode!() + end +end + +defmodule TopLevel do + @enforce_keys [:coding_keys, :name] + defstruct [:coding_keys, :name] + + @type t :: %__MODULE__{ + coding_keys: CodingKeys.t(), + name: String.t() + } + + def from_map(m) do + %TopLevel{ + coding_keys: CodingKeys.from_map(m["coding-keys"]), + name: m["name"], + } + end + + def from_json(json) do + json + |> Jason.decode!() + |> from_map() + end + + def to_map(struct) do + %{ + "coding-keys" => CodingKeys.to_map(struct.coding_keys), + "name" => struct.name, + } + end + + def to_json(struct) do + struct + |> to_map() + |> Jason.encode!() + end +end diff --git a/head/schema-elm/test/inputs/schema/coding-keys.schema/default/QuickType.elm b/head/schema-elm/test/inputs/schema/coding-keys.schema/default/QuickType.elm new file mode 100644 index 0000000..a7ebeb2 --- /dev/null +++ b/head/schema-elm/test/inputs/schema/coding-keys.schema/default/QuickType.elm @@ -0,0 +1,70 @@ +-- To decode the JSON data, add this file to your project, run +-- +-- elm install NoRedInk/elm-json-decode-pipeline +-- +-- add these imports +-- +-- import Json.Decode exposing (decodeString) +-- import QuickType exposing (quickType) +-- +-- and you're off to the races with +-- +-- decodeString quickType myJsonString + +module QuickType exposing + ( QuickType + , quickTypeToString + , quickType + , CodingKeys + ) + +import Json.Decode as Jdec +import Json.Decode.Pipeline as Jpipe +import Json.Encode as Jenc +import Dict exposing (Dict) + +type alias QuickType = + { codingKeys : CodingKeys + , name : String + } + +type alias CodingKeys = + { foo : String + } + +-- decoders and encoders + +quickTypeToString : QuickType -> String +quickTypeToString r = Jenc.encode 0 (encodeQuickType r) + +quickType : Jdec.Decoder QuickType +quickType = + Jdec.succeed QuickType + |> Jpipe.required "coding-keys" codingKeys + |> Jpipe.required "name" Jdec.string + +encodeQuickType : QuickType -> Jenc.Value +encodeQuickType x = + Jenc.object + [ ("coding-keys", encodeCodingKeys x.codingKeys) + , ("name", Jenc.string x.name) + ] + +codingKeys : Jdec.Decoder CodingKeys +codingKeys = + Jdec.succeed CodingKeys + |> Jpipe.required "foo" Jdec.string + +encodeCodingKeys : CodingKeys -> Jenc.Value +encodeCodingKeys x = + Jenc.object + [ ("foo", Jenc.string x.foo) + ] + +--- encoder helpers + +makeNullableEncoder : (a -> Jenc.Value) -> Maybe a -> Jenc.Value +makeNullableEncoder f m = + case m of + Just x -> f x + Nothing -> Jenc.null diff --git a/head/schema-flow/test/inputs/schema/coding-keys.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/coding-keys.schema/default/TopLevel.js new file mode 100644 index 0000000..4d91103 --- /dev/null +++ b/head/schema-flow/test/inputs/schema/coding-keys.schema/default/TopLevel.js @@ -0,0 +1,199 @@ +// @flow + +// To parse this data: +// +// const Convert = require("./TopLevel"); +// +// const topLevel = Convert.toTopLevel(json); +// +// These functions will throw an error if the JSON doesn't +// match the expected interface, even if the JSON is valid. + +export type TopLevel = { + "coding-keys": CodingKeys; + name: string; + [property: string]: mixed; +}; + +export type CodingKeys = { + foo: string; + [property: string]: mixed; +}; + +// Converts JSON strings to/from your types +// and asserts the results of JSON.parse at runtime +function toTopLevel(json: string): TopLevel { + return cast(JSON.parse(json), r("TopLevel")); +} + +function topLevelToJson(value: TopLevel): string { + return JSON.stringify(uncast(value, r("TopLevel")), null, 2); +} + +function invalidValue(typ: any, val: any, key: any, parent: any = '') { + const prettyTyp = prettyTypeName(typ); + const parentText = parent ? ` on ${parent}` : ''; + const keyText = key ? ` for key "${key}"` : ''; + throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`); +} + +function prettyTypeName(typ: any): string { + if (Array.isArray(typ)) { + if (typ.length === 2 && typ[0] === undefined) { + return `an optional ${prettyTypeName(typ[1])}`; + } else { + return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`; + } + } else if (typeof typ === "object" && typ.literal !== undefined) { + return typ.literal; + } else { + return typeof typ; + } +} + +function jsonToJSProps(typ: any): any { + if (typ.jsonToJS === undefined) { + const map: any = {}; + typ.props.forEach((p: any) => map[p.json] = { key: p.js, typ: p.typ }); + typ.jsonToJS = map; + } + return typ.jsonToJS; +} + +function jsToJSONProps(typ: any): any { + if (typ.jsToJSON === undefined) { + const map: any = {}; + typ.props.forEach((p: any) => map[p.js] = { key: p.json, typ: p.typ }); + typ.jsToJSON = map; + } + return typ.jsToJSON; +} + +function transform(val: any, typ: any, getProps: any, key: any = '', parent: any = ''): any { + function transformPrimitive(typ: string, val: any): any { + if (typeof typ === typeof val) return val; + return invalidValue(typ, val, key, parent); + } + + function transformUnion(typs: any[], val: any): any { + // val must validate against one typ in typs + const l = typs.length; + for (let i = 0; i < l; i++) { + const typ = typs[i]; + try { + return transform(val, typ, getProps); + } catch (_) {} + } + return invalidValue(typs, val, key, parent); + } + + function transformEnum(cases: string[], val: any): any { + if (cases.indexOf(val) !== -1) return val; + return invalidValue(cases.map(a => { return l(a); }), val, key, parent); + } + + function transformArray(typ: any, val: any): any { + // val must be an array with no invalid elements + if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent); + return val.map(el => transform(el, typ, getProps)); + } + + function transformDate(val: any): any { + if (val === null) { + return null; + } + const d = new Date(val); + if (isNaN(d.valueOf())) { + return invalidValue(l("Date"), val, key, parent); + } + return d; + } + + function transformObject(props: { [k: string]: any }, additional: any, val: any): any { + if (val === null || typeof val !== "object" || Array.isArray(val)) { + return invalidValue(l(ref || "object"), val, key, parent); + } + const result: any = {}; + Object.getOwnPropertyNames(props).forEach(key => { + const prop = props[key]; + const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined; + result[prop.key] = transform(v, prop.typ, getProps, key, ref); + }); + Object.getOwnPropertyNames(val).forEach(key => { + if (!Object.prototype.hasOwnProperty.call(props, key)) { + result[key] = transform(val[key], additional, getProps, key, ref); + } + }); + return result; + } + + if (typ === "any") return val; + if (typ === null) { + if (val === null) return val; + return invalidValue(typ, val, key, parent); + } + if (typ === false) return invalidValue(typ, val, key, parent); + let ref: any = undefined; + while (typeof typ === "object" && typ.ref !== undefined) { + ref = typ.ref; + typ = typeMap[typ.ref]; + } + if (Array.isArray(typ)) return transformEnum(typ, val); + if (typeof typ === "object") { + return typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) + : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val) + : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val) + : invalidValue(typ, val, key, parent); + } + // Numbers can be parsed by Date but shouldn't be. + if (typ === Date && typeof val !== "number") return transformDate(val); + return transformPrimitive(typ, val); +} + +function cast(val: any, typ: any): T { + return transform(val, typ, jsonToJSProps); +} + +function uncast(val: T, typ: any): any { + return transform(val, typ, jsToJSONProps); +} + +function l(typ: any) { + return { literal: typ }; +} + +function a(typ: any) { + return { arrayItems: typ }; +} + +function u(...typs: any[]) { + return { unionMembers: typs }; +} + +function o(props: any[], additional: any) { + return { props, additional }; +} + +function m(additional: any) { + const props: any[] = []; + return { props, additional }; +} + +function r(name: string) { + return { ref: name }; +} + +const typeMap: any = { + "TopLevel": o([ + { json: "coding-keys", js: "coding-keys", typ: r("CodingKeys") }, + { json: "name", js: "name", typ: "" }, + ], "any"), + "CodingKeys": o([ + { json: "foo", js: "foo", typ: "" }, + ], "any"), +}; + +module.exports = { + "topLevelToJson": topLevelToJson, + "toTopLevel": toTopLevel, +}; diff --git a/head/schema-golang/test/inputs/schema/coding-keys.schema/default/quicktype.go b/head/schema-golang/test/inputs/schema/coding-keys.schema/default/quicktype.go new file mode 100644 index 0000000..ac1d50a --- /dev/null +++ b/head/schema-golang/test/inputs/schema/coding-keys.schema/default/quicktype.go @@ -0,0 +1,28 @@ +// Code generated from JSON Schema using quicktype. DO NOT EDIT. +// To parse and unparse this JSON data, add this code to your project and do: +// +// topLevel, err := UnmarshalTopLevel(bytes) +// bytes, err = topLevel.Marshal() + +package main + +import "encoding/json" + +func UnmarshalTopLevel(data []byte) (TopLevel, error) { + var r TopLevel + err := json.Unmarshal(data, &r) + return r, err +} + +func (r *TopLevel) Marshal() ([]byte, error) { + return json.Marshal(r) +} + +type TopLevel struct { + CodingKeys CodingKeys `json:"coding-keys"` + Name string `json:"name"` +} + +type CodingKeys struct { + Foo string `json:"foo"` +} diff --git a/head/schema-haskell/test/inputs/schema/coding-keys.schema/default/QuickType.hs b/head/schema-haskell/test/inputs/schema/coding-keys.schema/default/QuickType.hs new file mode 100644 index 0000000..2193dca --- /dev/null +++ b/head/schema-haskell/test/inputs/schema/coding-keys.schema/default/QuickType.hs @@ -0,0 +1,48 @@ +{-# LANGUAGE StrictData #-} +{-# LANGUAGE OverloadedStrings #-} + +module QuickType + ( QuickType (..) + , CodingKeys (..) + , decodeTopLevel + ) where + +import Data.Aeson +import Data.Aeson.Types (emptyObject) +import Data.ByteString.Lazy (ByteString) +import Data.HashMap.Strict (HashMap) +import Data.Text (Text) + +data QuickType = QuickType + { codingKeysQuickType :: CodingKeys + , nameQuickType :: Text + } deriving (Show) + +data CodingKeys = CodingKeys + { fooCodingKeys :: Text + } deriving (Show) + +decodeTopLevel :: ByteString -> Maybe QuickType +decodeTopLevel = decode + +instance ToJSON QuickType where + toJSON (QuickType codingKeysQuickType nameQuickType) = + object + [ "coding-keys" .= codingKeysQuickType + , "name" .= nameQuickType + ] + +instance FromJSON QuickType where + parseJSON (Object v) = QuickType + <$> v .: "coding-keys" + <*> v .: "name" + +instance ToJSON CodingKeys where + toJSON (CodingKeys fooCodingKeys) = + object + [ "foo" .= fooCodingKeys + ] + +instance FromJSON CodingKeys where + parseJSON (Object v) = CodingKeys + <$> v .: "foo" diff --git a/head/schema-java/test/inputs/schema/coding-keys.schema/default/src/main/java/io/quicktype/CodingKeys.java b/head/schema-java/test/inputs/schema/coding-keys.schema/default/src/main/java/io/quicktype/CodingKeys.java new file mode 100644 index 0000000..24f0dea --- /dev/null +++ b/head/schema-java/test/inputs/schema/coding-keys.schema/default/src/main/java/io/quicktype/CodingKeys.java @@ -0,0 +1,12 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; + +public class CodingKeys { + private String foo; + + @JsonProperty("foo") + public String getFoo() { return foo; } + @JsonProperty("foo") + public void setFoo(String value) { this.foo = value; } +} diff --git a/head/schema-java/test/inputs/schema/coding-keys.schema/default/src/main/java/io/quicktype/Converter.java b/head/schema-java/test/inputs/schema/coding-keys.schema/default/src/main/java/io/quicktype/Converter.java new file mode 100644 index 0000000..a8eb236 --- /dev/null +++ b/head/schema-java/test/inputs/schema/coding-keys.schema/default/src/main/java/io/quicktype/Converter.java @@ -0,0 +1,101 @@ +// To use this code, add the following Maven dependency to your project: +// +// +// com.fasterxml.jackson.core : jackson-databind : 2.9.0 +// com.fasterxml.jackson.datatype : jackson-datatype-jsr310 : 2.9.0 +// +// Import this package: +// +// import io.quicktype.Converter; +// +// Then you can deserialize a JSON string with +// +// TopLevel data = Converter.fromJsonString(jsonString); + +package io.quicktype; + +import java.io.IOException; +import com.fasterxml.jackson.databind.*; +import com.fasterxml.jackson.databind.module.SimpleModule; +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.core.JsonProcessingException; +import java.util.*; +import java.time.LocalDate; +import java.time.OffsetDateTime; +import java.time.OffsetTime; +import java.time.ZoneOffset; +import java.time.ZonedDateTime; +import java.time.format.DateTimeFormatter; +import java.time.format.DateTimeFormatterBuilder; +import java.time.temporal.ChronoField; + +public class Converter { + // Date-time helpers + + private static final DateTimeFormatter DATE_TIME_FORMATTER = new DateTimeFormatterBuilder() + .appendOptional(DateTimeFormatter.ISO_DATE_TIME) + .appendOptional(DateTimeFormatter.ISO_OFFSET_DATE_TIME) + .appendOptional(DateTimeFormatter.ISO_INSTANT) + .appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SX")) + .appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ssX")) + .appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")) + .toFormatter() + .withZone(ZoneOffset.UTC); + + public static OffsetDateTime parseDateTimeString(String str) { + return ZonedDateTime.from(Converter.DATE_TIME_FORMATTER.parse(str)).toOffsetDateTime(); + } + + private static final DateTimeFormatter TIME_FORMATTER = new DateTimeFormatterBuilder() + .appendOptional(DateTimeFormatter.ISO_TIME) + .appendOptional(DateTimeFormatter.ISO_OFFSET_TIME) + .parseDefaulting(ChronoField.YEAR, 2020) + .parseDefaulting(ChronoField.MONTH_OF_YEAR, 1) + .parseDefaulting(ChronoField.DAY_OF_MONTH, 1) + .toFormatter() + .withZone(ZoneOffset.UTC); + + public static OffsetTime parseTimeString(String str) { + return ZonedDateTime.from(Converter.TIME_FORMATTER.parse(str)).toOffsetDateTime().toOffsetTime(); + } + // Serialize/deserialize helpers + + public static TopLevel fromJsonString(String json) throws IOException { + return getObjectReader().readValue(json); + } + + public static String toJsonString(TopLevel obj) throws JsonProcessingException { + return getObjectWriter().writeValueAsString(obj); + } + + private static ObjectReader reader; + private static ObjectWriter writer; + + private static void instantiateMapper() { + ObjectMapper mapper = new ObjectMapper(); + mapper.findAndRegisterModules(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false); + SimpleModule module = new SimpleModule(); + module.addDeserializer(OffsetDateTime.class, new JsonDeserializer() { + @Override + public OffsetDateTime deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException { + String value = jsonParser.getText(); + return Converter.parseDateTimeString(value); + } + }); + mapper.registerModule(module); + reader = mapper.readerFor(TopLevel.class); + writer = mapper.writerFor(TopLevel.class); + } + + private static ObjectReader getObjectReader() { + if (reader == null) instantiateMapper(); + return reader; + } + + private static ObjectWriter getObjectWriter() { + if (writer == null) instantiateMapper(); + return writer; + } +} diff --git a/head/schema-java/test/inputs/schema/coding-keys.schema/default/src/main/java/io/quicktype/TopLevel.java b/head/schema-java/test/inputs/schema/coding-keys.schema/default/src/main/java/io/quicktype/TopLevel.java new file mode 100644 index 0000000..1dc0812 --- /dev/null +++ b/head/schema-java/test/inputs/schema/coding-keys.schema/default/src/main/java/io/quicktype/TopLevel.java @@ -0,0 +1,18 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; + +public class TopLevel { + private CodingKeys codingKeys; + private String name; + + @JsonProperty("coding-keys") + public CodingKeys getCodingKeys() { return codingKeys; } + @JsonProperty("coding-keys") + public void setCodingKeys(CodingKeys value) { this.codingKeys = value; } + + @JsonProperty("name") + public String getName() { return name; } + @JsonProperty("name") + public void setName(String value) { this.name = value; } +} diff --git a/head/schema-java-datetime-legacy/test/inputs/schema/coding-keys.schema/default/src/main/java/io/quicktype/CodingKeys.java b/head/schema-java-datetime-legacy/test/inputs/schema/coding-keys.schema/default/src/main/java/io/quicktype/CodingKeys.java new file mode 100644 index 0000000..24f0dea --- /dev/null +++ b/head/schema-java-datetime-legacy/test/inputs/schema/coding-keys.schema/default/src/main/java/io/quicktype/CodingKeys.java @@ -0,0 +1,12 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; + +public class CodingKeys { + private String foo; + + @JsonProperty("foo") + public String getFoo() { return foo; } + @JsonProperty("foo") + public void setFoo(String value) { this.foo = value; } +} diff --git a/head/schema-java-datetime-legacy/test/inputs/schema/coding-keys.schema/default/src/main/java/io/quicktype/Converter.java b/head/schema-java-datetime-legacy/test/inputs/schema/coding-keys.schema/default/src/main/java/io/quicktype/Converter.java new file mode 100644 index 0000000..7d4811b --- /dev/null +++ b/head/schema-java-datetime-legacy/test/inputs/schema/coding-keys.schema/default/src/main/java/io/quicktype/Converter.java @@ -0,0 +1,121 @@ +// To use this code, add the following Maven dependency to your project: +// +// +// com.fasterxml.jackson.core : jackson-databind : 2.9.0 +// +// +// Import this package: +// +// import io.quicktype.Converter; +// +// Then you can deserialize a JSON string with +// +// TopLevel data = Converter.fromJsonString(jsonString); + +package io.quicktype; + +import java.io.IOException; +import com.fasterxml.jackson.databind.*; +import com.fasterxml.jackson.databind.module.SimpleModule; +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.core.JsonProcessingException; +import java.util.*; +import java.util.Date; +import java.text.SimpleDateFormat; + +public class Converter { + // Date-time helpers + + private static final String[] DATE_TIME_FORMATS = { + "yyyy-MM-dd'T'HH:mm:ss.SX", + "yyyy-MM-dd'T'HH:mm:ss.S", + "yyyy-MM-dd'T'HH:mm:ssX", + "yyyy-MM-dd'T'HH:mm:ss", + "yyyy-MM-dd HH:mm:ss.SX", + "yyyy-MM-dd HH:mm:ss.S", + "yyyy-MM-dd HH:mm:ssX", + "yyyy-MM-dd HH:mm:ss", + "HH:mm:ss.SZ", + "HH:mm:ss.S", + "HH:mm:ssZ", + "HH:mm:ss", + "yyyy-MM-dd", + }; + + public static Date parseAllDateTimeString(String str) { + for (String format : DATE_TIME_FORMATS) { + try { + return new SimpleDateFormat(format).parse(str); + } catch (Exception ex) { + // Ignored + } + } + return null; + } + + public static String serializeDateTime(Date datetime) { + return new SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ssZ").format(datetime); + } + + public static String serializeDate(Date datetime) { + return new SimpleDateFormat("yyyy-MM-dd").format(datetime); + } + + public static String serializeTime(Date datetime) { + return new SimpleDateFormat("hh:mm:ssZ").format(datetime); + } + // Serialize/deserialize helpers + + public static TopLevel fromJsonString(String json) throws IOException { + return getObjectReader().readValue(json); + } + + public static String toJsonString(TopLevel obj) throws JsonProcessingException { + return getObjectWriter().writeValueAsString(obj); + } + + private static ObjectReader reader; + private static ObjectWriter writer; + + private static void instantiateMapper() { + ObjectMapper mapper = new ObjectMapper(); + mapper.findAndRegisterModules(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false); + SimpleModule module = new SimpleModule(); + module.addDeserializer(Date.class, new JsonDeserializer() { + @Override + public Date deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException { + String value = jsonParser.getText(); + return Converter.parseAllDateTimeString(value); + } + }); + module.addDeserializer(Date.class, new JsonDeserializer() { + @Override + public Date deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException { + String value = jsonParser.getText(); + return Converter.parseAllDateTimeString(value); + } + }); + module.addDeserializer(Date.class, new JsonDeserializer() { + @Override + public Date deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException { + String value = jsonParser.getText(); + return Converter.parseAllDateTimeString(value); + } + }); + mapper.registerModule(module); + reader = mapper.readerFor(TopLevel.class); + writer = mapper.writerFor(TopLevel.class); + } + + private static ObjectReader getObjectReader() { + if (reader == null) instantiateMapper(); + return reader; + } + + private static ObjectWriter getObjectWriter() { + if (writer == null) instantiateMapper(); + return writer; + } +} diff --git a/head/schema-java-datetime-legacy/test/inputs/schema/coding-keys.schema/default/src/main/java/io/quicktype/TopLevel.java b/head/schema-java-datetime-legacy/test/inputs/schema/coding-keys.schema/default/src/main/java/io/quicktype/TopLevel.java new file mode 100644 index 0000000..1dc0812 --- /dev/null +++ b/head/schema-java-datetime-legacy/test/inputs/schema/coding-keys.schema/default/src/main/java/io/quicktype/TopLevel.java @@ -0,0 +1,18 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; + +public class TopLevel { + private CodingKeys codingKeys; + private String name; + + @JsonProperty("coding-keys") + public CodingKeys getCodingKeys() { return codingKeys; } + @JsonProperty("coding-keys") + public void setCodingKeys(CodingKeys value) { this.codingKeys = value; } + + @JsonProperty("name") + public String getName() { return name; } + @JsonProperty("name") + public void setName(String value) { this.name = value; } +} diff --git a/head/schema-java-lombok/test/inputs/schema/coding-keys.schema/default/src/main/java/io/quicktype/CodingKeys.java b/head/schema-java-lombok/test/inputs/schema/coding-keys.schema/default/src/main/java/io/quicktype/CodingKeys.java new file mode 100644 index 0000000..24f0dea --- /dev/null +++ b/head/schema-java-lombok/test/inputs/schema/coding-keys.schema/default/src/main/java/io/quicktype/CodingKeys.java @@ -0,0 +1,12 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; + +public class CodingKeys { + private String foo; + + @JsonProperty("foo") + public String getFoo() { return foo; } + @JsonProperty("foo") + public void setFoo(String value) { this.foo = value; } +} diff --git a/head/schema-java-lombok/test/inputs/schema/coding-keys.schema/default/src/main/java/io/quicktype/Converter.java b/head/schema-java-lombok/test/inputs/schema/coding-keys.schema/default/src/main/java/io/quicktype/Converter.java new file mode 100644 index 0000000..a8eb236 --- /dev/null +++ b/head/schema-java-lombok/test/inputs/schema/coding-keys.schema/default/src/main/java/io/quicktype/Converter.java @@ -0,0 +1,101 @@ +// To use this code, add the following Maven dependency to your project: +// +// +// com.fasterxml.jackson.core : jackson-databind : 2.9.0 +// com.fasterxml.jackson.datatype : jackson-datatype-jsr310 : 2.9.0 +// +// Import this package: +// +// import io.quicktype.Converter; +// +// Then you can deserialize a JSON string with +// +// TopLevel data = Converter.fromJsonString(jsonString); + +package io.quicktype; + +import java.io.IOException; +import com.fasterxml.jackson.databind.*; +import com.fasterxml.jackson.databind.module.SimpleModule; +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.core.JsonProcessingException; +import java.util.*; +import java.time.LocalDate; +import java.time.OffsetDateTime; +import java.time.OffsetTime; +import java.time.ZoneOffset; +import java.time.ZonedDateTime; +import java.time.format.DateTimeFormatter; +import java.time.format.DateTimeFormatterBuilder; +import java.time.temporal.ChronoField; + +public class Converter { + // Date-time helpers + + private static final DateTimeFormatter DATE_TIME_FORMATTER = new DateTimeFormatterBuilder() + .appendOptional(DateTimeFormatter.ISO_DATE_TIME) + .appendOptional(DateTimeFormatter.ISO_OFFSET_DATE_TIME) + .appendOptional(DateTimeFormatter.ISO_INSTANT) + .appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SX")) + .appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ssX")) + .appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")) + .toFormatter() + .withZone(ZoneOffset.UTC); + + public static OffsetDateTime parseDateTimeString(String str) { + return ZonedDateTime.from(Converter.DATE_TIME_FORMATTER.parse(str)).toOffsetDateTime(); + } + + private static final DateTimeFormatter TIME_FORMATTER = new DateTimeFormatterBuilder() + .appendOptional(DateTimeFormatter.ISO_TIME) + .appendOptional(DateTimeFormatter.ISO_OFFSET_TIME) + .parseDefaulting(ChronoField.YEAR, 2020) + .parseDefaulting(ChronoField.MONTH_OF_YEAR, 1) + .parseDefaulting(ChronoField.DAY_OF_MONTH, 1) + .toFormatter() + .withZone(ZoneOffset.UTC); + + public static OffsetTime parseTimeString(String str) { + return ZonedDateTime.from(Converter.TIME_FORMATTER.parse(str)).toOffsetDateTime().toOffsetTime(); + } + // Serialize/deserialize helpers + + public static TopLevel fromJsonString(String json) throws IOException { + return getObjectReader().readValue(json); + } + + public static String toJsonString(TopLevel obj) throws JsonProcessingException { + return getObjectWriter().writeValueAsString(obj); + } + + private static ObjectReader reader; + private static ObjectWriter writer; + + private static void instantiateMapper() { + ObjectMapper mapper = new ObjectMapper(); + mapper.findAndRegisterModules(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false); + SimpleModule module = new SimpleModule(); + module.addDeserializer(OffsetDateTime.class, new JsonDeserializer() { + @Override + public OffsetDateTime deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException { + String value = jsonParser.getText(); + return Converter.parseDateTimeString(value); + } + }); + mapper.registerModule(module); + reader = mapper.readerFor(TopLevel.class); + writer = mapper.writerFor(TopLevel.class); + } + + private static ObjectReader getObjectReader() { + if (reader == null) instantiateMapper(); + return reader; + } + + private static ObjectWriter getObjectWriter() { + if (writer == null) instantiateMapper(); + return writer; + } +} diff --git a/head/schema-java-lombok/test/inputs/schema/coding-keys.schema/default/src/main/java/io/quicktype/TopLevel.java b/head/schema-java-lombok/test/inputs/schema/coding-keys.schema/default/src/main/java/io/quicktype/TopLevel.java new file mode 100644 index 0000000..1dc0812 --- /dev/null +++ b/head/schema-java-lombok/test/inputs/schema/coding-keys.schema/default/src/main/java/io/quicktype/TopLevel.java @@ -0,0 +1,18 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; + +public class TopLevel { + private CodingKeys codingKeys; + private String name; + + @JsonProperty("coding-keys") + public CodingKeys getCodingKeys() { return codingKeys; } + @JsonProperty("coding-keys") + public void setCodingKeys(CodingKeys value) { this.codingKeys = value; } + + @JsonProperty("name") + public String getName() { return name; } + @JsonProperty("name") + public void setName(String value) { this.name = value; } +} diff --git a/head/schema-javascript/test/inputs/schema/coding-keys.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/coding-keys.schema/default/TopLevel.js new file mode 100644 index 0000000..bedff30 --- /dev/null +++ b/head/schema-javascript/test/inputs/schema/coding-keys.schema/default/TopLevel.js @@ -0,0 +1,186 @@ +// To parse this data: +// +// const Convert = require("./TopLevel"); +// +// const topLevel = Convert.toTopLevel(json); +// +// These functions will throw an error if the JSON doesn't +// match the expected interface, even if the JSON is valid. + +// Converts JSON strings to/from your types +// and asserts the results of JSON.parse at runtime +function toTopLevel(json) { + return cast(JSON.parse(json), r("TopLevel")); +} + +function topLevelToJson(value) { + return JSON.stringify(uncast(value, r("TopLevel")), null, 2); +} + +function invalidValue(typ, val, key, parent = '') { + const prettyTyp = prettyTypeName(typ); + const parentText = parent ? ` on ${parent}` : ''; + const keyText = key ? ` for key "${key}"` : ''; + throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`); +} + +function prettyTypeName(typ) { + if (Array.isArray(typ)) { + if (typ.length === 2 && typ[0] === undefined) { + return `an optional ${prettyTypeName(typ[1])}`; + } else { + return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`; + } + } else if (typeof typ === "object" && typ.literal !== undefined) { + return typ.literal; + } else { + return typeof typ; + } +} + +function jsonToJSProps(typ) { + if (typ.jsonToJS === undefined) { + const map = {}; + typ.props.forEach((p) => map[p.json] = { key: p.js, typ: p.typ }); + typ.jsonToJS = map; + } + return typ.jsonToJS; +} + +function jsToJSONProps(typ) { + if (typ.jsToJSON === undefined) { + const map = {}; + typ.props.forEach((p) => map[p.js] = { key: p.json, typ: p.typ }); + typ.jsToJSON = map; + } + return typ.jsToJSON; +} + +function transform(val, typ, getProps, key = '', parent = '') { + function transformPrimitive(typ, val) { + if (typeof typ === typeof val) return val; + return invalidValue(typ, val, key, parent); + } + + function transformUnion(typs, val) { + // val must validate against one typ in typs + const l = typs.length; + for (let i = 0; i < l; i++) { + const typ = typs[i]; + try { + return transform(val, typ, getProps); + } catch (_) {} + } + return invalidValue(typs, val, key, parent); + } + + function transformEnum(cases, val) { + if (cases.indexOf(val) !== -1) return val; + return invalidValue(cases.map(a => { return l(a); }), val, key, parent); + } + + function transformArray(typ, val) { + // val must be an array with no invalid elements + if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent); + return val.map(el => transform(el, typ, getProps)); + } + + function transformDate(val) { + if (val === null) { + return null; + } + const d = new Date(val); + if (isNaN(d.valueOf())) { + return invalidValue(l("Date"), val, key, parent); + } + return d; + } + + function transformObject(props, additional, val) { + if (val === null || typeof val !== "object" || Array.isArray(val)) { + return invalidValue(l(ref || "object"), val, key, parent); + } + const result = {}; + Object.getOwnPropertyNames(props).forEach(key => { + const prop = props[key]; + const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined; + result[prop.key] = transform(v, prop.typ, getProps, key, ref); + }); + Object.getOwnPropertyNames(val).forEach(key => { + if (!Object.prototype.hasOwnProperty.call(props, key)) { + result[key] = transform(val[key], additional, getProps, key, ref); + } + }); + return result; + } + + if (typ === "any") return val; + if (typ === null) { + if (val === null) return val; + return invalidValue(typ, val, key, parent); + } + if (typ === false) return invalidValue(typ, val, key, parent); + let ref = undefined; + while (typeof typ === "object" && typ.ref !== undefined) { + ref = typ.ref; + typ = typeMap[typ.ref]; + } + if (Array.isArray(typ)) return transformEnum(typ, val); + if (typeof typ === "object") { + return typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) + : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val) + : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val) + : invalidValue(typ, val, key, parent); + } + // Numbers can be parsed by Date but shouldn't be. + if (typ === Date && typeof val !== "number") return transformDate(val); + return transformPrimitive(typ, val); +} + +function cast(val, typ) { + return transform(val, typ, jsonToJSProps); +} + +function uncast(val, typ) { + return transform(val, typ, jsToJSONProps); +} + +function l(typ) { + return { literal: typ }; +} + +function a(typ) { + return { arrayItems: typ }; +} + +function u(...typs) { + return { unionMembers: typs }; +} + +function o(props, additional) { + return { props, additional }; +} + +function m(additional) { + const props = []; + return { props, additional }; +} + +function r(name) { + return { ref: name }; +} + +const typeMap = { + "TopLevel": o([ + { json: "coding-keys", js: "coding-keys", typ: r("CodingKeys") }, + { json: "name", js: "name", typ: "" }, + ], "any"), + "CodingKeys": o([ + { json: "foo", js: "foo", typ: "" }, + ], "any"), +}; + +module.exports = { + "topLevelToJson": topLevelToJson, + "toTopLevel": toTopLevel, +}; diff --git a/head/schema-kotlin/test/inputs/schema/coding-keys.schema/default/TopLevel.kt b/head/schema-kotlin/test/inputs/schema/coding-keys.schema/default/TopLevel.kt new file mode 100644 index 0000000..0944513 --- /dev/null +++ b/head/schema-kotlin/test/inputs/schema/coding-keys.schema/default/TopLevel.kt @@ -0,0 +1,26 @@ +// To parse the JSON, install Klaxon and do: +// +// val topLevel = TopLevel.fromJson(jsonString) + +package quicktype + +import com.beust.klaxon.* + +private val klaxon = Klaxon() + +data class TopLevel ( + @Json(name = "coding-keys") + val codingKeys: CodingKeys, + + val name: String +) { + public fun toJson() = klaxon.toJsonString(this) + + companion object { + public fun fromJson(json: String) = klaxon.parse(json) + } +} + +data class CodingKeys ( + val foo: String +) diff --git a/head/schema-kotlin-jackson/test/inputs/schema/coding-keys.schema/default/TopLevel.kt b/head/schema-kotlin-jackson/test/inputs/schema/coding-keys.schema/default/TopLevel.kt new file mode 100644 index 0000000..6b25614 --- /dev/null +++ b/head/schema-kotlin-jackson/test/inputs/schema/coding-keys.schema/default/TopLevel.kt @@ -0,0 +1,38 @@ +// To parse the JSON, install jackson-module-kotlin and do: +// +// val topLevel = TopLevel.fromJson(jsonString) + +package quicktype + +import com.fasterxml.jackson.annotation.* +import com.fasterxml.jackson.core.* +import com.fasterxml.jackson.databind.* +import com.fasterxml.jackson.databind.deser.std.StdDeserializer +import com.fasterxml.jackson.databind.module.SimpleModule +import com.fasterxml.jackson.databind.node.* +import com.fasterxml.jackson.databind.ser.std.StdSerializer +import com.fasterxml.jackson.module.kotlin.* + +val mapper = jacksonObjectMapper().apply { + propertyNamingStrategy = PropertyNamingStrategy.LOWER_CAMEL_CASE + setSerializationInclusion(JsonInclude.Include.NON_NULL) +} + +data class TopLevel ( + @get:JsonProperty("coding-keys", required=true)@field:JsonProperty("coding-keys", required=true) + val codingKeys: CodingKeys, + + @get:JsonProperty(required=true)@field:JsonProperty(required=true) + val name: String +) { + fun toJson() = mapper.writeValueAsString(this) + + companion object { + fun fromJson(json: String) = mapper.readValue(json) + } +} + +data class CodingKeys ( + @get:JsonProperty(required=true)@field:JsonProperty(required=true) + val foo: String +) diff --git a/head/schema-kotlinx/test/inputs/schema/coding-keys.schema/default/TopLevel.kt b/head/schema-kotlinx/test/inputs/schema/coding-keys.schema/default/TopLevel.kt new file mode 100644 index 0000000..ffe0fc4 --- /dev/null +++ b/head/schema-kotlinx/test/inputs/schema/coding-keys.schema/default/TopLevel.kt @@ -0,0 +1,24 @@ +// To parse the JSON, install kotlin's serialization plugin and do: +// +// val json = Json { allowStructuredMapKeys = true } +// val topLevel = json.parse(TopLevel.serializer(), jsonString) + +package quicktype + +import kotlinx.serialization.* +import kotlinx.serialization.json.* +import kotlinx.serialization.descriptors.* +import kotlinx.serialization.encoding.* + +@Serializable +data class TopLevel ( + @SerialName("coding-keys") + val codingKeys: CodingKeys, + + val name: String +) + +@Serializable +data class CodingKeys ( + val foo: String +) diff --git a/head/schema-php/test/inputs/schema/coding-keys.schema/default/TopLevel.php b/head/schema-php/test/inputs/schema/coding-keys.schema/default/TopLevel.php new file mode 100644 index 0000000..a4d1c5d --- /dev/null +++ b/head/schema-php/test/inputs/schema/coding-keys.schema/default/TopLevel.php @@ -0,0 +1,253 @@ +codingKeys = $codingKeys; + $this->name = $name; + } + + /** + * @param stdClass $value + * @throws Exception + * @return CodingKeys + */ + public static function fromCodingKeys(stdClass $value): CodingKeys { + return CodingKeys::from($value); /*class*/ + } + + /** + * @throws Exception + * @return stdClass + */ + public function toCodingKeys(): stdClass { + if (TopLevel::validateCodingKeys($this->codingKeys)) { + return $this->codingKeys->to(); /*class*/ + } + throw new Exception('never get to this TopLevel::codingKeys'); + } + + /** + * @param CodingKeys + * @return bool + * @throws Exception + */ + public static function validateCodingKeys(CodingKeys $value): bool { + $value->validate(); + return true; + } + + /** + * @throws Exception + * @return CodingKeys + */ + public function getCodingKeys(): CodingKeys { + if (TopLevel::validateCodingKeys($this->codingKeys)) { + return $this->codingKeys; + } + throw new Exception('never get to getCodingKeys TopLevel::codingKeys'); + } + + /** + * @return CodingKeys + */ + public static function sampleCodingKeys(): CodingKeys { + return CodingKeys::sample(); /*31:codingKeys*/ + } + + /** + * @param string $value + * @throws Exception + * @return string + */ + public static function fromName(string $value): string { + return $value; /*string*/ + } + + /** + * @throws Exception + * @return string + */ + public function toName(): string { + if (TopLevel::validateName($this->name)) { + return $this->name; /*string*/ + } + throw new Exception('never get to this TopLevel::name'); + } + + /** + * @param string + * @return bool + * @throws Exception + */ + public static function validateName(string $value): bool { + return true; + } + + /** + * @throws Exception + * @return string + */ + public function getName(): string { + if (TopLevel::validateName($this->name)) { + return $this->name; + } + throw new Exception('never get to getName TopLevel::name'); + } + + /** + * @return string + */ + public static function sampleName(): string { + return 'TopLevel::name::32'; /*32:name*/ + } + + /** + * @throws Exception + * @return bool + */ + public function validate(): bool { + return TopLevel::validateCodingKeys($this->codingKeys) + || TopLevel::validateName($this->name); + } + + /** + * @return stdClass + * @throws Exception + */ + public function to(): stdClass { + $out = new stdClass(); + $out->{'coding-keys'} = $this->toCodingKeys(); + $out->{'name'} = $this->toName(); + return $out; + } + + /** + * @param stdClass $obj + * @return TopLevel + * @throws Exception + */ + public static function from(stdClass $obj): TopLevel { + return new TopLevel( + TopLevel::fromCodingKeys($obj->{'coding-keys'}) + ,TopLevel::fromName($obj->{'name'}) + ); + } + + /** + * @return TopLevel + */ + public static function sample(): TopLevel { + return new TopLevel( + TopLevel::sampleCodingKeys() + ,TopLevel::sampleName() + ); + } +} + +// This is an autogenerated file:CodingKeys + +class CodingKeys { + private string $foo; // json:foo Required + + /** + * @param string $foo + */ + public function __construct(string $foo) { + $this->foo = $foo; + } + + /** + * @param string $value + * @throws Exception + * @return string + */ + public static function fromFoo(string $value): string { + return $value; /*string*/ + } + + /** + * @throws Exception + * @return string + */ + public function toFoo(): string { + if (CodingKeys::validateFoo($this->foo)) { + return $this->foo; /*string*/ + } + throw new Exception('never get to this CodingKeys::foo'); + } + + /** + * @param string + * @return bool + * @throws Exception + */ + public static function validateFoo(string $value): bool { + return true; + } + + /** + * @throws Exception + * @return string + */ + public function getFoo(): string { + if (CodingKeys::validateFoo($this->foo)) { + return $this->foo; + } + throw new Exception('never get to getFoo CodingKeys::foo'); + } + + /** + * @return string + */ + public static function sampleFoo(): string { + return 'CodingKeys::foo::31'; /*31:foo*/ + } + + /** + * @throws Exception + * @return bool + */ + public function validate(): bool { + return CodingKeys::validateFoo($this->foo); + } + + /** + * @return stdClass + * @throws Exception + */ + public function to(): stdClass { + $out = new stdClass(); + $out->{'foo'} = $this->toFoo(); + return $out; + } + + /** + * @param stdClass $obj + * @return CodingKeys + * @throws Exception + */ + public static function from(stdClass $obj): CodingKeys { + return new CodingKeys( + CodingKeys::fromFoo($obj->{'foo'}) + ); + } + + /** + * @return CodingKeys + */ + public static function sample(): CodingKeys { + return new CodingKeys( + CodingKeys::sampleFoo() + ); + } +} diff --git a/head/schema-pike/test/inputs/schema/coding-keys.schema/default/TopLevel.pmod b/head/schema-pike/test/inputs/schema/coding-keys.schema/default/TopLevel.pmod new file mode 100644 index 0000000..36cb5a5 --- /dev/null +++ b/head/schema-pike/test/inputs/schema/coding-keys.schema/default/TopLevel.pmod @@ -0,0 +1,56 @@ +// This source has been automatically generated by quicktype. +// ( https://github.com/quicktype/quicktype ) +// +// To use this code, simply import it into your project as a Pike module. +// To JSON-encode your object, you can pass it to `Standards.JSON.encode` +// or call `encode_json` on it. +// +// To decode a JSON string, first pass it to `Standards.JSON.decode`, +// and then pass the result to `_from_JSON`. +// It will return an instance of . +// Bear in mind that these functions have unexpected behavior, +// and will likely throw an error, if the JSON string does not +// match the expected interface, even if the JSON itself is valid. + +class TopLevel { + CodingKeys coding_keys; // json: "coding-keys" + string name; // json: "name" + + string encode_json() { + mapping(string:mixed) json = ([ + "coding-keys" : coding_keys, + "name" : name, + ]); + + return Standards.JSON.encode(json); + } +} + +TopLevel TopLevel_from_JSON(mixed json) { + TopLevel retval = TopLevel(); + + retval.coding_keys = json["coding-keys"]; + retval.name = json["name"]; + + return retval; +} + +class CodingKeys { + string foo; // json: "foo" + + string encode_json() { + mapping(string:mixed) json = ([ + "foo" : foo, + ]); + + return Standards.JSON.encode(json); + } +} + +CodingKeys CodingKeys_from_JSON(mixed json) { + CodingKeys retval = CodingKeys(); + + retval.foo = json["foo"]; + + return retval; +} diff --git a/head/schema-python/test/inputs/schema/coding-keys.schema/default/quicktype.py b/head/schema-python/test/inputs/schema/coding-keys.schema/default/quicktype.py new file mode 100644 index 0000000..54f2bbb --- /dev/null +++ b/head/schema-python/test/inputs/schema/coding-keys.schema/default/quicktype.py @@ -0,0 +1,58 @@ +from dataclasses import dataclass +from typing import Any, TypeVar, Type, cast + + +T = TypeVar("T") + + +def from_str(x: Any) -> str: + assert isinstance(x, str) + return x + + +def to_class(c: Type[T], x: Any) -> dict: + assert isinstance(x, c) + return cast(Any, x).to_dict() + + +@dataclass +class CodingKeys: + foo: str + + @staticmethod + def from_dict(obj: Any) -> 'CodingKeys': + assert isinstance(obj, dict) + foo = from_str(obj.get("foo")) + return CodingKeys(foo) + + def to_dict(self) -> dict: + result: dict = {} + result["foo"] = from_str(self.foo) + return result + + +@dataclass +class TopLevel: + coding_keys: CodingKeys + name: str + + @staticmethod + def from_dict(obj: Any) -> 'TopLevel': + assert isinstance(obj, dict) + coding_keys = CodingKeys.from_dict(obj.get("coding-keys")) + name = from_str(obj.get("name")) + return TopLevel(coding_keys, name) + + def to_dict(self) -> dict: + result: dict = {} + result["coding-keys"] = to_class(CodingKeys, self.coding_keys) + result["name"] = from_str(self.name) + return result + + +def top_level_from_dict(s: Any) -> TopLevel: + return TopLevel.from_dict(s) + + +def top_level_to_dict(x: TopLevel) -> Any: + return to_class(TopLevel, x) diff --git a/head/schema-ruby/test/inputs/schema/coding-keys.schema/default/TopLevel.rb b/head/schema-ruby/test/inputs/schema/coding-keys.schema/default/TopLevel.rb new file mode 100644 index 0000000..6e66576 --- /dev/null +++ b/head/schema-ruby/test/inputs/schema/coding-keys.schema/default/TopLevel.rb @@ -0,0 +1,73 @@ +# This code may look unusually verbose for Ruby (and it is), but +# it performs some subtle and complex validation of JSON data. +# +# To parse this JSON, add 'dry-struct' and 'dry-types' gems, then do: +# +# top_level = TopLevel.from_json! "{…}" +# puts top_level.coding_keys.foo +# +# If from_json! succeeds, the value returned matches the schema. + +require 'json' +require 'dry-types' +require 'dry-struct' + +module Types + include Dry.Types(default: :nominal) + + Hash = Strict::Hash + String = Strict::String +end + +class CodingKeys < Dry::Struct + attribute :foo, Types::String + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + foo: d.fetch("foo"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "foo" => foo, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class TopLevel < Dry::Struct + attribute :coding_keys, CodingKeys + attribute :top_level_name, Types::String + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + coding_keys: CodingKeys.from_dynamic!(d.fetch("coding-keys")), + top_level_name: d.fetch("name"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "coding-keys" => coding_keys.to_dynamic, + "name" => top_level_name, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end diff --git a/head/schema-rust/test/inputs/schema/coding-keys.schema/default/module_under_test.rs b/head/schema-rust/test/inputs/schema/coding-keys.schema/default/module_under_test.rs new file mode 100644 index 0000000..9a1bb77 --- /dev/null +++ b/head/schema-rust/test/inputs/schema/coding-keys.schema/default/module_under_test.rs @@ -0,0 +1,27 @@ +// Example code that deserializes and serializes the model. +// extern crate serde; +// #[macro_use] +// extern crate serde_derive; +// extern crate serde_json; +// +// use generated_module::TopLevel; +// +// fn main() { +// let json = r#"{"answer": 42}"#; +// let model: TopLevel = serde_json::from_str(&json).unwrap(); +// } + +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "kebab-case")] +pub struct TopLevel { + pub coding_keys: CodingKeys, + + pub name: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct CodingKeys { + pub foo: String, +} diff --git a/head/schema-scala3/test/inputs/schema/coding-keys.schema/default/TopLevel.scala b/head/schema-scala3/test/inputs/schema/coding-keys.schema/default/TopLevel.scala new file mode 100644 index 0000000..947d2f7 --- /dev/null +++ b/head/schema-scala3/test/inputs/schema/coding-keys.schema/default/TopLevel.scala @@ -0,0 +1,17 @@ +package quicktype + +import io.circe.syntax._ +import io.circe._ +import cats.syntax.functor._ + +// If a union has a null in, then we'll need this too... +type NullValue = None.type + +case class TopLevel ( + val `coding-keys` : CodingKeys, + val name : String +) derives Encoder.AsObject, Decoder + +case class CodingKeys ( + val foo : String +) derives Encoder.AsObject, Decoder diff --git a/head/schema-scala3-upickle/test/inputs/schema/coding-keys.schema/default/TopLevel.scala b/head/schema-scala3-upickle/test/inputs/schema/coding-keys.schema/default/TopLevel.scala new file mode 100644 index 0000000..559ce3a --- /dev/null +++ b/head/schema-scala3-upickle/test/inputs/schema/coding-keys.schema/default/TopLevel.scala @@ -0,0 +1,75 @@ +package quicktype + +// Custom pickler so that missing keys and JSON nulls both read as None, +// and None is left out when writing (upickle's default for Option is a +// JSON array). +object OptionPickler extends upickle.AttributeTagged: + import upickle.default.Writer + import upickle.default.Reader + override implicit def OptionWriter[T: Writer]: Writer[Option[T]] = + implicitly[Writer[T]].comap[Option[T]] { + case None => null.asInstanceOf[T] + case Some(x) => x + } + + override implicit def OptionReader[T: Reader]: Reader[Option[T]] = { + new Reader.Delegate[Any, Option[T]](implicitly[Reader[T]].map(Some(_))){ + override def visitNull(index: Int) = None + } + } +end OptionPickler + +// If a union has a null in, then we'll need this too... +type NullValue = None.type +given OptionPickler.ReadWriter[NullValue] = OptionPickler.readwriter[ujson.Value].bimap[NullValue]( + _ => ujson.Null, + json => if json.isNull then None else throw new upickle.core.Abort("not null") +) + +object JsonExt: + val valueReader = OptionPickler.readwriter[ujson.Value] + + // upickle's built-in primitive readers are lenient -- the numeric and + // boolean readers accept strings, and the string reader accepts + // numbers and booleans -- so untagged unions need strict readers to + // pick the right member. + val strictString: OptionPickler.Reader[String] = valueReader.map { + case ujson.Str(s) => s + case json => throw new upickle.core.Abort("expected string, got " + json) + } + val strictLong: OptionPickler.Reader[Long] = valueReader.map { + case ujson.Num(n) if n.isWhole => n.toLong + case json => throw new upickle.core.Abort("expected integer, got " + json) + } + val strictDouble: OptionPickler.Reader[Double] = valueReader.map { + case ujson.Num(n) => n + case json => throw new upickle.core.Abort("expected number, got " + json) + } + val strictBoolean: OptionPickler.Reader[Boolean] = valueReader.map { + case ujson.Bool(b) => b + case json => throw new upickle.core.Abort("expected boolean, got " + json) + } + + def badMerge[T](r1: => OptionPickler.Reader[?], rest: OptionPickler.Reader[?]*): OptionPickler.Reader[T] = valueReader.map { json => + var t: T | Null = null + val stack = Vector.newBuilder[Throwable] + (r1 +: rest).foreach { reader => + if t == null then + try + t = OptionPickler.read[T](json, trace = true)(using reader.asInstanceOf[OptionPickler.Reader[T]]) + catch + case exc => stack += exc + } + if t != null then t.nn else throw new Exception(json.toString(), stack.result().headOption.getOrElse(null)) + } +end JsonExt + + +case class TopLevel ( + val `coding-keys` : CodingKeys, + val name : String +) derives OptionPickler.ReadWriter + +case class CodingKeys ( + val foo : String +) derives OptionPickler.ReadWriter diff --git a/head/schema-schema/test/inputs/schema/coding-keys.schema/default/TopLevel.schema b/head/schema-schema/test/inputs/schema/coding-keys.schema/default/TopLevel.schema new file mode 100644 index 0000000..e1a46ea --- /dev/null +++ b/head/schema-schema/test/inputs/schema/coding-keys.schema/default/TopLevel.schema @@ -0,0 +1,36 @@ +{ + "$schema": "http://json-schema.org/draft-06/schema#", + "$ref": "#/definitions/TopLevel", + "definitions": { + "TopLevel": { + "type": "object", + "additionalProperties": {}, + "properties": { + "coding-keys": { + "$ref": "#/definitions/CodingKeys" + }, + "name": { + "type": "string" + } + }, + "required": [ + "coding-keys", + "name" + ], + "title": "TopLevel" + }, + "CodingKeys": { + "type": "object", + "additionalProperties": {}, + "properties": { + "foo": { + "type": "string" + } + }, + "required": [ + "foo" + ], + "title": "CodingKeys" + } + } +} diff --git a/head/schema-swift/test/inputs/schema/coding-keys.schema/default/quicktype.swift b/head/schema-swift/test/inputs/schema/coding-keys.schema/default/quicktype.swift new file mode 100644 index 0000000..b796f9f --- /dev/null +++ b/head/schema-swift/test/inputs/schema/coding-keys.schema/default/quicktype.swift @@ -0,0 +1,134 @@ +// This file was generated from JSON Schema using quicktype, do not modify it directly. +// To parse the JSON, add this file to your project and do: +// +// let topLevel = try TopLevel(json) + +import Foundation + +// MARK: - TopLevel +struct TopLevel: Codable { + let codingKeys: CodingKeysClass + let name: String + + enum CodingKeys: String, CodingKey { + case codingKeys = "coding-keys" + case name = "name" + } +} + +// MARK: TopLevel convenience initializers and mutators + +extension TopLevel { + init(data: Data) throws { + self = try newJSONDecoder().decode(TopLevel.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + codingKeys: CodingKeysClass? = nil, + name: String? = nil + ) -> TopLevel { + return TopLevel( + codingKeys: codingKeys ?? self.codingKeys, + name: name ?? self.name + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - CodingKeysClass +struct CodingKeysClass: Codable { + let foo: String + + enum CodingKeys: String, CodingKey { + case foo = "foo" + } +} + +// MARK: CodingKeysClass convenience initializers and mutators + +extension CodingKeysClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(CodingKeysClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + foo: String? = nil + ) -> CodingKeysClass { + return CodingKeysClass( + foo: foo ?? self.foo + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - Helper functions for creating encoders and decoders + +func newJSONDecoder() -> JSONDecoder { + let decoder = JSONDecoder() + decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in + let container = try decoder.singleValueContainer() + let dateStr = try container.decode(String.self) + + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date")) + }) + return decoder +} + +func newJSONEncoder() -> JSONEncoder { + let encoder = JSONEncoder() + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder +} diff --git a/head/schema-swift/test/inputs/schema/coding-keys.schema/nest-types-true--d03bdf4b0ab1/quicktype.swift b/head/schema-swift/test/inputs/schema/coding-keys.schema/nest-types-true--d03bdf4b0ab1/quicktype.swift new file mode 100644 index 0000000..3f7a9da --- /dev/null +++ b/head/schema-swift/test/inputs/schema/coding-keys.schema/nest-types-true--d03bdf4b0ab1/quicktype.swift @@ -0,0 +1,130 @@ +// This file was generated from JSON Schema using quicktype, do not modify it directly. +// To parse the JSON, add this file to your project and do: +// +// let topLevel = try TopLevel(json) + +import Foundation + +// MARK: - TopLevel +struct TopLevel: Codable { + let codingKeys: TopLevel.CodingKeysClass + let name: String + + enum CodingKeys: String, CodingKey { + case codingKeys = "coding-keys" + case name = "name" + } + + struct CodingKeysClass: Codable { + let foo: String + + enum CodingKeys: String, CodingKey { + case foo = "foo" + } + } + + // MARK: Helper functions for creating encoders and decoders + static func newJSONDecoder() -> JSONDecoder { + let decoder = JSONDecoder() + decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in + let container = try decoder.singleValueContainer() + let dateStr = try container.decode(String.self) + + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date")) + }) + return decoder + } + + static func newJSONEncoder() -> JSONEncoder { + let encoder = JSONEncoder() + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder + } +} + +// MARK: TopLevel convenience initializers and mutators + +extension TopLevel { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + codingKeys: TopLevel.CodingKeysClass? = nil, + name: String? = nil + ) -> TopLevel { + return TopLevel( + codingKeys: codingKeys ?? self.codingKeys, + name: name ?? self.name + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.CodingKeysClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.CodingKeysClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + foo: String? = nil + ) -> TopLevel.CodingKeysClass { + return TopLevel.CodingKeysClass( + foo: foo ?? self.foo + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} diff --git a/head/schema-typescript/test/inputs/schema/coding-keys.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/coding-keys.schema/default/TopLevel.ts new file mode 100644 index 0000000..25656f1 --- /dev/null +++ b/head/schema-typescript/test/inputs/schema/coding-keys.schema/default/TopLevel.ts @@ -0,0 +1,194 @@ +// To parse this data: +// +// import { Convert, TopLevel } from "./TopLevel"; +// +// const topLevel = Convert.toTopLevel(json); +// +// These functions will throw an error if the JSON doesn't +// match the expected interface, even if the JSON is valid. + +export interface TopLevel { + "coding-keys": CodingKeys; + name: string; + [property: string]: unknown; +} + +export interface CodingKeys { + foo: string; + [property: string]: unknown; +} + +// Converts JSON strings to/from your types +// and asserts the results of JSON.parse at runtime +export class Convert { + public static toTopLevel(json: string): TopLevel { + return cast(JSON.parse(json), r("TopLevel")); + } + + public static topLevelToJson(value: TopLevel): string { + return JSON.stringify(uncast(value, r("TopLevel")), null, 2); + } +} + +function invalidValue(typ: any, val: any, key: any, parent: any = ''): never { + const prettyTyp = prettyTypeName(typ); + const parentText = parent ? ` on ${parent}` : ''; + const keyText = key ? ` for key "${key}"` : ''; + throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`); +} + +function prettyTypeName(typ: any): string { + if (Array.isArray(typ)) { + if (typ.length === 2 && typ[0] === undefined) { + return `an optional ${prettyTypeName(typ[1])}`; + } else { + return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`; + } + } else if (typeof typ === "object" && typ.literal !== undefined) { + return typ.literal; + } else { + return typeof typ; + } +} + +function jsonToJSProps(typ: any): any { + if (typ.jsonToJS === undefined) { + const map: any = {}; + typ.props.forEach((p: any) => map[p.json] = { key: p.js, typ: p.typ }); + typ.jsonToJS = map; + } + return typ.jsonToJS; +} + +function jsToJSONProps(typ: any): any { + if (typ.jsToJSON === undefined) { + const map: any = {}; + typ.props.forEach((p: any) => map[p.js] = { key: p.json, typ: p.typ }); + typ.jsToJSON = map; + } + return typ.jsToJSON; +} + +function transform(val: any, typ: any, getProps: any, key: any = '', parent: any = ''): any { + function transformPrimitive(typ: string, val: any): any { + if (typeof typ === typeof val) return val; + return invalidValue(typ, val, key, parent); + } + + function transformUnion(typs: any[], val: any): any { + // val must validate against one typ in typs + const l = typs.length; + for (let i = 0; i < l; i++) { + const typ = typs[i]; + try { + return transform(val, typ, getProps); + } catch (_) {} + } + return invalidValue(typs, val, key, parent); + } + + function transformEnum(cases: string[], val: any): any { + if (cases.indexOf(val) !== -1) return val; + return invalidValue(cases.map(a => { return l(a); }), val, key, parent); + } + + function transformArray(typ: any, val: any): any { + // val must be an array with no invalid elements + if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent); + return val.map(el => transform(el, typ, getProps)); + } + + function transformDate(val: any): any { + if (val === null) { + return null; + } + const d = new Date(val); + if (isNaN(d.valueOf())) { + return invalidValue(l("Date"), val, key, parent); + } + return d; + } + + function transformObject(props: { [k: string]: any }, additional: any, val: any): any { + if (val === null || typeof val !== "object" || Array.isArray(val)) { + return invalidValue(l(ref || "object"), val, key, parent); + } + const result: any = {}; + Object.getOwnPropertyNames(props).forEach(key => { + const prop = props[key]; + const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined; + result[prop.key] = transform(v, prop.typ, getProps, key, ref); + }); + Object.getOwnPropertyNames(val).forEach(key => { + if (!Object.prototype.hasOwnProperty.call(props, key)) { + result[key] = transform(val[key], additional, getProps, key, ref); + } + }); + return result; + } + + if (typ === "any") return val; + if (typ === null) { + if (val === null) return val; + return invalidValue(typ, val, key, parent); + } + if (typ === false) return invalidValue(typ, val, key, parent); + let ref: any = undefined; + while (typeof typ === "object" && typ.ref !== undefined) { + ref = typ.ref; + typ = typeMap[typ.ref]; + } + if (Array.isArray(typ)) return transformEnum(typ, val); + if (typeof typ === "object") { + return typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) + : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val) + : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val) + : invalidValue(typ, val, key, parent); + } + // Numbers can be parsed by Date but shouldn't be. + if (typ === Date && typeof val !== "number") return transformDate(val); + return transformPrimitive(typ, val); +} + +function cast(val: any, typ: any): T { + return transform(val, typ, jsonToJSProps); +} + +function uncast(val: T, typ: any): any { + return transform(val, typ, jsToJSONProps); +} + +function l(typ: any) { + return { literal: typ }; +} + +function a(typ: any) { + return { arrayItems: typ }; +} + +function u(...typs: any[]) { + return { unionMembers: typs }; +} + +function o(props: any[], additional: any) { + return { props, additional }; +} + +function m(additional: any) { + const props: any[] = []; + return { props, additional }; +} + +function r(name: string) { + return { ref: name }; +} + +const typeMap: any = { + "TopLevel": o([ + { json: "coding-keys", js: "coding-keys", typ: r("CodingKeys") }, + { json: "name", js: "name", typ: "" }, + ], "any"), + "CodingKeys": o([ + { json: "foo", js: "foo", typ: "" }, + ], "any"), +}; diff --git a/head/schema-typescript-zod/test/inputs/schema/coding-keys.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/coding-keys.schema/default/TopLevel.ts new file mode 100644 index 0000000..251c481 --- /dev/null +++ b/head/schema-typescript-zod/test/inputs/schema/coding-keys.schema/default/TopLevel.ts @@ -0,0 +1,13 @@ +import * as z from "zod"; + + +export const CodingKeysSchema = z.object({ + "foo": z.string(), +}); +export type CodingKeys = z.infer; + +export const TopLevelSchema = z.object({ + "coding-keys": CodingKeysSchema, + "name": z.string(), +}); +export type TopLevel = z.infer; diff --git a/head/swift/test/inputs/json/priority/combinations1.json/nest-types-true--d03bdf4b0ab1/quicktype.swift b/head/swift/test/inputs/json/priority/combinations1.json/nest-types-true--d03bdf4b0ab1/quicktype.swift new file mode 100644 index 0000000..13db051 --- /dev/null +++ b/head/swift/test/inputs/json/priority/combinations1.json/nest-types-true--d03bdf4b0ab1/quicktype.swift @@ -0,0 +1,2798 @@ +// This file was generated from JSON Schema using quicktype, do not modify it directly. +// To parse the JSON, add this file to your project and do: +// +// let topLevel = try TopLevel(json) + +import Foundation + +// MARK: - TopLevel +struct TopLevel: Codable { + let centrodesmose: String + let cerograph: [TopLevel.CerographElement] + let chemotherapeutics: [TopLevel.ChemotherapeuticElement] + let cimelia: [TopLevel.CimeliaElement] + let citrated: Int + let clinodome: [TopLevel.Clinodome] + let coadjust: [TopLevel.CoadjustElement] + let consilience: [TopLevel.Consilience] + let constructor: [TopLevel.Constructor] + let continuative: [TopLevel.Continuative] + let credulity: [TopLevel.CredulityElement] + let creviced: [TopLevel.Creviced] + let cubiculum: [[Int?]] + let deruralize: [TopLevel.DeruralizeElement] + let diaereses: [TopLevel.DiaereseElement] + let dissolution: [[JSONNull?]?] + let downstroke: [TopLevel.Downstroke] + let electrotautomerism: [Double?] + let eleutheromania: [TopLevel.Eleutheromania] + let encrust: TopLevel.Encrust + let entomoid: [TopLevel.Entomoid] + let epipaleolithic: [TopLevel.Epipaleolithic] + let expropriable: [TopLevel.Expropriable] + let faggingly: [TopLevel.FagginglyElement] + let fenks: [TopLevel.FenkElement] + let flagmaking: [TopLevel.FlagmakingElement] + let fluorometer: [TopLevel.Fluorometer] + let fulsome: [Int?] + let fuzzy: [TopLevel.Fuzzy] + let gardenwards: [TopLevel.Gardenward] + let generalissimo: [TopLevel.Generalissimo] + let habeas: [[String: Int]?] + let hemicrystalline: [TopLevel.Hemicrystalline] + let hemocoele: [TopLevel.HemocoeleElement] + let hoister: [TopLevel.Hoister] + let hyperpiesis: [TopLevel.Hyperpiesi] + let hyppish: [TopLevel.Hyppish] + let idealizer: [TopLevel.Idealizer] + let incrustator: [TopLevel.Incrustator] + let intentiveness: [TopLevel.Intentiveness] + let interacinar: TopLevel.Interacinar + let intercorrelation: [[Int]?] + let jacutinga: [TopLevel.Jacutinga] + + enum CodingKeys: String, CodingKey { + case centrodesmose = "centrodesmose" + case cerograph = "cerograph" + case chemotherapeutics = "chemotherapeutics" + case cimelia = "cimelia" + case citrated = "citrated" + case clinodome = "clinodome" + case coadjust = "coadjust" + case consilience = "consilience" + case constructor = "constructor" + case continuative = "continuative" + case credulity = "credulity" + case creviced = "creviced" + case cubiculum = "cubiculum" + case deruralize = "deruralize" + case diaereses = "diaereses" + case dissolution = "dissolution" + case downstroke = "downstroke" + case electrotautomerism = "electrotautomerism" + case eleutheromania = "eleutheromania" + case encrust = "encrust" + case entomoid = "entomoid" + case epipaleolithic = "epipaleolithic" + case expropriable = "expropriable" + case faggingly = "faggingly" + case fenks = "fenks" + case flagmaking = "flagmaking" + case fluorometer = "fluorometer" + case fulsome = "fulsome" + case fuzzy = "fuzzy" + case gardenwards = "gardenwards" + case generalissimo = "generalissimo" + case habeas = "habeas" + case hemicrystalline = "hemicrystalline" + case hemocoele = "hemocoele" + case hoister = "hoister" + case hyperpiesis = "hyperpiesis" + case hyppish = "hyppish" + case idealizer = "idealizer" + case incrustator = "incrustator" + case intentiveness = "intentiveness" + case interacinar = "interacinar" + case intercorrelation = "intercorrelation" + case jacutinga = "jacutinga" + } + + enum CerographElement: Codable { + case cerographClass(TopLevel.CerographClass) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(TopLevel.CerographClass.self) { + self = .cerographClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(CerographElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CerographElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cerographClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } + } + + struct CerographClass: Codable { + let apotropaion: JSONNull? + let casuary: JSONNull? + let creaker: JSONNull? + let disqualification: JSONNull? + let imperatorious: JSONNull? + let impermeabilize: JSONNull? + let metastoma: JSONNull? + let noctidiurnal: JSONNull? + let nonreserve: JSONNull? + let ophthalmotonometry: JSONNull? + let pailful: JSONNull? + let pigfish: JSONNull? + let pongee: JSONNull? + let prosodical: JSONNull? + let scrofuloderm: JSONNull? + let storekeeping: JSONNull? + let therologist: JSONNull? + let tolowa: JSONNull? + let tradeful: JSONNull? + let unriveting: JSONNull? + + enum CodingKeys: String, CodingKey { + case apotropaion = "apotropaion" + case casuary = "casuary" + case creaker = "creaker" + case disqualification = "disqualification" + case imperatorious = "imperatorious" + case impermeabilize = "impermeabilize" + case metastoma = "metastoma" + case noctidiurnal = "noctidiurnal" + case nonreserve = "nonreserve" + case ophthalmotonometry = "ophthalmotonometry" + case pailful = "pailful" + case pigfish = "pigfish" + case pongee = "pongee" + case prosodical = "prosodical" + case scrofuloderm = "scrofuloderm" + case storekeeping = "storekeeping" + case therologist = "therologist" + case tolowa = "Tolowa" + case tradeful = "tradeful" + case unriveting = "unriveting" + } + } + + enum ChemotherapeuticElement: Codable { + case chemotherapeuticClass(TopLevel.ChemotherapeuticClass) + case integer(Int) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(TopLevel.ChemotherapeuticClass.self) { + self = .chemotherapeuticClass(x) + return + } + throw DecodingError.typeMismatch(ChemotherapeuticElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for ChemotherapeuticElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .chemotherapeuticClass(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + } + } + } + + struct ChemotherapeuticClass: Codable { + let angioneurotic: JSONNull? + let availment: JSONNull? + let bladelet: JSONNull? + let catharticalness: Double? + let caulis: JSONNull? + let chalcus: JSONNull? + let chirotherium: Int? + let disdiapason: String? + let enteradenological: JSONNull? + let homocerc: Bool? + let imporosity: JSONNull? + let insistently: JSONNull? + let intraparietal: JSONNull? + let ivied: JSONNull? + let maureen: JSONNull? + let nonbookish: JSONNull? + let nostochine: JSONNull? + let nutcracker: JSONNull? + let ofttimes: JSONNull? + let phenocryst: JSONNull? + let precoincident: JSONNull? + let ramiferous: JSONNull? + let stagmometer: JSONNull? + let tetherball: JSONNull? + let unshy: JSONNull? + + enum CodingKeys: String, CodingKey { + case angioneurotic = "angioneurotic" + case availment = "availment" + case bladelet = "bladelet" + case catharticalness = "catharticalness" + case caulis = "caulis" + case chalcus = "chalcus" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case enteradenological = "enteradenological" + case homocerc = "homocerc" + case imporosity = "imporosity" + case insistently = "insistently" + case intraparietal = "intraparietal" + case ivied = "ivied" + case maureen = "Maureen" + case nonbookish = "nonbookish" + case nostochine = "nostochine" + case nutcracker = "nutcracker" + case ofttimes = "ofttimes" + case phenocryst = "phenocryst" + case precoincident = "precoincident" + case ramiferous = "ramiferous" + case stagmometer = "stagmometer" + case tetherball = "tetherball" + case unshy = "unshy" + } + } + + enum CimeliaElement: Codable { + case cimeliaClass(TopLevel.CimeliaClass) + case integerArray([Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(TopLevel.CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(CimeliaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CimeliaElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } + } + + struct CimeliaClass: Codable { + let catharticalness: Double + let chirotherium: Int + let disdiapason: String + let homocerc: Bool + let nonbookish: JSONNull? + + enum CodingKeys: String, CodingKey { + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case homocerc = "homocerc" + case nonbookish = "nonbookish" + } + } + + enum Clinodome: Codable { + case double(Double) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Clinodome.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Clinodome")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + enum CoadjustElement: Codable { + case coadjustClass(TopLevel.CoadjustClass) + case double(Double) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(TopLevel.CoadjustClass.self) { + self = .coadjustClass(x) + return + } + throw DecodingError.typeMismatch(CoadjustElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CoadjustElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .coadjustClass(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + } + } + } + + struct CoadjustClass: Codable { + let amidosulphonal: JSONNull? + let benny: JSONNull? + let catharticalness: Double? + let chirotherium: Int? + let disdiapason: String? + let ensnare: JSONNull? + let homocerc: Bool? + let hybridizer: JSONNull? + let leastwise: JSONNull? + let lof: JSONNull? + let monkhood: JSONNull? + let netherlandish: JSONNull? + let nonbookish: JSONNull? + let peonism: JSONNull? + let phonelescope: JSONNull? + let porphyrogeniture: JSONNull? + let preindemnify: JSONNull? + let rosal: JSONNull? + let scalenous: JSONNull? + let scopine: JSONNull? + let sedaceae: JSONNull? + let suberinize: JSONNull? + let symbiot: JSONNull? + let tablefellow: JSONNull? + let unchargeable: JSONNull? + + enum CodingKeys: String, CodingKey { + case amidosulphonal = "amidosulphonal" + case benny = "Benny" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case ensnare = "ensnare" + case homocerc = "homocerc" + case hybridizer = "hybridizer" + case leastwise = "leastwise" + case lof = "lof" + case monkhood = "monkhood" + case netherlandish = "Netherlandish" + case nonbookish = "nonbookish" + case peonism = "peonism" + case phonelescope = "Phonelescope" + case porphyrogeniture = "porphyrogeniture" + case preindemnify = "preindemnify" + case rosal = "rosal" + case scalenous = "scalenous" + case scopine = "scopine" + case sedaceae = "Sedaceae" + case suberinize = "suberinize" + case symbiot = "symbiot" + case tablefellow = "tablefellow" + case unchargeable = "unchargeable" + } + } + + enum Consilience: Codable { + case double(Double) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Consilience.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Consilience")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } + } + + enum Constructor: Codable { + case bool(Bool) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + throw DecodingError.typeMismatch(Constructor.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Constructor")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } + } + + enum Continuative: Codable { + case integerMap([String: Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Continuative.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Continuative")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + enum CredulityElement: Codable { + case credulityClass(TopLevel.CredulityClass) + case integer(Int) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(TopLevel.CredulityClass.self) { + self = .credulityClass(x) + return + } + throw DecodingError.typeMismatch(CredulityElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CredulityElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .credulityClass(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + struct CredulityClass: Codable { + let ammonolytic: JSONNull? + let bushmaster: JSONNull? + let considering: JSONNull? + let consuetudinary: JSONNull? + let embarras: JSONNull? + let fineness: JSONNull? + let flaithship: JSONNull? + let flavia: JSONNull? + let gruffly: JSONNull? + let hedychium: JSONNull? + let leadwort: JSONNull? + let overseriously: JSONNull? + let parabola: JSONNull? + let pectinatodenticulate: JSONNull? + let popean: JSONNull? + let pornocrat: JSONNull? + let quadrisect: JSONNull? + let seriality: JSONNull? + let vamphorn: JSONNull? + let wharp: JSONNull? + + enum CodingKeys: String, CodingKey { + case ammonolytic = "ammonolytic" + case bushmaster = "bushmaster" + case considering = "considering" + case consuetudinary = "consuetudinary" + case embarras = "embarras" + case fineness = "fineness" + case flaithship = "flaithship" + case flavia = "Flavia" + case gruffly = "gruffly" + case hedychium = "Hedychium" + case leadwort = "leadwort" + case overseriously = "overseriously" + case parabola = "parabola" + case pectinatodenticulate = "pectinatodenticulate" + case popean = "Popean" + case pornocrat = "pornocrat" + case quadrisect = "quadrisect" + case seriality = "seriality" + case vamphorn = "vamphorn" + case wharp = "wharp" + } + } + + enum Creviced: Codable { + case bool(Bool) + case integerMap([String: Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Creviced.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Creviced")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + enum DeruralizeElement: Codable { + case bool(Bool) + case deruralizeClass(TopLevel.DeruralizeClass) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(TopLevel.DeruralizeClass.self) { + self = .deruralizeClass(x) + return + } + throw DecodingError.typeMismatch(DeruralizeElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for DeruralizeElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .deruralizeClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } + } + + struct DeruralizeClass: Codable { + let bockerel: JSONNull? + let boulder: JSONNull? + let churrus: JSONNull? + let counterdigged: JSONNull? + let dialogite: JSONNull? + let digenic: JSONNull? + let dunbird: JSONNull? + let ergatogyne: JSONNull? + let fiendful: JSONNull? + let jackrod: JSONNull? + let jehovistic: JSONNull? + let paninean: JSONNull? + let panther: JSONNull? + let placentigerous: JSONNull? + let romney: JSONNull? + let sparm: JSONNull? + let tocsin: JSONNull? + let unnicked: JSONNull? + let unstavable: JSONNull? + let windfirm: JSONNull? + + enum CodingKeys: String, CodingKey { + case bockerel = "bockerel" + case boulder = "boulder" + case churrus = "churrus" + case counterdigged = "counterdigged" + case dialogite = "dialogite" + case digenic = "digenic" + case dunbird = "dunbird" + case ergatogyne = "ergatogyne" + case fiendful = "fiendful" + case jackrod = "jackrod" + case jehovistic = "Jehovistic" + case paninean = "Paninean" + case panther = "panther" + case placentigerous = "placentigerous" + case romney = "Romney" + case sparm = "sparm" + case tocsin = "tocsin" + case unnicked = "unnicked" + case unstavable = "unstavable" + case windfirm = "windfirm" + } + } + + enum DiaereseElement: Codable { + case bool(Bool) + case diaereseClass(TopLevel.DiaereseClass) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(TopLevel.DiaereseClass.self) { + self = .diaereseClass(x) + return + } + throw DecodingError.typeMismatch(DiaereseElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for DiaereseElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .diaereseClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } + } + + struct DiaereseClass: Codable { + let amoreuxia: JSONNull? + let ani: JSONNull? + let bernicle: JSONNull? + let blackwasher: JSONNull? + let blowhard: JSONNull? + let broma: JSONNull? + let closecross: JSONNull? + let congregationalism: JSONNull? + let grayly: JSONNull? + let historically: JSONNull? + let hoast: JSONNull? + let irretentive: JSONNull? + let parcener: JSONNull? + let pedder: JSONNull? + let pseudoanatomic: JSONNull? + let rhizocarpian: JSONNull? + let samel: JSONNull? + let silker: JSONNull? + let subdentated: JSONNull? + let subobscure: JSONNull? + + enum CodingKeys: String, CodingKey { + case amoreuxia = "Amoreuxia" + case ani = "ani" + case bernicle = "bernicle" + case blackwasher = "blackwasher" + case blowhard = "blowhard" + case broma = "broma" + case closecross = "closecross" + case congregationalism = "congregationalism" + case grayly = "grayly" + case historically = "historically" + case hoast = "hoast" + case irretentive = "irretentive" + case parcener = "parcener" + case pedder = "pedder" + case pseudoanatomic = "pseudoanatomic" + case rhizocarpian = "rhizocarpian" + case samel = "samel" + case silker = "silker" + case subdentated = "subdentated" + case subobscure = "subobscure" + } + } + + enum Downstroke: Codable { + case bool(Bool) + case nullArray([JSONNull?]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Downstroke.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Downstroke")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + enum Eleutheromania: Codable { + case double(Double) + case integerMap([String: Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Eleutheromania.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Eleutheromania")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + struct Encrust: Codable { + let comradely: JSONNull? + let diacanthous: JSONNull? + let feminineness: JSONNull? + let gossamered: JSONNull? + let hibernia: JSONNull? + let hibiscus: JSONNull? + let lepidosauria: JSONNull? + let lollingly: JSONNull? + let manager: JSONNull? + let mechanic: JSONNull? + let overminuteness: JSONNull? + let papelonne: JSONNull? + let plebification: JSONNull? + let pugmiller: JSONNull? + let recoveror: JSONNull? + let spermatoblastic: JSONNull? + let syllidae: JSONNull? + let ungyved: JSONNull? + let whirlabout: JSONNull? + let woodenware: JSONNull? + + enum CodingKeys: String, CodingKey { + case comradely = "comradely" + case diacanthous = "diacanthous" + case feminineness = "feminineness" + case gossamered = "gossamered" + case hibernia = "Hibernia" + case hibiscus = "Hibiscus" + case lepidosauria = "Lepidosauria" + case lollingly = "lollingly" + case manager = "manager" + case mechanic = "mechanic" + case overminuteness = "overminuteness" + case papelonne = "papelonne" + case plebification = "plebification" + case pugmiller = "pugmiller" + case recoveror = "recoveror" + case spermatoblastic = "spermatoblastic" + case syllidae = "Syllidae" + case ungyved = "ungyved" + case whirlabout = "whirlabout" + case woodenware = "woodenware" + } + } + + enum Entomoid: Codable { + case cimeliaClass(TopLevel.CimeliaClass) + case integer(Int) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(TopLevel.CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + throw DecodingError.typeMismatch(Entomoid.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Entomoid")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + } + } + } + + enum Epipaleolithic: Codable { + case double(Double) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Epipaleolithic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Epipaleolithic")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } + } + + enum Expropriable: Codable { + case cimeliaClass(TopLevel.CimeliaClass) + case double(Double) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(TopLevel.CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + throw DecodingError.typeMismatch(Expropriable.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Expropriable")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } + } + + enum FagginglyElement: Codable { + case double(Double) + case fagginglyClass(TopLevel.FagginglyClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(TopLevel.FagginglyClass.self) { + self = .fagginglyClass(x) + return + } + throw DecodingError.typeMismatch(FagginglyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for FagginglyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .fagginglyClass(let x): + try container.encode(x) + } + } + } + + struct FagginglyClass: Codable { + let abranchian: JSONNull? + let aculeiform: JSONNull? + let adiaphoristic: JSONNull? + let adoptionism: JSONNull? + let anglic: JSONNull? + let antrotomy: JSONNull? + let coerciveness: JSONNull? + let decorist: JSONNull? + let duckhood: JSONNull? + let heteromeri: JSONNull? + let hypochnose: JSONNull? + let lochage: JSONNull? + let melee: JSONNull? + let nonconformitant: JSONNull? + let poinsettia: JSONNull? + let putatively: JSONNull? + let semivolatile: JSONNull? + let soleas: JSONNull? + let unfastenable: JSONNull? + let unmillinered: JSONNull? + + enum CodingKeys: String, CodingKey { + case abranchian = "abranchian" + case aculeiform = "aculeiform" + case adiaphoristic = "adiaphoristic" + case adoptionism = "adoptionism" + case anglic = "Anglic" + case antrotomy = "antrotomy" + case coerciveness = "coerciveness" + case decorist = "decorist" + case duckhood = "duckhood" + case heteromeri = "Heteromeri" + case hypochnose = "hypochnose" + case lochage = "lochage" + case melee = "melee" + case nonconformitant = "nonconformitant" + case poinsettia = "Poinsettia" + case putatively = "putatively" + case semivolatile = "semivolatile" + case soleas = "soleas" + case unfastenable = "unfastenable" + case unmillinered = "unmillinered" + } + } + + enum FenkElement: Codable { + case fenkClass(TopLevel.FenkClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(TopLevel.FenkClass.self) { + self = .fenkClass(x) + return + } + throw DecodingError.typeMismatch(FenkElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for FenkElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .fenkClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + struct FenkClass: Codable { + let apoise: JSONNull? + let astronomize: JSONNull? + let cockhorse: JSONNull? + let copular: JSONNull? + let dagomba: JSONNull? + let draffy: JSONNull? + let foreigner: JSONNull? + let guyandot: JSONNull? + let neurogliosis: JSONNull? + let osmious: JSONNull? + let palpitate: JSONNull? + let rebukeable: JSONNull? + let reinwardtia: JSONNull? + let reservatory: JSONNull? + let scalt: JSONNull? + let scripturalize: JSONNull? + let tintometer: JSONNull? + let tritoness: JSONNull? + let undergrade: JSONNull? + let undermountain: JSONNull? + + enum CodingKeys: String, CodingKey { + case apoise = "apoise" + case astronomize = "astronomize" + case cockhorse = "cockhorse" + case copular = "copular" + case dagomba = "Dagomba" + case draffy = "draffy" + case foreigner = "foreigner" + case guyandot = "Guyandot" + case neurogliosis = "neurogliosis" + case osmious = "osmious" + case palpitate = "palpitate" + case rebukeable = "rebukeable" + case reinwardtia = "Reinwardtia" + case reservatory = "reservatory" + case scalt = "scalt" + case scripturalize = "scripturalize" + case tintometer = "tintometer" + case tritoness = "Tritoness" + case undergrade = "undergrade" + case undermountain = "undermountain" + } + } + + enum FlagmakingElement: Codable { + case bool(Bool) + case double(Double) + case flagmakingClass(TopLevel.FlagmakingClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(TopLevel.FlagmakingClass.self) { + self = .flagmakingClass(x) + return + } + throw DecodingError.typeMismatch(FlagmakingElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for FlagmakingElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .flagmakingClass(let x): + try container.encode(x) + } + } + } + + struct FlagmakingClass: Codable { + let albarco: JSONNull? + let bunodonta: JSONNull? + let hornify: JSONNull? + let hydrocorisae: JSONNull? + let hypoglossus: JSONNull? + let inexpiably: JSONNull? + let ingratitude: JSONNull? + let ladyfly: JSONNull? + let medicament: JSONNull? + let monogrammatic: JSONNull? + let nobbut: JSONNull? + let notacanthidae: JSONNull? + let polyplacophore: JSONNull? + let proexercise: JSONNull? + let protoplast: JSONNull? + let puzzling: JSONNull? + let splanchnoskeleton: JSONNull? + let unloveliness: JSONNull? + let unquarantined: JSONNull? + let unrenounceable: JSONNull? + + enum CodingKeys: String, CodingKey { + case albarco = "albarco" + case bunodonta = "Bunodonta" + case hornify = "hornify" + case hydrocorisae = "Hydrocorisae" + case hypoglossus = "hypoglossus" + case inexpiably = "inexpiably" + case ingratitude = "ingratitude" + case ladyfly = "ladyfly" + case medicament = "medicament" + case monogrammatic = "monogrammatic" + case nobbut = "nobbut" + case notacanthidae = "Notacanthidae" + case polyplacophore = "polyplacophore" + case proexercise = "proexercise" + case protoplast = "protoplast" + case puzzling = "puzzling" + case splanchnoskeleton = "splanchnoskeleton" + case unloveliness = "unloveliness" + case unquarantined = "unquarantined" + case unrenounceable = "unrenounceable" + } + } + + enum Fluorometer: Codable { + case integer(Int) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Fluorometer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Fluorometer")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } + } + + enum Fuzzy: Codable { + case integer(Int) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + throw DecodingError.typeMismatch(Fuzzy.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Fuzzy")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } + } + + enum Gardenward: Codable { + case bool(Bool) + case integerArray([Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Gardenward.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Gardenward")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + enum Generalissimo: Codable { + case bool(Bool) + case integerMap([String: Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Generalissimo.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Generalissimo")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } + } + + enum Hemicrystalline: Codable { + case cimeliaClass(TopLevel.CimeliaClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(TopLevel.CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + throw DecodingError.typeMismatch(Hemicrystalline.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hemicrystalline")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + enum HemocoeleElement: Codable { + case hemocoeleClass(TopLevel.HemocoeleClass) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(TopLevel.HemocoeleClass.self) { + self = .hemocoeleClass(x) + return + } + throw DecodingError.typeMismatch(HemocoeleElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for HemocoeleElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .hemocoeleClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } + } + + struct HemocoeleClass: Codable { + let acrogamy: JSONNull? + let amelification: JSONNull? + let autobiographic: JSONNull? + let berat: JSONNull? + let catharticalness: Double? + let chirotherium: Int? + let disdiapason: String? + let disproportionably: JSONNull? + let erythrite: JSONNull? + let graphic: JSONNull? + let hepatological: JSONNull? + let homocerc: Bool? + let incommensurably: JSONNull? + let misaffirm: JSONNull? + let nonbookish: JSONNull? + let pocketbook: JSONNull? + let sclerometric: JSONNull? + let stambouline: JSONNull? + let stickpin: JSONNull? + let tubulure: JSONNull? + let undelated: JSONNull? + let unsalt: JSONNull? + let untutelar: JSONNull? + let vagrant: JSONNull? + let walt: JSONNull? + + enum CodingKeys: String, CodingKey { + case acrogamy = "acrogamy" + case amelification = "amelification" + case autobiographic = "autobiographic" + case berat = "berat" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case disproportionably = "disproportionably" + case erythrite = "erythrite" + case graphic = "graphic" + case hepatological = "hepatological" + case homocerc = "homocerc" + case incommensurably = "incommensurably" + case misaffirm = "misaffirm" + case nonbookish = "nonbookish" + case pocketbook = "pocketbook" + case sclerometric = "sclerometric" + case stambouline = "stambouline" + case stickpin = "stickpin" + case tubulure = "tubulure" + case undelated = "undelated" + case unsalt = "unsalt" + case untutelar = "untutelar" + case vagrant = "vagrant" + case walt = "Walt" + } + } + + enum Hoister: Codable { + case cimeliaClass(TopLevel.CimeliaClass) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(TopLevel.CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Hoister.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hoister")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } + } + + enum Hyperpiesi: Codable { + case cimeliaClass(TopLevel.CimeliaClass) + case nullArray([JSONNull?]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(TopLevel.CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Hyperpiesi.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hyperpiesi")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } + } + + enum Hyppish: Codable { + case bool(Bool) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Hyppish.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hyppish")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } + } + + enum Idealizer: Codable { + case cimeliaClass(TopLevel.CimeliaClass) + case integer(Int) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(TopLevel.CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + throw DecodingError.typeMismatch(Idealizer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Idealizer")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } + } + + enum Incrustator: Codable { + case integer(Int) + case integerArray([Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Incrustator.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Incrustator")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + enum Intentiveness: Codable { + case cimeliaClass(TopLevel.CimeliaClass) + case double(Double) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(TopLevel.CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + throw DecodingError.typeMismatch(Intentiveness.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Intentiveness")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + struct Interacinar: Codable { + let assapan: Double + let benefactorship: Bool + let triseriatim: String + let tubbing: Int + let untrimmed: JSONNull? + + enum CodingKeys: String, CodingKey { + case assapan = "assapan" + case benefactorship = "benefactorship" + case triseriatim = "triseriatim" + case tubbing = "tubbing" + case untrimmed = "untrimmed" + } + } + + enum Jacutinga: Codable { + case integerArray([Int]) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + throw DecodingError.typeMismatch(Jacutinga.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Jacutinga")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } + } + + // MARK: Helper functions for creating encoders and decoders + static func newJSONDecoder() -> JSONDecoder { + let decoder = JSONDecoder() + decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in + let container = try decoder.singleValueContainer() + let dateStr = try container.decode(String.self) + + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date")) + }) + return decoder + } + + static func newJSONEncoder() -> JSONEncoder { + let encoder = JSONEncoder() + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder + } +} + +// MARK: TopLevel convenience initializers and mutators + +extension TopLevel { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + centrodesmose: String? = nil, + cerograph: [TopLevel.CerographElement]? = nil, + chemotherapeutics: [TopLevel.ChemotherapeuticElement]? = nil, + cimelia: [TopLevel.CimeliaElement]? = nil, + citrated: Int? = nil, + clinodome: [TopLevel.Clinodome]? = nil, + coadjust: [TopLevel.CoadjustElement]? = nil, + consilience: [TopLevel.Consilience]? = nil, + constructor: [TopLevel.Constructor]? = nil, + continuative: [TopLevel.Continuative]? = nil, + credulity: [TopLevel.CredulityElement]? = nil, + creviced: [TopLevel.Creviced]? = nil, + cubiculum: [[Int?]]? = nil, + deruralize: [TopLevel.DeruralizeElement]? = nil, + diaereses: [TopLevel.DiaereseElement]? = nil, + dissolution: [[JSONNull?]?]? = nil, + downstroke: [TopLevel.Downstroke]? = nil, + electrotautomerism: [Double?]? = nil, + eleutheromania: [TopLevel.Eleutheromania]? = nil, + encrust: TopLevel.Encrust? = nil, + entomoid: [TopLevel.Entomoid]? = nil, + epipaleolithic: [TopLevel.Epipaleolithic]? = nil, + expropriable: [TopLevel.Expropriable]? = nil, + faggingly: [TopLevel.FagginglyElement]? = nil, + fenks: [TopLevel.FenkElement]? = nil, + flagmaking: [TopLevel.FlagmakingElement]? = nil, + fluorometer: [TopLevel.Fluorometer]? = nil, + fulsome: [Int?]? = nil, + fuzzy: [TopLevel.Fuzzy]? = nil, + gardenwards: [TopLevel.Gardenward]? = nil, + generalissimo: [TopLevel.Generalissimo]? = nil, + habeas: [[String: Int]?]? = nil, + hemicrystalline: [TopLevel.Hemicrystalline]? = nil, + hemocoele: [TopLevel.HemocoeleElement]? = nil, + hoister: [TopLevel.Hoister]? = nil, + hyperpiesis: [TopLevel.Hyperpiesi]? = nil, + hyppish: [TopLevel.Hyppish]? = nil, + idealizer: [TopLevel.Idealizer]? = nil, + incrustator: [TopLevel.Incrustator]? = nil, + intentiveness: [TopLevel.Intentiveness]? = nil, + interacinar: TopLevel.Interacinar? = nil, + intercorrelation: [[Int]?]? = nil, + jacutinga: [TopLevel.Jacutinga]? = nil + ) -> TopLevel { + return TopLevel( + centrodesmose: centrodesmose ?? self.centrodesmose, + cerograph: cerograph ?? self.cerograph, + chemotherapeutics: chemotherapeutics ?? self.chemotherapeutics, + cimelia: cimelia ?? self.cimelia, + citrated: citrated ?? self.citrated, + clinodome: clinodome ?? self.clinodome, + coadjust: coadjust ?? self.coadjust, + consilience: consilience ?? self.consilience, + constructor: constructor ?? self.constructor, + continuative: continuative ?? self.continuative, + credulity: credulity ?? self.credulity, + creviced: creviced ?? self.creviced, + cubiculum: cubiculum ?? self.cubiculum, + deruralize: deruralize ?? self.deruralize, + diaereses: diaereses ?? self.diaereses, + dissolution: dissolution ?? self.dissolution, + downstroke: downstroke ?? self.downstroke, + electrotautomerism: electrotautomerism ?? self.electrotautomerism, + eleutheromania: eleutheromania ?? self.eleutheromania, + encrust: encrust ?? self.encrust, + entomoid: entomoid ?? self.entomoid, + epipaleolithic: epipaleolithic ?? self.epipaleolithic, + expropriable: expropriable ?? self.expropriable, + faggingly: faggingly ?? self.faggingly, + fenks: fenks ?? self.fenks, + flagmaking: flagmaking ?? self.flagmaking, + fluorometer: fluorometer ?? self.fluorometer, + fulsome: fulsome ?? self.fulsome, + fuzzy: fuzzy ?? self.fuzzy, + gardenwards: gardenwards ?? self.gardenwards, + generalissimo: generalissimo ?? self.generalissimo, + habeas: habeas ?? self.habeas, + hemicrystalline: hemicrystalline ?? self.hemicrystalline, + hemocoele: hemocoele ?? self.hemocoele, + hoister: hoister ?? self.hoister, + hyperpiesis: hyperpiesis ?? self.hyperpiesis, + hyppish: hyppish ?? self.hyppish, + idealizer: idealizer ?? self.idealizer, + incrustator: incrustator ?? self.incrustator, + intentiveness: intentiveness ?? self.intentiveness, + interacinar: interacinar ?? self.interacinar, + intercorrelation: intercorrelation ?? self.intercorrelation, + jacutinga: jacutinga ?? self.jacutinga + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.CerographClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.CerographClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + apotropaion: JSONNull?? = nil, + casuary: JSONNull?? = nil, + creaker: JSONNull?? = nil, + disqualification: JSONNull?? = nil, + imperatorious: JSONNull?? = nil, + impermeabilize: JSONNull?? = nil, + metastoma: JSONNull?? = nil, + noctidiurnal: JSONNull?? = nil, + nonreserve: JSONNull?? = nil, + ophthalmotonometry: JSONNull?? = nil, + pailful: JSONNull?? = nil, + pigfish: JSONNull?? = nil, + pongee: JSONNull?? = nil, + prosodical: JSONNull?? = nil, + scrofuloderm: JSONNull?? = nil, + storekeeping: JSONNull?? = nil, + therologist: JSONNull?? = nil, + tolowa: JSONNull?? = nil, + tradeful: JSONNull?? = nil, + unriveting: JSONNull?? = nil + ) -> TopLevel.CerographClass { + return TopLevel.CerographClass( + apotropaion: apotropaion ?? self.apotropaion, + casuary: casuary ?? self.casuary, + creaker: creaker ?? self.creaker, + disqualification: disqualification ?? self.disqualification, + imperatorious: imperatorious ?? self.imperatorious, + impermeabilize: impermeabilize ?? self.impermeabilize, + metastoma: metastoma ?? self.metastoma, + noctidiurnal: noctidiurnal ?? self.noctidiurnal, + nonreserve: nonreserve ?? self.nonreserve, + ophthalmotonometry: ophthalmotonometry ?? self.ophthalmotonometry, + pailful: pailful ?? self.pailful, + pigfish: pigfish ?? self.pigfish, + pongee: pongee ?? self.pongee, + prosodical: prosodical ?? self.prosodical, + scrofuloderm: scrofuloderm ?? self.scrofuloderm, + storekeeping: storekeeping ?? self.storekeeping, + therologist: therologist ?? self.therologist, + tolowa: tolowa ?? self.tolowa, + tradeful: tradeful ?? self.tradeful, + unriveting: unriveting ?? self.unriveting + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.ChemotherapeuticClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.ChemotherapeuticClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + angioneurotic: JSONNull?? = nil, + availment: JSONNull?? = nil, + bladelet: JSONNull?? = nil, + catharticalness: Double?? = nil, + caulis: JSONNull?? = nil, + chalcus: JSONNull?? = nil, + chirotherium: Int?? = nil, + disdiapason: String?? = nil, + enteradenological: JSONNull?? = nil, + homocerc: Bool?? = nil, + imporosity: JSONNull?? = nil, + insistently: JSONNull?? = nil, + intraparietal: JSONNull?? = nil, + ivied: JSONNull?? = nil, + maureen: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + nostochine: JSONNull?? = nil, + nutcracker: JSONNull?? = nil, + ofttimes: JSONNull?? = nil, + phenocryst: JSONNull?? = nil, + precoincident: JSONNull?? = nil, + ramiferous: JSONNull?? = nil, + stagmometer: JSONNull?? = nil, + tetherball: JSONNull?? = nil, + unshy: JSONNull?? = nil + ) -> TopLevel.ChemotherapeuticClass { + return TopLevel.ChemotherapeuticClass( + angioneurotic: angioneurotic ?? self.angioneurotic, + availment: availment ?? self.availment, + bladelet: bladelet ?? self.bladelet, + catharticalness: catharticalness ?? self.catharticalness, + caulis: caulis ?? self.caulis, + chalcus: chalcus ?? self.chalcus, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + enteradenological: enteradenological ?? self.enteradenological, + homocerc: homocerc ?? self.homocerc, + imporosity: imporosity ?? self.imporosity, + insistently: insistently ?? self.insistently, + intraparietal: intraparietal ?? self.intraparietal, + ivied: ivied ?? self.ivied, + maureen: maureen ?? self.maureen, + nonbookish: nonbookish ?? self.nonbookish, + nostochine: nostochine ?? self.nostochine, + nutcracker: nutcracker ?? self.nutcracker, + ofttimes: ofttimes ?? self.ofttimes, + phenocryst: phenocryst ?? self.phenocryst, + precoincident: precoincident ?? self.precoincident, + ramiferous: ramiferous ?? self.ramiferous, + stagmometer: stagmometer ?? self.stagmometer, + tetherball: tetherball ?? self.tetherball, + unshy: unshy ?? self.unshy + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.CimeliaClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.CimeliaClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + catharticalness: Double? = nil, + chirotherium: Int? = nil, + disdiapason: String? = nil, + homocerc: Bool? = nil, + nonbookish: JSONNull?? = nil + ) -> TopLevel.CimeliaClass { + return TopLevel.CimeliaClass( + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + homocerc: homocerc ?? self.homocerc, + nonbookish: nonbookish ?? self.nonbookish + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.CoadjustClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.CoadjustClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + amidosulphonal: JSONNull?? = nil, + benny: JSONNull?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + disdiapason: String?? = nil, + ensnare: JSONNull?? = nil, + homocerc: Bool?? = nil, + hybridizer: JSONNull?? = nil, + leastwise: JSONNull?? = nil, + lof: JSONNull?? = nil, + monkhood: JSONNull?? = nil, + netherlandish: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + peonism: JSONNull?? = nil, + phonelescope: JSONNull?? = nil, + porphyrogeniture: JSONNull?? = nil, + preindemnify: JSONNull?? = nil, + rosal: JSONNull?? = nil, + scalenous: JSONNull?? = nil, + scopine: JSONNull?? = nil, + sedaceae: JSONNull?? = nil, + suberinize: JSONNull?? = nil, + symbiot: JSONNull?? = nil, + tablefellow: JSONNull?? = nil, + unchargeable: JSONNull?? = nil + ) -> TopLevel.CoadjustClass { + return TopLevel.CoadjustClass( + amidosulphonal: amidosulphonal ?? self.amidosulphonal, + benny: benny ?? self.benny, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + ensnare: ensnare ?? self.ensnare, + homocerc: homocerc ?? self.homocerc, + hybridizer: hybridizer ?? self.hybridizer, + leastwise: leastwise ?? self.leastwise, + lof: lof ?? self.lof, + monkhood: monkhood ?? self.monkhood, + netherlandish: netherlandish ?? self.netherlandish, + nonbookish: nonbookish ?? self.nonbookish, + peonism: peonism ?? self.peonism, + phonelescope: phonelescope ?? self.phonelescope, + porphyrogeniture: porphyrogeniture ?? self.porphyrogeniture, + preindemnify: preindemnify ?? self.preindemnify, + rosal: rosal ?? self.rosal, + scalenous: scalenous ?? self.scalenous, + scopine: scopine ?? self.scopine, + sedaceae: sedaceae ?? self.sedaceae, + suberinize: suberinize ?? self.suberinize, + symbiot: symbiot ?? self.symbiot, + tablefellow: tablefellow ?? self.tablefellow, + unchargeable: unchargeable ?? self.unchargeable + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.CredulityClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.CredulityClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + ammonolytic: JSONNull?? = nil, + bushmaster: JSONNull?? = nil, + considering: JSONNull?? = nil, + consuetudinary: JSONNull?? = nil, + embarras: JSONNull?? = nil, + fineness: JSONNull?? = nil, + flaithship: JSONNull?? = nil, + flavia: JSONNull?? = nil, + gruffly: JSONNull?? = nil, + hedychium: JSONNull?? = nil, + leadwort: JSONNull?? = nil, + overseriously: JSONNull?? = nil, + parabola: JSONNull?? = nil, + pectinatodenticulate: JSONNull?? = nil, + popean: JSONNull?? = nil, + pornocrat: JSONNull?? = nil, + quadrisect: JSONNull?? = nil, + seriality: JSONNull?? = nil, + vamphorn: JSONNull?? = nil, + wharp: JSONNull?? = nil + ) -> TopLevel.CredulityClass { + return TopLevel.CredulityClass( + ammonolytic: ammonolytic ?? self.ammonolytic, + bushmaster: bushmaster ?? self.bushmaster, + considering: considering ?? self.considering, + consuetudinary: consuetudinary ?? self.consuetudinary, + embarras: embarras ?? self.embarras, + fineness: fineness ?? self.fineness, + flaithship: flaithship ?? self.flaithship, + flavia: flavia ?? self.flavia, + gruffly: gruffly ?? self.gruffly, + hedychium: hedychium ?? self.hedychium, + leadwort: leadwort ?? self.leadwort, + overseriously: overseriously ?? self.overseriously, + parabola: parabola ?? self.parabola, + pectinatodenticulate: pectinatodenticulate ?? self.pectinatodenticulate, + popean: popean ?? self.popean, + pornocrat: pornocrat ?? self.pornocrat, + quadrisect: quadrisect ?? self.quadrisect, + seriality: seriality ?? self.seriality, + vamphorn: vamphorn ?? self.vamphorn, + wharp: wharp ?? self.wharp + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.DeruralizeClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.DeruralizeClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + bockerel: JSONNull?? = nil, + boulder: JSONNull?? = nil, + churrus: JSONNull?? = nil, + counterdigged: JSONNull?? = nil, + dialogite: JSONNull?? = nil, + digenic: JSONNull?? = nil, + dunbird: JSONNull?? = nil, + ergatogyne: JSONNull?? = nil, + fiendful: JSONNull?? = nil, + jackrod: JSONNull?? = nil, + jehovistic: JSONNull?? = nil, + paninean: JSONNull?? = nil, + panther: JSONNull?? = nil, + placentigerous: JSONNull?? = nil, + romney: JSONNull?? = nil, + sparm: JSONNull?? = nil, + tocsin: JSONNull?? = nil, + unnicked: JSONNull?? = nil, + unstavable: JSONNull?? = nil, + windfirm: JSONNull?? = nil + ) -> TopLevel.DeruralizeClass { + return TopLevel.DeruralizeClass( + bockerel: bockerel ?? self.bockerel, + boulder: boulder ?? self.boulder, + churrus: churrus ?? self.churrus, + counterdigged: counterdigged ?? self.counterdigged, + dialogite: dialogite ?? self.dialogite, + digenic: digenic ?? self.digenic, + dunbird: dunbird ?? self.dunbird, + ergatogyne: ergatogyne ?? self.ergatogyne, + fiendful: fiendful ?? self.fiendful, + jackrod: jackrod ?? self.jackrod, + jehovistic: jehovistic ?? self.jehovistic, + paninean: paninean ?? self.paninean, + panther: panther ?? self.panther, + placentigerous: placentigerous ?? self.placentigerous, + romney: romney ?? self.romney, + sparm: sparm ?? self.sparm, + tocsin: tocsin ?? self.tocsin, + unnicked: unnicked ?? self.unnicked, + unstavable: unstavable ?? self.unstavable, + windfirm: windfirm ?? self.windfirm + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.DiaereseClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.DiaereseClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + amoreuxia: JSONNull?? = nil, + ani: JSONNull?? = nil, + bernicle: JSONNull?? = nil, + blackwasher: JSONNull?? = nil, + blowhard: JSONNull?? = nil, + broma: JSONNull?? = nil, + closecross: JSONNull?? = nil, + congregationalism: JSONNull?? = nil, + grayly: JSONNull?? = nil, + historically: JSONNull?? = nil, + hoast: JSONNull?? = nil, + irretentive: JSONNull?? = nil, + parcener: JSONNull?? = nil, + pedder: JSONNull?? = nil, + pseudoanatomic: JSONNull?? = nil, + rhizocarpian: JSONNull?? = nil, + samel: JSONNull?? = nil, + silker: JSONNull?? = nil, + subdentated: JSONNull?? = nil, + subobscure: JSONNull?? = nil + ) -> TopLevel.DiaereseClass { + return TopLevel.DiaereseClass( + amoreuxia: amoreuxia ?? self.amoreuxia, + ani: ani ?? self.ani, + bernicle: bernicle ?? self.bernicle, + blackwasher: blackwasher ?? self.blackwasher, + blowhard: blowhard ?? self.blowhard, + broma: broma ?? self.broma, + closecross: closecross ?? self.closecross, + congregationalism: congregationalism ?? self.congregationalism, + grayly: grayly ?? self.grayly, + historically: historically ?? self.historically, + hoast: hoast ?? self.hoast, + irretentive: irretentive ?? self.irretentive, + parcener: parcener ?? self.parcener, + pedder: pedder ?? self.pedder, + pseudoanatomic: pseudoanatomic ?? self.pseudoanatomic, + rhizocarpian: rhizocarpian ?? self.rhizocarpian, + samel: samel ?? self.samel, + silker: silker ?? self.silker, + subdentated: subdentated ?? self.subdentated, + subobscure: subobscure ?? self.subobscure + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.Encrust { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.Encrust.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + comradely: JSONNull?? = nil, + diacanthous: JSONNull?? = nil, + feminineness: JSONNull?? = nil, + gossamered: JSONNull?? = nil, + hibernia: JSONNull?? = nil, + hibiscus: JSONNull?? = nil, + lepidosauria: JSONNull?? = nil, + lollingly: JSONNull?? = nil, + manager: JSONNull?? = nil, + mechanic: JSONNull?? = nil, + overminuteness: JSONNull?? = nil, + papelonne: JSONNull?? = nil, + plebification: JSONNull?? = nil, + pugmiller: JSONNull?? = nil, + recoveror: JSONNull?? = nil, + spermatoblastic: JSONNull?? = nil, + syllidae: JSONNull?? = nil, + ungyved: JSONNull?? = nil, + whirlabout: JSONNull?? = nil, + woodenware: JSONNull?? = nil + ) -> TopLevel.Encrust { + return TopLevel.Encrust( + comradely: comradely ?? self.comradely, + diacanthous: diacanthous ?? self.diacanthous, + feminineness: feminineness ?? self.feminineness, + gossamered: gossamered ?? self.gossamered, + hibernia: hibernia ?? self.hibernia, + hibiscus: hibiscus ?? self.hibiscus, + lepidosauria: lepidosauria ?? self.lepidosauria, + lollingly: lollingly ?? self.lollingly, + manager: manager ?? self.manager, + mechanic: mechanic ?? self.mechanic, + overminuteness: overminuteness ?? self.overminuteness, + papelonne: papelonne ?? self.papelonne, + plebification: plebification ?? self.plebification, + pugmiller: pugmiller ?? self.pugmiller, + recoveror: recoveror ?? self.recoveror, + spermatoblastic: spermatoblastic ?? self.spermatoblastic, + syllidae: syllidae ?? self.syllidae, + ungyved: ungyved ?? self.ungyved, + whirlabout: whirlabout ?? self.whirlabout, + woodenware: woodenware ?? self.woodenware + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.FagginglyClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.FagginglyClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + abranchian: JSONNull?? = nil, + aculeiform: JSONNull?? = nil, + adiaphoristic: JSONNull?? = nil, + adoptionism: JSONNull?? = nil, + anglic: JSONNull?? = nil, + antrotomy: JSONNull?? = nil, + coerciveness: JSONNull?? = nil, + decorist: JSONNull?? = nil, + duckhood: JSONNull?? = nil, + heteromeri: JSONNull?? = nil, + hypochnose: JSONNull?? = nil, + lochage: JSONNull?? = nil, + melee: JSONNull?? = nil, + nonconformitant: JSONNull?? = nil, + poinsettia: JSONNull?? = nil, + putatively: JSONNull?? = nil, + semivolatile: JSONNull?? = nil, + soleas: JSONNull?? = nil, + unfastenable: JSONNull?? = nil, + unmillinered: JSONNull?? = nil + ) -> TopLevel.FagginglyClass { + return TopLevel.FagginglyClass( + abranchian: abranchian ?? self.abranchian, + aculeiform: aculeiform ?? self.aculeiform, + adiaphoristic: adiaphoristic ?? self.adiaphoristic, + adoptionism: adoptionism ?? self.adoptionism, + anglic: anglic ?? self.anglic, + antrotomy: antrotomy ?? self.antrotomy, + coerciveness: coerciveness ?? self.coerciveness, + decorist: decorist ?? self.decorist, + duckhood: duckhood ?? self.duckhood, + heteromeri: heteromeri ?? self.heteromeri, + hypochnose: hypochnose ?? self.hypochnose, + lochage: lochage ?? self.lochage, + melee: melee ?? self.melee, + nonconformitant: nonconformitant ?? self.nonconformitant, + poinsettia: poinsettia ?? self.poinsettia, + putatively: putatively ?? self.putatively, + semivolatile: semivolatile ?? self.semivolatile, + soleas: soleas ?? self.soleas, + unfastenable: unfastenable ?? self.unfastenable, + unmillinered: unmillinered ?? self.unmillinered + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.FenkClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.FenkClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + apoise: JSONNull?? = nil, + astronomize: JSONNull?? = nil, + cockhorse: JSONNull?? = nil, + copular: JSONNull?? = nil, + dagomba: JSONNull?? = nil, + draffy: JSONNull?? = nil, + foreigner: JSONNull?? = nil, + guyandot: JSONNull?? = nil, + neurogliosis: JSONNull?? = nil, + osmious: JSONNull?? = nil, + palpitate: JSONNull?? = nil, + rebukeable: JSONNull?? = nil, + reinwardtia: JSONNull?? = nil, + reservatory: JSONNull?? = nil, + scalt: JSONNull?? = nil, + scripturalize: JSONNull?? = nil, + tintometer: JSONNull?? = nil, + tritoness: JSONNull?? = nil, + undergrade: JSONNull?? = nil, + undermountain: JSONNull?? = nil + ) -> TopLevel.FenkClass { + return TopLevel.FenkClass( + apoise: apoise ?? self.apoise, + astronomize: astronomize ?? self.astronomize, + cockhorse: cockhorse ?? self.cockhorse, + copular: copular ?? self.copular, + dagomba: dagomba ?? self.dagomba, + draffy: draffy ?? self.draffy, + foreigner: foreigner ?? self.foreigner, + guyandot: guyandot ?? self.guyandot, + neurogliosis: neurogliosis ?? self.neurogliosis, + osmious: osmious ?? self.osmious, + palpitate: palpitate ?? self.palpitate, + rebukeable: rebukeable ?? self.rebukeable, + reinwardtia: reinwardtia ?? self.reinwardtia, + reservatory: reservatory ?? self.reservatory, + scalt: scalt ?? self.scalt, + scripturalize: scripturalize ?? self.scripturalize, + tintometer: tintometer ?? self.tintometer, + tritoness: tritoness ?? self.tritoness, + undergrade: undergrade ?? self.undergrade, + undermountain: undermountain ?? self.undermountain + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.FlagmakingClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.FlagmakingClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + albarco: JSONNull?? = nil, + bunodonta: JSONNull?? = nil, + hornify: JSONNull?? = nil, + hydrocorisae: JSONNull?? = nil, + hypoglossus: JSONNull?? = nil, + inexpiably: JSONNull?? = nil, + ingratitude: JSONNull?? = nil, + ladyfly: JSONNull?? = nil, + medicament: JSONNull?? = nil, + monogrammatic: JSONNull?? = nil, + nobbut: JSONNull?? = nil, + notacanthidae: JSONNull?? = nil, + polyplacophore: JSONNull?? = nil, + proexercise: JSONNull?? = nil, + protoplast: JSONNull?? = nil, + puzzling: JSONNull?? = nil, + splanchnoskeleton: JSONNull?? = nil, + unloveliness: JSONNull?? = nil, + unquarantined: JSONNull?? = nil, + unrenounceable: JSONNull?? = nil + ) -> TopLevel.FlagmakingClass { + return TopLevel.FlagmakingClass( + albarco: albarco ?? self.albarco, + bunodonta: bunodonta ?? self.bunodonta, + hornify: hornify ?? self.hornify, + hydrocorisae: hydrocorisae ?? self.hydrocorisae, + hypoglossus: hypoglossus ?? self.hypoglossus, + inexpiably: inexpiably ?? self.inexpiably, + ingratitude: ingratitude ?? self.ingratitude, + ladyfly: ladyfly ?? self.ladyfly, + medicament: medicament ?? self.medicament, + monogrammatic: monogrammatic ?? self.monogrammatic, + nobbut: nobbut ?? self.nobbut, + notacanthidae: notacanthidae ?? self.notacanthidae, + polyplacophore: polyplacophore ?? self.polyplacophore, + proexercise: proexercise ?? self.proexercise, + protoplast: protoplast ?? self.protoplast, + puzzling: puzzling ?? self.puzzling, + splanchnoskeleton: splanchnoskeleton ?? self.splanchnoskeleton, + unloveliness: unloveliness ?? self.unloveliness, + unquarantined: unquarantined ?? self.unquarantined, + unrenounceable: unrenounceable ?? self.unrenounceable + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.HemocoeleClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.HemocoeleClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + acrogamy: JSONNull?? = nil, + amelification: JSONNull?? = nil, + autobiographic: JSONNull?? = nil, + berat: JSONNull?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + disdiapason: String?? = nil, + disproportionably: JSONNull?? = nil, + erythrite: JSONNull?? = nil, + graphic: JSONNull?? = nil, + hepatological: JSONNull?? = nil, + homocerc: Bool?? = nil, + incommensurably: JSONNull?? = nil, + misaffirm: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + pocketbook: JSONNull?? = nil, + sclerometric: JSONNull?? = nil, + stambouline: JSONNull?? = nil, + stickpin: JSONNull?? = nil, + tubulure: JSONNull?? = nil, + undelated: JSONNull?? = nil, + unsalt: JSONNull?? = nil, + untutelar: JSONNull?? = nil, + vagrant: JSONNull?? = nil, + walt: JSONNull?? = nil + ) -> TopLevel.HemocoeleClass { + return TopLevel.HemocoeleClass( + acrogamy: acrogamy ?? self.acrogamy, + amelification: amelification ?? self.amelification, + autobiographic: autobiographic ?? self.autobiographic, + berat: berat ?? self.berat, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + disproportionably: disproportionably ?? self.disproportionably, + erythrite: erythrite ?? self.erythrite, + graphic: graphic ?? self.graphic, + hepatological: hepatological ?? self.hepatological, + homocerc: homocerc ?? self.homocerc, + incommensurably: incommensurably ?? self.incommensurably, + misaffirm: misaffirm ?? self.misaffirm, + nonbookish: nonbookish ?? self.nonbookish, + pocketbook: pocketbook ?? self.pocketbook, + sclerometric: sclerometric ?? self.sclerometric, + stambouline: stambouline ?? self.stambouline, + stickpin: stickpin ?? self.stickpin, + tubulure: tubulure ?? self.tubulure, + undelated: undelated ?? self.undelated, + unsalt: unsalt ?? self.unsalt, + untutelar: untutelar ?? self.untutelar, + vagrant: vagrant ?? self.vagrant, + walt: walt ?? self.walt + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.Interacinar { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.Interacinar.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + assapan: Double? = nil, + benefactorship: Bool? = nil, + triseriatim: String? = nil, + tubbing: Int? = nil, + untrimmed: JSONNull?? = nil + ) -> TopLevel.Interacinar { + return TopLevel.Interacinar( + assapan: assapan ?? self.assapan, + benefactorship: benefactorship ?? self.benefactorship, + triseriatim: triseriatim ?? self.triseriatim, + tubbing: tubbing ?? self.tubbing, + untrimmed: untrimmed ?? self.untrimmed + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - Encode/decode helpers + +class JSONNull: Codable, Hashable { + + public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool { + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(0) + } + + public init() {} + + public required init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if !container.decodeNil() { + throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull")) + } + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + try container.encodeNil() + } +} diff --git a/head/swift/test/inputs/json/priority/combinations2.json/nest-types-true--d03bdf4b0ab1/quicktype.swift b/head/swift/test/inputs/json/priority/combinations2.json/nest-types-true--d03bdf4b0ab1/quicktype.swift new file mode 100644 index 0000000..71c9f0e --- /dev/null +++ b/head/swift/test/inputs/json/priority/combinations2.json/nest-types-true--d03bdf4b0ab1/quicktype.swift @@ -0,0 +1,2571 @@ +// This file was generated from JSON Schema using quicktype, do not modify it directly. +// To parse the JSON, add this file to your project and do: +// +// let topLevel = try TopLevel(json) + +import Foundation + +// MARK: - TopLevel +struct TopLevel: Codable { + let abranchiata: [TopLevel.Abranchiata] + let academe: [TopLevel.Academe] + let acquirable: [TopLevel.Acquirable] + let aerometry: [TopLevel.Aerometry] + let alexin: [TopLevel.Alexin] + let alleviate: [TopLevel.AlleviateElement] + let amaas: [TopLevel.Amaa] + let ambassage: [TopLevel.Ambassage] + let amphithyron: [TopLevel.Amphithyron?] + let andriana: [String?] + let ankee: [TopLevel.AnkeeElement] + let annihilator: [[String: Int?]?] + let annulose: JSONNull? + let ansarie: [TopLevel.AnsarieElement] + let aphasia: [TopLevel.Aphasia] + let asprawl: [TopLevel.Asprawl] + let attractive: [Bool?] + let barksome: [String: Int] + let bedesman: [TopLevel.Bedesman] + let belard: [TopLevel.Belard] + let bocking: [TopLevel.Bocking] + let brawlingly: [TopLevel.Brawlingly] + let brookie: [TopLevel.Brookie] + let bumboatman: [TopLevel.Bumboatman] + let bystreet: [JSONNull?] + let calaverite: [TopLevel.Calaverite] + let catallactic: [TopLevel.Catallactic] + let cemental: [TopLevel.Cemental] + let chytridiaceae: [TopLevel.ChytridiaceaeElement] + let discordia: [TopLevel.DiscordiaElement] + let endomyces: [TopLevel.Endomyce] + let epinephelidae: [TopLevel.Epinephelidae] + let eupatorium: [TopLevel.Eupatorium] + let gryphosaurus: [TopLevel.GryphosaurusElement] + let koryak: [TopLevel.Koryak] + let lavinia: [TopLevel.LaviniaElement] + let oskar: [TopLevel.OskarElement] + let rebecca: [TopLevel.RebeccaElement] + let rhomboganoidei: [TopLevel.Rhomboganoidei] + let rigsmal: Bool + let ruellia: [TopLevel.Ruellia] + let school: [TopLevel.School] + let shakespearolater: [TopLevel.Shakespearolater] + let svan: [Double] + let wayao: [String: Double] + + enum CodingKeys: String, CodingKey { + case abranchiata = "Abranchiata" + case academe = "academe" + case acquirable = "acquirable" + case aerometry = "aerometry" + case alexin = "alexin" + case alleviate = "alleviate" + case amaas = "amaas" + case ambassage = "ambassage" + case amphithyron = "amphithyron" + case andriana = "Andriana" + case ankee = "ankee" + case annihilator = "annihilator" + case annulose = "annulose" + case ansarie = "Ansarie" + case aphasia = "aphasia" + case asprawl = "asprawl" + case attractive = "attractive" + case barksome = "barksome" + case bedesman = "bedesman" + case belard = "belard" + case bocking = "bocking" + case brawlingly = "brawlingly" + case brookie = "brookie" + case bumboatman = "bumboatman" + case bystreet = "bystreet" + case calaverite = "calaverite" + case catallactic = "catallactic" + case cemental = "cemental" + case chytridiaceae = "Chytridiaceae" + case discordia = "Discordia" + case endomyces = "Endomyces" + case epinephelidae = "Epinephelidae" + case eupatorium = "Eupatorium" + case gryphosaurus = "Gryphosaurus" + case koryak = "Koryak" + case lavinia = "Lavinia" + case oskar = "Oskar" + case rebecca = "Rebecca" + case rhomboganoidei = "Rhomboganoidei" + case rigsmal = "Rigsmal" + case ruellia = "Ruellia" + case school = "School" + case shakespearolater = "Shakespearolater" + case svan = "Svan" + case wayao = "Wayao" + } + + enum Abranchiata: Codable { + case integer(Int) + case integerArray([Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Abranchiata.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Abranchiata")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } + } + + enum AnsarieElement: Codable { + case ansarieClass(TopLevel.AnsarieClass) + case integerArray([Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(TopLevel.AnsarieClass.self) { + self = .ansarieClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(AnsarieElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for AnsarieElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .ansarieClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } + } + + struct AnsarieClass: Codable { + let accension: JSONNull? + let alida: JSONNull? + let asteria: JSONNull? + let beriberic: JSONNull? + let edgebone: JSONNull? + let gastrodialysis: JSONNull? + let geographic: JSONNull? + let ictonyx: JSONNull? + let metrocele: JSONNull? + let misgraft: JSONNull? + let monteith: JSONNull? + let notcher: JSONNull? + let prorestriction: JSONNull? + let ramist: JSONNull? + let throatlet: JSONNull? + let unfair: JSONNull? + let unsynonymous: JSONNull? + let water: JSONNull? + let zestfully: JSONNull? + let zincic: JSONNull? + + enum CodingKeys: String, CodingKey { + case accension = "accension" + case alida = "Alida" + case asteria = "asteria" + case beriberic = "beriberic" + case edgebone = "edgebone" + case gastrodialysis = "gastrodialysis" + case geographic = "geographic" + case ictonyx = "Ictonyx" + case metrocele = "metrocele" + case misgraft = "misgraft" + case monteith = "monteith" + case notcher = "notcher" + case prorestriction = "prorestriction" + case ramist = "Ramist" + case throatlet = "throatlet" + case unfair = "unfair" + case unsynonymous = "unsynonymous" + case water = "water" + case zestfully = "zestfully" + case zincic = "zincic" + } + } + + enum ChytridiaceaeElement: Codable { + case bool(Bool) + case chytridiaceaeClass(TopLevel.ChytridiaceaeClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(TopLevel.ChytridiaceaeClass.self) { + self = .chytridiaceaeClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(ChytridiaceaeElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for ChytridiaceaeElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .chytridiaceaeClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } + } + + struct ChytridiaceaeClass: Codable { + let batidaceae: JSONNull? + let brechites: JSONNull? + let codespairer: JSONNull? + let emery: JSONNull? + let enervative: JSONNull? + let excriminate: JSONNull? + let goshenite: JSONNull? + let grime: JSONNull? + let gritten: JSONNull? + let hectorly: JSONNull? + let intermediation: JSONNull? + let meeterly: JSONNull? + let narraganset: JSONNull? + let onymatic: JSONNull? + let paddlecock: JSONNull? + let thana: JSONNull? + let thornily: JSONNull? + let uckia: JSONNull? + let unmettle: JSONNull? + let vorticellid: JSONNull? + + enum CodingKeys: String, CodingKey { + case batidaceae = "Batidaceae" + case brechites = "Brechites" + case codespairer = "codespairer" + case emery = "Emery" + case enervative = "enervative" + case excriminate = "excriminate" + case goshenite = "goshenite" + case grime = "grime" + case gritten = "gritten" + case hectorly = "hectorly" + case intermediation = "intermediation" + case meeterly = "meeterly" + case narraganset = "Narraganset" + case onymatic = "onymatic" + case paddlecock = "paddlecock" + case thana = "thana" + case thornily = "thornily" + case uckia = "uckia" + case unmettle = "unmettle" + case vorticellid = "vorticellid" + } + } + + enum DiscordiaElement: Codable { + case discordiaClass(TopLevel.DiscordiaClass) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(TopLevel.DiscordiaClass.self) { + self = .discordiaClass(x) + return + } + throw DecodingError.typeMismatch(DiscordiaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for DiscordiaElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .discordiaClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } + } + + struct DiscordiaClass: Codable { + let altaic: Int? + let amoristic: Int? + let blennophthalmia: Int? + let catharticalness: Double? + let chirotherium: Int? + let disciplinability: Int? + let disdiapason: String? + let goofer: Int? + let homocerc: Bool? + let laryngograph: Int? + let leucitis: Int? + let lymphocyst: Int? + let microcosmology: Int? + let nauseation: Int? + let nonbookish: JSONNull? + let patarin: Int? + let preliberal: Int? + let prettifier: Int? + let rangework: Int? + let redient: Int? + let subfusiform: Int? + let suicidical: Int? + let swow: Int? + let wastrel: Int? + let wingle: Int? + + enum CodingKeys: String, CodingKey { + case altaic = "Altaic" + case amoristic = "amoristic" + case blennophthalmia = "blennophthalmia" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disciplinability = "disciplinability" + case disdiapason = "disdiapason" + case goofer = "goofer" + case homocerc = "homocerc" + case laryngograph = "laryngograph" + case leucitis = "leucitis" + case lymphocyst = "lymphocyst" + case microcosmology = "microcosmology" + case nauseation = "nauseation" + case nonbookish = "nonbookish" + case patarin = "Patarin" + case preliberal = "preliberal" + case prettifier = "prettifier" + case rangework = "rangework" + case redient = "redient" + case subfusiform = "subfusiform" + case suicidical = "suicidical" + case swow = "swow" + case wastrel = "wastrel" + case wingle = "wingle" + } + } + + enum Endomyce: Codable { + case integer(Int) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Endomyce.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Endomyce")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + enum Epinephelidae: Codable { + case bool(Bool) + case integer(Int) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Epinephelidae.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Epinephelidae")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + enum Eupatorium: Codable { + case integerMap([String: Int]) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Eupatorium.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Eupatorium")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerMap(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } + } + + enum GryphosaurusElement: Codable { + case gryphosaurusClass(TopLevel.GryphosaurusClass) + case integerArray([Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(TopLevel.GryphosaurusClass.self) { + self = .gryphosaurusClass(x) + return + } + throw DecodingError.typeMismatch(GryphosaurusElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for GryphosaurusElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .gryphosaurusClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + struct GryphosaurusClass: Codable { + let amissibility: JSONNull? + let burushaski: JSONNull? + let citronin: JSONNull? + let coplaintiff: JSONNull? + let disquisitionary: JSONNull? + let enoplan: JSONNull? + let faintness: JSONNull? + let hebetomy: JSONNull? + let islandry: JSONNull? + let lameduck: JSONNull? + let overbattle: JSONNull? + let overinterested: JSONNull? + let phrenologic: JSONNull? + let rainband: JSONNull? + let shiningly: JSONNull? + let stamineous: JSONNull? + let subscapularis: JSONNull? + let tahami: JSONNull? + let undaubed: JSONNull? + let underntime: JSONNull? + + enum CodingKeys: String, CodingKey { + case amissibility = "amissibility" + case burushaski = "Burushaski" + case citronin = "citronin" + case coplaintiff = "coplaintiff" + case disquisitionary = "disquisitionary" + case enoplan = "enoplan" + case faintness = "faintness" + case hebetomy = "hebetomy" + case islandry = "islandry" + case lameduck = "lameduck" + case overbattle = "overbattle" + case overinterested = "overinterested" + case phrenologic = "phrenologic" + case rainband = "rainband" + case shiningly = "shiningly" + case stamineous = "stamineous" + case subscapularis = "subscapularis" + case tahami = "Tahami" + case undaubed = "undaubed" + case underntime = "underntime" + } + } + + enum Koryak: Codable { + case string(String) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Koryak.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Koryak")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .string(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } + } + + enum LaviniaElement: Codable { + case laviniaClass(TopLevel.LaviniaClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(TopLevel.LaviniaClass.self) { + self = .laviniaClass(x) + return + } + throw DecodingError.typeMismatch(LaviniaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for LaviniaElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .laviniaClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + struct LaviniaClass: Codable { + let agitable: Int? + let asininity: Int? + let benefiter: Int? + let bronzelike: Int? + let catharticalness: Double? + let chirotherium: Int? + let cholesteatomatous: Int? + let deprivement: Int? + let disdiapason: String? + let flippantness: Int? + let fogproof: Int? + let homocerc: Bool? + let merrymeeting: Int? + let nonbookish: JSONNull? + let overcareful: Int? + let panaris: Int? + let preacceptance: Int? + let quinoxaline: Int? + let sig: Int? + let superconfusion: Int? + let tacana: Int? + let tillotter: Int? + let tranquillize: Int? + let unquestionable: Int? + let uproute: Int? + + enum CodingKeys: String, CodingKey { + case agitable = "agitable" + case asininity = "asininity" + case benefiter = "benefiter" + case bronzelike = "bronzelike" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case cholesteatomatous = "cholesteatomatous" + case deprivement = "deprivement" + case disdiapason = "disdiapason" + case flippantness = "flippantness" + case fogproof = "fogproof" + case homocerc = "homocerc" + case merrymeeting = "merrymeeting" + case nonbookish = "nonbookish" + case overcareful = "overcareful" + case panaris = "panaris" + case preacceptance = "preacceptance" + case quinoxaline = "quinoxaline" + case sig = "sig" + case superconfusion = "superconfusion" + case tacana = "Tacana" + case tillotter = "tillotter" + case tranquillize = "tranquillize" + case unquestionable = "unquestionable" + case uproute = "uproute" + } + } + + enum OskarElement: Codable { + case integerArray([Int]) + case oskarClass(TopLevel.OskarClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(TopLevel.OskarClass.self) { + self = .oskarClass(x) + return + } + throw DecodingError.typeMismatch(OskarElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for OskarElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .oskarClass(let x): + try container.encode(x) + } + } + } + + struct OskarClass: Codable { + let acrobates: JSONNull? + let beanshooter: JSONNull? + let bearhound: JSONNull? + let cayuga: JSONNull? + let guarneri: JSONNull? + let hypochondriacism: JSONNull? + let indication: JSONNull? + let jaculative: JSONNull? + let nagana: JSONNull? + let netherlandish: JSONNull? + let noctivagous: JSONNull? + let nonphysiological: JSONNull? + let praxis: JSONNull? + let provision: JSONNull? + let subterhuman: JSONNull? + let sunlit: JSONNull? + let syncraniate: JSONNull? + let teachment: JSONNull? + let unmutinous: JSONNull? + let unstoppable: JSONNull? + + enum CodingKeys: String, CodingKey { + case acrobates = "Acrobates" + case beanshooter = "beanshooter" + case bearhound = "bearhound" + case cayuga = "Cayuga" + case guarneri = "guarneri" + case hypochondriacism = "hypochondriacism" + case indication = "indication" + case jaculative = "jaculative" + case nagana = "nagana" + case netherlandish = "Netherlandish" + case noctivagous = "noctivagous" + case nonphysiological = "nonphysiological" + case praxis = "praxis" + case provision = "provision" + case subterhuman = "subterhuman" + case sunlit = "sunlit" + case syncraniate = "syncraniate" + case teachment = "teachment" + case unmutinous = "unmutinous" + case unstoppable = "unstoppable" + } + } + + enum RebeccaElement: Codable { + case integer(Int) + case rebecca(TopLevel.Rebecca) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(TopLevel.Rebecca.self) { + self = .rebecca(x) + return + } + throw DecodingError.typeMismatch(RebeccaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for RebeccaElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .rebecca(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + struct Rebecca: Codable { + let catharticalness: Double + let chirotherium: Int + let disdiapason: String + let homocerc: Bool + let nonbookish: JSONNull? + + enum CodingKeys: String, CodingKey { + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case homocerc = "homocerc" + case nonbookish = "nonbookish" + } + } + + enum Rhomboganoidei: Codable { + case integerArray([Int]) + case rebecca(TopLevel.Rebecca) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(TopLevel.Rebecca.self) { + self = .rebecca(x) + return + } + throw DecodingError.typeMismatch(Rhomboganoidei.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Rhomboganoidei")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .rebecca(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + enum Ruellia: Codable { + case bool(Bool) + case rebecca(TopLevel.Rebecca) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(TopLevel.Rebecca.self) { + self = .rebecca(x) + return + } + throw DecodingError.typeMismatch(Ruellia.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Ruellia")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .rebecca(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + enum School: Codable { + case integer(Int) + case integerMap([String: Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(School.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for School")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } + } + + enum Shakespearolater: Codable { + case double(Double) + case integerArray([Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Shakespearolater.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Shakespearolater")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + enum Academe: Codable { + case integer(Int) + case integerArray([Int]) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Academe.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Academe")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } + } + + enum Acquirable: Codable { + case integerMap([String: Int]) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Acquirable.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Acquirable")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerMap(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } + } + + enum Aerometry: Codable { + case bool(Bool) + case double(Double) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Aerometry.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Aerometry")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + } + } + } + + enum Alexin: Codable { + case bool(Bool) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + throw DecodingError.typeMismatch(Alexin.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Alexin")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } + } + + enum AlleviateElement: Codable { + case alleviateClass(TopLevel.AlleviateClass) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + if let x = try? container.decode(TopLevel.AlleviateClass.self) { + self = .alleviateClass(x) + return + } + throw DecodingError.typeMismatch(AlleviateElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for AlleviateElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .alleviateClass(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } + } + + struct AlleviateClass: Codable { + let apriori: JSONNull? + let beggarer: JSONNull? + let brokenheartedly: JSONNull? + let debilitation: JSONNull? + let frike: JSONNull? + let gastrolith: JSONNull? + let hulsean: JSONNull? + let orthocentric: JSONNull? + let petaly: JSONNull? + let probudgeting: JSONNull? + let reacquire: JSONNull? + let scow: JSONNull? + let shutoff: JSONNull? + let subcontiguous: JSONNull? + let suffumigate: JSONNull? + let transformable: JSONNull? + let uncoroneted: JSONNull? + let unparking: JSONNull? + let unvarnishedness: JSONNull? + let wherewithal: JSONNull? + + enum CodingKeys: String, CodingKey { + case apriori = "apriori" + case beggarer = "beggarer" + case brokenheartedly = "brokenheartedly" + case debilitation = "debilitation" + case frike = "frike" + case gastrolith = "gastrolith" + case hulsean = "Hulsean" + case orthocentric = "orthocentric" + case petaly = "petaly" + case probudgeting = "probudgeting" + case reacquire = "reacquire" + case scow = "scow" + case shutoff = "shutoff" + case subcontiguous = "subcontiguous" + case suffumigate = "suffumigate" + case transformable = "transformable" + case uncoroneted = "uncoroneted" + case unparking = "unparking" + case unvarnishedness = "unvarnishedness" + case wherewithal = "wherewithal" + } + } + + enum Amaa: Codable { + case bool(Bool) + case integer(Int) + case rebecca(TopLevel.Rebecca) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(TopLevel.Rebecca.self) { + self = .rebecca(x) + return + } + throw DecodingError.typeMismatch(Amaa.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Amaa")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .rebecca(let x): + try container.encode(x) + } + } + } + + enum Ambassage: Codable { + case nullArray([JSONNull?]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Ambassage.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Ambassage")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + struct Amphithyron: Codable { + let akroasis: Int? + let antiphonical: Int? + let basebred: Int? + let catharticalness: Double? + let chirotherium: Int? + let conductometric: Int? + let disdiapason: String? + let ensilation: Int? + let eyebolt: Int? + let fistulated: Int? + let heteropod: Int? + let homocerc: Bool? + let juniperus: Int? + let labyrinthically: Int? + let martyrization: Int? + let mispolicy: Int? + let multipara: Int? + let nazirite: Int? + let nonbookish: JSONNull? + let possessorial: Int? + let shamed: Int? + let shelfworn: Int? + let stagnum: Int? + let those: Int? + let undecimal: Int? + + enum CodingKeys: String, CodingKey { + case akroasis = "akroasis" + case antiphonical = "antiphonical" + case basebred = "basebred" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case conductometric = "conductometric" + case disdiapason = "disdiapason" + case ensilation = "ensilation" + case eyebolt = "eyebolt" + case fistulated = "fistulated" + case heteropod = "heteropod" + case homocerc = "homocerc" + case juniperus = "Juniperus" + case labyrinthically = "labyrinthically" + case martyrization = "martyrization" + case mispolicy = "mispolicy" + case multipara = "multipara" + case nazirite = "Nazirite" + case nonbookish = "nonbookish" + case possessorial = "possessorial" + case shamed = "shamed" + case shelfworn = "shelfworn" + case stagnum = "stagnum" + case those = "Those" + case undecimal = "undecimal" + } + } + + enum AnkeeElement: Codable { + case ankeeClass(TopLevel.AnkeeClass) + case integer(Int) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(TopLevel.AnkeeClass.self) { + self = .ankeeClass(x) + return + } + throw DecodingError.typeMismatch(AnkeeElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for AnkeeElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .ankeeClass(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } + } + + struct AnkeeClass: Codable { + let anomoean: JSONNull? + let barleyhood: JSONNull? + let befriender: JSONNull? + let brutishness: JSONNull? + let cephalalgy: JSONNull? + let cirurgian: JSONNull? + let conventionally: JSONNull? + let jackshay: JSONNull? + let milammeter: JSONNull? + let naja: JSONNull? + let ombrological: JSONNull? + let phonasthenia: JSONNull? + let retrievableness: JSONNull? + let snakily: JSONNull? + let swot: JSONNull? + let tartlet: JSONNull? + let thiofuran: JSONNull? + let tracheophone: JSONNull? + let tuglike: JSONNull? + let unscratchingly: JSONNull? + + enum CodingKeys: String, CodingKey { + case anomoean = "Anomoean" + case barleyhood = "barleyhood" + case befriender = "befriender" + case brutishness = "brutishness" + case cephalalgy = "cephalalgy" + case cirurgian = "cirurgian" + case conventionally = "conventionally" + case jackshay = "jackshay" + case milammeter = "milammeter" + case naja = "Naja" + case ombrological = "ombrological" + case phonasthenia = "phonasthenia" + case retrievableness = "retrievableness" + case snakily = "snakily" + case swot = "swot" + case tartlet = "tartlet" + case thiofuran = "thiofuran" + case tracheophone = "tracheophone" + case tuglike = "tuglike" + case unscratchingly = "unscratchingly" + } + } + + enum Aphasia: Codable { + case integer(Int) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + throw DecodingError.typeMismatch(Aphasia.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Aphasia")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } + } + + enum Asprawl: Codable { + case double(Double) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Asprawl.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Asprawl")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + enum Bedesman: Codable { + case bool(Bool) + case double(Double) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Bedesman.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Bedesman")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + enum Belard: Codable { + case double(Double) + case integerArray([Int]) + case rebecca(TopLevel.Rebecca) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(TopLevel.Rebecca.self) { + self = .rebecca(x) + return + } + throw DecodingError.typeMismatch(Belard.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Belard")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .rebecca(let x): + try container.encode(x) + } + } + } + + enum Bocking: Codable { + case bool(Bool) + case integerArray([Int]) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Bocking.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Bocking")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } + } + + enum Brawlingly: Codable { + case nullArray([JSONNull?]) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + throw DecodingError.typeMismatch(Brawlingly.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Brawlingly")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } + } + + enum Brookie: Codable { + case integerArray([Int]) + case rebecca(TopLevel.Rebecca) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(TopLevel.Rebecca.self) { + self = .rebecca(x) + return + } + throw DecodingError.typeMismatch(Brookie.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Brookie")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .rebecca(let x): + try container.encode(x) + } + } + } + + enum Bumboatman: Codable { + case nullArray([JSONNull?]) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Bumboatman.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Bumboatman")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } + } + + enum Calaverite: Codable { + case integerArray([Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Calaverite.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Calaverite")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + enum Catallactic: Codable { + case bool(Bool) + case integerMap([String: Int]) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Catallactic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Catallactic")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } + } + + enum Cemental: Codable { + case double(Double) + case integerArray([Int]) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Cemental.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Cemental")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } + } + + // MARK: Helper functions for creating encoders and decoders + static func newJSONDecoder() -> JSONDecoder { + let decoder = JSONDecoder() + decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in + let container = try decoder.singleValueContainer() + let dateStr = try container.decode(String.self) + + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date")) + }) + return decoder + } + + static func newJSONEncoder() -> JSONEncoder { + let encoder = JSONEncoder() + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder + } +} + +// MARK: TopLevel convenience initializers and mutators + +extension TopLevel { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + abranchiata: [TopLevel.Abranchiata]? = nil, + academe: [TopLevel.Academe]? = nil, + acquirable: [TopLevel.Acquirable]? = nil, + aerometry: [TopLevel.Aerometry]? = nil, + alexin: [TopLevel.Alexin]? = nil, + alleviate: [TopLevel.AlleviateElement]? = nil, + amaas: [TopLevel.Amaa]? = nil, + ambassage: [TopLevel.Ambassage]? = nil, + amphithyron: [TopLevel.Amphithyron?]? = nil, + andriana: [String?]? = nil, + ankee: [TopLevel.AnkeeElement]? = nil, + annihilator: [[String: Int?]?]? = nil, + annulose: JSONNull?? = nil, + ansarie: [TopLevel.AnsarieElement]? = nil, + aphasia: [TopLevel.Aphasia]? = nil, + asprawl: [TopLevel.Asprawl]? = nil, + attractive: [Bool?]? = nil, + barksome: [String: Int]? = nil, + bedesman: [TopLevel.Bedesman]? = nil, + belard: [TopLevel.Belard]? = nil, + bocking: [TopLevel.Bocking]? = nil, + brawlingly: [TopLevel.Brawlingly]? = nil, + brookie: [TopLevel.Brookie]? = nil, + bumboatman: [TopLevel.Bumboatman]? = nil, + bystreet: [JSONNull?]? = nil, + calaverite: [TopLevel.Calaverite]? = nil, + catallactic: [TopLevel.Catallactic]? = nil, + cemental: [TopLevel.Cemental]? = nil, + chytridiaceae: [TopLevel.ChytridiaceaeElement]? = nil, + discordia: [TopLevel.DiscordiaElement]? = nil, + endomyces: [TopLevel.Endomyce]? = nil, + epinephelidae: [TopLevel.Epinephelidae]? = nil, + eupatorium: [TopLevel.Eupatorium]? = nil, + gryphosaurus: [TopLevel.GryphosaurusElement]? = nil, + koryak: [TopLevel.Koryak]? = nil, + lavinia: [TopLevel.LaviniaElement]? = nil, + oskar: [TopLevel.OskarElement]? = nil, + rebecca: [TopLevel.RebeccaElement]? = nil, + rhomboganoidei: [TopLevel.Rhomboganoidei]? = nil, + rigsmal: Bool? = nil, + ruellia: [TopLevel.Ruellia]? = nil, + school: [TopLevel.School]? = nil, + shakespearolater: [TopLevel.Shakespearolater]? = nil, + svan: [Double]? = nil, + wayao: [String: Double]? = nil + ) -> TopLevel { + return TopLevel( + abranchiata: abranchiata ?? self.abranchiata, + academe: academe ?? self.academe, + acquirable: acquirable ?? self.acquirable, + aerometry: aerometry ?? self.aerometry, + alexin: alexin ?? self.alexin, + alleviate: alleviate ?? self.alleviate, + amaas: amaas ?? self.amaas, + ambassage: ambassage ?? self.ambassage, + amphithyron: amphithyron ?? self.amphithyron, + andriana: andriana ?? self.andriana, + ankee: ankee ?? self.ankee, + annihilator: annihilator ?? self.annihilator, + annulose: annulose ?? self.annulose, + ansarie: ansarie ?? self.ansarie, + aphasia: aphasia ?? self.aphasia, + asprawl: asprawl ?? self.asprawl, + attractive: attractive ?? self.attractive, + barksome: barksome ?? self.barksome, + bedesman: bedesman ?? self.bedesman, + belard: belard ?? self.belard, + bocking: bocking ?? self.bocking, + brawlingly: brawlingly ?? self.brawlingly, + brookie: brookie ?? self.brookie, + bumboatman: bumboatman ?? self.bumboatman, + bystreet: bystreet ?? self.bystreet, + calaverite: calaverite ?? self.calaverite, + catallactic: catallactic ?? self.catallactic, + cemental: cemental ?? self.cemental, + chytridiaceae: chytridiaceae ?? self.chytridiaceae, + discordia: discordia ?? self.discordia, + endomyces: endomyces ?? self.endomyces, + epinephelidae: epinephelidae ?? self.epinephelidae, + eupatorium: eupatorium ?? self.eupatorium, + gryphosaurus: gryphosaurus ?? self.gryphosaurus, + koryak: koryak ?? self.koryak, + lavinia: lavinia ?? self.lavinia, + oskar: oskar ?? self.oskar, + rebecca: rebecca ?? self.rebecca, + rhomboganoidei: rhomboganoidei ?? self.rhomboganoidei, + rigsmal: rigsmal ?? self.rigsmal, + ruellia: ruellia ?? self.ruellia, + school: school ?? self.school, + shakespearolater: shakespearolater ?? self.shakespearolater, + svan: svan ?? self.svan, + wayao: wayao ?? self.wayao + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.AnsarieClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.AnsarieClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + accension: JSONNull?? = nil, + alida: JSONNull?? = nil, + asteria: JSONNull?? = nil, + beriberic: JSONNull?? = nil, + edgebone: JSONNull?? = nil, + gastrodialysis: JSONNull?? = nil, + geographic: JSONNull?? = nil, + ictonyx: JSONNull?? = nil, + metrocele: JSONNull?? = nil, + misgraft: JSONNull?? = nil, + monteith: JSONNull?? = nil, + notcher: JSONNull?? = nil, + prorestriction: JSONNull?? = nil, + ramist: JSONNull?? = nil, + throatlet: JSONNull?? = nil, + unfair: JSONNull?? = nil, + unsynonymous: JSONNull?? = nil, + water: JSONNull?? = nil, + zestfully: JSONNull?? = nil, + zincic: JSONNull?? = nil + ) -> TopLevel.AnsarieClass { + return TopLevel.AnsarieClass( + accension: accension ?? self.accension, + alida: alida ?? self.alida, + asteria: asteria ?? self.asteria, + beriberic: beriberic ?? self.beriberic, + edgebone: edgebone ?? self.edgebone, + gastrodialysis: gastrodialysis ?? self.gastrodialysis, + geographic: geographic ?? self.geographic, + ictonyx: ictonyx ?? self.ictonyx, + metrocele: metrocele ?? self.metrocele, + misgraft: misgraft ?? self.misgraft, + monteith: monteith ?? self.monteith, + notcher: notcher ?? self.notcher, + prorestriction: prorestriction ?? self.prorestriction, + ramist: ramist ?? self.ramist, + throatlet: throatlet ?? self.throatlet, + unfair: unfair ?? self.unfair, + unsynonymous: unsynonymous ?? self.unsynonymous, + water: water ?? self.water, + zestfully: zestfully ?? self.zestfully, + zincic: zincic ?? self.zincic + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.ChytridiaceaeClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.ChytridiaceaeClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + batidaceae: JSONNull?? = nil, + brechites: JSONNull?? = nil, + codespairer: JSONNull?? = nil, + emery: JSONNull?? = nil, + enervative: JSONNull?? = nil, + excriminate: JSONNull?? = nil, + goshenite: JSONNull?? = nil, + grime: JSONNull?? = nil, + gritten: JSONNull?? = nil, + hectorly: JSONNull?? = nil, + intermediation: JSONNull?? = nil, + meeterly: JSONNull?? = nil, + narraganset: JSONNull?? = nil, + onymatic: JSONNull?? = nil, + paddlecock: JSONNull?? = nil, + thana: JSONNull?? = nil, + thornily: JSONNull?? = nil, + uckia: JSONNull?? = nil, + unmettle: JSONNull?? = nil, + vorticellid: JSONNull?? = nil + ) -> TopLevel.ChytridiaceaeClass { + return TopLevel.ChytridiaceaeClass( + batidaceae: batidaceae ?? self.batidaceae, + brechites: brechites ?? self.brechites, + codespairer: codespairer ?? self.codespairer, + emery: emery ?? self.emery, + enervative: enervative ?? self.enervative, + excriminate: excriminate ?? self.excriminate, + goshenite: goshenite ?? self.goshenite, + grime: grime ?? self.grime, + gritten: gritten ?? self.gritten, + hectorly: hectorly ?? self.hectorly, + intermediation: intermediation ?? self.intermediation, + meeterly: meeterly ?? self.meeterly, + narraganset: narraganset ?? self.narraganset, + onymatic: onymatic ?? self.onymatic, + paddlecock: paddlecock ?? self.paddlecock, + thana: thana ?? self.thana, + thornily: thornily ?? self.thornily, + uckia: uckia ?? self.uckia, + unmettle: unmettle ?? self.unmettle, + vorticellid: vorticellid ?? self.vorticellid + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.DiscordiaClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.DiscordiaClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + altaic: Int?? = nil, + amoristic: Int?? = nil, + blennophthalmia: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + disciplinability: Int?? = nil, + disdiapason: String?? = nil, + goofer: Int?? = nil, + homocerc: Bool?? = nil, + laryngograph: Int?? = nil, + leucitis: Int?? = nil, + lymphocyst: Int?? = nil, + microcosmology: Int?? = nil, + nauseation: Int?? = nil, + nonbookish: JSONNull?? = nil, + patarin: Int?? = nil, + preliberal: Int?? = nil, + prettifier: Int?? = nil, + rangework: Int?? = nil, + redient: Int?? = nil, + subfusiform: Int?? = nil, + suicidical: Int?? = nil, + swow: Int?? = nil, + wastrel: Int?? = nil, + wingle: Int?? = nil + ) -> TopLevel.DiscordiaClass { + return TopLevel.DiscordiaClass( + altaic: altaic ?? self.altaic, + amoristic: amoristic ?? self.amoristic, + blennophthalmia: blennophthalmia ?? self.blennophthalmia, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disciplinability: disciplinability ?? self.disciplinability, + disdiapason: disdiapason ?? self.disdiapason, + goofer: goofer ?? self.goofer, + homocerc: homocerc ?? self.homocerc, + laryngograph: laryngograph ?? self.laryngograph, + leucitis: leucitis ?? self.leucitis, + lymphocyst: lymphocyst ?? self.lymphocyst, + microcosmology: microcosmology ?? self.microcosmology, + nauseation: nauseation ?? self.nauseation, + nonbookish: nonbookish ?? self.nonbookish, + patarin: patarin ?? self.patarin, + preliberal: preliberal ?? self.preliberal, + prettifier: prettifier ?? self.prettifier, + rangework: rangework ?? self.rangework, + redient: redient ?? self.redient, + subfusiform: subfusiform ?? self.subfusiform, + suicidical: suicidical ?? self.suicidical, + swow: swow ?? self.swow, + wastrel: wastrel ?? self.wastrel, + wingle: wingle ?? self.wingle + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.GryphosaurusClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.GryphosaurusClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + amissibility: JSONNull?? = nil, + burushaski: JSONNull?? = nil, + citronin: JSONNull?? = nil, + coplaintiff: JSONNull?? = nil, + disquisitionary: JSONNull?? = nil, + enoplan: JSONNull?? = nil, + faintness: JSONNull?? = nil, + hebetomy: JSONNull?? = nil, + islandry: JSONNull?? = nil, + lameduck: JSONNull?? = nil, + overbattle: JSONNull?? = nil, + overinterested: JSONNull?? = nil, + phrenologic: JSONNull?? = nil, + rainband: JSONNull?? = nil, + shiningly: JSONNull?? = nil, + stamineous: JSONNull?? = nil, + subscapularis: JSONNull?? = nil, + tahami: JSONNull?? = nil, + undaubed: JSONNull?? = nil, + underntime: JSONNull?? = nil + ) -> TopLevel.GryphosaurusClass { + return TopLevel.GryphosaurusClass( + amissibility: amissibility ?? self.amissibility, + burushaski: burushaski ?? self.burushaski, + citronin: citronin ?? self.citronin, + coplaintiff: coplaintiff ?? self.coplaintiff, + disquisitionary: disquisitionary ?? self.disquisitionary, + enoplan: enoplan ?? self.enoplan, + faintness: faintness ?? self.faintness, + hebetomy: hebetomy ?? self.hebetomy, + islandry: islandry ?? self.islandry, + lameduck: lameduck ?? self.lameduck, + overbattle: overbattle ?? self.overbattle, + overinterested: overinterested ?? self.overinterested, + phrenologic: phrenologic ?? self.phrenologic, + rainband: rainband ?? self.rainband, + shiningly: shiningly ?? self.shiningly, + stamineous: stamineous ?? self.stamineous, + subscapularis: subscapularis ?? self.subscapularis, + tahami: tahami ?? self.tahami, + undaubed: undaubed ?? self.undaubed, + underntime: underntime ?? self.underntime + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.LaviniaClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.LaviniaClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + agitable: Int?? = nil, + asininity: Int?? = nil, + benefiter: Int?? = nil, + bronzelike: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + cholesteatomatous: Int?? = nil, + deprivement: Int?? = nil, + disdiapason: String?? = nil, + flippantness: Int?? = nil, + fogproof: Int?? = nil, + homocerc: Bool?? = nil, + merrymeeting: Int?? = nil, + nonbookish: JSONNull?? = nil, + overcareful: Int?? = nil, + panaris: Int?? = nil, + preacceptance: Int?? = nil, + quinoxaline: Int?? = nil, + sig: Int?? = nil, + superconfusion: Int?? = nil, + tacana: Int?? = nil, + tillotter: Int?? = nil, + tranquillize: Int?? = nil, + unquestionable: Int?? = nil, + uproute: Int?? = nil + ) -> TopLevel.LaviniaClass { + return TopLevel.LaviniaClass( + agitable: agitable ?? self.agitable, + asininity: asininity ?? self.asininity, + benefiter: benefiter ?? self.benefiter, + bronzelike: bronzelike ?? self.bronzelike, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + cholesteatomatous: cholesteatomatous ?? self.cholesteatomatous, + deprivement: deprivement ?? self.deprivement, + disdiapason: disdiapason ?? self.disdiapason, + flippantness: flippantness ?? self.flippantness, + fogproof: fogproof ?? self.fogproof, + homocerc: homocerc ?? self.homocerc, + merrymeeting: merrymeeting ?? self.merrymeeting, + nonbookish: nonbookish ?? self.nonbookish, + overcareful: overcareful ?? self.overcareful, + panaris: panaris ?? self.panaris, + preacceptance: preacceptance ?? self.preacceptance, + quinoxaline: quinoxaline ?? self.quinoxaline, + sig: sig ?? self.sig, + superconfusion: superconfusion ?? self.superconfusion, + tacana: tacana ?? self.tacana, + tillotter: tillotter ?? self.tillotter, + tranquillize: tranquillize ?? self.tranquillize, + unquestionable: unquestionable ?? self.unquestionable, + uproute: uproute ?? self.uproute + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.OskarClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.OskarClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + acrobates: JSONNull?? = nil, + beanshooter: JSONNull?? = nil, + bearhound: JSONNull?? = nil, + cayuga: JSONNull?? = nil, + guarneri: JSONNull?? = nil, + hypochondriacism: JSONNull?? = nil, + indication: JSONNull?? = nil, + jaculative: JSONNull?? = nil, + nagana: JSONNull?? = nil, + netherlandish: JSONNull?? = nil, + noctivagous: JSONNull?? = nil, + nonphysiological: JSONNull?? = nil, + praxis: JSONNull?? = nil, + provision: JSONNull?? = nil, + subterhuman: JSONNull?? = nil, + sunlit: JSONNull?? = nil, + syncraniate: JSONNull?? = nil, + teachment: JSONNull?? = nil, + unmutinous: JSONNull?? = nil, + unstoppable: JSONNull?? = nil + ) -> TopLevel.OskarClass { + return TopLevel.OskarClass( + acrobates: acrobates ?? self.acrobates, + beanshooter: beanshooter ?? self.beanshooter, + bearhound: bearhound ?? self.bearhound, + cayuga: cayuga ?? self.cayuga, + guarneri: guarneri ?? self.guarneri, + hypochondriacism: hypochondriacism ?? self.hypochondriacism, + indication: indication ?? self.indication, + jaculative: jaculative ?? self.jaculative, + nagana: nagana ?? self.nagana, + netherlandish: netherlandish ?? self.netherlandish, + noctivagous: noctivagous ?? self.noctivagous, + nonphysiological: nonphysiological ?? self.nonphysiological, + praxis: praxis ?? self.praxis, + provision: provision ?? self.provision, + subterhuman: subterhuman ?? self.subterhuman, + sunlit: sunlit ?? self.sunlit, + syncraniate: syncraniate ?? self.syncraniate, + teachment: teachment ?? self.teachment, + unmutinous: unmutinous ?? self.unmutinous, + unstoppable: unstoppable ?? self.unstoppable + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.Rebecca { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.Rebecca.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + catharticalness: Double? = nil, + chirotherium: Int? = nil, + disdiapason: String? = nil, + homocerc: Bool? = nil, + nonbookish: JSONNull?? = nil + ) -> TopLevel.Rebecca { + return TopLevel.Rebecca( + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + homocerc: homocerc ?? self.homocerc, + nonbookish: nonbookish ?? self.nonbookish + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.AlleviateClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.AlleviateClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + apriori: JSONNull?? = nil, + beggarer: JSONNull?? = nil, + brokenheartedly: JSONNull?? = nil, + debilitation: JSONNull?? = nil, + frike: JSONNull?? = nil, + gastrolith: JSONNull?? = nil, + hulsean: JSONNull?? = nil, + orthocentric: JSONNull?? = nil, + petaly: JSONNull?? = nil, + probudgeting: JSONNull?? = nil, + reacquire: JSONNull?? = nil, + scow: JSONNull?? = nil, + shutoff: JSONNull?? = nil, + subcontiguous: JSONNull?? = nil, + suffumigate: JSONNull?? = nil, + transformable: JSONNull?? = nil, + uncoroneted: JSONNull?? = nil, + unparking: JSONNull?? = nil, + unvarnishedness: JSONNull?? = nil, + wherewithal: JSONNull?? = nil + ) -> TopLevel.AlleviateClass { + return TopLevel.AlleviateClass( + apriori: apriori ?? self.apriori, + beggarer: beggarer ?? self.beggarer, + brokenheartedly: brokenheartedly ?? self.brokenheartedly, + debilitation: debilitation ?? self.debilitation, + frike: frike ?? self.frike, + gastrolith: gastrolith ?? self.gastrolith, + hulsean: hulsean ?? self.hulsean, + orthocentric: orthocentric ?? self.orthocentric, + petaly: petaly ?? self.petaly, + probudgeting: probudgeting ?? self.probudgeting, + reacquire: reacquire ?? self.reacquire, + scow: scow ?? self.scow, + shutoff: shutoff ?? self.shutoff, + subcontiguous: subcontiguous ?? self.subcontiguous, + suffumigate: suffumigate ?? self.suffumigate, + transformable: transformable ?? self.transformable, + uncoroneted: uncoroneted ?? self.uncoroneted, + unparking: unparking ?? self.unparking, + unvarnishedness: unvarnishedness ?? self.unvarnishedness, + wherewithal: wherewithal ?? self.wherewithal + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.Amphithyron { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.Amphithyron.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + akroasis: Int?? = nil, + antiphonical: Int?? = nil, + basebred: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + conductometric: Int?? = nil, + disdiapason: String?? = nil, + ensilation: Int?? = nil, + eyebolt: Int?? = nil, + fistulated: Int?? = nil, + heteropod: Int?? = nil, + homocerc: Bool?? = nil, + juniperus: Int?? = nil, + labyrinthically: Int?? = nil, + martyrization: Int?? = nil, + mispolicy: Int?? = nil, + multipara: Int?? = nil, + nazirite: Int?? = nil, + nonbookish: JSONNull?? = nil, + possessorial: Int?? = nil, + shamed: Int?? = nil, + shelfworn: Int?? = nil, + stagnum: Int?? = nil, + those: Int?? = nil, + undecimal: Int?? = nil + ) -> TopLevel.Amphithyron { + return TopLevel.Amphithyron( + akroasis: akroasis ?? self.akroasis, + antiphonical: antiphonical ?? self.antiphonical, + basebred: basebred ?? self.basebred, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + conductometric: conductometric ?? self.conductometric, + disdiapason: disdiapason ?? self.disdiapason, + ensilation: ensilation ?? self.ensilation, + eyebolt: eyebolt ?? self.eyebolt, + fistulated: fistulated ?? self.fistulated, + heteropod: heteropod ?? self.heteropod, + homocerc: homocerc ?? self.homocerc, + juniperus: juniperus ?? self.juniperus, + labyrinthically: labyrinthically ?? self.labyrinthically, + martyrization: martyrization ?? self.martyrization, + mispolicy: mispolicy ?? self.mispolicy, + multipara: multipara ?? self.multipara, + nazirite: nazirite ?? self.nazirite, + nonbookish: nonbookish ?? self.nonbookish, + possessorial: possessorial ?? self.possessorial, + shamed: shamed ?? self.shamed, + shelfworn: shelfworn ?? self.shelfworn, + stagnum: stagnum ?? self.stagnum, + those: those ?? self.those, + undecimal: undecimal ?? self.undecimal + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.AnkeeClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.AnkeeClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + anomoean: JSONNull?? = nil, + barleyhood: JSONNull?? = nil, + befriender: JSONNull?? = nil, + brutishness: JSONNull?? = nil, + cephalalgy: JSONNull?? = nil, + cirurgian: JSONNull?? = nil, + conventionally: JSONNull?? = nil, + jackshay: JSONNull?? = nil, + milammeter: JSONNull?? = nil, + naja: JSONNull?? = nil, + ombrological: JSONNull?? = nil, + phonasthenia: JSONNull?? = nil, + retrievableness: JSONNull?? = nil, + snakily: JSONNull?? = nil, + swot: JSONNull?? = nil, + tartlet: JSONNull?? = nil, + thiofuran: JSONNull?? = nil, + tracheophone: JSONNull?? = nil, + tuglike: JSONNull?? = nil, + unscratchingly: JSONNull?? = nil + ) -> TopLevel.AnkeeClass { + return TopLevel.AnkeeClass( + anomoean: anomoean ?? self.anomoean, + barleyhood: barleyhood ?? self.barleyhood, + befriender: befriender ?? self.befriender, + brutishness: brutishness ?? self.brutishness, + cephalalgy: cephalalgy ?? self.cephalalgy, + cirurgian: cirurgian ?? self.cirurgian, + conventionally: conventionally ?? self.conventionally, + jackshay: jackshay ?? self.jackshay, + milammeter: milammeter ?? self.milammeter, + naja: naja ?? self.naja, + ombrological: ombrological ?? self.ombrological, + phonasthenia: phonasthenia ?? self.phonasthenia, + retrievableness: retrievableness ?? self.retrievableness, + snakily: snakily ?? self.snakily, + swot: swot ?? self.swot, + tartlet: tartlet ?? self.tartlet, + thiofuran: thiofuran ?? self.thiofuran, + tracheophone: tracheophone ?? self.tracheophone, + tuglike: tuglike ?? self.tuglike, + unscratchingly: unscratchingly ?? self.unscratchingly + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - Encode/decode helpers + +class JSONNull: Codable, Hashable { + + public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool { + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(0) + } + + public init() {} + + public required init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if !container.decodeNil() { + throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull")) + } + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + try container.encodeNil() + } +} diff --git a/head/swift/test/inputs/json/priority/combinations3.json/nest-types-true--d03bdf4b0ab1/quicktype.swift b/head/swift/test/inputs/json/priority/combinations3.json/nest-types-true--d03bdf4b0ab1/quicktype.swift new file mode 100644 index 0000000..f82d268 --- /dev/null +++ b/head/swift/test/inputs/json/priority/combinations3.json/nest-types-true--d03bdf4b0ab1/quicktype.swift @@ -0,0 +1,3094 @@ +// This file was generated from JSON Schema using quicktype, do not modify it directly. +// To parse the JSON, add this file to your project and do: +// +// let topLevel = try TopLevel(json) + +import Foundation + +// MARK: - TopLevel +struct TopLevel: Codable { + let juror: [TopLevel.JurorElement] + let kongoni: [TopLevel.Kongoni] + let ladronism: [TopLevel.LadronismElement] + let landlubberly: [TopLevel.LandlubberlyElement] + let listener: [TopLevel.Listener] + let lupus: [TopLevel.LupusElement] + let maslin: [TopLevel.Maslin] + let monazite: [TopLevel.MonaziteElement] + let monoliteral: [TopLevel.Monoliteral] + let monotheistically: [TopLevel.MonotheisticallyElement] + let montage: [TopLevel.Montage] + let moralness: [TopLevel.Moralness] + let mowra: [TopLevel.MonaziteClass?] + let mulishly: [TopLevel.Mulishly] + let myoscope: [TopLevel.Myoscope] + let nach: [[Int?]?] + let neuromastic: [TopLevel.Neuromastic] + let noncontributing: [TopLevel.Noncontributing] + let nonnervous: [TopLevel.Nonnervous] + let nonvaluation: [TopLevel.Nonvaluation] + let occupationalist: [TopLevel.OccupationalistElement] + let outrival: [TopLevel.OutrivalElement] + let paleographically: [TopLevel.Paleographically] + let pamphletwise: [TopLevel.Pamphletwise] + let pediatrics: [TopLevel.Pediatric] + let perceptive: [Bool] + let piaculum: [TopLevel.PiaculumElement] + let piccadilly: [TopLevel.Piccadilly] + let piffler: [TopLevel.Piffler] + let pithful: [TopLevel.Pithful] + let placuntitis: [TopLevel.Placuntiti] + let plectopterous: [TopLevel.Plectopterous] + let pneumocele: [TopLevel.Pneumocele?] + let poliorcetic: [TopLevel.Poliorcetic] + let poormaster: [TopLevel.Poormaster] + let potwhisky: [TopLevel.PotwhiskyElement] + let practicalizer: [TopLevel.Practicalizer] + let prefreshman: [TopLevel.PrefreshmanElement] + let prehensility: [TopLevel.Prehensility] + let prevoidance: [TopLevel.Prevoidance] + let probant: [[String: Int?]] + let protext: [TopLevel.Protext] + + enum CodingKeys: String, CodingKey { + case juror = "juror" + case kongoni = "kongoni" + case ladronism = "ladronism" + case landlubberly = "landlubberly" + case listener = "listener" + case lupus = "lupus" + case maslin = "maslin" + case monazite = "monazite" + case monoliteral = "monoliteral" + case monotheistically = "monotheistically" + case montage = "montage" + case moralness = "moralness" + case mowra = "mowra" + case mulishly = "mulishly" + case myoscope = "myoscope" + case nach = "nach" + case neuromastic = "neuromastic" + case noncontributing = "noncontributing" + case nonnervous = "nonnervous" + case nonvaluation = "nonvaluation" + case occupationalist = "occupationalist" + case outrival = "outrival" + case paleographically = "paleographically" + case pamphletwise = "pamphletwise" + case pediatrics = "pediatrics" + case perceptive = "perceptive" + case piaculum = "piaculum" + case piccadilly = "piccadilly" + case piffler = "piffler" + case pithful = "pithful" + case placuntitis = "placuntitis" + case plectopterous = "plectopterous" + case pneumocele = "pneumocele" + case poliorcetic = "poliorcetic" + case poormaster = "poormaster" + case potwhisky = "potwhisky" + case practicalizer = "practicalizer" + case prefreshman = "prefreshman" + case prehensility = "prehensility" + case prevoidance = "prevoidance" + case probant = "probant" + case protext = "protext" + } + + enum JurorElement: Codable { + case bool(Bool) + case jurorClass(TopLevel.JurorClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(TopLevel.JurorClass.self) { + self = .jurorClass(x) + return + } + throw DecodingError.typeMismatch(JurorElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JurorElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .jurorClass(let x): + try container.encode(x) + } + } + } + + struct JurorClass: Codable { + let adipsy: JSONNull? + let auxiliator: JSONNull? + let benda: JSONNull? + let benjamin: JSONNull? + let brandling: JSONNull? + let epicurishly: JSONNull? + let eremochaetous: JSONNull? + let marten: JSONNull? + let monocline: JSONNull? + let olea: JSONNull? + let palgat: JSONNull? + let pennyworth: JSONNull? + let pioury: JSONNull? + let pragmatistic: JSONNull? + let stylelessness: JSONNull? + let systematical: JSONNull? + let thready: JSONNull? + let uncontemporary: JSONNull? + let uncouched: JSONNull? + let uninhabitedness: JSONNull? + + enum CodingKeys: String, CodingKey { + case adipsy = "adipsy" + case auxiliator = "auxiliator" + case benda = "benda" + case benjamin = "benjamin" + case brandling = "brandling" + case epicurishly = "epicurishly" + case eremochaetous = "eremochaetous" + case marten = "marten" + case monocline = "monocline" + case olea = "Olea" + case palgat = "palgat" + case pennyworth = "pennyworth" + case pioury = "pioury" + case pragmatistic = "pragmatistic" + case stylelessness = "stylelessness" + case systematical = "systematical" + case thready = "thready" + case uncontemporary = "uncontemporary" + case uncouched = "uncouched" + case uninhabitedness = "uninhabitedness" + } + } + + enum Kongoni: Codable { + case integerArray([Int]) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Kongoni.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Kongoni")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } + } + + enum LadronismElement: Codable { + case double(Double) + case ladronismClass(TopLevel.LadronismClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(TopLevel.LadronismClass.self) { + self = .ladronismClass(x) + return + } + throw DecodingError.typeMismatch(LadronismElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for LadronismElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .ladronismClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + struct LadronismClass: Codable { + let acclaimer: JSONNull? + let achree: JSONNull? + let base: JSONNull? + let conundrumize: JSONNull? + let degerminator: JSONNull? + let describable: JSONNull? + let exasperatedly: JSONNull? + let heroine: JSONNull? + let indazin: JSONNull? + let luteous: JSONNull? + let papular: JSONNull? + let pritch: JSONNull? + let prodenia: JSONNull? + let seege: JSONNull? + let shopgirl: JSONNull? + let tragedietta: JSONNull? + let unsparse: JSONNull? + let uplook: JSONNull? + let vermiformis: JSONNull? + let whafabout: JSONNull? + + enum CodingKeys: String, CodingKey { + case acclaimer = "acclaimer" + case achree = "achree" + case base = "base" + case conundrumize = "conundrumize" + case degerminator = "degerminator" + case describable = "describable" + case exasperatedly = "exasperatedly" + case heroine = "heroine" + case indazin = "indazin" + case luteous = "luteous" + case papular = "papular" + case pritch = "pritch" + case prodenia = "Prodenia" + case seege = "seege" + case shopgirl = "shopgirl" + case tragedietta = "tragedietta" + case unsparse = "unsparse" + case uplook = "uplook" + case vermiformis = "vermiformis" + case whafabout = "whafabout" + } + } + + enum LandlubberlyElement: Codable { + case bool(Bool) + case integer(Int) + case landlubberlyClass(TopLevel.LandlubberlyClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(TopLevel.LandlubberlyClass.self) { + self = .landlubberlyClass(x) + return + } + throw DecodingError.typeMismatch(LandlubberlyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for LandlubberlyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .landlubberlyClass(let x): + try container.encode(x) + } + } + } + + struct LandlubberlyClass: Codable { + let acropoleis: JSONNull? + let aminate: JSONNull? + let amyraldism: JSONNull? + let bipenniform: JSONNull? + let bugre: JSONNull? + let calycule: JSONNull? + let caoutchouc: JSONNull? + let disprover: JSONNull? + let fitroot: JSONNull? + let fulgently: JSONNull? + let kickup: JSONNull? + let laevoversion: JSONNull? + let moter: JSONNull? + let objectivity: JSONNull? + let posterity: JSONNull? + let postnuptial: JSONNull? + let precedentary: JSONNull? + let saddling: JSONNull? + let subcurrent: JSONNull? + let unrecriminative: JSONNull? + + enum CodingKeys: String, CodingKey { + case acropoleis = "acropoleis" + case aminate = "aminate" + case amyraldism = "Amyraldism" + case bipenniform = "bipenniform" + case bugre = "bugre" + case calycule = "calycule" + case caoutchouc = "caoutchouc" + case disprover = "disprover" + case fitroot = "fitroot" + case fulgently = "fulgently" + case kickup = "kickup" + case laevoversion = "laevoversion" + case moter = "moter" + case objectivity = "objectivity" + case posterity = "posterity" + case postnuptial = "postnuptial" + case precedentary = "precedentary" + case saddling = "saddling" + case subcurrent = "subcurrent" + case unrecriminative = "unrecriminative" + } + } + + enum Listener: Codable { + case integer(Int) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + throw DecodingError.typeMismatch(Listener.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Listener")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } + } + + enum LupusElement: Codable { + case integer(Int) + case lupusClass(TopLevel.LupusClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(TopLevel.LupusClass.self) { + self = .lupusClass(x) + return + } + throw DecodingError.typeMismatch(LupusElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for LupusElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .lupusClass(let x): + try container.encode(x) + } + } + } + + struct LupusClass: Codable { + let catharticalness: Double? + let chirotherium: Int? + let chlorioninae: Int? + let corvinae: Int? + let crassina: Int? + let disdiapason: String? + let exiguity: Int? + let farcist: Int? + let holographical: Int? + let homocerc: Bool? + let ichthyophagan: Int? + let implacable: Int? + let nonbookish: JSONNull? + let outshiner: Int? + let overweather: Int? + let protonegroid: Int? + let shallowish: Int? + let snoke: Int? + let snout: Int? + let surveillance: Int? + let threshingtime: Int? + let thysanocarpus: Int? + let unsignificantly: Int? + let unsnap: Int? + let vendible: Int? + + enum CodingKeys: String, CodingKey { + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case chlorioninae = "Chlorioninae" + case corvinae = "Corvinae" + case crassina = "Crassina" + case disdiapason = "disdiapason" + case exiguity = "exiguity" + case farcist = "farcist" + case holographical = "holographical" + case homocerc = "homocerc" + case ichthyophagan = "ichthyophagan" + case implacable = "implacable" + case nonbookish = "nonbookish" + case outshiner = "outshiner" + case overweather = "overweather" + case protonegroid = "protonegroid" + case shallowish = "shallowish" + case snoke = "snoke" + case snout = "snout" + case surveillance = "surveillance" + case threshingtime = "threshingtime" + case thysanocarpus = "Thysanocarpus" + case unsignificantly = "unsignificantly" + case unsnap = "unsnap" + case vendible = "vendible" + } + } + + struct Maslin: Codable { + let alicant: Int? + let antiatonement: JSONNull? + let anticorrosive: Int? + let aphidozer: JSONNull? + let bakuninist: JSONNull? + let be: Int? + let catharticalness: Double? + let chirotherium: Int? + let chub: Int? + let cuprosilicon: Int? + let curtailedly: Int? + let dellenite: Int? + let dimitry: Int? + let disdiapason: String? + let edifying: JSONNull? + let ethmoiditis: Int? + let gastralgy: JSONNull? + let goatherd: Int? + let hammerdress: Int? + let hangfire: JSONNull? + let homocerc: Bool? + let lacunosity: Int? + let longiloquence: JSONNull? + let mameliere: Int? + let motherless: JSONNull? + let nonbookish: JSONNull? + let noncorrodible: JSONNull? + let nonsensicality: JSONNull? + let oafishly: Int? + let pfund: JSONNull? + let preadvisory: JSONNull? + let retroflexed: JSONNull? + let saccharulmic: Int? + let scowlful: Int? + let secluded: JSONNull? + let slackage: JSONNull? + let sphaeridial: Int? + let spondulics: JSONNull? + let subsecive: Int? + let swellmobsman: JSONNull? + let trachyglossate: Int? + let trialogue: JSONNull? + let unassuaged: Int? + let ungross: JSONNull? + let unjudiciously: JSONNull? + + enum CodingKeys: String, CodingKey { + case alicant = "Alicant" + case antiatonement = "antiatonement" + case anticorrosive = "anticorrosive" + case aphidozer = "aphidozer" + case bakuninist = "Bakuninist" + case be = "be" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case chub = "chub" + case cuprosilicon = "cuprosilicon" + case curtailedly = "curtailedly" + case dellenite = "dellenite" + case dimitry = "Dimitry" + case disdiapason = "disdiapason" + case edifying = "edifying" + case ethmoiditis = "ethmoiditis" + case gastralgy = "gastralgy" + case goatherd = "goatherd" + case hammerdress = "hammerdress" + case hangfire = "hangfire" + case homocerc = "homocerc" + case lacunosity = "lacunosity" + case longiloquence = "longiloquence" + case mameliere = "mameliere" + case motherless = "motherless" + case nonbookish = "nonbookish" + case noncorrodible = "noncorrodible" + case nonsensicality = "nonsensicality" + case oafishly = "oafishly" + case pfund = "pfund" + case preadvisory = "preadvisory" + case retroflexed = "retroflexed" + case saccharulmic = "saccharulmic" + case scowlful = "scowlful" + case secluded = "secluded" + case slackage = "slackage" + case sphaeridial = "sphaeridial" + case spondulics = "spondulics" + case subsecive = "subsecive" + case swellmobsman = "swellmobsman" + case trachyglossate = "trachyglossate" + case trialogue = "trialogue" + case unassuaged = "unassuaged" + case ungross = "ungross" + case unjudiciously = "unjudiciously" + } + } + + enum MonaziteElement: Codable { + case double(Double) + case monaziteClass(TopLevel.MonaziteClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(TopLevel.MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(MonaziteElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for MonaziteElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .monaziteClass(let x): + try container.encode(x) + } + } + } + + struct MonaziteClass: Codable { + let catharticalness: Double + let chirotherium: Int + let disdiapason: String + let homocerc: Bool + let nonbookish: JSONNull? + + enum CodingKeys: String, CodingKey { + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case homocerc = "homocerc" + case nonbookish = "nonbookish" + } + } + + enum Monoliteral: Codable { + case bool(Bool) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + throw DecodingError.typeMismatch(Monoliteral.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Monoliteral")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } + } + + enum MonotheisticallyElement: Codable { + case monotheisticallyClass(TopLevel.MonotheisticallyClass) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(TopLevel.MonotheisticallyClass.self) { + self = .monotheisticallyClass(x) + return + } + throw DecodingError.typeMismatch(MonotheisticallyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for MonotheisticallyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .monotheisticallyClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } + } + + struct MonotheisticallyClass: Codable { + let blaspheme: JSONNull? + let catharticalness: Double? + let celiosalpingectomy: JSONNull? + let chirotherium: Int? + let consummativeness: JSONNull? + let disdiapason: String? + let egestive: JSONNull? + let enchylema: JSONNull? + let gasconade: JSONNull? + let holidayer: JSONNull? + let homocerc: Bool? + let intuitionalism: JSONNull? + let lophiostomate: JSONNull? + let nonbookish: JSONNull? + let nonvolition: JSONNull? + let palatableness: JSONNull? + let pimpery: JSONNull? + let previolation: JSONNull? + let reconveyance: JSONNull? + let registership: JSONNull? + let rhyacolite: JSONNull? + let smithereens: JSONNull? + let superedification: JSONNull? + let trust: JSONNull? + let whitestone: JSONNull? + + enum CodingKeys: String, CodingKey { + case blaspheme = "blaspheme" + case catharticalness = "catharticalness" + case celiosalpingectomy = "celiosalpingectomy" + case chirotherium = "Chirotherium" + case consummativeness = "consummativeness" + case disdiapason = "disdiapason" + case egestive = "egestive" + case enchylema = "enchylema" + case gasconade = "gasconade" + case holidayer = "holidayer" + case homocerc = "homocerc" + case intuitionalism = "intuitionalism" + case lophiostomate = "lophiostomate" + case nonbookish = "nonbookish" + case nonvolition = "nonvolition" + case palatableness = "palatableness" + case pimpery = "pimpery" + case previolation = "previolation" + case reconveyance = "reconveyance" + case registership = "registership" + case rhyacolite = "rhyacolite" + case smithereens = "smithereens" + case superedification = "superedification" + case trust = "trust" + case whitestone = "whitestone" + } + } + + enum Montage: Codable { + case double(Double) + case nullArray([JSONNull?]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Montage.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Montage")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + enum Moralness: Codable { + case double(Double) + case nullArray([JSONNull?]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Moralness.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Moralness")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } + } + + enum Mulishly: Codable { + case double(Double) + case integerArray([Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Mulishly.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Mulishly")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } + } + + enum Myoscope: Codable { + case bool(Bool) + case integer(Int) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + throw DecodingError.typeMismatch(Myoscope.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Myoscope")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } + } + + enum Neuromastic: Codable { + case double(Double) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Neuromastic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Neuromastic")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } + } + + struct Noncontributing: Codable { + let estevin: String + let jolterhead: Double + let sauternes: Int + let sparsely: Bool + let unrequested: JSONNull? + + enum CodingKeys: String, CodingKey { + case estevin = "estevin" + case jolterhead = "jolterhead" + case sauternes = "sauternes" + case sparsely = "sparsely" + case unrequested = "unrequested" + } + } + + enum Nonnervous: Codable { + case bool(Bool) + case integer(Int) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + throw DecodingError.typeMismatch(Nonnervous.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Nonnervous")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + } + } + } + + enum Nonvaluation: Codable { + case bool(Bool) + case double(Double) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Nonvaluation.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Nonvaluation")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } + } + + enum OccupationalistElement: Codable { + case nullArray([JSONNull?]) + case occupationalistClass(TopLevel.OccupationalistClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(TopLevel.OccupationalistClass.self) { + self = .occupationalistClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(OccupationalistElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for OccupationalistElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .occupationalistClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } + } + + struct OccupationalistClass: Codable { + let beholdable: JSONNull? + let brotuliform: JSONNull? + let chimakum: JSONNull? + let doodler: JSONNull? + let emulsin: JSONNull? + let fin: JSONNull? + let flourishing: JSONNull? + let flueless: JSONNull? + let furtively: JSONNull? + let gritter: JSONNull? + let interwish: JSONNull? + let monoxylic: JSONNull? + let myristic: JSONNull? + let nightwear: JSONNull? + let peruser: JSONNull? + let theoastrological: JSONNull? + let thumby: JSONNull? + let tingitid: JSONNull? + let trailless: JSONNull? + let unpocketed: JSONNull? + + enum CodingKeys: String, CodingKey { + case beholdable = "beholdable" + case brotuliform = "brotuliform" + case chimakum = "Chimakum" + case doodler = "doodler" + case emulsin = "emulsin" + case fin = "Fin" + case flourishing = "flourishing" + case flueless = "flueless" + case furtively = "furtively" + case gritter = "gritter" + case interwish = "interwish" + case monoxylic = "monoxylic" + case myristic = "myristic" + case nightwear = "nightwear" + case peruser = "peruser" + case theoastrological = "theoastrological" + case thumby = "thumby" + case tingitid = "tingitid" + case trailless = "trailless" + case unpocketed = "unpocketed" + } + } + + enum OutrivalElement: Codable { + case double(Double) + case outrivalClass(TopLevel.OutrivalClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(TopLevel.OutrivalClass.self) { + self = .outrivalClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(OutrivalElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for OutrivalElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .outrivalClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } + } + + struct OutrivalClass: Codable { + let adroitly: JSONNull? + let bridehood: JSONNull? + let castoroides: JSONNull? + let czechoslovak: JSONNull? + let diagenesis: JSONNull? + let dihexahedron: JSONNull? + let dopester: JSONNull? + let eumerism: JSONNull? + let flyness: JSONNull? + let fouler: JSONNull? + let laudanosine: JSONNull? + let lingulidae: JSONNull? + let minutary: JSONNull? + let mitra: JSONNull? + let opisthorchiasis: JSONNull? + let pensively: JSONNull? + let pubigerous: JSONNull? + let rebellious: JSONNull? + let recodify: JSONNull? + let unpaced: JSONNull? + + enum CodingKeys: String, CodingKey { + case adroitly = "adroitly" + case bridehood = "bridehood" + case castoroides = "Castoroides" + case czechoslovak = "Czechoslovak" + case diagenesis = "diagenesis" + case dihexahedron = "dihexahedron" + case dopester = "dopester" + case eumerism = "eumerism" + case flyness = "flyness" + case fouler = "fouler" + case laudanosine = "laudanosine" + case lingulidae = "Lingulidae" + case minutary = "minutary" + case mitra = "mitra" + case opisthorchiasis = "opisthorchiasis" + case pensively = "pensively" + case pubigerous = "pubigerous" + case rebellious = "rebellious" + case recodify = "recodify" + case unpaced = "unpaced" + } + } + + enum Paleographically: Codable { + case double(Double) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + throw DecodingError.typeMismatch(Paleographically.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Paleographically")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } + } + + enum Pamphletwise: Codable { + case integer(Int) + case integerMap([String: Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Pamphletwise.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Pamphletwise")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + enum Pediatric: Codable { + case bool(Bool) + case double(Double) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Pediatric.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Pediatric")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } + } + + enum PiaculumElement: Codable { + case double(Double) + case piaculumClass(TopLevel.PiaculumClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(TopLevel.PiaculumClass.self) { + self = .piaculumClass(x) + return + } + throw DecodingError.typeMismatch(PiaculumElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PiaculumElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .piaculumClass(let x): + try container.encode(x) + } + } + } + + struct PiaculumClass: Codable { + let alada: Int? + let amphistomous: Int? + let boysenberry: Int? + let catharticalness: Double? + let chirotherium: Int? + let decardinalize: Int? + let discouragement: Int? + let disdiapason: String? + let doitrified: Int? + let hexaspermous: Int? + let homocerc: Bool? + let insinking: Int? + let loathfulness: Int? + let miasmatical: Int? + let neurofibril: Int? + let nonbookish: JSONNull? + let phonendoscope: Int? + let pilferment: Int? + let predismissory: Int? + let preinscription: Int? + let quotative: Int? + let sienna: Int? + let thorax: Int? + let yachting: Int? + let zipper: Int? + + enum CodingKeys: String, CodingKey { + case alada = "alada" + case amphistomous = "amphistomous" + case boysenberry = "boysenberry" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case decardinalize = "decardinalize" + case discouragement = "discouragement" + case disdiapason = "disdiapason" + case doitrified = "doitrified" + case hexaspermous = "hexaspermous" + case homocerc = "homocerc" + case insinking = "insinking" + case loathfulness = "loathfulness" + case miasmatical = "miasmatical" + case neurofibril = "neurofibril" + case nonbookish = "nonbookish" + case phonendoscope = "phonendoscope" + case pilferment = "pilferment" + case predismissory = "predismissory" + case preinscription = "preinscription" + case quotative = "quotative" + case sienna = "sienna" + case thorax = "thorax" + case yachting = "yachting" + case zipper = "Zipper" + } + } + + enum Piccadilly: Codable { + case double(Double) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Piccadilly.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Piccadilly")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } + } + + enum Piffler: Codable { + case monaziteClass(TopLevel.MonaziteClass) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(TopLevel.MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(Piffler.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Piffler")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .monaziteClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } + } + + enum Pithful: Codable { + case bool(Bool) + case integer(Int) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Pithful.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Pithful")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } + } + + enum Placuntiti: Codable { + case integer(Int) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Placuntiti.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Placuntiti")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } + } + + enum Plectopterous: Codable { + case double(Double) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Plectopterous.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Plectopterous")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } + } + + struct Pneumocele: Codable { + let carbonarism: JSONNull? + let catharticalness: Double? + let chirotherium: Int? + let cineolic: JSONNull? + let cobbly: JSONNull? + let conchyliferous: JSONNull? + let congregation: JSONNull? + let disdiapason: String? + let enterotomy: JSONNull? + let entophytal: JSONNull? + let fewtrils: JSONNull? + let herem: JSONNull? + let homocerc: Bool? + let koniga: JSONNull? + let meticulosity: JSONNull? + let micky: JSONNull? + let mismarriage: JSONNull? + let neurotrophic: JSONNull? + let nonbookish: JSONNull? + let persuasively: JSONNull? + let replaceable: JSONNull? + let silex: JSONNull? + let taillight: JSONNull? + let unjealous: JSONNull? + let visitorial: JSONNull? + + enum CodingKeys: String, CodingKey { + case carbonarism = "Carbonarism" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case cineolic = "cineolic" + case cobbly = "cobbly" + case conchyliferous = "conchyliferous" + case congregation = "congregation" + case disdiapason = "disdiapason" + case enterotomy = "enterotomy" + case entophytal = "entophytal" + case fewtrils = "fewtrils" + case herem = "herem" + case homocerc = "homocerc" + case koniga = "Koniga" + case meticulosity = "meticulosity" + case micky = "Micky" + case mismarriage = "mismarriage" + case neurotrophic = "neurotrophic" + case nonbookish = "nonbookish" + case persuasively = "persuasively" + case replaceable = "replaceable" + case silex = "silex" + case taillight = "taillight" + case unjealous = "unjealous" + case visitorial = "visitorial" + } + } + + enum Poliorcetic: Codable { + case bool(Bool) + case monaziteClass(TopLevel.MonaziteClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(TopLevel.MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(Poliorcetic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Poliorcetic")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .monaziteClass(let x): + try container.encode(x) + } + } + } + + enum Poormaster: Codable { + case integerArray([Int]) + case integerMap([String: Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Poormaster.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Poormaster")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } + } + + enum PotwhiskyElement: Codable { + case integer(Int) + case potwhiskyClass(TopLevel.PotwhiskyClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(TopLevel.PotwhiskyClass.self) { + self = .potwhiskyClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(PotwhiskyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PotwhiskyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .potwhiskyClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } + } + + struct PotwhiskyClass: Codable { + let arciform: JSONNull? + let cresolin: JSONNull? + let disheartener: JSONNull? + let disproportionable: JSONNull? + let euchorda: JSONNull? + let ferryway: JSONNull? + let filamentiferous: JSONNull? + let flemish: JSONNull? + let forgainst: JSONNull? + let grainering: JSONNull? + let irrevoluble: JSONNull? + let kindredship: JSONNull? + let pinguitudinous: JSONNull? + let simpletonic: JSONNull? + let singsong: JSONNull? + let submergement: JSONNull? + let supraoesophagal: JSONNull? + let thrashel: JSONNull? + let tyremesis: JSONNull? + let yoruba: JSONNull? + + enum CodingKeys: String, CodingKey { + case arciform = "arciform" + case cresolin = "cresolin" + case disheartener = "disheartener" + case disproportionable = "disproportionable" + case euchorda = "Euchorda" + case ferryway = "ferryway" + case filamentiferous = "filamentiferous" + case flemish = "flemish" + case forgainst = "forgainst" + case grainering = "grainering" + case irrevoluble = "irrevoluble" + case kindredship = "kindredship" + case pinguitudinous = "pinguitudinous" + case simpletonic = "simpletonic" + case singsong = "singsong" + case submergement = "submergement" + case supraoesophagal = "supraoesophagal" + case thrashel = "thrashel" + case tyremesis = "tyremesis" + case yoruba = "Yoruba" + } + } + + enum Practicalizer: Codable { + case monaziteClass(TopLevel.MonaziteClass) + case nullArray([JSONNull?]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(TopLevel.MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(Practicalizer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Practicalizer")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .monaziteClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + enum PrefreshmanElement: Codable { + case nullArray([JSONNull?]) + case prefreshmanClass(TopLevel.PrefreshmanClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(TopLevel.PrefreshmanClass.self) { + self = .prefreshmanClass(x) + return + } + throw DecodingError.typeMismatch(PrefreshmanElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PrefreshmanElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .prefreshmanClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + struct PrefreshmanClass: Codable { + let azorubine: JSONNull? + let choroiditis: JSONNull? + let coagulatory: JSONNull? + let cyclorama: JSONNull? + let dolphus: JSONNull? + let duckhearted: JSONNull? + let ficus: JSONNull? + let gemaric: JSONNull? + let jugation: JSONNull? + let myoliposis: JSONNull? + let nonnomination: JSONNull? + let palay: JSONNull? + let pentactinal: JSONNull? + let phaet: JSONNull? + let piquant: JSONNull? + let registration: JSONNull? + let remancipation: JSONNull? + let scutatiform: JSONNull? + let theodolite: JSONNull? + let underward: JSONNull? + + enum CodingKeys: String, CodingKey { + case azorubine = "azorubine" + case choroiditis = "choroiditis" + case coagulatory = "coagulatory" + case cyclorama = "cyclorama" + case dolphus = "Dolphus" + case duckhearted = "duckhearted" + case ficus = "Ficus" + case gemaric = "Gemaric" + case jugation = "jugation" + case myoliposis = "myoliposis" + case nonnomination = "nonnomination" + case palay = "palay" + case pentactinal = "pentactinal" + case phaet = "Phaet" + case piquant = "piquant" + case registration = "registration" + case remancipation = "remancipation" + case scutatiform = "scutatiform" + case theodolite = "theodolite" + case underward = "underward" + } + } + + enum Prehensility: Codable { + case bool(Bool) + case monaziteClass(TopLevel.MonaziteClass) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(TopLevel.MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(Prehensility.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Prehensility")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .monaziteClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } + } + + enum Prevoidance: Codable { + case integer(Int) + case integerArray([Int]) + case monaziteClass(TopLevel.MonaziteClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(TopLevel.MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(Prevoidance.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Prevoidance")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .monaziteClass(let x): + try container.encode(x) + } + } + } + + enum Protext: Codable { + case bool(Bool) + case integerArray([Int]) + case monaziteClass(TopLevel.MonaziteClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(TopLevel.MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(Protext.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Protext")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .monaziteClass(let x): + try container.encode(x) + } + } + } + + // MARK: Helper functions for creating encoders and decoders + static func newJSONDecoder() -> JSONDecoder { + let decoder = JSONDecoder() + decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in + let container = try decoder.singleValueContainer() + let dateStr = try container.decode(String.self) + + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date")) + }) + return decoder + } + + static func newJSONEncoder() -> JSONEncoder { + let encoder = JSONEncoder() + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder + } +} + +// MARK: TopLevel convenience initializers and mutators + +extension TopLevel { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + juror: [TopLevel.JurorElement]? = nil, + kongoni: [TopLevel.Kongoni]? = nil, + ladronism: [TopLevel.LadronismElement]? = nil, + landlubberly: [TopLevel.LandlubberlyElement]? = nil, + listener: [TopLevel.Listener]? = nil, + lupus: [TopLevel.LupusElement]? = nil, + maslin: [TopLevel.Maslin]? = nil, + monazite: [TopLevel.MonaziteElement]? = nil, + monoliteral: [TopLevel.Monoliteral]? = nil, + monotheistically: [TopLevel.MonotheisticallyElement]? = nil, + montage: [TopLevel.Montage]? = nil, + moralness: [TopLevel.Moralness]? = nil, + mowra: [TopLevel.MonaziteClass?]? = nil, + mulishly: [TopLevel.Mulishly]? = nil, + myoscope: [TopLevel.Myoscope]? = nil, + nach: [[Int?]?]? = nil, + neuromastic: [TopLevel.Neuromastic]? = nil, + noncontributing: [TopLevel.Noncontributing]? = nil, + nonnervous: [TopLevel.Nonnervous]? = nil, + nonvaluation: [TopLevel.Nonvaluation]? = nil, + occupationalist: [TopLevel.OccupationalistElement]? = nil, + outrival: [TopLevel.OutrivalElement]? = nil, + paleographically: [TopLevel.Paleographically]? = nil, + pamphletwise: [TopLevel.Pamphletwise]? = nil, + pediatrics: [TopLevel.Pediatric]? = nil, + perceptive: [Bool]? = nil, + piaculum: [TopLevel.PiaculumElement]? = nil, + piccadilly: [TopLevel.Piccadilly]? = nil, + piffler: [TopLevel.Piffler]? = nil, + pithful: [TopLevel.Pithful]? = nil, + placuntitis: [TopLevel.Placuntiti]? = nil, + plectopterous: [TopLevel.Plectopterous]? = nil, + pneumocele: [TopLevel.Pneumocele?]? = nil, + poliorcetic: [TopLevel.Poliorcetic]? = nil, + poormaster: [TopLevel.Poormaster]? = nil, + potwhisky: [TopLevel.PotwhiskyElement]? = nil, + practicalizer: [TopLevel.Practicalizer]? = nil, + prefreshman: [TopLevel.PrefreshmanElement]? = nil, + prehensility: [TopLevel.Prehensility]? = nil, + prevoidance: [TopLevel.Prevoidance]? = nil, + probant: [[String: Int?]]? = nil, + protext: [TopLevel.Protext]? = nil + ) -> TopLevel { + return TopLevel( + juror: juror ?? self.juror, + kongoni: kongoni ?? self.kongoni, + ladronism: ladronism ?? self.ladronism, + landlubberly: landlubberly ?? self.landlubberly, + listener: listener ?? self.listener, + lupus: lupus ?? self.lupus, + maslin: maslin ?? self.maslin, + monazite: monazite ?? self.monazite, + monoliteral: monoliteral ?? self.monoliteral, + monotheistically: monotheistically ?? self.monotheistically, + montage: montage ?? self.montage, + moralness: moralness ?? self.moralness, + mowra: mowra ?? self.mowra, + mulishly: mulishly ?? self.mulishly, + myoscope: myoscope ?? self.myoscope, + nach: nach ?? self.nach, + neuromastic: neuromastic ?? self.neuromastic, + noncontributing: noncontributing ?? self.noncontributing, + nonnervous: nonnervous ?? self.nonnervous, + nonvaluation: nonvaluation ?? self.nonvaluation, + occupationalist: occupationalist ?? self.occupationalist, + outrival: outrival ?? self.outrival, + paleographically: paleographically ?? self.paleographically, + pamphletwise: pamphletwise ?? self.pamphletwise, + pediatrics: pediatrics ?? self.pediatrics, + perceptive: perceptive ?? self.perceptive, + piaculum: piaculum ?? self.piaculum, + piccadilly: piccadilly ?? self.piccadilly, + piffler: piffler ?? self.piffler, + pithful: pithful ?? self.pithful, + placuntitis: placuntitis ?? self.placuntitis, + plectopterous: plectopterous ?? self.plectopterous, + pneumocele: pneumocele ?? self.pneumocele, + poliorcetic: poliorcetic ?? self.poliorcetic, + poormaster: poormaster ?? self.poormaster, + potwhisky: potwhisky ?? self.potwhisky, + practicalizer: practicalizer ?? self.practicalizer, + prefreshman: prefreshman ?? self.prefreshman, + prehensility: prehensility ?? self.prehensility, + prevoidance: prevoidance ?? self.prevoidance, + probant: probant ?? self.probant, + protext: protext ?? self.protext + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.JurorClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.JurorClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + adipsy: JSONNull?? = nil, + auxiliator: JSONNull?? = nil, + benda: JSONNull?? = nil, + benjamin: JSONNull?? = nil, + brandling: JSONNull?? = nil, + epicurishly: JSONNull?? = nil, + eremochaetous: JSONNull?? = nil, + marten: JSONNull?? = nil, + monocline: JSONNull?? = nil, + olea: JSONNull?? = nil, + palgat: JSONNull?? = nil, + pennyworth: JSONNull?? = nil, + pioury: JSONNull?? = nil, + pragmatistic: JSONNull?? = nil, + stylelessness: JSONNull?? = nil, + systematical: JSONNull?? = nil, + thready: JSONNull?? = nil, + uncontemporary: JSONNull?? = nil, + uncouched: JSONNull?? = nil, + uninhabitedness: JSONNull?? = nil + ) -> TopLevel.JurorClass { + return TopLevel.JurorClass( + adipsy: adipsy ?? self.adipsy, + auxiliator: auxiliator ?? self.auxiliator, + benda: benda ?? self.benda, + benjamin: benjamin ?? self.benjamin, + brandling: brandling ?? self.brandling, + epicurishly: epicurishly ?? self.epicurishly, + eremochaetous: eremochaetous ?? self.eremochaetous, + marten: marten ?? self.marten, + monocline: monocline ?? self.monocline, + olea: olea ?? self.olea, + palgat: palgat ?? self.palgat, + pennyworth: pennyworth ?? self.pennyworth, + pioury: pioury ?? self.pioury, + pragmatistic: pragmatistic ?? self.pragmatistic, + stylelessness: stylelessness ?? self.stylelessness, + systematical: systematical ?? self.systematical, + thready: thready ?? self.thready, + uncontemporary: uncontemporary ?? self.uncontemporary, + uncouched: uncouched ?? self.uncouched, + uninhabitedness: uninhabitedness ?? self.uninhabitedness + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.LadronismClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.LadronismClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + acclaimer: JSONNull?? = nil, + achree: JSONNull?? = nil, + base: JSONNull?? = nil, + conundrumize: JSONNull?? = nil, + degerminator: JSONNull?? = nil, + describable: JSONNull?? = nil, + exasperatedly: JSONNull?? = nil, + heroine: JSONNull?? = nil, + indazin: JSONNull?? = nil, + luteous: JSONNull?? = nil, + papular: JSONNull?? = nil, + pritch: JSONNull?? = nil, + prodenia: JSONNull?? = nil, + seege: JSONNull?? = nil, + shopgirl: JSONNull?? = nil, + tragedietta: JSONNull?? = nil, + unsparse: JSONNull?? = nil, + uplook: JSONNull?? = nil, + vermiformis: JSONNull?? = nil, + whafabout: JSONNull?? = nil + ) -> TopLevel.LadronismClass { + return TopLevel.LadronismClass( + acclaimer: acclaimer ?? self.acclaimer, + achree: achree ?? self.achree, + base: base ?? self.base, + conundrumize: conundrumize ?? self.conundrumize, + degerminator: degerminator ?? self.degerminator, + describable: describable ?? self.describable, + exasperatedly: exasperatedly ?? self.exasperatedly, + heroine: heroine ?? self.heroine, + indazin: indazin ?? self.indazin, + luteous: luteous ?? self.luteous, + papular: papular ?? self.papular, + pritch: pritch ?? self.pritch, + prodenia: prodenia ?? self.prodenia, + seege: seege ?? self.seege, + shopgirl: shopgirl ?? self.shopgirl, + tragedietta: tragedietta ?? self.tragedietta, + unsparse: unsparse ?? self.unsparse, + uplook: uplook ?? self.uplook, + vermiformis: vermiformis ?? self.vermiformis, + whafabout: whafabout ?? self.whafabout + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.LandlubberlyClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.LandlubberlyClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + acropoleis: JSONNull?? = nil, + aminate: JSONNull?? = nil, + amyraldism: JSONNull?? = nil, + bipenniform: JSONNull?? = nil, + bugre: JSONNull?? = nil, + calycule: JSONNull?? = nil, + caoutchouc: JSONNull?? = nil, + disprover: JSONNull?? = nil, + fitroot: JSONNull?? = nil, + fulgently: JSONNull?? = nil, + kickup: JSONNull?? = nil, + laevoversion: JSONNull?? = nil, + moter: JSONNull?? = nil, + objectivity: JSONNull?? = nil, + posterity: JSONNull?? = nil, + postnuptial: JSONNull?? = nil, + precedentary: JSONNull?? = nil, + saddling: JSONNull?? = nil, + subcurrent: JSONNull?? = nil, + unrecriminative: JSONNull?? = nil + ) -> TopLevel.LandlubberlyClass { + return TopLevel.LandlubberlyClass( + acropoleis: acropoleis ?? self.acropoleis, + aminate: aminate ?? self.aminate, + amyraldism: amyraldism ?? self.amyraldism, + bipenniform: bipenniform ?? self.bipenniform, + bugre: bugre ?? self.bugre, + calycule: calycule ?? self.calycule, + caoutchouc: caoutchouc ?? self.caoutchouc, + disprover: disprover ?? self.disprover, + fitroot: fitroot ?? self.fitroot, + fulgently: fulgently ?? self.fulgently, + kickup: kickup ?? self.kickup, + laevoversion: laevoversion ?? self.laevoversion, + moter: moter ?? self.moter, + objectivity: objectivity ?? self.objectivity, + posterity: posterity ?? self.posterity, + postnuptial: postnuptial ?? self.postnuptial, + precedentary: precedentary ?? self.precedentary, + saddling: saddling ?? self.saddling, + subcurrent: subcurrent ?? self.subcurrent, + unrecriminative: unrecriminative ?? self.unrecriminative + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.LupusClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.LupusClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + chlorioninae: Int?? = nil, + corvinae: Int?? = nil, + crassina: Int?? = nil, + disdiapason: String?? = nil, + exiguity: Int?? = nil, + farcist: Int?? = nil, + holographical: Int?? = nil, + homocerc: Bool?? = nil, + ichthyophagan: Int?? = nil, + implacable: Int?? = nil, + nonbookish: JSONNull?? = nil, + outshiner: Int?? = nil, + overweather: Int?? = nil, + protonegroid: Int?? = nil, + shallowish: Int?? = nil, + snoke: Int?? = nil, + snout: Int?? = nil, + surveillance: Int?? = nil, + threshingtime: Int?? = nil, + thysanocarpus: Int?? = nil, + unsignificantly: Int?? = nil, + unsnap: Int?? = nil, + vendible: Int?? = nil + ) -> TopLevel.LupusClass { + return TopLevel.LupusClass( + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + chlorioninae: chlorioninae ?? self.chlorioninae, + corvinae: corvinae ?? self.corvinae, + crassina: crassina ?? self.crassina, + disdiapason: disdiapason ?? self.disdiapason, + exiguity: exiguity ?? self.exiguity, + farcist: farcist ?? self.farcist, + holographical: holographical ?? self.holographical, + homocerc: homocerc ?? self.homocerc, + ichthyophagan: ichthyophagan ?? self.ichthyophagan, + implacable: implacable ?? self.implacable, + nonbookish: nonbookish ?? self.nonbookish, + outshiner: outshiner ?? self.outshiner, + overweather: overweather ?? self.overweather, + protonegroid: protonegroid ?? self.protonegroid, + shallowish: shallowish ?? self.shallowish, + snoke: snoke ?? self.snoke, + snout: snout ?? self.snout, + surveillance: surveillance ?? self.surveillance, + threshingtime: threshingtime ?? self.threshingtime, + thysanocarpus: thysanocarpus ?? self.thysanocarpus, + unsignificantly: unsignificantly ?? self.unsignificantly, + unsnap: unsnap ?? self.unsnap, + vendible: vendible ?? self.vendible + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.Maslin { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.Maslin.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + alicant: Int?? = nil, + antiatonement: JSONNull?? = nil, + anticorrosive: Int?? = nil, + aphidozer: JSONNull?? = nil, + bakuninist: JSONNull?? = nil, + be: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + chub: Int?? = nil, + cuprosilicon: Int?? = nil, + curtailedly: Int?? = nil, + dellenite: Int?? = nil, + dimitry: Int?? = nil, + disdiapason: String?? = nil, + edifying: JSONNull?? = nil, + ethmoiditis: Int?? = nil, + gastralgy: JSONNull?? = nil, + goatherd: Int?? = nil, + hammerdress: Int?? = nil, + hangfire: JSONNull?? = nil, + homocerc: Bool?? = nil, + lacunosity: Int?? = nil, + longiloquence: JSONNull?? = nil, + mameliere: Int?? = nil, + motherless: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + noncorrodible: JSONNull?? = nil, + nonsensicality: JSONNull?? = nil, + oafishly: Int?? = nil, + pfund: JSONNull?? = nil, + preadvisory: JSONNull?? = nil, + retroflexed: JSONNull?? = nil, + saccharulmic: Int?? = nil, + scowlful: Int?? = nil, + secluded: JSONNull?? = nil, + slackage: JSONNull?? = nil, + sphaeridial: Int?? = nil, + spondulics: JSONNull?? = nil, + subsecive: Int?? = nil, + swellmobsman: JSONNull?? = nil, + trachyglossate: Int?? = nil, + trialogue: JSONNull?? = nil, + unassuaged: Int?? = nil, + ungross: JSONNull?? = nil, + unjudiciously: JSONNull?? = nil + ) -> TopLevel.Maslin { + return TopLevel.Maslin( + alicant: alicant ?? self.alicant, + antiatonement: antiatonement ?? self.antiatonement, + anticorrosive: anticorrosive ?? self.anticorrosive, + aphidozer: aphidozer ?? self.aphidozer, + bakuninist: bakuninist ?? self.bakuninist, + be: be ?? self.be, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + chub: chub ?? self.chub, + cuprosilicon: cuprosilicon ?? self.cuprosilicon, + curtailedly: curtailedly ?? self.curtailedly, + dellenite: dellenite ?? self.dellenite, + dimitry: dimitry ?? self.dimitry, + disdiapason: disdiapason ?? self.disdiapason, + edifying: edifying ?? self.edifying, + ethmoiditis: ethmoiditis ?? self.ethmoiditis, + gastralgy: gastralgy ?? self.gastralgy, + goatherd: goatherd ?? self.goatherd, + hammerdress: hammerdress ?? self.hammerdress, + hangfire: hangfire ?? self.hangfire, + homocerc: homocerc ?? self.homocerc, + lacunosity: lacunosity ?? self.lacunosity, + longiloquence: longiloquence ?? self.longiloquence, + mameliere: mameliere ?? self.mameliere, + motherless: motherless ?? self.motherless, + nonbookish: nonbookish ?? self.nonbookish, + noncorrodible: noncorrodible ?? self.noncorrodible, + nonsensicality: nonsensicality ?? self.nonsensicality, + oafishly: oafishly ?? self.oafishly, + pfund: pfund ?? self.pfund, + preadvisory: preadvisory ?? self.preadvisory, + retroflexed: retroflexed ?? self.retroflexed, + saccharulmic: saccharulmic ?? self.saccharulmic, + scowlful: scowlful ?? self.scowlful, + secluded: secluded ?? self.secluded, + slackage: slackage ?? self.slackage, + sphaeridial: sphaeridial ?? self.sphaeridial, + spondulics: spondulics ?? self.spondulics, + subsecive: subsecive ?? self.subsecive, + swellmobsman: swellmobsman ?? self.swellmobsman, + trachyglossate: trachyglossate ?? self.trachyglossate, + trialogue: trialogue ?? self.trialogue, + unassuaged: unassuaged ?? self.unassuaged, + ungross: ungross ?? self.ungross, + unjudiciously: unjudiciously ?? self.unjudiciously + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.MonaziteClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.MonaziteClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + catharticalness: Double? = nil, + chirotherium: Int? = nil, + disdiapason: String? = nil, + homocerc: Bool? = nil, + nonbookish: JSONNull?? = nil + ) -> TopLevel.MonaziteClass { + return TopLevel.MonaziteClass( + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + homocerc: homocerc ?? self.homocerc, + nonbookish: nonbookish ?? self.nonbookish + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.MonotheisticallyClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.MonotheisticallyClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + blaspheme: JSONNull?? = nil, + catharticalness: Double?? = nil, + celiosalpingectomy: JSONNull?? = nil, + chirotherium: Int?? = nil, + consummativeness: JSONNull?? = nil, + disdiapason: String?? = nil, + egestive: JSONNull?? = nil, + enchylema: JSONNull?? = nil, + gasconade: JSONNull?? = nil, + holidayer: JSONNull?? = nil, + homocerc: Bool?? = nil, + intuitionalism: JSONNull?? = nil, + lophiostomate: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + nonvolition: JSONNull?? = nil, + palatableness: JSONNull?? = nil, + pimpery: JSONNull?? = nil, + previolation: JSONNull?? = nil, + reconveyance: JSONNull?? = nil, + registership: JSONNull?? = nil, + rhyacolite: JSONNull?? = nil, + smithereens: JSONNull?? = nil, + superedification: JSONNull?? = nil, + trust: JSONNull?? = nil, + whitestone: JSONNull?? = nil + ) -> TopLevel.MonotheisticallyClass { + return TopLevel.MonotheisticallyClass( + blaspheme: blaspheme ?? self.blaspheme, + catharticalness: catharticalness ?? self.catharticalness, + celiosalpingectomy: celiosalpingectomy ?? self.celiosalpingectomy, + chirotherium: chirotherium ?? self.chirotherium, + consummativeness: consummativeness ?? self.consummativeness, + disdiapason: disdiapason ?? self.disdiapason, + egestive: egestive ?? self.egestive, + enchylema: enchylema ?? self.enchylema, + gasconade: gasconade ?? self.gasconade, + holidayer: holidayer ?? self.holidayer, + homocerc: homocerc ?? self.homocerc, + intuitionalism: intuitionalism ?? self.intuitionalism, + lophiostomate: lophiostomate ?? self.lophiostomate, + nonbookish: nonbookish ?? self.nonbookish, + nonvolition: nonvolition ?? self.nonvolition, + palatableness: palatableness ?? self.palatableness, + pimpery: pimpery ?? self.pimpery, + previolation: previolation ?? self.previolation, + reconveyance: reconveyance ?? self.reconveyance, + registership: registership ?? self.registership, + rhyacolite: rhyacolite ?? self.rhyacolite, + smithereens: smithereens ?? self.smithereens, + superedification: superedification ?? self.superedification, + trust: trust ?? self.trust, + whitestone: whitestone ?? self.whitestone + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.Noncontributing { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.Noncontributing.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + estevin: String? = nil, + jolterhead: Double? = nil, + sauternes: Int? = nil, + sparsely: Bool? = nil, + unrequested: JSONNull?? = nil + ) -> TopLevel.Noncontributing { + return TopLevel.Noncontributing( + estevin: estevin ?? self.estevin, + jolterhead: jolterhead ?? self.jolterhead, + sauternes: sauternes ?? self.sauternes, + sparsely: sparsely ?? self.sparsely, + unrequested: unrequested ?? self.unrequested + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.OccupationalistClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.OccupationalistClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + beholdable: JSONNull?? = nil, + brotuliform: JSONNull?? = nil, + chimakum: JSONNull?? = nil, + doodler: JSONNull?? = nil, + emulsin: JSONNull?? = nil, + fin: JSONNull?? = nil, + flourishing: JSONNull?? = nil, + flueless: JSONNull?? = nil, + furtively: JSONNull?? = nil, + gritter: JSONNull?? = nil, + interwish: JSONNull?? = nil, + monoxylic: JSONNull?? = nil, + myristic: JSONNull?? = nil, + nightwear: JSONNull?? = nil, + peruser: JSONNull?? = nil, + theoastrological: JSONNull?? = nil, + thumby: JSONNull?? = nil, + tingitid: JSONNull?? = nil, + trailless: JSONNull?? = nil, + unpocketed: JSONNull?? = nil + ) -> TopLevel.OccupationalistClass { + return TopLevel.OccupationalistClass( + beholdable: beholdable ?? self.beholdable, + brotuliform: brotuliform ?? self.brotuliform, + chimakum: chimakum ?? self.chimakum, + doodler: doodler ?? self.doodler, + emulsin: emulsin ?? self.emulsin, + fin: fin ?? self.fin, + flourishing: flourishing ?? self.flourishing, + flueless: flueless ?? self.flueless, + furtively: furtively ?? self.furtively, + gritter: gritter ?? self.gritter, + interwish: interwish ?? self.interwish, + monoxylic: monoxylic ?? self.monoxylic, + myristic: myristic ?? self.myristic, + nightwear: nightwear ?? self.nightwear, + peruser: peruser ?? self.peruser, + theoastrological: theoastrological ?? self.theoastrological, + thumby: thumby ?? self.thumby, + tingitid: tingitid ?? self.tingitid, + trailless: trailless ?? self.trailless, + unpocketed: unpocketed ?? self.unpocketed + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.OutrivalClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.OutrivalClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + adroitly: JSONNull?? = nil, + bridehood: JSONNull?? = nil, + castoroides: JSONNull?? = nil, + czechoslovak: JSONNull?? = nil, + diagenesis: JSONNull?? = nil, + dihexahedron: JSONNull?? = nil, + dopester: JSONNull?? = nil, + eumerism: JSONNull?? = nil, + flyness: JSONNull?? = nil, + fouler: JSONNull?? = nil, + laudanosine: JSONNull?? = nil, + lingulidae: JSONNull?? = nil, + minutary: JSONNull?? = nil, + mitra: JSONNull?? = nil, + opisthorchiasis: JSONNull?? = nil, + pensively: JSONNull?? = nil, + pubigerous: JSONNull?? = nil, + rebellious: JSONNull?? = nil, + recodify: JSONNull?? = nil, + unpaced: JSONNull?? = nil + ) -> TopLevel.OutrivalClass { + return TopLevel.OutrivalClass( + adroitly: adroitly ?? self.adroitly, + bridehood: bridehood ?? self.bridehood, + castoroides: castoroides ?? self.castoroides, + czechoslovak: czechoslovak ?? self.czechoslovak, + diagenesis: diagenesis ?? self.diagenesis, + dihexahedron: dihexahedron ?? self.dihexahedron, + dopester: dopester ?? self.dopester, + eumerism: eumerism ?? self.eumerism, + flyness: flyness ?? self.flyness, + fouler: fouler ?? self.fouler, + laudanosine: laudanosine ?? self.laudanosine, + lingulidae: lingulidae ?? self.lingulidae, + minutary: minutary ?? self.minutary, + mitra: mitra ?? self.mitra, + opisthorchiasis: opisthorchiasis ?? self.opisthorchiasis, + pensively: pensively ?? self.pensively, + pubigerous: pubigerous ?? self.pubigerous, + rebellious: rebellious ?? self.rebellious, + recodify: recodify ?? self.recodify, + unpaced: unpaced ?? self.unpaced + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.PiaculumClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.PiaculumClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + alada: Int?? = nil, + amphistomous: Int?? = nil, + boysenberry: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + decardinalize: Int?? = nil, + discouragement: Int?? = nil, + disdiapason: String?? = nil, + doitrified: Int?? = nil, + hexaspermous: Int?? = nil, + homocerc: Bool?? = nil, + insinking: Int?? = nil, + loathfulness: Int?? = nil, + miasmatical: Int?? = nil, + neurofibril: Int?? = nil, + nonbookish: JSONNull?? = nil, + phonendoscope: Int?? = nil, + pilferment: Int?? = nil, + predismissory: Int?? = nil, + preinscription: Int?? = nil, + quotative: Int?? = nil, + sienna: Int?? = nil, + thorax: Int?? = nil, + yachting: Int?? = nil, + zipper: Int?? = nil + ) -> TopLevel.PiaculumClass { + return TopLevel.PiaculumClass( + alada: alada ?? self.alada, + amphistomous: amphistomous ?? self.amphistomous, + boysenberry: boysenberry ?? self.boysenberry, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + decardinalize: decardinalize ?? self.decardinalize, + discouragement: discouragement ?? self.discouragement, + disdiapason: disdiapason ?? self.disdiapason, + doitrified: doitrified ?? self.doitrified, + hexaspermous: hexaspermous ?? self.hexaspermous, + homocerc: homocerc ?? self.homocerc, + insinking: insinking ?? self.insinking, + loathfulness: loathfulness ?? self.loathfulness, + miasmatical: miasmatical ?? self.miasmatical, + neurofibril: neurofibril ?? self.neurofibril, + nonbookish: nonbookish ?? self.nonbookish, + phonendoscope: phonendoscope ?? self.phonendoscope, + pilferment: pilferment ?? self.pilferment, + predismissory: predismissory ?? self.predismissory, + preinscription: preinscription ?? self.preinscription, + quotative: quotative ?? self.quotative, + sienna: sienna ?? self.sienna, + thorax: thorax ?? self.thorax, + yachting: yachting ?? self.yachting, + zipper: zipper ?? self.zipper + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.Pneumocele { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.Pneumocele.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + carbonarism: JSONNull?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + cineolic: JSONNull?? = nil, + cobbly: JSONNull?? = nil, + conchyliferous: JSONNull?? = nil, + congregation: JSONNull?? = nil, + disdiapason: String?? = nil, + enterotomy: JSONNull?? = nil, + entophytal: JSONNull?? = nil, + fewtrils: JSONNull?? = nil, + herem: JSONNull?? = nil, + homocerc: Bool?? = nil, + koniga: JSONNull?? = nil, + meticulosity: JSONNull?? = nil, + micky: JSONNull?? = nil, + mismarriage: JSONNull?? = nil, + neurotrophic: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + persuasively: JSONNull?? = nil, + replaceable: JSONNull?? = nil, + silex: JSONNull?? = nil, + taillight: JSONNull?? = nil, + unjealous: JSONNull?? = nil, + visitorial: JSONNull?? = nil + ) -> TopLevel.Pneumocele { + return TopLevel.Pneumocele( + carbonarism: carbonarism ?? self.carbonarism, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + cineolic: cineolic ?? self.cineolic, + cobbly: cobbly ?? self.cobbly, + conchyliferous: conchyliferous ?? self.conchyliferous, + congregation: congregation ?? self.congregation, + disdiapason: disdiapason ?? self.disdiapason, + enterotomy: enterotomy ?? self.enterotomy, + entophytal: entophytal ?? self.entophytal, + fewtrils: fewtrils ?? self.fewtrils, + herem: herem ?? self.herem, + homocerc: homocerc ?? self.homocerc, + koniga: koniga ?? self.koniga, + meticulosity: meticulosity ?? self.meticulosity, + micky: micky ?? self.micky, + mismarriage: mismarriage ?? self.mismarriage, + neurotrophic: neurotrophic ?? self.neurotrophic, + nonbookish: nonbookish ?? self.nonbookish, + persuasively: persuasively ?? self.persuasively, + replaceable: replaceable ?? self.replaceable, + silex: silex ?? self.silex, + taillight: taillight ?? self.taillight, + unjealous: unjealous ?? self.unjealous, + visitorial: visitorial ?? self.visitorial + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.PotwhiskyClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.PotwhiskyClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + arciform: JSONNull?? = nil, + cresolin: JSONNull?? = nil, + disheartener: JSONNull?? = nil, + disproportionable: JSONNull?? = nil, + euchorda: JSONNull?? = nil, + ferryway: JSONNull?? = nil, + filamentiferous: JSONNull?? = nil, + flemish: JSONNull?? = nil, + forgainst: JSONNull?? = nil, + grainering: JSONNull?? = nil, + irrevoluble: JSONNull?? = nil, + kindredship: JSONNull?? = nil, + pinguitudinous: JSONNull?? = nil, + simpletonic: JSONNull?? = nil, + singsong: JSONNull?? = nil, + submergement: JSONNull?? = nil, + supraoesophagal: JSONNull?? = nil, + thrashel: JSONNull?? = nil, + tyremesis: JSONNull?? = nil, + yoruba: JSONNull?? = nil + ) -> TopLevel.PotwhiskyClass { + return TopLevel.PotwhiskyClass( + arciform: arciform ?? self.arciform, + cresolin: cresolin ?? self.cresolin, + disheartener: disheartener ?? self.disheartener, + disproportionable: disproportionable ?? self.disproportionable, + euchorda: euchorda ?? self.euchorda, + ferryway: ferryway ?? self.ferryway, + filamentiferous: filamentiferous ?? self.filamentiferous, + flemish: flemish ?? self.flemish, + forgainst: forgainst ?? self.forgainst, + grainering: grainering ?? self.grainering, + irrevoluble: irrevoluble ?? self.irrevoluble, + kindredship: kindredship ?? self.kindredship, + pinguitudinous: pinguitudinous ?? self.pinguitudinous, + simpletonic: simpletonic ?? self.simpletonic, + singsong: singsong ?? self.singsong, + submergement: submergement ?? self.submergement, + supraoesophagal: supraoesophagal ?? self.supraoesophagal, + thrashel: thrashel ?? self.thrashel, + tyremesis: tyremesis ?? self.tyremesis, + yoruba: yoruba ?? self.yoruba + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.PrefreshmanClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.PrefreshmanClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + azorubine: JSONNull?? = nil, + choroiditis: JSONNull?? = nil, + coagulatory: JSONNull?? = nil, + cyclorama: JSONNull?? = nil, + dolphus: JSONNull?? = nil, + duckhearted: JSONNull?? = nil, + ficus: JSONNull?? = nil, + gemaric: JSONNull?? = nil, + jugation: JSONNull?? = nil, + myoliposis: JSONNull?? = nil, + nonnomination: JSONNull?? = nil, + palay: JSONNull?? = nil, + pentactinal: JSONNull?? = nil, + phaet: JSONNull?? = nil, + piquant: JSONNull?? = nil, + registration: JSONNull?? = nil, + remancipation: JSONNull?? = nil, + scutatiform: JSONNull?? = nil, + theodolite: JSONNull?? = nil, + underward: JSONNull?? = nil + ) -> TopLevel.PrefreshmanClass { + return TopLevel.PrefreshmanClass( + azorubine: azorubine ?? self.azorubine, + choroiditis: choroiditis ?? self.choroiditis, + coagulatory: coagulatory ?? self.coagulatory, + cyclorama: cyclorama ?? self.cyclorama, + dolphus: dolphus ?? self.dolphus, + duckhearted: duckhearted ?? self.duckhearted, + ficus: ficus ?? self.ficus, + gemaric: gemaric ?? self.gemaric, + jugation: jugation ?? self.jugation, + myoliposis: myoliposis ?? self.myoliposis, + nonnomination: nonnomination ?? self.nonnomination, + palay: palay ?? self.palay, + pentactinal: pentactinal ?? self.pentactinal, + phaet: phaet ?? self.phaet, + piquant: piquant ?? self.piquant, + registration: registration ?? self.registration, + remancipation: remancipation ?? self.remancipation, + scutatiform: scutatiform ?? self.scutatiform, + theodolite: theodolite ?? self.theodolite, + underward: underward ?? self.underward + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - Encode/decode helpers + +class JSONNull: Codable, Hashable { + + public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool { + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(0) + } + + public init() {} + + public required init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if !container.decodeNil() { + throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull")) + } + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + try container.encodeNil() + } +} diff --git a/head/swift/test/inputs/json/priority/combinations4.json/nest-types-true--d03bdf4b0ab1/quicktype.swift b/head/swift/test/inputs/json/priority/combinations4.json/nest-types-true--d03bdf4b0ab1/quicktype.swift new file mode 100644 index 0000000..0a225e4 --- /dev/null +++ b/head/swift/test/inputs/json/priority/combinations4.json/nest-types-true--d03bdf4b0ab1/quicktype.swift @@ -0,0 +1,3592 @@ +// This file was generated from JSON Schema using quicktype, do not modify it directly. +// To parse the JSON, add this file to your project and do: +// +// let topLevel = try TopLevel(json) + +import Foundation + +// MARK: - TopLevel +struct TopLevel: Codable { + let protrusive: [TopLevel.Protrusive] + let pulpitism: [TopLevel.PulpitismElement] + let pyodermia: [TopLevel.PyodermiaElement] + let quebrachine: [TopLevel.QuebrachineElement] + let querier: [TopLevel.Querier] + let rebarbative: [TopLevel.Rebarbative] + let reimagine: [TopLevel.Reimagine] + let ressaut: TopLevel.Ressaut + let retrocervical: [TopLevel.Retrocervical] + let revert: [TopLevel.Revert] + let rewrite: [TopLevel.RewriteElement] + let saccoderm: [TopLevel.Saccoderm] + let santir: [TopLevel.SantirElement] + let saprophilous: [TopLevel.Saprophilous] + let saxten: [TopLevel.SaxtenElement] + let scatty: [TopLevel.Scatty?] + let scoffer: [TopLevel.Scoffer] + let scrampum: [TopLevel.Scrampum] + let semantic: Double + let serpentinic: [TopLevel.Serpentinic] + let shadowable: [TopLevel.Shadowable] + let sistering: [TopLevel.SisteringElement] + let staghunting: [TopLevel.Staghunting] + let stagmometer: [TopLevel.Stagmometer] + let stimulability: [TopLevel.Stimulability] + let strangleable: [TopLevel.Strangleable] + let strenuosity: [TopLevel.StrenuosityElement] + let tabaxir: [TopLevel.Tabaxir] + let talpiform: [TopLevel.Talpiform] + let thwack: [TopLevel.Thwack] + let to: [Double?] + let tortricine: [TopLevel.Tortricine] + let truantcy: [TopLevel.TruantcyElement] + let turgesce: [String] + let unbeginning: [TopLevel.Unbeginning] + let underdunged: [Double] + let undesirability: [TopLevel.Undesirability] + let unerasing: [TopLevel.Unerasing] + let unguentarium: [TopLevel.Unguentarium] + let unimpeachably: [TopLevel.UnimpeachablyElement] + let unmortgaged: [TopLevel.Unmortgaged] + let unobstructed: [TopLevel.Unobstructed] + let unreceptivity: [TopLevel.Unreceptivity] + let unsatisfactoriness: [TopLevel.Unsatisfactoriness] + let unsecurity: [Int] + let unstressed: [TopLevel.UnstressedElement] + let untasked: [TopLevel.Untasked] + let unvarying: [TopLevel.Unvarying] + let vehemently: [TopLevel.Vehemently] + let warriorship: [String: Bool] + let whitepot: [TopLevel.Whitepot] + let wrothy: [TopLevel.WrothyElement] + + enum CodingKeys: String, CodingKey { + case protrusive = "protrusive" + case pulpitism = "pulpitism" + case pyodermia = "pyodermia" + case quebrachine = "quebrachine" + case querier = "querier" + case rebarbative = "rebarbative" + case reimagine = "reimagine" + case ressaut = "ressaut" + case retrocervical = "retrocervical" + case revert = "revert" + case rewrite = "rewrite" + case saccoderm = "saccoderm" + case santir = "santir" + case saprophilous = "saprophilous" + case saxten = "saxten" + case scatty = "scatty" + case scoffer = "scoffer" + case scrampum = "scrampum" + case semantic = "semantic" + case serpentinic = "serpentinic" + case shadowable = "shadowable" + case sistering = "sistering" + case staghunting = "staghunting" + case stagmometer = "stagmometer" + case stimulability = "stimulability" + case strangleable = "strangleable" + case strenuosity = "strenuosity" + case tabaxir = "tabaxir" + case talpiform = "talpiform" + case thwack = "thwack" + case to = "to" + case tortricine = "tortricine" + case truantcy = "truantcy" + case turgesce = "turgesce" + case unbeginning = "unbeginning" + case underdunged = "underdunged" + case undesirability = "undesirability" + case unerasing = "unerasing" + case unguentarium = "unguentarium" + case unimpeachably = "unimpeachably" + case unmortgaged = "unmortgaged" + case unobstructed = "unobstructed" + case unreceptivity = "unreceptivity" + case unsatisfactoriness = "unsatisfactoriness" + case unsecurity = "unsecurity" + case unstressed = "unstressed" + case untasked = "untasked" + case unvarying = "unvarying" + case vehemently = "vehemently" + case warriorship = "warriorship" + case whitepot = "whitepot" + case wrothy = "wrothy" + } + + enum Protrusive: Codable { + case double(Double) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Protrusive.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Protrusive")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } + } + + enum PulpitismElement: Codable { + case double(Double) + case integerArray([Int]) + case pulpitismClass(TopLevel.PulpitismClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(TopLevel.PulpitismClass.self) { + self = .pulpitismClass(x) + return + } + throw DecodingError.typeMismatch(PulpitismElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PulpitismElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .pulpitismClass(let x): + try container.encode(x) + } + } + } + + struct PulpitismClass: Codable { + let abnet: JSONNull? + let buckhorn: JSONNull? + let calciform: JSONNull? + let chelophore: JSONNull? + let cogitation: JSONNull? + let decreeable: JSONNull? + let despicable: JSONNull? + let isodiazo: JSONNull? + let jadedly: JSONNull? + let leptochlorite: JSONNull? + let nursling: JSONNull? + let palamedean: JSONNull? + let photoheliograph: JSONNull? + let pipewood: JSONNull? + let roberd: JSONNull? + let statable: JSONNull? + let superassume: JSONNull? + let syllabe: JSONNull? + let toughhead: JSONNull? + let underburn: JSONNull? + + enum CodingKeys: String, CodingKey { + case abnet = "abnet" + case buckhorn = "buckhorn" + case calciform = "calciform" + case chelophore = "chelophore" + case cogitation = "cogitation" + case decreeable = "decreeable" + case despicable = "despicable" + case isodiazo = "isodiazo" + case jadedly = "jadedly" + case leptochlorite = "leptochlorite" + case nursling = "nursling" + case palamedean = "palamedean" + case photoheliograph = "photoheliograph" + case pipewood = "pipewood" + case roberd = "roberd" + case statable = "statable" + case superassume = "superassume" + case syllabe = "syllabe" + case toughhead = "toughhead" + case underburn = "underburn" + } + } + + enum PyodermiaElement: Codable { + case integer(Int) + case pyodermiaClass(TopLevel.PyodermiaClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(TopLevel.PyodermiaClass.self) { + self = .pyodermiaClass(x) + return + } + throw DecodingError.typeMismatch(PyodermiaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PyodermiaElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .pyodermiaClass(let x): + try container.encode(x) + } + } + } + + struct PyodermiaClass: Codable { + let aphoristically: JSONNull? + let apophyllous: JSONNull? + let cognize: JSONNull? + let dermonosology: JSONNull? + let gyppo: JSONNull? + let ither: JSONNull? + let juglandaceous: JSONNull? + let litho: JSONNull? + let macropterous: JSONNull? + let photographer: JSONNull? + let romancing: JSONNull? + let rumness: JSONNull? + let somniloquist: JSONNull? + let stressfully: JSONNull? + let tactically: JSONNull? + let tracheophony: JSONNull? + let unappositely: JSONNull? + let unclothedly: JSONNull? + let unimplied: JSONNull? + let unsyncopated: JSONNull? + + enum CodingKeys: String, CodingKey { + case aphoristically = "aphoristically" + case apophyllous = "apophyllous" + case cognize = "cognize" + case dermonosology = "dermonosology" + case gyppo = "Gyppo" + case ither = "ither" + case juglandaceous = "juglandaceous" + case litho = "litho" + case macropterous = "macropterous" + case photographer = "photographer" + case romancing = "romancing" + case rumness = "rumness" + case somniloquist = "somniloquist" + case stressfully = "stressfully" + case tactically = "tactically" + case tracheophony = "tracheophony" + case unappositely = "unappositely" + case unclothedly = "unclothedly" + case unimplied = "unimplied" + case unsyncopated = "unsyncopated" + } + } + + enum QuebrachineElement: Codable { + case bool(Bool) + case quebrachineClass(TopLevel.QuebrachineClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(TopLevel.QuebrachineClass.self) { + self = .quebrachineClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(QuebrachineElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for QuebrachineElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .quebrachineClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } + } + + struct QuebrachineClass: Codable { + let catharticalness: Double + let chirotherium: Int + let disdiapason: String + let homocerc: Bool + let nonbookish: JSONNull? + + enum CodingKeys: String, CodingKey { + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case homocerc = "homocerc" + case nonbookish = "nonbookish" + } + } + + enum Querier: Codable { + case bool(Bool) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Querier.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Querier")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } + } + + enum Rebarbative: Codable { + case bool(Bool) + case double(Double) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Rebarbative.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Rebarbative")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } + } + + struct Reimagine: Codable { + let adducible: JSONNull? + let anabolin: JSONNull? + let brainy: JSONNull? + let catharticalness: Double? + let chirotherium: Int? + let chrysamine: JSONNull? + let disdiapason: String? + let fluxweed: JSONNull? + let glaucine: JSONNull? + let grobianism: JSONNull? + let hermo: JSONNull? + let hieroglyphist: JSONNull? + let homocerc: Bool? + let icteroid: JSONNull? + let immortal: JSONNull? + let impetulant: JSONNull? + let irrigate: JSONNull? + let myxedema: JSONNull? + let nonbookish: JSONNull? + let onyx: JSONNull? + let repasser: JSONNull? + let septomarginal: JSONNull? + let subdie: JSONNull? + let tibiometatarsal: JSONNull? + let waltzlike: JSONNull? + + enum CodingKeys: String, CodingKey { + case adducible = "adducible" + case anabolin = "anabolin" + case brainy = "brainy" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case chrysamine = "chrysamine" + case disdiapason = "disdiapason" + case fluxweed = "fluxweed" + case glaucine = "glaucine" + case grobianism = "grobianism" + case hermo = "Hermo" + case hieroglyphist = "hieroglyphist" + case homocerc = "homocerc" + case icteroid = "icteroid" + case immortal = "immortal" + case impetulant = "impetulant" + case irrigate = "irrigate" + case myxedema = "myxedema" + case nonbookish = "nonbookish" + case onyx = "onyx" + case repasser = "repasser" + case septomarginal = "septomarginal" + case subdie = "subdie" + case tibiometatarsal = "tibiometatarsal" + case waltzlike = "waltzlike" + } + } + + struct Ressaut: Codable { + let apperceptive: String + let cuttoo: String + let douser: String + let drinkproof: String + let forementioned: String + let freesia: String + let genevieve: String + let hyperdiabolical: String + let hypocone: String + let irreverentially: String + let jumart: String + let mimosaceae: String + let mollicrush: String + let nedder: String + let retinasphalt: String + let sough: String + let steading: String + let theopaschitism: String + let undurableness: String + let unmingleable: String + + enum CodingKeys: String, CodingKey { + case apperceptive = "apperceptive" + case cuttoo = "cuttoo" + case douser = "douser" + case drinkproof = "drinkproof" + case forementioned = "forementioned" + case freesia = "Freesia" + case genevieve = "Genevieve" + case hyperdiabolical = "hyperdiabolical" + case hypocone = "hypocone" + case irreverentially = "irreverentially" + case jumart = "jumart" + case mimosaceae = "Mimosaceae" + case mollicrush = "mollicrush" + case nedder = "nedder" + case retinasphalt = "retinasphalt" + case sough = "sough" + case steading = "steading" + case theopaschitism = "Theopaschitism" + case undurableness = "undurableness" + case unmingleable = "unmingleable" + } + } + + enum Retrocervical: Codable { + case integer(Int) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + throw DecodingError.typeMismatch(Retrocervical.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Retrocervical")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } + } + + enum Revert: Codable { + case bool(Bool) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Revert.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Revert")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + enum RewriteElement: Codable { + case double(Double) + case nullArray([JSONNull?]) + case rewriteClass(TopLevel.RewriteClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(TopLevel.RewriteClass.self) { + self = .rewriteClass(x) + return + } + throw DecodingError.typeMismatch(RewriteElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for RewriteElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .rewriteClass(let x): + try container.encode(x) + } + } + } + + struct RewriteClass: Codable { + let accountancy: JSONNull? + let cacotrophic: JSONNull? + let contest: JSONNull? + let couthily: JSONNull? + let falculate: JSONNull? + let foreseize: JSONNull? + let hyades: JSONNull? + let lemnad: JSONNull? + let monotheistically: JSONNull? + let nonflying: JSONNull? + let ptenoglossa: JSONNull? + let repatch: JSONNull? + let rodman: JSONNull? + let strung: JSONNull? + let titmal: JSONNull? + let twalpennyworth: JSONNull? + let unblamable: JSONNull? + let vertical: JSONNull? + let whiggification: JSONNull? + let yardman: JSONNull? + + enum CodingKeys: String, CodingKey { + case accountancy = "accountancy" + case cacotrophic = "cacotrophic" + case contest = "contest" + case couthily = "couthily" + case falculate = "falculate" + case foreseize = "foreseize" + case hyades = "Hyades" + case lemnad = "lemnad" + case monotheistically = "monotheistically" + case nonflying = "nonflying" + case ptenoglossa = "Ptenoglossa" + case repatch = "repatch" + case rodman = "rodman" + case strung = "strung" + case titmal = "titmal" + case twalpennyworth = "twalpennyworth" + case unblamable = "unblamable" + case vertical = "vertical" + case whiggification = "Whiggification" + case yardman = "yardman" + } + } + + enum Saccoderm: Codable { + case integerArray([Int]) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Saccoderm.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Saccoderm")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } + } + + enum SantirElement: Codable { + case double(Double) + case santirClass(TopLevel.SantirClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(TopLevel.SantirClass.self) { + self = .santirClass(x) + return + } + throw DecodingError.typeMismatch(SantirElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for SantirElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .santirClass(let x): + try container.encode(x) + } + } + } + + struct SantirClass: Codable { + let admiredly: JSONNull? + let demicaponier: JSONNull? + let epitympanic: JSONNull? + let investitor: JSONNull? + let lupiform: JSONNull? + let monoflagellate: JSONNull? + let paleoethnic: JSONNull? + let prediscountable: JSONNull? + let rhetoricals: JSONNull? + let roomth: JSONNull? + let saccharose: JSONNull? + let septonasal: JSONNull? + let serpenticide: JSONNull? + let setarious: JSONNull? + let spaework: JSONNull? + let stylite: JSONNull? + let suessiones: JSONNull? + let timelily: JSONNull? + let unprofaned: JSONNull? + let vorticular: JSONNull? + + enum CodingKeys: String, CodingKey { + case admiredly = "admiredly" + case demicaponier = "demicaponier" + case epitympanic = "epitympanic" + case investitor = "investitor" + case lupiform = "lupiform" + case monoflagellate = "monoflagellate" + case paleoethnic = "paleoethnic" + case prediscountable = "prediscountable" + case rhetoricals = "rhetoricals" + case roomth = "roomth" + case saccharose = "saccharose" + case septonasal = "septonasal" + case serpenticide = "serpenticide" + case setarious = "setarious" + case spaework = "spaework" + case stylite = "stylite" + case suessiones = "Suessiones" + case timelily = "timelily" + case unprofaned = "unprofaned" + case vorticular = "vorticular" + } + } + + enum Saprophilous: Codable { + case integerMap([String: Int]) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Saprophilous.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Saprophilous")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } + } + + enum SaxtenElement: Codable { + case saxtenClass(TopLevel.SaxtenClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(TopLevel.SaxtenClass.self) { + self = .saxtenClass(x) + return + } + throw DecodingError.typeMismatch(SaxtenElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for SaxtenElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .saxtenClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + struct SaxtenClass: Codable { + let algarrobilla: JSONNull? + let bowgrace: JSONNull? + let catharticalness: Double? + let centaurid: JSONNull? + let chirotherium: Int? + let disdiapason: String? + let flix: JSONNull? + let germanely: JSONNull? + let homocerc: Bool? + let inhume: JSONNull? + let lepidote: JSONNull? + let megalochirous: JSONNull? + let ninepenny: JSONNull? + let nonbookish: JSONNull? + let nondeist: JSONNull? + let nymphaeaceous: JSONNull? + let parietofrontal: JSONNull? + let sancyite: JSONNull? + let subjectivist: JSONNull? + let tibiad: JSONNull? + let transonic: JSONNull? + let tripetalous: JSONNull? + let trunchman: JSONNull? + let urger: JSONNull? + let withdrawnness: JSONNull? + + enum CodingKeys: String, CodingKey { + case algarrobilla = "algarrobilla" + case bowgrace = "bowgrace" + case catharticalness = "catharticalness" + case centaurid = "Centaurid" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case flix = "flix" + case germanely = "germanely" + case homocerc = "homocerc" + case inhume = "inhume" + case lepidote = "lepidote" + case megalochirous = "megalochirous" + case ninepenny = "ninepenny" + case nonbookish = "nonbookish" + case nondeist = "nondeist" + case nymphaeaceous = "nymphaeaceous" + case parietofrontal = "parietofrontal" + case sancyite = "sancyite" + case subjectivist = "subjectivist" + case tibiad = "tibiad" + case transonic = "transonic" + case tripetalous = "tripetalous" + case trunchman = "trunchman" + case urger = "urger" + case withdrawnness = "withdrawnness" + } + } + + struct Scatty: Codable { + let aeriferous: JSONNull? + let antical: JSONNull? + let antighostism: JSONNull? + let arcanum: JSONNull? + let autotrophy: JSONNull? + let baronial: JSONNull? + let caffeine: JSONNull? + let gorgoniacean: JSONNull? + let heroical: JSONNull? + let hydropical: JSONNull? + let mechanology: JSONNull? + let musicopoetic: JSONNull? + let officiality: JSONNull? + let oftentimes: JSONNull? + let ophthalmotonometer: JSONNull? + let reflectively: JSONNull? + let springer: JSONNull? + let tabasco: JSONNull? + let teleianthous: JSONNull? + let uncombated: JSONNull? + + enum CodingKeys: String, CodingKey { + case aeriferous = "aeriferous" + case antical = "antical" + case antighostism = "antighostism" + case arcanum = "arcanum" + case autotrophy = "autotrophy" + case baronial = "baronial" + case caffeine = "caffeine" + case gorgoniacean = "gorgoniacean" + case heroical = "heroical" + case hydropical = "hydropical" + case mechanology = "mechanology" + case musicopoetic = "musicopoetic" + case officiality = "officiality" + case oftentimes = "oftentimes" + case ophthalmotonometer = "ophthalmotonometer" + case reflectively = "reflectively" + case springer = "springer" + case tabasco = "Tabasco" + case teleianthous = "teleianthous" + case uncombated = "uncombated" + } + } + + enum Scoffer: Codable { + case integerMap([String: Int]) + case nullArray([JSONNull?]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Scoffer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Scoffer")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerMap(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } + } + + enum Scrampum: Codable { + case bool(Bool) + case integerArray([Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Scrampum.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Scrampum")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } + } + + enum Serpentinic: Codable { + case double(Double) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Serpentinic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Serpentinic")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } + } + + enum Shadowable: Codable { + case bool(Bool) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + throw DecodingError.typeMismatch(Shadowable.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Shadowable")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } + } + + enum SisteringElement: Codable { + case integer(Int) + case nullArray([JSONNull?]) + case sisteringClass(TopLevel.SisteringClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(TopLevel.SisteringClass.self) { + self = .sisteringClass(x) + return + } + throw DecodingError.typeMismatch(SisteringElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for SisteringElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .sisteringClass(let x): + try container.encode(x) + } + } + } + + struct SisteringClass: Codable { + let amphicarpic: JSONNull? + let chianti: JSONNull? + let frigorific: JSONNull? + let haplomi: JSONNull? + let hyperkinesis: JSONNull? + let laudable: JSONNull? + let madwoman: JSONNull? + let maimedly: JSONNull? + let micropterygidae: JSONNull? + let microrhabdus: JSONNull? + let nondense: JSONNull? + let phlebemphraxis: JSONNull? + let redsear: JSONNull? + let schismatical: JSONNull? + let tartryl: JSONNull? + let unabhorred: JSONNull? + let undeliberateness: JSONNull? + let unmixable: JSONNull? + let untruckling: JSONNull? + let vineal: JSONNull? + + enum CodingKeys: String, CodingKey { + case amphicarpic = "amphicarpic" + case chianti = "Chianti" + case frigorific = "frigorific" + case haplomi = "Haplomi" + case hyperkinesis = "hyperkinesis" + case laudable = "laudable" + case madwoman = "madwoman" + case maimedly = "maimedly" + case micropterygidae = "Micropterygidae" + case microrhabdus = "microrhabdus" + case nondense = "nondense" + case phlebemphraxis = "phlebemphraxis" + case redsear = "redsear" + case schismatical = "schismatical" + case tartryl = "tartryl" + case unabhorred = "unabhorred" + case undeliberateness = "undeliberateness" + case unmixable = "unmixable" + case untruckling = "untruckling" + case vineal = "vineal" + } + } + + struct Staghunting: Codable { + let calorimetric: Int? + let canid: Int? + let catharticalness: Double? + let chirotherium: Int? + let disdiapason: String? + let ditriglyphic: Int? + let floriferousness: Int? + let gamelike: Int? + let grig: Int? + let homocerc: Bool? + let interloan: Int? + let lithotomy: Int? + let loric: Int? + let membranocoriaceous: Int? + let membranogenic: Int? + let nonbookish: JSONNull? + let overtrump: Int? + let scotino: Int? + let seasonable: Int? + let sephen: Int? + let stigmarioid: Int? + let tired: Int? + let trifid: Int? + let undefeatedly: Int? + let ungirlish: Int? + + enum CodingKeys: String, CodingKey { + case calorimetric = "calorimetric" + case canid = "canid" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case ditriglyphic = "ditriglyphic" + case floriferousness = "floriferousness" + case gamelike = "gamelike" + case grig = "grig" + case homocerc = "homocerc" + case interloan = "interloan" + case lithotomy = "lithotomy" + case loric = "loric" + case membranocoriaceous = "membranocoriaceous" + case membranogenic = "membranogenic" + case nonbookish = "nonbookish" + case overtrump = "overtrump" + case scotino = "scotino" + case seasonable = "seasonable" + case sephen = "sephen" + case stigmarioid = "stigmarioid" + case tired = "tired" + case trifid = "trifid" + case undefeatedly = "undefeatedly" + case ungirlish = "ungirlish" + } + } + + enum Stagmometer: Codable { + case string(String) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Stagmometer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Stagmometer")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .string(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } + } + + enum Stimulability: Codable { + case bool(Bool) + case integer(Int) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Stimulability.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Stimulability")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } + } + + enum Strangleable: Codable { + case double(Double) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Strangleable.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Strangleable")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } + } + + enum StrenuosityElement: Codable { + case nullArray([JSONNull?]) + case strenuosityClass(TopLevel.StrenuosityClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(TopLevel.StrenuosityClass.self) { + self = .strenuosityClass(x) + return + } + throw DecodingError.typeMismatch(StrenuosityElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for StrenuosityElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .strenuosityClass(let x): + try container.encode(x) + } + } + } + + struct StrenuosityClass: Codable { + let bliss: Int? + let buccate: Int? + let bulletproof: Int? + let catharticalness: Double? + let chirotherium: Int? + let crumblingness: Int? + let disdiapason: String? + let engagedly: Int? + let fightable: Int? + let hoariness: Int? + let homocerc: Bool? + let hypopodium: Int? + let luxurist: Int? + let mechanician: Int? + let nonbookish: JSONNull? + let onopordon: Int? + let podgily: Int? + let reformableness: Int? + let scatterbrains: Int? + let seminuria: Int? + let sodomite: Int? + let tramp: Int? + let undueness: Int? + let worthily: Int? + let yankeeist: Int? + + enum CodingKeys: String, CodingKey { + case bliss = "bliss" + case buccate = "buccate" + case bulletproof = "bulletproof" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case crumblingness = "crumblingness" + case disdiapason = "disdiapason" + case engagedly = "engagedly" + case fightable = "fightable" + case hoariness = "hoariness" + case homocerc = "homocerc" + case hypopodium = "hypopodium" + case luxurist = "luxurist" + case mechanician = "mechanician" + case nonbookish = "nonbookish" + case onopordon = "Onopordon" + case podgily = "podgily" + case reformableness = "reformableness" + case scatterbrains = "scatterbrains" + case seminuria = "seminuria" + case sodomite = "Sodomite" + case tramp = "tramp" + case undueness = "undueness" + case worthily = "worthily" + case yankeeist = "Yankeeist" + } + } + + enum Tabaxir: Codable { + case bool(Bool) + case double(Double) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Tabaxir.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Tabaxir")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + } + } + } + + enum Talpiform: Codable { + case double(Double) + case quebrachineClass(TopLevel.QuebrachineClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(TopLevel.QuebrachineClass.self) { + self = .quebrachineClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Talpiform.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Talpiform")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .quebrachineClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } + } + + enum Thwack: Codable { + case bool(Bool) + case double(Double) + case quebrachineClass(TopLevel.QuebrachineClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(TopLevel.QuebrachineClass.self) { + self = .quebrachineClass(x) + return + } + throw DecodingError.typeMismatch(Thwack.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Thwack")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .quebrachineClass(let x): + try container.encode(x) + } + } + } + + enum Tortricine: Codable { + case quebrachineClass(TopLevel.QuebrachineClass) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + if let x = try? container.decode(TopLevel.QuebrachineClass.self) { + self = .quebrachineClass(x) + return + } + throw DecodingError.typeMismatch(Tortricine.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Tortricine")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .quebrachineClass(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } + } + + enum TruantcyElement: Codable { + case bool(Bool) + case truantcyClass(TopLevel.TruantcyClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(TopLevel.TruantcyClass.self) { + self = .truantcyClass(x) + return + } + throw DecodingError.typeMismatch(TruantcyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for TruantcyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .truantcyClass(let x): + try container.encode(x) + } + } + } + + struct TruantcyClass: Codable { + let alfiona: JSONNull? + let ascaridiasis: JSONNull? + let bungey: JSONNull? + let catharticalness: Double? + let ceroxyle: JSONNull? + let chirotherium: Int? + let chorology: JSONNull? + let disdiapason: String? + let enmarble: JSONNull? + let epeira: JSONNull? + let eurylaimi: JSONNull? + let germination: JSONNull? + let hallelujah: JSONNull? + let homocerc: Bool? + let lev: JSONNull? + let mouthing: JSONNull? + let nonbookish: JSONNull? + let philliloo: JSONNull? + let planetal: JSONNull? + let poney: JSONNull? + let punctualist: JSONNull? + let returnlessly: JSONNull? + let skelder: JSONNull? + let windwaywardly: JSONNull? + let yuman: JSONNull? + + enum CodingKeys: String, CodingKey { + case alfiona = "alfiona" + case ascaridiasis = "ascaridiasis" + case bungey = "bungey" + case catharticalness = "catharticalness" + case ceroxyle = "ceroxyle" + case chirotherium = "Chirotherium" + case chorology = "chorology" + case disdiapason = "disdiapason" + case enmarble = "enmarble" + case epeira = "Epeira" + case eurylaimi = "Eurylaimi" + case germination = "germination" + case hallelujah = "hallelujah" + case homocerc = "homocerc" + case lev = "lev" + case mouthing = "mouthing" + case nonbookish = "nonbookish" + case philliloo = "philliloo" + case planetal = "planetal" + case poney = "poney" + case punctualist = "punctualist" + case returnlessly = "returnlessly" + case skelder = "skelder" + case windwaywardly = "windwaywardly" + case yuman = "Yuman" + } + } + + enum Unbeginning: Codable { + case integerMap([String: Int]) + case nullArray([JSONNull?]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Unbeginning.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unbeginning")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerMap(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + enum Undesirability: Codable { + case integerArray([Int]) + case integerMap([String: Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Undesirability.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Undesirability")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + enum Unerasing: Codable { + case integer(Int) + case integerMap([String: Int]) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Unerasing.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unerasing")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } + } + + enum Unguentarium: Codable { + case integer(Int) + case nullArray([JSONNull?]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Unguentarium.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unguentarium")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } + } + + enum UnimpeachablyElement: Codable { + case bool(Bool) + case unimpeachablyClass(TopLevel.UnimpeachablyClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(TopLevel.UnimpeachablyClass.self) { + self = .unimpeachablyClass(x) + return + } + throw DecodingError.typeMismatch(UnimpeachablyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for UnimpeachablyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .unimpeachablyClass(let x): + try container.encode(x) + } + } + } + + struct UnimpeachablyClass: Codable { + let acerin: Int? + let bobadil: Int? + let catharticalness: Double? + let chirotherium: Int? + let chlorophylligenous: Int? + let conversational: Int? + let demiowl: Int? + let disdiapason: String? + let ectorhinal: Int? + let gamblesomeness: Int? + let homocerc: Bool? + let irrorate: Int? + let kindergartening: Int? + let lateritic: Int? + let mespil: Int? + let misconfiguration: Int? + let nonbookish: JSONNull? + let planometry: Int? + let quiina: Int? + let robert: Int? + let rot: Int? + let subcinctorium: Int? + let tussocker: Int? + let ultraproud: Int? + let unsuggestedness: Int? + + enum CodingKeys: String, CodingKey { + case acerin = "acerin" + case bobadil = "Bobadil" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case chlorophylligenous = "chlorophylligenous" + case conversational = "conversational" + case demiowl = "demiowl" + case disdiapason = "disdiapason" + case ectorhinal = "ectorhinal" + case gamblesomeness = "gamblesomeness" + case homocerc = "homocerc" + case irrorate = "irrorate" + case kindergartening = "kindergartening" + case lateritic = "lateritic" + case mespil = "mespil" + case misconfiguration = "misconfiguration" + case nonbookish = "nonbookish" + case planometry = "planometry" + case quiina = "Quiina" + case robert = "Robert" + case rot = "rot" + case subcinctorium = "subcinctorium" + case tussocker = "tussocker" + case ultraproud = "ultraproud" + case unsuggestedness = "unsuggestedness" + } + } + + enum Unmortgaged: Codable { + case double(Double) + case integerMap([String: Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Unmortgaged.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unmortgaged")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } + } + + enum Unobstructed: Codable { + case integer(Int) + case quebrachineClass(TopLevel.QuebrachineClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(TopLevel.QuebrachineClass.self) { + self = .quebrachineClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Unobstructed.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unobstructed")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .quebrachineClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } + } + + enum Unreceptivity: Codable { + case integer(Int) + case nullArray([JSONNull?]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Unreceptivity.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unreceptivity")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } + } + + enum Unsatisfactoriness: Codable { + case bool(Bool) + case integer(Int) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + throw DecodingError.typeMismatch(Unsatisfactoriness.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unsatisfactoriness")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } + } + + enum UnstressedElement: Codable { + case bool(Bool) + case string(String) + case unstressedClass(TopLevel.UnstressedClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(TopLevel.UnstressedClass.self) { + self = .unstressedClass(x) + return + } + throw DecodingError.typeMismatch(UnstressedElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for UnstressedElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .unstressedClass(let x): + try container.encode(x) + } + } + } + + struct UnstressedClass: Codable { + let alain: JSONNull? + let amphirhina: JSONNull? + let antimachinery: JSONNull? + let coldish: JSONNull? + let crantara: JSONNull? + let distinguishing: JSONNull? + let elytroposis: JSONNull? + let gentianwort: JSONNull? + let heliosis: JSONNull? + let instrumental: JSONNull? + let introinflection: JSONNull? + let kala: JSONNull? + let lincolnian: JSONNull? + let metad: JSONNull? + let sarcophilus: JSONNull? + let swingingly: JSONNull? + let unconformity: JSONNull? + let undecreed: JSONNull? + let venerable: JSONNull? + let vowellessness: JSONNull? + + enum CodingKeys: String, CodingKey { + case alain = "Alain" + case amphirhina = "Amphirhina" + case antimachinery = "antimachinery" + case coldish = "coldish" + case crantara = "crantara" + case distinguishing = "distinguishing" + case elytroposis = "elytroposis" + case gentianwort = "gentianwort" + case heliosis = "heliosis" + case instrumental = "instrumental" + case introinflection = "introinflection" + case kala = "kala" + case lincolnian = "Lincolnian" + case metad = "metad" + case sarcophilus = "Sarcophilus" + case swingingly = "swingingly" + case unconformity = "unconformity" + case undecreed = "undecreed" + case venerable = "venerable" + case vowellessness = "vowellessness" + } + } + + enum Untasked: Codable { + case double(Double) + case integerMap([String: Int]) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Untasked.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Untasked")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } + } + + enum Unvarying: Codable { + case bool(Bool) + case double(Double) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Unvarying.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unvarying")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } + } + + enum Vehemently: Codable { + case bool(Bool) + case nullArray([JSONNull?]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Vehemently.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Vehemently")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } + } + + enum Whitepot: Codable { + case double(Double) + case quebrachineClass(TopLevel.QuebrachineClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(TopLevel.QuebrachineClass.self) { + self = .quebrachineClass(x) + return + } + throw DecodingError.typeMismatch(Whitepot.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Whitepot")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .quebrachineClass(let x): + try container.encode(x) + } + } + } + + enum WrothyElement: Codable { + case nullArray([JSONNull?]) + case wrothyClass(TopLevel.WrothyClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(TopLevel.WrothyClass.self) { + self = .wrothyClass(x) + return + } + throw DecodingError.typeMismatch(WrothyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for WrothyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .wrothyClass(let x): + try container.encode(x) + } + } + } + + struct WrothyClass: Codable { + let aeschynanthus: JSONNull? + let aquiferous: JSONNull? + let cheapener: JSONNull? + let enumeration: JSONNull? + let ephesine: JSONNull? + let escadrille: JSONNull? + let estrous: JSONNull? + let interestedly: JSONNull? + let katakinetomer: JSONNull? + let mortification: JSONNull? + let morula: JSONNull? + let orthosymmetrical: JSONNull? + let overbark: JSONNull? + let politist: JSONNull? + let qualified: JSONNull? + let sphenomalar: JSONNull? + let throatful: JSONNull? + let transhumance: JSONNull? + let triandrian: JSONNull? + let unbooked: JSONNull? + + enum CodingKeys: String, CodingKey { + case aeschynanthus = "Aeschynanthus" + case aquiferous = "aquiferous" + case cheapener = "cheapener" + case enumeration = "enumeration" + case ephesine = "Ephesine" + case escadrille = "escadrille" + case estrous = "estrous" + case interestedly = "interestedly" + case katakinetomer = "katakinetomer" + case mortification = "mortification" + case morula = "morula" + case orthosymmetrical = "orthosymmetrical" + case overbark = "overbark" + case politist = "politist" + case qualified = "qualified" + case sphenomalar = "sphenomalar" + case throatful = "throatful" + case transhumance = "transhumance" + case triandrian = "triandrian" + case unbooked = "unbooked" + } + } + + // MARK: Helper functions for creating encoders and decoders + static func newJSONDecoder() -> JSONDecoder { + let decoder = JSONDecoder() + decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in + let container = try decoder.singleValueContainer() + let dateStr = try container.decode(String.self) + + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date")) + }) + return decoder + } + + static func newJSONEncoder() -> JSONEncoder { + let encoder = JSONEncoder() + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder + } +} + +// MARK: TopLevel convenience initializers and mutators + +extension TopLevel { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + protrusive: [TopLevel.Protrusive]? = nil, + pulpitism: [TopLevel.PulpitismElement]? = nil, + pyodermia: [TopLevel.PyodermiaElement]? = nil, + quebrachine: [TopLevel.QuebrachineElement]? = nil, + querier: [TopLevel.Querier]? = nil, + rebarbative: [TopLevel.Rebarbative]? = nil, + reimagine: [TopLevel.Reimagine]? = nil, + ressaut: TopLevel.Ressaut? = nil, + retrocervical: [TopLevel.Retrocervical]? = nil, + revert: [TopLevel.Revert]? = nil, + rewrite: [TopLevel.RewriteElement]? = nil, + saccoderm: [TopLevel.Saccoderm]? = nil, + santir: [TopLevel.SantirElement]? = nil, + saprophilous: [TopLevel.Saprophilous]? = nil, + saxten: [TopLevel.SaxtenElement]? = nil, + scatty: [TopLevel.Scatty?]? = nil, + scoffer: [TopLevel.Scoffer]? = nil, + scrampum: [TopLevel.Scrampum]? = nil, + semantic: Double? = nil, + serpentinic: [TopLevel.Serpentinic]? = nil, + shadowable: [TopLevel.Shadowable]? = nil, + sistering: [TopLevel.SisteringElement]? = nil, + staghunting: [TopLevel.Staghunting]? = nil, + stagmometer: [TopLevel.Stagmometer]? = nil, + stimulability: [TopLevel.Stimulability]? = nil, + strangleable: [TopLevel.Strangleable]? = nil, + strenuosity: [TopLevel.StrenuosityElement]? = nil, + tabaxir: [TopLevel.Tabaxir]? = nil, + talpiform: [TopLevel.Talpiform]? = nil, + thwack: [TopLevel.Thwack]? = nil, + to: [Double?]? = nil, + tortricine: [TopLevel.Tortricine]? = nil, + truantcy: [TopLevel.TruantcyElement]? = nil, + turgesce: [String]? = nil, + unbeginning: [TopLevel.Unbeginning]? = nil, + underdunged: [Double]? = nil, + undesirability: [TopLevel.Undesirability]? = nil, + unerasing: [TopLevel.Unerasing]? = nil, + unguentarium: [TopLevel.Unguentarium]? = nil, + unimpeachably: [TopLevel.UnimpeachablyElement]? = nil, + unmortgaged: [TopLevel.Unmortgaged]? = nil, + unobstructed: [TopLevel.Unobstructed]? = nil, + unreceptivity: [TopLevel.Unreceptivity]? = nil, + unsatisfactoriness: [TopLevel.Unsatisfactoriness]? = nil, + unsecurity: [Int]? = nil, + unstressed: [TopLevel.UnstressedElement]? = nil, + untasked: [TopLevel.Untasked]? = nil, + unvarying: [TopLevel.Unvarying]? = nil, + vehemently: [TopLevel.Vehemently]? = nil, + warriorship: [String: Bool]? = nil, + whitepot: [TopLevel.Whitepot]? = nil, + wrothy: [TopLevel.WrothyElement]? = nil + ) -> TopLevel { + return TopLevel( + protrusive: protrusive ?? self.protrusive, + pulpitism: pulpitism ?? self.pulpitism, + pyodermia: pyodermia ?? self.pyodermia, + quebrachine: quebrachine ?? self.quebrachine, + querier: querier ?? self.querier, + rebarbative: rebarbative ?? self.rebarbative, + reimagine: reimagine ?? self.reimagine, + ressaut: ressaut ?? self.ressaut, + retrocervical: retrocervical ?? self.retrocervical, + revert: revert ?? self.revert, + rewrite: rewrite ?? self.rewrite, + saccoderm: saccoderm ?? self.saccoderm, + santir: santir ?? self.santir, + saprophilous: saprophilous ?? self.saprophilous, + saxten: saxten ?? self.saxten, + scatty: scatty ?? self.scatty, + scoffer: scoffer ?? self.scoffer, + scrampum: scrampum ?? self.scrampum, + semantic: semantic ?? self.semantic, + serpentinic: serpentinic ?? self.serpentinic, + shadowable: shadowable ?? self.shadowable, + sistering: sistering ?? self.sistering, + staghunting: staghunting ?? self.staghunting, + stagmometer: stagmometer ?? self.stagmometer, + stimulability: stimulability ?? self.stimulability, + strangleable: strangleable ?? self.strangleable, + strenuosity: strenuosity ?? self.strenuosity, + tabaxir: tabaxir ?? self.tabaxir, + talpiform: talpiform ?? self.talpiform, + thwack: thwack ?? self.thwack, + to: to ?? self.to, + tortricine: tortricine ?? self.tortricine, + truantcy: truantcy ?? self.truantcy, + turgesce: turgesce ?? self.turgesce, + unbeginning: unbeginning ?? self.unbeginning, + underdunged: underdunged ?? self.underdunged, + undesirability: undesirability ?? self.undesirability, + unerasing: unerasing ?? self.unerasing, + unguentarium: unguentarium ?? self.unguentarium, + unimpeachably: unimpeachably ?? self.unimpeachably, + unmortgaged: unmortgaged ?? self.unmortgaged, + unobstructed: unobstructed ?? self.unobstructed, + unreceptivity: unreceptivity ?? self.unreceptivity, + unsatisfactoriness: unsatisfactoriness ?? self.unsatisfactoriness, + unsecurity: unsecurity ?? self.unsecurity, + unstressed: unstressed ?? self.unstressed, + untasked: untasked ?? self.untasked, + unvarying: unvarying ?? self.unvarying, + vehemently: vehemently ?? self.vehemently, + warriorship: warriorship ?? self.warriorship, + whitepot: whitepot ?? self.whitepot, + wrothy: wrothy ?? self.wrothy + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.PulpitismClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.PulpitismClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + abnet: JSONNull?? = nil, + buckhorn: JSONNull?? = nil, + calciform: JSONNull?? = nil, + chelophore: JSONNull?? = nil, + cogitation: JSONNull?? = nil, + decreeable: JSONNull?? = nil, + despicable: JSONNull?? = nil, + isodiazo: JSONNull?? = nil, + jadedly: JSONNull?? = nil, + leptochlorite: JSONNull?? = nil, + nursling: JSONNull?? = nil, + palamedean: JSONNull?? = nil, + photoheliograph: JSONNull?? = nil, + pipewood: JSONNull?? = nil, + roberd: JSONNull?? = nil, + statable: JSONNull?? = nil, + superassume: JSONNull?? = nil, + syllabe: JSONNull?? = nil, + toughhead: JSONNull?? = nil, + underburn: JSONNull?? = nil + ) -> TopLevel.PulpitismClass { + return TopLevel.PulpitismClass( + abnet: abnet ?? self.abnet, + buckhorn: buckhorn ?? self.buckhorn, + calciform: calciform ?? self.calciform, + chelophore: chelophore ?? self.chelophore, + cogitation: cogitation ?? self.cogitation, + decreeable: decreeable ?? self.decreeable, + despicable: despicable ?? self.despicable, + isodiazo: isodiazo ?? self.isodiazo, + jadedly: jadedly ?? self.jadedly, + leptochlorite: leptochlorite ?? self.leptochlorite, + nursling: nursling ?? self.nursling, + palamedean: palamedean ?? self.palamedean, + photoheliograph: photoheliograph ?? self.photoheliograph, + pipewood: pipewood ?? self.pipewood, + roberd: roberd ?? self.roberd, + statable: statable ?? self.statable, + superassume: superassume ?? self.superassume, + syllabe: syllabe ?? self.syllabe, + toughhead: toughhead ?? self.toughhead, + underburn: underburn ?? self.underburn + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.PyodermiaClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.PyodermiaClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + aphoristically: JSONNull?? = nil, + apophyllous: JSONNull?? = nil, + cognize: JSONNull?? = nil, + dermonosology: JSONNull?? = nil, + gyppo: JSONNull?? = nil, + ither: JSONNull?? = nil, + juglandaceous: JSONNull?? = nil, + litho: JSONNull?? = nil, + macropterous: JSONNull?? = nil, + photographer: JSONNull?? = nil, + romancing: JSONNull?? = nil, + rumness: JSONNull?? = nil, + somniloquist: JSONNull?? = nil, + stressfully: JSONNull?? = nil, + tactically: JSONNull?? = nil, + tracheophony: JSONNull?? = nil, + unappositely: JSONNull?? = nil, + unclothedly: JSONNull?? = nil, + unimplied: JSONNull?? = nil, + unsyncopated: JSONNull?? = nil + ) -> TopLevel.PyodermiaClass { + return TopLevel.PyodermiaClass( + aphoristically: aphoristically ?? self.aphoristically, + apophyllous: apophyllous ?? self.apophyllous, + cognize: cognize ?? self.cognize, + dermonosology: dermonosology ?? self.dermonosology, + gyppo: gyppo ?? self.gyppo, + ither: ither ?? self.ither, + juglandaceous: juglandaceous ?? self.juglandaceous, + litho: litho ?? self.litho, + macropterous: macropterous ?? self.macropterous, + photographer: photographer ?? self.photographer, + romancing: romancing ?? self.romancing, + rumness: rumness ?? self.rumness, + somniloquist: somniloquist ?? self.somniloquist, + stressfully: stressfully ?? self.stressfully, + tactically: tactically ?? self.tactically, + tracheophony: tracheophony ?? self.tracheophony, + unappositely: unappositely ?? self.unappositely, + unclothedly: unclothedly ?? self.unclothedly, + unimplied: unimplied ?? self.unimplied, + unsyncopated: unsyncopated ?? self.unsyncopated + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.QuebrachineClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.QuebrachineClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + catharticalness: Double? = nil, + chirotherium: Int? = nil, + disdiapason: String? = nil, + homocerc: Bool? = nil, + nonbookish: JSONNull?? = nil + ) -> TopLevel.QuebrachineClass { + return TopLevel.QuebrachineClass( + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + homocerc: homocerc ?? self.homocerc, + nonbookish: nonbookish ?? self.nonbookish + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.Reimagine { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.Reimagine.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + adducible: JSONNull?? = nil, + anabolin: JSONNull?? = nil, + brainy: JSONNull?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + chrysamine: JSONNull?? = nil, + disdiapason: String?? = nil, + fluxweed: JSONNull?? = nil, + glaucine: JSONNull?? = nil, + grobianism: JSONNull?? = nil, + hermo: JSONNull?? = nil, + hieroglyphist: JSONNull?? = nil, + homocerc: Bool?? = nil, + icteroid: JSONNull?? = nil, + immortal: JSONNull?? = nil, + impetulant: JSONNull?? = nil, + irrigate: JSONNull?? = nil, + myxedema: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + onyx: JSONNull?? = nil, + repasser: JSONNull?? = nil, + septomarginal: JSONNull?? = nil, + subdie: JSONNull?? = nil, + tibiometatarsal: JSONNull?? = nil, + waltzlike: JSONNull?? = nil + ) -> TopLevel.Reimagine { + return TopLevel.Reimagine( + adducible: adducible ?? self.adducible, + anabolin: anabolin ?? self.anabolin, + brainy: brainy ?? self.brainy, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + chrysamine: chrysamine ?? self.chrysamine, + disdiapason: disdiapason ?? self.disdiapason, + fluxweed: fluxweed ?? self.fluxweed, + glaucine: glaucine ?? self.glaucine, + grobianism: grobianism ?? self.grobianism, + hermo: hermo ?? self.hermo, + hieroglyphist: hieroglyphist ?? self.hieroglyphist, + homocerc: homocerc ?? self.homocerc, + icteroid: icteroid ?? self.icteroid, + immortal: immortal ?? self.immortal, + impetulant: impetulant ?? self.impetulant, + irrigate: irrigate ?? self.irrigate, + myxedema: myxedema ?? self.myxedema, + nonbookish: nonbookish ?? self.nonbookish, + onyx: onyx ?? self.onyx, + repasser: repasser ?? self.repasser, + septomarginal: septomarginal ?? self.septomarginal, + subdie: subdie ?? self.subdie, + tibiometatarsal: tibiometatarsal ?? self.tibiometatarsal, + waltzlike: waltzlike ?? self.waltzlike + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.Ressaut { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.Ressaut.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + apperceptive: String? = nil, + cuttoo: String? = nil, + douser: String? = nil, + drinkproof: String? = nil, + forementioned: String? = nil, + freesia: String? = nil, + genevieve: String? = nil, + hyperdiabolical: String? = nil, + hypocone: String? = nil, + irreverentially: String? = nil, + jumart: String? = nil, + mimosaceae: String? = nil, + mollicrush: String? = nil, + nedder: String? = nil, + retinasphalt: String? = nil, + sough: String? = nil, + steading: String? = nil, + theopaschitism: String? = nil, + undurableness: String? = nil, + unmingleable: String? = nil + ) -> TopLevel.Ressaut { + return TopLevel.Ressaut( + apperceptive: apperceptive ?? self.apperceptive, + cuttoo: cuttoo ?? self.cuttoo, + douser: douser ?? self.douser, + drinkproof: drinkproof ?? self.drinkproof, + forementioned: forementioned ?? self.forementioned, + freesia: freesia ?? self.freesia, + genevieve: genevieve ?? self.genevieve, + hyperdiabolical: hyperdiabolical ?? self.hyperdiabolical, + hypocone: hypocone ?? self.hypocone, + irreverentially: irreverentially ?? self.irreverentially, + jumart: jumart ?? self.jumart, + mimosaceae: mimosaceae ?? self.mimosaceae, + mollicrush: mollicrush ?? self.mollicrush, + nedder: nedder ?? self.nedder, + retinasphalt: retinasphalt ?? self.retinasphalt, + sough: sough ?? self.sough, + steading: steading ?? self.steading, + theopaschitism: theopaschitism ?? self.theopaschitism, + undurableness: undurableness ?? self.undurableness, + unmingleable: unmingleable ?? self.unmingleable + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.RewriteClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.RewriteClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + accountancy: JSONNull?? = nil, + cacotrophic: JSONNull?? = nil, + contest: JSONNull?? = nil, + couthily: JSONNull?? = nil, + falculate: JSONNull?? = nil, + foreseize: JSONNull?? = nil, + hyades: JSONNull?? = nil, + lemnad: JSONNull?? = nil, + monotheistically: JSONNull?? = nil, + nonflying: JSONNull?? = nil, + ptenoglossa: JSONNull?? = nil, + repatch: JSONNull?? = nil, + rodman: JSONNull?? = nil, + strung: JSONNull?? = nil, + titmal: JSONNull?? = nil, + twalpennyworth: JSONNull?? = nil, + unblamable: JSONNull?? = nil, + vertical: JSONNull?? = nil, + whiggification: JSONNull?? = nil, + yardman: JSONNull?? = nil + ) -> TopLevel.RewriteClass { + return TopLevel.RewriteClass( + accountancy: accountancy ?? self.accountancy, + cacotrophic: cacotrophic ?? self.cacotrophic, + contest: contest ?? self.contest, + couthily: couthily ?? self.couthily, + falculate: falculate ?? self.falculate, + foreseize: foreseize ?? self.foreseize, + hyades: hyades ?? self.hyades, + lemnad: lemnad ?? self.lemnad, + monotheistically: monotheistically ?? self.monotheistically, + nonflying: nonflying ?? self.nonflying, + ptenoglossa: ptenoglossa ?? self.ptenoglossa, + repatch: repatch ?? self.repatch, + rodman: rodman ?? self.rodman, + strung: strung ?? self.strung, + titmal: titmal ?? self.titmal, + twalpennyworth: twalpennyworth ?? self.twalpennyworth, + unblamable: unblamable ?? self.unblamable, + vertical: vertical ?? self.vertical, + whiggification: whiggification ?? self.whiggification, + yardman: yardman ?? self.yardman + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.SantirClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.SantirClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + admiredly: JSONNull?? = nil, + demicaponier: JSONNull?? = nil, + epitympanic: JSONNull?? = nil, + investitor: JSONNull?? = nil, + lupiform: JSONNull?? = nil, + monoflagellate: JSONNull?? = nil, + paleoethnic: JSONNull?? = nil, + prediscountable: JSONNull?? = nil, + rhetoricals: JSONNull?? = nil, + roomth: JSONNull?? = nil, + saccharose: JSONNull?? = nil, + septonasal: JSONNull?? = nil, + serpenticide: JSONNull?? = nil, + setarious: JSONNull?? = nil, + spaework: JSONNull?? = nil, + stylite: JSONNull?? = nil, + suessiones: JSONNull?? = nil, + timelily: JSONNull?? = nil, + unprofaned: JSONNull?? = nil, + vorticular: JSONNull?? = nil + ) -> TopLevel.SantirClass { + return TopLevel.SantirClass( + admiredly: admiredly ?? self.admiredly, + demicaponier: demicaponier ?? self.demicaponier, + epitympanic: epitympanic ?? self.epitympanic, + investitor: investitor ?? self.investitor, + lupiform: lupiform ?? self.lupiform, + monoflagellate: monoflagellate ?? self.monoflagellate, + paleoethnic: paleoethnic ?? self.paleoethnic, + prediscountable: prediscountable ?? self.prediscountable, + rhetoricals: rhetoricals ?? self.rhetoricals, + roomth: roomth ?? self.roomth, + saccharose: saccharose ?? self.saccharose, + septonasal: septonasal ?? self.septonasal, + serpenticide: serpenticide ?? self.serpenticide, + setarious: setarious ?? self.setarious, + spaework: spaework ?? self.spaework, + stylite: stylite ?? self.stylite, + suessiones: suessiones ?? self.suessiones, + timelily: timelily ?? self.timelily, + unprofaned: unprofaned ?? self.unprofaned, + vorticular: vorticular ?? self.vorticular + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.SaxtenClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.SaxtenClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + algarrobilla: JSONNull?? = nil, + bowgrace: JSONNull?? = nil, + catharticalness: Double?? = nil, + centaurid: JSONNull?? = nil, + chirotherium: Int?? = nil, + disdiapason: String?? = nil, + flix: JSONNull?? = nil, + germanely: JSONNull?? = nil, + homocerc: Bool?? = nil, + inhume: JSONNull?? = nil, + lepidote: JSONNull?? = nil, + megalochirous: JSONNull?? = nil, + ninepenny: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + nondeist: JSONNull?? = nil, + nymphaeaceous: JSONNull?? = nil, + parietofrontal: JSONNull?? = nil, + sancyite: JSONNull?? = nil, + subjectivist: JSONNull?? = nil, + tibiad: JSONNull?? = nil, + transonic: JSONNull?? = nil, + tripetalous: JSONNull?? = nil, + trunchman: JSONNull?? = nil, + urger: JSONNull?? = nil, + withdrawnness: JSONNull?? = nil + ) -> TopLevel.SaxtenClass { + return TopLevel.SaxtenClass( + algarrobilla: algarrobilla ?? self.algarrobilla, + bowgrace: bowgrace ?? self.bowgrace, + catharticalness: catharticalness ?? self.catharticalness, + centaurid: centaurid ?? self.centaurid, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + flix: flix ?? self.flix, + germanely: germanely ?? self.germanely, + homocerc: homocerc ?? self.homocerc, + inhume: inhume ?? self.inhume, + lepidote: lepidote ?? self.lepidote, + megalochirous: megalochirous ?? self.megalochirous, + ninepenny: ninepenny ?? self.ninepenny, + nonbookish: nonbookish ?? self.nonbookish, + nondeist: nondeist ?? self.nondeist, + nymphaeaceous: nymphaeaceous ?? self.nymphaeaceous, + parietofrontal: parietofrontal ?? self.parietofrontal, + sancyite: sancyite ?? self.sancyite, + subjectivist: subjectivist ?? self.subjectivist, + tibiad: tibiad ?? self.tibiad, + transonic: transonic ?? self.transonic, + tripetalous: tripetalous ?? self.tripetalous, + trunchman: trunchman ?? self.trunchman, + urger: urger ?? self.urger, + withdrawnness: withdrawnness ?? self.withdrawnness + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.Scatty { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.Scatty.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + aeriferous: JSONNull?? = nil, + antical: JSONNull?? = nil, + antighostism: JSONNull?? = nil, + arcanum: JSONNull?? = nil, + autotrophy: JSONNull?? = nil, + baronial: JSONNull?? = nil, + caffeine: JSONNull?? = nil, + gorgoniacean: JSONNull?? = nil, + heroical: JSONNull?? = nil, + hydropical: JSONNull?? = nil, + mechanology: JSONNull?? = nil, + musicopoetic: JSONNull?? = nil, + officiality: JSONNull?? = nil, + oftentimes: JSONNull?? = nil, + ophthalmotonometer: JSONNull?? = nil, + reflectively: JSONNull?? = nil, + springer: JSONNull?? = nil, + tabasco: JSONNull?? = nil, + teleianthous: JSONNull?? = nil, + uncombated: JSONNull?? = nil + ) -> TopLevel.Scatty { + return TopLevel.Scatty( + aeriferous: aeriferous ?? self.aeriferous, + antical: antical ?? self.antical, + antighostism: antighostism ?? self.antighostism, + arcanum: arcanum ?? self.arcanum, + autotrophy: autotrophy ?? self.autotrophy, + baronial: baronial ?? self.baronial, + caffeine: caffeine ?? self.caffeine, + gorgoniacean: gorgoniacean ?? self.gorgoniacean, + heroical: heroical ?? self.heroical, + hydropical: hydropical ?? self.hydropical, + mechanology: mechanology ?? self.mechanology, + musicopoetic: musicopoetic ?? self.musicopoetic, + officiality: officiality ?? self.officiality, + oftentimes: oftentimes ?? self.oftentimes, + ophthalmotonometer: ophthalmotonometer ?? self.ophthalmotonometer, + reflectively: reflectively ?? self.reflectively, + springer: springer ?? self.springer, + tabasco: tabasco ?? self.tabasco, + teleianthous: teleianthous ?? self.teleianthous, + uncombated: uncombated ?? self.uncombated + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.SisteringClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.SisteringClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + amphicarpic: JSONNull?? = nil, + chianti: JSONNull?? = nil, + frigorific: JSONNull?? = nil, + haplomi: JSONNull?? = nil, + hyperkinesis: JSONNull?? = nil, + laudable: JSONNull?? = nil, + madwoman: JSONNull?? = nil, + maimedly: JSONNull?? = nil, + micropterygidae: JSONNull?? = nil, + microrhabdus: JSONNull?? = nil, + nondense: JSONNull?? = nil, + phlebemphraxis: JSONNull?? = nil, + redsear: JSONNull?? = nil, + schismatical: JSONNull?? = nil, + tartryl: JSONNull?? = nil, + unabhorred: JSONNull?? = nil, + undeliberateness: JSONNull?? = nil, + unmixable: JSONNull?? = nil, + untruckling: JSONNull?? = nil, + vineal: JSONNull?? = nil + ) -> TopLevel.SisteringClass { + return TopLevel.SisteringClass( + amphicarpic: amphicarpic ?? self.amphicarpic, + chianti: chianti ?? self.chianti, + frigorific: frigorific ?? self.frigorific, + haplomi: haplomi ?? self.haplomi, + hyperkinesis: hyperkinesis ?? self.hyperkinesis, + laudable: laudable ?? self.laudable, + madwoman: madwoman ?? self.madwoman, + maimedly: maimedly ?? self.maimedly, + micropterygidae: micropterygidae ?? self.micropterygidae, + microrhabdus: microrhabdus ?? self.microrhabdus, + nondense: nondense ?? self.nondense, + phlebemphraxis: phlebemphraxis ?? self.phlebemphraxis, + redsear: redsear ?? self.redsear, + schismatical: schismatical ?? self.schismatical, + tartryl: tartryl ?? self.tartryl, + unabhorred: unabhorred ?? self.unabhorred, + undeliberateness: undeliberateness ?? self.undeliberateness, + unmixable: unmixable ?? self.unmixable, + untruckling: untruckling ?? self.untruckling, + vineal: vineal ?? self.vineal + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.Staghunting { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.Staghunting.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + calorimetric: Int?? = nil, + canid: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + disdiapason: String?? = nil, + ditriglyphic: Int?? = nil, + floriferousness: Int?? = nil, + gamelike: Int?? = nil, + grig: Int?? = nil, + homocerc: Bool?? = nil, + interloan: Int?? = nil, + lithotomy: Int?? = nil, + loric: Int?? = nil, + membranocoriaceous: Int?? = nil, + membranogenic: Int?? = nil, + nonbookish: JSONNull?? = nil, + overtrump: Int?? = nil, + scotino: Int?? = nil, + seasonable: Int?? = nil, + sephen: Int?? = nil, + stigmarioid: Int?? = nil, + tired: Int?? = nil, + trifid: Int?? = nil, + undefeatedly: Int?? = nil, + ungirlish: Int?? = nil + ) -> TopLevel.Staghunting { + return TopLevel.Staghunting( + calorimetric: calorimetric ?? self.calorimetric, + canid: canid ?? self.canid, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + ditriglyphic: ditriglyphic ?? self.ditriglyphic, + floriferousness: floriferousness ?? self.floriferousness, + gamelike: gamelike ?? self.gamelike, + grig: grig ?? self.grig, + homocerc: homocerc ?? self.homocerc, + interloan: interloan ?? self.interloan, + lithotomy: lithotomy ?? self.lithotomy, + loric: loric ?? self.loric, + membranocoriaceous: membranocoriaceous ?? self.membranocoriaceous, + membranogenic: membranogenic ?? self.membranogenic, + nonbookish: nonbookish ?? self.nonbookish, + overtrump: overtrump ?? self.overtrump, + scotino: scotino ?? self.scotino, + seasonable: seasonable ?? self.seasonable, + sephen: sephen ?? self.sephen, + stigmarioid: stigmarioid ?? self.stigmarioid, + tired: tired ?? self.tired, + trifid: trifid ?? self.trifid, + undefeatedly: undefeatedly ?? self.undefeatedly, + ungirlish: ungirlish ?? self.ungirlish + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.StrenuosityClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.StrenuosityClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + bliss: Int?? = nil, + buccate: Int?? = nil, + bulletproof: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + crumblingness: Int?? = nil, + disdiapason: String?? = nil, + engagedly: Int?? = nil, + fightable: Int?? = nil, + hoariness: Int?? = nil, + homocerc: Bool?? = nil, + hypopodium: Int?? = nil, + luxurist: Int?? = nil, + mechanician: Int?? = nil, + nonbookish: JSONNull?? = nil, + onopordon: Int?? = nil, + podgily: Int?? = nil, + reformableness: Int?? = nil, + scatterbrains: Int?? = nil, + seminuria: Int?? = nil, + sodomite: Int?? = nil, + tramp: Int?? = nil, + undueness: Int?? = nil, + worthily: Int?? = nil, + yankeeist: Int?? = nil + ) -> TopLevel.StrenuosityClass { + return TopLevel.StrenuosityClass( + bliss: bliss ?? self.bliss, + buccate: buccate ?? self.buccate, + bulletproof: bulletproof ?? self.bulletproof, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + crumblingness: crumblingness ?? self.crumblingness, + disdiapason: disdiapason ?? self.disdiapason, + engagedly: engagedly ?? self.engagedly, + fightable: fightable ?? self.fightable, + hoariness: hoariness ?? self.hoariness, + homocerc: homocerc ?? self.homocerc, + hypopodium: hypopodium ?? self.hypopodium, + luxurist: luxurist ?? self.luxurist, + mechanician: mechanician ?? self.mechanician, + nonbookish: nonbookish ?? self.nonbookish, + onopordon: onopordon ?? self.onopordon, + podgily: podgily ?? self.podgily, + reformableness: reformableness ?? self.reformableness, + scatterbrains: scatterbrains ?? self.scatterbrains, + seminuria: seminuria ?? self.seminuria, + sodomite: sodomite ?? self.sodomite, + tramp: tramp ?? self.tramp, + undueness: undueness ?? self.undueness, + worthily: worthily ?? self.worthily, + yankeeist: yankeeist ?? self.yankeeist + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.TruantcyClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.TruantcyClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + alfiona: JSONNull?? = nil, + ascaridiasis: JSONNull?? = nil, + bungey: JSONNull?? = nil, + catharticalness: Double?? = nil, + ceroxyle: JSONNull?? = nil, + chirotherium: Int?? = nil, + chorology: JSONNull?? = nil, + disdiapason: String?? = nil, + enmarble: JSONNull?? = nil, + epeira: JSONNull?? = nil, + eurylaimi: JSONNull?? = nil, + germination: JSONNull?? = nil, + hallelujah: JSONNull?? = nil, + homocerc: Bool?? = nil, + lev: JSONNull?? = nil, + mouthing: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + philliloo: JSONNull?? = nil, + planetal: JSONNull?? = nil, + poney: JSONNull?? = nil, + punctualist: JSONNull?? = nil, + returnlessly: JSONNull?? = nil, + skelder: JSONNull?? = nil, + windwaywardly: JSONNull?? = nil, + yuman: JSONNull?? = nil + ) -> TopLevel.TruantcyClass { + return TopLevel.TruantcyClass( + alfiona: alfiona ?? self.alfiona, + ascaridiasis: ascaridiasis ?? self.ascaridiasis, + bungey: bungey ?? self.bungey, + catharticalness: catharticalness ?? self.catharticalness, + ceroxyle: ceroxyle ?? self.ceroxyle, + chirotherium: chirotherium ?? self.chirotherium, + chorology: chorology ?? self.chorology, + disdiapason: disdiapason ?? self.disdiapason, + enmarble: enmarble ?? self.enmarble, + epeira: epeira ?? self.epeira, + eurylaimi: eurylaimi ?? self.eurylaimi, + germination: germination ?? self.germination, + hallelujah: hallelujah ?? self.hallelujah, + homocerc: homocerc ?? self.homocerc, + lev: lev ?? self.lev, + mouthing: mouthing ?? self.mouthing, + nonbookish: nonbookish ?? self.nonbookish, + philliloo: philliloo ?? self.philliloo, + planetal: planetal ?? self.planetal, + poney: poney ?? self.poney, + punctualist: punctualist ?? self.punctualist, + returnlessly: returnlessly ?? self.returnlessly, + skelder: skelder ?? self.skelder, + windwaywardly: windwaywardly ?? self.windwaywardly, + yuman: yuman ?? self.yuman + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.UnimpeachablyClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.UnimpeachablyClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + acerin: Int?? = nil, + bobadil: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + chlorophylligenous: Int?? = nil, + conversational: Int?? = nil, + demiowl: Int?? = nil, + disdiapason: String?? = nil, + ectorhinal: Int?? = nil, + gamblesomeness: Int?? = nil, + homocerc: Bool?? = nil, + irrorate: Int?? = nil, + kindergartening: Int?? = nil, + lateritic: Int?? = nil, + mespil: Int?? = nil, + misconfiguration: Int?? = nil, + nonbookish: JSONNull?? = nil, + planometry: Int?? = nil, + quiina: Int?? = nil, + robert: Int?? = nil, + rot: Int?? = nil, + subcinctorium: Int?? = nil, + tussocker: Int?? = nil, + ultraproud: Int?? = nil, + unsuggestedness: Int?? = nil + ) -> TopLevel.UnimpeachablyClass { + return TopLevel.UnimpeachablyClass( + acerin: acerin ?? self.acerin, + bobadil: bobadil ?? self.bobadil, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + chlorophylligenous: chlorophylligenous ?? self.chlorophylligenous, + conversational: conversational ?? self.conversational, + demiowl: demiowl ?? self.demiowl, + disdiapason: disdiapason ?? self.disdiapason, + ectorhinal: ectorhinal ?? self.ectorhinal, + gamblesomeness: gamblesomeness ?? self.gamblesomeness, + homocerc: homocerc ?? self.homocerc, + irrorate: irrorate ?? self.irrorate, + kindergartening: kindergartening ?? self.kindergartening, + lateritic: lateritic ?? self.lateritic, + mespil: mespil ?? self.mespil, + misconfiguration: misconfiguration ?? self.misconfiguration, + nonbookish: nonbookish ?? self.nonbookish, + planometry: planometry ?? self.planometry, + quiina: quiina ?? self.quiina, + robert: robert ?? self.robert, + rot: rot ?? self.rot, + subcinctorium: subcinctorium ?? self.subcinctorium, + tussocker: tussocker ?? self.tussocker, + ultraproud: ultraproud ?? self.ultraproud, + unsuggestedness: unsuggestedness ?? self.unsuggestedness + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.UnstressedClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.UnstressedClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + alain: JSONNull?? = nil, + amphirhina: JSONNull?? = nil, + antimachinery: JSONNull?? = nil, + coldish: JSONNull?? = nil, + crantara: JSONNull?? = nil, + distinguishing: JSONNull?? = nil, + elytroposis: JSONNull?? = nil, + gentianwort: JSONNull?? = nil, + heliosis: JSONNull?? = nil, + instrumental: JSONNull?? = nil, + introinflection: JSONNull?? = nil, + kala: JSONNull?? = nil, + lincolnian: JSONNull?? = nil, + metad: JSONNull?? = nil, + sarcophilus: JSONNull?? = nil, + swingingly: JSONNull?? = nil, + unconformity: JSONNull?? = nil, + undecreed: JSONNull?? = nil, + venerable: JSONNull?? = nil, + vowellessness: JSONNull?? = nil + ) -> TopLevel.UnstressedClass { + return TopLevel.UnstressedClass( + alain: alain ?? self.alain, + amphirhina: amphirhina ?? self.amphirhina, + antimachinery: antimachinery ?? self.antimachinery, + coldish: coldish ?? self.coldish, + crantara: crantara ?? self.crantara, + distinguishing: distinguishing ?? self.distinguishing, + elytroposis: elytroposis ?? self.elytroposis, + gentianwort: gentianwort ?? self.gentianwort, + heliosis: heliosis ?? self.heliosis, + instrumental: instrumental ?? self.instrumental, + introinflection: introinflection ?? self.introinflection, + kala: kala ?? self.kala, + lincolnian: lincolnian ?? self.lincolnian, + metad: metad ?? self.metad, + sarcophilus: sarcophilus ?? self.sarcophilus, + swingingly: swingingly ?? self.swingingly, + unconformity: unconformity ?? self.unconformity, + undecreed: undecreed ?? self.undecreed, + venerable: venerable ?? self.venerable, + vowellessness: vowellessness ?? self.vowellessness + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +extension TopLevel.WrothyClass { + init(data: Data) throws { + self = try TopLevel.newJSONDecoder().decode(TopLevel.WrothyClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + aeschynanthus: JSONNull?? = nil, + aquiferous: JSONNull?? = nil, + cheapener: JSONNull?? = nil, + enumeration: JSONNull?? = nil, + ephesine: JSONNull?? = nil, + escadrille: JSONNull?? = nil, + estrous: JSONNull?? = nil, + interestedly: JSONNull?? = nil, + katakinetomer: JSONNull?? = nil, + mortification: JSONNull?? = nil, + morula: JSONNull?? = nil, + orthosymmetrical: JSONNull?? = nil, + overbark: JSONNull?? = nil, + politist: JSONNull?? = nil, + qualified: JSONNull?? = nil, + sphenomalar: JSONNull?? = nil, + throatful: JSONNull?? = nil, + transhumance: JSONNull?? = nil, + triandrian: JSONNull?? = nil, + unbooked: JSONNull?? = nil + ) -> TopLevel.WrothyClass { + return TopLevel.WrothyClass( + aeschynanthus: aeschynanthus ?? self.aeschynanthus, + aquiferous: aquiferous ?? self.aquiferous, + cheapener: cheapener ?? self.cheapener, + enumeration: enumeration ?? self.enumeration, + ephesine: ephesine ?? self.ephesine, + escadrille: escadrille ?? self.escadrille, + estrous: estrous ?? self.estrous, + interestedly: interestedly ?? self.interestedly, + katakinetomer: katakinetomer ?? self.katakinetomer, + mortification: mortification ?? self.mortification, + morula: morula ?? self.morula, + orthosymmetrical: orthosymmetrical ?? self.orthosymmetrical, + overbark: overbark ?? self.overbark, + politist: politist ?? self.politist, + qualified: qualified ?? self.qualified, + sphenomalar: sphenomalar ?? self.sphenomalar, + throatful: throatful ?? self.throatful, + transhumance: transhumance ?? self.transhumance, + triandrian: triandrian ?? self.triandrian, + unbooked: unbooked ?? self.unbooked + ) + } + + func jsonData() throws -> Data { + return try TopLevel.newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - Encode/decode helpers + +class JSONNull: Codable, Hashable { + + public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool { + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(0) + } + + public init() {} + + public required init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if !container.decodeNil() { + throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull")) + } + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + try container.encodeNil() + } +}