diff --git a/base/cjson/test/inputs/json/priority/keywords.json/default/TopLevel.c b/head/cjson/test/inputs/json/priority/keywords.json/default/TopLevel.c index 7557795..a1b125d 100644 --- a/base/cjson/test/inputs/json/priority/keywords.json/default/TopLevel.c +++ b/head/cjson/test/inputs/json/priority/keywords.json/default/TopLevel.c @@ -14990,6 +14990,61 @@ void cJSON_DeleteRight(struct Right * x) { } } +struct S * cJSON_ParseS(const char * s) { + struct S * x = NULL; + if (NULL != s) { + cJSON * j = cJSON_Parse(s); + if (NULL != j) { + x = cJSON_GetSValue(j); + cJSON_Delete(j); + } + } + return x; +} + +struct S * cJSON_GetSValue(const cJSON * j) { + struct S * x = NULL; + if (NULL != j) { + if (NULL != (x = cJSON_malloc(sizeof(struct S)))) { + memset(x, 0, sizeof(struct S)); + if (!cJSON_HasObjectItem(j, "s")) { cJSON_DeleteS(x); return NULL; } + if (cJSON_HasObjectItem(j, "s")) { + if (!quicktype_cJSON_IsInteger(cJSON_GetObjectItemCaseSensitive(j, "s"))) { cJSON_DeleteS(x); return NULL; } + x->s = cJSON_GetNumberValue(cJSON_GetObjectItemCaseSensitive(j, "s")); + } + } + } + return x; +} + +cJSON * cJSON_CreateS(const struct S * x) { + cJSON * j = NULL; + if (NULL != x) { + if (NULL != (j = cJSON_CreateObject())) { + cJSON_AddNumberToObject(j, "s", x->s); + } + } + return j; +} + +char * cJSON_PrintS(const struct S * x) { + char * s = NULL; + if (NULL != x) { + cJSON * j = cJSON_CreateS(x); + if (NULL != j) { + s = cJSON_Print(j); + cJSON_Delete(j); + } + } + return s; +} + +void cJSON_DeleteS(struct S * x) { + if (NULL != x) { + cJSON_free(x); + } +} + struct Sbyte * cJSON_ParseSbyte(const char * s) { struct Sbyte * x = NULL; if (NULL != s) { @@ -16621,6 +16676,12 @@ struct Obj4 * cJSON_GetObj4Value(const cJSON * j) { x->right = cJSON_GetRightValue(cJSON_GetObjectItemCaseSensitive(j, "right")); if (NULL == x->right) { cJSON_DeleteObj4(x); return NULL; } } + if (!cJSON_HasObjectItem(j, "s")) { cJSON_DeleteObj4(x); return NULL; } + if (cJSON_HasObjectItem(j, "s")) { + if (!cJSON_IsObject(cJSON_GetObjectItemCaseSensitive(j, "s"))) { cJSON_DeleteObj4(x); return NULL; } + x->s = cJSON_GetSValue(cJSON_GetObjectItemCaseSensitive(j, "s")); + if (NULL == x->s) { cJSON_DeleteObj4(x); return NULL; } + } if (!cJSON_HasObjectItem(j, "sbyte")) { cJSON_DeleteObj4(x); return NULL; } if (cJSON_HasObjectItem(j, "sbyte")) { if (!cJSON_IsObject(cJSON_GetObjectItemCaseSensitive(j, "sbyte"))) { cJSON_DeleteObj4(x); return NULL; } @@ -16820,6 +16881,7 @@ cJSON * cJSON_CreateObj4(const struct Obj4 * x) { cJSON_AddItemToObject(j, "retain", cJSON_CreateRetain(x->retain)); cJSON_AddItemToObject(j, "rethrows", cJSON_CreateRethrows(x->rethrows)); cJSON_AddItemToObject(j, "right", cJSON_CreateRight(x->right)); + cJSON_AddItemToObject(j, "s", cJSON_CreateS(x->s)); cJSON_AddItemToObject(j, "sbyte", cJSON_CreateSbyte(x->sbyte)); cJSON_AddItemToObject(j, "sealed", cJSON_CreateSealed(x->sealed)); cJSON_AddItemToObject(j, "SEL", cJSON_CreateSel(x->sel)); @@ -16981,6 +17043,9 @@ void cJSON_DeleteObj4(struct Obj4 * x) { if (NULL != x->right) { cJSON_DeleteRight(x->right); } + if (NULL != x->s) { + cJSON_DeleteS(x->s); + } if (NULL != x->sbyte) { cJSON_DeleteSbyte(x->sbyte); } diff --git a/base/cjson/test/inputs/json/priority/keywords.json/default/TopLevel.h b/head/cjson/test/inputs/json/priority/keywords.json/default/TopLevel.h index 42b25a3..a3eabe3 100644 --- a/base/cjson/test/inputs/json/priority/keywords.json/default/TopLevel.h +++ b/head/cjson/test/inputs/json/priority/keywords.json/default/TopLevel.h @@ -1181,6 +1181,10 @@ struct Right { int64_t right; }; +struct S { + int64_t s; +}; + struct Sbyte { int64_t sbyte; }; @@ -1322,6 +1326,7 @@ struct Obj4 { struct Retain * retain; struct Rethrows * rethrows; struct Right * right; + struct S * s; struct Sbyte * sbyte; struct Sealed * sealed; struct Sel * sel; @@ -2884,6 +2889,12 @@ cJSON * cJSON_CreateRight(const struct Right * x); char * cJSON_PrintRight(const struct Right * x); void cJSON_DeleteRight(struct Right * x); +struct S * cJSON_ParseS(const char * s); +struct S * cJSON_GetSValue(const cJSON * j); +cJSON * cJSON_CreateS(const struct S * x); +char * cJSON_PrintS(const struct S * x); +void cJSON_DeleteS(struct S * x); + struct Sbyte * cJSON_ParseSbyte(const char * s); struct Sbyte * cJSON_GetSbyteValue(const cJSON * j); cJSON * cJSON_CreateSbyte(const struct Sbyte * x); diff --git a/base/cplusplus/test/inputs/json/priority/keywords.json/default/quicktype.hpp b/head/cplusplus/test/inputs/json/priority/keywords.json/default/quicktype.hpp index c3aa09a..07becbf 100644 --- a/base/cplusplus/test/inputs/json/priority/keywords.json/default/quicktype.hpp +++ b/head/cplusplus/test/inputs/json/priority/keywords.json/default/quicktype.hpp @@ -4310,6 +4310,20 @@ namespace quicktype { void set_right(const int64_t & value) { this->right = value; } }; + class S { + public: + S() = default; + virtual ~S() = default; + + private: + int64_t s; + + public: + const int64_t & get_s() const { return s; } + int64_t & get_mutable_s() { return s; } + void set_s(const int64_t & value) { this->s = value; } + }; + class Sbyte { public: Sbyte() = default; @@ -4719,6 +4733,7 @@ namespace quicktype { Retain retain; Rethrows rethrows; Right right; + S s; Sbyte sbyte; Sealed sealed; Sel sel; @@ -4903,6 +4918,10 @@ namespace quicktype { Right & get_mutable_right() { return right; } void set_right(const Right & value) { this->right = value; } + const S & get_s() const { return s; } + S & get_mutable_s() { return s; } + void set_s(const S & value) { this->s = value; } + const Sbyte & get_sbyte() const { return sbyte; } Sbyte & get_mutable_sbyte() { return sbyte; } void set_sbyte(const Sbyte & value) { this->sbyte = value; } @@ -6151,6 +6170,9 @@ namespace quicktype { void from_json(const json & j, Right & x); void to_json(json & j, const Right & x); + void from_json(const json & j, S & x); + void to_json(json & j, const S & x); + void from_json(const json & j, Sbyte & x); void to_json(json & j, const Sbyte & x); @@ -9284,6 +9306,17 @@ namespace quicktype { j["right"] = x.get_right(); } + inline void from_json(const json & j, S& x) { + if (!j.is_object()) throw std::runtime_error("Expected object"); + if (j.find("s") != j.end() && !j.at("s").is_number_integer()) throw std::runtime_error("Expected integer"); + x.set_s(j.at("s").get()); + } + + inline void to_json(json & j, const S & x) { + j = json::object(); + j["s"] = x.get_s(); + } + inline void from_json(const json & j, Sbyte& x) { if (!j.is_object()) throw std::runtime_error("Expected object"); if (j.find("sbyte") != j.end() && !j.at("sbyte").is_number_integer()) throw std::runtime_error("Expected integer"); @@ -9612,6 +9645,7 @@ namespace quicktype { x.set_retain(j.at("retain").get()); x.set_rethrows(j.at("rethrows").get()); x.set_right(j.at("right").get()); + x.set_s(j.at("s").get()); x.set_sbyte(j.at("sbyte").get()); x.set_sealed(j.at("sealed").get()); x.set_sel(j.at("SEL").get()); @@ -9681,6 +9715,7 @@ namespace quicktype { j["retain"] = x.get_retain(); j["rethrows"] = x.get_rethrows(); j["right"] = x.get_right(); + j["s"] = x.get_s(); j["sbyte"] = x.get_sbyte(); j["sealed"] = x.get_sealed(); j["SEL"] = x.get_sel(); diff --git a/base/crystal/test/inputs/json/priority/keywords.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/keywords.json/default/TopLevel.cr index b92d91e..2667c39 100644 --- a/base/crystal/test/inputs/json/priority/keywords.json/default/TopLevel.cr +++ b/head/crystal/test/inputs/json/priority/keywords.json/default/TopLevel.cr @@ -1755,6 +1755,8 @@ class Obj4 property right : Right + property s : S + property sbyte : Sbyte property sealed : Sealed @@ -2020,6 +2022,12 @@ class Right property right : Int64 end +class S + include JSON::Serializable + + property s : Int64 +end + class Sbyte include JSON::Serializable diff --git a/base/csharp/test/inputs/json/priority/keywords.json/default/QuickType.cs b/head/csharp/test/inputs/json/priority/keywords.json/default/QuickType.cs index dd675f2..d88524a 100644 --- a/base/csharp/test/inputs/json/priority/keywords.json/default/QuickType.cs +++ b/head/csharp/test/inputs/json/priority/keywords.json/default/QuickType.cs @@ -1885,6 +1885,9 @@ namespace QuickType [JsonProperty("right", Required = Required.Always)] public Right Right { get; set; } + [JsonProperty("s", Required = Required.Always)] + public S S { get; set; } + [JsonProperty("sbyte", Required = Required.Always)] public Sbyte Sbyte { get; set; } @@ -2141,6 +2144,12 @@ namespace QuickType public long RightRight { get; set; } } + public partial class S + { + [JsonProperty("s", Required = Required.Always)] + public long SS { get; set; } + } + public partial class Sbyte { [JsonProperty("sbyte", Required = Required.Always)] diff --git a/base/csharp-SystemTextJson/test/inputs/json/priority/keywords.json/default/QuickType.cs b/head/csharp-SystemTextJson/test/inputs/json/priority/keywords.json/default/QuickType.cs index eed1117..1e333ba 100644 --- a/base/csharp-SystemTextJson/test/inputs/json/priority/keywords.json/default/QuickType.cs +++ b/head/csharp-SystemTextJson/test/inputs/json/priority/keywords.json/default/QuickType.cs @@ -2303,6 +2303,10 @@ namespace QuickType [JsonPropertyName("right")] public Right Right { get; set; } + [JsonRequired] + [JsonPropertyName("s")] + public S S { get; set; } + [JsonRequired] [JsonPropertyName("sbyte")] public Sbyte Sbyte { get; set; } @@ -2623,6 +2627,13 @@ namespace QuickType public long RightRight { get; set; } } + public partial class S + { + [JsonRequired] + [JsonPropertyName("s")] + public long SS { get; set; } + } + public partial class Sbyte { [JsonRequired] diff --git a/base/csharp-records/test/inputs/json/priority/keywords.json/default/QuickType.cs b/head/csharp-records/test/inputs/json/priority/keywords.json/default/QuickType.cs index 65c63fd..eec1680 100644 --- a/base/csharp-records/test/inputs/json/priority/keywords.json/default/QuickType.cs +++ b/head/csharp-records/test/inputs/json/priority/keywords.json/default/QuickType.cs @@ -1885,6 +1885,9 @@ namespace QuickType [JsonProperty("right", Required = Required.Always)] public Right Right { get; set; } + [JsonProperty("s", Required = Required.Always)] + public S S { get; set; } + [JsonProperty("sbyte", Required = Required.Always)] public Sbyte Sbyte { get; set; } @@ -2141,6 +2144,12 @@ namespace QuickType public long RightRight { get; set; } } + public partial record S + { + [JsonProperty("s", Required = Required.Always)] + public long SS { get; set; } + } + public partial record Sbyte { [JsonProperty("sbyte", Required = Required.Always)] diff --git a/head/dart/test/inputs/json/priority/combinations1.json/from-map-true--d222f65b3fee/TopLevel.dart b/head/dart/test/inputs/json/priority/combinations1.json/from-map-true--d222f65b3fee/TopLevel.dart new file mode 100644 index 0000000..37bf404 --- /dev/null +++ b/head/dart/test/inputs/json/priority/combinations1.json/from-map-true--d222f65b3fee/TopLevel.dart @@ -0,0 +1,1329 @@ +// To parse this JSON data, do +// +// final topLevel = topLevelFromJson(jsonString); + +import 'dart:convert'; + +TopLevel topLevelFromJson(String str) => TopLevel.fromMap(json.decode(str)); + +String topLevelToJson(TopLevel data) => json.encode(data.toMap()); + +class TopLevel { + final String centrodesmose; + final List cerograph; + final List chemotherapeutics; + final List cimelia; + final int citrated; + final List clinodome; + final List coadjust; + final List consilience; + final List constructor; + final List continuative; + final List credulity; + final List creviced; + final List> cubiculum; + final List deruralize; + final List diaereses; + final List?> dissolution; + final List downstroke; + final List electrotautomerism; + final List eleutheromania; + final Encrust encrust; + final List entomoid; + final List epipaleolithic; + final List expropriable; + final List faggingly; + final List fenks; + final List flagmaking; + final List fluorometer; + final List fulsome; + final List fuzzy; + final List gardenwards; + final List generalissimo; + final List?> habeas; + final List hemicrystalline; + final List hemocoele; + final List hoister; + final List hyperpiesis; + final List hyppish; + final List idealizer; + final List incrustator; + final List intentiveness; + final Interacinar interacinar; + final List?> intercorrelation; + final List jacutinga; + + TopLevel({ + required this.centrodesmose, + required this.cerograph, + required this.chemotherapeutics, + required this.cimelia, + required this.citrated, + required this.clinodome, + required this.coadjust, + required this.consilience, + required this.constructor, + required this.continuative, + required this.credulity, + required this.creviced, + required this.cubiculum, + required this.deruralize, + required this.diaereses, + required this.dissolution, + required this.downstroke, + required this.electrotautomerism, + required this.eleutheromania, + required this.encrust, + required this.entomoid, + required this.epipaleolithic, + required this.expropriable, + required this.faggingly, + required this.fenks, + required this.flagmaking, + required this.fluorometer, + required this.fulsome, + required this.fuzzy, + required this.gardenwards, + required this.generalissimo, + required this.habeas, + required this.hemicrystalline, + required this.hemocoele, + required this.hoister, + required this.hyperpiesis, + required this.hyppish, + required this.idealizer, + required this.incrustator, + required this.intentiveness, + required this.interacinar, + required this.intercorrelation, + required this.jacutinga, + }); + + factory TopLevel.fromMap(Map json) => TopLevel( + centrodesmose: json["centrodesmose"], + cerograph: List.from(json["cerograph"].map((x) => x)), + chemotherapeutics: List.from(json["chemotherapeutics"].map((x) => x)), + cimelia: List.from(json["cimelia"].map((x) => x)), + citrated: json["citrated"], + clinodome: List.from(json["clinodome"].map((x) => x)), + coadjust: List.from(json["coadjust"].map((x) => x)), + consilience: List.from(json["consilience"].map((x) => x)), + constructor: List.from(json["constructor"].map((x) => x)), + continuative: List.from(json["continuative"].map((x) => x)), + credulity: List.from(json["credulity"].map((x) => x)), + creviced: List.from(json["creviced"].map((x) => x)), + cubiculum: List>.from(json["cubiculum"].map((x) => List.from(x.map((x) => x)))), + deruralize: List.from(json["deruralize"].map((x) => x)), + diaereses: List.from(json["diaereses"].map((x) => x)), + dissolution: List?>.from(json["dissolution"].map((x) => x == null ? null : List.from(x!.map((x) => x)))), + downstroke: List.from(json["downstroke"].map((x) => x)), + electrotautomerism: List.from(json["electrotautomerism"].map((x) => x?.toDouble())), + eleutheromania: List.from(json["eleutheromania"].map((x) => x)), + encrust: Encrust.fromMap(json["encrust"]), + entomoid: List.from(json["entomoid"].map((x) => x)), + epipaleolithic: List.from(json["epipaleolithic"].map((x) => x)), + expropriable: List.from(json["expropriable"].map((x) => x)), + faggingly: List.from(json["faggingly"].map((x) => x)), + fenks: List.from(json["fenks"].map((x) => x)), + flagmaking: List.from(json["flagmaking"].map((x) => x)), + fluorometer: List.from(json["fluorometer"].map((x) => x)), + fulsome: List.from(json["fulsome"].map((x) => x)), + fuzzy: List.from(json["fuzzy"].map((x) => x)), + gardenwards: List.from(json["gardenwards"].map((x) => x)), + generalissimo: List.from(json["generalissimo"].map((x) => x)), + habeas: List?>.from(json["habeas"].map((x) => x == null ? null : Map.from(x!).map((k, v) => MapEntry(k, v)))), + hemicrystalline: List.from(json["hemicrystalline"].map((x) => x)), + hemocoele: List.from(json["hemocoele"].map((x) => x)), + hoister: List.from(json["hoister"].map((x) => x)), + hyperpiesis: List.from(json["hyperpiesis"].map((x) => x)), + hyppish: List.from(json["hyppish"].map((x) => x)), + idealizer: List.from(json["idealizer"].map((x) => x)), + incrustator: List.from(json["incrustator"].map((x) => x)), + intentiveness: List.from(json["intentiveness"].map((x) => x)), + interacinar: Interacinar.fromMap(json["interacinar"]), + intercorrelation: List?>.from(json["intercorrelation"].map((x) => x == null ? null : List.from(x!.map((x) => x)))), + jacutinga: List.from(json["jacutinga"].map((x) => x)), + ); + + Map toMap() => { + "centrodesmose": centrodesmose, + "cerograph": List.from(cerograph.map((x) => x)), + "chemotherapeutics": List.from(chemotherapeutics.map((x) => x)), + "cimelia": List.from(cimelia.map((x) => x)), + "citrated": citrated, + "clinodome": List.from(clinodome.map((x) => x)), + "coadjust": List.from(coadjust.map((x) => x)), + "consilience": List.from(consilience.map((x) => x)), + "constructor": List.from(constructor.map((x) => x)), + "continuative": List.from(continuative.map((x) => x)), + "credulity": List.from(credulity.map((x) => x)), + "creviced": List.from(creviced.map((x) => x)), + "cubiculum": List.from(cubiculum.map((x) => List.from(x.map((x) => x)))), + "deruralize": List.from(deruralize.map((x) => x)), + "diaereses": List.from(diaereses.map((x) => x)), + "dissolution": List.from(dissolution.map((x) => x == null ? null : List.from(x!.map((x) => x)))), + "downstroke": List.from(downstroke.map((x) => x)), + "electrotautomerism": List.from(electrotautomerism.map((x) => x)), + "eleutheromania": List.from(eleutheromania.map((x) => x)), + "encrust": encrust.toMap(), + "entomoid": List.from(entomoid.map((x) => x)), + "epipaleolithic": List.from(epipaleolithic.map((x) => x)), + "expropriable": List.from(expropriable.map((x) => x)), + "faggingly": List.from(faggingly.map((x) => x)), + "fenks": List.from(fenks.map((x) => x)), + "flagmaking": List.from(flagmaking.map((x) => x)), + "fluorometer": List.from(fluorometer.map((x) => x)), + "fulsome": List.from(fulsome.map((x) => x)), + "fuzzy": List.from(fuzzy.map((x) => x)), + "gardenwards": List.from(gardenwards.map((x) => x)), + "generalissimo": List.from(generalissimo.map((x) => x)), + "habeas": List.from(habeas.map((x) => x == null ? null : Map.from(x!).map((k, v) => MapEntry(k, v)))), + "hemicrystalline": List.from(hemicrystalline.map((x) => x)), + "hemocoele": List.from(hemocoele.map((x) => x)), + "hoister": List.from(hoister.map((x) => x)), + "hyperpiesis": List.from(hyperpiesis.map((x) => x)), + "hyppish": List.from(hyppish.map((x) => x)), + "idealizer": List.from(idealizer.map((x) => x)), + "incrustator": List.from(incrustator.map((x) => x)), + "intentiveness": List.from(intentiveness.map((x) => x)), + "interacinar": interacinar.toMap(), + "intercorrelation": List.from(intercorrelation.map((x) => x == null ? null : List.from(x!.map((x) => x)))), + "jacutinga": List.from(jacutinga.map((x) => x)), + }; +} + +class CerographClass { + final dynamic apotropaion; + final dynamic casuary; + final dynamic creaker; + final dynamic disqualification; + final dynamic imperatorious; + final dynamic impermeabilize; + final dynamic metastoma; + final dynamic noctidiurnal; + final dynamic nonreserve; + final dynamic ophthalmotonometry; + final dynamic pailful; + final dynamic pigfish; + final dynamic pongee; + final dynamic prosodical; + final dynamic scrofuloderm; + final dynamic storekeeping; + final dynamic therologist; + final dynamic tolowa; + final dynamic tradeful; + final dynamic unriveting; + + CerographClass({ + required this.apotropaion, + required this.casuary, + required this.creaker, + required this.disqualification, + required this.imperatorious, + required this.impermeabilize, + required this.metastoma, + required this.noctidiurnal, + required this.nonreserve, + required this.ophthalmotonometry, + required this.pailful, + required this.pigfish, + required this.pongee, + required this.prosodical, + required this.scrofuloderm, + required this.storekeeping, + required this.therologist, + required this.tolowa, + required this.tradeful, + required this.unriveting, + }); + + factory CerographClass.fromMap(Map json) => CerographClass( + apotropaion: (json.containsKey("apotropaion") ? json["apotropaion"] : throw FormatException('Missing required property')), + casuary: (json.containsKey("casuary") ? json["casuary"] : throw FormatException('Missing required property')), + creaker: (json.containsKey("creaker") ? json["creaker"] : throw FormatException('Missing required property')), + disqualification: (json.containsKey("disqualification") ? json["disqualification"] : throw FormatException('Missing required property')), + imperatorious: (json.containsKey("imperatorious") ? json["imperatorious"] : throw FormatException('Missing required property')), + impermeabilize: (json.containsKey("impermeabilize") ? json["impermeabilize"] : throw FormatException('Missing required property')), + metastoma: (json.containsKey("metastoma") ? json["metastoma"] : throw FormatException('Missing required property')), + noctidiurnal: (json.containsKey("noctidiurnal") ? json["noctidiurnal"] : throw FormatException('Missing required property')), + nonreserve: (json.containsKey("nonreserve") ? json["nonreserve"] : throw FormatException('Missing required property')), + ophthalmotonometry: (json.containsKey("ophthalmotonometry") ? json["ophthalmotonometry"] : throw FormatException('Missing required property')), + pailful: (json.containsKey("pailful") ? json["pailful"] : throw FormatException('Missing required property')), + pigfish: (json.containsKey("pigfish") ? json["pigfish"] : throw FormatException('Missing required property')), + pongee: (json.containsKey("pongee") ? json["pongee"] : throw FormatException('Missing required property')), + prosodical: (json.containsKey("prosodical") ? json["prosodical"] : throw FormatException('Missing required property')), + scrofuloderm: (json.containsKey("scrofuloderm") ? json["scrofuloderm"] : throw FormatException('Missing required property')), + storekeeping: (json.containsKey("storekeeping") ? json["storekeeping"] : throw FormatException('Missing required property')), + therologist: (json.containsKey("therologist") ? json["therologist"] : throw FormatException('Missing required property')), + tolowa: (json.containsKey("Tolowa") ? json["Tolowa"] : throw FormatException('Missing required property')), + tradeful: (json.containsKey("tradeful") ? json["tradeful"] : throw FormatException('Missing required property')), + unriveting: (json.containsKey("unriveting") ? json["unriveting"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "apotropaion": apotropaion, + "casuary": casuary, + "creaker": creaker, + "disqualification": disqualification, + "imperatorious": imperatorious, + "impermeabilize": impermeabilize, + "metastoma": metastoma, + "noctidiurnal": noctidiurnal, + "nonreserve": nonreserve, + "ophthalmotonometry": ophthalmotonometry, + "pailful": pailful, + "pigfish": pigfish, + "pongee": pongee, + "prosodical": prosodical, + "scrofuloderm": scrofuloderm, + "storekeeping": storekeeping, + "therologist": therologist, + "Tolowa": tolowa, + "tradeful": tradeful, + "unriveting": unriveting, + }; +} + +class ChemotherapeuticClass { + final dynamic angioneurotic; + final dynamic availment; + final dynamic bladelet; + final double? catharticalness; + final dynamic caulis; + final dynamic chalcus; + final int? chirotherium; + final String? disdiapason; + final dynamic enteradenological; + final bool? homocerc; + final dynamic imporosity; + final dynamic insistently; + final dynamic intraparietal; + final dynamic ivied; + final dynamic maureen; + final dynamic nonbookish; + final dynamic nostochine; + final dynamic nutcracker; + final dynamic ofttimes; + final dynamic phenocryst; + final dynamic precoincident; + final dynamic ramiferous; + final dynamic stagmometer; + final dynamic tetherball; + final dynamic unshy; + + ChemotherapeuticClass({ + this.angioneurotic, + this.availment, + this.bladelet, + this.catharticalness, + this.caulis, + this.chalcus, + this.chirotherium, + this.disdiapason, + this.enteradenological, + this.homocerc, + this.imporosity, + this.insistently, + this.intraparietal, + this.ivied, + this.maureen, + this.nonbookish, + this.nostochine, + this.nutcracker, + this.ofttimes, + this.phenocryst, + this.precoincident, + this.ramiferous, + this.stagmometer, + this.tetherball, + this.unshy, + }); + + factory ChemotherapeuticClass.fromMap(Map json) => ChemotherapeuticClass( + angioneurotic: json["angioneurotic"], + availment: json["availment"], + bladelet: json["bladelet"], + catharticalness: json["catharticalness"]?.toDouble(), + caulis: json["caulis"], + chalcus: json["chalcus"], + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + enteradenological: json["enteradenological"], + homocerc: json["homocerc"], + imporosity: json["imporosity"], + insistently: json["insistently"], + intraparietal: json["intraparietal"], + ivied: json["ivied"], + maureen: json["Maureen"], + nonbookish: json["nonbookish"], + nostochine: json["nostochine"], + nutcracker: json["nutcracker"], + ofttimes: json["ofttimes"], + phenocryst: json["phenocryst"], + precoincident: json["precoincident"], + ramiferous: json["ramiferous"], + stagmometer: json["stagmometer"], + tetherball: json["tetherball"], + unshy: json["unshy"], + ); + + Map toMap() => { + "angioneurotic": angioneurotic, + "availment": availment, + "bladelet": bladelet, + "catharticalness": catharticalness, + "caulis": caulis, + "chalcus": chalcus, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "enteradenological": enteradenological, + "homocerc": homocerc, + "imporosity": imporosity, + "insistently": insistently, + "intraparietal": intraparietal, + "ivied": ivied, + "Maureen": maureen, + "nonbookish": nonbookish, + "nostochine": nostochine, + "nutcracker": nutcracker, + "ofttimes": ofttimes, + "phenocryst": phenocryst, + "precoincident": precoincident, + "ramiferous": ramiferous, + "stagmometer": stagmometer, + "tetherball": tetherball, + "unshy": unshy, + }; +} + +class CimeliaClass { + final double catharticalness; + final int chirotherium; + final String disdiapason; + final bool homocerc; + final dynamic nonbookish; + + CimeliaClass({ + required this.catharticalness, + required this.chirotherium, + required this.disdiapason, + required this.homocerc, + required this.nonbookish, + }); + + factory CimeliaClass.fromMap(Map json) => CimeliaClass( + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + homocerc: json["homocerc"], + nonbookish: (json.containsKey("nonbookish") ? json["nonbookish"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "homocerc": homocerc, + "nonbookish": nonbookish, + }; +} + +class CoadjustClass { + final dynamic amidosulphonal; + final dynamic benny; + final double? catharticalness; + final int? chirotherium; + final String? disdiapason; + final dynamic ensnare; + final bool? homocerc; + final dynamic hybridizer; + final dynamic leastwise; + final dynamic lof; + final dynamic monkhood; + final dynamic netherlandish; + final dynamic nonbookish; + final dynamic peonism; + final dynamic phonelescope; + final dynamic porphyrogeniture; + final dynamic preindemnify; + final dynamic rosal; + final dynamic scalenous; + final dynamic scopine; + final dynamic sedaceae; + final dynamic suberinize; + final dynamic symbiot; + final dynamic tablefellow; + final dynamic unchargeable; + + CoadjustClass({ + this.amidosulphonal, + this.benny, + this.catharticalness, + this.chirotherium, + this.disdiapason, + this.ensnare, + this.homocerc, + this.hybridizer, + this.leastwise, + this.lof, + this.monkhood, + this.netherlandish, + this.nonbookish, + this.peonism, + this.phonelescope, + this.porphyrogeniture, + this.preindemnify, + this.rosal, + this.scalenous, + this.scopine, + this.sedaceae, + this.suberinize, + this.symbiot, + this.tablefellow, + this.unchargeable, + }); + + factory CoadjustClass.fromMap(Map json) => CoadjustClass( + amidosulphonal: json["amidosulphonal"], + benny: json["Benny"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + ensnare: json["ensnare"], + homocerc: json["homocerc"], + hybridizer: json["hybridizer"], + leastwise: json["leastwise"], + lof: json["lof"], + monkhood: json["monkhood"], + netherlandish: json["Netherlandish"], + nonbookish: json["nonbookish"], + peonism: json["peonism"], + phonelescope: json["Phonelescope"], + porphyrogeniture: json["porphyrogeniture"], + preindemnify: json["preindemnify"], + rosal: json["rosal"], + scalenous: json["scalenous"], + scopine: json["scopine"], + sedaceae: json["Sedaceae"], + suberinize: json["suberinize"], + symbiot: json["symbiot"], + tablefellow: json["tablefellow"], + unchargeable: json["unchargeable"], + ); + + Map toMap() => { + "amidosulphonal": amidosulphonal, + "Benny": benny, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "ensnare": ensnare, + "homocerc": homocerc, + "hybridizer": hybridizer, + "leastwise": leastwise, + "lof": lof, + "monkhood": monkhood, + "Netherlandish": netherlandish, + "nonbookish": nonbookish, + "peonism": peonism, + "Phonelescope": phonelescope, + "porphyrogeniture": porphyrogeniture, + "preindemnify": preindemnify, + "rosal": rosal, + "scalenous": scalenous, + "scopine": scopine, + "Sedaceae": sedaceae, + "suberinize": suberinize, + "symbiot": symbiot, + "tablefellow": tablefellow, + "unchargeable": unchargeable, + }; +} + +class CredulityClass { + final dynamic ammonolytic; + final dynamic bushmaster; + final dynamic considering; + final dynamic consuetudinary; + final dynamic embarras; + final dynamic fineness; + final dynamic flaithship; + final dynamic flavia; + final dynamic gruffly; + final dynamic hedychium; + final dynamic leadwort; + final dynamic overseriously; + final dynamic parabola; + final dynamic pectinatodenticulate; + final dynamic popean; + final dynamic pornocrat; + final dynamic quadrisect; + final dynamic seriality; + final dynamic vamphorn; + final dynamic wharp; + + CredulityClass({ + required this.ammonolytic, + required this.bushmaster, + required this.considering, + required this.consuetudinary, + required this.embarras, + required this.fineness, + required this.flaithship, + required this.flavia, + required this.gruffly, + required this.hedychium, + required this.leadwort, + required this.overseriously, + required this.parabola, + required this.pectinatodenticulate, + required this.popean, + required this.pornocrat, + required this.quadrisect, + required this.seriality, + required this.vamphorn, + required this.wharp, + }); + + factory CredulityClass.fromMap(Map json) => CredulityClass( + ammonolytic: (json.containsKey("ammonolytic") ? json["ammonolytic"] : throw FormatException('Missing required property')), + bushmaster: (json.containsKey("bushmaster") ? json["bushmaster"] : throw FormatException('Missing required property')), + considering: (json.containsKey("considering") ? json["considering"] : throw FormatException('Missing required property')), + consuetudinary: (json.containsKey("consuetudinary") ? json["consuetudinary"] : throw FormatException('Missing required property')), + embarras: (json.containsKey("embarras") ? json["embarras"] : throw FormatException('Missing required property')), + fineness: (json.containsKey("fineness") ? json["fineness"] : throw FormatException('Missing required property')), + flaithship: (json.containsKey("flaithship") ? json["flaithship"] : throw FormatException('Missing required property')), + flavia: (json.containsKey("Flavia") ? json["Flavia"] : throw FormatException('Missing required property')), + gruffly: (json.containsKey("gruffly") ? json["gruffly"] : throw FormatException('Missing required property')), + hedychium: (json.containsKey("Hedychium") ? json["Hedychium"] : throw FormatException('Missing required property')), + leadwort: (json.containsKey("leadwort") ? json["leadwort"] : throw FormatException('Missing required property')), + overseriously: (json.containsKey("overseriously") ? json["overseriously"] : throw FormatException('Missing required property')), + parabola: (json.containsKey("parabola") ? json["parabola"] : throw FormatException('Missing required property')), + pectinatodenticulate: (json.containsKey("pectinatodenticulate") ? json["pectinatodenticulate"] : throw FormatException('Missing required property')), + popean: (json.containsKey("Popean") ? json["Popean"] : throw FormatException('Missing required property')), + pornocrat: (json.containsKey("pornocrat") ? json["pornocrat"] : throw FormatException('Missing required property')), + quadrisect: (json.containsKey("quadrisect") ? json["quadrisect"] : throw FormatException('Missing required property')), + seriality: (json.containsKey("seriality") ? json["seriality"] : throw FormatException('Missing required property')), + vamphorn: (json.containsKey("vamphorn") ? json["vamphorn"] : throw FormatException('Missing required property')), + wharp: (json.containsKey("wharp") ? json["wharp"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "ammonolytic": ammonolytic, + "bushmaster": bushmaster, + "considering": considering, + "consuetudinary": consuetudinary, + "embarras": embarras, + "fineness": fineness, + "flaithship": flaithship, + "Flavia": flavia, + "gruffly": gruffly, + "Hedychium": hedychium, + "leadwort": leadwort, + "overseriously": overseriously, + "parabola": parabola, + "pectinatodenticulate": pectinatodenticulate, + "Popean": popean, + "pornocrat": pornocrat, + "quadrisect": quadrisect, + "seriality": seriality, + "vamphorn": vamphorn, + "wharp": wharp, + }; +} + +class DeruralizeClass { + final dynamic bockerel; + final dynamic boulder; + final dynamic churrus; + final dynamic counterdigged; + final dynamic dialogite; + final dynamic digenic; + final dynamic dunbird; + final dynamic ergatogyne; + final dynamic fiendful; + final dynamic jackrod; + final dynamic jehovistic; + final dynamic paninean; + final dynamic panther; + final dynamic placentigerous; + final dynamic romney; + final dynamic sparm; + final dynamic tocsin; + final dynamic unnicked; + final dynamic unstavable; + final dynamic windfirm; + + DeruralizeClass({ + required this.bockerel, + required this.boulder, + required this.churrus, + required this.counterdigged, + required this.dialogite, + required this.digenic, + required this.dunbird, + required this.ergatogyne, + required this.fiendful, + required this.jackrod, + required this.jehovistic, + required this.paninean, + required this.panther, + required this.placentigerous, + required this.romney, + required this.sparm, + required this.tocsin, + required this.unnicked, + required this.unstavable, + required this.windfirm, + }); + + factory DeruralizeClass.fromMap(Map json) => DeruralizeClass( + bockerel: (json.containsKey("bockerel") ? json["bockerel"] : throw FormatException('Missing required property')), + boulder: (json.containsKey("boulder") ? json["boulder"] : throw FormatException('Missing required property')), + churrus: (json.containsKey("churrus") ? json["churrus"] : throw FormatException('Missing required property')), + counterdigged: (json.containsKey("counterdigged") ? json["counterdigged"] : throw FormatException('Missing required property')), + dialogite: (json.containsKey("dialogite") ? json["dialogite"] : throw FormatException('Missing required property')), + digenic: (json.containsKey("digenic") ? json["digenic"] : throw FormatException('Missing required property')), + dunbird: (json.containsKey("dunbird") ? json["dunbird"] : throw FormatException('Missing required property')), + ergatogyne: (json.containsKey("ergatogyne") ? json["ergatogyne"] : throw FormatException('Missing required property')), + fiendful: (json.containsKey("fiendful") ? json["fiendful"] : throw FormatException('Missing required property')), + jackrod: (json.containsKey("jackrod") ? json["jackrod"] : throw FormatException('Missing required property')), + jehovistic: (json.containsKey("Jehovistic") ? json["Jehovistic"] : throw FormatException('Missing required property')), + paninean: (json.containsKey("Paninean") ? json["Paninean"] : throw FormatException('Missing required property')), + panther: (json.containsKey("panther") ? json["panther"] : throw FormatException('Missing required property')), + placentigerous: (json.containsKey("placentigerous") ? json["placentigerous"] : throw FormatException('Missing required property')), + romney: (json.containsKey("Romney") ? json["Romney"] : throw FormatException('Missing required property')), + sparm: (json.containsKey("sparm") ? json["sparm"] : throw FormatException('Missing required property')), + tocsin: (json.containsKey("tocsin") ? json["tocsin"] : throw FormatException('Missing required property')), + unnicked: (json.containsKey("unnicked") ? json["unnicked"] : throw FormatException('Missing required property')), + unstavable: (json.containsKey("unstavable") ? json["unstavable"] : throw FormatException('Missing required property')), + windfirm: (json.containsKey("windfirm") ? json["windfirm"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "bockerel": bockerel, + "boulder": boulder, + "churrus": churrus, + "counterdigged": counterdigged, + "dialogite": dialogite, + "digenic": digenic, + "dunbird": dunbird, + "ergatogyne": ergatogyne, + "fiendful": fiendful, + "jackrod": jackrod, + "Jehovistic": jehovistic, + "Paninean": paninean, + "panther": panther, + "placentigerous": placentigerous, + "Romney": romney, + "sparm": sparm, + "tocsin": tocsin, + "unnicked": unnicked, + "unstavable": unstavable, + "windfirm": windfirm, + }; +} + +class DiaereseClass { + final dynamic amoreuxia; + final dynamic ani; + final dynamic bernicle; + final dynamic blackwasher; + final dynamic blowhard; + final dynamic broma; + final dynamic closecross; + final dynamic congregationalism; + final dynamic grayly; + final dynamic historically; + final dynamic hoast; + final dynamic irretentive; + final dynamic parcener; + final dynamic pedder; + final dynamic pseudoanatomic; + final dynamic rhizocarpian; + final dynamic samel; + final dynamic silker; + final dynamic subdentated; + final dynamic subobscure; + + DiaereseClass({ + required this.amoreuxia, + required this.ani, + required this.bernicle, + required this.blackwasher, + required this.blowhard, + required this.broma, + required this.closecross, + required this.congregationalism, + required this.grayly, + required this.historically, + required this.hoast, + required this.irretentive, + required this.parcener, + required this.pedder, + required this.pseudoanatomic, + required this.rhizocarpian, + required this.samel, + required this.silker, + required this.subdentated, + required this.subobscure, + }); + + factory DiaereseClass.fromMap(Map json) => DiaereseClass( + amoreuxia: (json.containsKey("Amoreuxia") ? json["Amoreuxia"] : throw FormatException('Missing required property')), + ani: (json.containsKey("ani") ? json["ani"] : throw FormatException('Missing required property')), + bernicle: (json.containsKey("bernicle") ? json["bernicle"] : throw FormatException('Missing required property')), + blackwasher: (json.containsKey("blackwasher") ? json["blackwasher"] : throw FormatException('Missing required property')), + blowhard: (json.containsKey("blowhard") ? json["blowhard"] : throw FormatException('Missing required property')), + broma: (json.containsKey("broma") ? json["broma"] : throw FormatException('Missing required property')), + closecross: (json.containsKey("closecross") ? json["closecross"] : throw FormatException('Missing required property')), + congregationalism: (json.containsKey("congregationalism") ? json["congregationalism"] : throw FormatException('Missing required property')), + grayly: (json.containsKey("grayly") ? json["grayly"] : throw FormatException('Missing required property')), + historically: (json.containsKey("historically") ? json["historically"] : throw FormatException('Missing required property')), + hoast: (json.containsKey("hoast") ? json["hoast"] : throw FormatException('Missing required property')), + irretentive: (json.containsKey("irretentive") ? json["irretentive"] : throw FormatException('Missing required property')), + parcener: (json.containsKey("parcener") ? json["parcener"] : throw FormatException('Missing required property')), + pedder: (json.containsKey("pedder") ? json["pedder"] : throw FormatException('Missing required property')), + pseudoanatomic: (json.containsKey("pseudoanatomic") ? json["pseudoanatomic"] : throw FormatException('Missing required property')), + rhizocarpian: (json.containsKey("rhizocarpian") ? json["rhizocarpian"] : throw FormatException('Missing required property')), + samel: (json.containsKey("samel") ? json["samel"] : throw FormatException('Missing required property')), + silker: (json.containsKey("silker") ? json["silker"] : throw FormatException('Missing required property')), + subdentated: (json.containsKey("subdentated") ? json["subdentated"] : throw FormatException('Missing required property')), + subobscure: (json.containsKey("subobscure") ? json["subobscure"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "Amoreuxia": amoreuxia, + "ani": ani, + "bernicle": bernicle, + "blackwasher": blackwasher, + "blowhard": blowhard, + "broma": broma, + "closecross": closecross, + "congregationalism": congregationalism, + "grayly": grayly, + "historically": historically, + "hoast": hoast, + "irretentive": irretentive, + "parcener": parcener, + "pedder": pedder, + "pseudoanatomic": pseudoanatomic, + "rhizocarpian": rhizocarpian, + "samel": samel, + "silker": silker, + "subdentated": subdentated, + "subobscure": subobscure, + }; +} + +class Encrust { + final dynamic comradely; + final dynamic diacanthous; + final dynamic feminineness; + final dynamic gossamered; + final dynamic hibernia; + final dynamic hibiscus; + final dynamic lepidosauria; + final dynamic lollingly; + final dynamic manager; + final dynamic mechanic; + final dynamic overminuteness; + final dynamic papelonne; + final dynamic plebification; + final dynamic pugmiller; + final dynamic recoveror; + final dynamic spermatoblastic; + final dynamic syllidae; + final dynamic ungyved; + final dynamic whirlabout; + final dynamic woodenware; + + Encrust({ + required this.comradely, + required this.diacanthous, + required this.feminineness, + required this.gossamered, + required this.hibernia, + required this.hibiscus, + required this.lepidosauria, + required this.lollingly, + required this.manager, + required this.mechanic, + required this.overminuteness, + required this.papelonne, + required this.plebification, + required this.pugmiller, + required this.recoveror, + required this.spermatoblastic, + required this.syllidae, + required this.ungyved, + required this.whirlabout, + required this.woodenware, + }); + + factory Encrust.fromMap(Map json) => Encrust( + comradely: (json.containsKey("comradely") ? json["comradely"] : throw FormatException('Missing required property')), + diacanthous: (json.containsKey("diacanthous") ? json["diacanthous"] : throw FormatException('Missing required property')), + feminineness: (json.containsKey("feminineness") ? json["feminineness"] : throw FormatException('Missing required property')), + gossamered: (json.containsKey("gossamered") ? json["gossamered"] : throw FormatException('Missing required property')), + hibernia: (json.containsKey("Hibernia") ? json["Hibernia"] : throw FormatException('Missing required property')), + hibiscus: (json.containsKey("Hibiscus") ? json["Hibiscus"] : throw FormatException('Missing required property')), + lepidosauria: (json.containsKey("Lepidosauria") ? json["Lepidosauria"] : throw FormatException('Missing required property')), + lollingly: (json.containsKey("lollingly") ? json["lollingly"] : throw FormatException('Missing required property')), + manager: (json.containsKey("manager") ? json["manager"] : throw FormatException('Missing required property')), + mechanic: (json.containsKey("mechanic") ? json["mechanic"] : throw FormatException('Missing required property')), + overminuteness: (json.containsKey("overminuteness") ? json["overminuteness"] : throw FormatException('Missing required property')), + papelonne: (json.containsKey("papelonne") ? json["papelonne"] : throw FormatException('Missing required property')), + plebification: (json.containsKey("plebification") ? json["plebification"] : throw FormatException('Missing required property')), + pugmiller: (json.containsKey("pugmiller") ? json["pugmiller"] : throw FormatException('Missing required property')), + recoveror: (json.containsKey("recoveror") ? json["recoveror"] : throw FormatException('Missing required property')), + spermatoblastic: (json.containsKey("spermatoblastic") ? json["spermatoblastic"] : throw FormatException('Missing required property')), + syllidae: (json.containsKey("Syllidae") ? json["Syllidae"] : throw FormatException('Missing required property')), + ungyved: (json.containsKey("ungyved") ? json["ungyved"] : throw FormatException('Missing required property')), + whirlabout: (json.containsKey("whirlabout") ? json["whirlabout"] : throw FormatException('Missing required property')), + woodenware: (json.containsKey("woodenware") ? json["woodenware"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "comradely": comradely, + "diacanthous": diacanthous, + "feminineness": feminineness, + "gossamered": gossamered, + "Hibernia": hibernia, + "Hibiscus": hibiscus, + "Lepidosauria": lepidosauria, + "lollingly": lollingly, + "manager": manager, + "mechanic": mechanic, + "overminuteness": overminuteness, + "papelonne": papelonne, + "plebification": plebification, + "pugmiller": pugmiller, + "recoveror": recoveror, + "spermatoblastic": spermatoblastic, + "Syllidae": syllidae, + "ungyved": ungyved, + "whirlabout": whirlabout, + "woodenware": woodenware, + }; +} + +class FagginglyClass { + final dynamic abranchian; + final dynamic aculeiform; + final dynamic adiaphoristic; + final dynamic adoptionism; + final dynamic anglic; + final dynamic antrotomy; + final dynamic coerciveness; + final dynamic decorist; + final dynamic duckhood; + final dynamic heteromeri; + final dynamic hypochnose; + final dynamic lochage; + final dynamic melee; + final dynamic nonconformitant; + final dynamic poinsettia; + final dynamic putatively; + final dynamic semivolatile; + final dynamic soleas; + final dynamic unfastenable; + final dynamic unmillinered; + + FagginglyClass({ + required this.abranchian, + required this.aculeiform, + required this.adiaphoristic, + required this.adoptionism, + required this.anglic, + required this.antrotomy, + required this.coerciveness, + required this.decorist, + required this.duckhood, + required this.heteromeri, + required this.hypochnose, + required this.lochage, + required this.melee, + required this.nonconformitant, + required this.poinsettia, + required this.putatively, + required this.semivolatile, + required this.soleas, + required this.unfastenable, + required this.unmillinered, + }); + + factory FagginglyClass.fromMap(Map json) => FagginglyClass( + abranchian: (json.containsKey("abranchian") ? json["abranchian"] : throw FormatException('Missing required property')), + aculeiform: (json.containsKey("aculeiform") ? json["aculeiform"] : throw FormatException('Missing required property')), + adiaphoristic: (json.containsKey("adiaphoristic") ? json["adiaphoristic"] : throw FormatException('Missing required property')), + adoptionism: (json.containsKey("adoptionism") ? json["adoptionism"] : throw FormatException('Missing required property')), + anglic: (json.containsKey("Anglic") ? json["Anglic"] : throw FormatException('Missing required property')), + antrotomy: (json.containsKey("antrotomy") ? json["antrotomy"] : throw FormatException('Missing required property')), + coerciveness: (json.containsKey("coerciveness") ? json["coerciveness"] : throw FormatException('Missing required property')), + decorist: (json.containsKey("decorist") ? json["decorist"] : throw FormatException('Missing required property')), + duckhood: (json.containsKey("duckhood") ? json["duckhood"] : throw FormatException('Missing required property')), + heteromeri: (json.containsKey("Heteromeri") ? json["Heteromeri"] : throw FormatException('Missing required property')), + hypochnose: (json.containsKey("hypochnose") ? json["hypochnose"] : throw FormatException('Missing required property')), + lochage: (json.containsKey("lochage") ? json["lochage"] : throw FormatException('Missing required property')), + melee: (json.containsKey("melee") ? json["melee"] : throw FormatException('Missing required property')), + nonconformitant: (json.containsKey("nonconformitant") ? json["nonconformitant"] : throw FormatException('Missing required property')), + poinsettia: (json.containsKey("Poinsettia") ? json["Poinsettia"] : throw FormatException('Missing required property')), + putatively: (json.containsKey("putatively") ? json["putatively"] : throw FormatException('Missing required property')), + semivolatile: (json.containsKey("semivolatile") ? json["semivolatile"] : throw FormatException('Missing required property')), + soleas: (json.containsKey("soleas") ? json["soleas"] : throw FormatException('Missing required property')), + unfastenable: (json.containsKey("unfastenable") ? json["unfastenable"] : throw FormatException('Missing required property')), + unmillinered: (json.containsKey("unmillinered") ? json["unmillinered"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "abranchian": abranchian, + "aculeiform": aculeiform, + "adiaphoristic": adiaphoristic, + "adoptionism": adoptionism, + "Anglic": anglic, + "antrotomy": antrotomy, + "coerciveness": coerciveness, + "decorist": decorist, + "duckhood": duckhood, + "Heteromeri": heteromeri, + "hypochnose": hypochnose, + "lochage": lochage, + "melee": melee, + "nonconformitant": nonconformitant, + "Poinsettia": poinsettia, + "putatively": putatively, + "semivolatile": semivolatile, + "soleas": soleas, + "unfastenable": unfastenable, + "unmillinered": unmillinered, + }; +} + +class FenkClass { + final dynamic apoise; + final dynamic astronomize; + final dynamic cockhorse; + final dynamic copular; + final dynamic dagomba; + final dynamic draffy; + final dynamic foreigner; + final dynamic guyandot; + final dynamic neurogliosis; + final dynamic osmious; + final dynamic palpitate; + final dynamic rebukeable; + final dynamic reinwardtia; + final dynamic reservatory; + final dynamic scalt; + final dynamic scripturalize; + final dynamic tintometer; + final dynamic tritoness; + final dynamic undergrade; + final dynamic undermountain; + + FenkClass({ + required this.apoise, + required this.astronomize, + required this.cockhorse, + required this.copular, + required this.dagomba, + required this.draffy, + required this.foreigner, + required this.guyandot, + required this.neurogliosis, + required this.osmious, + required this.palpitate, + required this.rebukeable, + required this.reinwardtia, + required this.reservatory, + required this.scalt, + required this.scripturalize, + required this.tintometer, + required this.tritoness, + required this.undergrade, + required this.undermountain, + }); + + factory FenkClass.fromMap(Map json) => FenkClass( + apoise: (json.containsKey("apoise") ? json["apoise"] : throw FormatException('Missing required property')), + astronomize: (json.containsKey("astronomize") ? json["astronomize"] : throw FormatException('Missing required property')), + cockhorse: (json.containsKey("cockhorse") ? json["cockhorse"] : throw FormatException('Missing required property')), + copular: (json.containsKey("copular") ? json["copular"] : throw FormatException('Missing required property')), + dagomba: (json.containsKey("Dagomba") ? json["Dagomba"] : throw FormatException('Missing required property')), + draffy: (json.containsKey("draffy") ? json["draffy"] : throw FormatException('Missing required property')), + foreigner: (json.containsKey("foreigner") ? json["foreigner"] : throw FormatException('Missing required property')), + guyandot: (json.containsKey("Guyandot") ? json["Guyandot"] : throw FormatException('Missing required property')), + neurogliosis: (json.containsKey("neurogliosis") ? json["neurogliosis"] : throw FormatException('Missing required property')), + osmious: (json.containsKey("osmious") ? json["osmious"] : throw FormatException('Missing required property')), + palpitate: (json.containsKey("palpitate") ? json["palpitate"] : throw FormatException('Missing required property')), + rebukeable: (json.containsKey("rebukeable") ? json["rebukeable"] : throw FormatException('Missing required property')), + reinwardtia: (json.containsKey("Reinwardtia") ? json["Reinwardtia"] : throw FormatException('Missing required property')), + reservatory: (json.containsKey("reservatory") ? json["reservatory"] : throw FormatException('Missing required property')), + scalt: (json.containsKey("scalt") ? json["scalt"] : throw FormatException('Missing required property')), + scripturalize: (json.containsKey("scripturalize") ? json["scripturalize"] : throw FormatException('Missing required property')), + tintometer: (json.containsKey("tintometer") ? json["tintometer"] : throw FormatException('Missing required property')), + tritoness: (json.containsKey("Tritoness") ? json["Tritoness"] : throw FormatException('Missing required property')), + undergrade: (json.containsKey("undergrade") ? json["undergrade"] : throw FormatException('Missing required property')), + undermountain: (json.containsKey("undermountain") ? json["undermountain"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "apoise": apoise, + "astronomize": astronomize, + "cockhorse": cockhorse, + "copular": copular, + "Dagomba": dagomba, + "draffy": draffy, + "foreigner": foreigner, + "Guyandot": guyandot, + "neurogliosis": neurogliosis, + "osmious": osmious, + "palpitate": palpitate, + "rebukeable": rebukeable, + "Reinwardtia": reinwardtia, + "reservatory": reservatory, + "scalt": scalt, + "scripturalize": scripturalize, + "tintometer": tintometer, + "Tritoness": tritoness, + "undergrade": undergrade, + "undermountain": undermountain, + }; +} + +class FlagmakingClass { + final dynamic albarco; + final dynamic bunodonta; + final dynamic hornify; + final dynamic hydrocorisae; + final dynamic hypoglossus; + final dynamic inexpiably; + final dynamic ingratitude; + final dynamic ladyfly; + final dynamic medicament; + final dynamic monogrammatic; + final dynamic nobbut; + final dynamic notacanthidae; + final dynamic polyplacophore; + final dynamic proexercise; + final dynamic protoplast; + final dynamic puzzling; + final dynamic splanchnoskeleton; + final dynamic unloveliness; + final dynamic unquarantined; + final dynamic unrenounceable; + + FlagmakingClass({ + required this.albarco, + required this.bunodonta, + required this.hornify, + required this.hydrocorisae, + required this.hypoglossus, + required this.inexpiably, + required this.ingratitude, + required this.ladyfly, + required this.medicament, + required this.monogrammatic, + required this.nobbut, + required this.notacanthidae, + required this.polyplacophore, + required this.proexercise, + required this.protoplast, + required this.puzzling, + required this.splanchnoskeleton, + required this.unloveliness, + required this.unquarantined, + required this.unrenounceable, + }); + + factory FlagmakingClass.fromMap(Map json) => FlagmakingClass( + albarco: (json.containsKey("albarco") ? json["albarco"] : throw FormatException('Missing required property')), + bunodonta: (json.containsKey("Bunodonta") ? json["Bunodonta"] : throw FormatException('Missing required property')), + hornify: (json.containsKey("hornify") ? json["hornify"] : throw FormatException('Missing required property')), + hydrocorisae: (json.containsKey("Hydrocorisae") ? json["Hydrocorisae"] : throw FormatException('Missing required property')), + hypoglossus: (json.containsKey("hypoglossus") ? json["hypoglossus"] : throw FormatException('Missing required property')), + inexpiably: (json.containsKey("inexpiably") ? json["inexpiably"] : throw FormatException('Missing required property')), + ingratitude: (json.containsKey("ingratitude") ? json["ingratitude"] : throw FormatException('Missing required property')), + ladyfly: (json.containsKey("ladyfly") ? json["ladyfly"] : throw FormatException('Missing required property')), + medicament: (json.containsKey("medicament") ? json["medicament"] : throw FormatException('Missing required property')), + monogrammatic: (json.containsKey("monogrammatic") ? json["monogrammatic"] : throw FormatException('Missing required property')), + nobbut: (json.containsKey("nobbut") ? json["nobbut"] : throw FormatException('Missing required property')), + notacanthidae: (json.containsKey("Notacanthidae") ? json["Notacanthidae"] : throw FormatException('Missing required property')), + polyplacophore: (json.containsKey("polyplacophore") ? json["polyplacophore"] : throw FormatException('Missing required property')), + proexercise: (json.containsKey("proexercise") ? json["proexercise"] : throw FormatException('Missing required property')), + protoplast: (json.containsKey("protoplast") ? json["protoplast"] : throw FormatException('Missing required property')), + puzzling: (json.containsKey("puzzling") ? json["puzzling"] : throw FormatException('Missing required property')), + splanchnoskeleton: (json.containsKey("splanchnoskeleton") ? json["splanchnoskeleton"] : throw FormatException('Missing required property')), + unloveliness: (json.containsKey("unloveliness") ? json["unloveliness"] : throw FormatException('Missing required property')), + unquarantined: (json.containsKey("unquarantined") ? json["unquarantined"] : throw FormatException('Missing required property')), + unrenounceable: (json.containsKey("unrenounceable") ? json["unrenounceable"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "albarco": albarco, + "Bunodonta": bunodonta, + "hornify": hornify, + "Hydrocorisae": hydrocorisae, + "hypoglossus": hypoglossus, + "inexpiably": inexpiably, + "ingratitude": ingratitude, + "ladyfly": ladyfly, + "medicament": medicament, + "monogrammatic": monogrammatic, + "nobbut": nobbut, + "Notacanthidae": notacanthidae, + "polyplacophore": polyplacophore, + "proexercise": proexercise, + "protoplast": protoplast, + "puzzling": puzzling, + "splanchnoskeleton": splanchnoskeleton, + "unloveliness": unloveliness, + "unquarantined": unquarantined, + "unrenounceable": unrenounceable, + }; +} + +class HemocoeleClass { + final dynamic acrogamy; + final dynamic amelification; + final dynamic autobiographic; + final dynamic berat; + final double? catharticalness; + final int? chirotherium; + final String? disdiapason; + final dynamic disproportionably; + final dynamic erythrite; + final dynamic graphic; + final dynamic hepatological; + final bool? homocerc; + final dynamic incommensurably; + final dynamic misaffirm; + final dynamic nonbookish; + final dynamic pocketbook; + final dynamic sclerometric; + final dynamic stambouline; + final dynamic stickpin; + final dynamic tubulure; + final dynamic undelated; + final dynamic unsalt; + final dynamic untutelar; + final dynamic vagrant; + final dynamic walt; + + HemocoeleClass({ + this.acrogamy, + this.amelification, + this.autobiographic, + this.berat, + this.catharticalness, + this.chirotherium, + this.disdiapason, + this.disproportionably, + this.erythrite, + this.graphic, + this.hepatological, + this.homocerc, + this.incommensurably, + this.misaffirm, + this.nonbookish, + this.pocketbook, + this.sclerometric, + this.stambouline, + this.stickpin, + this.tubulure, + this.undelated, + this.unsalt, + this.untutelar, + this.vagrant, + this.walt, + }); + + factory HemocoeleClass.fromMap(Map json) => HemocoeleClass( + acrogamy: json["acrogamy"], + amelification: json["amelification"], + autobiographic: json["autobiographic"], + berat: json["berat"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + disproportionably: json["disproportionably"], + erythrite: json["erythrite"], + graphic: json["graphic"], + hepatological: json["hepatological"], + homocerc: json["homocerc"], + incommensurably: json["incommensurably"], + misaffirm: json["misaffirm"], + nonbookish: json["nonbookish"], + pocketbook: json["pocketbook"], + sclerometric: json["sclerometric"], + stambouline: json["stambouline"], + stickpin: json["stickpin"], + tubulure: json["tubulure"], + undelated: json["undelated"], + unsalt: json["unsalt"], + untutelar: json["untutelar"], + vagrant: json["vagrant"], + walt: json["Walt"], + ); + + Map toMap() => { + "acrogamy": acrogamy, + "amelification": amelification, + "autobiographic": autobiographic, + "berat": berat, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "disproportionably": disproportionably, + "erythrite": erythrite, + "graphic": graphic, + "hepatological": hepatological, + "homocerc": homocerc, + "incommensurably": incommensurably, + "misaffirm": misaffirm, + "nonbookish": nonbookish, + "pocketbook": pocketbook, + "sclerometric": sclerometric, + "stambouline": stambouline, + "stickpin": stickpin, + "tubulure": tubulure, + "undelated": undelated, + "unsalt": unsalt, + "untutelar": untutelar, + "vagrant": vagrant, + "Walt": walt, + }; +} + +class Interacinar { + final double assapan; + final bool benefactorship; + final String triseriatim; + final int tubbing; + final dynamic untrimmed; + + Interacinar({ + required this.assapan, + required this.benefactorship, + required this.triseriatim, + required this.tubbing, + required this.untrimmed, + }); + + factory Interacinar.fromMap(Map json) => Interacinar( + assapan: json["assapan"]?.toDouble(), + benefactorship: json["benefactorship"], + triseriatim: json["triseriatim"], + tubbing: json["tubbing"], + untrimmed: (json.containsKey("untrimmed") ? json["untrimmed"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "assapan": assapan, + "benefactorship": benefactorship, + "triseriatim": triseriatim, + "tubbing": tubbing, + "untrimmed": untrimmed, + }; +} diff --git a/head/dart/test/inputs/json/priority/combinations2.json/from-map-true--d222f65b3fee/TopLevel.dart b/head/dart/test/inputs/json/priority/combinations2.json/from-map-true--d222f65b3fee/TopLevel.dart new file mode 100644 index 0000000..215f333 --- /dev/null +++ b/head/dart/test/inputs/json/priority/combinations2.json/from-map-true--d222f65b3fee/TopLevel.dart @@ -0,0 +1,1121 @@ +// To parse this JSON data, do +// +// final topLevel = topLevelFromJson(jsonString); + +import 'dart:convert'; + +TopLevel topLevelFromJson(String str) => TopLevel.fromMap(json.decode(str)); + +String topLevelToJson(TopLevel data) => json.encode(data.toMap()); + +class TopLevel { + final List abranchiata; + final List academe; + final List acquirable; + final List aerometry; + final List alexin; + final List alleviate; + final List amaas; + final List ambassage; + final List amphithyron; + final List andriana; + final List ankee; + final List?> annihilator; + final dynamic annulose; + final List ansarie; + final List aphasia; + final List asprawl; + final List attractive; + final Map barksome; + final List bedesman; + final List belard; + final List bocking; + final List brawlingly; + final List brookie; + final List bumboatman; + final List bystreet; + final List calaverite; + final List catallactic; + final List cemental; + final List chytridiaceae; + final List discordia; + final List endomyces; + final List epinephelidae; + final List eupatorium; + final List gryphosaurus; + final List koryak; + final List lavinia; + final List oskar; + final List rebecca; + final List rhomboganoidei; + final bool rigsmal; + final List ruellia; + final List school; + final List shakespearolater; + final List svan; + final Map wayao; + + TopLevel({ + required this.abranchiata, + required this.academe, + required this.acquirable, + required this.aerometry, + required this.alexin, + required this.alleviate, + required this.amaas, + required this.ambassage, + required this.amphithyron, + required this.andriana, + required this.ankee, + required this.annihilator, + required this.annulose, + required this.ansarie, + required this.aphasia, + required this.asprawl, + required this.attractive, + required this.barksome, + required this.bedesman, + required this.belard, + required this.bocking, + required this.brawlingly, + required this.brookie, + required this.bumboatman, + required this.bystreet, + required this.calaverite, + required this.catallactic, + required this.cemental, + required this.chytridiaceae, + required this.discordia, + required this.endomyces, + required this.epinephelidae, + required this.eupatorium, + required this.gryphosaurus, + required this.koryak, + required this.lavinia, + required this.oskar, + required this.rebecca, + required this.rhomboganoidei, + required this.rigsmal, + required this.ruellia, + required this.school, + required this.shakespearolater, + required this.svan, + required this.wayao, + }); + + factory TopLevel.fromMap(Map json) => TopLevel( + abranchiata: List.from(json["Abranchiata"].map((x) => x)), + academe: List.from(json["academe"].map((x) => x)), + acquirable: List.from(json["acquirable"].map((x) => x)), + aerometry: List.from(json["aerometry"].map((x) => x)), + alexin: List.from(json["alexin"].map((x) => x)), + alleviate: List.from(json["alleviate"].map((x) => x)), + amaas: List.from(json["amaas"].map((x) => x)), + ambassage: List.from(json["ambassage"].map((x) => x)), + amphithyron: List.from(json["amphithyron"].map((x) => x == null ? null : Amphithyron.fromMap(x))), + andriana: List.from(json["Andriana"].map((x) => x)), + ankee: List.from(json["ankee"].map((x) => x)), + annihilator: List?>.from(json["annihilator"].map((x) => x == null ? null : Map.from(x!).map((k, v) => MapEntry(k, v)))), + annulose: (json.containsKey("annulose") ? json["annulose"] : throw FormatException('Missing required property')), + ansarie: List.from(json["Ansarie"].map((x) => x)), + aphasia: List.from(json["aphasia"].map((x) => x)), + asprawl: List.from(json["asprawl"].map((x) => x)), + attractive: List.from(json["attractive"].map((x) => x)), + barksome: Map.from(json["barksome"]).map((k, v) => MapEntry(k, v)), + bedesman: List.from(json["bedesman"].map((x) => x)), + belard: List.from(json["belard"].map((x) => x)), + bocking: List.from(json["bocking"].map((x) => x)), + brawlingly: List.from(json["brawlingly"].map((x) => x)), + brookie: List.from(json["brookie"].map((x) => x)), + bumboatman: List.from(json["bumboatman"].map((x) => x)), + bystreet: List.from(json["bystreet"].map((x) => x)), + calaverite: List.from(json["calaverite"].map((x) => x)), + catallactic: List.from(json["catallactic"].map((x) => x)), + cemental: List.from(json["cemental"].map((x) => x)), + chytridiaceae: List.from(json["Chytridiaceae"].map((x) => x)), + discordia: List.from(json["Discordia"].map((x) => x)), + endomyces: List.from(json["Endomyces"].map((x) => x)), + epinephelidae: List.from(json["Epinephelidae"].map((x) => x)), + eupatorium: List.from(json["Eupatorium"].map((x) => x)), + gryphosaurus: List.from(json["Gryphosaurus"].map((x) => x)), + koryak: List.from(json["Koryak"].map((x) => x)), + lavinia: List.from(json["Lavinia"].map((x) => x)), + oskar: List.from(json["Oskar"].map((x) => x)), + rebecca: List.from(json["Rebecca"].map((x) => x)), + rhomboganoidei: List.from(json["Rhomboganoidei"].map((x) => x)), + rigsmal: json["Rigsmal"], + ruellia: List.from(json["Ruellia"].map((x) => x)), + school: List.from(json["School"].map((x) => x)), + shakespearolater: List.from(json["Shakespearolater"].map((x) => x)), + svan: List.from(json["Svan"].map((x) => x?.toDouble())), + wayao: Map.from(json["Wayao"]).map((k, v) => MapEntry(k, v?.toDouble())), + ); + + Map toMap() => { + "Abranchiata": List.from(abranchiata.map((x) => x)), + "academe": List.from(academe.map((x) => x)), + "acquirable": List.from(acquirable.map((x) => x)), + "aerometry": List.from(aerometry.map((x) => x)), + "alexin": List.from(alexin.map((x) => x)), + "alleviate": List.from(alleviate.map((x) => x)), + "amaas": List.from(amaas.map((x) => x)), + "ambassage": List.from(ambassage.map((x) => x)), + "amphithyron": List.from(amphithyron.map((x) => x?.toMap())), + "Andriana": List.from(andriana.map((x) => x)), + "ankee": List.from(ankee.map((x) => x)), + "annihilator": List.from(annihilator.map((x) => x == null ? null : Map.from(x!).map((k, v) => MapEntry(k, v)))), + "annulose": annulose, + "Ansarie": List.from(ansarie.map((x) => x)), + "aphasia": List.from(aphasia.map((x) => x)), + "asprawl": List.from(asprawl.map((x) => x)), + "attractive": List.from(attractive.map((x) => x)), + "barksome": Map.from(barksome).map((k, v) => MapEntry(k, v)), + "bedesman": List.from(bedesman.map((x) => x)), + "belard": List.from(belard.map((x) => x)), + "bocking": List.from(bocking.map((x) => x)), + "brawlingly": List.from(brawlingly.map((x) => x)), + "brookie": List.from(brookie.map((x) => x)), + "bumboatman": List.from(bumboatman.map((x) => x)), + "bystreet": List.from(bystreet.map((x) => x)), + "calaverite": List.from(calaverite.map((x) => x)), + "catallactic": List.from(catallactic.map((x) => x)), + "cemental": List.from(cemental.map((x) => x)), + "Chytridiaceae": List.from(chytridiaceae.map((x) => x)), + "Discordia": List.from(discordia.map((x) => x)), + "Endomyces": List.from(endomyces.map((x) => x)), + "Epinephelidae": List.from(epinephelidae.map((x) => x)), + "Eupatorium": List.from(eupatorium.map((x) => x)), + "Gryphosaurus": List.from(gryphosaurus.map((x) => x)), + "Koryak": List.from(koryak.map((x) => x)), + "Lavinia": List.from(lavinia.map((x) => x)), + "Oskar": List.from(oskar.map((x) => x)), + "Rebecca": List.from(rebecca.map((x) => x)), + "Rhomboganoidei": List.from(rhomboganoidei.map((x) => x)), + "Rigsmal": rigsmal, + "Ruellia": List.from(ruellia.map((x) => x)), + "School": List.from(school.map((x) => x)), + "Shakespearolater": List.from(shakespearolater.map((x) => x)), + "Svan": List.from(svan.map((x) => x)), + "Wayao": Map.from(wayao).map((k, v) => MapEntry(k, v)), + }; +} + +class AlleviateClass { + final dynamic apriori; + final dynamic beggarer; + final dynamic brokenheartedly; + final dynamic debilitation; + final dynamic frike; + final dynamic gastrolith; + final dynamic hulsean; + final dynamic orthocentric; + final dynamic petaly; + final dynamic probudgeting; + final dynamic reacquire; + final dynamic scow; + final dynamic shutoff; + final dynamic subcontiguous; + final dynamic suffumigate; + final dynamic transformable; + final dynamic uncoroneted; + final dynamic unparking; + final dynamic unvarnishedness; + final dynamic wherewithal; + + AlleviateClass({ + required this.apriori, + required this.beggarer, + required this.brokenheartedly, + required this.debilitation, + required this.frike, + required this.gastrolith, + required this.hulsean, + required this.orthocentric, + required this.petaly, + required this.probudgeting, + required this.reacquire, + required this.scow, + required this.shutoff, + required this.subcontiguous, + required this.suffumigate, + required this.transformable, + required this.uncoroneted, + required this.unparking, + required this.unvarnishedness, + required this.wherewithal, + }); + + factory AlleviateClass.fromMap(Map json) => AlleviateClass( + apriori: (json.containsKey("apriori") ? json["apriori"] : throw FormatException('Missing required property')), + beggarer: (json.containsKey("beggarer") ? json["beggarer"] : throw FormatException('Missing required property')), + brokenheartedly: (json.containsKey("brokenheartedly") ? json["brokenheartedly"] : throw FormatException('Missing required property')), + debilitation: (json.containsKey("debilitation") ? json["debilitation"] : throw FormatException('Missing required property')), + frike: (json.containsKey("frike") ? json["frike"] : throw FormatException('Missing required property')), + gastrolith: (json.containsKey("gastrolith") ? json["gastrolith"] : throw FormatException('Missing required property')), + hulsean: (json.containsKey("Hulsean") ? json["Hulsean"] : throw FormatException('Missing required property')), + orthocentric: (json.containsKey("orthocentric") ? json["orthocentric"] : throw FormatException('Missing required property')), + petaly: (json.containsKey("petaly") ? json["petaly"] : throw FormatException('Missing required property')), + probudgeting: (json.containsKey("probudgeting") ? json["probudgeting"] : throw FormatException('Missing required property')), + reacquire: (json.containsKey("reacquire") ? json["reacquire"] : throw FormatException('Missing required property')), + scow: (json.containsKey("scow") ? json["scow"] : throw FormatException('Missing required property')), + shutoff: (json.containsKey("shutoff") ? json["shutoff"] : throw FormatException('Missing required property')), + subcontiguous: (json.containsKey("subcontiguous") ? json["subcontiguous"] : throw FormatException('Missing required property')), + suffumigate: (json.containsKey("suffumigate") ? json["suffumigate"] : throw FormatException('Missing required property')), + transformable: (json.containsKey("transformable") ? json["transformable"] : throw FormatException('Missing required property')), + uncoroneted: (json.containsKey("uncoroneted") ? json["uncoroneted"] : throw FormatException('Missing required property')), + unparking: (json.containsKey("unparking") ? json["unparking"] : throw FormatException('Missing required property')), + unvarnishedness: (json.containsKey("unvarnishedness") ? json["unvarnishedness"] : throw FormatException('Missing required property')), + wherewithal: (json.containsKey("wherewithal") ? json["wherewithal"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "apriori": apriori, + "beggarer": beggarer, + "brokenheartedly": brokenheartedly, + "debilitation": debilitation, + "frike": frike, + "gastrolith": gastrolith, + "Hulsean": hulsean, + "orthocentric": orthocentric, + "petaly": petaly, + "probudgeting": probudgeting, + "reacquire": reacquire, + "scow": scow, + "shutoff": shutoff, + "subcontiguous": subcontiguous, + "suffumigate": suffumigate, + "transformable": transformable, + "uncoroneted": uncoroneted, + "unparking": unparking, + "unvarnishedness": unvarnishedness, + "wherewithal": wherewithal, + }; +} + +class Rebecca { + final double catharticalness; + final int chirotherium; + final String disdiapason; + final bool homocerc; + final dynamic nonbookish; + + Rebecca({ + required this.catharticalness, + required this.chirotherium, + required this.disdiapason, + required this.homocerc, + required this.nonbookish, + }); + + factory Rebecca.fromMap(Map json) => Rebecca( + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + homocerc: json["homocerc"], + nonbookish: (json.containsKey("nonbookish") ? json["nonbookish"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "homocerc": homocerc, + "nonbookish": nonbookish, + }; +} + +class Amphithyron { + final int? akroasis; + final int? antiphonical; + final int? basebred; + final double? catharticalness; + final int? chirotherium; + final int? conductometric; + final String? disdiapason; + final int? ensilation; + final int? eyebolt; + final int? fistulated; + final int? heteropod; + final bool? homocerc; + final int? juniperus; + final int? labyrinthically; + final int? martyrization; + final int? mispolicy; + final int? multipara; + final int? nazirite; + final dynamic nonbookish; + final int? possessorial; + final int? shamed; + final int? shelfworn; + final int? stagnum; + final int? those; + final int? undecimal; + + Amphithyron({ + this.akroasis, + this.antiphonical, + this.basebred, + this.catharticalness, + this.chirotherium, + this.conductometric, + this.disdiapason, + this.ensilation, + this.eyebolt, + this.fistulated, + this.heteropod, + this.homocerc, + this.juniperus, + this.labyrinthically, + this.martyrization, + this.mispolicy, + this.multipara, + this.nazirite, + this.nonbookish, + this.possessorial, + this.shamed, + this.shelfworn, + this.stagnum, + this.those, + this.undecimal, + }); + + factory Amphithyron.fromMap(Map json) => Amphithyron( + akroasis: json["akroasis"], + antiphonical: json["antiphonical"], + basebred: json["basebred"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + conductometric: json["conductometric"], + disdiapason: json["disdiapason"], + ensilation: json["ensilation"], + eyebolt: json["eyebolt"], + fistulated: json["fistulated"], + heteropod: json["heteropod"], + homocerc: json["homocerc"], + juniperus: json["Juniperus"], + labyrinthically: json["labyrinthically"], + martyrization: json["martyrization"], + mispolicy: json["mispolicy"], + multipara: json["multipara"], + nazirite: json["Nazirite"], + nonbookish: json["nonbookish"], + possessorial: json["possessorial"], + shamed: json["shamed"], + shelfworn: json["shelfworn"], + stagnum: json["stagnum"], + those: json["Those"], + undecimal: json["undecimal"], + ); + + Map toMap() => { + "akroasis": akroasis, + "antiphonical": antiphonical, + "basebred": basebred, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "conductometric": conductometric, + "disdiapason": disdiapason, + "ensilation": ensilation, + "eyebolt": eyebolt, + "fistulated": fistulated, + "heteropod": heteropod, + "homocerc": homocerc, + "Juniperus": juniperus, + "labyrinthically": labyrinthically, + "martyrization": martyrization, + "mispolicy": mispolicy, + "multipara": multipara, + "Nazirite": nazirite, + "nonbookish": nonbookish, + "possessorial": possessorial, + "shamed": shamed, + "shelfworn": shelfworn, + "stagnum": stagnum, + "Those": those, + "undecimal": undecimal, + }; +} + +class AnkeeClass { + final dynamic anomoean; + final dynamic barleyhood; + final dynamic befriender; + final dynamic brutishness; + final dynamic cephalalgy; + final dynamic cirurgian; + final dynamic conventionally; + final dynamic jackshay; + final dynamic milammeter; + final dynamic naja; + final dynamic ombrological; + final dynamic phonasthenia; + final dynamic retrievableness; + final dynamic snakily; + final dynamic swot; + final dynamic tartlet; + final dynamic thiofuran; + final dynamic tracheophone; + final dynamic tuglike; + final dynamic unscratchingly; + + AnkeeClass({ + required this.anomoean, + required this.barleyhood, + required this.befriender, + required this.brutishness, + required this.cephalalgy, + required this.cirurgian, + required this.conventionally, + required this.jackshay, + required this.milammeter, + required this.naja, + required this.ombrological, + required this.phonasthenia, + required this.retrievableness, + required this.snakily, + required this.swot, + required this.tartlet, + required this.thiofuran, + required this.tracheophone, + required this.tuglike, + required this.unscratchingly, + }); + + factory AnkeeClass.fromMap(Map json) => AnkeeClass( + anomoean: (json.containsKey("Anomoean") ? json["Anomoean"] : throw FormatException('Missing required property')), + barleyhood: (json.containsKey("barleyhood") ? json["barleyhood"] : throw FormatException('Missing required property')), + befriender: (json.containsKey("befriender") ? json["befriender"] : throw FormatException('Missing required property')), + brutishness: (json.containsKey("brutishness") ? json["brutishness"] : throw FormatException('Missing required property')), + cephalalgy: (json.containsKey("cephalalgy") ? json["cephalalgy"] : throw FormatException('Missing required property')), + cirurgian: (json.containsKey("cirurgian") ? json["cirurgian"] : throw FormatException('Missing required property')), + conventionally: (json.containsKey("conventionally") ? json["conventionally"] : throw FormatException('Missing required property')), + jackshay: (json.containsKey("jackshay") ? json["jackshay"] : throw FormatException('Missing required property')), + milammeter: (json.containsKey("milammeter") ? json["milammeter"] : throw FormatException('Missing required property')), + naja: (json.containsKey("Naja") ? json["Naja"] : throw FormatException('Missing required property')), + ombrological: (json.containsKey("ombrological") ? json["ombrological"] : throw FormatException('Missing required property')), + phonasthenia: (json.containsKey("phonasthenia") ? json["phonasthenia"] : throw FormatException('Missing required property')), + retrievableness: (json.containsKey("retrievableness") ? json["retrievableness"] : throw FormatException('Missing required property')), + snakily: (json.containsKey("snakily") ? json["snakily"] : throw FormatException('Missing required property')), + swot: (json.containsKey("swot") ? json["swot"] : throw FormatException('Missing required property')), + tartlet: (json.containsKey("tartlet") ? json["tartlet"] : throw FormatException('Missing required property')), + thiofuran: (json.containsKey("thiofuran") ? json["thiofuran"] : throw FormatException('Missing required property')), + tracheophone: (json.containsKey("tracheophone") ? json["tracheophone"] : throw FormatException('Missing required property')), + tuglike: (json.containsKey("tuglike") ? json["tuglike"] : throw FormatException('Missing required property')), + unscratchingly: (json.containsKey("unscratchingly") ? json["unscratchingly"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "Anomoean": anomoean, + "barleyhood": barleyhood, + "befriender": befriender, + "brutishness": brutishness, + "cephalalgy": cephalalgy, + "cirurgian": cirurgian, + "conventionally": conventionally, + "jackshay": jackshay, + "milammeter": milammeter, + "Naja": naja, + "ombrological": ombrological, + "phonasthenia": phonasthenia, + "retrievableness": retrievableness, + "snakily": snakily, + "swot": swot, + "tartlet": tartlet, + "thiofuran": thiofuran, + "tracheophone": tracheophone, + "tuglike": tuglike, + "unscratchingly": unscratchingly, + }; +} + +class AnsarieClass { + final dynamic accension; + final dynamic alida; + final dynamic asteria; + final dynamic beriberic; + final dynamic edgebone; + final dynamic gastrodialysis; + final dynamic geographic; + final dynamic ictonyx; + final dynamic metrocele; + final dynamic misgraft; + final dynamic monteith; + final dynamic notcher; + final dynamic prorestriction; + final dynamic ramist; + final dynamic throatlet; + final dynamic unfair; + final dynamic unsynonymous; + final dynamic water; + final dynamic zestfully; + final dynamic zincic; + + AnsarieClass({ + required this.accension, + required this.alida, + required this.asteria, + required this.beriberic, + required this.edgebone, + required this.gastrodialysis, + required this.geographic, + required this.ictonyx, + required this.metrocele, + required this.misgraft, + required this.monteith, + required this.notcher, + required this.prorestriction, + required this.ramist, + required this.throatlet, + required this.unfair, + required this.unsynonymous, + required this.water, + required this.zestfully, + required this.zincic, + }); + + factory AnsarieClass.fromMap(Map json) => AnsarieClass( + accension: (json.containsKey("accension") ? json["accension"] : throw FormatException('Missing required property')), + alida: (json.containsKey("Alida") ? json["Alida"] : throw FormatException('Missing required property')), + asteria: (json.containsKey("asteria") ? json["asteria"] : throw FormatException('Missing required property')), + beriberic: (json.containsKey("beriberic") ? json["beriberic"] : throw FormatException('Missing required property')), + edgebone: (json.containsKey("edgebone") ? json["edgebone"] : throw FormatException('Missing required property')), + gastrodialysis: (json.containsKey("gastrodialysis") ? json["gastrodialysis"] : throw FormatException('Missing required property')), + geographic: (json.containsKey("geographic") ? json["geographic"] : throw FormatException('Missing required property')), + ictonyx: (json.containsKey("Ictonyx") ? json["Ictonyx"] : throw FormatException('Missing required property')), + metrocele: (json.containsKey("metrocele") ? json["metrocele"] : throw FormatException('Missing required property')), + misgraft: (json.containsKey("misgraft") ? json["misgraft"] : throw FormatException('Missing required property')), + monteith: (json.containsKey("monteith") ? json["monteith"] : throw FormatException('Missing required property')), + notcher: (json.containsKey("notcher") ? json["notcher"] : throw FormatException('Missing required property')), + prorestriction: (json.containsKey("prorestriction") ? json["prorestriction"] : throw FormatException('Missing required property')), + ramist: (json.containsKey("Ramist") ? json["Ramist"] : throw FormatException('Missing required property')), + throatlet: (json.containsKey("throatlet") ? json["throatlet"] : throw FormatException('Missing required property')), + unfair: (json.containsKey("unfair") ? json["unfair"] : throw FormatException('Missing required property')), + unsynonymous: (json.containsKey("unsynonymous") ? json["unsynonymous"] : throw FormatException('Missing required property')), + water: (json.containsKey("water") ? json["water"] : throw FormatException('Missing required property')), + zestfully: (json.containsKey("zestfully") ? json["zestfully"] : throw FormatException('Missing required property')), + zincic: (json.containsKey("zincic") ? json["zincic"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "accension": accension, + "Alida": alida, + "asteria": asteria, + "beriberic": beriberic, + "edgebone": edgebone, + "gastrodialysis": gastrodialysis, + "geographic": geographic, + "Ictonyx": ictonyx, + "metrocele": metrocele, + "misgraft": misgraft, + "monteith": monteith, + "notcher": notcher, + "prorestriction": prorestriction, + "Ramist": ramist, + "throatlet": throatlet, + "unfair": unfair, + "unsynonymous": unsynonymous, + "water": water, + "zestfully": zestfully, + "zincic": zincic, + }; +} + +class ChytridiaceaeClass { + final dynamic batidaceae; + final dynamic brechites; + final dynamic codespairer; + final dynamic emery; + final dynamic enervative; + final dynamic excriminate; + final dynamic goshenite; + final dynamic grime; + final dynamic gritten; + final dynamic hectorly; + final dynamic intermediation; + final dynamic meeterly; + final dynamic narraganset; + final dynamic onymatic; + final dynamic paddlecock; + final dynamic thana; + final dynamic thornily; + final dynamic uckia; + final dynamic unmettle; + final dynamic vorticellid; + + ChytridiaceaeClass({ + required this.batidaceae, + required this.brechites, + required this.codespairer, + required this.emery, + required this.enervative, + required this.excriminate, + required this.goshenite, + required this.grime, + required this.gritten, + required this.hectorly, + required this.intermediation, + required this.meeterly, + required this.narraganset, + required this.onymatic, + required this.paddlecock, + required this.thana, + required this.thornily, + required this.uckia, + required this.unmettle, + required this.vorticellid, + }); + + factory ChytridiaceaeClass.fromMap(Map json) => ChytridiaceaeClass( + batidaceae: (json.containsKey("Batidaceae") ? json["Batidaceae"] : throw FormatException('Missing required property')), + brechites: (json.containsKey("Brechites") ? json["Brechites"] : throw FormatException('Missing required property')), + codespairer: (json.containsKey("codespairer") ? json["codespairer"] : throw FormatException('Missing required property')), + emery: (json.containsKey("Emery") ? json["Emery"] : throw FormatException('Missing required property')), + enervative: (json.containsKey("enervative") ? json["enervative"] : throw FormatException('Missing required property')), + excriminate: (json.containsKey("excriminate") ? json["excriminate"] : throw FormatException('Missing required property')), + goshenite: (json.containsKey("goshenite") ? json["goshenite"] : throw FormatException('Missing required property')), + grime: (json.containsKey("grime") ? json["grime"] : throw FormatException('Missing required property')), + gritten: (json.containsKey("gritten") ? json["gritten"] : throw FormatException('Missing required property')), + hectorly: (json.containsKey("hectorly") ? json["hectorly"] : throw FormatException('Missing required property')), + intermediation: (json.containsKey("intermediation") ? json["intermediation"] : throw FormatException('Missing required property')), + meeterly: (json.containsKey("meeterly") ? json["meeterly"] : throw FormatException('Missing required property')), + narraganset: (json.containsKey("Narraganset") ? json["Narraganset"] : throw FormatException('Missing required property')), + onymatic: (json.containsKey("onymatic") ? json["onymatic"] : throw FormatException('Missing required property')), + paddlecock: (json.containsKey("paddlecock") ? json["paddlecock"] : throw FormatException('Missing required property')), + thana: (json.containsKey("thana") ? json["thana"] : throw FormatException('Missing required property')), + thornily: (json.containsKey("thornily") ? json["thornily"] : throw FormatException('Missing required property')), + uckia: (json.containsKey("uckia") ? json["uckia"] : throw FormatException('Missing required property')), + unmettle: (json.containsKey("unmettle") ? json["unmettle"] : throw FormatException('Missing required property')), + vorticellid: (json.containsKey("vorticellid") ? json["vorticellid"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "Batidaceae": batidaceae, + "Brechites": brechites, + "codespairer": codespairer, + "Emery": emery, + "enervative": enervative, + "excriminate": excriminate, + "goshenite": goshenite, + "grime": grime, + "gritten": gritten, + "hectorly": hectorly, + "intermediation": intermediation, + "meeterly": meeterly, + "Narraganset": narraganset, + "onymatic": onymatic, + "paddlecock": paddlecock, + "thana": thana, + "thornily": thornily, + "uckia": uckia, + "unmettle": unmettle, + "vorticellid": vorticellid, + }; +} + +class DiscordiaClass { + final int? altaic; + final int? amoristic; + final int? blennophthalmia; + final double? catharticalness; + final int? chirotherium; + final int? disciplinability; + final String? disdiapason; + final int? goofer; + final bool? homocerc; + final int? laryngograph; + final int? leucitis; + final int? lymphocyst; + final int? microcosmology; + final int? nauseation; + final dynamic nonbookish; + final int? patarin; + final int? preliberal; + final int? prettifier; + final int? rangework; + final int? redient; + final int? subfusiform; + final int? suicidical; + final int? swow; + final int? wastrel; + final int? wingle; + + DiscordiaClass({ + this.altaic, + this.amoristic, + this.blennophthalmia, + this.catharticalness, + this.chirotherium, + this.disciplinability, + this.disdiapason, + this.goofer, + this.homocerc, + this.laryngograph, + this.leucitis, + this.lymphocyst, + this.microcosmology, + this.nauseation, + this.nonbookish, + this.patarin, + this.preliberal, + this.prettifier, + this.rangework, + this.redient, + this.subfusiform, + this.suicidical, + this.swow, + this.wastrel, + this.wingle, + }); + + factory DiscordiaClass.fromMap(Map json) => DiscordiaClass( + altaic: json["Altaic"], + amoristic: json["amoristic"], + blennophthalmia: json["blennophthalmia"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + disciplinability: json["disciplinability"], + disdiapason: json["disdiapason"], + goofer: json["goofer"], + homocerc: json["homocerc"], + laryngograph: json["laryngograph"], + leucitis: json["leucitis"], + lymphocyst: json["lymphocyst"], + microcosmology: json["microcosmology"], + nauseation: json["nauseation"], + nonbookish: json["nonbookish"], + patarin: json["Patarin"], + preliberal: json["preliberal"], + prettifier: json["prettifier"], + rangework: json["rangework"], + redient: json["redient"], + subfusiform: json["subfusiform"], + suicidical: json["suicidical"], + swow: json["swow"], + wastrel: json["wastrel"], + wingle: json["wingle"], + ); + + Map toMap() => { + "Altaic": altaic, + "amoristic": amoristic, + "blennophthalmia": blennophthalmia, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "disciplinability": disciplinability, + "disdiapason": disdiapason, + "goofer": goofer, + "homocerc": homocerc, + "laryngograph": laryngograph, + "leucitis": leucitis, + "lymphocyst": lymphocyst, + "microcosmology": microcosmology, + "nauseation": nauseation, + "nonbookish": nonbookish, + "Patarin": patarin, + "preliberal": preliberal, + "prettifier": prettifier, + "rangework": rangework, + "redient": redient, + "subfusiform": subfusiform, + "suicidical": suicidical, + "swow": swow, + "wastrel": wastrel, + "wingle": wingle, + }; +} + +class GryphosaurusClass { + final dynamic amissibility; + final dynamic burushaski; + final dynamic citronin; + final dynamic coplaintiff; + final dynamic disquisitionary; + final dynamic enoplan; + final dynamic faintness; + final dynamic hebetomy; + final dynamic islandry; + final dynamic lameduck; + final dynamic overbattle; + final dynamic overinterested; + final dynamic phrenologic; + final dynamic rainband; + final dynamic shiningly; + final dynamic stamineous; + final dynamic subscapularis; + final dynamic tahami; + final dynamic undaubed; + final dynamic underntime; + + GryphosaurusClass({ + required this.amissibility, + required this.burushaski, + required this.citronin, + required this.coplaintiff, + required this.disquisitionary, + required this.enoplan, + required this.faintness, + required this.hebetomy, + required this.islandry, + required this.lameduck, + required this.overbattle, + required this.overinterested, + required this.phrenologic, + required this.rainband, + required this.shiningly, + required this.stamineous, + required this.subscapularis, + required this.tahami, + required this.undaubed, + required this.underntime, + }); + + factory GryphosaurusClass.fromMap(Map json) => GryphosaurusClass( + amissibility: (json.containsKey("amissibility") ? json["amissibility"] : throw FormatException('Missing required property')), + burushaski: (json.containsKey("Burushaski") ? json["Burushaski"] : throw FormatException('Missing required property')), + citronin: (json.containsKey("citronin") ? json["citronin"] : throw FormatException('Missing required property')), + coplaintiff: (json.containsKey("coplaintiff") ? json["coplaintiff"] : throw FormatException('Missing required property')), + disquisitionary: (json.containsKey("disquisitionary") ? json["disquisitionary"] : throw FormatException('Missing required property')), + enoplan: (json.containsKey("enoplan") ? json["enoplan"] : throw FormatException('Missing required property')), + faintness: (json.containsKey("faintness") ? json["faintness"] : throw FormatException('Missing required property')), + hebetomy: (json.containsKey("hebetomy") ? json["hebetomy"] : throw FormatException('Missing required property')), + islandry: (json.containsKey("islandry") ? json["islandry"] : throw FormatException('Missing required property')), + lameduck: (json.containsKey("lameduck") ? json["lameduck"] : throw FormatException('Missing required property')), + overbattle: (json.containsKey("overbattle") ? json["overbattle"] : throw FormatException('Missing required property')), + overinterested: (json.containsKey("overinterested") ? json["overinterested"] : throw FormatException('Missing required property')), + phrenologic: (json.containsKey("phrenologic") ? json["phrenologic"] : throw FormatException('Missing required property')), + rainband: (json.containsKey("rainband") ? json["rainband"] : throw FormatException('Missing required property')), + shiningly: (json.containsKey("shiningly") ? json["shiningly"] : throw FormatException('Missing required property')), + stamineous: (json.containsKey("stamineous") ? json["stamineous"] : throw FormatException('Missing required property')), + subscapularis: (json.containsKey("subscapularis") ? json["subscapularis"] : throw FormatException('Missing required property')), + tahami: (json.containsKey("Tahami") ? json["Tahami"] : throw FormatException('Missing required property')), + undaubed: (json.containsKey("undaubed") ? json["undaubed"] : throw FormatException('Missing required property')), + underntime: (json.containsKey("underntime") ? json["underntime"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "amissibility": amissibility, + "Burushaski": burushaski, + "citronin": citronin, + "coplaintiff": coplaintiff, + "disquisitionary": disquisitionary, + "enoplan": enoplan, + "faintness": faintness, + "hebetomy": hebetomy, + "islandry": islandry, + "lameduck": lameduck, + "overbattle": overbattle, + "overinterested": overinterested, + "phrenologic": phrenologic, + "rainband": rainband, + "shiningly": shiningly, + "stamineous": stamineous, + "subscapularis": subscapularis, + "Tahami": tahami, + "undaubed": undaubed, + "underntime": underntime, + }; +} + +class LaviniaClass { + final int? agitable; + final int? asininity; + final int? benefiter; + final int? bronzelike; + final double? catharticalness; + final int? chirotherium; + final int? cholesteatomatous; + final int? deprivement; + final String? disdiapason; + final int? flippantness; + final int? fogproof; + final bool? homocerc; + final int? merrymeeting; + final dynamic nonbookish; + final int? overcareful; + final int? panaris; + final int? preacceptance; + final int? quinoxaline; + final int? sig; + final int? superconfusion; + final int? tacana; + final int? tillotter; + final int? tranquillize; + final int? unquestionable; + final int? uproute; + + LaviniaClass({ + this.agitable, + this.asininity, + this.benefiter, + this.bronzelike, + this.catharticalness, + this.chirotherium, + this.cholesteatomatous, + this.deprivement, + this.disdiapason, + this.flippantness, + this.fogproof, + this.homocerc, + this.merrymeeting, + this.nonbookish, + this.overcareful, + this.panaris, + this.preacceptance, + this.quinoxaline, + this.sig, + this.superconfusion, + this.tacana, + this.tillotter, + this.tranquillize, + this.unquestionable, + this.uproute, + }); + + factory LaviniaClass.fromMap(Map json) => LaviniaClass( + agitable: json["agitable"], + asininity: json["asininity"], + benefiter: json["benefiter"], + bronzelike: json["bronzelike"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + cholesteatomatous: json["cholesteatomatous"], + deprivement: json["deprivement"], + disdiapason: json["disdiapason"], + flippantness: json["flippantness"], + fogproof: json["fogproof"], + homocerc: json["homocerc"], + merrymeeting: json["merrymeeting"], + nonbookish: json["nonbookish"], + overcareful: json["overcareful"], + panaris: json["panaris"], + preacceptance: json["preacceptance"], + quinoxaline: json["quinoxaline"], + sig: json["sig"], + superconfusion: json["superconfusion"], + tacana: json["Tacana"], + tillotter: json["tillotter"], + tranquillize: json["tranquillize"], + unquestionable: json["unquestionable"], + uproute: json["uproute"], + ); + + Map toMap() => { + "agitable": agitable, + "asininity": asininity, + "benefiter": benefiter, + "bronzelike": bronzelike, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "cholesteatomatous": cholesteatomatous, + "deprivement": deprivement, + "disdiapason": disdiapason, + "flippantness": flippantness, + "fogproof": fogproof, + "homocerc": homocerc, + "merrymeeting": merrymeeting, + "nonbookish": nonbookish, + "overcareful": overcareful, + "panaris": panaris, + "preacceptance": preacceptance, + "quinoxaline": quinoxaline, + "sig": sig, + "superconfusion": superconfusion, + "Tacana": tacana, + "tillotter": tillotter, + "tranquillize": tranquillize, + "unquestionable": unquestionable, + "uproute": uproute, + }; +} + +class OskarClass { + final dynamic acrobates; + final dynamic beanshooter; + final dynamic bearhound; + final dynamic cayuga; + final dynamic guarneri; + final dynamic hypochondriacism; + final dynamic indication; + final dynamic jaculative; + final dynamic nagana; + final dynamic netherlandish; + final dynamic noctivagous; + final dynamic nonphysiological; + final dynamic praxis; + final dynamic provision; + final dynamic subterhuman; + final dynamic sunlit; + final dynamic syncraniate; + final dynamic teachment; + final dynamic unmutinous; + final dynamic unstoppable; + + OskarClass({ + required this.acrobates, + required this.beanshooter, + required this.bearhound, + required this.cayuga, + required this.guarneri, + required this.hypochondriacism, + required this.indication, + required this.jaculative, + required this.nagana, + required this.netherlandish, + required this.noctivagous, + required this.nonphysiological, + required this.praxis, + required this.provision, + required this.subterhuman, + required this.sunlit, + required this.syncraniate, + required this.teachment, + required this.unmutinous, + required this.unstoppable, + }); + + factory OskarClass.fromMap(Map json) => OskarClass( + acrobates: (json.containsKey("Acrobates") ? json["Acrobates"] : throw FormatException('Missing required property')), + beanshooter: (json.containsKey("beanshooter") ? json["beanshooter"] : throw FormatException('Missing required property')), + bearhound: (json.containsKey("bearhound") ? json["bearhound"] : throw FormatException('Missing required property')), + cayuga: (json.containsKey("Cayuga") ? json["Cayuga"] : throw FormatException('Missing required property')), + guarneri: (json.containsKey("guarneri") ? json["guarneri"] : throw FormatException('Missing required property')), + hypochondriacism: (json.containsKey("hypochondriacism") ? json["hypochondriacism"] : throw FormatException('Missing required property')), + indication: (json.containsKey("indication") ? json["indication"] : throw FormatException('Missing required property')), + jaculative: (json.containsKey("jaculative") ? json["jaculative"] : throw FormatException('Missing required property')), + nagana: (json.containsKey("nagana") ? json["nagana"] : throw FormatException('Missing required property')), + netherlandish: (json.containsKey("Netherlandish") ? json["Netherlandish"] : throw FormatException('Missing required property')), + noctivagous: (json.containsKey("noctivagous") ? json["noctivagous"] : throw FormatException('Missing required property')), + nonphysiological: (json.containsKey("nonphysiological") ? json["nonphysiological"] : throw FormatException('Missing required property')), + praxis: (json.containsKey("praxis") ? json["praxis"] : throw FormatException('Missing required property')), + provision: (json.containsKey("provision") ? json["provision"] : throw FormatException('Missing required property')), + subterhuman: (json.containsKey("subterhuman") ? json["subterhuman"] : throw FormatException('Missing required property')), + sunlit: (json.containsKey("sunlit") ? json["sunlit"] : throw FormatException('Missing required property')), + syncraniate: (json.containsKey("syncraniate") ? json["syncraniate"] : throw FormatException('Missing required property')), + teachment: (json.containsKey("teachment") ? json["teachment"] : throw FormatException('Missing required property')), + unmutinous: (json.containsKey("unmutinous") ? json["unmutinous"] : throw FormatException('Missing required property')), + unstoppable: (json.containsKey("unstoppable") ? json["unstoppable"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "Acrobates": acrobates, + "beanshooter": beanshooter, + "bearhound": bearhound, + "Cayuga": cayuga, + "guarneri": guarneri, + "hypochondriacism": hypochondriacism, + "indication": indication, + "jaculative": jaculative, + "nagana": nagana, + "Netherlandish": netherlandish, + "noctivagous": noctivagous, + "nonphysiological": nonphysiological, + "praxis": praxis, + "provision": provision, + "subterhuman": subterhuman, + "sunlit": sunlit, + "syncraniate": syncraniate, + "teachment": teachment, + "unmutinous": unmutinous, + "unstoppable": unstoppable, + }; +} diff --git a/head/dart/test/inputs/json/priority/combinations3.json/from-map-true--d222f65b3fee/TopLevel.dart b/head/dart/test/inputs/json/priority/combinations3.json/from-map-true--d222f65b3fee/TopLevel.dart new file mode 100644 index 0000000..ab644d5 --- /dev/null +++ b/head/dart/test/inputs/json/priority/combinations3.json/from-map-true--d222f65b3fee/TopLevel.dart @@ -0,0 +1,1537 @@ +// To parse this JSON data, do +// +// final topLevel = topLevelFromJson(jsonString); + +import 'dart:convert'; + +TopLevel topLevelFromJson(String str) => TopLevel.fromMap(json.decode(str)); + +String topLevelToJson(TopLevel data) => json.encode(data.toMap()); + +class TopLevel { + final List juror; + final List kongoni; + final List ladronism; + final List landlubberly; + final List listener; + final List lupus; + final List maslin; + final List monazite; + final List monoliteral; + final List monotheistically; + final List montage; + final List moralness; + final List mowra; + final List mulishly; + final List myoscope; + final List?> nach; + final List neuromastic; + final List noncontributing; + final List nonnervous; + final List nonvaluation; + final List occupationalist; + final List outrival; + final List paleographically; + final List pamphletwise; + final List pediatrics; + final List perceptive; + final List piaculum; + final List piccadilly; + final List piffler; + final List pithful; + final List placuntitis; + final List plectopterous; + final List pneumocele; + final List poliorcetic; + final List poormaster; + final List potwhisky; + final List practicalizer; + final List prefreshman; + final List prehensility; + final List prevoidance; + final List> probant; + final List protext; + + TopLevel({ + required this.juror, + required this.kongoni, + required this.ladronism, + required this.landlubberly, + required this.listener, + required this.lupus, + required this.maslin, + required this.monazite, + required this.monoliteral, + required this.monotheistically, + required this.montage, + required this.moralness, + required this.mowra, + required this.mulishly, + required this.myoscope, + required this.nach, + required this.neuromastic, + required this.noncontributing, + required this.nonnervous, + required this.nonvaluation, + required this.occupationalist, + required this.outrival, + required this.paleographically, + required this.pamphletwise, + required this.pediatrics, + required this.perceptive, + required this.piaculum, + required this.piccadilly, + required this.piffler, + required this.pithful, + required this.placuntitis, + required this.plectopterous, + required this.pneumocele, + required this.poliorcetic, + required this.poormaster, + required this.potwhisky, + required this.practicalizer, + required this.prefreshman, + required this.prehensility, + required this.prevoidance, + required this.probant, + required this.protext, + }); + + factory TopLevel.fromMap(Map json) => TopLevel( + juror: List.from(json["juror"].map((x) => x)), + kongoni: List.from(json["kongoni"].map((x) => x)), + ladronism: List.from(json["ladronism"].map((x) => x)), + landlubberly: List.from(json["landlubberly"].map((x) => x)), + listener: List.from(json["listener"].map((x) => x)), + lupus: List.from(json["lupus"].map((x) => x)), + maslin: List.from(json["maslin"].map((x) => Maslin.fromMap(x))), + monazite: List.from(json["monazite"].map((x) => x)), + monoliteral: List.from(json["monoliteral"].map((x) => x)), + monotheistically: List.from(json["monotheistically"].map((x) => x)), + montage: List.from(json["montage"].map((x) => x)), + moralness: List.from(json["moralness"].map((x) => x)), + mowra: List.from(json["mowra"].map((x) => x == null ? null : MonaziteClass.fromMap(x))), + mulishly: List.from(json["mulishly"].map((x) => x)), + myoscope: List.from(json["myoscope"].map((x) => x)), + nach: List?>.from(json["nach"].map((x) => x == null ? null : List.from(x!.map((x) => x)))), + neuromastic: List.from(json["neuromastic"].map((x) => x)), + noncontributing: List.from(json["noncontributing"].map((x) => Noncontributing.fromMap(x))), + nonnervous: List.from(json["nonnervous"].map((x) => x)), + nonvaluation: List.from(json["nonvaluation"].map((x) => x)), + occupationalist: List.from(json["occupationalist"].map((x) => x)), + outrival: List.from(json["outrival"].map((x) => x)), + paleographically: List.from(json["paleographically"].map((x) => x)), + pamphletwise: List.from(json["pamphletwise"].map((x) => x)), + pediatrics: List.from(json["pediatrics"].map((x) => x)), + perceptive: List.from(json["perceptive"].map((x) => x)), + piaculum: List.from(json["piaculum"].map((x) => x)), + piccadilly: List.from(json["piccadilly"].map((x) => x)), + piffler: List.from(json["piffler"].map((x) => x)), + pithful: List.from(json["pithful"].map((x) => x)), + placuntitis: List.from(json["placuntitis"].map((x) => x)), + plectopterous: List.from(json["plectopterous"].map((x) => x)), + pneumocele: List.from(json["pneumocele"].map((x) => x == null ? null : Pneumocele.fromMap(x))), + poliorcetic: List.from(json["poliorcetic"].map((x) => x)), + poormaster: List.from(json["poormaster"].map((x) => x)), + potwhisky: List.from(json["potwhisky"].map((x) => x)), + practicalizer: List.from(json["practicalizer"].map((x) => x)), + prefreshman: List.from(json["prefreshman"].map((x) => x)), + prehensility: List.from(json["prehensility"].map((x) => x)), + prevoidance: List.from(json["prevoidance"].map((x) => x)), + probant: List>.from(json["probant"].map((x) => Map.from(x).map((k, v) => MapEntry(k, v)))), + protext: List.from(json["protext"].map((x) => x)), + ); + + Map toMap() => { + "juror": List.from(juror.map((x) => x)), + "kongoni": List.from(kongoni.map((x) => x)), + "ladronism": List.from(ladronism.map((x) => x)), + "landlubberly": List.from(landlubberly.map((x) => x)), + "listener": List.from(listener.map((x) => x)), + "lupus": List.from(lupus.map((x) => x)), + "maslin": List.from(maslin.map((x) => x.toMap())), + "monazite": List.from(monazite.map((x) => x)), + "monoliteral": List.from(monoliteral.map((x) => x)), + "monotheistically": List.from(monotheistically.map((x) => x)), + "montage": List.from(montage.map((x) => x)), + "moralness": List.from(moralness.map((x) => x)), + "mowra": List.from(mowra.map((x) => x?.toMap())), + "mulishly": List.from(mulishly.map((x) => x)), + "myoscope": List.from(myoscope.map((x) => x)), + "nach": List.from(nach.map((x) => x == null ? null : List.from(x!.map((x) => x)))), + "neuromastic": List.from(neuromastic.map((x) => x)), + "noncontributing": List.from(noncontributing.map((x) => x.toMap())), + "nonnervous": List.from(nonnervous.map((x) => x)), + "nonvaluation": List.from(nonvaluation.map((x) => x)), + "occupationalist": List.from(occupationalist.map((x) => x)), + "outrival": List.from(outrival.map((x) => x)), + "paleographically": List.from(paleographically.map((x) => x)), + "pamphletwise": List.from(pamphletwise.map((x) => x)), + "pediatrics": List.from(pediatrics.map((x) => x)), + "perceptive": List.from(perceptive.map((x) => x)), + "piaculum": List.from(piaculum.map((x) => x)), + "piccadilly": List.from(piccadilly.map((x) => x)), + "piffler": List.from(piffler.map((x) => x)), + "pithful": List.from(pithful.map((x) => x)), + "placuntitis": List.from(placuntitis.map((x) => x)), + "plectopterous": List.from(plectopterous.map((x) => x)), + "pneumocele": List.from(pneumocele.map((x) => x?.toMap())), + "poliorcetic": List.from(poliorcetic.map((x) => x)), + "poormaster": List.from(poormaster.map((x) => x)), + "potwhisky": List.from(potwhisky.map((x) => x)), + "practicalizer": List.from(practicalizer.map((x) => x)), + "prefreshman": List.from(prefreshman.map((x) => x)), + "prehensility": List.from(prehensility.map((x) => x)), + "prevoidance": List.from(prevoidance.map((x) => x)), + "probant": List.from(probant.map((x) => Map.from(x).map((k, v) => MapEntry(k, v)))), + "protext": List.from(protext.map((x) => x)), + }; +} + +class JurorClass { + final dynamic adipsy; + final dynamic auxiliator; + final dynamic benda; + final dynamic benjamin; + final dynamic brandling; + final dynamic epicurishly; + final dynamic eremochaetous; + final dynamic marten; + final dynamic monocline; + final dynamic olea; + final dynamic palgat; + final dynamic pennyworth; + final dynamic pioury; + final dynamic pragmatistic; + final dynamic stylelessness; + final dynamic systematical; + final dynamic thready; + final dynamic uncontemporary; + final dynamic uncouched; + final dynamic uninhabitedness; + + JurorClass({ + required this.adipsy, + required this.auxiliator, + required this.benda, + required this.benjamin, + required this.brandling, + required this.epicurishly, + required this.eremochaetous, + required this.marten, + required this.monocline, + required this.olea, + required this.palgat, + required this.pennyworth, + required this.pioury, + required this.pragmatistic, + required this.stylelessness, + required this.systematical, + required this.thready, + required this.uncontemporary, + required this.uncouched, + required this.uninhabitedness, + }); + + factory JurorClass.fromMap(Map json) => JurorClass( + adipsy: (json.containsKey("adipsy") ? json["adipsy"] : throw FormatException('Missing required property')), + auxiliator: (json.containsKey("auxiliator") ? json["auxiliator"] : throw FormatException('Missing required property')), + benda: (json.containsKey("benda") ? json["benda"] : throw FormatException('Missing required property')), + benjamin: (json.containsKey("benjamin") ? json["benjamin"] : throw FormatException('Missing required property')), + brandling: (json.containsKey("brandling") ? json["brandling"] : throw FormatException('Missing required property')), + epicurishly: (json.containsKey("epicurishly") ? json["epicurishly"] : throw FormatException('Missing required property')), + eremochaetous: (json.containsKey("eremochaetous") ? json["eremochaetous"] : throw FormatException('Missing required property')), + marten: (json.containsKey("marten") ? json["marten"] : throw FormatException('Missing required property')), + monocline: (json.containsKey("monocline") ? json["monocline"] : throw FormatException('Missing required property')), + olea: (json.containsKey("Olea") ? json["Olea"] : throw FormatException('Missing required property')), + palgat: (json.containsKey("palgat") ? json["palgat"] : throw FormatException('Missing required property')), + pennyworth: (json.containsKey("pennyworth") ? json["pennyworth"] : throw FormatException('Missing required property')), + pioury: (json.containsKey("pioury") ? json["pioury"] : throw FormatException('Missing required property')), + pragmatistic: (json.containsKey("pragmatistic") ? json["pragmatistic"] : throw FormatException('Missing required property')), + stylelessness: (json.containsKey("stylelessness") ? json["stylelessness"] : throw FormatException('Missing required property')), + systematical: (json.containsKey("systematical") ? json["systematical"] : throw FormatException('Missing required property')), + thready: (json.containsKey("thready") ? json["thready"] : throw FormatException('Missing required property')), + uncontemporary: (json.containsKey("uncontemporary") ? json["uncontemporary"] : throw FormatException('Missing required property')), + uncouched: (json.containsKey("uncouched") ? json["uncouched"] : throw FormatException('Missing required property')), + uninhabitedness: (json.containsKey("uninhabitedness") ? json["uninhabitedness"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "adipsy": adipsy, + "auxiliator": auxiliator, + "benda": benda, + "benjamin": benjamin, + "brandling": brandling, + "epicurishly": epicurishly, + "eremochaetous": eremochaetous, + "marten": marten, + "monocline": monocline, + "Olea": olea, + "palgat": palgat, + "pennyworth": pennyworth, + "pioury": pioury, + "pragmatistic": pragmatistic, + "stylelessness": stylelessness, + "systematical": systematical, + "thready": thready, + "uncontemporary": uncontemporary, + "uncouched": uncouched, + "uninhabitedness": uninhabitedness, + }; +} + +class LadronismClass { + final dynamic acclaimer; + final dynamic achree; + final dynamic base; + final dynamic conundrumize; + final dynamic degerminator; + final dynamic describable; + final dynamic exasperatedly; + final dynamic heroine; + final dynamic indazin; + final dynamic luteous; + final dynamic papular; + final dynamic pritch; + final dynamic prodenia; + final dynamic seege; + final dynamic shopgirl; + final dynamic tragedietta; + final dynamic unsparse; + final dynamic uplook; + final dynamic vermiformis; + final dynamic whafabout; + + LadronismClass({ + required this.acclaimer, + required this.achree, + required this.base, + required this.conundrumize, + required this.degerminator, + required this.describable, + required this.exasperatedly, + required this.heroine, + required this.indazin, + required this.luteous, + required this.papular, + required this.pritch, + required this.prodenia, + required this.seege, + required this.shopgirl, + required this.tragedietta, + required this.unsparse, + required this.uplook, + required this.vermiformis, + required this.whafabout, + }); + + factory LadronismClass.fromMap(Map json) => LadronismClass( + acclaimer: (json.containsKey("acclaimer") ? json["acclaimer"] : throw FormatException('Missing required property')), + achree: (json.containsKey("achree") ? json["achree"] : throw FormatException('Missing required property')), + base: (json.containsKey("base") ? json["base"] : throw FormatException('Missing required property')), + conundrumize: (json.containsKey("conundrumize") ? json["conundrumize"] : throw FormatException('Missing required property')), + degerminator: (json.containsKey("degerminator") ? json["degerminator"] : throw FormatException('Missing required property')), + describable: (json.containsKey("describable") ? json["describable"] : throw FormatException('Missing required property')), + exasperatedly: (json.containsKey("exasperatedly") ? json["exasperatedly"] : throw FormatException('Missing required property')), + heroine: (json.containsKey("heroine") ? json["heroine"] : throw FormatException('Missing required property')), + indazin: (json.containsKey("indazin") ? json["indazin"] : throw FormatException('Missing required property')), + luteous: (json.containsKey("luteous") ? json["luteous"] : throw FormatException('Missing required property')), + papular: (json.containsKey("papular") ? json["papular"] : throw FormatException('Missing required property')), + pritch: (json.containsKey("pritch") ? json["pritch"] : throw FormatException('Missing required property')), + prodenia: (json.containsKey("Prodenia") ? json["Prodenia"] : throw FormatException('Missing required property')), + seege: (json.containsKey("seege") ? json["seege"] : throw FormatException('Missing required property')), + shopgirl: (json.containsKey("shopgirl") ? json["shopgirl"] : throw FormatException('Missing required property')), + tragedietta: (json.containsKey("tragedietta") ? json["tragedietta"] : throw FormatException('Missing required property')), + unsparse: (json.containsKey("unsparse") ? json["unsparse"] : throw FormatException('Missing required property')), + uplook: (json.containsKey("uplook") ? json["uplook"] : throw FormatException('Missing required property')), + vermiformis: (json.containsKey("vermiformis") ? json["vermiformis"] : throw FormatException('Missing required property')), + whafabout: (json.containsKey("whafabout") ? json["whafabout"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "acclaimer": acclaimer, + "achree": achree, + "base": base, + "conundrumize": conundrumize, + "degerminator": degerminator, + "describable": describable, + "exasperatedly": exasperatedly, + "heroine": heroine, + "indazin": indazin, + "luteous": luteous, + "papular": papular, + "pritch": pritch, + "Prodenia": prodenia, + "seege": seege, + "shopgirl": shopgirl, + "tragedietta": tragedietta, + "unsparse": unsparse, + "uplook": uplook, + "vermiformis": vermiformis, + "whafabout": whafabout, + }; +} + +class LandlubberlyClass { + final dynamic acropoleis; + final dynamic aminate; + final dynamic amyraldism; + final dynamic bipenniform; + final dynamic bugre; + final dynamic calycule; + final dynamic caoutchouc; + final dynamic disprover; + final dynamic fitroot; + final dynamic fulgently; + final dynamic kickup; + final dynamic laevoversion; + final dynamic moter; + final dynamic objectivity; + final dynamic posterity; + final dynamic postnuptial; + final dynamic precedentary; + final dynamic saddling; + final dynamic subcurrent; + final dynamic unrecriminative; + + LandlubberlyClass({ + required this.acropoleis, + required this.aminate, + required this.amyraldism, + required this.bipenniform, + required this.bugre, + required this.calycule, + required this.caoutchouc, + required this.disprover, + required this.fitroot, + required this.fulgently, + required this.kickup, + required this.laevoversion, + required this.moter, + required this.objectivity, + required this.posterity, + required this.postnuptial, + required this.precedentary, + required this.saddling, + required this.subcurrent, + required this.unrecriminative, + }); + + factory LandlubberlyClass.fromMap(Map json) => LandlubberlyClass( + acropoleis: (json.containsKey("acropoleis") ? json["acropoleis"] : throw FormatException('Missing required property')), + aminate: (json.containsKey("aminate") ? json["aminate"] : throw FormatException('Missing required property')), + amyraldism: (json.containsKey("Amyraldism") ? json["Amyraldism"] : throw FormatException('Missing required property')), + bipenniform: (json.containsKey("bipenniform") ? json["bipenniform"] : throw FormatException('Missing required property')), + bugre: (json.containsKey("bugre") ? json["bugre"] : throw FormatException('Missing required property')), + calycule: (json.containsKey("calycule") ? json["calycule"] : throw FormatException('Missing required property')), + caoutchouc: (json.containsKey("caoutchouc") ? json["caoutchouc"] : throw FormatException('Missing required property')), + disprover: (json.containsKey("disprover") ? json["disprover"] : throw FormatException('Missing required property')), + fitroot: (json.containsKey("fitroot") ? json["fitroot"] : throw FormatException('Missing required property')), + fulgently: (json.containsKey("fulgently") ? json["fulgently"] : throw FormatException('Missing required property')), + kickup: (json.containsKey("kickup") ? json["kickup"] : throw FormatException('Missing required property')), + laevoversion: (json.containsKey("laevoversion") ? json["laevoversion"] : throw FormatException('Missing required property')), + moter: (json.containsKey("moter") ? json["moter"] : throw FormatException('Missing required property')), + objectivity: (json.containsKey("objectivity") ? json["objectivity"] : throw FormatException('Missing required property')), + posterity: (json.containsKey("posterity") ? json["posterity"] : throw FormatException('Missing required property')), + postnuptial: (json.containsKey("postnuptial") ? json["postnuptial"] : throw FormatException('Missing required property')), + precedentary: (json.containsKey("precedentary") ? json["precedentary"] : throw FormatException('Missing required property')), + saddling: (json.containsKey("saddling") ? json["saddling"] : throw FormatException('Missing required property')), + subcurrent: (json.containsKey("subcurrent") ? json["subcurrent"] : throw FormatException('Missing required property')), + unrecriminative: (json.containsKey("unrecriminative") ? json["unrecriminative"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "acropoleis": acropoleis, + "aminate": aminate, + "Amyraldism": amyraldism, + "bipenniform": bipenniform, + "bugre": bugre, + "calycule": calycule, + "caoutchouc": caoutchouc, + "disprover": disprover, + "fitroot": fitroot, + "fulgently": fulgently, + "kickup": kickup, + "laevoversion": laevoversion, + "moter": moter, + "objectivity": objectivity, + "posterity": posterity, + "postnuptial": postnuptial, + "precedentary": precedentary, + "saddling": saddling, + "subcurrent": subcurrent, + "unrecriminative": unrecriminative, + }; +} + +class LupusClass { + final double? catharticalness; + final int? chirotherium; + final int? chlorioninae; + final int? corvinae; + final int? crassina; + final String? disdiapason; + final int? exiguity; + final int? farcist; + final int? holographical; + final bool? homocerc; + final int? ichthyophagan; + final int? implacable; + final dynamic nonbookish; + final int? outshiner; + final int? overweather; + final int? protonegroid; + final int? shallowish; + final int? snoke; + final int? snout; + final int? surveillance; + final int? threshingtime; + final int? thysanocarpus; + final int? unsignificantly; + final int? unsnap; + final int? vendible; + + LupusClass({ + this.catharticalness, + this.chirotherium, + this.chlorioninae, + this.corvinae, + this.crassina, + this.disdiapason, + this.exiguity, + this.farcist, + this.holographical, + this.homocerc, + this.ichthyophagan, + this.implacable, + this.nonbookish, + this.outshiner, + this.overweather, + this.protonegroid, + this.shallowish, + this.snoke, + this.snout, + this.surveillance, + this.threshingtime, + this.thysanocarpus, + this.unsignificantly, + this.unsnap, + this.vendible, + }); + + factory LupusClass.fromMap(Map json) => LupusClass( + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + chlorioninae: json["Chlorioninae"], + corvinae: json["Corvinae"], + crassina: json["Crassina"], + disdiapason: json["disdiapason"], + exiguity: json["exiguity"], + farcist: json["farcist"], + holographical: json["holographical"], + homocerc: json["homocerc"], + ichthyophagan: json["ichthyophagan"], + implacable: json["implacable"], + nonbookish: json["nonbookish"], + outshiner: json["outshiner"], + overweather: json["overweather"], + protonegroid: json["protonegroid"], + shallowish: json["shallowish"], + snoke: json["snoke"], + snout: json["snout"], + surveillance: json["surveillance"], + threshingtime: json["threshingtime"], + thysanocarpus: json["Thysanocarpus"], + unsignificantly: json["unsignificantly"], + unsnap: json["unsnap"], + vendible: json["vendible"], + ); + + Map toMap() => { + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "Chlorioninae": chlorioninae, + "Corvinae": corvinae, + "Crassina": crassina, + "disdiapason": disdiapason, + "exiguity": exiguity, + "farcist": farcist, + "holographical": holographical, + "homocerc": homocerc, + "ichthyophagan": ichthyophagan, + "implacable": implacable, + "nonbookish": nonbookish, + "outshiner": outshiner, + "overweather": overweather, + "protonegroid": protonegroid, + "shallowish": shallowish, + "snoke": snoke, + "snout": snout, + "surveillance": surveillance, + "threshingtime": threshingtime, + "Thysanocarpus": thysanocarpus, + "unsignificantly": unsignificantly, + "unsnap": unsnap, + "vendible": vendible, + }; +} + +class Maslin { + final int? alicant; + final dynamic antiatonement; + final int? anticorrosive; + final dynamic aphidozer; + final dynamic bakuninist; + final int? be; + final double? catharticalness; + final int? chirotherium; + final int? chub; + final int? cuprosilicon; + final int? curtailedly; + final int? dellenite; + final int? dimitry; + final String? disdiapason; + final dynamic edifying; + final int? ethmoiditis; + final dynamic gastralgy; + final int? goatherd; + final int? hammerdress; + final dynamic hangfire; + final bool? homocerc; + final int? lacunosity; + final dynamic longiloquence; + final int? mameliere; + final dynamic motherless; + final dynamic nonbookish; + final dynamic noncorrodible; + final dynamic nonsensicality; + final int? oafishly; + final dynamic pfund; + final dynamic preadvisory; + final dynamic retroflexed; + final int? saccharulmic; + final int? scowlful; + final dynamic secluded; + final dynamic slackage; + final int? sphaeridial; + final dynamic spondulics; + final int? subsecive; + final dynamic swellmobsman; + final int? trachyglossate; + final dynamic trialogue; + final int? unassuaged; + final dynamic ungross; + final dynamic unjudiciously; + + Maslin({ + this.alicant, + this.antiatonement, + this.anticorrosive, + this.aphidozer, + this.bakuninist, + this.be, + this.catharticalness, + this.chirotherium, + this.chub, + this.cuprosilicon, + this.curtailedly, + this.dellenite, + this.dimitry, + this.disdiapason, + this.edifying, + this.ethmoiditis, + this.gastralgy, + this.goatherd, + this.hammerdress, + this.hangfire, + this.homocerc, + this.lacunosity, + this.longiloquence, + this.mameliere, + this.motherless, + this.nonbookish, + this.noncorrodible, + this.nonsensicality, + this.oafishly, + this.pfund, + this.preadvisory, + this.retroflexed, + this.saccharulmic, + this.scowlful, + this.secluded, + this.slackage, + this.sphaeridial, + this.spondulics, + this.subsecive, + this.swellmobsman, + this.trachyglossate, + this.trialogue, + this.unassuaged, + this.ungross, + this.unjudiciously, + }); + + factory Maslin.fromMap(Map json) => Maslin( + alicant: json["Alicant"], + antiatonement: json["antiatonement"], + anticorrosive: json["anticorrosive"], + aphidozer: json["aphidozer"], + bakuninist: json["Bakuninist"], + be: json["be"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + chub: json["chub"], + cuprosilicon: json["cuprosilicon"], + curtailedly: json["curtailedly"], + dellenite: json["dellenite"], + dimitry: json["Dimitry"], + disdiapason: json["disdiapason"], + edifying: json["edifying"], + ethmoiditis: json["ethmoiditis"], + gastralgy: json["gastralgy"], + goatherd: json["goatherd"], + hammerdress: json["hammerdress"], + hangfire: json["hangfire"], + homocerc: json["homocerc"], + lacunosity: json["lacunosity"], + longiloquence: json["longiloquence"], + mameliere: json["mameliere"], + motherless: json["motherless"], + nonbookish: json["nonbookish"], + noncorrodible: json["noncorrodible"], + nonsensicality: json["nonsensicality"], + oafishly: json["oafishly"], + pfund: json["pfund"], + preadvisory: json["preadvisory"], + retroflexed: json["retroflexed"], + saccharulmic: json["saccharulmic"], + scowlful: json["scowlful"], + secluded: json["secluded"], + slackage: json["slackage"], + sphaeridial: json["sphaeridial"], + spondulics: json["spondulics"], + subsecive: json["subsecive"], + swellmobsman: json["swellmobsman"], + trachyglossate: json["trachyglossate"], + trialogue: json["trialogue"], + unassuaged: json["unassuaged"], + ungross: json["ungross"], + unjudiciously: json["unjudiciously"], + ); + + Map toMap() => { + "Alicant": alicant, + "antiatonement": antiatonement, + "anticorrosive": anticorrosive, + "aphidozer": aphidozer, + "Bakuninist": bakuninist, + "be": be, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "chub": chub, + "cuprosilicon": cuprosilicon, + "curtailedly": curtailedly, + "dellenite": dellenite, + "Dimitry": dimitry, + "disdiapason": disdiapason, + "edifying": edifying, + "ethmoiditis": ethmoiditis, + "gastralgy": gastralgy, + "goatherd": goatherd, + "hammerdress": hammerdress, + "hangfire": hangfire, + "homocerc": homocerc, + "lacunosity": lacunosity, + "longiloquence": longiloquence, + "mameliere": mameliere, + "motherless": motherless, + "nonbookish": nonbookish, + "noncorrodible": noncorrodible, + "nonsensicality": nonsensicality, + "oafishly": oafishly, + "pfund": pfund, + "preadvisory": preadvisory, + "retroflexed": retroflexed, + "saccharulmic": saccharulmic, + "scowlful": scowlful, + "secluded": secluded, + "slackage": slackage, + "sphaeridial": sphaeridial, + "spondulics": spondulics, + "subsecive": subsecive, + "swellmobsman": swellmobsman, + "trachyglossate": trachyglossate, + "trialogue": trialogue, + "unassuaged": unassuaged, + "ungross": ungross, + "unjudiciously": unjudiciously, + }; +} + +class MonaziteClass { + final double catharticalness; + final int chirotherium; + final String disdiapason; + final bool homocerc; + final dynamic nonbookish; + + MonaziteClass({ + required this.catharticalness, + required this.chirotherium, + required this.disdiapason, + required this.homocerc, + required this.nonbookish, + }); + + factory MonaziteClass.fromMap(Map json) => MonaziteClass( + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + homocerc: json["homocerc"], + nonbookish: (json.containsKey("nonbookish") ? json["nonbookish"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "homocerc": homocerc, + "nonbookish": nonbookish, + }; +} + +class MonotheisticallyClass { + final dynamic blaspheme; + final double? catharticalness; + final dynamic celiosalpingectomy; + final int? chirotherium; + final dynamic consummativeness; + final String? disdiapason; + final dynamic egestive; + final dynamic enchylema; + final dynamic gasconade; + final dynamic holidayer; + final bool? homocerc; + final dynamic intuitionalism; + final dynamic lophiostomate; + final dynamic nonbookish; + final dynamic nonvolition; + final dynamic palatableness; + final dynamic pimpery; + final dynamic previolation; + final dynamic reconveyance; + final dynamic registership; + final dynamic rhyacolite; + final dynamic smithereens; + final dynamic superedification; + final dynamic trust; + final dynamic whitestone; + + MonotheisticallyClass({ + this.blaspheme, + this.catharticalness, + this.celiosalpingectomy, + this.chirotherium, + this.consummativeness, + this.disdiapason, + this.egestive, + this.enchylema, + this.gasconade, + this.holidayer, + this.homocerc, + this.intuitionalism, + this.lophiostomate, + this.nonbookish, + this.nonvolition, + this.palatableness, + this.pimpery, + this.previolation, + this.reconveyance, + this.registership, + this.rhyacolite, + this.smithereens, + this.superedification, + this.trust, + this.whitestone, + }); + + factory MonotheisticallyClass.fromMap(Map json) => MonotheisticallyClass( + blaspheme: json["blaspheme"], + catharticalness: json["catharticalness"]?.toDouble(), + celiosalpingectomy: json["celiosalpingectomy"], + chirotherium: json["Chirotherium"], + consummativeness: json["consummativeness"], + disdiapason: json["disdiapason"], + egestive: json["egestive"], + enchylema: json["enchylema"], + gasconade: json["gasconade"], + holidayer: json["holidayer"], + homocerc: json["homocerc"], + intuitionalism: json["intuitionalism"], + lophiostomate: json["lophiostomate"], + nonbookish: json["nonbookish"], + nonvolition: json["nonvolition"], + palatableness: json["palatableness"], + pimpery: json["pimpery"], + previolation: json["previolation"], + reconveyance: json["reconveyance"], + registership: json["registership"], + rhyacolite: json["rhyacolite"], + smithereens: json["smithereens"], + superedification: json["superedification"], + trust: json["trust"], + whitestone: json["whitestone"], + ); + + Map toMap() => { + "blaspheme": blaspheme, + "catharticalness": catharticalness, + "celiosalpingectomy": celiosalpingectomy, + "Chirotherium": chirotherium, + "consummativeness": consummativeness, + "disdiapason": disdiapason, + "egestive": egestive, + "enchylema": enchylema, + "gasconade": gasconade, + "holidayer": holidayer, + "homocerc": homocerc, + "intuitionalism": intuitionalism, + "lophiostomate": lophiostomate, + "nonbookish": nonbookish, + "nonvolition": nonvolition, + "palatableness": palatableness, + "pimpery": pimpery, + "previolation": previolation, + "reconveyance": reconveyance, + "registership": registership, + "rhyacolite": rhyacolite, + "smithereens": smithereens, + "superedification": superedification, + "trust": trust, + "whitestone": whitestone, + }; +} + +class Noncontributing { + final String estevin; + final double jolterhead; + final int sauternes; + final bool sparsely; + final dynamic unrequested; + + Noncontributing({ + required this.estevin, + required this.jolterhead, + required this.sauternes, + required this.sparsely, + required this.unrequested, + }); + + factory Noncontributing.fromMap(Map json) => Noncontributing( + estevin: json["estevin"], + jolterhead: json["jolterhead"]?.toDouble(), + sauternes: json["sauternes"], + sparsely: json["sparsely"], + unrequested: (json.containsKey("unrequested") ? json["unrequested"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "estevin": estevin, + "jolterhead": jolterhead, + "sauternes": sauternes, + "sparsely": sparsely, + "unrequested": unrequested, + }; +} + +class OccupationalistClass { + final dynamic beholdable; + final dynamic brotuliform; + final dynamic chimakum; + final dynamic doodler; + final dynamic emulsin; + final dynamic fin; + final dynamic flourishing; + final dynamic flueless; + final dynamic furtively; + final dynamic gritter; + final dynamic interwish; + final dynamic monoxylic; + final dynamic myristic; + final dynamic nightwear; + final dynamic peruser; + final dynamic theoastrological; + final dynamic thumby; + final dynamic tingitid; + final dynamic trailless; + final dynamic unpocketed; + + OccupationalistClass({ + required this.beholdable, + required this.brotuliform, + required this.chimakum, + required this.doodler, + required this.emulsin, + required this.fin, + required this.flourishing, + required this.flueless, + required this.furtively, + required this.gritter, + required this.interwish, + required this.monoxylic, + required this.myristic, + required this.nightwear, + required this.peruser, + required this.theoastrological, + required this.thumby, + required this.tingitid, + required this.trailless, + required this.unpocketed, + }); + + factory OccupationalistClass.fromMap(Map json) => OccupationalistClass( + beholdable: (json.containsKey("beholdable") ? json["beholdable"] : throw FormatException('Missing required property')), + brotuliform: (json.containsKey("brotuliform") ? json["brotuliform"] : throw FormatException('Missing required property')), + chimakum: (json.containsKey("Chimakum") ? json["Chimakum"] : throw FormatException('Missing required property')), + doodler: (json.containsKey("doodler") ? json["doodler"] : throw FormatException('Missing required property')), + emulsin: (json.containsKey("emulsin") ? json["emulsin"] : throw FormatException('Missing required property')), + fin: (json.containsKey("Fin") ? json["Fin"] : throw FormatException('Missing required property')), + flourishing: (json.containsKey("flourishing") ? json["flourishing"] : throw FormatException('Missing required property')), + flueless: (json.containsKey("flueless") ? json["flueless"] : throw FormatException('Missing required property')), + furtively: (json.containsKey("furtively") ? json["furtively"] : throw FormatException('Missing required property')), + gritter: (json.containsKey("gritter") ? json["gritter"] : throw FormatException('Missing required property')), + interwish: (json.containsKey("interwish") ? json["interwish"] : throw FormatException('Missing required property')), + monoxylic: (json.containsKey("monoxylic") ? json["monoxylic"] : throw FormatException('Missing required property')), + myristic: (json.containsKey("myristic") ? json["myristic"] : throw FormatException('Missing required property')), + nightwear: (json.containsKey("nightwear") ? json["nightwear"] : throw FormatException('Missing required property')), + peruser: (json.containsKey("peruser") ? json["peruser"] : throw FormatException('Missing required property')), + theoastrological: (json.containsKey("theoastrological") ? json["theoastrological"] : throw FormatException('Missing required property')), + thumby: (json.containsKey("thumby") ? json["thumby"] : throw FormatException('Missing required property')), + tingitid: (json.containsKey("tingitid") ? json["tingitid"] : throw FormatException('Missing required property')), + trailless: (json.containsKey("trailless") ? json["trailless"] : throw FormatException('Missing required property')), + unpocketed: (json.containsKey("unpocketed") ? json["unpocketed"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "beholdable": beholdable, + "brotuliform": brotuliform, + "Chimakum": chimakum, + "doodler": doodler, + "emulsin": emulsin, + "Fin": fin, + "flourishing": flourishing, + "flueless": flueless, + "furtively": furtively, + "gritter": gritter, + "interwish": interwish, + "monoxylic": monoxylic, + "myristic": myristic, + "nightwear": nightwear, + "peruser": peruser, + "theoastrological": theoastrological, + "thumby": thumby, + "tingitid": tingitid, + "trailless": trailless, + "unpocketed": unpocketed, + }; +} + +class OutrivalClass { + final dynamic adroitly; + final dynamic bridehood; + final dynamic castoroides; + final dynamic czechoslovak; + final dynamic diagenesis; + final dynamic dihexahedron; + final dynamic dopester; + final dynamic eumerism; + final dynamic flyness; + final dynamic fouler; + final dynamic laudanosine; + final dynamic lingulidae; + final dynamic minutary; + final dynamic mitra; + final dynamic opisthorchiasis; + final dynamic pensively; + final dynamic pubigerous; + final dynamic rebellious; + final dynamic recodify; + final dynamic unpaced; + + OutrivalClass({ + required this.adroitly, + required this.bridehood, + required this.castoroides, + required this.czechoslovak, + required this.diagenesis, + required this.dihexahedron, + required this.dopester, + required this.eumerism, + required this.flyness, + required this.fouler, + required this.laudanosine, + required this.lingulidae, + required this.minutary, + required this.mitra, + required this.opisthorchiasis, + required this.pensively, + required this.pubigerous, + required this.rebellious, + required this.recodify, + required this.unpaced, + }); + + factory OutrivalClass.fromMap(Map json) => OutrivalClass( + adroitly: (json.containsKey("adroitly") ? json["adroitly"] : throw FormatException('Missing required property')), + bridehood: (json.containsKey("bridehood") ? json["bridehood"] : throw FormatException('Missing required property')), + castoroides: (json.containsKey("Castoroides") ? json["Castoroides"] : throw FormatException('Missing required property')), + czechoslovak: (json.containsKey("Czechoslovak") ? json["Czechoslovak"] : throw FormatException('Missing required property')), + diagenesis: (json.containsKey("diagenesis") ? json["diagenesis"] : throw FormatException('Missing required property')), + dihexahedron: (json.containsKey("dihexahedron") ? json["dihexahedron"] : throw FormatException('Missing required property')), + dopester: (json.containsKey("dopester") ? json["dopester"] : throw FormatException('Missing required property')), + eumerism: (json.containsKey("eumerism") ? json["eumerism"] : throw FormatException('Missing required property')), + flyness: (json.containsKey("flyness") ? json["flyness"] : throw FormatException('Missing required property')), + fouler: (json.containsKey("fouler") ? json["fouler"] : throw FormatException('Missing required property')), + laudanosine: (json.containsKey("laudanosine") ? json["laudanosine"] : throw FormatException('Missing required property')), + lingulidae: (json.containsKey("Lingulidae") ? json["Lingulidae"] : throw FormatException('Missing required property')), + minutary: (json.containsKey("minutary") ? json["minutary"] : throw FormatException('Missing required property')), + mitra: (json.containsKey("mitra") ? json["mitra"] : throw FormatException('Missing required property')), + opisthorchiasis: (json.containsKey("opisthorchiasis") ? json["opisthorchiasis"] : throw FormatException('Missing required property')), + pensively: (json.containsKey("pensively") ? json["pensively"] : throw FormatException('Missing required property')), + pubigerous: (json.containsKey("pubigerous") ? json["pubigerous"] : throw FormatException('Missing required property')), + rebellious: (json.containsKey("rebellious") ? json["rebellious"] : throw FormatException('Missing required property')), + recodify: (json.containsKey("recodify") ? json["recodify"] : throw FormatException('Missing required property')), + unpaced: (json.containsKey("unpaced") ? json["unpaced"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "adroitly": adroitly, + "bridehood": bridehood, + "Castoroides": castoroides, + "Czechoslovak": czechoslovak, + "diagenesis": diagenesis, + "dihexahedron": dihexahedron, + "dopester": dopester, + "eumerism": eumerism, + "flyness": flyness, + "fouler": fouler, + "laudanosine": laudanosine, + "Lingulidae": lingulidae, + "minutary": minutary, + "mitra": mitra, + "opisthorchiasis": opisthorchiasis, + "pensively": pensively, + "pubigerous": pubigerous, + "rebellious": rebellious, + "recodify": recodify, + "unpaced": unpaced, + }; +} + +class PiaculumClass { + final int? alada; + final int? amphistomous; + final int? boysenberry; + final double? catharticalness; + final int? chirotherium; + final int? decardinalize; + final int? discouragement; + final String? disdiapason; + final int? doitrified; + final int? hexaspermous; + final bool? homocerc; + final int? insinking; + final int? loathfulness; + final int? miasmatical; + final int? neurofibril; + final dynamic nonbookish; + final int? phonendoscope; + final int? pilferment; + final int? predismissory; + final int? preinscription; + final int? quotative; + final int? sienna; + final int? thorax; + final int? yachting; + final int? zipper; + + PiaculumClass({ + this.alada, + this.amphistomous, + this.boysenberry, + this.catharticalness, + this.chirotherium, + this.decardinalize, + this.discouragement, + this.disdiapason, + this.doitrified, + this.hexaspermous, + this.homocerc, + this.insinking, + this.loathfulness, + this.miasmatical, + this.neurofibril, + this.nonbookish, + this.phonendoscope, + this.pilferment, + this.predismissory, + this.preinscription, + this.quotative, + this.sienna, + this.thorax, + this.yachting, + this.zipper, + }); + + factory PiaculumClass.fromMap(Map json) => PiaculumClass( + alada: json["alada"], + amphistomous: json["amphistomous"], + boysenberry: json["boysenberry"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + decardinalize: json["decardinalize"], + discouragement: json["discouragement"], + disdiapason: json["disdiapason"], + doitrified: json["doitrified"], + hexaspermous: json["hexaspermous"], + homocerc: json["homocerc"], + insinking: json["insinking"], + loathfulness: json["loathfulness"], + miasmatical: json["miasmatical"], + neurofibril: json["neurofibril"], + nonbookish: json["nonbookish"], + phonendoscope: json["phonendoscope"], + pilferment: json["pilferment"], + predismissory: json["predismissory"], + preinscription: json["preinscription"], + quotative: json["quotative"], + sienna: json["sienna"], + thorax: json["thorax"], + yachting: json["yachting"], + zipper: json["Zipper"], + ); + + Map toMap() => { + "alada": alada, + "amphistomous": amphistomous, + "boysenberry": boysenberry, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "decardinalize": decardinalize, + "discouragement": discouragement, + "disdiapason": disdiapason, + "doitrified": doitrified, + "hexaspermous": hexaspermous, + "homocerc": homocerc, + "insinking": insinking, + "loathfulness": loathfulness, + "miasmatical": miasmatical, + "neurofibril": neurofibril, + "nonbookish": nonbookish, + "phonendoscope": phonendoscope, + "pilferment": pilferment, + "predismissory": predismissory, + "preinscription": preinscription, + "quotative": quotative, + "sienna": sienna, + "thorax": thorax, + "yachting": yachting, + "Zipper": zipper, + }; +} + +class Pneumocele { + final dynamic carbonarism; + final double? catharticalness; + final int? chirotherium; + final dynamic cineolic; + final dynamic cobbly; + final dynamic conchyliferous; + final dynamic congregation; + final String? disdiapason; + final dynamic enterotomy; + final dynamic entophytal; + final dynamic fewtrils; + final dynamic herem; + final bool? homocerc; + final dynamic koniga; + final dynamic meticulosity; + final dynamic micky; + final dynamic mismarriage; + final dynamic neurotrophic; + final dynamic nonbookish; + final dynamic persuasively; + final dynamic replaceable; + final dynamic silex; + final dynamic taillight; + final dynamic unjealous; + final dynamic visitorial; + + Pneumocele({ + this.carbonarism, + this.catharticalness, + this.chirotherium, + this.cineolic, + this.cobbly, + this.conchyliferous, + this.congregation, + this.disdiapason, + this.enterotomy, + this.entophytal, + this.fewtrils, + this.herem, + this.homocerc, + this.koniga, + this.meticulosity, + this.micky, + this.mismarriage, + this.neurotrophic, + this.nonbookish, + this.persuasively, + this.replaceable, + this.silex, + this.taillight, + this.unjealous, + this.visitorial, + }); + + factory Pneumocele.fromMap(Map json) => Pneumocele( + carbonarism: json["Carbonarism"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + cineolic: json["cineolic"], + cobbly: json["cobbly"], + conchyliferous: json["conchyliferous"], + congregation: json["congregation"], + disdiapason: json["disdiapason"], + enterotomy: json["enterotomy"], + entophytal: json["entophytal"], + fewtrils: json["fewtrils"], + herem: json["herem"], + homocerc: json["homocerc"], + koniga: json["Koniga"], + meticulosity: json["meticulosity"], + micky: json["Micky"], + mismarriage: json["mismarriage"], + neurotrophic: json["neurotrophic"], + nonbookish: json["nonbookish"], + persuasively: json["persuasively"], + replaceable: json["replaceable"], + silex: json["silex"], + taillight: json["taillight"], + unjealous: json["unjealous"], + visitorial: json["visitorial"], + ); + + Map toMap() => { + "Carbonarism": carbonarism, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "cineolic": cineolic, + "cobbly": cobbly, + "conchyliferous": conchyliferous, + "congregation": congregation, + "disdiapason": disdiapason, + "enterotomy": enterotomy, + "entophytal": entophytal, + "fewtrils": fewtrils, + "herem": herem, + "homocerc": homocerc, + "Koniga": koniga, + "meticulosity": meticulosity, + "Micky": micky, + "mismarriage": mismarriage, + "neurotrophic": neurotrophic, + "nonbookish": nonbookish, + "persuasively": persuasively, + "replaceable": replaceable, + "silex": silex, + "taillight": taillight, + "unjealous": unjealous, + "visitorial": visitorial, + }; +} + +class PotwhiskyClass { + final dynamic arciform; + final dynamic cresolin; + final dynamic disheartener; + final dynamic disproportionable; + final dynamic euchorda; + final dynamic ferryway; + final dynamic filamentiferous; + final dynamic flemish; + final dynamic forgainst; + final dynamic grainering; + final dynamic irrevoluble; + final dynamic kindredship; + final dynamic pinguitudinous; + final dynamic simpletonic; + final dynamic singsong; + final dynamic submergement; + final dynamic supraoesophagal; + final dynamic thrashel; + final dynamic tyremesis; + final dynamic yoruba; + + PotwhiskyClass({ + required this.arciform, + required this.cresolin, + required this.disheartener, + required this.disproportionable, + required this.euchorda, + required this.ferryway, + required this.filamentiferous, + required this.flemish, + required this.forgainst, + required this.grainering, + required this.irrevoluble, + required this.kindredship, + required this.pinguitudinous, + required this.simpletonic, + required this.singsong, + required this.submergement, + required this.supraoesophagal, + required this.thrashel, + required this.tyremesis, + required this.yoruba, + }); + + factory PotwhiskyClass.fromMap(Map json) => PotwhiskyClass( + arciform: (json.containsKey("arciform") ? json["arciform"] : throw FormatException('Missing required property')), + cresolin: (json.containsKey("cresolin") ? json["cresolin"] : throw FormatException('Missing required property')), + disheartener: (json.containsKey("disheartener") ? json["disheartener"] : throw FormatException('Missing required property')), + disproportionable: (json.containsKey("disproportionable") ? json["disproportionable"] : throw FormatException('Missing required property')), + euchorda: (json.containsKey("Euchorda") ? json["Euchorda"] : throw FormatException('Missing required property')), + ferryway: (json.containsKey("ferryway") ? json["ferryway"] : throw FormatException('Missing required property')), + filamentiferous: (json.containsKey("filamentiferous") ? json["filamentiferous"] : throw FormatException('Missing required property')), + flemish: (json.containsKey("flemish") ? json["flemish"] : throw FormatException('Missing required property')), + forgainst: (json.containsKey("forgainst") ? json["forgainst"] : throw FormatException('Missing required property')), + grainering: (json.containsKey("grainering") ? json["grainering"] : throw FormatException('Missing required property')), + irrevoluble: (json.containsKey("irrevoluble") ? json["irrevoluble"] : throw FormatException('Missing required property')), + kindredship: (json.containsKey("kindredship") ? json["kindredship"] : throw FormatException('Missing required property')), + pinguitudinous: (json.containsKey("pinguitudinous") ? json["pinguitudinous"] : throw FormatException('Missing required property')), + simpletonic: (json.containsKey("simpletonic") ? json["simpletonic"] : throw FormatException('Missing required property')), + singsong: (json.containsKey("singsong") ? json["singsong"] : throw FormatException('Missing required property')), + submergement: (json.containsKey("submergement") ? json["submergement"] : throw FormatException('Missing required property')), + supraoesophagal: (json.containsKey("supraoesophagal") ? json["supraoesophagal"] : throw FormatException('Missing required property')), + thrashel: (json.containsKey("thrashel") ? json["thrashel"] : throw FormatException('Missing required property')), + tyremesis: (json.containsKey("tyremesis") ? json["tyremesis"] : throw FormatException('Missing required property')), + yoruba: (json.containsKey("Yoruba") ? json["Yoruba"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "arciform": arciform, + "cresolin": cresolin, + "disheartener": disheartener, + "disproportionable": disproportionable, + "Euchorda": euchorda, + "ferryway": ferryway, + "filamentiferous": filamentiferous, + "flemish": flemish, + "forgainst": forgainst, + "grainering": grainering, + "irrevoluble": irrevoluble, + "kindredship": kindredship, + "pinguitudinous": pinguitudinous, + "simpletonic": simpletonic, + "singsong": singsong, + "submergement": submergement, + "supraoesophagal": supraoesophagal, + "thrashel": thrashel, + "tyremesis": tyremesis, + "Yoruba": yoruba, + }; +} + +class PrefreshmanClass { + final dynamic azorubine; + final dynamic choroiditis; + final dynamic coagulatory; + final dynamic cyclorama; + final dynamic dolphus; + final dynamic duckhearted; + final dynamic ficus; + final dynamic gemaric; + final dynamic jugation; + final dynamic myoliposis; + final dynamic nonnomination; + final dynamic palay; + final dynamic pentactinal; + final dynamic phaet; + final dynamic piquant; + final dynamic registration; + final dynamic remancipation; + final dynamic scutatiform; + final dynamic theodolite; + final dynamic underward; + + PrefreshmanClass({ + required this.azorubine, + required this.choroiditis, + required this.coagulatory, + required this.cyclorama, + required this.dolphus, + required this.duckhearted, + required this.ficus, + required this.gemaric, + required this.jugation, + required this.myoliposis, + required this.nonnomination, + required this.palay, + required this.pentactinal, + required this.phaet, + required this.piquant, + required this.registration, + required this.remancipation, + required this.scutatiform, + required this.theodolite, + required this.underward, + }); + + factory PrefreshmanClass.fromMap(Map json) => PrefreshmanClass( + azorubine: (json.containsKey("azorubine") ? json["azorubine"] : throw FormatException('Missing required property')), + choroiditis: (json.containsKey("choroiditis") ? json["choroiditis"] : throw FormatException('Missing required property')), + coagulatory: (json.containsKey("coagulatory") ? json["coagulatory"] : throw FormatException('Missing required property')), + cyclorama: (json.containsKey("cyclorama") ? json["cyclorama"] : throw FormatException('Missing required property')), + dolphus: (json.containsKey("Dolphus") ? json["Dolphus"] : throw FormatException('Missing required property')), + duckhearted: (json.containsKey("duckhearted") ? json["duckhearted"] : throw FormatException('Missing required property')), + ficus: (json.containsKey("Ficus") ? json["Ficus"] : throw FormatException('Missing required property')), + gemaric: (json.containsKey("Gemaric") ? json["Gemaric"] : throw FormatException('Missing required property')), + jugation: (json.containsKey("jugation") ? json["jugation"] : throw FormatException('Missing required property')), + myoliposis: (json.containsKey("myoliposis") ? json["myoliposis"] : throw FormatException('Missing required property')), + nonnomination: (json.containsKey("nonnomination") ? json["nonnomination"] : throw FormatException('Missing required property')), + palay: (json.containsKey("palay") ? json["palay"] : throw FormatException('Missing required property')), + pentactinal: (json.containsKey("pentactinal") ? json["pentactinal"] : throw FormatException('Missing required property')), + phaet: (json.containsKey("Phaet") ? json["Phaet"] : throw FormatException('Missing required property')), + piquant: (json.containsKey("piquant") ? json["piquant"] : throw FormatException('Missing required property')), + registration: (json.containsKey("registration") ? json["registration"] : throw FormatException('Missing required property')), + remancipation: (json.containsKey("remancipation") ? json["remancipation"] : throw FormatException('Missing required property')), + scutatiform: (json.containsKey("scutatiform") ? json["scutatiform"] : throw FormatException('Missing required property')), + theodolite: (json.containsKey("theodolite") ? json["theodolite"] : throw FormatException('Missing required property')), + underward: (json.containsKey("underward") ? json["underward"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "azorubine": azorubine, + "choroiditis": choroiditis, + "coagulatory": coagulatory, + "cyclorama": cyclorama, + "Dolphus": dolphus, + "duckhearted": duckhearted, + "Ficus": ficus, + "Gemaric": gemaric, + "jugation": jugation, + "myoliposis": myoliposis, + "nonnomination": nonnomination, + "palay": palay, + "pentactinal": pentactinal, + "Phaet": phaet, + "piquant": piquant, + "registration": registration, + "remancipation": remancipation, + "scutatiform": scutatiform, + "theodolite": theodolite, + "underward": underward, + }; +} diff --git a/head/dart/test/inputs/json/priority/combinations4.json/from-map-true--d222f65b3fee/TopLevel.dart b/head/dart/test/inputs/json/priority/combinations4.json/from-map-true--d222f65b3fee/TopLevel.dart new file mode 100644 index 0000000..8564d49 --- /dev/null +++ b/head/dart/test/inputs/json/priority/combinations4.json/from-map-true--d222f65b3fee/TopLevel.dart @@ -0,0 +1,1761 @@ +// To parse this JSON data, do +// +// final topLevel = topLevelFromJson(jsonString); + +import 'dart:convert'; + +TopLevel topLevelFromJson(String str) => TopLevel.fromMap(json.decode(str)); + +String topLevelToJson(TopLevel data) => json.encode(data.toMap()); + +class TopLevel { + final List protrusive; + final List pulpitism; + final List pyodermia; + final List quebrachine; + final List querier; + final List rebarbative; + final List reimagine; + final Ressaut ressaut; + final List retrocervical; + final List revert; + final List rewrite; + final List saccoderm; + final List santir; + final List saprophilous; + final List saxten; + final List scatty; + final List scoffer; + final List scrampum; + final double semantic; + final List serpentinic; + final List shadowable; + final List sistering; + final List staghunting; + final List stagmometer; + final List stimulability; + final List strangleable; + final List strenuosity; + final List tabaxir; + final List talpiform; + final List thwack; + final List to; + final List tortricine; + final List truantcy; + final List turgesce; + final List unbeginning; + final List underdunged; + final List undesirability; + final List unerasing; + final List unguentarium; + final List unimpeachably; + final List unmortgaged; + final List unobstructed; + final List unreceptivity; + final List unsatisfactoriness; + final List unsecurity; + final List unstressed; + final List untasked; + final List unvarying; + final List vehemently; + final Map warriorship; + final List whitepot; + final List wrothy; + + TopLevel({ + required this.protrusive, + required this.pulpitism, + required this.pyodermia, + required this.quebrachine, + required this.querier, + required this.rebarbative, + required this.reimagine, + required this.ressaut, + required this.retrocervical, + required this.revert, + required this.rewrite, + required this.saccoderm, + required this.santir, + required this.saprophilous, + required this.saxten, + required this.scatty, + required this.scoffer, + required this.scrampum, + required this.semantic, + required this.serpentinic, + required this.shadowable, + required this.sistering, + required this.staghunting, + required this.stagmometer, + required this.stimulability, + required this.strangleable, + required this.strenuosity, + required this.tabaxir, + required this.talpiform, + required this.thwack, + required this.to, + required this.tortricine, + required this.truantcy, + required this.turgesce, + required this.unbeginning, + required this.underdunged, + required this.undesirability, + required this.unerasing, + required this.unguentarium, + required this.unimpeachably, + required this.unmortgaged, + required this.unobstructed, + required this.unreceptivity, + required this.unsatisfactoriness, + required this.unsecurity, + required this.unstressed, + required this.untasked, + required this.unvarying, + required this.vehemently, + required this.warriorship, + required this.whitepot, + required this.wrothy, + }); + + factory TopLevel.fromMap(Map json) => TopLevel( + protrusive: List.from(json["protrusive"].map((x) => x)), + pulpitism: List.from(json["pulpitism"].map((x) => x)), + pyodermia: List.from(json["pyodermia"].map((x) => x)), + quebrachine: List.from(json["quebrachine"].map((x) => x)), + querier: List.from(json["querier"].map((x) => x)), + rebarbative: List.from(json["rebarbative"].map((x) => x)), + reimagine: List.from(json["reimagine"].map((x) => Reimagine.fromMap(x))), + ressaut: Ressaut.fromMap(json["ressaut"]), + retrocervical: List.from(json["retrocervical"].map((x) => x)), + revert: List.from(json["revert"].map((x) => x)), + rewrite: List.from(json["rewrite"].map((x) => x)), + saccoderm: List.from(json["saccoderm"].map((x) => x)), + santir: List.from(json["santir"].map((x) => x)), + saprophilous: List.from(json["saprophilous"].map((x) => x)), + saxten: List.from(json["saxten"].map((x) => x)), + scatty: List.from(json["scatty"].map((x) => x == null ? null : Scatty.fromMap(x))), + scoffer: List.from(json["scoffer"].map((x) => x)), + scrampum: List.from(json["scrampum"].map((x) => x)), + semantic: json["semantic"]?.toDouble(), + serpentinic: List.from(json["serpentinic"].map((x) => x)), + shadowable: List.from(json["shadowable"].map((x) => x)), + sistering: List.from(json["sistering"].map((x) => x)), + staghunting: List.from(json["staghunting"].map((x) => Staghunting.fromMap(x))), + stagmometer: List.from(json["stagmometer"].map((x) => x)), + stimulability: List.from(json["stimulability"].map((x) => x)), + strangleable: List.from(json["strangleable"].map((x) => x)), + strenuosity: List.from(json["strenuosity"].map((x) => x)), + tabaxir: List.from(json["tabaxir"].map((x) => x)), + talpiform: List.from(json["talpiform"].map((x) => x)), + thwack: List.from(json["thwack"].map((x) => x)), + to: List.from(json["to"].map((x) => x?.toDouble())), + tortricine: List.from(json["tortricine"].map((x) => x)), + truantcy: List.from(json["truantcy"].map((x) => x)), + turgesce: List.from(json["turgesce"].map((x) => x)), + unbeginning: List.from(json["unbeginning"].map((x) => x)), + underdunged: List.from(json["underdunged"].map((x) => x?.toDouble())), + undesirability: List.from(json["undesirability"].map((x) => x)), + unerasing: List.from(json["unerasing"].map((x) => x)), + unguentarium: List.from(json["unguentarium"].map((x) => x)), + unimpeachably: List.from(json["unimpeachably"].map((x) => x)), + unmortgaged: List.from(json["unmortgaged"].map((x) => x)), + unobstructed: List.from(json["unobstructed"].map((x) => x)), + unreceptivity: List.from(json["unreceptivity"].map((x) => x)), + unsatisfactoriness: List.from(json["unsatisfactoriness"].map((x) => x)), + unsecurity: List.from(json["unsecurity"].map((x) => x)), + unstressed: List.from(json["unstressed"].map((x) => x)), + untasked: List.from(json["untasked"].map((x) => x)), + unvarying: List.from(json["unvarying"].map((x) => x)), + vehemently: List.from(json["vehemently"].map((x) => x)), + warriorship: Map.from(json["warriorship"]).map((k, v) => MapEntry(k, v)), + whitepot: List.from(json["whitepot"].map((x) => x)), + wrothy: List.from(json["wrothy"].map((x) => x)), + ); + + Map toMap() => { + "protrusive": List.from(protrusive.map((x) => x)), + "pulpitism": List.from(pulpitism.map((x) => x)), + "pyodermia": List.from(pyodermia.map((x) => x)), + "quebrachine": List.from(quebrachine.map((x) => x)), + "querier": List.from(querier.map((x) => x)), + "rebarbative": List.from(rebarbative.map((x) => x)), + "reimagine": List.from(reimagine.map((x) => x.toMap())), + "ressaut": ressaut.toMap(), + "retrocervical": List.from(retrocervical.map((x) => x)), + "revert": List.from(revert.map((x) => x)), + "rewrite": List.from(rewrite.map((x) => x)), + "saccoderm": List.from(saccoderm.map((x) => x)), + "santir": List.from(santir.map((x) => x)), + "saprophilous": List.from(saprophilous.map((x) => x)), + "saxten": List.from(saxten.map((x) => x)), + "scatty": List.from(scatty.map((x) => x?.toMap())), + "scoffer": List.from(scoffer.map((x) => x)), + "scrampum": List.from(scrampum.map((x) => x)), + "semantic": semantic, + "serpentinic": List.from(serpentinic.map((x) => x)), + "shadowable": List.from(shadowable.map((x) => x)), + "sistering": List.from(sistering.map((x) => x)), + "staghunting": List.from(staghunting.map((x) => x.toMap())), + "stagmometer": List.from(stagmometer.map((x) => x)), + "stimulability": List.from(stimulability.map((x) => x)), + "strangleable": List.from(strangleable.map((x) => x)), + "strenuosity": List.from(strenuosity.map((x) => x)), + "tabaxir": List.from(tabaxir.map((x) => x)), + "talpiform": List.from(talpiform.map((x) => x)), + "thwack": List.from(thwack.map((x) => x)), + "to": List.from(to.map((x) => x)), + "tortricine": List.from(tortricine.map((x) => x)), + "truantcy": List.from(truantcy.map((x) => x)), + "turgesce": List.from(turgesce.map((x) => x)), + "unbeginning": List.from(unbeginning.map((x) => x)), + "underdunged": List.from(underdunged.map((x) => x)), + "undesirability": List.from(undesirability.map((x) => x)), + "unerasing": List.from(unerasing.map((x) => x)), + "unguentarium": List.from(unguentarium.map((x) => x)), + "unimpeachably": List.from(unimpeachably.map((x) => x)), + "unmortgaged": List.from(unmortgaged.map((x) => x)), + "unobstructed": List.from(unobstructed.map((x) => x)), + "unreceptivity": List.from(unreceptivity.map((x) => x)), + "unsatisfactoriness": List.from(unsatisfactoriness.map((x) => x)), + "unsecurity": List.from(unsecurity.map((x) => x)), + "unstressed": List.from(unstressed.map((x) => x)), + "untasked": List.from(untasked.map((x) => x)), + "unvarying": List.from(unvarying.map((x) => x)), + "vehemently": List.from(vehemently.map((x) => x)), + "warriorship": Map.from(warriorship).map((k, v) => MapEntry(k, v)), + "whitepot": List.from(whitepot.map((x) => x)), + "wrothy": List.from(wrothy.map((x) => x)), + }; +} + +class PulpitismClass { + final dynamic abnet; + final dynamic buckhorn; + final dynamic calciform; + final dynamic chelophore; + final dynamic cogitation; + final dynamic decreeable; + final dynamic despicable; + final dynamic isodiazo; + final dynamic jadedly; + final dynamic leptochlorite; + final dynamic nursling; + final dynamic palamedean; + final dynamic photoheliograph; + final dynamic pipewood; + final dynamic roberd; + final dynamic statable; + final dynamic superassume; + final dynamic syllabe; + final dynamic toughhead; + final dynamic underburn; + + PulpitismClass({ + required this.abnet, + required this.buckhorn, + required this.calciform, + required this.chelophore, + required this.cogitation, + required this.decreeable, + required this.despicable, + required this.isodiazo, + required this.jadedly, + required this.leptochlorite, + required this.nursling, + required this.palamedean, + required this.photoheliograph, + required this.pipewood, + required this.roberd, + required this.statable, + required this.superassume, + required this.syllabe, + required this.toughhead, + required this.underburn, + }); + + factory PulpitismClass.fromMap(Map json) => PulpitismClass( + abnet: (json.containsKey("abnet") ? json["abnet"] : throw FormatException('Missing required property')), + buckhorn: (json.containsKey("buckhorn") ? json["buckhorn"] : throw FormatException('Missing required property')), + calciform: (json.containsKey("calciform") ? json["calciform"] : throw FormatException('Missing required property')), + chelophore: (json.containsKey("chelophore") ? json["chelophore"] : throw FormatException('Missing required property')), + cogitation: (json.containsKey("cogitation") ? json["cogitation"] : throw FormatException('Missing required property')), + decreeable: (json.containsKey("decreeable") ? json["decreeable"] : throw FormatException('Missing required property')), + despicable: (json.containsKey("despicable") ? json["despicable"] : throw FormatException('Missing required property')), + isodiazo: (json.containsKey("isodiazo") ? json["isodiazo"] : throw FormatException('Missing required property')), + jadedly: (json.containsKey("jadedly") ? json["jadedly"] : throw FormatException('Missing required property')), + leptochlorite: (json.containsKey("leptochlorite") ? json["leptochlorite"] : throw FormatException('Missing required property')), + nursling: (json.containsKey("nursling") ? json["nursling"] : throw FormatException('Missing required property')), + palamedean: (json.containsKey("palamedean") ? json["palamedean"] : throw FormatException('Missing required property')), + photoheliograph: (json.containsKey("photoheliograph") ? json["photoheliograph"] : throw FormatException('Missing required property')), + pipewood: (json.containsKey("pipewood") ? json["pipewood"] : throw FormatException('Missing required property')), + roberd: (json.containsKey("roberd") ? json["roberd"] : throw FormatException('Missing required property')), + statable: (json.containsKey("statable") ? json["statable"] : throw FormatException('Missing required property')), + superassume: (json.containsKey("superassume") ? json["superassume"] : throw FormatException('Missing required property')), + syllabe: (json.containsKey("syllabe") ? json["syllabe"] : throw FormatException('Missing required property')), + toughhead: (json.containsKey("toughhead") ? json["toughhead"] : throw FormatException('Missing required property')), + underburn: (json.containsKey("underburn") ? json["underburn"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "abnet": abnet, + "buckhorn": buckhorn, + "calciform": calciform, + "chelophore": chelophore, + "cogitation": cogitation, + "decreeable": decreeable, + "despicable": despicable, + "isodiazo": isodiazo, + "jadedly": jadedly, + "leptochlorite": leptochlorite, + "nursling": nursling, + "palamedean": palamedean, + "photoheliograph": photoheliograph, + "pipewood": pipewood, + "roberd": roberd, + "statable": statable, + "superassume": superassume, + "syllabe": syllabe, + "toughhead": toughhead, + "underburn": underburn, + }; +} + +class PyodermiaClass { + final dynamic aphoristically; + final dynamic apophyllous; + final dynamic cognize; + final dynamic dermonosology; + final dynamic gyppo; + final dynamic ither; + final dynamic juglandaceous; + final dynamic litho; + final dynamic macropterous; + final dynamic photographer; + final dynamic romancing; + final dynamic rumness; + final dynamic somniloquist; + final dynamic stressfully; + final dynamic tactically; + final dynamic tracheophony; + final dynamic unappositely; + final dynamic unclothedly; + final dynamic unimplied; + final dynamic unsyncopated; + + PyodermiaClass({ + required this.aphoristically, + required this.apophyllous, + required this.cognize, + required this.dermonosology, + required this.gyppo, + required this.ither, + required this.juglandaceous, + required this.litho, + required this.macropterous, + required this.photographer, + required this.romancing, + required this.rumness, + required this.somniloquist, + required this.stressfully, + required this.tactically, + required this.tracheophony, + required this.unappositely, + required this.unclothedly, + required this.unimplied, + required this.unsyncopated, + }); + + factory PyodermiaClass.fromMap(Map json) => PyodermiaClass( + aphoristically: (json.containsKey("aphoristically") ? json["aphoristically"] : throw FormatException('Missing required property')), + apophyllous: (json.containsKey("apophyllous") ? json["apophyllous"] : throw FormatException('Missing required property')), + cognize: (json.containsKey("cognize") ? json["cognize"] : throw FormatException('Missing required property')), + dermonosology: (json.containsKey("dermonosology") ? json["dermonosology"] : throw FormatException('Missing required property')), + gyppo: (json.containsKey("Gyppo") ? json["Gyppo"] : throw FormatException('Missing required property')), + ither: (json.containsKey("ither") ? json["ither"] : throw FormatException('Missing required property')), + juglandaceous: (json.containsKey("juglandaceous") ? json["juglandaceous"] : throw FormatException('Missing required property')), + litho: (json.containsKey("litho") ? json["litho"] : throw FormatException('Missing required property')), + macropterous: (json.containsKey("macropterous") ? json["macropterous"] : throw FormatException('Missing required property')), + photographer: (json.containsKey("photographer") ? json["photographer"] : throw FormatException('Missing required property')), + romancing: (json.containsKey("romancing") ? json["romancing"] : throw FormatException('Missing required property')), + rumness: (json.containsKey("rumness") ? json["rumness"] : throw FormatException('Missing required property')), + somniloquist: (json.containsKey("somniloquist") ? json["somniloquist"] : throw FormatException('Missing required property')), + stressfully: (json.containsKey("stressfully") ? json["stressfully"] : throw FormatException('Missing required property')), + tactically: (json.containsKey("tactically") ? json["tactically"] : throw FormatException('Missing required property')), + tracheophony: (json.containsKey("tracheophony") ? json["tracheophony"] : throw FormatException('Missing required property')), + unappositely: (json.containsKey("unappositely") ? json["unappositely"] : throw FormatException('Missing required property')), + unclothedly: (json.containsKey("unclothedly") ? json["unclothedly"] : throw FormatException('Missing required property')), + unimplied: (json.containsKey("unimplied") ? json["unimplied"] : throw FormatException('Missing required property')), + unsyncopated: (json.containsKey("unsyncopated") ? json["unsyncopated"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "aphoristically": aphoristically, + "apophyllous": apophyllous, + "cognize": cognize, + "dermonosology": dermonosology, + "Gyppo": gyppo, + "ither": ither, + "juglandaceous": juglandaceous, + "litho": litho, + "macropterous": macropterous, + "photographer": photographer, + "romancing": romancing, + "rumness": rumness, + "somniloquist": somniloquist, + "stressfully": stressfully, + "tactically": tactically, + "tracheophony": tracheophony, + "unappositely": unappositely, + "unclothedly": unclothedly, + "unimplied": unimplied, + "unsyncopated": unsyncopated, + }; +} + +class QuebrachineClass { + final double catharticalness; + final int chirotherium; + final String disdiapason; + final bool homocerc; + final dynamic nonbookish; + + QuebrachineClass({ + required this.catharticalness, + required this.chirotherium, + required this.disdiapason, + required this.homocerc, + required this.nonbookish, + }); + + factory QuebrachineClass.fromMap(Map json) => QuebrachineClass( + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + homocerc: json["homocerc"], + nonbookish: (json.containsKey("nonbookish") ? json["nonbookish"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "homocerc": homocerc, + "nonbookish": nonbookish, + }; +} + +class Reimagine { + final dynamic adducible; + final dynamic anabolin; + final dynamic brainy; + final double? catharticalness; + final int? chirotherium; + final dynamic chrysamine; + final String? disdiapason; + final dynamic fluxweed; + final dynamic glaucine; + final dynamic grobianism; + final dynamic hermo; + final dynamic hieroglyphist; + final bool? homocerc; + final dynamic icteroid; + final dynamic immortal; + final dynamic impetulant; + final dynamic irrigate; + final dynamic myxedema; + final dynamic nonbookish; + final dynamic onyx; + final dynamic repasser; + final dynamic septomarginal; + final dynamic subdie; + final dynamic tibiometatarsal; + final dynamic waltzlike; + + Reimagine({ + this.adducible, + this.anabolin, + this.brainy, + this.catharticalness, + this.chirotherium, + this.chrysamine, + this.disdiapason, + this.fluxweed, + this.glaucine, + this.grobianism, + this.hermo, + this.hieroglyphist, + this.homocerc, + this.icteroid, + this.immortal, + this.impetulant, + this.irrigate, + this.myxedema, + this.nonbookish, + this.onyx, + this.repasser, + this.septomarginal, + this.subdie, + this.tibiometatarsal, + this.waltzlike, + }); + + factory Reimagine.fromMap(Map json) => Reimagine( + adducible: json["adducible"], + anabolin: json["anabolin"], + brainy: json["brainy"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + chrysamine: json["chrysamine"], + disdiapason: json["disdiapason"], + fluxweed: json["fluxweed"], + glaucine: json["glaucine"], + grobianism: json["grobianism"], + hermo: json["Hermo"], + hieroglyphist: json["hieroglyphist"], + homocerc: json["homocerc"], + icteroid: json["icteroid"], + immortal: json["immortal"], + impetulant: json["impetulant"], + irrigate: json["irrigate"], + myxedema: json["myxedema"], + nonbookish: json["nonbookish"], + onyx: json["onyx"], + repasser: json["repasser"], + septomarginal: json["septomarginal"], + subdie: json["subdie"], + tibiometatarsal: json["tibiometatarsal"], + waltzlike: json["waltzlike"], + ); + + Map toMap() => { + "adducible": adducible, + "anabolin": anabolin, + "brainy": brainy, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "chrysamine": chrysamine, + "disdiapason": disdiapason, + "fluxweed": fluxweed, + "glaucine": glaucine, + "grobianism": grobianism, + "Hermo": hermo, + "hieroglyphist": hieroglyphist, + "homocerc": homocerc, + "icteroid": icteroid, + "immortal": immortal, + "impetulant": impetulant, + "irrigate": irrigate, + "myxedema": myxedema, + "nonbookish": nonbookish, + "onyx": onyx, + "repasser": repasser, + "septomarginal": septomarginal, + "subdie": subdie, + "tibiometatarsal": tibiometatarsal, + "waltzlike": waltzlike, + }; +} + +class Ressaut { + final String apperceptive; + final String cuttoo; + final String douser; + final String drinkproof; + final String forementioned; + final String freesia; + final String genevieve; + final String hyperdiabolical; + final String hypocone; + final String irreverentially; + final String jumart; + final String mimosaceae; + final String mollicrush; + final String nedder; + final String retinasphalt; + final String sough; + final String steading; + final String theopaschitism; + final String undurableness; + final String unmingleable; + + Ressaut({ + required this.apperceptive, + required this.cuttoo, + required this.douser, + required this.drinkproof, + required this.forementioned, + required this.freesia, + required this.genevieve, + required this.hyperdiabolical, + required this.hypocone, + required this.irreverentially, + required this.jumart, + required this.mimosaceae, + required this.mollicrush, + required this.nedder, + required this.retinasphalt, + required this.sough, + required this.steading, + required this.theopaschitism, + required this.undurableness, + required this.unmingleable, + }); + + factory Ressaut.fromMap(Map json) => Ressaut( + apperceptive: json["apperceptive"], + cuttoo: json["cuttoo"], + douser: json["douser"], + drinkproof: json["drinkproof"], + forementioned: json["forementioned"], + freesia: json["Freesia"], + genevieve: json["Genevieve"], + hyperdiabolical: json["hyperdiabolical"], + hypocone: json["hypocone"], + irreverentially: json["irreverentially"], + jumart: json["jumart"], + mimosaceae: json["Mimosaceae"], + mollicrush: json["mollicrush"], + nedder: json["nedder"], + retinasphalt: json["retinasphalt"], + sough: json["sough"], + steading: json["steading"], + theopaschitism: json["Theopaschitism"], + undurableness: json["undurableness"], + unmingleable: json["unmingleable"], + ); + + Map toMap() => { + "apperceptive": apperceptive, + "cuttoo": cuttoo, + "douser": douser, + "drinkproof": drinkproof, + "forementioned": forementioned, + "Freesia": freesia, + "Genevieve": genevieve, + "hyperdiabolical": hyperdiabolical, + "hypocone": hypocone, + "irreverentially": irreverentially, + "jumart": jumart, + "Mimosaceae": mimosaceae, + "mollicrush": mollicrush, + "nedder": nedder, + "retinasphalt": retinasphalt, + "sough": sough, + "steading": steading, + "Theopaschitism": theopaschitism, + "undurableness": undurableness, + "unmingleable": unmingleable, + }; +} + +class RewriteClass { + final dynamic accountancy; + final dynamic cacotrophic; + final dynamic contest; + final dynamic couthily; + final dynamic falculate; + final dynamic foreseize; + final dynamic hyades; + final dynamic lemnad; + final dynamic monotheistically; + final dynamic nonflying; + final dynamic ptenoglossa; + final dynamic repatch; + final dynamic rodman; + final dynamic strung; + final dynamic titmal; + final dynamic twalpennyworth; + final dynamic unblamable; + final dynamic vertical; + final dynamic whiggification; + final dynamic yardman; + + RewriteClass({ + required this.accountancy, + required this.cacotrophic, + required this.contest, + required this.couthily, + required this.falculate, + required this.foreseize, + required this.hyades, + required this.lemnad, + required this.monotheistically, + required this.nonflying, + required this.ptenoglossa, + required this.repatch, + required this.rodman, + required this.strung, + required this.titmal, + required this.twalpennyworth, + required this.unblamable, + required this.vertical, + required this.whiggification, + required this.yardman, + }); + + factory RewriteClass.fromMap(Map json) => RewriteClass( + accountancy: (json.containsKey("accountancy") ? json["accountancy"] : throw FormatException('Missing required property')), + cacotrophic: (json.containsKey("cacotrophic") ? json["cacotrophic"] : throw FormatException('Missing required property')), + contest: (json.containsKey("contest") ? json["contest"] : throw FormatException('Missing required property')), + couthily: (json.containsKey("couthily") ? json["couthily"] : throw FormatException('Missing required property')), + falculate: (json.containsKey("falculate") ? json["falculate"] : throw FormatException('Missing required property')), + foreseize: (json.containsKey("foreseize") ? json["foreseize"] : throw FormatException('Missing required property')), + hyades: (json.containsKey("Hyades") ? json["Hyades"] : throw FormatException('Missing required property')), + lemnad: (json.containsKey("lemnad") ? json["lemnad"] : throw FormatException('Missing required property')), + monotheistically: (json.containsKey("monotheistically") ? json["monotheistically"] : throw FormatException('Missing required property')), + nonflying: (json.containsKey("nonflying") ? json["nonflying"] : throw FormatException('Missing required property')), + ptenoglossa: (json.containsKey("Ptenoglossa") ? json["Ptenoglossa"] : throw FormatException('Missing required property')), + repatch: (json.containsKey("repatch") ? json["repatch"] : throw FormatException('Missing required property')), + rodman: (json.containsKey("rodman") ? json["rodman"] : throw FormatException('Missing required property')), + strung: (json.containsKey("strung") ? json["strung"] : throw FormatException('Missing required property')), + titmal: (json.containsKey("titmal") ? json["titmal"] : throw FormatException('Missing required property')), + twalpennyworth: (json.containsKey("twalpennyworth") ? json["twalpennyworth"] : throw FormatException('Missing required property')), + unblamable: (json.containsKey("unblamable") ? json["unblamable"] : throw FormatException('Missing required property')), + vertical: (json.containsKey("vertical") ? json["vertical"] : throw FormatException('Missing required property')), + whiggification: (json.containsKey("Whiggification") ? json["Whiggification"] : throw FormatException('Missing required property')), + yardman: (json.containsKey("yardman") ? json["yardman"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "accountancy": accountancy, + "cacotrophic": cacotrophic, + "contest": contest, + "couthily": couthily, + "falculate": falculate, + "foreseize": foreseize, + "Hyades": hyades, + "lemnad": lemnad, + "monotheistically": monotheistically, + "nonflying": nonflying, + "Ptenoglossa": ptenoglossa, + "repatch": repatch, + "rodman": rodman, + "strung": strung, + "titmal": titmal, + "twalpennyworth": twalpennyworth, + "unblamable": unblamable, + "vertical": vertical, + "Whiggification": whiggification, + "yardman": yardman, + }; +} + +class SantirClass { + final dynamic admiredly; + final dynamic demicaponier; + final dynamic epitympanic; + final dynamic investitor; + final dynamic lupiform; + final dynamic monoflagellate; + final dynamic paleoethnic; + final dynamic prediscountable; + final dynamic rhetoricals; + final dynamic roomth; + final dynamic saccharose; + final dynamic septonasal; + final dynamic serpenticide; + final dynamic setarious; + final dynamic spaework; + final dynamic stylite; + final dynamic suessiones; + final dynamic timelily; + final dynamic unprofaned; + final dynamic vorticular; + + SantirClass({ + required this.admiredly, + required this.demicaponier, + required this.epitympanic, + required this.investitor, + required this.lupiform, + required this.monoflagellate, + required this.paleoethnic, + required this.prediscountable, + required this.rhetoricals, + required this.roomth, + required this.saccharose, + required this.septonasal, + required this.serpenticide, + required this.setarious, + required this.spaework, + required this.stylite, + required this.suessiones, + required this.timelily, + required this.unprofaned, + required this.vorticular, + }); + + factory SantirClass.fromMap(Map json) => SantirClass( + admiredly: (json.containsKey("admiredly") ? json["admiredly"] : throw FormatException('Missing required property')), + demicaponier: (json.containsKey("demicaponier") ? json["demicaponier"] : throw FormatException('Missing required property')), + epitympanic: (json.containsKey("epitympanic") ? json["epitympanic"] : throw FormatException('Missing required property')), + investitor: (json.containsKey("investitor") ? json["investitor"] : throw FormatException('Missing required property')), + lupiform: (json.containsKey("lupiform") ? json["lupiform"] : throw FormatException('Missing required property')), + monoflagellate: (json.containsKey("monoflagellate") ? json["monoflagellate"] : throw FormatException('Missing required property')), + paleoethnic: (json.containsKey("paleoethnic") ? json["paleoethnic"] : throw FormatException('Missing required property')), + prediscountable: (json.containsKey("prediscountable") ? json["prediscountable"] : throw FormatException('Missing required property')), + rhetoricals: (json.containsKey("rhetoricals") ? json["rhetoricals"] : throw FormatException('Missing required property')), + roomth: (json.containsKey("roomth") ? json["roomth"] : throw FormatException('Missing required property')), + saccharose: (json.containsKey("saccharose") ? json["saccharose"] : throw FormatException('Missing required property')), + septonasal: (json.containsKey("septonasal") ? json["septonasal"] : throw FormatException('Missing required property')), + serpenticide: (json.containsKey("serpenticide") ? json["serpenticide"] : throw FormatException('Missing required property')), + setarious: (json.containsKey("setarious") ? json["setarious"] : throw FormatException('Missing required property')), + spaework: (json.containsKey("spaework") ? json["spaework"] : throw FormatException('Missing required property')), + stylite: (json.containsKey("stylite") ? json["stylite"] : throw FormatException('Missing required property')), + suessiones: (json.containsKey("Suessiones") ? json["Suessiones"] : throw FormatException('Missing required property')), + timelily: (json.containsKey("timelily") ? json["timelily"] : throw FormatException('Missing required property')), + unprofaned: (json.containsKey("unprofaned") ? json["unprofaned"] : throw FormatException('Missing required property')), + vorticular: (json.containsKey("vorticular") ? json["vorticular"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "admiredly": admiredly, + "demicaponier": demicaponier, + "epitympanic": epitympanic, + "investitor": investitor, + "lupiform": lupiform, + "monoflagellate": monoflagellate, + "paleoethnic": paleoethnic, + "prediscountable": prediscountable, + "rhetoricals": rhetoricals, + "roomth": roomth, + "saccharose": saccharose, + "septonasal": septonasal, + "serpenticide": serpenticide, + "setarious": setarious, + "spaework": spaework, + "stylite": stylite, + "Suessiones": suessiones, + "timelily": timelily, + "unprofaned": unprofaned, + "vorticular": vorticular, + }; +} + +class SaxtenClass { + final dynamic algarrobilla; + final dynamic bowgrace; + final double? catharticalness; + final dynamic centaurid; + final int? chirotherium; + final String? disdiapason; + final dynamic flix; + final dynamic germanely; + final bool? homocerc; + final dynamic inhume; + final dynamic lepidote; + final dynamic megalochirous; + final dynamic ninepenny; + final dynamic nonbookish; + final dynamic nondeist; + final dynamic nymphaeaceous; + final dynamic parietofrontal; + final dynamic sancyite; + final dynamic subjectivist; + final dynamic tibiad; + final dynamic transonic; + final dynamic tripetalous; + final dynamic trunchman; + final dynamic urger; + final dynamic withdrawnness; + + SaxtenClass({ + this.algarrobilla, + this.bowgrace, + this.catharticalness, + this.centaurid, + this.chirotherium, + this.disdiapason, + this.flix, + this.germanely, + this.homocerc, + this.inhume, + this.lepidote, + this.megalochirous, + this.ninepenny, + this.nonbookish, + this.nondeist, + this.nymphaeaceous, + this.parietofrontal, + this.sancyite, + this.subjectivist, + this.tibiad, + this.transonic, + this.tripetalous, + this.trunchman, + this.urger, + this.withdrawnness, + }); + + factory SaxtenClass.fromMap(Map json) => SaxtenClass( + algarrobilla: json["algarrobilla"], + bowgrace: json["bowgrace"], + catharticalness: json["catharticalness"]?.toDouble(), + centaurid: json["Centaurid"], + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + flix: json["flix"], + germanely: json["germanely"], + homocerc: json["homocerc"], + inhume: json["inhume"], + lepidote: json["lepidote"], + megalochirous: json["megalochirous"], + ninepenny: json["ninepenny"], + nonbookish: json["nonbookish"], + nondeist: json["nondeist"], + nymphaeaceous: json["nymphaeaceous"], + parietofrontal: json["parietofrontal"], + sancyite: json["sancyite"], + subjectivist: json["subjectivist"], + tibiad: json["tibiad"], + transonic: json["transonic"], + tripetalous: json["tripetalous"], + trunchman: json["trunchman"], + urger: json["urger"], + withdrawnness: json["withdrawnness"], + ); + + Map toMap() => { + "algarrobilla": algarrobilla, + "bowgrace": bowgrace, + "catharticalness": catharticalness, + "Centaurid": centaurid, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "flix": flix, + "germanely": germanely, + "homocerc": homocerc, + "inhume": inhume, + "lepidote": lepidote, + "megalochirous": megalochirous, + "ninepenny": ninepenny, + "nonbookish": nonbookish, + "nondeist": nondeist, + "nymphaeaceous": nymphaeaceous, + "parietofrontal": parietofrontal, + "sancyite": sancyite, + "subjectivist": subjectivist, + "tibiad": tibiad, + "transonic": transonic, + "tripetalous": tripetalous, + "trunchman": trunchman, + "urger": urger, + "withdrawnness": withdrawnness, + }; +} + +class Scatty { + final dynamic aeriferous; + final dynamic antical; + final dynamic antighostism; + final dynamic arcanum; + final dynamic autotrophy; + final dynamic baronial; + final dynamic caffeine; + final dynamic gorgoniacean; + final dynamic heroical; + final dynamic hydropical; + final dynamic mechanology; + final dynamic musicopoetic; + final dynamic officiality; + final dynamic oftentimes; + final dynamic ophthalmotonometer; + final dynamic reflectively; + final dynamic springer; + final dynamic tabasco; + final dynamic teleianthous; + final dynamic uncombated; + + Scatty({ + required this.aeriferous, + required this.antical, + required this.antighostism, + required this.arcanum, + required this.autotrophy, + required this.baronial, + required this.caffeine, + required this.gorgoniacean, + required this.heroical, + required this.hydropical, + required this.mechanology, + required this.musicopoetic, + required this.officiality, + required this.oftentimes, + required this.ophthalmotonometer, + required this.reflectively, + required this.springer, + required this.tabasco, + required this.teleianthous, + required this.uncombated, + }); + + factory Scatty.fromMap(Map json) => Scatty( + aeriferous: (json.containsKey("aeriferous") ? json["aeriferous"] : throw FormatException('Missing required property')), + antical: (json.containsKey("antical") ? json["antical"] : throw FormatException('Missing required property')), + antighostism: (json.containsKey("antighostism") ? json["antighostism"] : throw FormatException('Missing required property')), + arcanum: (json.containsKey("arcanum") ? json["arcanum"] : throw FormatException('Missing required property')), + autotrophy: (json.containsKey("autotrophy") ? json["autotrophy"] : throw FormatException('Missing required property')), + baronial: (json.containsKey("baronial") ? json["baronial"] : throw FormatException('Missing required property')), + caffeine: (json.containsKey("caffeine") ? json["caffeine"] : throw FormatException('Missing required property')), + gorgoniacean: (json.containsKey("gorgoniacean") ? json["gorgoniacean"] : throw FormatException('Missing required property')), + heroical: (json.containsKey("heroical") ? json["heroical"] : throw FormatException('Missing required property')), + hydropical: (json.containsKey("hydropical") ? json["hydropical"] : throw FormatException('Missing required property')), + mechanology: (json.containsKey("mechanology") ? json["mechanology"] : throw FormatException('Missing required property')), + musicopoetic: (json.containsKey("musicopoetic") ? json["musicopoetic"] : throw FormatException('Missing required property')), + officiality: (json.containsKey("officiality") ? json["officiality"] : throw FormatException('Missing required property')), + oftentimes: (json.containsKey("oftentimes") ? json["oftentimes"] : throw FormatException('Missing required property')), + ophthalmotonometer: (json.containsKey("ophthalmotonometer") ? json["ophthalmotonometer"] : throw FormatException('Missing required property')), + reflectively: (json.containsKey("reflectively") ? json["reflectively"] : throw FormatException('Missing required property')), + springer: (json.containsKey("springer") ? json["springer"] : throw FormatException('Missing required property')), + tabasco: (json.containsKey("Tabasco") ? json["Tabasco"] : throw FormatException('Missing required property')), + teleianthous: (json.containsKey("teleianthous") ? json["teleianthous"] : throw FormatException('Missing required property')), + uncombated: (json.containsKey("uncombated") ? json["uncombated"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "aeriferous": aeriferous, + "antical": antical, + "antighostism": antighostism, + "arcanum": arcanum, + "autotrophy": autotrophy, + "baronial": baronial, + "caffeine": caffeine, + "gorgoniacean": gorgoniacean, + "heroical": heroical, + "hydropical": hydropical, + "mechanology": mechanology, + "musicopoetic": musicopoetic, + "officiality": officiality, + "oftentimes": oftentimes, + "ophthalmotonometer": ophthalmotonometer, + "reflectively": reflectively, + "springer": springer, + "Tabasco": tabasco, + "teleianthous": teleianthous, + "uncombated": uncombated, + }; +} + +class SisteringClass { + final dynamic amphicarpic; + final dynamic chianti; + final dynamic frigorific; + final dynamic haplomi; + final dynamic hyperkinesis; + final dynamic laudable; + final dynamic madwoman; + final dynamic maimedly; + final dynamic micropterygidae; + final dynamic microrhabdus; + final dynamic nondense; + final dynamic phlebemphraxis; + final dynamic redsear; + final dynamic schismatical; + final dynamic tartryl; + final dynamic unabhorred; + final dynamic undeliberateness; + final dynamic unmixable; + final dynamic untruckling; + final dynamic vineal; + + SisteringClass({ + required this.amphicarpic, + required this.chianti, + required this.frigorific, + required this.haplomi, + required this.hyperkinesis, + required this.laudable, + required this.madwoman, + required this.maimedly, + required this.micropterygidae, + required this.microrhabdus, + required this.nondense, + required this.phlebemphraxis, + required this.redsear, + required this.schismatical, + required this.tartryl, + required this.unabhorred, + required this.undeliberateness, + required this.unmixable, + required this.untruckling, + required this.vineal, + }); + + factory SisteringClass.fromMap(Map json) => SisteringClass( + amphicarpic: (json.containsKey("amphicarpic") ? json["amphicarpic"] : throw FormatException('Missing required property')), + chianti: (json.containsKey("Chianti") ? json["Chianti"] : throw FormatException('Missing required property')), + frigorific: (json.containsKey("frigorific") ? json["frigorific"] : throw FormatException('Missing required property')), + haplomi: (json.containsKey("Haplomi") ? json["Haplomi"] : throw FormatException('Missing required property')), + hyperkinesis: (json.containsKey("hyperkinesis") ? json["hyperkinesis"] : throw FormatException('Missing required property')), + laudable: (json.containsKey("laudable") ? json["laudable"] : throw FormatException('Missing required property')), + madwoman: (json.containsKey("madwoman") ? json["madwoman"] : throw FormatException('Missing required property')), + maimedly: (json.containsKey("maimedly") ? json["maimedly"] : throw FormatException('Missing required property')), + micropterygidae: (json.containsKey("Micropterygidae") ? json["Micropterygidae"] : throw FormatException('Missing required property')), + microrhabdus: (json.containsKey("microrhabdus") ? json["microrhabdus"] : throw FormatException('Missing required property')), + nondense: (json.containsKey("nondense") ? json["nondense"] : throw FormatException('Missing required property')), + phlebemphraxis: (json.containsKey("phlebemphraxis") ? json["phlebemphraxis"] : throw FormatException('Missing required property')), + redsear: (json.containsKey("redsear") ? json["redsear"] : throw FormatException('Missing required property')), + schismatical: (json.containsKey("schismatical") ? json["schismatical"] : throw FormatException('Missing required property')), + tartryl: (json.containsKey("tartryl") ? json["tartryl"] : throw FormatException('Missing required property')), + unabhorred: (json.containsKey("unabhorred") ? json["unabhorred"] : throw FormatException('Missing required property')), + undeliberateness: (json.containsKey("undeliberateness") ? json["undeliberateness"] : throw FormatException('Missing required property')), + unmixable: (json.containsKey("unmixable") ? json["unmixable"] : throw FormatException('Missing required property')), + untruckling: (json.containsKey("untruckling") ? json["untruckling"] : throw FormatException('Missing required property')), + vineal: (json.containsKey("vineal") ? json["vineal"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "amphicarpic": amphicarpic, + "Chianti": chianti, + "frigorific": frigorific, + "Haplomi": haplomi, + "hyperkinesis": hyperkinesis, + "laudable": laudable, + "madwoman": madwoman, + "maimedly": maimedly, + "Micropterygidae": micropterygidae, + "microrhabdus": microrhabdus, + "nondense": nondense, + "phlebemphraxis": phlebemphraxis, + "redsear": redsear, + "schismatical": schismatical, + "tartryl": tartryl, + "unabhorred": unabhorred, + "undeliberateness": undeliberateness, + "unmixable": unmixable, + "untruckling": untruckling, + "vineal": vineal, + }; +} + +class Staghunting { + final int? calorimetric; + final int? canid; + final double? catharticalness; + final int? chirotherium; + final String? disdiapason; + final int? ditriglyphic; + final int? floriferousness; + final int? gamelike; + final int? grig; + final bool? homocerc; + final int? interloan; + final int? lithotomy; + final int? loric; + final int? membranocoriaceous; + final int? membranogenic; + final dynamic nonbookish; + final int? overtrump; + final int? scotino; + final int? seasonable; + final int? sephen; + final int? stigmarioid; + final int? tired; + final int? trifid; + final int? undefeatedly; + final int? ungirlish; + + Staghunting({ + this.calorimetric, + this.canid, + this.catharticalness, + this.chirotherium, + this.disdiapason, + this.ditriglyphic, + this.floriferousness, + this.gamelike, + this.grig, + this.homocerc, + this.interloan, + this.lithotomy, + this.loric, + this.membranocoriaceous, + this.membranogenic, + this.nonbookish, + this.overtrump, + this.scotino, + this.seasonable, + this.sephen, + this.stigmarioid, + this.tired, + this.trifid, + this.undefeatedly, + this.ungirlish, + }); + + factory Staghunting.fromMap(Map json) => Staghunting( + calorimetric: json["calorimetric"], + canid: json["canid"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + ditriglyphic: json["ditriglyphic"], + floriferousness: json["floriferousness"], + gamelike: json["gamelike"], + grig: json["grig"], + homocerc: json["homocerc"], + interloan: json["interloan"], + lithotomy: json["lithotomy"], + loric: json["loric"], + membranocoriaceous: json["membranocoriaceous"], + membranogenic: json["membranogenic"], + nonbookish: json["nonbookish"], + overtrump: json["overtrump"], + scotino: json["scotino"], + seasonable: json["seasonable"], + sephen: json["sephen"], + stigmarioid: json["stigmarioid"], + tired: json["tired"], + trifid: json["trifid"], + undefeatedly: json["undefeatedly"], + ungirlish: json["ungirlish"], + ); + + Map toMap() => { + "calorimetric": calorimetric, + "canid": canid, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "ditriglyphic": ditriglyphic, + "floriferousness": floriferousness, + "gamelike": gamelike, + "grig": grig, + "homocerc": homocerc, + "interloan": interloan, + "lithotomy": lithotomy, + "loric": loric, + "membranocoriaceous": membranocoriaceous, + "membranogenic": membranogenic, + "nonbookish": nonbookish, + "overtrump": overtrump, + "scotino": scotino, + "seasonable": seasonable, + "sephen": sephen, + "stigmarioid": stigmarioid, + "tired": tired, + "trifid": trifid, + "undefeatedly": undefeatedly, + "ungirlish": ungirlish, + }; +} + +class StrenuosityClass { + final int? bliss; + final int? buccate; + final int? bulletproof; + final double? catharticalness; + final int? chirotherium; + final int? crumblingness; + final String? disdiapason; + final int? engagedly; + final int? fightable; + final int? hoariness; + final bool? homocerc; + final int? hypopodium; + final int? luxurist; + final int? mechanician; + final dynamic nonbookish; + final int? onopordon; + final int? podgily; + final int? reformableness; + final int? scatterbrains; + final int? seminuria; + final int? sodomite; + final int? tramp; + final int? undueness; + final int? worthily; + final int? yankeeist; + + StrenuosityClass({ + this.bliss, + this.buccate, + this.bulletproof, + this.catharticalness, + this.chirotherium, + this.crumblingness, + this.disdiapason, + this.engagedly, + this.fightable, + this.hoariness, + this.homocerc, + this.hypopodium, + this.luxurist, + this.mechanician, + this.nonbookish, + this.onopordon, + this.podgily, + this.reformableness, + this.scatterbrains, + this.seminuria, + this.sodomite, + this.tramp, + this.undueness, + this.worthily, + this.yankeeist, + }); + + factory StrenuosityClass.fromMap(Map json) => StrenuosityClass( + bliss: json["bliss"], + buccate: json["buccate"], + bulletproof: json["bulletproof"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + crumblingness: json["crumblingness"], + disdiapason: json["disdiapason"], + engagedly: json["engagedly"], + fightable: json["fightable"], + hoariness: json["hoariness"], + homocerc: json["homocerc"], + hypopodium: json["hypopodium"], + luxurist: json["luxurist"], + mechanician: json["mechanician"], + nonbookish: json["nonbookish"], + onopordon: json["Onopordon"], + podgily: json["podgily"], + reformableness: json["reformableness"], + scatterbrains: json["scatterbrains"], + seminuria: json["seminuria"], + sodomite: json["Sodomite"], + tramp: json["tramp"], + undueness: json["undueness"], + worthily: json["worthily"], + yankeeist: json["Yankeeist"], + ); + + Map toMap() => { + "bliss": bliss, + "buccate": buccate, + "bulletproof": bulletproof, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "crumblingness": crumblingness, + "disdiapason": disdiapason, + "engagedly": engagedly, + "fightable": fightable, + "hoariness": hoariness, + "homocerc": homocerc, + "hypopodium": hypopodium, + "luxurist": luxurist, + "mechanician": mechanician, + "nonbookish": nonbookish, + "Onopordon": onopordon, + "podgily": podgily, + "reformableness": reformableness, + "scatterbrains": scatterbrains, + "seminuria": seminuria, + "Sodomite": sodomite, + "tramp": tramp, + "undueness": undueness, + "worthily": worthily, + "Yankeeist": yankeeist, + }; +} + +class TruantcyClass { + final dynamic alfiona; + final dynamic ascaridiasis; + final dynamic bungey; + final double? catharticalness; + final dynamic ceroxyle; + final int? chirotherium; + final dynamic chorology; + final String? disdiapason; + final dynamic enmarble; + final dynamic epeira; + final dynamic eurylaimi; + final dynamic germination; + final dynamic hallelujah; + final bool? homocerc; + final dynamic lev; + final dynamic mouthing; + final dynamic nonbookish; + final dynamic philliloo; + final dynamic planetal; + final dynamic poney; + final dynamic punctualist; + final dynamic returnlessly; + final dynamic skelder; + final dynamic windwaywardly; + final dynamic yuman; + + TruantcyClass({ + this.alfiona, + this.ascaridiasis, + this.bungey, + this.catharticalness, + this.ceroxyle, + this.chirotherium, + this.chorology, + this.disdiapason, + this.enmarble, + this.epeira, + this.eurylaimi, + this.germination, + this.hallelujah, + this.homocerc, + this.lev, + this.mouthing, + this.nonbookish, + this.philliloo, + this.planetal, + this.poney, + this.punctualist, + this.returnlessly, + this.skelder, + this.windwaywardly, + this.yuman, + }); + + factory TruantcyClass.fromMap(Map json) => TruantcyClass( + alfiona: json["alfiona"], + ascaridiasis: json["ascaridiasis"], + bungey: json["bungey"], + catharticalness: json["catharticalness"]?.toDouble(), + ceroxyle: json["ceroxyle"], + chirotherium: json["Chirotherium"], + chorology: json["chorology"], + disdiapason: json["disdiapason"], + enmarble: json["enmarble"], + epeira: json["Epeira"], + eurylaimi: json["Eurylaimi"], + germination: json["germination"], + hallelujah: json["hallelujah"], + homocerc: json["homocerc"], + lev: json["lev"], + mouthing: json["mouthing"], + nonbookish: json["nonbookish"], + philliloo: json["philliloo"], + planetal: json["planetal"], + poney: json["poney"], + punctualist: json["punctualist"], + returnlessly: json["returnlessly"], + skelder: json["skelder"], + windwaywardly: json["windwaywardly"], + yuman: json["Yuman"], + ); + + Map toMap() => { + "alfiona": alfiona, + "ascaridiasis": ascaridiasis, + "bungey": bungey, + "catharticalness": catharticalness, + "ceroxyle": ceroxyle, + "Chirotherium": chirotherium, + "chorology": chorology, + "disdiapason": disdiapason, + "enmarble": enmarble, + "Epeira": epeira, + "Eurylaimi": eurylaimi, + "germination": germination, + "hallelujah": hallelujah, + "homocerc": homocerc, + "lev": lev, + "mouthing": mouthing, + "nonbookish": nonbookish, + "philliloo": philliloo, + "planetal": planetal, + "poney": poney, + "punctualist": punctualist, + "returnlessly": returnlessly, + "skelder": skelder, + "windwaywardly": windwaywardly, + "Yuman": yuman, + }; +} + +class UnimpeachablyClass { + final int? acerin; + final int? bobadil; + final double? catharticalness; + final int? chirotherium; + final int? chlorophylligenous; + final int? conversational; + final int? demiowl; + final String? disdiapason; + final int? ectorhinal; + final int? gamblesomeness; + final bool? homocerc; + final int? irrorate; + final int? kindergartening; + final int? lateritic; + final int? mespil; + final int? misconfiguration; + final dynamic nonbookish; + final int? planometry; + final int? quiina; + final int? robert; + final int? rot; + final int? subcinctorium; + final int? tussocker; + final int? ultraproud; + final int? unsuggestedness; + + UnimpeachablyClass({ + this.acerin, + this.bobadil, + this.catharticalness, + this.chirotherium, + this.chlorophylligenous, + this.conversational, + this.demiowl, + this.disdiapason, + this.ectorhinal, + this.gamblesomeness, + this.homocerc, + this.irrorate, + this.kindergartening, + this.lateritic, + this.mespil, + this.misconfiguration, + this.nonbookish, + this.planometry, + this.quiina, + this.robert, + this.rot, + this.subcinctorium, + this.tussocker, + this.ultraproud, + this.unsuggestedness, + }); + + factory UnimpeachablyClass.fromMap(Map json) => UnimpeachablyClass( + acerin: json["acerin"], + bobadil: json["Bobadil"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + chlorophylligenous: json["chlorophylligenous"], + conversational: json["conversational"], + demiowl: json["demiowl"], + disdiapason: json["disdiapason"], + ectorhinal: json["ectorhinal"], + gamblesomeness: json["gamblesomeness"], + homocerc: json["homocerc"], + irrorate: json["irrorate"], + kindergartening: json["kindergartening"], + lateritic: json["lateritic"], + mespil: json["mespil"], + misconfiguration: json["misconfiguration"], + nonbookish: json["nonbookish"], + planometry: json["planometry"], + quiina: json["Quiina"], + robert: json["Robert"], + rot: json["rot"], + subcinctorium: json["subcinctorium"], + tussocker: json["tussocker"], + ultraproud: json["ultraproud"], + unsuggestedness: json["unsuggestedness"], + ); + + Map toMap() => { + "acerin": acerin, + "Bobadil": bobadil, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "chlorophylligenous": chlorophylligenous, + "conversational": conversational, + "demiowl": demiowl, + "disdiapason": disdiapason, + "ectorhinal": ectorhinal, + "gamblesomeness": gamblesomeness, + "homocerc": homocerc, + "irrorate": irrorate, + "kindergartening": kindergartening, + "lateritic": lateritic, + "mespil": mespil, + "misconfiguration": misconfiguration, + "nonbookish": nonbookish, + "planometry": planometry, + "Quiina": quiina, + "Robert": robert, + "rot": rot, + "subcinctorium": subcinctorium, + "tussocker": tussocker, + "ultraproud": ultraproud, + "unsuggestedness": unsuggestedness, + }; +} + +class UnstressedClass { + final dynamic alain; + final dynamic amphirhina; + final dynamic antimachinery; + final dynamic coldish; + final dynamic crantara; + final dynamic distinguishing; + final dynamic elytroposis; + final dynamic gentianwort; + final dynamic heliosis; + final dynamic instrumental; + final dynamic introinflection; + final dynamic kala; + final dynamic lincolnian; + final dynamic metad; + final dynamic sarcophilus; + final dynamic swingingly; + final dynamic unconformity; + final dynamic undecreed; + final dynamic venerable; + final dynamic vowellessness; + + UnstressedClass({ + required this.alain, + required this.amphirhina, + required this.antimachinery, + required this.coldish, + required this.crantara, + required this.distinguishing, + required this.elytroposis, + required this.gentianwort, + required this.heliosis, + required this.instrumental, + required this.introinflection, + required this.kala, + required this.lincolnian, + required this.metad, + required this.sarcophilus, + required this.swingingly, + required this.unconformity, + required this.undecreed, + required this.venerable, + required this.vowellessness, + }); + + factory UnstressedClass.fromMap(Map json) => UnstressedClass( + alain: (json.containsKey("Alain") ? json["Alain"] : throw FormatException('Missing required property')), + amphirhina: (json.containsKey("Amphirhina") ? json["Amphirhina"] : throw FormatException('Missing required property')), + antimachinery: (json.containsKey("antimachinery") ? json["antimachinery"] : throw FormatException('Missing required property')), + coldish: (json.containsKey("coldish") ? json["coldish"] : throw FormatException('Missing required property')), + crantara: (json.containsKey("crantara") ? json["crantara"] : throw FormatException('Missing required property')), + distinguishing: (json.containsKey("distinguishing") ? json["distinguishing"] : throw FormatException('Missing required property')), + elytroposis: (json.containsKey("elytroposis") ? json["elytroposis"] : throw FormatException('Missing required property')), + gentianwort: (json.containsKey("gentianwort") ? json["gentianwort"] : throw FormatException('Missing required property')), + heliosis: (json.containsKey("heliosis") ? json["heliosis"] : throw FormatException('Missing required property')), + instrumental: (json.containsKey("instrumental") ? json["instrumental"] : throw FormatException('Missing required property')), + introinflection: (json.containsKey("introinflection") ? json["introinflection"] : throw FormatException('Missing required property')), + kala: (json.containsKey("kala") ? json["kala"] : throw FormatException('Missing required property')), + lincolnian: (json.containsKey("Lincolnian") ? json["Lincolnian"] : throw FormatException('Missing required property')), + metad: (json.containsKey("metad") ? json["metad"] : throw FormatException('Missing required property')), + sarcophilus: (json.containsKey("Sarcophilus") ? json["Sarcophilus"] : throw FormatException('Missing required property')), + swingingly: (json.containsKey("swingingly") ? json["swingingly"] : throw FormatException('Missing required property')), + unconformity: (json.containsKey("unconformity") ? json["unconformity"] : throw FormatException('Missing required property')), + undecreed: (json.containsKey("undecreed") ? json["undecreed"] : throw FormatException('Missing required property')), + venerable: (json.containsKey("venerable") ? json["venerable"] : throw FormatException('Missing required property')), + vowellessness: (json.containsKey("vowellessness") ? json["vowellessness"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "Alain": alain, + "Amphirhina": amphirhina, + "antimachinery": antimachinery, + "coldish": coldish, + "crantara": crantara, + "distinguishing": distinguishing, + "elytroposis": elytroposis, + "gentianwort": gentianwort, + "heliosis": heliosis, + "instrumental": instrumental, + "introinflection": introinflection, + "kala": kala, + "Lincolnian": lincolnian, + "metad": metad, + "Sarcophilus": sarcophilus, + "swingingly": swingingly, + "unconformity": unconformity, + "undecreed": undecreed, + "venerable": venerable, + "vowellessness": vowellessness, + }; +} + +class WrothyClass { + final dynamic aeschynanthus; + final dynamic aquiferous; + final dynamic cheapener; + final dynamic enumeration; + final dynamic ephesine; + final dynamic escadrille; + final dynamic estrous; + final dynamic interestedly; + final dynamic katakinetomer; + final dynamic mortification; + final dynamic morula; + final dynamic orthosymmetrical; + final dynamic overbark; + final dynamic politist; + final dynamic qualified; + final dynamic sphenomalar; + final dynamic throatful; + final dynamic transhumance; + final dynamic triandrian; + final dynamic unbooked; + + WrothyClass({ + required this.aeschynanthus, + required this.aquiferous, + required this.cheapener, + required this.enumeration, + required this.ephesine, + required this.escadrille, + required this.estrous, + required this.interestedly, + required this.katakinetomer, + required this.mortification, + required this.morula, + required this.orthosymmetrical, + required this.overbark, + required this.politist, + required this.qualified, + required this.sphenomalar, + required this.throatful, + required this.transhumance, + required this.triandrian, + required this.unbooked, + }); + + factory WrothyClass.fromMap(Map json) => WrothyClass( + aeschynanthus: (json.containsKey("Aeschynanthus") ? json["Aeschynanthus"] : throw FormatException('Missing required property')), + aquiferous: (json.containsKey("aquiferous") ? json["aquiferous"] : throw FormatException('Missing required property')), + cheapener: (json.containsKey("cheapener") ? json["cheapener"] : throw FormatException('Missing required property')), + enumeration: (json.containsKey("enumeration") ? json["enumeration"] : throw FormatException('Missing required property')), + ephesine: (json.containsKey("Ephesine") ? json["Ephesine"] : throw FormatException('Missing required property')), + escadrille: (json.containsKey("escadrille") ? json["escadrille"] : throw FormatException('Missing required property')), + estrous: (json.containsKey("estrous") ? json["estrous"] : throw FormatException('Missing required property')), + interestedly: (json.containsKey("interestedly") ? json["interestedly"] : throw FormatException('Missing required property')), + katakinetomer: (json.containsKey("katakinetomer") ? json["katakinetomer"] : throw FormatException('Missing required property')), + mortification: (json.containsKey("mortification") ? json["mortification"] : throw FormatException('Missing required property')), + morula: (json.containsKey("morula") ? json["morula"] : throw FormatException('Missing required property')), + orthosymmetrical: (json.containsKey("orthosymmetrical") ? json["orthosymmetrical"] : throw FormatException('Missing required property')), + overbark: (json.containsKey("overbark") ? json["overbark"] : throw FormatException('Missing required property')), + politist: (json.containsKey("politist") ? json["politist"] : throw FormatException('Missing required property')), + qualified: (json.containsKey("qualified") ? json["qualified"] : throw FormatException('Missing required property')), + sphenomalar: (json.containsKey("sphenomalar") ? json["sphenomalar"] : throw FormatException('Missing required property')), + throatful: (json.containsKey("throatful") ? json["throatful"] : throw FormatException('Missing required property')), + transhumance: (json.containsKey("transhumance") ? json["transhumance"] : throw FormatException('Missing required property')), + triandrian: (json.containsKey("triandrian") ? json["triandrian"] : throw FormatException('Missing required property')), + unbooked: (json.containsKey("unbooked") ? json["unbooked"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "Aeschynanthus": aeschynanthus, + "aquiferous": aquiferous, + "cheapener": cheapener, + "enumeration": enumeration, + "Ephesine": ephesine, + "escadrille": escadrille, + "estrous": estrous, + "interestedly": interestedly, + "katakinetomer": katakinetomer, + "mortification": mortification, + "morula": morula, + "orthosymmetrical": orthosymmetrical, + "overbark": overbark, + "politist": politist, + "qualified": qualified, + "sphenomalar": sphenomalar, + "throatful": throatful, + "transhumance": transhumance, + "triandrian": triandrian, + "unbooked": unbooked, + }; +} diff --git a/base/dart/test/inputs/json/priority/keywords.json/default/TopLevel.dart b/head/dart/test/inputs/json/priority/keywords.json/default/TopLevel.dart index e011b3d..5d004bc 100644 --- a/base/dart/test/inputs/json/priority/keywords.json/default/TopLevel.dart +++ b/head/dart/test/inputs/json/priority/keywords.json/default/TopLevel.dart @@ -4024,6 +4024,7 @@ class Obj4 { final Retain retain; final Rethrows rethrows; final Right right; + final S s; final Sbyte sbyte; final Sealed sealed; final Sel sel; @@ -4091,6 +4092,7 @@ class Obj4 { required this.retain, required this.rethrows, required this.right, + required this.s, required this.sbyte, required this.sealed, required this.sel, @@ -4159,6 +4161,7 @@ class Obj4 { retain: Retain.fromJson(json["retain"]), rethrows: Rethrows.fromJson(json["rethrows"]), right: Right.fromJson(json["right"]), + s: S.fromJson(json["s"]), sbyte: Sbyte.fromJson(json["sbyte"]), sealed: Sealed.fromJson(json["sealed"]), sel: Sel.fromJson(json["SEL"]), @@ -4227,6 +4230,7 @@ class Obj4 { "retain": retain.toJson(), "rethrows": rethrows.toJson(), "right": right.toJson(), + "s": s.toJson(), "sbyte": sbyte.toJson(), "sealed": sealed.toJson(), "SEL": sel.toJson(), @@ -4744,6 +4748,22 @@ class Right { }; } +class S { + final int s; + + S({ + required this.s, + }); + + factory S.fromJson(Map json) => S( + s: json["s"], + ); + + Map toJson() => { + "s": s, + }; +} + class Sbyte { final int sbyte; diff --git a/base/elixir/test/inputs/json/priority/keywords.json/default/QuickType.ex b/head/elixir/test/inputs/json/priority/keywords.json/default/QuickType.ex index d651b3f..1947dee 100644 --- a/base/elixir/test/inputs/json/priority/keywords.json/default/QuickType.ex +++ b/head/elixir/test/inputs/json/priority/keywords.json/default/QuickType.ex @@ -9092,6 +9092,45 @@ defmodule Right do end end +defmodule S do + @enforce_keys [:s] + defstruct [:s] + + @type t :: %__MODULE__{ + s: integer() + } + + def decode_s(value) when is_integer(value), do: value + def decode_s(_), do: {:error, "Unexpected type when decoding S.s"} + + def encode_s(value) when is_integer(value), do: value + def encode_s(_), do: {:error, "Unexpected type when encoding S.s"} + + def from_map(m) do + %S{ + s: decode_s(m["s"]), + } + end + + def from_json(json) do + json + |> Jason.decode!() + |> from_map() + end + + def to_map(struct) do + %{ + "s" => struct.s, + } + end + + def to_json(struct) do + struct + |> to_map() + |> Jason.encode!() + end +end + defmodule Sbyte do @enforce_keys [:sbyte] defstruct [:sbyte] @@ -10809,8 +10848,8 @@ defmodule Undefined do end defmodule Obj4 do - @enforce_keys [:dummy, :obj4_self, :obj4_true, :obj4_type, :public, :quicktype, :raise, :range, :readonly, :ref, :register, :reinterpret_cast, :repeat, :require, :required, :requires, :restrict, :retain, :rethrows, :return, :right, :sbyte, :sealed, :sel, :select, :self, :serialize, :set, :short, :signed, :sizeof, :stackalloc, :static, :static_assert, :static_cast, :strictfp, :string, :struct, :subscript, :super, :switch, :symbol, :synchronized, :system, :template, :then, :this, :thread_local, :throw, :throws, :to_json, :top_level, :transient, :true_1, :try, :type, :typealias, :typedef, :typeid, :typename, :typeof, :uint, :ulong, :unchecked, :undefined] - defstruct [:dummy, :obj4_self, :obj4_true, :obj4_type, :public, :quicktype, :raise, :range, :readonly, :ref, :register, :reinterpret_cast, :repeat, :require, :required, :requires, :restrict, :retain, :rethrows, :return, :right, :sbyte, :sealed, :sel, :select, :self, :serialize, :set, :short, :signed, :sizeof, :stackalloc, :static, :static_assert, :static_cast, :strictfp, :string, :struct, :subscript, :super, :switch, :symbol, :synchronized, :system, :template, :then, :this, :thread_local, :throw, :throws, :to_json, :top_level, :transient, :true_1, :try, :type, :typealias, :typedef, :typeid, :typename, :typeof, :uint, :ulong, :unchecked, :undefined] + @enforce_keys [:dummy, :obj4_self, :obj4_true, :obj4_type, :public, :quicktype, :raise, :range, :readonly, :ref, :register, :reinterpret_cast, :repeat, :require, :required, :requires, :restrict, :retain, :rethrows, :return, :right, :s, :sbyte, :sealed, :sel, :select, :self, :serialize, :set, :short, :signed, :sizeof, :stackalloc, :static, :static_assert, :static_cast, :strictfp, :string, :struct, :subscript, :super, :switch, :symbol, :synchronized, :system, :template, :then, :this, :thread_local, :throw, :throws, :to_json, :top_level, :transient, :true_1, :try, :type, :typealias, :typedef, :typeid, :typename, :typeof, :uint, :ulong, :unchecked, :undefined] + defstruct [:dummy, :obj4_self, :obj4_true, :obj4_type, :public, :quicktype, :raise, :range, :readonly, :ref, :register, :reinterpret_cast, :repeat, :require, :required, :requires, :restrict, :retain, :rethrows, :return, :right, :s, :sbyte, :sealed, :sel, :select, :self, :serialize, :set, :short, :signed, :sizeof, :stackalloc, :static, :static_assert, :static_cast, :strictfp, :string, :struct, :subscript, :super, :switch, :symbol, :synchronized, :system, :template, :then, :this, :thread_local, :throw, :throws, :to_json, :top_level, :transient, :true_1, :try, :type, :typealias, :typedef, :typeid, :typename, :typeof, :uint, :ulong, :unchecked, :undefined] @type t :: %__MODULE__{ dummy: integer(), @@ -10834,6 +10873,7 @@ defmodule Obj4 do rethrows: Rethrows.t(), return: Return.t(), right: Right.t(), + s: S.t(), sbyte: Sbyte.t(), sealed: Sealed.t(), sel: Sel.t(), @@ -10909,6 +10949,7 @@ defmodule Obj4 do rethrows: Rethrows.from_map(m["rethrows"]), return: Return.from_map(m["return"]), right: Right.from_map(m["right"]), + s: S.from_map(m["s"]), sbyte: Sbyte.from_map(m["sbyte"]), sealed: Sealed.from_map(m["sealed"]), sel: Sel.from_map(m["SEL"]), @@ -10985,6 +11026,7 @@ defmodule Obj4 do "rethrows" => Rethrows.to_map(struct.rethrows), "return" => Return.to_map(struct.return), "right" => Right.to_map(struct.right), + "s" => S.to_map(struct.s), "sbyte" => Sbyte.to_map(struct.sbyte), "sealed" => Sealed.to_map(struct.sealed), "SEL" => Sel.to_map(struct.sel), diff --git a/base/elm/test/inputs/json/priority/keywords.json/default/QuickType.elm b/head/elm/test/inputs/json/priority/keywords.json/default/QuickType.elm index 77707ee..7df6f5d 100644 --- a/base/elm/test/inputs/json/priority/keywords.json/default/QuickType.elm +++ b/head/elm/test/inputs/json/priority/keywords.json/default/QuickType.elm @@ -237,6 +237,7 @@ module QuickType exposing , Rethrows , Return , Right + , S , Sbyte , Sealed , Sel @@ -1327,6 +1328,7 @@ type alias Obj4 = , rethrows : Rethrows , return : Return , right : Right + , s : S , sbyte : Sbyte , sealed : Sealed , sel : Sel @@ -1462,6 +1464,10 @@ type alias Right = { right : Int } +type alias S = + { s : Int + } + type alias Sbyte = { sbyte : Int } @@ -4357,6 +4363,7 @@ obj4 = |> Jpipe.required "rethrows" rethrows |> Jpipe.required "return" return |> Jpipe.required "right" right + |> Jpipe.required "s" s |> Jpipe.required "sbyte" sbyte |> Jpipe.required "sealed" sealed |> Jpipe.required "SEL" sel @@ -4426,6 +4433,7 @@ encodeObj4 x = , ("rethrows", encodeRethrows x.rethrows) , ("return", encodeReturn x.return) , ("right", encodeRight x.right) + , ("s", encodeS x.s) , ("sbyte", encodeSbyte x.sbyte) , ("sealed", encodeSealed x.sealed) , ("SEL", encodeSel x.sel) @@ -4722,6 +4730,17 @@ encodeRight x = [ ("right", Jenc.int x.right) ] +s : Jdec.Decoder S +s = + Jdec.succeed S + |> Jpipe.required "s" Jdec.int + +encodeS : S -> Jenc.Value +encodeS x = + Jenc.object + [ ("s", Jenc.int x.s) + ] + sbyte : Jdec.Decoder Sbyte sbyte = Jdec.succeed Sbyte diff --git a/base/flow/test/inputs/json/priority/keywords.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/keywords.json/default/TopLevel.js index fcb98df..276a37b 100644 --- a/base/flow/test/inputs/json/priority/keywords.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/keywords.json/default/TopLevel.js @@ -1028,6 +1028,7 @@ export type Obj4 = { rethrows: Rethrows; return: Return; right: Right; + s: S; sbyte: Sbyte; sealed: Sealed; select: Select; @@ -1157,6 +1158,10 @@ export type Right = { right: number; }; +export type S = { + s: number; +}; + export type Sbyte = { sbyte: number; }; @@ -2438,6 +2443,7 @@ const typeMap: any = { { json: "rethrows", js: "rethrows", typ: r("Rethrows") }, { json: "return", js: "return", typ: r("Return") }, { json: "right", js: "right", typ: r("Right") }, + { json: "s", js: "s", typ: r("S") }, { json: "sbyte", js: "sbyte", typ: r("Sbyte") }, { json: "sealed", js: "sealed", typ: r("Sealed") }, { json: "select", js: "select", typ: r("Select") }, @@ -2545,6 +2551,9 @@ const typeMap: any = { "Right": o([ { json: "right", js: "right", typ: i(0) }, ], false), + "S": o([ + { json: "s", js: "s", typ: i(0) }, + ], false), "Sbyte": o([ { json: "sbyte", js: "sbyte", typ: i(0) }, ], false), diff --git a/base/golang/test/inputs/json/priority/keywords.json/default/quicktype.go b/head/golang/test/inputs/json/priority/keywords.json/default/quicktype.go index 500118c..260e9db 100644 --- a/base/golang/test/inputs/json/priority/keywords.json/default/quicktype.go +++ b/head/golang/test/inputs/json/priority/keywords.json/default/quicktype.go @@ -1036,6 +1036,7 @@ type Obj4 struct { Rethrows Rethrows `json:"rethrows"` Return Return `json:"return"` Right Right `json:"right"` + S S `json:"s"` Sbyte Sbyte `json:"sbyte"` Sealed Sealed `json:"sealed"` Sel Sel `json:"SEL"` @@ -1162,6 +1163,10 @@ type Right struct { Right int64 `json:"right"` } +type S struct { + S int64 `json:"s"` +} + type Sbyte struct { Sbyte int64 `json:"sbyte"` } diff --git a/base/haskell/test/inputs/json/priority/keywords.json/default/QuickType.hs b/head/haskell/test/inputs/json/priority/keywords.json/default/QuickType.hs index c0a99ee..7c9af54 100644 --- a/base/haskell/test/inputs/json/priority/keywords.json/default/QuickType.hs +++ b/head/haskell/test/inputs/json/priority/keywords.json/default/QuickType.hs @@ -224,6 +224,7 @@ module QuickType , Rethrows (..) , Return (..) , RightClass (..) + , S (..) , Sbyte (..) , Sealed (..) , Sel (..) @@ -1316,6 +1317,7 @@ data Obj4 = Obj4 , rethrowsObj4 :: Rethrows , returnObj4 :: Return , rightObj4 :: RightClass + , sObj4 :: S , sbyteObj4 :: Sbyte , sealedObj4 :: Sealed , selObj4 :: Sel @@ -1448,6 +1450,10 @@ data RightClass = RightClass { rightRightClass :: Int } deriving (Show) +data S = S + { sS :: Int + } deriving (Show) + data Sbyte = Sbyte { sbyteSbyte :: Int } deriving (Show) @@ -4114,7 +4120,7 @@ instance FromJSON Protocol where <$> v .: "Protocol" instance ToJSON Obj4 where - toJSON (Obj4 dummyObj4 obj4SelfObj4 obj4ThenObj4 obj4TrueObj4 obj4TypeObj4 publicObj4 purpleTypeObj4 quicktypeObj4 raiseObj4 rangeObj4 readonlyObj4 refObj4 registerObj4 reinterpretCastObj4 repeatObj4 requireObj4 requiredObj4 requiresObj4 restrictObj4 retainObj4 rethrowsObj4 returnObj4 rightObj4 sbyteObj4 sealedObj4 selObj4 selectObj4 selfObj4 serializeObj4 setObj4 shortObj4 signedObj4 sizeofObj4 stackallocObj4 staticObj4 staticAssertObj4 staticCastObj4 strictfpObj4 stringObj4 structObj4 subscriptObj4 superObj4 switchObj4 symbolObj4 synchronizedObj4 systemObj4 templateObj4 thisObj4 threadLocalObj4 throwObj4 throwsObj4 toJSONObj4 topLevelObj4 transientObj4 trueObj4 tryObj4 typealiasObj4 typedefObj4 typeidObj4 typenameObj4 typeofObj4 uintObj4 ulongObj4 uncheckedObj4 undefinedObj4) = + toJSON (Obj4 dummyObj4 obj4SelfObj4 obj4ThenObj4 obj4TrueObj4 obj4TypeObj4 publicObj4 purpleTypeObj4 quicktypeObj4 raiseObj4 rangeObj4 readonlyObj4 refObj4 registerObj4 reinterpretCastObj4 repeatObj4 requireObj4 requiredObj4 requiresObj4 restrictObj4 retainObj4 rethrowsObj4 returnObj4 rightObj4 sObj4 sbyteObj4 sealedObj4 selObj4 selectObj4 selfObj4 serializeObj4 setObj4 shortObj4 signedObj4 sizeofObj4 stackallocObj4 staticObj4 staticAssertObj4 staticCastObj4 strictfpObj4 stringObj4 structObj4 subscriptObj4 superObj4 switchObj4 symbolObj4 synchronizedObj4 systemObj4 templateObj4 thisObj4 threadLocalObj4 throwObj4 throwsObj4 toJSONObj4 topLevelObj4 transientObj4 trueObj4 tryObj4 typealiasObj4 typedefObj4 typeidObj4 typenameObj4 typeofObj4 uintObj4 ulongObj4 uncheckedObj4 undefinedObj4) = object [ "dummy" .= dummyObj4 , "self" .= obj4SelfObj4 @@ -4139,6 +4145,7 @@ instance ToJSON Obj4 where , "rethrows" .= rethrowsObj4 , "return" .= returnObj4 , "right" .= rightObj4 + , "s" .= sObj4 , "sbyte" .= sbyteObj4 , "sealed" .= sealedObj4 , "SEL" .= selObj4 @@ -4208,6 +4215,7 @@ instance FromJSON Obj4 where <*> v .: "rethrows" <*> v .: "return" <*> v .: "right" + <*> v .: "s" <*> v .: "sbyte" <*> v .: "sealed" <*> v .: "SEL" @@ -4471,6 +4479,16 @@ instance FromJSON RightClass where parseJSON (Object v) = RightClass <$> v .: "right" +instance ToJSON S where + toJSON (S sS) = + object + [ "s" .= sS + ] + +instance FromJSON S where + parseJSON (Object v) = S + <$> v .: "s" + instance ToJSON Sbyte where toJSON (Sbyte sbyteSbyte) = object diff --git a/base/java/test/inputs/json/priority/keywords.json/default/src/main/java/io/quicktype/Obj4.java b/head/java/test/inputs/json/priority/keywords.json/default/src/main/java/io/quicktype/Obj4.java index fb5fed6..d8860f6 100644 --- a/base/java/test/inputs/json/priority/keywords.json/default/src/main/java/io/quicktype/Obj4.java +++ b/head/java/test/inputs/json/priority/keywords.json/default/src/main/java/io/quicktype/Obj4.java @@ -36,6 +36,7 @@ public class Obj4 { private Retain retain; private Rethrows rethrows; private Right right; + private S s; private Sbyte sbyte; private Sealed sealed; private Sel sel; @@ -234,6 +235,11 @@ public class Obj4 { @JsonProperty("right") public void setRight(Right value) { this.right = value; } + @JsonProperty("s") + public S getS() { return s; } + @JsonProperty("s") + public void setS(S value) { this.s = value; } + @JsonProperty("sbyte") public Sbyte getSbyte() { return sbyte; } @JsonProperty("sbyte") diff --git a/head/java/test/inputs/json/priority/keywords.json/default/src/main/java/io/quicktype/S.java b/head/java/test/inputs/json/priority/keywords.json/default/src/main/java/io/quicktype/S.java new file mode 100644 index 0000000..d949cd5 --- /dev/null +++ b/head/java/test/inputs/json/priority/keywords.json/default/src/main/java/io/quicktype/S.java @@ -0,0 +1,12 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; + +public class S { + private long s; + + @JsonProperty("s") + public long getS() { return s; } + @JsonProperty("s") + public void setS(long value) { this.s = value; } +} diff --git a/base/java-datetime-legacy/test/inputs/json/priority/keywords.json/default/src/main/java/io/quicktype/Obj4.java b/head/java-datetime-legacy/test/inputs/json/priority/keywords.json/default/src/main/java/io/quicktype/Obj4.java index fb5fed6..d8860f6 100644 --- a/base/java-datetime-legacy/test/inputs/json/priority/keywords.json/default/src/main/java/io/quicktype/Obj4.java +++ b/head/java-datetime-legacy/test/inputs/json/priority/keywords.json/default/src/main/java/io/quicktype/Obj4.java @@ -36,6 +36,7 @@ public class Obj4 { private Retain retain; private Rethrows rethrows; private Right right; + private S s; private Sbyte sbyte; private Sealed sealed; private Sel sel; @@ -234,6 +235,11 @@ public class Obj4 { @JsonProperty("right") public void setRight(Right value) { this.right = value; } + @JsonProperty("s") + public S getS() { return s; } + @JsonProperty("s") + public void setS(S value) { this.s = value; } + @JsonProperty("sbyte") public Sbyte getSbyte() { return sbyte; } @JsonProperty("sbyte") diff --git a/head/java-datetime-legacy/test/inputs/json/priority/keywords.json/default/src/main/java/io/quicktype/S.java b/head/java-datetime-legacy/test/inputs/json/priority/keywords.json/default/src/main/java/io/quicktype/S.java new file mode 100644 index 0000000..d949cd5 --- /dev/null +++ b/head/java-datetime-legacy/test/inputs/json/priority/keywords.json/default/src/main/java/io/quicktype/S.java @@ -0,0 +1,12 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; + +public class S { + private long s; + + @JsonProperty("s") + public long getS() { return s; } + @JsonProperty("s") + public void setS(long value) { this.s = value; } +} diff --git a/base/java-lombok/test/inputs/json/priority/keywords.json/default/src/main/java/io/quicktype/Obj4.java b/head/java-lombok/test/inputs/json/priority/keywords.json/default/src/main/java/io/quicktype/Obj4.java index fb5fed6..d8860f6 100644 --- a/base/java-lombok/test/inputs/json/priority/keywords.json/default/src/main/java/io/quicktype/Obj4.java +++ b/head/java-lombok/test/inputs/json/priority/keywords.json/default/src/main/java/io/quicktype/Obj4.java @@ -36,6 +36,7 @@ public class Obj4 { private Retain retain; private Rethrows rethrows; private Right right; + private S s; private Sbyte sbyte; private Sealed sealed; private Sel sel; @@ -234,6 +235,11 @@ public class Obj4 { @JsonProperty("right") public void setRight(Right value) { this.right = value; } + @JsonProperty("s") + public S getS() { return s; } + @JsonProperty("s") + public void setS(S value) { this.s = value; } + @JsonProperty("sbyte") public Sbyte getSbyte() { return sbyte; } @JsonProperty("sbyte") diff --git a/head/java-lombok/test/inputs/json/priority/keywords.json/default/src/main/java/io/quicktype/S.java b/head/java-lombok/test/inputs/json/priority/keywords.json/default/src/main/java/io/quicktype/S.java new file mode 100644 index 0000000..d949cd5 --- /dev/null +++ b/head/java-lombok/test/inputs/json/priority/keywords.json/default/src/main/java/io/quicktype/S.java @@ -0,0 +1,12 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; + +public class S { + private long s; + + @JsonProperty("s") + public long getS() { return s; } + @JsonProperty("s") + public void setS(long value) { this.s = value; } +} diff --git a/base/javascript/test/inputs/json/priority/keywords.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/keywords.json/default/TopLevel.js index a07148f..cbfaf42 100644 --- a/base/javascript/test/inputs/json/priority/keywords.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/keywords.json/default/TopLevel.js @@ -1012,6 +1012,7 @@ const typeMap = { { json: "rethrows", js: "rethrows", typ: r("Rethrows") }, { json: "return", js: "return", typ: r("Return") }, { json: "right", js: "right", typ: r("Right") }, + { json: "s", js: "s", typ: r("S") }, { json: "sbyte", js: "sbyte", typ: r("Sbyte") }, { json: "sealed", js: "sealed", typ: r("Sealed") }, { json: "select", js: "select", typ: r("Select") }, @@ -1119,6 +1120,9 @@ const typeMap = { "Right": o([ { json: "right", js: "right", typ: i(0) }, ], false), + "S": o([ + { json: "s", js: "s", typ: i(0) }, + ], false), "Sbyte": o([ { json: "sbyte", js: "sbyte", typ: i(0) }, ], false), diff --git a/base/javascript-prop-types/test/inputs/json/priority/keywords.json/default/toplevel.js b/head/javascript-prop-types/test/inputs/json/priority/keywords.json/default/toplevel.js index f20178d..e00479f 100644 --- a/base/javascript-prop-types/test/inputs/json/priority/keywords.json/default/toplevel.js +++ b/head/javascript-prop-types/test/inputs/json/priority/keywords.json/default/toplevel.js @@ -234,6 +234,7 @@ let _Retain; let _Rethrows; let _Return; let _Right; +let _S; let _Sbyte; let _Sealed; let _Select; @@ -1150,6 +1151,9 @@ _Return = PropTypes.shape({ _Right = PropTypes.shape({ "right": PropTypes.oneOfType([Integer]).isRequired, }); +_S = PropTypes.shape({ + "s": PropTypes.oneOfType([Integer]).isRequired, +}); _Sbyte = PropTypes.shape({ "sbyte": PropTypes.oneOfType([Integer]).isRequired, }); @@ -1302,6 +1306,7 @@ _Obj4 = PropTypes.shape({ "rethrows": _Rethrows, "return": _Return, "right": _Right, + "s": _S, "sbyte": _Sbyte, "sealed": _Sealed, "select": _Select, diff --git a/base/kotlin/test/inputs/json/priority/keywords.json/default/TopLevel.kt b/head/kotlin/test/inputs/json/priority/keywords.json/default/TopLevel.kt index c059c6f..250ed16 100644 --- a/base/kotlin/test/inputs/json/priority/keywords.json/default/TopLevel.kt +++ b/head/kotlin/test/inputs/json/priority/keywords.json/default/TopLevel.kt @@ -1247,6 +1247,7 @@ data class Obj4 ( val retain: Retain, val rethrows: Rethrows, val right: Right, + val s: S, val sbyte: Sbyte, val sealed: Sealed, @@ -1426,6 +1427,10 @@ data class Right ( val right: Long ) +data class S ( + val s: Long +) + data class Sbyte ( val sbyte: Long ) diff --git a/base/kotlin-jackson/test/inputs/json/priority/keywords.json/default/TopLevel.kt b/head/kotlin-jackson/test/inputs/json/priority/keywords.json/default/TopLevel.kt index ab3695c..d41f7a7 100644 --- a/base/kotlin-jackson/test/inputs/json/priority/keywords.json/default/TopLevel.kt +++ b/head/kotlin-jackson/test/inputs/json/priority/keywords.json/default/TopLevel.kt @@ -1705,6 +1705,9 @@ data class Obj4 ( @get:JsonProperty(required=true)@field:JsonProperty(required=true) val right: Right, + @get:JsonProperty(required=true)@field:JsonProperty(required=true) + val s: S, + @get:JsonProperty(required=true)@field:JsonProperty(required=true) val sbyte: Sbyte, @@ -1952,6 +1955,11 @@ data class Right ( val right: Long ) +data class S ( + @get:JsonProperty(required=true)@field:JsonProperty(required=true) + val s: Long +) + data class Sbyte ( @get:JsonProperty(required=true)@field:JsonProperty(required=true) val sbyte: Long diff --git a/base/kotlinx/test/inputs/json/priority/keywords.json/default/TopLevel.kt b/head/kotlinx/test/inputs/json/priority/keywords.json/default/TopLevel.kt index 0c822b1..c0ac134 100644 --- a/base/kotlinx/test/inputs/json/priority/keywords.json/default/TopLevel.kt +++ b/head/kotlinx/test/inputs/json/priority/keywords.json/default/TopLevel.kt @@ -1443,6 +1443,7 @@ data class Obj4 ( val retain: Retain, val rethrows: Rethrows, val right: Right, + val s: S, val sbyte: Sbyte, val sealed: Sealed, @@ -1649,6 +1650,11 @@ data class Right ( val right: Long ) +@Serializable +data class S ( + val s: Long +) + @Serializable data class Sbyte ( val sbyte: Long diff --git a/base/objective-c/test/inputs/json/priority/keywords.json/default/QTTopLevel.h b/head/objective-c/test/inputs/json/priority/keywords.json/default/QTTopLevel.h index cba566c..9c4b79d 100644 --- a/base/objective-c/test/inputs/json/priority/keywords.json/default/QTTopLevel.h +++ b/head/objective-c/test/inputs/json/priority/keywords.json/default/QTTopLevel.h @@ -233,6 +233,7 @@ @class QTRequires; @class QTRethrows; @class QTRight; +@class QTS; @class QTSbyte; @class QTSealed; @class QTSel; @@ -1333,6 +1334,7 @@ NSString *_Nullable QTTopLevelToJSON(QTTopLevel *topLevel, NSStringEncoding en @property (nonatomic, strong) QTRequires *requires; @property (nonatomic, strong) QTRethrows *rethrows; @property (nonatomic, strong) QTRight *right; +@property (nonatomic, strong) QTS *s; @property (nonatomic, strong) QTSbyte *sbyte; @property (nonatomic, strong) QTSealed *sealed; @property (nonatomic, strong) QTSel *sel; @@ -1483,6 +1485,10 @@ NSString *_Nullable QTTopLevelToJSON(QTTopLevel *topLevel, NSStringEncoding en @property (nonatomic, assign) NSInteger right; @end +@interface QTS : NSObject +@property (nonatomic, assign) NSInteger s; +@end + @interface QTSbyte : NSObject @property (nonatomic, assign) NSInteger sbyte; @end diff --git a/base/objective-c/test/inputs/json/priority/keywords.json/default/QTTopLevel.m b/head/objective-c/test/inputs/json/priority/keywords.json/default/QTTopLevel.m index 9c3d8bf..4e4d813 100644 --- a/base/objective-c/test/inputs/json/priority/keywords.json/default/QTTopLevel.m +++ b/head/objective-c/test/inputs/json/priority/keywords.json/default/QTTopLevel.m @@ -1148,6 +1148,11 @@ NS_ASSUME_NONNULL_BEGIN - (NSDictionary *)JSONDictionary; @end +@interface QTS (JSONConversion) ++ (instancetype)fromJSONDictionary:(NSDictionary *)dict; +- (NSDictionary *)JSONDictionary; +@end + @interface QTSbyte (JSONConversion) + (instancetype)fromJSONDictionary:(NSDictionary *)dict; - (NSDictionary *)JSONDictionary; @@ -11565,6 +11570,7 @@ NSString *_Nullable QTTopLevelToJSON(QTTopLevel *topLevel, NSStringEncoding enco @"requires": @"requires", @"rethrows": @"rethrows", @"right": @"right", + @"s": @"s", @"sbyte": @"sbyte", @"sealed": @"sealed", @"SEL": @"sel", @@ -11642,6 +11648,7 @@ NSString *_Nullable QTTopLevelToJSON(QTTopLevel *topLevel, NSStringEncoding enco if (![dict[@"requires"] isKindOfClass:NSDictionary.class]) return nil; if (![dict[@"rethrows"] isKindOfClass:NSDictionary.class]) return nil; if (![dict[@"right"] isKindOfClass:NSDictionary.class]) return nil; + if (![dict[@"s"] isKindOfClass:NSDictionary.class]) return nil; if (![dict[@"sbyte"] isKindOfClass:NSDictionary.class]) return nil; if (![dict[@"sealed"] isKindOfClass:NSDictionary.class]) return nil; if (![dict[@"SEL"] isKindOfClass:NSDictionary.class]) return nil; @@ -11735,6 +11742,8 @@ NSString *_Nullable QTTopLevelToJSON(QTTopLevel *topLevel, NSStringEncoding enco if (!_rethrows && dict[@"rethrows"] && ![dict[@"rethrows"] isKindOfClass:NSNull.class]) return nil; _right = [QTRight fromJSONDictionary:(id)_right]; if (!_right && dict[@"right"] && ![dict[@"right"] isKindOfClass:NSNull.class]) return nil; + _s = [QTS fromJSONDictionary:(id)_s]; + if (!_s && dict[@"s"] && ![dict[@"s"] isKindOfClass:NSNull.class]) return nil; _sbyte = [QTSbyte fromJSONDictionary:(id)_sbyte]; if (!_sbyte && dict[@"sbyte"] && ![dict[@"sbyte"] isKindOfClass:NSNull.class]) return nil; _sealed = [QTSealed fromJSONDictionary:(id)_sealed]; @@ -11864,6 +11873,7 @@ NSString *_Nullable QTTopLevelToJSON(QTTopLevel *topLevel, NSStringEncoding enco @"requires": [_requires JSONDictionary], @"rethrows": [_rethrows JSONDictionary], @"right": [_right JSONDictionary], + @"s": [_s JSONDictionary], @"sbyte": [_sbyte JSONDictionary], @"sealed": [_sealed JSONDictionary], @"SEL": [_sel JSONDictionary], @@ -13222,6 +13232,48 @@ NSString *_Nullable QTTopLevelToJSON(QTTopLevel *topLevel, NSStringEncoding enco } @end +@implementation QTS ++ (NSDictionary *)properties +{ + static NSDictionary *properties; + return properties = properties ? properties : @{ + @"s": @"s", + }; +} + ++ (instancetype)fromJSONDictionary:(NSDictionary *)dict +{ + return [dict isKindOfClass:NSDictionary.class] ? [[QTS alloc] initWithJSONDictionary:dict] : nil; +} + +- (instancetype)initWithJSONDictionary:(NSDictionary *)dict +{ + if (self = [super init]) { + if (![dict[@"s"] isKindOfClass:NSNumber.class]) return nil; + if ([dict[@"s"] doubleValue] != [dict[@"s"] longLongValue]) return nil; + [self setValuesForKeysWithDictionary:dict]; + } + return self; +} + +- (void)setValue:(nullable id)value forKey:(NSString *)key +{ + id resolved = QTS.properties[key]; + if (resolved) [super setValue:value forKey:resolved]; +} + +- (void)setNilValueForKey:(NSString *)key +{ + id resolved = QTS.properties[key]; + if (resolved) [super setValue:@(0) forKey:resolved]; +} + +- (NSDictionary *)JSONDictionary +{ + return [self dictionaryWithValuesForKeys:QTS.properties.allValues]; +} +@end + @implementation QTSbyte + (NSDictionary *)properties { diff --git a/base/php/test/inputs/json/priority/keywords.json/default/TopLevel.php b/head/php/test/inputs/json/priority/keywords.json/default/TopLevel.php index 4fbc2b0..2d52bc4 100644 --- a/base/php/test/inputs/json/priority/keywords.json/default/TopLevel.php +++ b/head/php/test/inputs/json/priority/keywords.json/default/TopLevel.php @@ -31725,6 +31725,7 @@ class Obj4 { private Rethrows $rethrows; // json:rethrows Required private ReturnClass $return; // json:return Required private Right $right; // json:right Required + private S $s; // json:s Required private Sbyte $sbyte; // json:sbyte Required private Sealed $sealed; // json:sealed Required private Sel $sel; // json:SEL Required @@ -31792,6 +31793,7 @@ class Obj4 { * @param Rethrows $rethrows * @param ReturnClass $return * @param Right $right + * @param S $s * @param Sbyte $sbyte * @param Sealed $sealed * @param Sel $sel @@ -31836,7 +31838,7 @@ class Obj4 { * @param Unchecked $unchecked * @param Undefined $undefined */ - public function __construct(int $dummy, Obj4Self $obj4Self, This $obj4This, Obj4True $obj4True, TypeClass $obj4Type, PublicClass $public, Quicktype $quicktype, Raise $raise, Range $range, ReadonlyClass $readonly, Ref $ref, Register $register, ReinterpretCast $reinterpretCast, Repeat $repeat, RequireClass $require, Required $required, Requires $requires, Restrict $restrict, Retain $retain, Rethrows $rethrows, ReturnClass $return, Right $right, Sbyte $sbyte, Sealed $sealed, Sel $sel, Select $select, SelfClass $self, Serialize $serialize, Set $set, Short $short, Signed $signed, Sizeof $sizeof, Stackalloc $stackalloc, StaticClass $static, StaticAssert $staticAssert, StaticCast $staticCast, Strictfp $strictfp, StringClass $string, Struct $struct, Subscript $subscript, Super $super, SwitchClass $switch, Symbol $symbol, Synchronized $synchronized, System $system, Template $template, Then $then, ThreadLocal $threadLocal, ThrowClass $throw, Throws $throws, ToJSON $toJSON, TopLevelClass $topLevel, Transient $transient, TrueClass $true, TryClass $try, Type $type, Typealias $typealias, Typedef $typedef, Typeid $typeid, Typename $typename, Typeof $typeof, Uint $uint, Ulong $ulong, Unchecked $unchecked, Undefined $undefined) { + public function __construct(int $dummy, Obj4Self $obj4Self, This $obj4This, Obj4True $obj4True, TypeClass $obj4Type, PublicClass $public, Quicktype $quicktype, Raise $raise, Range $range, ReadonlyClass $readonly, Ref $ref, Register $register, ReinterpretCast $reinterpretCast, Repeat $repeat, RequireClass $require, Required $required, Requires $requires, Restrict $restrict, Retain $retain, Rethrows $rethrows, ReturnClass $return, Right $right, S $s, Sbyte $sbyte, Sealed $sealed, Sel $sel, Select $select, SelfClass $self, Serialize $serialize, Set $set, Short $short, Signed $signed, Sizeof $sizeof, Stackalloc $stackalloc, StaticClass $static, StaticAssert $staticAssert, StaticCast $staticCast, Strictfp $strictfp, StringClass $string, Struct $struct, Subscript $subscript, Super $super, SwitchClass $switch, Symbol $symbol, Synchronized $synchronized, System $system, Template $template, Then $then, ThreadLocal $threadLocal, ThrowClass $throw, Throws $throws, ToJSON $toJSON, TopLevelClass $topLevel, Transient $transient, TrueClass $true, TryClass $try, Type $type, Typealias $typealias, Typedef $typedef, Typeid $typeid, Typename $typename, Typeof $typeof, Uint $uint, Ulong $ulong, Unchecked $unchecked, Undefined $undefined) { $this->dummy = $dummy; $this->obj4Self = $obj4Self; $this->obj4This = $obj4This; @@ -31859,6 +31861,7 @@ class Obj4 { $this->rethrows = $rethrows; $this->return = $return; $this->right = $right; + $this->s = $s; $this->sbyte = $sbyte; $this->sealed = $sealed; $this->sel = $sel; @@ -32959,6 +32962,54 @@ class Obj4 { return Right::sample(); /*52:right*/ } + /** + * @param stdClass $value + * @throws Exception + * @return S + */ + public static function fromS(stdClass $value): S { + return S::from($value); /*class*/ + } + + /** + * @throws Exception + * @return stdClass + */ + public function toS(): stdClass { + if (Obj4::validateS($this->s)) { + return $this->s->to(); /*class*/ + } + throw new Exception('never get to this Obj4::s'); + } + + /** + * @param S + * @return bool + * @throws Exception + */ + public static function validateS(S $value): bool { + $value->validate(); + return true; + } + + /** + * @throws Exception + * @return S + */ + public function getS(): S { + if (Obj4::validateS($this->s)) { + return $this->s; + } + throw new Exception('never get to getS Obj4::s'); + } + + /** + * @return S + */ + public static function sampleS(): S { + return S::sample(); /*53:s*/ + } + /** * @param stdClass $value * @throws Exception @@ -33004,7 +33055,7 @@ class Obj4 { * @return Sbyte */ public static function sampleSbyte(): Sbyte { - return Sbyte::sample(); /*53:sbyte*/ + return Sbyte::sample(); /*54:sbyte*/ } /** @@ -33052,7 +33103,7 @@ class Obj4 { * @return Sealed */ public static function sampleSealed(): Sealed { - return Sealed::sample(); /*54:sealed*/ + return Sealed::sample(); /*55:sealed*/ } /** @@ -33100,7 +33151,7 @@ class Obj4 { * @return Sel */ public static function sampleSel(): Sel { - return Sel::sample(); /*55:sel*/ + return Sel::sample(); /*56:sel*/ } /** @@ -33148,7 +33199,7 @@ class Obj4 { * @return Select */ public static function sampleSelect(): Select { - return Select::sample(); /*56:select*/ + return Select::sample(); /*57:select*/ } /** @@ -33196,7 +33247,7 @@ class Obj4 { * @return SelfClass */ public static function sampleSelf(): SelfClass { - return SelfClass::sample(); /*57:self*/ + return SelfClass::sample(); /*58:self*/ } /** @@ -33244,7 +33295,7 @@ class Obj4 { * @return Serialize */ public static function sampleSerialize(): Serialize { - return Serialize::sample(); /*58:serialize*/ + return Serialize::sample(); /*59:serialize*/ } /** @@ -33292,7 +33343,7 @@ class Obj4 { * @return Set */ public static function sampleSet(): Set { - return Set::sample(); /*59:set*/ + return Set::sample(); /*60:set*/ } /** @@ -33340,7 +33391,7 @@ class Obj4 { * @return Short */ public static function sampleShort(): Short { - return Short::sample(); /*60:short*/ + return Short::sample(); /*61:short*/ } /** @@ -33388,7 +33439,7 @@ class Obj4 { * @return Signed */ public static function sampleSigned(): Signed { - return Signed::sample(); /*61:signed*/ + return Signed::sample(); /*62:signed*/ } /** @@ -33436,7 +33487,7 @@ class Obj4 { * @return Sizeof */ public static function sampleSizeof(): Sizeof { - return Sizeof::sample(); /*62:sizeof*/ + return Sizeof::sample(); /*63:sizeof*/ } /** @@ -33484,7 +33535,7 @@ class Obj4 { * @return Stackalloc */ public static function sampleStackalloc(): Stackalloc { - return Stackalloc::sample(); /*63:stackalloc*/ + return Stackalloc::sample(); /*64:stackalloc*/ } /** @@ -33532,7 +33583,7 @@ class Obj4 { * @return StaticClass */ public static function sampleStatic(): StaticClass { - return StaticClass::sample(); /*64:static*/ + return StaticClass::sample(); /*65:static*/ } /** @@ -33580,7 +33631,7 @@ class Obj4 { * @return StaticAssert */ public static function sampleStaticAssert(): StaticAssert { - return StaticAssert::sample(); /*65:staticAssert*/ + return StaticAssert::sample(); /*66:staticAssert*/ } /** @@ -33628,7 +33679,7 @@ class Obj4 { * @return StaticCast */ public static function sampleStaticCast(): StaticCast { - return StaticCast::sample(); /*66:staticCast*/ + return StaticCast::sample(); /*67:staticCast*/ } /** @@ -33676,7 +33727,7 @@ class Obj4 { * @return Strictfp */ public static function sampleStrictfp(): Strictfp { - return Strictfp::sample(); /*67:strictfp*/ + return Strictfp::sample(); /*68:strictfp*/ } /** @@ -33724,7 +33775,7 @@ class Obj4 { * @return StringClass */ public static function sampleString(): StringClass { - return StringClass::sample(); /*68:string*/ + return StringClass::sample(); /*69:string*/ } /** @@ -33772,7 +33823,7 @@ class Obj4 { * @return Struct */ public static function sampleStruct(): Struct { - return Struct::sample(); /*69:struct*/ + return Struct::sample(); /*70:struct*/ } /** @@ -33820,7 +33871,7 @@ class Obj4 { * @return Subscript */ public static function sampleSubscript(): Subscript { - return Subscript::sample(); /*70:subscript*/ + return Subscript::sample(); /*71:subscript*/ } /** @@ -33868,7 +33919,7 @@ class Obj4 { * @return Super */ public static function sampleSuper(): Super { - return Super::sample(); /*71:super*/ + return Super::sample(); /*72:super*/ } /** @@ -33916,7 +33967,7 @@ class Obj4 { * @return SwitchClass */ public static function sampleSwitch(): SwitchClass { - return SwitchClass::sample(); /*72:switch*/ + return SwitchClass::sample(); /*73:switch*/ } /** @@ -33964,7 +34015,7 @@ class Obj4 { * @return Symbol */ public static function sampleSymbol(): Symbol { - return Symbol::sample(); /*73:symbol*/ + return Symbol::sample(); /*74:symbol*/ } /** @@ -34012,7 +34063,7 @@ class Obj4 { * @return Synchronized */ public static function sampleSynchronized(): Synchronized { - return Synchronized::sample(); /*74:synchronized*/ + return Synchronized::sample(); /*75:synchronized*/ } /** @@ -34060,7 +34111,7 @@ class Obj4 { * @return System */ public static function sampleSystem(): System { - return System::sample(); /*75:system*/ + return System::sample(); /*76:system*/ } /** @@ -34108,7 +34159,7 @@ class Obj4 { * @return Template */ public static function sampleTemplate(): Template { - return Template::sample(); /*76:template*/ + return Template::sample(); /*77:template*/ } /** @@ -34156,7 +34207,7 @@ class Obj4 { * @return Then */ public static function sampleThen(): Then { - return Then::sample(); /*77:then*/ + return Then::sample(); /*78:then*/ } /** @@ -34204,7 +34255,7 @@ class Obj4 { * @return ThreadLocal */ public static function sampleThreadLocal(): ThreadLocal { - return ThreadLocal::sample(); /*78:threadLocal*/ + return ThreadLocal::sample(); /*79:threadLocal*/ } /** @@ -34252,7 +34303,7 @@ class Obj4 { * @return ThrowClass */ public static function sampleThrow(): ThrowClass { - return ThrowClass::sample(); /*79:throw*/ + return ThrowClass::sample(); /*80:throw*/ } /** @@ -34300,7 +34351,7 @@ class Obj4 { * @return Throws */ public static function sampleThrows(): Throws { - return Throws::sample(); /*80:throws*/ + return Throws::sample(); /*81:throws*/ } /** @@ -34348,7 +34399,7 @@ class Obj4 { * @return ToJSON */ public static function sampleToJSON(): ToJSON { - return ToJSON::sample(); /*81:toJSON*/ + return ToJSON::sample(); /*82:toJSON*/ } /** @@ -34396,7 +34447,7 @@ class Obj4 { * @return TopLevelClass */ public static function sampleTopLevel(): TopLevelClass { - return TopLevelClass::sample(); /*82:topLevel*/ + return TopLevelClass::sample(); /*83:topLevel*/ } /** @@ -34444,7 +34495,7 @@ class Obj4 { * @return Transient */ public static function sampleTransient(): Transient { - return Transient::sample(); /*83:transient*/ + return Transient::sample(); /*84:transient*/ } /** @@ -34492,7 +34543,7 @@ class Obj4 { * @return TrueClass */ public static function sampleTrue(): TrueClass { - return TrueClass::sample(); /*84:true*/ + return TrueClass::sample(); /*85:true*/ } /** @@ -34540,7 +34591,7 @@ class Obj4 { * @return TryClass */ public static function sampleTry(): TryClass { - return TryClass::sample(); /*85:try*/ + return TryClass::sample(); /*86:try*/ } /** @@ -34588,7 +34639,7 @@ class Obj4 { * @return Type */ public static function sampleType(): Type { - return Type::sample(); /*86:type*/ + return Type::sample(); /*87:type*/ } /** @@ -34636,7 +34687,7 @@ class Obj4 { * @return Typealias */ public static function sampleTypealias(): Typealias { - return Typealias::sample(); /*87:typealias*/ + return Typealias::sample(); /*88:typealias*/ } /** @@ -34684,7 +34735,7 @@ class Obj4 { * @return Typedef */ public static function sampleTypedef(): Typedef { - return Typedef::sample(); /*88:typedef*/ + return Typedef::sample(); /*89:typedef*/ } /** @@ -34732,7 +34783,7 @@ class Obj4 { * @return Typeid */ public static function sampleTypeid(): Typeid { - return Typeid::sample(); /*89:typeid*/ + return Typeid::sample(); /*90:typeid*/ } /** @@ -34780,7 +34831,7 @@ class Obj4 { * @return Typename */ public static function sampleTypename(): Typename { - return Typename::sample(); /*90:typename*/ + return Typename::sample(); /*91:typename*/ } /** @@ -34828,7 +34879,7 @@ class Obj4 { * @return Typeof */ public static function sampleTypeof(): Typeof { - return Typeof::sample(); /*91:typeof*/ + return Typeof::sample(); /*92:typeof*/ } /** @@ -34876,7 +34927,7 @@ class Obj4 { * @return Uint */ public static function sampleUint(): Uint { - return Uint::sample(); /*92:uint*/ + return Uint::sample(); /*93:uint*/ } /** @@ -34924,7 +34975,7 @@ class Obj4 { * @return Ulong */ public static function sampleUlong(): Ulong { - return Ulong::sample(); /*93:ulong*/ + return Ulong::sample(); /*94:ulong*/ } /** @@ -34972,7 +35023,7 @@ class Obj4 { * @return Unchecked */ public static function sampleUnchecked(): Unchecked { - return Unchecked::sample(); /*94:unchecked*/ + return Unchecked::sample(); /*95:unchecked*/ } /** @@ -35020,7 +35071,7 @@ class Obj4 { * @return Undefined */ public static function sampleUndefined(): Undefined { - return Undefined::sample(); /*95:undefined*/ + return Undefined::sample(); /*96:undefined*/ } /** @@ -35050,6 +35101,7 @@ class Obj4 { || Obj4::validateRethrows($this->rethrows) || Obj4::validateReturn($this->return) || Obj4::validateRight($this->right) + || Obj4::validateS($this->s) || Obj4::validateSbyte($this->sbyte) || Obj4::validateSealed($this->sealed) || Obj4::validateSel($this->sel) @@ -35123,6 +35175,7 @@ class Obj4 { $out->{'rethrows'} = $this->toRethrows(); $out->{'return'} = $this->toReturn(); $out->{'right'} = $this->toRight(); + $out->{'s'} = $this->toS(); $out->{'sbyte'} = $this->toSbyte(); $out->{'sealed'} = $this->toSealed(); $out->{'SEL'} = $this->toSel(); @@ -35241,6 +35294,9 @@ class Obj4 { if (!property_exists($obj, 'right')) { throw new Exception("Missing required property"); } + if (!property_exists($obj, 's')) { + throw new Exception("Missing required property"); + } if (!property_exists($obj, 'sbyte')) { throw new Exception("Missing required property"); } @@ -35393,6 +35449,7 @@ class Obj4 { ,Obj4::fromRethrows($obj->{'rethrows'}) ,Obj4::fromReturn($obj->{'return'}) ,Obj4::fromRight($obj->{'right'}) + ,Obj4::fromS($obj->{'s'}) ,Obj4::fromSbyte($obj->{'sbyte'}) ,Obj4::fromSealed($obj->{'sealed'}) ,Obj4::fromSel($obj->{'SEL'}) @@ -35466,6 +35523,7 @@ class Obj4 { ,Obj4::sampleRethrows() ,Obj4::sampleReturn() ,Obj4::sampleRight() + ,Obj4::sampleS() ,Obj4::sampleSbyte() ,Obj4::sampleSealed() ,Obj4::sampleSel() @@ -37634,6 +37692,107 @@ class Right { } } +// This is an autogenerated file:S + +class S { + private int $s; // json:s Required + + /** + * @param int $s + */ + public function __construct(int $s) { + $this->s = $s; + } + + /** + * @param int $value + * @throws Exception + * @return int + */ + public static function fromS(int $value): int { + return $value; /*int*/ + } + + /** + * @throws Exception + * @return int + */ + public function toS(): int { + if (S::validateS($this->s)) { + return $this->s; /*int*/ + } + throw new Exception('never get to this S::s'); + } + + /** + * @param int + * @return bool + * @throws Exception + */ + public static function validateS(int $value): bool { + return true; + } + + /** + * @throws Exception + * @return int + */ + public function getS(): int { + if (S::validateS($this->s)) { + return $this->s; + } + throw new Exception('never get to getS S::s'); + } + + /** + * @return int + */ + public static function sampleS(): int { + return 31; /*31:s*/ + } + + /** + * @throws Exception + * @return bool + */ + public function validate(): bool { + return S::validateS($this->s); + } + + /** + * @return stdClass + * @throws Exception + */ + public function to(): stdClass { + $out = new stdClass(); + $out->{'s'} = $this->toS(); + return $out; + } + + /** + * @param stdClass $obj + * @return S + * @throws Exception + */ + public static function from(stdClass $obj): S { + if (!property_exists($obj, 's')) { + throw new Exception("Missing required property"); + } + return new S( + S::fromS($obj->{'s'}) + ); + } + + /** + * @return S + */ + public static function sample(): S { + return new S( + S::sampleS() + ); + } +} + // This is an autogenerated file:Sbyte class Sbyte { diff --git a/base/pike/test/inputs/json/priority/keywords.json/default/TopLevel.pmod b/head/pike/test/inputs/json/priority/keywords.json/default/TopLevel.pmod index be66731..313acdb 100644 --- a/base/pike/test/inputs/json/priority/keywords.json/default/TopLevel.pmod +++ b/head/pike/test/inputs/json/priority/keywords.json/default/TopLevel.pmod @@ -4818,6 +4818,7 @@ class Obj4 { Retain retain; // json: "retain" Rethrows rethrows; // json: "rethrows" Right right; // json: "right" + S s; // json: "s" Sbyte sbyte; // json: "sbyte" Sealed sealed; // json: "sealed" Sel sel; // json: "SEL" @@ -4886,6 +4887,7 @@ class Obj4 { "retain" : retain, "rethrows" : rethrows, "right" : right, + "s" : s, "sbyte" : sbyte, "sealed" : sealed, "SEL" : sel, @@ -4961,6 +4963,7 @@ Obj4 Obj4_from_JSON(mixed json) { retval.retain = json["retain"]; retval.rethrows = json["rethrows"]; retval.right = json["right"]; + retval.s = json["s"]; retval.sbyte = json["sbyte"]; retval.sealed = json["sealed"]; retval.sel = json["SEL"]; @@ -5529,6 +5532,27 @@ Right Right_from_JSON(mixed json) { return retval; } +class S { + int s; // json: "s" + + string encode_json() { + mapping(string:mixed) json = ([ + "s" : s, + ]); + + return Standards.JSON.encode(json); + } +} + +S S_from_JSON(mixed json) { + S retval = S(); + + if (!intp(json["s"])) error("Expected integer"); + retval.s = json["s"]; + + return retval; +} + class Sbyte { int sbyte; // json: "sbyte" diff --git a/base/python/test/inputs/json/priority/keywords.json/default/quicktype.py b/head/python/test/inputs/json/priority/keywords.json/default/quicktype.py index b63d029..f68c212 100644 --- a/base/python/test/inputs/json/priority/keywords.json/default/quicktype.py +++ b/head/python/test/inputs/json/priority/keywords.json/default/quicktype.py @@ -4120,6 +4120,22 @@ class Right: return result +@dataclass +class S: + s: int + + @staticmethod + def from_dict(obj: Any) -> 'S': + assert isinstance(obj, dict) + s = from_int(obj.get("s")) + return S(s) + + def to_dict(self) -> dict: + result: dict = {} + result["s"] = from_int(self.s) + return result + + @dataclass class Sbyte: sbyte: int @@ -4816,6 +4832,7 @@ class Obj4: rethrows: Rethrows obj4_return: Return right: Right + s: S sbyte: Sbyte sealed: Sealed select: Select @@ -4885,6 +4902,7 @@ class Obj4: rethrows = Rethrows.from_dict(obj.get("rethrows")) obj4_return = Return.from_dict(obj.get("return")) right = Right.from_dict(obj.get("right")) + s = S.from_dict(obj.get("s")) sbyte = Sbyte.from_dict(obj.get("sbyte")) sealed = Sealed.from_dict(obj.get("sealed")) select = Select.from_dict(obj.get("select")) @@ -4928,7 +4946,7 @@ class Obj4: ulong = Ulong.from_dict(obj.get("ulong")) unchecked = Unchecked.from_dict(obj.get("unchecked")) undefined = Undefined.from_dict(obj.get("undefined")) - return Obj4(sel, obj4_self, true, type, dummy, public, quicktype, obj4_raise, range, readonly, ref, register, reinterpret_cast, repeat, require, required, requires, restrict, retain, rethrows, obj4_return, right, sbyte, sealed, select, purple_self, serialize, set, short, signed, sizeof, stackalloc, static, static_assert, static_cast, strictfp, string, struct, subscript, super, switch, symbol, synchronized, system, template, then, this, thread_local, throw, throws, to_json, top_level, transient, obj4_true, obj4_try, obj4_type, typealias, typedef, typeid, typename, typeof, uint, ulong, unchecked, undefined) + return Obj4(sel, obj4_self, true, type, dummy, public, quicktype, obj4_raise, range, readonly, ref, register, reinterpret_cast, repeat, require, required, requires, restrict, retain, rethrows, obj4_return, right, s, sbyte, sealed, select, purple_self, serialize, set, short, signed, sizeof, stackalloc, static, static_assert, static_cast, strictfp, string, struct, subscript, super, switch, symbol, synchronized, system, template, then, this, thread_local, throw, throws, to_json, top_level, transient, obj4_true, obj4_try, obj4_type, typealias, typedef, typeid, typename, typeof, uint, ulong, unchecked, undefined) def to_dict(self) -> dict: result: dict = {} @@ -4954,6 +4972,7 @@ class Obj4: result["rethrows"] = to_class(Rethrows, self.rethrows) result["return"] = to_class(Return, self.obj4_return) result["right"] = to_class(Right, self.right) + result["s"] = to_class(S, self.s) result["sbyte"] = to_class(Sbyte, self.sbyte) result["sealed"] = to_class(Sealed, self.sealed) result["select"] = to_class(Select, self.select) diff --git a/base/ruby/test/inputs/json/priority/keywords.json/default/TopLevel.rb b/head/ruby/test/inputs/json/priority/keywords.json/default/TopLevel.rb index 80af01e..d376988 100644 --- a/base/ruby/test/inputs/json/priority/keywords.json/default/TopLevel.rb +++ b/head/ruby/test/inputs/json/priority/keywords.json/default/TopLevel.rb @@ -6229,6 +6229,31 @@ class Right < Dry::Struct end end +class S < Dry::Struct + attribute :s, Types::Integer + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + s: d.fetch("s"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "s" => s, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + class Sbyte < Dry::Struct attribute :sbyte, Types::Integer @@ -7183,6 +7208,7 @@ class Obj4 < Dry::Struct attribute :retain, Retain attribute :rethrows, Rethrows attribute :right, Right + attribute :s, S attribute :sbyte, Sbyte attribute :sealed, Sealed attribute :sel, Sel @@ -7252,6 +7278,7 @@ class Obj4 < Dry::Struct retain: Retain.from_dynamic!(d.fetch("retain")), rethrows: Rethrows.from_dynamic!(d.fetch("rethrows")), right: Right.from_dynamic!(d.fetch("right")), + s: S.from_dynamic!(d.fetch("s")), sbyte: Sbyte.from_dynamic!(d.fetch("sbyte")), sealed: Sealed.from_dynamic!(d.fetch("sealed")), sel: Sel.from_dynamic!(d.fetch("SEL")), @@ -7326,6 +7353,7 @@ class Obj4 < Dry::Struct "retain" => retain.to_dynamic, "rethrows" => rethrows.to_dynamic, "right" => right.to_dynamic, + "s" => s.to_dynamic, "sbyte" => sbyte.to_dynamic, "sealed" => sealed.to_dynamic, "SEL" => sel.to_dynamic, diff --git a/base/rust/test/inputs/json/priority/keywords.json/default/module_under_test.rs b/head/rust/test/inputs/json/priority/keywords.json/default/module_under_test.rs index 14aa82f..ce136b7 100644 --- a/base/rust/test/inputs/json/priority/keywords.json/default/module_under_test.rs +++ b/head/rust/test/inputs/json/priority/keywords.json/default/module_under_test.rs @@ -1565,6 +1565,8 @@ pub struct Obj4 { pub right: Right, + pub s: S, + pub sbyte: Sbyte, pub sealed: Sealed, @@ -1795,6 +1797,11 @@ pub struct Right { pub right: i64, } +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct S { + pub s: i64, +} + #[derive(Debug, Clone, Serialize, Deserialize)] pub struct Sbyte { pub sbyte: i64, diff --git a/base/scala3/test/inputs/json/priority/keywords.json/default/TopLevel.scala b/head/scala3/test/inputs/json/priority/keywords.json/default/TopLevel.scala index 5c7aab8..7af7235 100644 --- a/base/scala3/test/inputs/json/priority/keywords.json/default/TopLevel.scala +++ b/head/scala3/test/inputs/json/priority/keywords.json/default/TopLevel.scala @@ -1061,6 +1061,7 @@ case class Obj4 ( val retain : Retain, val rethrows : Rethrows, val right : Right, + val s : S, val sbyte : Sbyte, val SEL : Sel, val select : Select, @@ -1220,6 +1221,10 @@ case class Right ( val right : Long ) derives Encoder.AsObject, Decoder +case class S ( + val s : Long +) derives Encoder.AsObject, Decoder + case class Sbyte ( val sbyte : Long ) derives Encoder.AsObject, Decoder diff --git a/base/scala3-upickle/test/inputs/json/priority/keywords.json/default/TopLevel.scala b/head/scala3-upickle/test/inputs/json/priority/keywords.json/default/TopLevel.scala index e071ec1..044154f 100644 --- a/base/scala3-upickle/test/inputs/json/priority/keywords.json/default/TopLevel.scala +++ b/head/scala3-upickle/test/inputs/json/priority/keywords.json/default/TopLevel.scala @@ -1097,6 +1097,7 @@ case class Obj4 ( val retain : Retain, val rethrows : Rethrows, val right : Right, + val s : S, val sbyte : Sbyte, val SEL : Sel, val select : Select, @@ -1248,6 +1249,10 @@ case class Right ( val right : Long ) derives OptionPickler.ReadWriter +case class S ( + val s : Long +) derives OptionPickler.ReadWriter + case class Sbyte ( val sbyte : Long ) derives OptionPickler.ReadWriter diff --git a/head/swift/test/inputs/json/priority/combinations1.json/final-classes-true__struct-or-class-class--d3c62ec7414d/quicktype.swift b/head/swift/test/inputs/json/priority/combinations1.json/final-classes-true__struct-or-class-class--d3c62ec7414d/quicktype.swift new file mode 100644 index 0000000..e124cd4 --- /dev/null +++ b/head/swift/test/inputs/json/priority/combinations1.json/final-classes-true__struct-or-class-class--d3c62ec7414d/quicktype.swift @@ -0,0 +1,3182 @@ +// 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 +final class TopLevel: Codable { + let centrodesmose: String + let cerograph: [CerographElement] + let chemotherapeutics: [ChemotherapeuticElement] + let cimelia: [CimeliaElement] + let citrated: Int + let clinodome: [Clinodome] + let coadjust: [CoadjustElement] + let consilience: [Consilience] + let constructor: [Constructor] + let continuative: [Continuative] + let credulity: [CredulityElement] + let creviced: [Creviced] + let cubiculum: [[Int?]] + let deruralize: [DeruralizeElement] + let diaereses: [DiaereseElement] + let dissolution: [[JSONNull?]?] + let downstroke: [Downstroke] + let electrotautomerism: [Double?] + let eleutheromania: [Eleutheromania] + let encrust: Encrust + let entomoid: [Entomoid] + let epipaleolithic: [Epipaleolithic] + let expropriable: [Expropriable] + let faggingly: [FagginglyElement] + let fenks: [FenkElement] + let flagmaking: [FlagmakingElement] + let fluorometer: [Fluorometer] + let fulsome: [Int?] + let fuzzy: [Fuzzy] + let gardenwards: [Gardenward] + let generalissimo: [Generalissimo] + let habeas: [[String: Int]?] + let hemicrystalline: [Hemicrystalline] + let hemocoele: [HemocoeleElement] + let hoister: [Hoister] + let hyperpiesis: [Hyperpiesi] + let hyppish: [Hyppish] + let idealizer: [Idealizer] + let incrustator: [Incrustator] + let intentiveness: [Intentiveness] + let interacinar: Interacinar + let intercorrelation: [[Int]?] + let jacutinga: [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" + } + + init(centrodesmose: String, cerograph: [CerographElement], chemotherapeutics: [ChemotherapeuticElement], cimelia: [CimeliaElement], citrated: Int, clinodome: [Clinodome], coadjust: [CoadjustElement], consilience: [Consilience], constructor: [Constructor], continuative: [Continuative], credulity: [CredulityElement], creviced: [Creviced], cubiculum: [[Int?]], deruralize: [DeruralizeElement], diaereses: [DiaereseElement], dissolution: [[JSONNull?]?], downstroke: [Downstroke], electrotautomerism: [Double?], eleutheromania: [Eleutheromania], encrust: Encrust, entomoid: [Entomoid], epipaleolithic: [Epipaleolithic], expropriable: [Expropriable], faggingly: [FagginglyElement], fenks: [FenkElement], flagmaking: [FlagmakingElement], fluorometer: [Fluorometer], fulsome: [Int?], fuzzy: [Fuzzy], gardenwards: [Gardenward], generalissimo: [Generalissimo], habeas: [[String: Int]?], hemicrystalline: [Hemicrystalline], hemocoele: [HemocoeleElement], hoister: [Hoister], hyperpiesis: [Hyperpiesi], hyppish: [Hyppish], idealizer: [Idealizer], incrustator: [Incrustator], intentiveness: [Intentiveness], interacinar: Interacinar, intercorrelation: [[Int]?], jacutinga: [Jacutinga]) { + self.centrodesmose = centrodesmose + self.cerograph = cerograph + self.chemotherapeutics = chemotherapeutics + self.cimelia = cimelia + self.citrated = citrated + self.clinodome = clinodome + self.coadjust = coadjust + self.consilience = consilience + self.constructor = constructor + self.continuative = continuative + self.credulity = credulity + self.creviced = creviced + self.cubiculum = cubiculum + self.deruralize = deruralize + self.diaereses = diaereses + self.dissolution = dissolution + self.downstroke = downstroke + self.electrotautomerism = electrotautomerism + self.eleutheromania = eleutheromania + self.encrust = encrust + self.entomoid = entomoid + self.epipaleolithic = epipaleolithic + self.expropriable = expropriable + self.faggingly = faggingly + self.fenks = fenks + self.flagmaking = flagmaking + self.fluorometer = fluorometer + self.fulsome = fulsome + self.fuzzy = fuzzy + self.gardenwards = gardenwards + self.generalissimo = generalissimo + self.habeas = habeas + self.hemicrystalline = hemicrystalline + self.hemocoele = hemocoele + self.hoister = hoister + self.hyperpiesis = hyperpiesis + self.hyppish = hyppish + self.idealizer = idealizer + self.incrustator = incrustator + self.intentiveness = intentiveness + self.interacinar = interacinar + self.intercorrelation = intercorrelation + self.jacutinga = jacutinga + } +} + +// MARK: TopLevel convenience initializers and mutators + +extension TopLevel { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(TopLevel.self, from: data) + self.init(centrodesmose: me.centrodesmose, cerograph: me.cerograph, chemotherapeutics: me.chemotherapeutics, cimelia: me.cimelia, citrated: me.citrated, clinodome: me.clinodome, coadjust: me.coadjust, consilience: me.consilience, constructor: me.constructor, continuative: me.continuative, credulity: me.credulity, creviced: me.creviced, cubiculum: me.cubiculum, deruralize: me.deruralize, diaereses: me.diaereses, dissolution: me.dissolution, downstroke: me.downstroke, electrotautomerism: me.electrotautomerism, eleutheromania: me.eleutheromania, encrust: me.encrust, entomoid: me.entomoid, epipaleolithic: me.epipaleolithic, expropriable: me.expropriable, faggingly: me.faggingly, fenks: me.fenks, flagmaking: me.flagmaking, fluorometer: me.fluorometer, fulsome: me.fulsome, fuzzy: me.fuzzy, gardenwards: me.gardenwards, generalissimo: me.generalissimo, habeas: me.habeas, hemicrystalline: me.hemicrystalline, hemocoele: me.hemocoele, hoister: me.hoister, hyperpiesis: me.hyperpiesis, hyppish: me.hyppish, idealizer: me.idealizer, incrustator: me.incrustator, intentiveness: me.intentiveness, interacinar: me.interacinar, intercorrelation: me.intercorrelation, jacutinga: me.jacutinga) + } + + convenience 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) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + centrodesmose: String? = nil, + cerograph: [CerographElement]? = nil, + chemotherapeutics: [ChemotherapeuticElement]? = nil, + cimelia: [CimeliaElement]? = nil, + citrated: Int? = nil, + clinodome: [Clinodome]? = nil, + coadjust: [CoadjustElement]? = nil, + consilience: [Consilience]? = nil, + constructor: [Constructor]? = nil, + continuative: [Continuative]? = nil, + credulity: [CredulityElement]? = nil, + creviced: [Creviced]? = nil, + cubiculum: [[Int?]]? = nil, + deruralize: [DeruralizeElement]? = nil, + diaereses: [DiaereseElement]? = nil, + dissolution: [[JSONNull?]?]? = nil, + downstroke: [Downstroke]? = nil, + electrotautomerism: [Double?]? = nil, + eleutheromania: [Eleutheromania]? = nil, + encrust: Encrust? = nil, + entomoid: [Entomoid]? = nil, + epipaleolithic: [Epipaleolithic]? = nil, + expropriable: [Expropriable]? = nil, + faggingly: [FagginglyElement]? = nil, + fenks: [FenkElement]? = nil, + flagmaking: [FlagmakingElement]? = nil, + fluorometer: [Fluorometer]? = nil, + fulsome: [Int?]? = nil, + fuzzy: [Fuzzy]? = nil, + gardenwards: [Gardenward]? = nil, + generalissimo: [Generalissimo]? = nil, + habeas: [[String: Int]?]? = nil, + hemicrystalline: [Hemicrystalline]? = nil, + hemocoele: [HemocoeleElement]? = nil, + hoister: [Hoister]? = nil, + hyperpiesis: [Hyperpiesi]? = nil, + hyppish: [Hyppish]? = nil, + idealizer: [Idealizer]? = nil, + incrustator: [Incrustator]? = nil, + intentiveness: [Intentiveness]? = nil, + interacinar: Interacinar? = nil, + intercorrelation: [[Int]?]? = nil, + jacutinga: [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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum CerographElement: Codable { + case cerographClass(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(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() + } + } +} + +// MARK: - CerographClass +final class 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" + } + + init(apotropaion: JSONNull?, casuary: JSONNull?, creaker: JSONNull?, disqualification: JSONNull?, imperatorious: JSONNull?, impermeabilize: JSONNull?, metastoma: JSONNull?, noctidiurnal: JSONNull?, nonreserve: JSONNull?, ophthalmotonometry: JSONNull?, pailful: JSONNull?, pigfish: JSONNull?, pongee: JSONNull?, prosodical: JSONNull?, scrofuloderm: JSONNull?, storekeeping: JSONNull?, therologist: JSONNull?, tolowa: JSONNull?, tradeful: JSONNull?, unriveting: JSONNull?) { + self.apotropaion = apotropaion + self.casuary = casuary + self.creaker = creaker + self.disqualification = disqualification + self.imperatorious = imperatorious + self.impermeabilize = impermeabilize + self.metastoma = metastoma + self.noctidiurnal = noctidiurnal + self.nonreserve = nonreserve + self.ophthalmotonometry = ophthalmotonometry + self.pailful = pailful + self.pigfish = pigfish + self.pongee = pongee + self.prosodical = prosodical + self.scrofuloderm = scrofuloderm + self.storekeeping = storekeeping + self.therologist = therologist + self.tolowa = tolowa + self.tradeful = tradeful + self.unriveting = unriveting + } +} + +// MARK: CerographClass convenience initializers and mutators + +extension CerographClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(CerographClass.self, from: data) + self.init(apotropaion: me.apotropaion, casuary: me.casuary, creaker: me.creaker, disqualification: me.disqualification, imperatorious: me.imperatorious, impermeabilize: me.impermeabilize, metastoma: me.metastoma, noctidiurnal: me.noctidiurnal, nonreserve: me.nonreserve, ophthalmotonometry: me.ophthalmotonometry, pailful: me.pailful, pigfish: me.pigfish, pongee: me.pongee, prosodical: me.prosodical, scrofuloderm: me.scrofuloderm, storekeeping: me.storekeeping, therologist: me.therologist, tolowa: me.tolowa, tradeful: me.tradeful, unriveting: me.unriveting) + } + + convenience 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) + } + + convenience 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 + ) -> CerographClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum ChemotherapeuticElement: Codable { + case chemotherapeuticClass(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(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) + } + } +} + +// MARK: - ChemotherapeuticClass +final class 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" + } + + init(angioneurotic: JSONNull?, availment: JSONNull?, bladelet: JSONNull?, catharticalness: Double?, caulis: JSONNull?, chalcus: JSONNull?, chirotherium: Int?, disdiapason: String?, enteradenological: JSONNull?, homocerc: Bool?, imporosity: JSONNull?, insistently: JSONNull?, intraparietal: JSONNull?, ivied: JSONNull?, maureen: JSONNull?, nonbookish: JSONNull?, nostochine: JSONNull?, nutcracker: JSONNull?, ofttimes: JSONNull?, phenocryst: JSONNull?, precoincident: JSONNull?, ramiferous: JSONNull?, stagmometer: JSONNull?, tetherball: JSONNull?, unshy: JSONNull?) { + self.angioneurotic = angioneurotic + self.availment = availment + self.bladelet = bladelet + self.catharticalness = catharticalness + self.caulis = caulis + self.chalcus = chalcus + self.chirotherium = chirotherium + self.disdiapason = disdiapason + self.enteradenological = enteradenological + self.homocerc = homocerc + self.imporosity = imporosity + self.insistently = insistently + self.intraparietal = intraparietal + self.ivied = ivied + self.maureen = maureen + self.nonbookish = nonbookish + self.nostochine = nostochine + self.nutcracker = nutcracker + self.ofttimes = ofttimes + self.phenocryst = phenocryst + self.precoincident = precoincident + self.ramiferous = ramiferous + self.stagmometer = stagmometer + self.tetherball = tetherball + self.unshy = unshy + } +} + +// MARK: ChemotherapeuticClass convenience initializers and mutators + +extension ChemotherapeuticClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(ChemotherapeuticClass.self, from: data) + self.init(angioneurotic: me.angioneurotic, availment: me.availment, bladelet: me.bladelet, catharticalness: me.catharticalness, caulis: me.caulis, chalcus: me.chalcus, chirotherium: me.chirotherium, disdiapason: me.disdiapason, enteradenological: me.enteradenological, homocerc: me.homocerc, imporosity: me.imporosity, insistently: me.insistently, intraparietal: me.intraparietal, ivied: me.ivied, maureen: me.maureen, nonbookish: me.nonbookish, nostochine: me.nostochine, nutcracker: me.nutcracker, ofttimes: me.ofttimes, phenocryst: me.phenocryst, precoincident: me.precoincident, ramiferous: me.ramiferous, stagmometer: me.stagmometer, tetherball: me.tetherball, unshy: me.unshy) + } + + convenience 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) + } + + convenience 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 + ) -> ChemotherapeuticClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum CimeliaElement: Codable { + case cimeliaClass(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(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() + } + } +} + +// MARK: - CimeliaClass +final class 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" + } + + init(catharticalness: Double, chirotherium: Int, disdiapason: String, homocerc: Bool, nonbookish: JSONNull?) { + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.disdiapason = disdiapason + self.homocerc = homocerc + self.nonbookish = nonbookish + } +} + +// MARK: CimeliaClass convenience initializers and mutators + +extension CimeliaClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(CimeliaClass.self, from: data) + self.init(catharticalness: me.catharticalness, chirotherium: me.chirotherium, disdiapason: me.disdiapason, homocerc: me.homocerc, nonbookish: me.nonbookish) + } + + convenience 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) + } + + convenience 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 + ) -> CimeliaClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +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(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(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) + } + } +} + +// MARK: - CoadjustClass +final class 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" + } + + init(amidosulphonal: JSONNull?, benny: JSONNull?, catharticalness: Double?, chirotherium: Int?, disdiapason: String?, ensnare: JSONNull?, homocerc: Bool?, hybridizer: JSONNull?, leastwise: JSONNull?, lof: JSONNull?, monkhood: JSONNull?, netherlandish: JSONNull?, nonbookish: JSONNull?, peonism: JSONNull?, phonelescope: JSONNull?, porphyrogeniture: JSONNull?, preindemnify: JSONNull?, rosal: JSONNull?, scalenous: JSONNull?, scopine: JSONNull?, sedaceae: JSONNull?, suberinize: JSONNull?, symbiot: JSONNull?, tablefellow: JSONNull?, unchargeable: JSONNull?) { + self.amidosulphonal = amidosulphonal + self.benny = benny + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.disdiapason = disdiapason + self.ensnare = ensnare + self.homocerc = homocerc + self.hybridizer = hybridizer + self.leastwise = leastwise + self.lof = lof + self.monkhood = monkhood + self.netherlandish = netherlandish + self.nonbookish = nonbookish + self.peonism = peonism + self.phonelescope = phonelescope + self.porphyrogeniture = porphyrogeniture + self.preindemnify = preindemnify + self.rosal = rosal + self.scalenous = scalenous + self.scopine = scopine + self.sedaceae = sedaceae + self.suberinize = suberinize + self.symbiot = symbiot + self.tablefellow = tablefellow + self.unchargeable = unchargeable + } +} + +// MARK: CoadjustClass convenience initializers and mutators + +extension CoadjustClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(CoadjustClass.self, from: data) + self.init(amidosulphonal: me.amidosulphonal, benny: me.benny, catharticalness: me.catharticalness, chirotherium: me.chirotherium, disdiapason: me.disdiapason, ensnare: me.ensnare, homocerc: me.homocerc, hybridizer: me.hybridizer, leastwise: me.leastwise, lof: me.lof, monkhood: me.monkhood, netherlandish: me.netherlandish, nonbookish: me.nonbookish, peonism: me.peonism, phonelescope: me.phonelescope, porphyrogeniture: me.porphyrogeniture, preindemnify: me.preindemnify, rosal: me.rosal, scalenous: me.scalenous, scopine: me.scopine, sedaceae: me.sedaceae, suberinize: me.suberinize, symbiot: me.symbiot, tablefellow: me.tablefellow, unchargeable: me.unchargeable) + } + + convenience 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) + } + + convenience 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 + ) -> CoadjustClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +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(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(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) + } + } +} + +// MARK: - CredulityClass +final class 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" + } + + init(ammonolytic: JSONNull?, bushmaster: JSONNull?, considering: JSONNull?, consuetudinary: JSONNull?, embarras: JSONNull?, fineness: JSONNull?, flaithship: JSONNull?, flavia: JSONNull?, gruffly: JSONNull?, hedychium: JSONNull?, leadwort: JSONNull?, overseriously: JSONNull?, parabola: JSONNull?, pectinatodenticulate: JSONNull?, popean: JSONNull?, pornocrat: JSONNull?, quadrisect: JSONNull?, seriality: JSONNull?, vamphorn: JSONNull?, wharp: JSONNull?) { + self.ammonolytic = ammonolytic + self.bushmaster = bushmaster + self.considering = considering + self.consuetudinary = consuetudinary + self.embarras = embarras + self.fineness = fineness + self.flaithship = flaithship + self.flavia = flavia + self.gruffly = gruffly + self.hedychium = hedychium + self.leadwort = leadwort + self.overseriously = overseriously + self.parabola = parabola + self.pectinatodenticulate = pectinatodenticulate + self.popean = popean + self.pornocrat = pornocrat + self.quadrisect = quadrisect + self.seriality = seriality + self.vamphorn = vamphorn + self.wharp = wharp + } +} + +// MARK: CredulityClass convenience initializers and mutators + +extension CredulityClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(CredulityClass.self, from: data) + self.init(ammonolytic: me.ammonolytic, bushmaster: me.bushmaster, considering: me.considering, consuetudinary: me.consuetudinary, embarras: me.embarras, fineness: me.fineness, flaithship: me.flaithship, flavia: me.flavia, gruffly: me.gruffly, hedychium: me.hedychium, leadwort: me.leadwort, overseriously: me.overseriously, parabola: me.parabola, pectinatodenticulate: me.pectinatodenticulate, popean: me.popean, pornocrat: me.pornocrat, quadrisect: me.quadrisect, seriality: me.seriality, vamphorn: me.vamphorn, wharp: me.wharp) + } + + convenience 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) + } + + convenience 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 + ) -> CredulityClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +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(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(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) + } + } +} + +// MARK: - DeruralizeClass +final class 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" + } + + init(bockerel: JSONNull?, boulder: JSONNull?, churrus: JSONNull?, counterdigged: JSONNull?, dialogite: JSONNull?, digenic: JSONNull?, dunbird: JSONNull?, ergatogyne: JSONNull?, fiendful: JSONNull?, jackrod: JSONNull?, jehovistic: JSONNull?, paninean: JSONNull?, panther: JSONNull?, placentigerous: JSONNull?, romney: JSONNull?, sparm: JSONNull?, tocsin: JSONNull?, unnicked: JSONNull?, unstavable: JSONNull?, windfirm: JSONNull?) { + self.bockerel = bockerel + self.boulder = boulder + self.churrus = churrus + self.counterdigged = counterdigged + self.dialogite = dialogite + self.digenic = digenic + self.dunbird = dunbird + self.ergatogyne = ergatogyne + self.fiendful = fiendful + self.jackrod = jackrod + self.jehovistic = jehovistic + self.paninean = paninean + self.panther = panther + self.placentigerous = placentigerous + self.romney = romney + self.sparm = sparm + self.tocsin = tocsin + self.unnicked = unnicked + self.unstavable = unstavable + self.windfirm = windfirm + } +} + +// MARK: DeruralizeClass convenience initializers and mutators + +extension DeruralizeClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(DeruralizeClass.self, from: data) + self.init(bockerel: me.bockerel, boulder: me.boulder, churrus: me.churrus, counterdigged: me.counterdigged, dialogite: me.dialogite, digenic: me.digenic, dunbird: me.dunbird, ergatogyne: me.ergatogyne, fiendful: me.fiendful, jackrod: me.jackrod, jehovistic: me.jehovistic, paninean: me.paninean, panther: me.panther, placentigerous: me.placentigerous, romney: me.romney, sparm: me.sparm, tocsin: me.tocsin, unnicked: me.unnicked, unstavable: me.unstavable, windfirm: me.windfirm) + } + + convenience 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) + } + + convenience 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 + ) -> DeruralizeClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum DiaereseElement: Codable { + case bool(Bool) + case diaereseClass(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(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) + } + } +} + +// MARK: - DiaereseClass +final class 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" + } + + init(amoreuxia: JSONNull?, ani: JSONNull?, bernicle: JSONNull?, blackwasher: JSONNull?, blowhard: JSONNull?, broma: JSONNull?, closecross: JSONNull?, congregationalism: JSONNull?, grayly: JSONNull?, historically: JSONNull?, hoast: JSONNull?, irretentive: JSONNull?, parcener: JSONNull?, pedder: JSONNull?, pseudoanatomic: JSONNull?, rhizocarpian: JSONNull?, samel: JSONNull?, silker: JSONNull?, subdentated: JSONNull?, subobscure: JSONNull?) { + self.amoreuxia = amoreuxia + self.ani = ani + self.bernicle = bernicle + self.blackwasher = blackwasher + self.blowhard = blowhard + self.broma = broma + self.closecross = closecross + self.congregationalism = congregationalism + self.grayly = grayly + self.historically = historically + self.hoast = hoast + self.irretentive = irretentive + self.parcener = parcener + self.pedder = pedder + self.pseudoanatomic = pseudoanatomic + self.rhizocarpian = rhizocarpian + self.samel = samel + self.silker = silker + self.subdentated = subdentated + self.subobscure = subobscure + } +} + +// MARK: DiaereseClass convenience initializers and mutators + +extension DiaereseClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(DiaereseClass.self, from: data) + self.init(amoreuxia: me.amoreuxia, ani: me.ani, bernicle: me.bernicle, blackwasher: me.blackwasher, blowhard: me.blowhard, broma: me.broma, closecross: me.closecross, congregationalism: me.congregationalism, grayly: me.grayly, historically: me.historically, hoast: me.hoast, irretentive: me.irretentive, parcener: me.parcener, pedder: me.pedder, pseudoanatomic: me.pseudoanatomic, rhizocarpian: me.rhizocarpian, samel: me.samel, silker: me.silker, subdentated: me.subdentated, subobscure: me.subobscure) + } + + convenience 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) + } + + convenience 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 + ) -> DiaereseClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +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) + } + } +} + +// MARK: - Encrust +final class 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" + } + + init(comradely: JSONNull?, diacanthous: JSONNull?, feminineness: JSONNull?, gossamered: JSONNull?, hibernia: JSONNull?, hibiscus: JSONNull?, lepidosauria: JSONNull?, lollingly: JSONNull?, manager: JSONNull?, mechanic: JSONNull?, overminuteness: JSONNull?, papelonne: JSONNull?, plebification: JSONNull?, pugmiller: JSONNull?, recoveror: JSONNull?, spermatoblastic: JSONNull?, syllidae: JSONNull?, ungyved: JSONNull?, whirlabout: JSONNull?, woodenware: JSONNull?) { + self.comradely = comradely + self.diacanthous = diacanthous + self.feminineness = feminineness + self.gossamered = gossamered + self.hibernia = hibernia + self.hibiscus = hibiscus + self.lepidosauria = lepidosauria + self.lollingly = lollingly + self.manager = manager + self.mechanic = mechanic + self.overminuteness = overminuteness + self.papelonne = papelonne + self.plebification = plebification + self.pugmiller = pugmiller + self.recoveror = recoveror + self.spermatoblastic = spermatoblastic + self.syllidae = syllidae + self.ungyved = ungyved + self.whirlabout = whirlabout + self.woodenware = woodenware + } +} + +// MARK: Encrust convenience initializers and mutators + +extension Encrust { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Encrust.self, from: data) + self.init(comradely: me.comradely, diacanthous: me.diacanthous, feminineness: me.feminineness, gossamered: me.gossamered, hibernia: me.hibernia, hibiscus: me.hibiscus, lepidosauria: me.lepidosauria, lollingly: me.lollingly, manager: me.manager, mechanic: me.mechanic, overminuteness: me.overminuteness, papelonne: me.papelonne, plebification: me.plebification, pugmiller: me.pugmiller, recoveror: me.recoveror, spermatoblastic: me.spermatoblastic, syllidae: me.syllidae, ungyved: me.ungyved, whirlabout: me.whirlabout, woodenware: me.woodenware) + } + + convenience 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) + } + + convenience 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 + ) -> Encrust { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Entomoid: Codable { + case cimeliaClass(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(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(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(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(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(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) + } + } +} + +// MARK: - FagginglyClass +final class 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" + } + + init(abranchian: JSONNull?, aculeiform: JSONNull?, adiaphoristic: JSONNull?, adoptionism: JSONNull?, anglic: JSONNull?, antrotomy: JSONNull?, coerciveness: JSONNull?, decorist: JSONNull?, duckhood: JSONNull?, heteromeri: JSONNull?, hypochnose: JSONNull?, lochage: JSONNull?, melee: JSONNull?, nonconformitant: JSONNull?, poinsettia: JSONNull?, putatively: JSONNull?, semivolatile: JSONNull?, soleas: JSONNull?, unfastenable: JSONNull?, unmillinered: JSONNull?) { + self.abranchian = abranchian + self.aculeiform = aculeiform + self.adiaphoristic = adiaphoristic + self.adoptionism = adoptionism + self.anglic = anglic + self.antrotomy = antrotomy + self.coerciveness = coerciveness + self.decorist = decorist + self.duckhood = duckhood + self.heteromeri = heteromeri + self.hypochnose = hypochnose + self.lochage = lochage + self.melee = melee + self.nonconformitant = nonconformitant + self.poinsettia = poinsettia + self.putatively = putatively + self.semivolatile = semivolatile + self.soleas = soleas + self.unfastenable = unfastenable + self.unmillinered = unmillinered + } +} + +// MARK: FagginglyClass convenience initializers and mutators + +extension FagginglyClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(FagginglyClass.self, from: data) + self.init(abranchian: me.abranchian, aculeiform: me.aculeiform, adiaphoristic: me.adiaphoristic, adoptionism: me.adoptionism, anglic: me.anglic, antrotomy: me.antrotomy, coerciveness: me.coerciveness, decorist: me.decorist, duckhood: me.duckhood, heteromeri: me.heteromeri, hypochnose: me.hypochnose, lochage: me.lochage, melee: me.melee, nonconformitant: me.nonconformitant, poinsettia: me.poinsettia, putatively: me.putatively, semivolatile: me.semivolatile, soleas: me.soleas, unfastenable: me.unfastenable, unmillinered: me.unmillinered) + } + + convenience 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) + } + + convenience 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 + ) -> FagginglyClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum FenkElement: Codable { + case fenkClass(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(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) + } + } +} + +// MARK: - FenkClass +final class 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" + } + + init(apoise: JSONNull?, astronomize: JSONNull?, cockhorse: JSONNull?, copular: JSONNull?, dagomba: JSONNull?, draffy: JSONNull?, foreigner: JSONNull?, guyandot: JSONNull?, neurogliosis: JSONNull?, osmious: JSONNull?, palpitate: JSONNull?, rebukeable: JSONNull?, reinwardtia: JSONNull?, reservatory: JSONNull?, scalt: JSONNull?, scripturalize: JSONNull?, tintometer: JSONNull?, tritoness: JSONNull?, undergrade: JSONNull?, undermountain: JSONNull?) { + self.apoise = apoise + self.astronomize = astronomize + self.cockhorse = cockhorse + self.copular = copular + self.dagomba = dagomba + self.draffy = draffy + self.foreigner = foreigner + self.guyandot = guyandot + self.neurogliosis = neurogliosis + self.osmious = osmious + self.palpitate = palpitate + self.rebukeable = rebukeable + self.reinwardtia = reinwardtia + self.reservatory = reservatory + self.scalt = scalt + self.scripturalize = scripturalize + self.tintometer = tintometer + self.tritoness = tritoness + self.undergrade = undergrade + self.undermountain = undermountain + } +} + +// MARK: FenkClass convenience initializers and mutators + +extension FenkClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(FenkClass.self, from: data) + self.init(apoise: me.apoise, astronomize: me.astronomize, cockhorse: me.cockhorse, copular: me.copular, dagomba: me.dagomba, draffy: me.draffy, foreigner: me.foreigner, guyandot: me.guyandot, neurogliosis: me.neurogliosis, osmious: me.osmious, palpitate: me.palpitate, rebukeable: me.rebukeable, reinwardtia: me.reinwardtia, reservatory: me.reservatory, scalt: me.scalt, scripturalize: me.scripturalize, tintometer: me.tintometer, tritoness: me.tritoness, undergrade: me.undergrade, undermountain: me.undermountain) + } + + convenience 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) + } + + convenience 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 + ) -> FenkClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum FlagmakingElement: Codable { + case bool(Bool) + case double(Double) + case flagmakingClass(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(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) + } + } +} + +// MARK: - FlagmakingClass +final class 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" + } + + init(albarco: JSONNull?, bunodonta: JSONNull?, hornify: JSONNull?, hydrocorisae: JSONNull?, hypoglossus: JSONNull?, inexpiably: JSONNull?, ingratitude: JSONNull?, ladyfly: JSONNull?, medicament: JSONNull?, monogrammatic: JSONNull?, nobbut: JSONNull?, notacanthidae: JSONNull?, polyplacophore: JSONNull?, proexercise: JSONNull?, protoplast: JSONNull?, puzzling: JSONNull?, splanchnoskeleton: JSONNull?, unloveliness: JSONNull?, unquarantined: JSONNull?, unrenounceable: JSONNull?) { + self.albarco = albarco + self.bunodonta = bunodonta + self.hornify = hornify + self.hydrocorisae = hydrocorisae + self.hypoglossus = hypoglossus + self.inexpiably = inexpiably + self.ingratitude = ingratitude + self.ladyfly = ladyfly + self.medicament = medicament + self.monogrammatic = monogrammatic + self.nobbut = nobbut + self.notacanthidae = notacanthidae + self.polyplacophore = polyplacophore + self.proexercise = proexercise + self.protoplast = protoplast + self.puzzling = puzzling + self.splanchnoskeleton = splanchnoskeleton + self.unloveliness = unloveliness + self.unquarantined = unquarantined + self.unrenounceable = unrenounceable + } +} + +// MARK: FlagmakingClass convenience initializers and mutators + +extension FlagmakingClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(FlagmakingClass.self, from: data) + self.init(albarco: me.albarco, bunodonta: me.bunodonta, hornify: me.hornify, hydrocorisae: me.hydrocorisae, hypoglossus: me.hypoglossus, inexpiably: me.inexpiably, ingratitude: me.ingratitude, ladyfly: me.ladyfly, medicament: me.medicament, monogrammatic: me.monogrammatic, nobbut: me.nobbut, notacanthidae: me.notacanthidae, polyplacophore: me.polyplacophore, proexercise: me.proexercise, protoplast: me.protoplast, puzzling: me.puzzling, splanchnoskeleton: me.splanchnoskeleton, unloveliness: me.unloveliness, unquarantined: me.unquarantined, unrenounceable: me.unrenounceable) + } + + convenience 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) + } + + convenience 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 + ) -> FlagmakingClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +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(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(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(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(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) + } + } +} + +// MARK: - HemocoeleClass +final class 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" + } + + init(acrogamy: JSONNull?, amelification: JSONNull?, autobiographic: JSONNull?, berat: JSONNull?, catharticalness: Double?, chirotherium: Int?, disdiapason: String?, disproportionably: JSONNull?, erythrite: JSONNull?, graphic: JSONNull?, hepatological: JSONNull?, homocerc: Bool?, incommensurably: JSONNull?, misaffirm: JSONNull?, nonbookish: JSONNull?, pocketbook: JSONNull?, sclerometric: JSONNull?, stambouline: JSONNull?, stickpin: JSONNull?, tubulure: JSONNull?, undelated: JSONNull?, unsalt: JSONNull?, untutelar: JSONNull?, vagrant: JSONNull?, walt: JSONNull?) { + self.acrogamy = acrogamy + self.amelification = amelification + self.autobiographic = autobiographic + self.berat = berat + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.disdiapason = disdiapason + self.disproportionably = disproportionably + self.erythrite = erythrite + self.graphic = graphic + self.hepatological = hepatological + self.homocerc = homocerc + self.incommensurably = incommensurably + self.misaffirm = misaffirm + self.nonbookish = nonbookish + self.pocketbook = pocketbook + self.sclerometric = sclerometric + self.stambouline = stambouline + self.stickpin = stickpin + self.tubulure = tubulure + self.undelated = undelated + self.unsalt = unsalt + self.untutelar = untutelar + self.vagrant = vagrant + self.walt = walt + } +} + +// MARK: HemocoeleClass convenience initializers and mutators + +extension HemocoeleClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(HemocoeleClass.self, from: data) + self.init(acrogamy: me.acrogamy, amelification: me.amelification, autobiographic: me.autobiographic, berat: me.berat, catharticalness: me.catharticalness, chirotherium: me.chirotherium, disdiapason: me.disdiapason, disproportionably: me.disproportionably, erythrite: me.erythrite, graphic: me.graphic, hepatological: me.hepatological, homocerc: me.homocerc, incommensurably: me.incommensurably, misaffirm: me.misaffirm, nonbookish: me.nonbookish, pocketbook: me.pocketbook, sclerometric: me.sclerometric, stambouline: me.stambouline, stickpin: me.stickpin, tubulure: me.tubulure, undelated: me.undelated, unsalt: me.unsalt, untutelar: me.untutelar, vagrant: me.vagrant, walt: me.walt) + } + + convenience 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) + } + + convenience 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 + ) -> HemocoeleClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Hoister: Codable { + case cimeliaClass(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(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(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(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(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(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(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(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) + } + } +} + +// MARK: - Interacinar +final class 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" + } + + init(assapan: Double, benefactorship: Bool, triseriatim: String, tubbing: Int, untrimmed: JSONNull?) { + self.assapan = assapan + self.benefactorship = benefactorship + self.triseriatim = triseriatim + self.tubbing = tubbing + self.untrimmed = untrimmed + } +} + +// MARK: Interacinar convenience initializers and mutators + +extension Interacinar { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Interacinar.self, from: data) + self.init(assapan: me.assapan, benefactorship: me.benefactorship, triseriatim: me.triseriatim, tubbing: me.tubbing, untrimmed: me.untrimmed) + } + + convenience 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) + } + + convenience 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 + ) -> Interacinar { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +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 + +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:ss.SSSSSSXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder +} + +// MARK: - Encode/decode helpers + +final 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/combinations1.json/protocol-hashable--739b516c7897/quicktype.swift b/head/swift/test/inputs/json/priority/combinations1.json/protocol-hashable--739b516c7897/quicktype.swift new file mode 100644 index 0000000..740138a --- /dev/null +++ b/head/swift/test/inputs/json/priority/combinations1.json/protocol-hashable--739b516c7897/quicktype.swift @@ -0,0 +1,2922 @@ +// 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) + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +import Foundation + +// MARK: - TopLevel +struct TopLevel: Codable, Hashable { + let centrodesmose: String + let cerograph: [CerographElement] + let chemotherapeutics: [ChemotherapeuticElement] + let cimelia: [CimeliaElement] + let citrated: Int + let clinodome: [Clinodome] + let coadjust: [CoadjustElement] + let consilience: [Consilience] + let constructor: [Constructor] + let continuative: [Continuative] + let credulity: [CredulityElement] + let creviced: [Creviced] + let cubiculum: [[Int?]] + let deruralize: [DeruralizeElement] + let diaereses: [DiaereseElement] + let dissolution: [[JSONNull?]?] + let downstroke: [Downstroke] + let electrotautomerism: [Double?] + let eleutheromania: [Eleutheromania] + let encrust: Encrust + let entomoid: [Entomoid] + let epipaleolithic: [Epipaleolithic] + let expropriable: [Expropriable] + let faggingly: [FagginglyElement] + let fenks: [FenkElement] + let flagmaking: [FlagmakingElement] + let fluorometer: [Fluorometer] + let fulsome: [Int?] + let fuzzy: [Fuzzy] + let gardenwards: [Gardenward] + let generalissimo: [Generalissimo] + let habeas: [[String: Int]?] + let hemicrystalline: [Hemicrystalline] + let hemocoele: [HemocoeleElement] + let hoister: [Hoister] + let hyperpiesis: [Hyperpiesi] + let hyppish: [Hyppish] + let idealizer: [Idealizer] + let incrustator: [Incrustator] + let intentiveness: [Intentiveness] + let interacinar: Interacinar + let intercorrelation: [[Int]?] + let jacutinga: [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" + } +} + +// 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( + centrodesmose: String? = nil, + cerograph: [CerographElement]? = nil, + chemotherapeutics: [ChemotherapeuticElement]? = nil, + cimelia: [CimeliaElement]? = nil, + citrated: Int? = nil, + clinodome: [Clinodome]? = nil, + coadjust: [CoadjustElement]? = nil, + consilience: [Consilience]? = nil, + constructor: [Constructor]? = nil, + continuative: [Continuative]? = nil, + credulity: [CredulityElement]? = nil, + creviced: [Creviced]? = nil, + cubiculum: [[Int?]]? = nil, + deruralize: [DeruralizeElement]? = nil, + diaereses: [DiaereseElement]? = nil, + dissolution: [[JSONNull?]?]? = nil, + downstroke: [Downstroke]? = nil, + electrotautomerism: [Double?]? = nil, + eleutheromania: [Eleutheromania]? = nil, + encrust: Encrust? = nil, + entomoid: [Entomoid]? = nil, + epipaleolithic: [Epipaleolithic]? = nil, + expropriable: [Expropriable]? = nil, + faggingly: [FagginglyElement]? = nil, + fenks: [FenkElement]? = nil, + flagmaking: [FlagmakingElement]? = nil, + fluorometer: [Fluorometer]? = nil, + fulsome: [Int?]? = nil, + fuzzy: [Fuzzy]? = nil, + gardenwards: [Gardenward]? = nil, + generalissimo: [Generalissimo]? = nil, + habeas: [[String: Int]?]? = nil, + hemicrystalline: [Hemicrystalline]? = nil, + hemocoele: [HemocoeleElement]? = nil, + hoister: [Hoister]? = nil, + hyperpiesis: [Hyperpiesi]? = nil, + hyppish: [Hyppish]? = nil, + idealizer: [Idealizer]? = nil, + incrustator: [Incrustator]? = nil, + intentiveness: [Intentiveness]? = nil, + interacinar: Interacinar? = nil, + intercorrelation: [[Int]?]? = nil, + jacutinga: [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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum CerographElement: Codable, Hashable { + case cerographClass(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(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() + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - CerographClass +struct CerographClass: Codable, Hashable { + 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" + } +} + +// MARK: CerographClass convenience initializers and mutators + +extension CerographClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> CerographClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum ChemotherapeuticElement: Codable, Hashable { + case chemotherapeuticClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - ChemotherapeuticClass +struct ChemotherapeuticClass: Codable, Hashable { + 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" + } +} + +// MARK: ChemotherapeuticClass convenience initializers and mutators + +extension ChemotherapeuticClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> ChemotherapeuticClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum CimeliaElement: Codable, Hashable { + case cimeliaClass(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(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() + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - CimeliaClass +struct CimeliaClass: Codable, Hashable { + 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" + } +} + +// MARK: CimeliaClass convenience initializers and mutators + +extension CimeliaClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> CimeliaClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Clinodome: Codable, Hashable { + 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, Hashable { + case coadjustClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - CoadjustClass +struct CoadjustClass: Codable, Hashable { + 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" + } +} + +// MARK: CoadjustClass convenience initializers and mutators + +extension CoadjustClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> CoadjustClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Consilience: Codable, Hashable { + 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, Hashable { + 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, Hashable { + 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, Hashable { + case credulityClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - CredulityClass +struct CredulityClass: Codable, Hashable { + 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" + } +} + +// MARK: CredulityClass convenience initializers and mutators + +extension CredulityClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> CredulityClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Creviced: Codable, Hashable { + 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, Hashable { + case bool(Bool) + case deruralizeClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - DeruralizeClass +struct DeruralizeClass: Codable, Hashable { + 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" + } +} + +// MARK: DeruralizeClass convenience initializers and mutators + +extension DeruralizeClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> DeruralizeClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum DiaereseElement: Codable, Hashable { + case bool(Bool) + case diaereseClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - DiaereseClass +struct DiaereseClass: Codable, Hashable { + 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" + } +} + +// MARK: DiaereseClass convenience initializers and mutators + +extension DiaereseClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> DiaereseClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Downstroke: Codable, Hashable { + 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, Hashable { + 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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - Encrust +struct Encrust: Codable, Hashable { + 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" + } +} + +// MARK: Encrust convenience initializers and mutators + +extension Encrust { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> Encrust { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Entomoid: Codable, Hashable { + case cimeliaClass(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(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, Hashable { + 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, Hashable { + case cimeliaClass(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(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, Hashable { + case double(Double) + case fagginglyClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - FagginglyClass +struct FagginglyClass: Codable, Hashable { + 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" + } +} + +// MARK: FagginglyClass convenience initializers and mutators + +extension FagginglyClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> FagginglyClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum FenkElement: Codable, Hashable { + case fenkClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - FenkClass +struct FenkClass: Codable, Hashable { + 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" + } +} + +// MARK: FenkClass convenience initializers and mutators + +extension FenkClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> FenkClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum FlagmakingElement: Codable, Hashable { + case bool(Bool) + case double(Double) + case flagmakingClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - FlagmakingClass +struct FlagmakingClass: Codable, Hashable { + 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" + } +} + +// MARK: FlagmakingClass convenience initializers and mutators + +extension FlagmakingClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> FlagmakingClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Fluorometer: Codable, Hashable { + 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, Hashable { + 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, Hashable { + 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, Hashable { + 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, Hashable { + case cimeliaClass(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(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, Hashable { + case hemocoeleClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - HemocoeleClass +struct HemocoeleClass: Codable, Hashable { + 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" + } +} + +// MARK: HemocoeleClass convenience initializers and mutators + +extension HemocoeleClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> HemocoeleClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Hoister: Codable, Hashable { + case cimeliaClass(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(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, Hashable { + case cimeliaClass(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(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, Hashable { + 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, Hashable { + case cimeliaClass(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(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, Hashable { + 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, Hashable { + case cimeliaClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - Interacinar +struct Interacinar: Codable, Hashable { + 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" + } +} + +// MARK: Interacinar convenience initializers and mutators + +extension Interacinar { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> Interacinar { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Jacutinga: Codable, Hashable { + 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 + +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:ss.SSSSSSXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder +} + +// 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/final-classes-true__struct-or-class-class--d3c62ec7414d/quicktype.swift b/head/swift/test/inputs/json/priority/combinations2.json/final-classes-true__struct-or-class-class--d3c62ec7414d/quicktype.swift new file mode 100644 index 0000000..9d37c26 --- /dev/null +++ b/head/swift/test/inputs/json/priority/combinations2.json/final-classes-true__struct-or-class-class--d3c62ec7414d/quicktype.swift @@ -0,0 +1,2891 @@ +// 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 +final class TopLevel: Codable { + let abranchiata: [Abranchiata] + let academe: [Academe] + let acquirable: [Acquirable] + let aerometry: [Aerometry] + let alexin: [Alexin] + let alleviate: [AlleviateElement] + let amaas: [Amaa] + let ambassage: [Ambassage] + let amphithyron: [Amphithyron?] + let andriana: [String?] + let ankee: [AnkeeElement] + let annihilator: [[String: Int?]?] + let annulose: JSONNull? + let ansarie: [AnsarieElement] + let aphasia: [Aphasia] + let asprawl: [Asprawl] + let attractive: [Bool?] + let barksome: [String: Int] + let bedesman: [Bedesman] + let belard: [Belard] + let bocking: [Bocking] + let brawlingly: [Brawlingly] + let brookie: [Brookie] + let bumboatman: [Bumboatman] + let bystreet: [JSONNull?] + let calaverite: [Calaverite] + let catallactic: [Catallactic] + let cemental: [Cemental] + let chytridiaceae: [ChytridiaceaeElement] + let discordia: [DiscordiaElement] + let endomyces: [Endomyce] + let epinephelidae: [Epinephelidae] + let eupatorium: [Eupatorium] + let gryphosaurus: [GryphosaurusElement] + let koryak: [Koryak] + let lavinia: [LaviniaElement] + let oskar: [OskarElement] + let rebecca: [RebeccaElement] + let rhomboganoidei: [Rhomboganoidei] + let rigsmal: Bool + let ruellia: [Ruellia] + let school: [School] + let shakespearolater: [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" + } + + init(abranchiata: [Abranchiata], academe: [Academe], acquirable: [Acquirable], aerometry: [Aerometry], alexin: [Alexin], alleviate: [AlleviateElement], amaas: [Amaa], ambassage: [Ambassage], amphithyron: [Amphithyron?], andriana: [String?], ankee: [AnkeeElement], annihilator: [[String: Int?]?], annulose: JSONNull?, ansarie: [AnsarieElement], aphasia: [Aphasia], asprawl: [Asprawl], attractive: [Bool?], barksome: [String: Int], bedesman: [Bedesman], belard: [Belard], bocking: [Bocking], brawlingly: [Brawlingly], brookie: [Brookie], bumboatman: [Bumboatman], bystreet: [JSONNull?], calaverite: [Calaverite], catallactic: [Catallactic], cemental: [Cemental], chytridiaceae: [ChytridiaceaeElement], discordia: [DiscordiaElement], endomyces: [Endomyce], epinephelidae: [Epinephelidae], eupatorium: [Eupatorium], gryphosaurus: [GryphosaurusElement], koryak: [Koryak], lavinia: [LaviniaElement], oskar: [OskarElement], rebecca: [RebeccaElement], rhomboganoidei: [Rhomboganoidei], rigsmal: Bool, ruellia: [Ruellia], school: [School], shakespearolater: [Shakespearolater], svan: [Double], wayao: [String: Double]) { + self.abranchiata = abranchiata + self.academe = academe + self.acquirable = acquirable + self.aerometry = aerometry + self.alexin = alexin + self.alleviate = alleviate + self.amaas = amaas + self.ambassage = ambassage + self.amphithyron = amphithyron + self.andriana = andriana + self.ankee = ankee + self.annihilator = annihilator + self.annulose = annulose + self.ansarie = ansarie + self.aphasia = aphasia + self.asprawl = asprawl + self.attractive = attractive + self.barksome = barksome + self.bedesman = bedesman + self.belard = belard + self.bocking = bocking + self.brawlingly = brawlingly + self.brookie = brookie + self.bumboatman = bumboatman + self.bystreet = bystreet + self.calaverite = calaverite + self.catallactic = catallactic + self.cemental = cemental + self.chytridiaceae = chytridiaceae + self.discordia = discordia + self.endomyces = endomyces + self.epinephelidae = epinephelidae + self.eupatorium = eupatorium + self.gryphosaurus = gryphosaurus + self.koryak = koryak + self.lavinia = lavinia + self.oskar = oskar + self.rebecca = rebecca + self.rhomboganoidei = rhomboganoidei + self.rigsmal = rigsmal + self.ruellia = ruellia + self.school = school + self.shakespearolater = shakespearolater + self.svan = svan + self.wayao = wayao + } +} + +// MARK: TopLevel convenience initializers and mutators + +extension TopLevel { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(TopLevel.self, from: data) + self.init(abranchiata: me.abranchiata, academe: me.academe, acquirable: me.acquirable, aerometry: me.aerometry, alexin: me.alexin, alleviate: me.alleviate, amaas: me.amaas, ambassage: me.ambassage, amphithyron: me.amphithyron, andriana: me.andriana, ankee: me.ankee, annihilator: me.annihilator, annulose: me.annulose, ansarie: me.ansarie, aphasia: me.aphasia, asprawl: me.asprawl, attractive: me.attractive, barksome: me.barksome, bedesman: me.bedesman, belard: me.belard, bocking: me.bocking, brawlingly: me.brawlingly, brookie: me.brookie, bumboatman: me.bumboatman, bystreet: me.bystreet, calaverite: me.calaverite, catallactic: me.catallactic, cemental: me.cemental, chytridiaceae: me.chytridiaceae, discordia: me.discordia, endomyces: me.endomyces, epinephelidae: me.epinephelidae, eupatorium: me.eupatorium, gryphosaurus: me.gryphosaurus, koryak: me.koryak, lavinia: me.lavinia, oskar: me.oskar, rebecca: me.rebecca, rhomboganoidei: me.rhomboganoidei, rigsmal: me.rigsmal, ruellia: me.ruellia, school: me.school, shakespearolater: me.shakespearolater, svan: me.svan, wayao: me.wayao) + } + + convenience 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) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + abranchiata: [Abranchiata]? = nil, + academe: [Academe]? = nil, + acquirable: [Acquirable]? = nil, + aerometry: [Aerometry]? = nil, + alexin: [Alexin]? = nil, + alleviate: [AlleviateElement]? = nil, + amaas: [Amaa]? = nil, + ambassage: [Ambassage]? = nil, + amphithyron: [Amphithyron?]? = nil, + andriana: [String?]? = nil, + ankee: [AnkeeElement]? = nil, + annihilator: [[String: Int?]?]? = nil, + annulose: JSONNull?? = nil, + ansarie: [AnsarieElement]? = nil, + aphasia: [Aphasia]? = nil, + asprawl: [Asprawl]? = nil, + attractive: [Bool?]? = nil, + barksome: [String: Int]? = nil, + bedesman: [Bedesman]? = nil, + belard: [Belard]? = nil, + bocking: [Bocking]? = nil, + brawlingly: [Brawlingly]? = nil, + brookie: [Brookie]? = nil, + bumboatman: [Bumboatman]? = nil, + bystreet: [JSONNull?]? = nil, + calaverite: [Calaverite]? = nil, + catallactic: [Catallactic]? = nil, + cemental: [Cemental]? = nil, + chytridiaceae: [ChytridiaceaeElement]? = nil, + discordia: [DiscordiaElement]? = nil, + endomyces: [Endomyce]? = nil, + epinephelidae: [Epinephelidae]? = nil, + eupatorium: [Eupatorium]? = nil, + gryphosaurus: [GryphosaurusElement]? = nil, + koryak: [Koryak]? = nil, + lavinia: [LaviniaElement]? = nil, + oskar: [OskarElement]? = nil, + rebecca: [RebeccaElement]? = nil, + rhomboganoidei: [Rhomboganoidei]? = nil, + rigsmal: Bool? = nil, + ruellia: [Ruellia]? = nil, + school: [School]? = nil, + shakespearolater: [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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +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 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(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(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) + } + } +} + +// MARK: - AlleviateClass +final class 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" + } + + init(apriori: JSONNull?, beggarer: JSONNull?, brokenheartedly: JSONNull?, debilitation: JSONNull?, frike: JSONNull?, gastrolith: JSONNull?, hulsean: JSONNull?, orthocentric: JSONNull?, petaly: JSONNull?, probudgeting: JSONNull?, reacquire: JSONNull?, scow: JSONNull?, shutoff: JSONNull?, subcontiguous: JSONNull?, suffumigate: JSONNull?, transformable: JSONNull?, uncoroneted: JSONNull?, unparking: JSONNull?, unvarnishedness: JSONNull?, wherewithal: JSONNull?) { + self.apriori = apriori + self.beggarer = beggarer + self.brokenheartedly = brokenheartedly + self.debilitation = debilitation + self.frike = frike + self.gastrolith = gastrolith + self.hulsean = hulsean + self.orthocentric = orthocentric + self.petaly = petaly + self.probudgeting = probudgeting + self.reacquire = reacquire + self.scow = scow + self.shutoff = shutoff + self.subcontiguous = subcontiguous + self.suffumigate = suffumigate + self.transformable = transformable + self.uncoroneted = uncoroneted + self.unparking = unparking + self.unvarnishedness = unvarnishedness + self.wherewithal = wherewithal + } +} + +// MARK: AlleviateClass convenience initializers and mutators + +extension AlleviateClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(AlleviateClass.self, from: data) + self.init(apriori: me.apriori, beggarer: me.beggarer, brokenheartedly: me.brokenheartedly, debilitation: me.debilitation, frike: me.frike, gastrolith: me.gastrolith, hulsean: me.hulsean, orthocentric: me.orthocentric, petaly: me.petaly, probudgeting: me.probudgeting, reacquire: me.reacquire, scow: me.scow, shutoff: me.shutoff, subcontiguous: me.subcontiguous, suffumigate: me.suffumigate, transformable: me.transformable, uncoroneted: me.uncoroneted, unparking: me.unparking, unvarnishedness: me.unvarnishedness, wherewithal: me.wherewithal) + } + + convenience 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) + } + + convenience 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 + ) -> AlleviateClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Amaa: Codable { + case bool(Bool) + case integer(Int) + case rebecca(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(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) + } + } +} + +// MARK: - Rebecca +final class 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" + } + + init(catharticalness: Double, chirotherium: Int, disdiapason: String, homocerc: Bool, nonbookish: JSONNull?) { + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.disdiapason = disdiapason + self.homocerc = homocerc + self.nonbookish = nonbookish + } +} + +// MARK: Rebecca convenience initializers and mutators + +extension Rebecca { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Rebecca.self, from: data) + self.init(catharticalness: me.catharticalness, chirotherium: me.chirotherium, disdiapason: me.disdiapason, homocerc: me.homocerc, nonbookish: me.nonbookish) + } + + convenience 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) + } + + convenience 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 + ) -> Rebecca { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +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) + } + } +} + +// MARK: - Amphithyron +final class 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" + } + + init(akroasis: Int?, antiphonical: Int?, basebred: Int?, catharticalness: Double?, chirotherium: Int?, conductometric: Int?, disdiapason: String?, ensilation: Int?, eyebolt: Int?, fistulated: Int?, heteropod: Int?, homocerc: Bool?, juniperus: Int?, labyrinthically: Int?, martyrization: Int?, mispolicy: Int?, multipara: Int?, nazirite: Int?, nonbookish: JSONNull?, possessorial: Int?, shamed: Int?, shelfworn: Int?, stagnum: Int?, those: Int?, undecimal: Int?) { + self.akroasis = akroasis + self.antiphonical = antiphonical + self.basebred = basebred + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.conductometric = conductometric + self.disdiapason = disdiapason + self.ensilation = ensilation + self.eyebolt = eyebolt + self.fistulated = fistulated + self.heteropod = heteropod + self.homocerc = homocerc + self.juniperus = juniperus + self.labyrinthically = labyrinthically + self.martyrization = martyrization + self.mispolicy = mispolicy + self.multipara = multipara + self.nazirite = nazirite + self.nonbookish = nonbookish + self.possessorial = possessorial + self.shamed = shamed + self.shelfworn = shelfworn + self.stagnum = stagnum + self.those = those + self.undecimal = undecimal + } +} + +// MARK: Amphithyron convenience initializers and mutators + +extension Amphithyron { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Amphithyron.self, from: data) + self.init(akroasis: me.akroasis, antiphonical: me.antiphonical, basebred: me.basebred, catharticalness: me.catharticalness, chirotherium: me.chirotherium, conductometric: me.conductometric, disdiapason: me.disdiapason, ensilation: me.ensilation, eyebolt: me.eyebolt, fistulated: me.fistulated, heteropod: me.heteropod, homocerc: me.homocerc, juniperus: me.juniperus, labyrinthically: me.labyrinthically, martyrization: me.martyrization, mispolicy: me.mispolicy, multipara: me.multipara, nazirite: me.nazirite, nonbookish: me.nonbookish, possessorial: me.possessorial, shamed: me.shamed, shelfworn: me.shelfworn, stagnum: me.stagnum, those: me.those, undecimal: me.undecimal) + } + + convenience 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) + } + + convenience 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 + ) -> Amphithyron { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum AnkeeElement: Codable { + case ankeeClass(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(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) + } + } +} + +// MARK: - AnkeeClass +final class 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" + } + + init(anomoean: JSONNull?, barleyhood: JSONNull?, befriender: JSONNull?, brutishness: JSONNull?, cephalalgy: JSONNull?, cirurgian: JSONNull?, conventionally: JSONNull?, jackshay: JSONNull?, milammeter: JSONNull?, naja: JSONNull?, ombrological: JSONNull?, phonasthenia: JSONNull?, retrievableness: JSONNull?, snakily: JSONNull?, swot: JSONNull?, tartlet: JSONNull?, thiofuran: JSONNull?, tracheophone: JSONNull?, tuglike: JSONNull?, unscratchingly: JSONNull?) { + self.anomoean = anomoean + self.barleyhood = barleyhood + self.befriender = befriender + self.brutishness = brutishness + self.cephalalgy = cephalalgy + self.cirurgian = cirurgian + self.conventionally = conventionally + self.jackshay = jackshay + self.milammeter = milammeter + self.naja = naja + self.ombrological = ombrological + self.phonasthenia = phonasthenia + self.retrievableness = retrievableness + self.snakily = snakily + self.swot = swot + self.tartlet = tartlet + self.thiofuran = thiofuran + self.tracheophone = tracheophone + self.tuglike = tuglike + self.unscratchingly = unscratchingly + } +} + +// MARK: AnkeeClass convenience initializers and mutators + +extension AnkeeClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(AnkeeClass.self, from: data) + self.init(anomoean: me.anomoean, barleyhood: me.barleyhood, befriender: me.befriender, brutishness: me.brutishness, cephalalgy: me.cephalalgy, cirurgian: me.cirurgian, conventionally: me.conventionally, jackshay: me.jackshay, milammeter: me.milammeter, naja: me.naja, ombrological: me.ombrological, phonasthenia: me.phonasthenia, retrievableness: me.retrievableness, snakily: me.snakily, swot: me.swot, tartlet: me.tartlet, thiofuran: me.thiofuran, tracheophone: me.tracheophone, tuglike: me.tuglike, unscratchingly: me.unscratchingly) + } + + convenience 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) + } + + convenience 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 + ) -> AnkeeClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum AnsarieElement: Codable { + case ansarieClass(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(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() + } + } +} + +// MARK: - AnsarieClass +final class 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" + } + + init(accension: JSONNull?, alida: JSONNull?, asteria: JSONNull?, beriberic: JSONNull?, edgebone: JSONNull?, gastrodialysis: JSONNull?, geographic: JSONNull?, ictonyx: JSONNull?, metrocele: JSONNull?, misgraft: JSONNull?, monteith: JSONNull?, notcher: JSONNull?, prorestriction: JSONNull?, ramist: JSONNull?, throatlet: JSONNull?, unfair: JSONNull?, unsynonymous: JSONNull?, water: JSONNull?, zestfully: JSONNull?, zincic: JSONNull?) { + self.accension = accension + self.alida = alida + self.asteria = asteria + self.beriberic = beriberic + self.edgebone = edgebone + self.gastrodialysis = gastrodialysis + self.geographic = geographic + self.ictonyx = ictonyx + self.metrocele = metrocele + self.misgraft = misgraft + self.monteith = monteith + self.notcher = notcher + self.prorestriction = prorestriction + self.ramist = ramist + self.throatlet = throatlet + self.unfair = unfair + self.unsynonymous = unsynonymous + self.water = water + self.zestfully = zestfully + self.zincic = zincic + } +} + +// MARK: AnsarieClass convenience initializers and mutators + +extension AnsarieClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(AnsarieClass.self, from: data) + self.init(accension: me.accension, alida: me.alida, asteria: me.asteria, beriberic: me.beriberic, edgebone: me.edgebone, gastrodialysis: me.gastrodialysis, geographic: me.geographic, ictonyx: me.ictonyx, metrocele: me.metrocele, misgraft: me.misgraft, monteith: me.monteith, notcher: me.notcher, prorestriction: me.prorestriction, ramist: me.ramist, throatlet: me.throatlet, unfair: me.unfair, unsynonymous: me.unsynonymous, water: me.water, zestfully: me.zestfully, zincic: me.zincic) + } + + convenience 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) + } + + convenience 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 + ) -> AnsarieClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +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(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(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(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(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) + } + } +} + +enum ChytridiaceaeElement: Codable { + case bool(Bool) + case chytridiaceaeClass(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(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() + } + } +} + +// MARK: - ChytridiaceaeClass +final class 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" + } + + init(batidaceae: JSONNull?, brechites: JSONNull?, codespairer: JSONNull?, emery: JSONNull?, enervative: JSONNull?, excriminate: JSONNull?, goshenite: JSONNull?, grime: JSONNull?, gritten: JSONNull?, hectorly: JSONNull?, intermediation: JSONNull?, meeterly: JSONNull?, narraganset: JSONNull?, onymatic: JSONNull?, paddlecock: JSONNull?, thana: JSONNull?, thornily: JSONNull?, uckia: JSONNull?, unmettle: JSONNull?, vorticellid: JSONNull?) { + self.batidaceae = batidaceae + self.brechites = brechites + self.codespairer = codespairer + self.emery = emery + self.enervative = enervative + self.excriminate = excriminate + self.goshenite = goshenite + self.grime = grime + self.gritten = gritten + self.hectorly = hectorly + self.intermediation = intermediation + self.meeterly = meeterly + self.narraganset = narraganset + self.onymatic = onymatic + self.paddlecock = paddlecock + self.thana = thana + self.thornily = thornily + self.uckia = uckia + self.unmettle = unmettle + self.vorticellid = vorticellid + } +} + +// MARK: ChytridiaceaeClass convenience initializers and mutators + +extension ChytridiaceaeClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(ChytridiaceaeClass.self, from: data) + self.init(batidaceae: me.batidaceae, brechites: me.brechites, codespairer: me.codespairer, emery: me.emery, enervative: me.enervative, excriminate: me.excriminate, goshenite: me.goshenite, grime: me.grime, gritten: me.gritten, hectorly: me.hectorly, intermediation: me.intermediation, meeterly: me.meeterly, narraganset: me.narraganset, onymatic: me.onymatic, paddlecock: me.paddlecock, thana: me.thana, thornily: me.thornily, uckia: me.uckia, unmettle: me.unmettle, vorticellid: me.vorticellid) + } + + convenience 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) + } + + convenience 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 + ) -> ChytridiaceaeClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum DiscordiaElement: Codable { + case discordiaClass(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(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) + } + } +} + +// MARK: - DiscordiaClass +final class 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" + } + + init(altaic: Int?, amoristic: Int?, blennophthalmia: Int?, catharticalness: Double?, chirotherium: Int?, disciplinability: Int?, disdiapason: String?, goofer: Int?, homocerc: Bool?, laryngograph: Int?, leucitis: Int?, lymphocyst: Int?, microcosmology: Int?, nauseation: Int?, nonbookish: JSONNull?, patarin: Int?, preliberal: Int?, prettifier: Int?, rangework: Int?, redient: Int?, subfusiform: Int?, suicidical: Int?, swow: Int?, wastrel: Int?, wingle: Int?) { + self.altaic = altaic + self.amoristic = amoristic + self.blennophthalmia = blennophthalmia + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.disciplinability = disciplinability + self.disdiapason = disdiapason + self.goofer = goofer + self.homocerc = homocerc + self.laryngograph = laryngograph + self.leucitis = leucitis + self.lymphocyst = lymphocyst + self.microcosmology = microcosmology + self.nauseation = nauseation + self.nonbookish = nonbookish + self.patarin = patarin + self.preliberal = preliberal + self.prettifier = prettifier + self.rangework = rangework + self.redient = redient + self.subfusiform = subfusiform + self.suicidical = suicidical + self.swow = swow + self.wastrel = wastrel + self.wingle = wingle + } +} + +// MARK: DiscordiaClass convenience initializers and mutators + +extension DiscordiaClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(DiscordiaClass.self, from: data) + self.init(altaic: me.altaic, amoristic: me.amoristic, blennophthalmia: me.blennophthalmia, catharticalness: me.catharticalness, chirotherium: me.chirotherium, disciplinability: me.disciplinability, disdiapason: me.disdiapason, goofer: me.goofer, homocerc: me.homocerc, laryngograph: me.laryngograph, leucitis: me.leucitis, lymphocyst: me.lymphocyst, microcosmology: me.microcosmology, nauseation: me.nauseation, nonbookish: me.nonbookish, patarin: me.patarin, preliberal: me.preliberal, prettifier: me.prettifier, rangework: me.rangework, redient: me.redient, subfusiform: me.subfusiform, suicidical: me.suicidical, swow: me.swow, wastrel: me.wastrel, wingle: me.wingle) + } + + convenience 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) + } + + convenience 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 + ) -> DiscordiaClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +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(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(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) + } + } +} + +// MARK: - GryphosaurusClass +final class 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" + } + + init(amissibility: JSONNull?, burushaski: JSONNull?, citronin: JSONNull?, coplaintiff: JSONNull?, disquisitionary: JSONNull?, enoplan: JSONNull?, faintness: JSONNull?, hebetomy: JSONNull?, islandry: JSONNull?, lameduck: JSONNull?, overbattle: JSONNull?, overinterested: JSONNull?, phrenologic: JSONNull?, rainband: JSONNull?, shiningly: JSONNull?, stamineous: JSONNull?, subscapularis: JSONNull?, tahami: JSONNull?, undaubed: JSONNull?, underntime: JSONNull?) { + self.amissibility = amissibility + self.burushaski = burushaski + self.citronin = citronin + self.coplaintiff = coplaintiff + self.disquisitionary = disquisitionary + self.enoplan = enoplan + self.faintness = faintness + self.hebetomy = hebetomy + self.islandry = islandry + self.lameduck = lameduck + self.overbattle = overbattle + self.overinterested = overinterested + self.phrenologic = phrenologic + self.rainband = rainband + self.shiningly = shiningly + self.stamineous = stamineous + self.subscapularis = subscapularis + self.tahami = tahami + self.undaubed = undaubed + self.underntime = underntime + } +} + +// MARK: GryphosaurusClass convenience initializers and mutators + +extension GryphosaurusClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(GryphosaurusClass.self, from: data) + self.init(amissibility: me.amissibility, burushaski: me.burushaski, citronin: me.citronin, coplaintiff: me.coplaintiff, disquisitionary: me.disquisitionary, enoplan: me.enoplan, faintness: me.faintness, hebetomy: me.hebetomy, islandry: me.islandry, lameduck: me.lameduck, overbattle: me.overbattle, overinterested: me.overinterested, phrenologic: me.phrenologic, rainband: me.rainband, shiningly: me.shiningly, stamineous: me.stamineous, subscapularis: me.subscapularis, tahami: me.tahami, undaubed: me.undaubed, underntime: me.underntime) + } + + convenience 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) + } + + convenience 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 + ) -> GryphosaurusClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +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(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(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) + } + } +} + +// MARK: - LaviniaClass +final class 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" + } + + init(agitable: Int?, asininity: Int?, benefiter: Int?, bronzelike: Int?, catharticalness: Double?, chirotherium: Int?, cholesteatomatous: Int?, deprivement: Int?, disdiapason: String?, flippantness: Int?, fogproof: Int?, homocerc: Bool?, merrymeeting: Int?, nonbookish: JSONNull?, overcareful: Int?, panaris: Int?, preacceptance: Int?, quinoxaline: Int?, sig: Int?, superconfusion: Int?, tacana: Int?, tillotter: Int?, tranquillize: Int?, unquestionable: Int?, uproute: Int?) { + self.agitable = agitable + self.asininity = asininity + self.benefiter = benefiter + self.bronzelike = bronzelike + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.cholesteatomatous = cholesteatomatous + self.deprivement = deprivement + self.disdiapason = disdiapason + self.flippantness = flippantness + self.fogproof = fogproof + self.homocerc = homocerc + self.merrymeeting = merrymeeting + self.nonbookish = nonbookish + self.overcareful = overcareful + self.panaris = panaris + self.preacceptance = preacceptance + self.quinoxaline = quinoxaline + self.sig = sig + self.superconfusion = superconfusion + self.tacana = tacana + self.tillotter = tillotter + self.tranquillize = tranquillize + self.unquestionable = unquestionable + self.uproute = uproute + } +} + +// MARK: LaviniaClass convenience initializers and mutators + +extension LaviniaClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(LaviniaClass.self, from: data) + self.init(agitable: me.agitable, asininity: me.asininity, benefiter: me.benefiter, bronzelike: me.bronzelike, catharticalness: me.catharticalness, chirotherium: me.chirotherium, cholesteatomatous: me.cholesteatomatous, deprivement: me.deprivement, disdiapason: me.disdiapason, flippantness: me.flippantness, fogproof: me.fogproof, homocerc: me.homocerc, merrymeeting: me.merrymeeting, nonbookish: me.nonbookish, overcareful: me.overcareful, panaris: me.panaris, preacceptance: me.preacceptance, quinoxaline: me.quinoxaline, sig: me.sig, superconfusion: me.superconfusion, tacana: me.tacana, tillotter: me.tillotter, tranquillize: me.tranquillize, unquestionable: me.unquestionable, uproute: me.uproute) + } + + convenience 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) + } + + convenience 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 + ) -> LaviniaClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum OskarElement: Codable { + case integerArray([Int]) + case oskarClass(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(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) + } + } +} + +// MARK: - OskarClass +final class 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" + } + + init(acrobates: JSONNull?, beanshooter: JSONNull?, bearhound: JSONNull?, cayuga: JSONNull?, guarneri: JSONNull?, hypochondriacism: JSONNull?, indication: JSONNull?, jaculative: JSONNull?, nagana: JSONNull?, netherlandish: JSONNull?, noctivagous: JSONNull?, nonphysiological: JSONNull?, praxis: JSONNull?, provision: JSONNull?, subterhuman: JSONNull?, sunlit: JSONNull?, syncraniate: JSONNull?, teachment: JSONNull?, unmutinous: JSONNull?, unstoppable: JSONNull?) { + self.acrobates = acrobates + self.beanshooter = beanshooter + self.bearhound = bearhound + self.cayuga = cayuga + self.guarneri = guarneri + self.hypochondriacism = hypochondriacism + self.indication = indication + self.jaculative = jaculative + self.nagana = nagana + self.netherlandish = netherlandish + self.noctivagous = noctivagous + self.nonphysiological = nonphysiological + self.praxis = praxis + self.provision = provision + self.subterhuman = subterhuman + self.sunlit = sunlit + self.syncraniate = syncraniate + self.teachment = teachment + self.unmutinous = unmutinous + self.unstoppable = unstoppable + } +} + +// MARK: OskarClass convenience initializers and mutators + +extension OskarClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(OskarClass.self, from: data) + self.init(acrobates: me.acrobates, beanshooter: me.beanshooter, bearhound: me.bearhound, cayuga: me.cayuga, guarneri: me.guarneri, hypochondriacism: me.hypochondriacism, indication: me.indication, jaculative: me.jaculative, nagana: me.nagana, netherlandish: me.netherlandish, noctivagous: me.noctivagous, nonphysiological: me.nonphysiological, praxis: me.praxis, provision: me.provision, subterhuman: me.subterhuman, sunlit: me.sunlit, syncraniate: me.syncraniate, teachment: me.teachment, unmutinous: me.unmutinous, unstoppable: me.unstoppable) + } + + convenience 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) + } + + convenience 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 + ) -> OskarClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum RebeccaElement: Codable { + case integer(Int) + case rebecca(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(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) + } + } +} + +enum Rhomboganoidei: Codable { + case integerArray([Int]) + case rebecca(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(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(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(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) + } + } +} + +// 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:ss.SSSSSSXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder +} + +// MARK: - Encode/decode helpers + +final 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/protocol-hashable--739b516c7897/quicktype.swift b/head/swift/test/inputs/json/priority/combinations2.json/protocol-hashable--739b516c7897/quicktype.swift new file mode 100644 index 0000000..df9a33c --- /dev/null +++ b/head/swift/test/inputs/json/priority/combinations2.json/protocol-hashable--739b516c7897/quicktype.swift @@ -0,0 +1,2668 @@ +// 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) + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +import Foundation + +// MARK: - TopLevel +struct TopLevel: Codable, Hashable { + let abranchiata: [Abranchiata] + let academe: [Academe] + let acquirable: [Acquirable] + let aerometry: [Aerometry] + let alexin: [Alexin] + let alleviate: [AlleviateElement] + let amaas: [Amaa] + let ambassage: [Ambassage] + let amphithyron: [Amphithyron?] + let andriana: [String?] + let ankee: [AnkeeElement] + let annihilator: [[String: Int?]?] + let annulose: JSONNull? + let ansarie: [AnsarieElement] + let aphasia: [Aphasia] + let asprawl: [Asprawl] + let attractive: [Bool?] + let barksome: [String: Int] + let bedesman: [Bedesman] + let belard: [Belard] + let bocking: [Bocking] + let brawlingly: [Brawlingly] + let brookie: [Brookie] + let bumboatman: [Bumboatman] + let bystreet: [JSONNull?] + let calaverite: [Calaverite] + let catallactic: [Catallactic] + let cemental: [Cemental] + let chytridiaceae: [ChytridiaceaeElement] + let discordia: [DiscordiaElement] + let endomyces: [Endomyce] + let epinephelidae: [Epinephelidae] + let eupatorium: [Eupatorium] + let gryphosaurus: [GryphosaurusElement] + let koryak: [Koryak] + let lavinia: [LaviniaElement] + let oskar: [OskarElement] + let rebecca: [RebeccaElement] + let rhomboganoidei: [Rhomboganoidei] + let rigsmal: Bool + let ruellia: [Ruellia] + let school: [School] + let shakespearolater: [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" + } +} + +// 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( + abranchiata: [Abranchiata]? = nil, + academe: [Academe]? = nil, + acquirable: [Acquirable]? = nil, + aerometry: [Aerometry]? = nil, + alexin: [Alexin]? = nil, + alleviate: [AlleviateElement]? = nil, + amaas: [Amaa]? = nil, + ambassage: [Ambassage]? = nil, + amphithyron: [Amphithyron?]? = nil, + andriana: [String?]? = nil, + ankee: [AnkeeElement]? = nil, + annihilator: [[String: Int?]?]? = nil, + annulose: JSONNull?? = nil, + ansarie: [AnsarieElement]? = nil, + aphasia: [Aphasia]? = nil, + asprawl: [Asprawl]? = nil, + attractive: [Bool?]? = nil, + barksome: [String: Int]? = nil, + bedesman: [Bedesman]? = nil, + belard: [Belard]? = nil, + bocking: [Bocking]? = nil, + brawlingly: [Brawlingly]? = nil, + brookie: [Brookie]? = nil, + bumboatman: [Bumboatman]? = nil, + bystreet: [JSONNull?]? = nil, + calaverite: [Calaverite]? = nil, + catallactic: [Catallactic]? = nil, + cemental: [Cemental]? = nil, + chytridiaceae: [ChytridiaceaeElement]? = nil, + discordia: [DiscordiaElement]? = nil, + endomyces: [Endomyce]? = nil, + epinephelidae: [Epinephelidae]? = nil, + eupatorium: [Eupatorium]? = nil, + gryphosaurus: [GryphosaurusElement]? = nil, + koryak: [Koryak]? = nil, + lavinia: [LaviniaElement]? = nil, + oskar: [OskarElement]? = nil, + rebecca: [RebeccaElement]? = nil, + rhomboganoidei: [Rhomboganoidei]? = nil, + rigsmal: Bool? = nil, + ruellia: [Ruellia]? = nil, + school: [School]? = nil, + shakespearolater: [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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Abranchiata: Codable, Hashable { + 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 Academe: Codable, Hashable { + 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, Hashable { + 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, Hashable { + 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, Hashable { + 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, Hashable { + case alleviateClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - AlleviateClass +struct AlleviateClass: Codable, Hashable { + 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" + } +} + +// MARK: AlleviateClass convenience initializers and mutators + +extension AlleviateClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> AlleviateClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Amaa: Codable, Hashable { + case bool(Bool) + case integer(Int) + case rebecca(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - Rebecca +struct Rebecca: Codable, Hashable { + 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" + } +} + +// MARK: Rebecca convenience initializers and mutators + +extension Rebecca { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> Rebecca { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Ambassage: Codable, Hashable { + 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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - Amphithyron +struct Amphithyron: Codable, Hashable { + 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" + } +} + +// MARK: Amphithyron convenience initializers and mutators + +extension Amphithyron { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> Amphithyron { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum AnkeeElement: Codable, Hashable { + case ankeeClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - AnkeeClass +struct AnkeeClass: Codable, Hashable { + 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" + } +} + +// MARK: AnkeeClass convenience initializers and mutators + +extension AnkeeClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> AnkeeClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum AnsarieElement: Codable, Hashable { + case ansarieClass(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(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() + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - AnsarieClass +struct AnsarieClass: Codable, Hashable { + 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" + } +} + +// MARK: AnsarieClass convenience initializers and mutators + +extension AnsarieClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> AnsarieClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Aphasia: Codable, Hashable { + 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, Hashable { + 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, Hashable { + 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, Hashable { + case double(Double) + case integerArray([Int]) + case rebecca(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(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, Hashable { + 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, Hashable { + 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, Hashable { + case integerArray([Int]) + case rebecca(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(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, Hashable { + 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, Hashable { + 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, Hashable { + 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, Hashable { + 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) + } + } +} + +enum ChytridiaceaeElement: Codable, Hashable { + case bool(Bool) + case chytridiaceaeClass(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(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() + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - ChytridiaceaeClass +struct ChytridiaceaeClass: Codable, Hashable { + 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" + } +} + +// MARK: ChytridiaceaeClass convenience initializers and mutators + +extension ChytridiaceaeClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> ChytridiaceaeClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum DiscordiaElement: Codable, Hashable { + case discordiaClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - DiscordiaClass +struct DiscordiaClass: Codable, Hashable { + 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" + } +} + +// MARK: DiscordiaClass convenience initializers and mutators + +extension DiscordiaClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> DiscordiaClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Endomyce: Codable, Hashable { + 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, Hashable { + 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, Hashable { + 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, Hashable { + case gryphosaurusClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - GryphosaurusClass +struct GryphosaurusClass: Codable, Hashable { + 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" + } +} + +// MARK: GryphosaurusClass convenience initializers and mutators + +extension GryphosaurusClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> GryphosaurusClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Koryak: Codable, Hashable { + 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, Hashable { + case laviniaClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - LaviniaClass +struct LaviniaClass: Codable, Hashable { + 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" + } +} + +// MARK: LaviniaClass convenience initializers and mutators + +extension LaviniaClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> LaviniaClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum OskarElement: Codable, Hashable { + case integerArray([Int]) + case oskarClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - OskarClass +struct OskarClass: Codable, Hashable { + 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" + } +} + +// MARK: OskarClass convenience initializers and mutators + +extension OskarClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> OskarClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum RebeccaElement: Codable, Hashable { + case integer(Int) + case rebecca(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(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) + } + } +} + +enum Rhomboganoidei: Codable, Hashable { + case integerArray([Int]) + case rebecca(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(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, Hashable { + case bool(Bool) + case rebecca(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(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, Hashable { + 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, Hashable { + 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) + } + } +} + +// 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:ss.SSSSSSXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder +} + +// 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/final-classes-true__struct-or-class-class--d3c62ec7414d/quicktype.swift b/head/swift/test/inputs/json/priority/combinations3.json/final-classes-true__struct-or-class-class--d3c62ec7414d/quicktype.swift new file mode 100644 index 0000000..c8e32ee --- /dev/null +++ b/head/swift/test/inputs/json/priority/combinations3.json/final-classes-true__struct-or-class-class--d3c62ec7414d/quicktype.swift @@ -0,0 +1,3534 @@ +// 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 +final class TopLevel: Codable { + let juror: [JurorElement] + let kongoni: [Kongoni] + let ladronism: [LadronismElement] + let landlubberly: [LandlubberlyElement] + let listener: [Listener] + let lupus: [LupusElement] + let maslin: [Maslin] + let monazite: [MonaziteElement] + let monoliteral: [Monoliteral] + let monotheistically: [MonotheisticallyElement] + let montage: [Montage] + let moralness: [Moralness] + let mowra: [MonaziteClass?] + let mulishly: [Mulishly] + let myoscope: [Myoscope] + let nach: [[Int?]?] + let neuromastic: [Neuromastic] + let noncontributing: [Noncontributing] + let nonnervous: [Nonnervous] + let nonvaluation: [Nonvaluation] + let occupationalist: [OccupationalistElement] + let outrival: [OutrivalElement] + let paleographically: [Paleographically] + let pamphletwise: [Pamphletwise] + let pediatrics: [Pediatric] + let perceptive: [Bool] + let piaculum: [PiaculumElement] + let piccadilly: [Piccadilly] + let piffler: [Piffler] + let pithful: [Pithful] + let placuntitis: [Placuntiti] + let plectopterous: [Plectopterous] + let pneumocele: [Pneumocele?] + let poliorcetic: [Poliorcetic] + let poormaster: [Poormaster] + let potwhisky: [PotwhiskyElement] + let practicalizer: [Practicalizer] + let prefreshman: [PrefreshmanElement] + let prehensility: [Prehensility] + let prevoidance: [Prevoidance] + let probant: [[String: Int?]] + let protext: [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" + } + + init(juror: [JurorElement], kongoni: [Kongoni], ladronism: [LadronismElement], landlubberly: [LandlubberlyElement], listener: [Listener], lupus: [LupusElement], maslin: [Maslin], monazite: [MonaziteElement], monoliteral: [Monoliteral], monotheistically: [MonotheisticallyElement], montage: [Montage], moralness: [Moralness], mowra: [MonaziteClass?], mulishly: [Mulishly], myoscope: [Myoscope], nach: [[Int?]?], neuromastic: [Neuromastic], noncontributing: [Noncontributing], nonnervous: [Nonnervous], nonvaluation: [Nonvaluation], occupationalist: [OccupationalistElement], outrival: [OutrivalElement], paleographically: [Paleographically], pamphletwise: [Pamphletwise], pediatrics: [Pediatric], perceptive: [Bool], piaculum: [PiaculumElement], piccadilly: [Piccadilly], piffler: [Piffler], pithful: [Pithful], placuntitis: [Placuntiti], plectopterous: [Plectopterous], pneumocele: [Pneumocele?], poliorcetic: [Poliorcetic], poormaster: [Poormaster], potwhisky: [PotwhiskyElement], practicalizer: [Practicalizer], prefreshman: [PrefreshmanElement], prehensility: [Prehensility], prevoidance: [Prevoidance], probant: [[String: Int?]], protext: [Protext]) { + self.juror = juror + self.kongoni = kongoni + self.ladronism = ladronism + self.landlubberly = landlubberly + self.listener = listener + self.lupus = lupus + self.maslin = maslin + self.monazite = monazite + self.monoliteral = monoliteral + self.monotheistically = monotheistically + self.montage = montage + self.moralness = moralness + self.mowra = mowra + self.mulishly = mulishly + self.myoscope = myoscope + self.nach = nach + self.neuromastic = neuromastic + self.noncontributing = noncontributing + self.nonnervous = nonnervous + self.nonvaluation = nonvaluation + self.occupationalist = occupationalist + self.outrival = outrival + self.paleographically = paleographically + self.pamphletwise = pamphletwise + self.pediatrics = pediatrics + self.perceptive = perceptive + self.piaculum = piaculum + self.piccadilly = piccadilly + self.piffler = piffler + self.pithful = pithful + self.placuntitis = placuntitis + self.plectopterous = plectopterous + self.pneumocele = pneumocele + self.poliorcetic = poliorcetic + self.poormaster = poormaster + self.potwhisky = potwhisky + self.practicalizer = practicalizer + self.prefreshman = prefreshman + self.prehensility = prehensility + self.prevoidance = prevoidance + self.probant = probant + self.protext = protext + } +} + +// MARK: TopLevel convenience initializers and mutators + +extension TopLevel { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(TopLevel.self, from: data) + self.init(juror: me.juror, kongoni: me.kongoni, ladronism: me.ladronism, landlubberly: me.landlubberly, listener: me.listener, lupus: me.lupus, maslin: me.maslin, monazite: me.monazite, monoliteral: me.monoliteral, monotheistically: me.monotheistically, montage: me.montage, moralness: me.moralness, mowra: me.mowra, mulishly: me.mulishly, myoscope: me.myoscope, nach: me.nach, neuromastic: me.neuromastic, noncontributing: me.noncontributing, nonnervous: me.nonnervous, nonvaluation: me.nonvaluation, occupationalist: me.occupationalist, outrival: me.outrival, paleographically: me.paleographically, pamphletwise: me.pamphletwise, pediatrics: me.pediatrics, perceptive: me.perceptive, piaculum: me.piaculum, piccadilly: me.piccadilly, piffler: me.piffler, pithful: me.pithful, placuntitis: me.placuntitis, plectopterous: me.plectopterous, pneumocele: me.pneumocele, poliorcetic: me.poliorcetic, poormaster: me.poormaster, potwhisky: me.potwhisky, practicalizer: me.practicalizer, prefreshman: me.prefreshman, prehensility: me.prehensility, prevoidance: me.prevoidance, probant: me.probant, protext: me.protext) + } + + convenience 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) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + juror: [JurorElement]? = nil, + kongoni: [Kongoni]? = nil, + ladronism: [LadronismElement]? = nil, + landlubberly: [LandlubberlyElement]? = nil, + listener: [Listener]? = nil, + lupus: [LupusElement]? = nil, + maslin: [Maslin]? = nil, + monazite: [MonaziteElement]? = nil, + monoliteral: [Monoliteral]? = nil, + monotheistically: [MonotheisticallyElement]? = nil, + montage: [Montage]? = nil, + moralness: [Moralness]? = nil, + mowra: [MonaziteClass?]? = nil, + mulishly: [Mulishly]? = nil, + myoscope: [Myoscope]? = nil, + nach: [[Int?]?]? = nil, + neuromastic: [Neuromastic]? = nil, + noncontributing: [Noncontributing]? = nil, + nonnervous: [Nonnervous]? = nil, + nonvaluation: [Nonvaluation]? = nil, + occupationalist: [OccupationalistElement]? = nil, + outrival: [OutrivalElement]? = nil, + paleographically: [Paleographically]? = nil, + pamphletwise: [Pamphletwise]? = nil, + pediatrics: [Pediatric]? = nil, + perceptive: [Bool]? = nil, + piaculum: [PiaculumElement]? = nil, + piccadilly: [Piccadilly]? = nil, + piffler: [Piffler]? = nil, + pithful: [Pithful]? = nil, + placuntitis: [Placuntiti]? = nil, + plectopterous: [Plectopterous]? = nil, + pneumocele: [Pneumocele?]? = nil, + poliorcetic: [Poliorcetic]? = nil, + poormaster: [Poormaster]? = nil, + potwhisky: [PotwhiskyElement]? = nil, + practicalizer: [Practicalizer]? = nil, + prefreshman: [PrefreshmanElement]? = nil, + prehensility: [Prehensility]? = nil, + prevoidance: [Prevoidance]? = nil, + probant: [[String: Int?]]? = nil, + protext: [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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum JurorElement: Codable { + case bool(Bool) + case jurorClass(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(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) + } + } +} + +// MARK: - JurorClass +final class 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" + } + + init(adipsy: JSONNull?, auxiliator: JSONNull?, benda: JSONNull?, benjamin: JSONNull?, brandling: JSONNull?, epicurishly: JSONNull?, eremochaetous: JSONNull?, marten: JSONNull?, monocline: JSONNull?, olea: JSONNull?, palgat: JSONNull?, pennyworth: JSONNull?, pioury: JSONNull?, pragmatistic: JSONNull?, stylelessness: JSONNull?, systematical: JSONNull?, thready: JSONNull?, uncontemporary: JSONNull?, uncouched: JSONNull?, uninhabitedness: JSONNull?) { + self.adipsy = adipsy + self.auxiliator = auxiliator + self.benda = benda + self.benjamin = benjamin + self.brandling = brandling + self.epicurishly = epicurishly + self.eremochaetous = eremochaetous + self.marten = marten + self.monocline = monocline + self.olea = olea + self.palgat = palgat + self.pennyworth = pennyworth + self.pioury = pioury + self.pragmatistic = pragmatistic + self.stylelessness = stylelessness + self.systematical = systematical + self.thready = thready + self.uncontemporary = uncontemporary + self.uncouched = uncouched + self.uninhabitedness = uninhabitedness + } +} + +// MARK: JurorClass convenience initializers and mutators + +extension JurorClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(JurorClass.self, from: data) + self.init(adipsy: me.adipsy, auxiliator: me.auxiliator, benda: me.benda, benjamin: me.benjamin, brandling: me.brandling, epicurishly: me.epicurishly, eremochaetous: me.eremochaetous, marten: me.marten, monocline: me.monocline, olea: me.olea, palgat: me.palgat, pennyworth: me.pennyworth, pioury: me.pioury, pragmatistic: me.pragmatistic, stylelessness: me.stylelessness, systematical: me.systematical, thready: me.thready, uncontemporary: me.uncontemporary, uncouched: me.uncouched, uninhabitedness: me.uninhabitedness) + } + + convenience 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) + } + + convenience 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 + ) -> JurorClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +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(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(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) + } + } +} + +// MARK: - LadronismClass +final class 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" + } + + init(acclaimer: JSONNull?, achree: JSONNull?, base: JSONNull?, conundrumize: JSONNull?, degerminator: JSONNull?, describable: JSONNull?, exasperatedly: JSONNull?, heroine: JSONNull?, indazin: JSONNull?, luteous: JSONNull?, papular: JSONNull?, pritch: JSONNull?, prodenia: JSONNull?, seege: JSONNull?, shopgirl: JSONNull?, tragedietta: JSONNull?, unsparse: JSONNull?, uplook: JSONNull?, vermiformis: JSONNull?, whafabout: JSONNull?) { + self.acclaimer = acclaimer + self.achree = achree + self.base = base + self.conundrumize = conundrumize + self.degerminator = degerminator + self.describable = describable + self.exasperatedly = exasperatedly + self.heroine = heroine + self.indazin = indazin + self.luteous = luteous + self.papular = papular + self.pritch = pritch + self.prodenia = prodenia + self.seege = seege + self.shopgirl = shopgirl + self.tragedietta = tragedietta + self.unsparse = unsparse + self.uplook = uplook + self.vermiformis = vermiformis + self.whafabout = whafabout + } +} + +// MARK: LadronismClass convenience initializers and mutators + +extension LadronismClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(LadronismClass.self, from: data) + self.init(acclaimer: me.acclaimer, achree: me.achree, base: me.base, conundrumize: me.conundrumize, degerminator: me.degerminator, describable: me.describable, exasperatedly: me.exasperatedly, heroine: me.heroine, indazin: me.indazin, luteous: me.luteous, papular: me.papular, pritch: me.pritch, prodenia: me.prodenia, seege: me.seege, shopgirl: me.shopgirl, tragedietta: me.tragedietta, unsparse: me.unsparse, uplook: me.uplook, vermiformis: me.vermiformis, whafabout: me.whafabout) + } + + convenience 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) + } + + convenience 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 + ) -> LadronismClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum LandlubberlyElement: Codable { + case bool(Bool) + case integer(Int) + case landlubberlyClass(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(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) + } + } +} + +// MARK: - LandlubberlyClass +final class 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" + } + + init(acropoleis: JSONNull?, aminate: JSONNull?, amyraldism: JSONNull?, bipenniform: JSONNull?, bugre: JSONNull?, calycule: JSONNull?, caoutchouc: JSONNull?, disprover: JSONNull?, fitroot: JSONNull?, fulgently: JSONNull?, kickup: JSONNull?, laevoversion: JSONNull?, moter: JSONNull?, objectivity: JSONNull?, posterity: JSONNull?, postnuptial: JSONNull?, precedentary: JSONNull?, saddling: JSONNull?, subcurrent: JSONNull?, unrecriminative: JSONNull?) { + self.acropoleis = acropoleis + self.aminate = aminate + self.amyraldism = amyraldism + self.bipenniform = bipenniform + self.bugre = bugre + self.calycule = calycule + self.caoutchouc = caoutchouc + self.disprover = disprover + self.fitroot = fitroot + self.fulgently = fulgently + self.kickup = kickup + self.laevoversion = laevoversion + self.moter = moter + self.objectivity = objectivity + self.posterity = posterity + self.postnuptial = postnuptial + self.precedentary = precedentary + self.saddling = saddling + self.subcurrent = subcurrent + self.unrecriminative = unrecriminative + } +} + +// MARK: LandlubberlyClass convenience initializers and mutators + +extension LandlubberlyClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(LandlubberlyClass.self, from: data) + self.init(acropoleis: me.acropoleis, aminate: me.aminate, amyraldism: me.amyraldism, bipenniform: me.bipenniform, bugre: me.bugre, calycule: me.calycule, caoutchouc: me.caoutchouc, disprover: me.disprover, fitroot: me.fitroot, fulgently: me.fulgently, kickup: me.kickup, laevoversion: me.laevoversion, moter: me.moter, objectivity: me.objectivity, posterity: me.posterity, postnuptial: me.postnuptial, precedentary: me.precedentary, saddling: me.saddling, subcurrent: me.subcurrent, unrecriminative: me.unrecriminative) + } + + convenience 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) + } + + convenience 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 + ) -> LandlubberlyClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +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(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(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) + } + } +} + +// MARK: - LupusClass +final class 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" + } + + init(catharticalness: Double?, chirotherium: Int?, chlorioninae: Int?, corvinae: Int?, crassina: Int?, disdiapason: String?, exiguity: Int?, farcist: Int?, holographical: Int?, homocerc: Bool?, ichthyophagan: Int?, implacable: Int?, nonbookish: JSONNull?, outshiner: Int?, overweather: Int?, protonegroid: Int?, shallowish: Int?, snoke: Int?, snout: Int?, surveillance: Int?, threshingtime: Int?, thysanocarpus: Int?, unsignificantly: Int?, unsnap: Int?, vendible: Int?) { + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.chlorioninae = chlorioninae + self.corvinae = corvinae + self.crassina = crassina + self.disdiapason = disdiapason + self.exiguity = exiguity + self.farcist = farcist + self.holographical = holographical + self.homocerc = homocerc + self.ichthyophagan = ichthyophagan + self.implacable = implacable + self.nonbookish = nonbookish + self.outshiner = outshiner + self.overweather = overweather + self.protonegroid = protonegroid + self.shallowish = shallowish + self.snoke = snoke + self.snout = snout + self.surveillance = surveillance + self.threshingtime = threshingtime + self.thysanocarpus = thysanocarpus + self.unsignificantly = unsignificantly + self.unsnap = unsnap + self.vendible = vendible + } +} + +// MARK: LupusClass convenience initializers and mutators + +extension LupusClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(LupusClass.self, from: data) + self.init(catharticalness: me.catharticalness, chirotherium: me.chirotherium, chlorioninae: me.chlorioninae, corvinae: me.corvinae, crassina: me.crassina, disdiapason: me.disdiapason, exiguity: me.exiguity, farcist: me.farcist, holographical: me.holographical, homocerc: me.homocerc, ichthyophagan: me.ichthyophagan, implacable: me.implacable, nonbookish: me.nonbookish, outshiner: me.outshiner, overweather: me.overweather, protonegroid: me.protonegroid, shallowish: me.shallowish, snoke: me.snoke, snout: me.snout, surveillance: me.surveillance, threshingtime: me.threshingtime, thysanocarpus: me.thysanocarpus, unsignificantly: me.unsignificantly, unsnap: me.unsnap, vendible: me.vendible) + } + + convenience 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) + } + + convenience 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 + ) -> LupusClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - Maslin +final class 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" + } + + init(alicant: Int?, antiatonement: JSONNull?, anticorrosive: Int?, aphidozer: JSONNull?, bakuninist: JSONNull?, be: Int?, catharticalness: Double?, chirotherium: Int?, chub: Int?, cuprosilicon: Int?, curtailedly: Int?, dellenite: Int?, dimitry: Int?, disdiapason: String?, edifying: JSONNull?, ethmoiditis: Int?, gastralgy: JSONNull?, goatherd: Int?, hammerdress: Int?, hangfire: JSONNull?, homocerc: Bool?, lacunosity: Int?, longiloquence: JSONNull?, mameliere: Int?, motherless: JSONNull?, nonbookish: JSONNull?, noncorrodible: JSONNull?, nonsensicality: JSONNull?, oafishly: Int?, pfund: JSONNull?, preadvisory: JSONNull?, retroflexed: JSONNull?, saccharulmic: Int?, scowlful: Int?, secluded: JSONNull?, slackage: JSONNull?, sphaeridial: Int?, spondulics: JSONNull?, subsecive: Int?, swellmobsman: JSONNull?, trachyglossate: Int?, trialogue: JSONNull?, unassuaged: Int?, ungross: JSONNull?, unjudiciously: JSONNull?) { + self.alicant = alicant + self.antiatonement = antiatonement + self.anticorrosive = anticorrosive + self.aphidozer = aphidozer + self.bakuninist = bakuninist + self.be = be + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.chub = chub + self.cuprosilicon = cuprosilicon + self.curtailedly = curtailedly + self.dellenite = dellenite + self.dimitry = dimitry + self.disdiapason = disdiapason + self.edifying = edifying + self.ethmoiditis = ethmoiditis + self.gastralgy = gastralgy + self.goatherd = goatherd + self.hammerdress = hammerdress + self.hangfire = hangfire + self.homocerc = homocerc + self.lacunosity = lacunosity + self.longiloquence = longiloquence + self.mameliere = mameliere + self.motherless = motherless + self.nonbookish = nonbookish + self.noncorrodible = noncorrodible + self.nonsensicality = nonsensicality + self.oafishly = oafishly + self.pfund = pfund + self.preadvisory = preadvisory + self.retroflexed = retroflexed + self.saccharulmic = saccharulmic + self.scowlful = scowlful + self.secluded = secluded + self.slackage = slackage + self.sphaeridial = sphaeridial + self.spondulics = spondulics + self.subsecive = subsecive + self.swellmobsman = swellmobsman + self.trachyglossate = trachyglossate + self.trialogue = trialogue + self.unassuaged = unassuaged + self.ungross = ungross + self.unjudiciously = unjudiciously + } +} + +// MARK: Maslin convenience initializers and mutators + +extension Maslin { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Maslin.self, from: data) + self.init(alicant: me.alicant, antiatonement: me.antiatonement, anticorrosive: me.anticorrosive, aphidozer: me.aphidozer, bakuninist: me.bakuninist, be: me.be, catharticalness: me.catharticalness, chirotherium: me.chirotherium, chub: me.chub, cuprosilicon: me.cuprosilicon, curtailedly: me.curtailedly, dellenite: me.dellenite, dimitry: me.dimitry, disdiapason: me.disdiapason, edifying: me.edifying, ethmoiditis: me.ethmoiditis, gastralgy: me.gastralgy, goatherd: me.goatherd, hammerdress: me.hammerdress, hangfire: me.hangfire, homocerc: me.homocerc, lacunosity: me.lacunosity, longiloquence: me.longiloquence, mameliere: me.mameliere, motherless: me.motherless, nonbookish: me.nonbookish, noncorrodible: me.noncorrodible, nonsensicality: me.nonsensicality, oafishly: me.oafishly, pfund: me.pfund, preadvisory: me.preadvisory, retroflexed: me.retroflexed, saccharulmic: me.saccharulmic, scowlful: me.scowlful, secluded: me.secluded, slackage: me.slackage, sphaeridial: me.sphaeridial, spondulics: me.spondulics, subsecive: me.subsecive, swellmobsman: me.swellmobsman, trachyglossate: me.trachyglossate, trialogue: me.trialogue, unassuaged: me.unassuaged, ungross: me.ungross, unjudiciously: me.unjudiciously) + } + + convenience 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) + } + + convenience 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 + ) -> Maslin { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum MonaziteElement: Codable { + case double(Double) + case monaziteClass(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(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) + } + } +} + +// MARK: - MonaziteClass +final class 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" + } + + init(catharticalness: Double, chirotherium: Int, disdiapason: String, homocerc: Bool, nonbookish: JSONNull?) { + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.disdiapason = disdiapason + self.homocerc = homocerc + self.nonbookish = nonbookish + } +} + +// MARK: MonaziteClass convenience initializers and mutators + +extension MonaziteClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(MonaziteClass.self, from: data) + self.init(catharticalness: me.catharticalness, chirotherium: me.chirotherium, disdiapason: me.disdiapason, homocerc: me.homocerc, nonbookish: me.nonbookish) + } + + convenience 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) + } + + convenience 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 + ) -> MonaziteClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +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(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(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) + } + } +} + +// MARK: - MonotheisticallyClass +final class 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" + } + + init(blaspheme: JSONNull?, catharticalness: Double?, celiosalpingectomy: JSONNull?, chirotherium: Int?, consummativeness: JSONNull?, disdiapason: String?, egestive: JSONNull?, enchylema: JSONNull?, gasconade: JSONNull?, holidayer: JSONNull?, homocerc: Bool?, intuitionalism: JSONNull?, lophiostomate: JSONNull?, nonbookish: JSONNull?, nonvolition: JSONNull?, palatableness: JSONNull?, pimpery: JSONNull?, previolation: JSONNull?, reconveyance: JSONNull?, registership: JSONNull?, rhyacolite: JSONNull?, smithereens: JSONNull?, superedification: JSONNull?, trust: JSONNull?, whitestone: JSONNull?) { + self.blaspheme = blaspheme + self.catharticalness = catharticalness + self.celiosalpingectomy = celiosalpingectomy + self.chirotherium = chirotherium + self.consummativeness = consummativeness + self.disdiapason = disdiapason + self.egestive = egestive + self.enchylema = enchylema + self.gasconade = gasconade + self.holidayer = holidayer + self.homocerc = homocerc + self.intuitionalism = intuitionalism + self.lophiostomate = lophiostomate + self.nonbookish = nonbookish + self.nonvolition = nonvolition + self.palatableness = palatableness + self.pimpery = pimpery + self.previolation = previolation + self.reconveyance = reconveyance + self.registership = registership + self.rhyacolite = rhyacolite + self.smithereens = smithereens + self.superedification = superedification + self.trust = trust + self.whitestone = whitestone + } +} + +// MARK: MonotheisticallyClass convenience initializers and mutators + +extension MonotheisticallyClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(MonotheisticallyClass.self, from: data) + self.init(blaspheme: me.blaspheme, catharticalness: me.catharticalness, celiosalpingectomy: me.celiosalpingectomy, chirotherium: me.chirotherium, consummativeness: me.consummativeness, disdiapason: me.disdiapason, egestive: me.egestive, enchylema: me.enchylema, gasconade: me.gasconade, holidayer: me.holidayer, homocerc: me.homocerc, intuitionalism: me.intuitionalism, lophiostomate: me.lophiostomate, nonbookish: me.nonbookish, nonvolition: me.nonvolition, palatableness: me.palatableness, pimpery: me.pimpery, previolation: me.previolation, reconveyance: me.reconveyance, registership: me.registership, rhyacolite: me.rhyacolite, smithereens: me.smithereens, superedification: me.superedification, trust: me.trust, whitestone: me.whitestone) + } + + convenience 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) + } + + convenience 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 + ) -> MonotheisticallyClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +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) + } + } +} + +// MARK: - Noncontributing +final class 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" + } + + init(estevin: String, jolterhead: Double, sauternes: Int, sparsely: Bool, unrequested: JSONNull?) { + self.estevin = estevin + self.jolterhead = jolterhead + self.sauternes = sauternes + self.sparsely = sparsely + self.unrequested = unrequested + } +} + +// MARK: Noncontributing convenience initializers and mutators + +extension Noncontributing { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Noncontributing.self, from: data) + self.init(estevin: me.estevin, jolterhead: me.jolterhead, sauternes: me.sauternes, sparsely: me.sparsely, unrequested: me.unrequested) + } + + convenience 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) + } + + convenience 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 + ) -> Noncontributing { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +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(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(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() + } + } +} + +// MARK: - OccupationalistClass +final class 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" + } + + init(beholdable: JSONNull?, brotuliform: JSONNull?, chimakum: JSONNull?, doodler: JSONNull?, emulsin: JSONNull?, fin: JSONNull?, flourishing: JSONNull?, flueless: JSONNull?, furtively: JSONNull?, gritter: JSONNull?, interwish: JSONNull?, monoxylic: JSONNull?, myristic: JSONNull?, nightwear: JSONNull?, peruser: JSONNull?, theoastrological: JSONNull?, thumby: JSONNull?, tingitid: JSONNull?, trailless: JSONNull?, unpocketed: JSONNull?) { + self.beholdable = beholdable + self.brotuliform = brotuliform + self.chimakum = chimakum + self.doodler = doodler + self.emulsin = emulsin + self.fin = fin + self.flourishing = flourishing + self.flueless = flueless + self.furtively = furtively + self.gritter = gritter + self.interwish = interwish + self.monoxylic = monoxylic + self.myristic = myristic + self.nightwear = nightwear + self.peruser = peruser + self.theoastrological = theoastrological + self.thumby = thumby + self.tingitid = tingitid + self.trailless = trailless + self.unpocketed = unpocketed + } +} + +// MARK: OccupationalistClass convenience initializers and mutators + +extension OccupationalistClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(OccupationalistClass.self, from: data) + self.init(beholdable: me.beholdable, brotuliform: me.brotuliform, chimakum: me.chimakum, doodler: me.doodler, emulsin: me.emulsin, fin: me.fin, flourishing: me.flourishing, flueless: me.flueless, furtively: me.furtively, gritter: me.gritter, interwish: me.interwish, monoxylic: me.monoxylic, myristic: me.myristic, nightwear: me.nightwear, peruser: me.peruser, theoastrological: me.theoastrological, thumby: me.thumby, tingitid: me.tingitid, trailless: me.trailless, unpocketed: me.unpocketed) + } + + convenience 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) + } + + convenience 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 + ) -> OccupationalistClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum OutrivalElement: Codable { + case double(Double) + case outrivalClass(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(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() + } + } +} + +// MARK: - OutrivalClass +final class 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" + } + + init(adroitly: JSONNull?, bridehood: JSONNull?, castoroides: JSONNull?, czechoslovak: JSONNull?, diagenesis: JSONNull?, dihexahedron: JSONNull?, dopester: JSONNull?, eumerism: JSONNull?, flyness: JSONNull?, fouler: JSONNull?, laudanosine: JSONNull?, lingulidae: JSONNull?, minutary: JSONNull?, mitra: JSONNull?, opisthorchiasis: JSONNull?, pensively: JSONNull?, pubigerous: JSONNull?, rebellious: JSONNull?, recodify: JSONNull?, unpaced: JSONNull?) { + self.adroitly = adroitly + self.bridehood = bridehood + self.castoroides = castoroides + self.czechoslovak = czechoslovak + self.diagenesis = diagenesis + self.dihexahedron = dihexahedron + self.dopester = dopester + self.eumerism = eumerism + self.flyness = flyness + self.fouler = fouler + self.laudanosine = laudanosine + self.lingulidae = lingulidae + self.minutary = minutary + self.mitra = mitra + self.opisthorchiasis = opisthorchiasis + self.pensively = pensively + self.pubigerous = pubigerous + self.rebellious = rebellious + self.recodify = recodify + self.unpaced = unpaced + } +} + +// MARK: OutrivalClass convenience initializers and mutators + +extension OutrivalClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(OutrivalClass.self, from: data) + self.init(adroitly: me.adroitly, bridehood: me.bridehood, castoroides: me.castoroides, czechoslovak: me.czechoslovak, diagenesis: me.diagenesis, dihexahedron: me.dihexahedron, dopester: me.dopester, eumerism: me.eumerism, flyness: me.flyness, fouler: me.fouler, laudanosine: me.laudanosine, lingulidae: me.lingulidae, minutary: me.minutary, mitra: me.mitra, opisthorchiasis: me.opisthorchiasis, pensively: me.pensively, pubigerous: me.pubigerous, rebellious: me.rebellious, recodify: me.recodify, unpaced: me.unpaced) + } + + convenience 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) + } + + convenience 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 + ) -> OutrivalClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +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(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(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) + } + } +} + +// MARK: - PiaculumClass +final class 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" + } + + init(alada: Int?, amphistomous: Int?, boysenberry: Int?, catharticalness: Double?, chirotherium: Int?, decardinalize: Int?, discouragement: Int?, disdiapason: String?, doitrified: Int?, hexaspermous: Int?, homocerc: Bool?, insinking: Int?, loathfulness: Int?, miasmatical: Int?, neurofibril: Int?, nonbookish: JSONNull?, phonendoscope: Int?, pilferment: Int?, predismissory: Int?, preinscription: Int?, quotative: Int?, sienna: Int?, thorax: Int?, yachting: Int?, zipper: Int?) { + self.alada = alada + self.amphistomous = amphistomous + self.boysenberry = boysenberry + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.decardinalize = decardinalize + self.discouragement = discouragement + self.disdiapason = disdiapason + self.doitrified = doitrified + self.hexaspermous = hexaspermous + self.homocerc = homocerc + self.insinking = insinking + self.loathfulness = loathfulness + self.miasmatical = miasmatical + self.neurofibril = neurofibril + self.nonbookish = nonbookish + self.phonendoscope = phonendoscope + self.pilferment = pilferment + self.predismissory = predismissory + self.preinscription = preinscription + self.quotative = quotative + self.sienna = sienna + self.thorax = thorax + self.yachting = yachting + self.zipper = zipper + } +} + +// MARK: PiaculumClass convenience initializers and mutators + +extension PiaculumClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(PiaculumClass.self, from: data) + self.init(alada: me.alada, amphistomous: me.amphistomous, boysenberry: me.boysenberry, catharticalness: me.catharticalness, chirotherium: me.chirotherium, decardinalize: me.decardinalize, discouragement: me.discouragement, disdiapason: me.disdiapason, doitrified: me.doitrified, hexaspermous: me.hexaspermous, homocerc: me.homocerc, insinking: me.insinking, loathfulness: me.loathfulness, miasmatical: me.miasmatical, neurofibril: me.neurofibril, nonbookish: me.nonbookish, phonendoscope: me.phonendoscope, pilferment: me.pilferment, predismissory: me.predismissory, preinscription: me.preinscription, quotative: me.quotative, sienna: me.sienna, thorax: me.thorax, yachting: me.yachting, zipper: me.zipper) + } + + convenience 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) + } + + convenience 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 + ) -> PiaculumClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +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(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(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) + } + } +} + +// MARK: - Pneumocele +final class 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" + } + + init(carbonarism: JSONNull?, catharticalness: Double?, chirotherium: Int?, cineolic: JSONNull?, cobbly: JSONNull?, conchyliferous: JSONNull?, congregation: JSONNull?, disdiapason: String?, enterotomy: JSONNull?, entophytal: JSONNull?, fewtrils: JSONNull?, herem: JSONNull?, homocerc: Bool?, koniga: JSONNull?, meticulosity: JSONNull?, micky: JSONNull?, mismarriage: JSONNull?, neurotrophic: JSONNull?, nonbookish: JSONNull?, persuasively: JSONNull?, replaceable: JSONNull?, silex: JSONNull?, taillight: JSONNull?, unjealous: JSONNull?, visitorial: JSONNull?) { + self.carbonarism = carbonarism + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.cineolic = cineolic + self.cobbly = cobbly + self.conchyliferous = conchyliferous + self.congregation = congregation + self.disdiapason = disdiapason + self.enterotomy = enterotomy + self.entophytal = entophytal + self.fewtrils = fewtrils + self.herem = herem + self.homocerc = homocerc + self.koniga = koniga + self.meticulosity = meticulosity + self.micky = micky + self.mismarriage = mismarriage + self.neurotrophic = neurotrophic + self.nonbookish = nonbookish + self.persuasively = persuasively + self.replaceable = replaceable + self.silex = silex + self.taillight = taillight + self.unjealous = unjealous + self.visitorial = visitorial + } +} + +// MARK: Pneumocele convenience initializers and mutators + +extension Pneumocele { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Pneumocele.self, from: data) + self.init(carbonarism: me.carbonarism, catharticalness: me.catharticalness, chirotherium: me.chirotherium, cineolic: me.cineolic, cobbly: me.cobbly, conchyliferous: me.conchyliferous, congregation: me.congregation, disdiapason: me.disdiapason, enterotomy: me.enterotomy, entophytal: me.entophytal, fewtrils: me.fewtrils, herem: me.herem, homocerc: me.homocerc, koniga: me.koniga, meticulosity: me.meticulosity, micky: me.micky, mismarriage: me.mismarriage, neurotrophic: me.neurotrophic, nonbookish: me.nonbookish, persuasively: me.persuasively, replaceable: me.replaceable, silex: me.silex, taillight: me.taillight, unjealous: me.unjealous, visitorial: me.visitorial) + } + + convenience 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) + } + + convenience 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 + ) -> Pneumocele { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Poliorcetic: Codable { + case bool(Bool) + case monaziteClass(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(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(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(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() + } + } +} + +// MARK: - PotwhiskyClass +final class 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" + } + + init(arciform: JSONNull?, cresolin: JSONNull?, disheartener: JSONNull?, disproportionable: JSONNull?, euchorda: JSONNull?, ferryway: JSONNull?, filamentiferous: JSONNull?, flemish: JSONNull?, forgainst: JSONNull?, grainering: JSONNull?, irrevoluble: JSONNull?, kindredship: JSONNull?, pinguitudinous: JSONNull?, simpletonic: JSONNull?, singsong: JSONNull?, submergement: JSONNull?, supraoesophagal: JSONNull?, thrashel: JSONNull?, tyremesis: JSONNull?, yoruba: JSONNull?) { + self.arciform = arciform + self.cresolin = cresolin + self.disheartener = disheartener + self.disproportionable = disproportionable + self.euchorda = euchorda + self.ferryway = ferryway + self.filamentiferous = filamentiferous + self.flemish = flemish + self.forgainst = forgainst + self.grainering = grainering + self.irrevoluble = irrevoluble + self.kindredship = kindredship + self.pinguitudinous = pinguitudinous + self.simpletonic = simpletonic + self.singsong = singsong + self.submergement = submergement + self.supraoesophagal = supraoesophagal + self.thrashel = thrashel + self.tyremesis = tyremesis + self.yoruba = yoruba + } +} + +// MARK: PotwhiskyClass convenience initializers and mutators + +extension PotwhiskyClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(PotwhiskyClass.self, from: data) + self.init(arciform: me.arciform, cresolin: me.cresolin, disheartener: me.disheartener, disproportionable: me.disproportionable, euchorda: me.euchorda, ferryway: me.ferryway, filamentiferous: me.filamentiferous, flemish: me.flemish, forgainst: me.forgainst, grainering: me.grainering, irrevoluble: me.irrevoluble, kindredship: me.kindredship, pinguitudinous: me.pinguitudinous, simpletonic: me.simpletonic, singsong: me.singsong, submergement: me.submergement, supraoesophagal: me.supraoesophagal, thrashel: me.thrashel, tyremesis: me.tyremesis, yoruba: me.yoruba) + } + + convenience 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) + } + + convenience 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 + ) -> PotwhiskyClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Practicalizer: Codable { + case monaziteClass(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(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(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(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) + } + } +} + +// MARK: - PrefreshmanClass +final class 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" + } + + init(azorubine: JSONNull?, choroiditis: JSONNull?, coagulatory: JSONNull?, cyclorama: JSONNull?, dolphus: JSONNull?, duckhearted: JSONNull?, ficus: JSONNull?, gemaric: JSONNull?, jugation: JSONNull?, myoliposis: JSONNull?, nonnomination: JSONNull?, palay: JSONNull?, pentactinal: JSONNull?, phaet: JSONNull?, piquant: JSONNull?, registration: JSONNull?, remancipation: JSONNull?, scutatiform: JSONNull?, theodolite: JSONNull?, underward: JSONNull?) { + self.azorubine = azorubine + self.choroiditis = choroiditis + self.coagulatory = coagulatory + self.cyclorama = cyclorama + self.dolphus = dolphus + self.duckhearted = duckhearted + self.ficus = ficus + self.gemaric = gemaric + self.jugation = jugation + self.myoliposis = myoliposis + self.nonnomination = nonnomination + self.palay = palay + self.pentactinal = pentactinal + self.phaet = phaet + self.piquant = piquant + self.registration = registration + self.remancipation = remancipation + self.scutatiform = scutatiform + self.theodolite = theodolite + self.underward = underward + } +} + +// MARK: PrefreshmanClass convenience initializers and mutators + +extension PrefreshmanClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(PrefreshmanClass.self, from: data) + self.init(azorubine: me.azorubine, choroiditis: me.choroiditis, coagulatory: me.coagulatory, cyclorama: me.cyclorama, dolphus: me.dolphus, duckhearted: me.duckhearted, ficus: me.ficus, gemaric: me.gemaric, jugation: me.jugation, myoliposis: me.myoliposis, nonnomination: me.nonnomination, palay: me.palay, pentactinal: me.pentactinal, phaet: me.phaet, piquant: me.piquant, registration: me.registration, remancipation: me.remancipation, scutatiform: me.scutatiform, theodolite: me.theodolite, underward: me.underward) + } + + convenience 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) + } + + convenience 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 + ) -> PrefreshmanClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Prehensility: Codable { + case bool(Bool) + case monaziteClass(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(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(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(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(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(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 + +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:ss.SSSSSSXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder +} + +// MARK: - Encode/decode helpers + +final 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/protocol-hashable--739b516c7897/quicktype.swift b/head/swift/test/inputs/json/priority/combinations3.json/protocol-hashable--739b516c7897/quicktype.swift new file mode 100644 index 0000000..0d99745 --- /dev/null +++ b/head/swift/test/inputs/json/priority/combinations3.json/protocol-hashable--739b516c7897/quicktype.swift @@ -0,0 +1,3227 @@ +// 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) + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +import Foundation + +// MARK: - TopLevel +struct TopLevel: Codable, Hashable { + let juror: [JurorElement] + let kongoni: [Kongoni] + let ladronism: [LadronismElement] + let landlubberly: [LandlubberlyElement] + let listener: [Listener] + let lupus: [LupusElement] + let maslin: [Maslin] + let monazite: [MonaziteElement] + let monoliteral: [Monoliteral] + let monotheistically: [MonotheisticallyElement] + let montage: [Montage] + let moralness: [Moralness] + let mowra: [MonaziteClass?] + let mulishly: [Mulishly] + let myoscope: [Myoscope] + let nach: [[Int?]?] + let neuromastic: [Neuromastic] + let noncontributing: [Noncontributing] + let nonnervous: [Nonnervous] + let nonvaluation: [Nonvaluation] + let occupationalist: [OccupationalistElement] + let outrival: [OutrivalElement] + let paleographically: [Paleographically] + let pamphletwise: [Pamphletwise] + let pediatrics: [Pediatric] + let perceptive: [Bool] + let piaculum: [PiaculumElement] + let piccadilly: [Piccadilly] + let piffler: [Piffler] + let pithful: [Pithful] + let placuntitis: [Placuntiti] + let plectopterous: [Plectopterous] + let pneumocele: [Pneumocele?] + let poliorcetic: [Poliorcetic] + let poormaster: [Poormaster] + let potwhisky: [PotwhiskyElement] + let practicalizer: [Practicalizer] + let prefreshman: [PrefreshmanElement] + let prehensility: [Prehensility] + let prevoidance: [Prevoidance] + let probant: [[String: Int?]] + let protext: [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" + } +} + +// 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( + juror: [JurorElement]? = nil, + kongoni: [Kongoni]? = nil, + ladronism: [LadronismElement]? = nil, + landlubberly: [LandlubberlyElement]? = nil, + listener: [Listener]? = nil, + lupus: [LupusElement]? = nil, + maslin: [Maslin]? = nil, + monazite: [MonaziteElement]? = nil, + monoliteral: [Monoliteral]? = nil, + monotheistically: [MonotheisticallyElement]? = nil, + montage: [Montage]? = nil, + moralness: [Moralness]? = nil, + mowra: [MonaziteClass?]? = nil, + mulishly: [Mulishly]? = nil, + myoscope: [Myoscope]? = nil, + nach: [[Int?]?]? = nil, + neuromastic: [Neuromastic]? = nil, + noncontributing: [Noncontributing]? = nil, + nonnervous: [Nonnervous]? = nil, + nonvaluation: [Nonvaluation]? = nil, + occupationalist: [OccupationalistElement]? = nil, + outrival: [OutrivalElement]? = nil, + paleographically: [Paleographically]? = nil, + pamphletwise: [Pamphletwise]? = nil, + pediatrics: [Pediatric]? = nil, + perceptive: [Bool]? = nil, + piaculum: [PiaculumElement]? = nil, + piccadilly: [Piccadilly]? = nil, + piffler: [Piffler]? = nil, + pithful: [Pithful]? = nil, + placuntitis: [Placuntiti]? = nil, + plectopterous: [Plectopterous]? = nil, + pneumocele: [Pneumocele?]? = nil, + poliorcetic: [Poliorcetic]? = nil, + poormaster: [Poormaster]? = nil, + potwhisky: [PotwhiskyElement]? = nil, + practicalizer: [Practicalizer]? = nil, + prefreshman: [PrefreshmanElement]? = nil, + prehensility: [Prehensility]? = nil, + prevoidance: [Prevoidance]? = nil, + probant: [[String: Int?]]? = nil, + protext: [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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum JurorElement: Codable, Hashable { + case bool(Bool) + case jurorClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - JurorClass +struct JurorClass: Codable, Hashable { + 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" + } +} + +// MARK: JurorClass convenience initializers and mutators + +extension JurorClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> JurorClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Kongoni: Codable, Hashable { + 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, Hashable { + case double(Double) + case ladronismClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - LadronismClass +struct LadronismClass: Codable, Hashable { + 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" + } +} + +// MARK: LadronismClass convenience initializers and mutators + +extension LadronismClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> LadronismClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum LandlubberlyElement: Codable, Hashable { + case bool(Bool) + case integer(Int) + case landlubberlyClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - LandlubberlyClass +struct LandlubberlyClass: Codable, Hashable { + 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" + } +} + +// MARK: LandlubberlyClass convenience initializers and mutators + +extension LandlubberlyClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> LandlubberlyClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Listener: Codable, Hashable { + 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, Hashable { + case integer(Int) + case lupusClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - LupusClass +struct LupusClass: Codable, Hashable { + 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" + } +} + +// MARK: LupusClass convenience initializers and mutators + +extension LupusClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> LupusClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - Maslin +struct Maslin: Codable, Hashable { + 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" + } +} + +// MARK: Maslin convenience initializers and mutators + +extension Maslin { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> Maslin { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum MonaziteElement: Codable, Hashable { + case double(Double) + case monaziteClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - MonaziteClass +struct MonaziteClass: Codable, Hashable { + 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" + } +} + +// MARK: MonaziteClass convenience initializers and mutators + +extension MonaziteClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> MonaziteClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Monoliteral: Codable, Hashable { + 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, Hashable { + case monotheisticallyClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - MonotheisticallyClass +struct MonotheisticallyClass: Codable, Hashable { + 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" + } +} + +// MARK: MonotheisticallyClass convenience initializers and mutators + +extension MonotheisticallyClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> MonotheisticallyClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Montage: Codable, Hashable { + 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, Hashable { + 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, Hashable { + 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, Hashable { + 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, Hashable { + 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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - Noncontributing +struct Noncontributing: Codable, Hashable { + 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" + } +} + +// MARK: Noncontributing convenience initializers and mutators + +extension Noncontributing { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> Noncontributing { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Nonnervous: Codable, Hashable { + 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, Hashable { + 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, Hashable { + case nullArray([JSONNull?]) + case occupationalistClass(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(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() + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - OccupationalistClass +struct OccupationalistClass: Codable, Hashable { + 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" + } +} + +// MARK: OccupationalistClass convenience initializers and mutators + +extension OccupationalistClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> OccupationalistClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum OutrivalElement: Codable, Hashable { + case double(Double) + case outrivalClass(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(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() + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - OutrivalClass +struct OutrivalClass: Codable, Hashable { + 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" + } +} + +// MARK: OutrivalClass convenience initializers and mutators + +extension OutrivalClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> OutrivalClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Paleographically: Codable, Hashable { + 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, Hashable { + 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, Hashable { + 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, Hashable { + case double(Double) + case piaculumClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - PiaculumClass +struct PiaculumClass: Codable, Hashable { + 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" + } +} + +// MARK: PiaculumClass convenience initializers and mutators + +extension PiaculumClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> PiaculumClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Piccadilly: Codable, Hashable { + 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, Hashable { + case monaziteClass(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(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, Hashable { + 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, Hashable { + 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, Hashable { + 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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - Pneumocele +struct Pneumocele: Codable, Hashable { + 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" + } +} + +// MARK: Pneumocele convenience initializers and mutators + +extension Pneumocele { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> Pneumocele { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Poliorcetic: Codable, Hashable { + case bool(Bool) + case monaziteClass(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(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, Hashable { + 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, Hashable { + case integer(Int) + case potwhiskyClass(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(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() + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - PotwhiskyClass +struct PotwhiskyClass: Codable, Hashable { + 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" + } +} + +// MARK: PotwhiskyClass convenience initializers and mutators + +extension PotwhiskyClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> PotwhiskyClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Practicalizer: Codable, Hashable { + case monaziteClass(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(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, Hashable { + case nullArray([JSONNull?]) + case prefreshmanClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - PrefreshmanClass +struct PrefreshmanClass: Codable, Hashable { + 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" + } +} + +// MARK: PrefreshmanClass convenience initializers and mutators + +extension PrefreshmanClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> PrefreshmanClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Prehensility: Codable, Hashable { + case bool(Bool) + case monaziteClass(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(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, Hashable { + case integer(Int) + case integerArray([Int]) + case monaziteClass(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(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, Hashable { + case bool(Bool) + case integerArray([Int]) + case monaziteClass(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(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 + +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:ss.SSSSSSXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder +} + +// 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/final-classes-true__struct-or-class-class--d3c62ec7414d/quicktype.swift b/head/swift/test/inputs/json/priority/combinations4.json/final-classes-true__struct-or-class-class--d3c62ec7414d/quicktype.swift new file mode 100644 index 0000000..7509976 --- /dev/null +++ b/head/swift/test/inputs/json/priority/combinations4.json/final-classes-true__struct-or-class-class--d3c62ec7414d/quicktype.swift @@ -0,0 +1,4096 @@ +// 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 +final class TopLevel: Codable { + let protrusive: [Protrusive] + let pulpitism: [PulpitismElement] + let pyodermia: [PyodermiaElement] + let quebrachine: [QuebrachineElement] + let querier: [Querier] + let rebarbative: [Rebarbative] + let reimagine: [Reimagine] + let ressaut: Ressaut + let retrocervical: [Retrocervical] + let revert: [Revert] + let rewrite: [RewriteElement] + let saccoderm: [Saccoderm] + let santir: [SantirElement] + let saprophilous: [Saprophilous] + let saxten: [SaxtenElement] + let scatty: [Scatty?] + let scoffer: [Scoffer] + let scrampum: [Scrampum] + let semantic: Double + let serpentinic: [Serpentinic] + let shadowable: [Shadowable] + let sistering: [SisteringElement] + let staghunting: [Staghunting] + let stagmometer: [Stagmometer] + let stimulability: [Stimulability] + let strangleable: [Strangleable] + let strenuosity: [StrenuosityElement] + let tabaxir: [Tabaxir] + let talpiform: [Talpiform] + let thwack: [Thwack] + let to: [Double?] + let tortricine: [Tortricine] + let truantcy: [TruantcyElement] + let turgesce: [String] + let unbeginning: [Unbeginning] + let underdunged: [Double] + let undesirability: [Undesirability] + let unerasing: [Unerasing] + let unguentarium: [Unguentarium] + let unimpeachably: [UnimpeachablyElement] + let unmortgaged: [Unmortgaged] + let unobstructed: [Unobstructed] + let unreceptivity: [Unreceptivity] + let unsatisfactoriness: [Unsatisfactoriness] + let unsecurity: [Int] + let unstressed: [UnstressedElement] + let untasked: [Untasked] + let unvarying: [Unvarying] + let vehemently: [Vehemently] + let warriorship: [String: Bool] + let whitepot: [Whitepot] + let wrothy: [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" + } + + init(protrusive: [Protrusive], pulpitism: [PulpitismElement], pyodermia: [PyodermiaElement], quebrachine: [QuebrachineElement], querier: [Querier], rebarbative: [Rebarbative], reimagine: [Reimagine], ressaut: Ressaut, retrocervical: [Retrocervical], revert: [Revert], rewrite: [RewriteElement], saccoderm: [Saccoderm], santir: [SantirElement], saprophilous: [Saprophilous], saxten: [SaxtenElement], scatty: [Scatty?], scoffer: [Scoffer], scrampum: [Scrampum], semantic: Double, serpentinic: [Serpentinic], shadowable: [Shadowable], sistering: [SisteringElement], staghunting: [Staghunting], stagmometer: [Stagmometer], stimulability: [Stimulability], strangleable: [Strangleable], strenuosity: [StrenuosityElement], tabaxir: [Tabaxir], talpiform: [Talpiform], thwack: [Thwack], to: [Double?], tortricine: [Tortricine], truantcy: [TruantcyElement], turgesce: [String], unbeginning: [Unbeginning], underdunged: [Double], undesirability: [Undesirability], unerasing: [Unerasing], unguentarium: [Unguentarium], unimpeachably: [UnimpeachablyElement], unmortgaged: [Unmortgaged], unobstructed: [Unobstructed], unreceptivity: [Unreceptivity], unsatisfactoriness: [Unsatisfactoriness], unsecurity: [Int], unstressed: [UnstressedElement], untasked: [Untasked], unvarying: [Unvarying], vehemently: [Vehemently], warriorship: [String: Bool], whitepot: [Whitepot], wrothy: [WrothyElement]) { + self.protrusive = protrusive + self.pulpitism = pulpitism + self.pyodermia = pyodermia + self.quebrachine = quebrachine + self.querier = querier + self.rebarbative = rebarbative + self.reimagine = reimagine + self.ressaut = ressaut + self.retrocervical = retrocervical + self.revert = revert + self.rewrite = rewrite + self.saccoderm = saccoderm + self.santir = santir + self.saprophilous = saprophilous + self.saxten = saxten + self.scatty = scatty + self.scoffer = scoffer + self.scrampum = scrampum + self.semantic = semantic + self.serpentinic = serpentinic + self.shadowable = shadowable + self.sistering = sistering + self.staghunting = staghunting + self.stagmometer = stagmometer + self.stimulability = stimulability + self.strangleable = strangleable + self.strenuosity = strenuosity + self.tabaxir = tabaxir + self.talpiform = talpiform + self.thwack = thwack + self.to = to + self.tortricine = tortricine + self.truantcy = truantcy + self.turgesce = turgesce + self.unbeginning = unbeginning + self.underdunged = underdunged + self.undesirability = undesirability + self.unerasing = unerasing + self.unguentarium = unguentarium + self.unimpeachably = unimpeachably + self.unmortgaged = unmortgaged + self.unobstructed = unobstructed + self.unreceptivity = unreceptivity + self.unsatisfactoriness = unsatisfactoriness + self.unsecurity = unsecurity + self.unstressed = unstressed + self.untasked = untasked + self.unvarying = unvarying + self.vehemently = vehemently + self.warriorship = warriorship + self.whitepot = whitepot + self.wrothy = wrothy + } +} + +// MARK: TopLevel convenience initializers and mutators + +extension TopLevel { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(TopLevel.self, from: data) + self.init(protrusive: me.protrusive, pulpitism: me.pulpitism, pyodermia: me.pyodermia, quebrachine: me.quebrachine, querier: me.querier, rebarbative: me.rebarbative, reimagine: me.reimagine, ressaut: me.ressaut, retrocervical: me.retrocervical, revert: me.revert, rewrite: me.rewrite, saccoderm: me.saccoderm, santir: me.santir, saprophilous: me.saprophilous, saxten: me.saxten, scatty: me.scatty, scoffer: me.scoffer, scrampum: me.scrampum, semantic: me.semantic, serpentinic: me.serpentinic, shadowable: me.shadowable, sistering: me.sistering, staghunting: me.staghunting, stagmometer: me.stagmometer, stimulability: me.stimulability, strangleable: me.strangleable, strenuosity: me.strenuosity, tabaxir: me.tabaxir, talpiform: me.talpiform, thwack: me.thwack, to: me.to, tortricine: me.tortricine, truantcy: me.truantcy, turgesce: me.turgesce, unbeginning: me.unbeginning, underdunged: me.underdunged, undesirability: me.undesirability, unerasing: me.unerasing, unguentarium: me.unguentarium, unimpeachably: me.unimpeachably, unmortgaged: me.unmortgaged, unobstructed: me.unobstructed, unreceptivity: me.unreceptivity, unsatisfactoriness: me.unsatisfactoriness, unsecurity: me.unsecurity, unstressed: me.unstressed, untasked: me.untasked, unvarying: me.unvarying, vehemently: me.vehemently, warriorship: me.warriorship, whitepot: me.whitepot, wrothy: me.wrothy) + } + + convenience 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) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + protrusive: [Protrusive]? = nil, + pulpitism: [PulpitismElement]? = nil, + pyodermia: [PyodermiaElement]? = nil, + quebrachine: [QuebrachineElement]? = nil, + querier: [Querier]? = nil, + rebarbative: [Rebarbative]? = nil, + reimagine: [Reimagine]? = nil, + ressaut: Ressaut? = nil, + retrocervical: [Retrocervical]? = nil, + revert: [Revert]? = nil, + rewrite: [RewriteElement]? = nil, + saccoderm: [Saccoderm]? = nil, + santir: [SantirElement]? = nil, + saprophilous: [Saprophilous]? = nil, + saxten: [SaxtenElement]? = nil, + scatty: [Scatty?]? = nil, + scoffer: [Scoffer]? = nil, + scrampum: [Scrampum]? = nil, + semantic: Double? = nil, + serpentinic: [Serpentinic]? = nil, + shadowable: [Shadowable]? = nil, + sistering: [SisteringElement]? = nil, + staghunting: [Staghunting]? = nil, + stagmometer: [Stagmometer]? = nil, + stimulability: [Stimulability]? = nil, + strangleable: [Strangleable]? = nil, + strenuosity: [StrenuosityElement]? = nil, + tabaxir: [Tabaxir]? = nil, + talpiform: [Talpiform]? = nil, + thwack: [Thwack]? = nil, + to: [Double?]? = nil, + tortricine: [Tortricine]? = nil, + truantcy: [TruantcyElement]? = nil, + turgesce: [String]? = nil, + unbeginning: [Unbeginning]? = nil, + underdunged: [Double]? = nil, + undesirability: [Undesirability]? = nil, + unerasing: [Unerasing]? = nil, + unguentarium: [Unguentarium]? = nil, + unimpeachably: [UnimpeachablyElement]? = nil, + unmortgaged: [Unmortgaged]? = nil, + unobstructed: [Unobstructed]? = nil, + unreceptivity: [Unreceptivity]? = nil, + unsatisfactoriness: [Unsatisfactoriness]? = nil, + unsecurity: [Int]? = nil, + unstressed: [UnstressedElement]? = nil, + untasked: [Untasked]? = nil, + unvarying: [Unvarying]? = nil, + vehemently: [Vehemently]? = nil, + warriorship: [String: Bool]? = nil, + whitepot: [Whitepot]? = nil, + wrothy: [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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +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(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(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) + } + } +} + +// MARK: - PulpitismClass +final class 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" + } + + init(abnet: JSONNull?, buckhorn: JSONNull?, calciform: JSONNull?, chelophore: JSONNull?, cogitation: JSONNull?, decreeable: JSONNull?, despicable: JSONNull?, isodiazo: JSONNull?, jadedly: JSONNull?, leptochlorite: JSONNull?, nursling: JSONNull?, palamedean: JSONNull?, photoheliograph: JSONNull?, pipewood: JSONNull?, roberd: JSONNull?, statable: JSONNull?, superassume: JSONNull?, syllabe: JSONNull?, toughhead: JSONNull?, underburn: JSONNull?) { + self.abnet = abnet + self.buckhorn = buckhorn + self.calciform = calciform + self.chelophore = chelophore + self.cogitation = cogitation + self.decreeable = decreeable + self.despicable = despicable + self.isodiazo = isodiazo + self.jadedly = jadedly + self.leptochlorite = leptochlorite + self.nursling = nursling + self.palamedean = palamedean + self.photoheliograph = photoheliograph + self.pipewood = pipewood + self.roberd = roberd + self.statable = statable + self.superassume = superassume + self.syllabe = syllabe + self.toughhead = toughhead + self.underburn = underburn + } +} + +// MARK: PulpitismClass convenience initializers and mutators + +extension PulpitismClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(PulpitismClass.self, from: data) + self.init(abnet: me.abnet, buckhorn: me.buckhorn, calciform: me.calciform, chelophore: me.chelophore, cogitation: me.cogitation, decreeable: me.decreeable, despicable: me.despicable, isodiazo: me.isodiazo, jadedly: me.jadedly, leptochlorite: me.leptochlorite, nursling: me.nursling, palamedean: me.palamedean, photoheliograph: me.photoheliograph, pipewood: me.pipewood, roberd: me.roberd, statable: me.statable, superassume: me.superassume, syllabe: me.syllabe, toughhead: me.toughhead, underburn: me.underburn) + } + + convenience 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) + } + + convenience 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 + ) -> PulpitismClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum PyodermiaElement: Codable { + case integer(Int) + case pyodermiaClass(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(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) + } + } +} + +// MARK: - PyodermiaClass +final class 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" + } + + init(aphoristically: JSONNull?, apophyllous: JSONNull?, cognize: JSONNull?, dermonosology: JSONNull?, gyppo: JSONNull?, ither: JSONNull?, juglandaceous: JSONNull?, litho: JSONNull?, macropterous: JSONNull?, photographer: JSONNull?, romancing: JSONNull?, rumness: JSONNull?, somniloquist: JSONNull?, stressfully: JSONNull?, tactically: JSONNull?, tracheophony: JSONNull?, unappositely: JSONNull?, unclothedly: JSONNull?, unimplied: JSONNull?, unsyncopated: JSONNull?) { + self.aphoristically = aphoristically + self.apophyllous = apophyllous + self.cognize = cognize + self.dermonosology = dermonosology + self.gyppo = gyppo + self.ither = ither + self.juglandaceous = juglandaceous + self.litho = litho + self.macropterous = macropterous + self.photographer = photographer + self.romancing = romancing + self.rumness = rumness + self.somniloquist = somniloquist + self.stressfully = stressfully + self.tactically = tactically + self.tracheophony = tracheophony + self.unappositely = unappositely + self.unclothedly = unclothedly + self.unimplied = unimplied + self.unsyncopated = unsyncopated + } +} + +// MARK: PyodermiaClass convenience initializers and mutators + +extension PyodermiaClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(PyodermiaClass.self, from: data) + self.init(aphoristically: me.aphoristically, apophyllous: me.apophyllous, cognize: me.cognize, dermonosology: me.dermonosology, gyppo: me.gyppo, ither: me.ither, juglandaceous: me.juglandaceous, litho: me.litho, macropterous: me.macropterous, photographer: me.photographer, romancing: me.romancing, rumness: me.rumness, somniloquist: me.somniloquist, stressfully: me.stressfully, tactically: me.tactically, tracheophony: me.tracheophony, unappositely: me.unappositely, unclothedly: me.unclothedly, unimplied: me.unimplied, unsyncopated: me.unsyncopated) + } + + convenience 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) + } + + convenience 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 + ) -> PyodermiaClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum QuebrachineElement: Codable { + case bool(Bool) + case quebrachineClass(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(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() + } + } +} + +// MARK: - QuebrachineClass +final class 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" + } + + init(catharticalness: Double, chirotherium: Int, disdiapason: String, homocerc: Bool, nonbookish: JSONNull?) { + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.disdiapason = disdiapason + self.homocerc = homocerc + self.nonbookish = nonbookish + } +} + +// MARK: QuebrachineClass convenience initializers and mutators + +extension QuebrachineClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(QuebrachineClass.self, from: data) + self.init(catharticalness: me.catharticalness, chirotherium: me.chirotherium, disdiapason: me.disdiapason, homocerc: me.homocerc, nonbookish: me.nonbookish) + } + + convenience 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) + } + + convenience 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 + ) -> QuebrachineClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +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) + } + } +} + +// MARK: - Reimagine +final class 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" + } + + init(adducible: JSONNull?, anabolin: JSONNull?, brainy: JSONNull?, catharticalness: Double?, chirotherium: Int?, chrysamine: JSONNull?, disdiapason: String?, fluxweed: JSONNull?, glaucine: JSONNull?, grobianism: JSONNull?, hermo: JSONNull?, hieroglyphist: JSONNull?, homocerc: Bool?, icteroid: JSONNull?, immortal: JSONNull?, impetulant: JSONNull?, irrigate: JSONNull?, myxedema: JSONNull?, nonbookish: JSONNull?, onyx: JSONNull?, repasser: JSONNull?, septomarginal: JSONNull?, subdie: JSONNull?, tibiometatarsal: JSONNull?, waltzlike: JSONNull?) { + self.adducible = adducible + self.anabolin = anabolin + self.brainy = brainy + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.chrysamine = chrysamine + self.disdiapason = disdiapason + self.fluxweed = fluxweed + self.glaucine = glaucine + self.grobianism = grobianism + self.hermo = hermo + self.hieroglyphist = hieroglyphist + self.homocerc = homocerc + self.icteroid = icteroid + self.immortal = immortal + self.impetulant = impetulant + self.irrigate = irrigate + self.myxedema = myxedema + self.nonbookish = nonbookish + self.onyx = onyx + self.repasser = repasser + self.septomarginal = septomarginal + self.subdie = subdie + self.tibiometatarsal = tibiometatarsal + self.waltzlike = waltzlike + } +} + +// MARK: Reimagine convenience initializers and mutators + +extension Reimagine { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Reimagine.self, from: data) + self.init(adducible: me.adducible, anabolin: me.anabolin, brainy: me.brainy, catharticalness: me.catharticalness, chirotherium: me.chirotherium, chrysamine: me.chrysamine, disdiapason: me.disdiapason, fluxweed: me.fluxweed, glaucine: me.glaucine, grobianism: me.grobianism, hermo: me.hermo, hieroglyphist: me.hieroglyphist, homocerc: me.homocerc, icteroid: me.icteroid, immortal: me.immortal, impetulant: me.impetulant, irrigate: me.irrigate, myxedema: me.myxedema, nonbookish: me.nonbookish, onyx: me.onyx, repasser: me.repasser, septomarginal: me.septomarginal, subdie: me.subdie, tibiometatarsal: me.tibiometatarsal, waltzlike: me.waltzlike) + } + + convenience 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) + } + + convenience 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 + ) -> Reimagine { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - Ressaut +final class 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" + } + + init(apperceptive: String, cuttoo: String, douser: String, drinkproof: String, forementioned: String, freesia: String, genevieve: String, hyperdiabolical: String, hypocone: String, irreverentially: String, jumart: String, mimosaceae: String, mollicrush: String, nedder: String, retinasphalt: String, sough: String, steading: String, theopaschitism: String, undurableness: String, unmingleable: String) { + self.apperceptive = apperceptive + self.cuttoo = cuttoo + self.douser = douser + self.drinkproof = drinkproof + self.forementioned = forementioned + self.freesia = freesia + self.genevieve = genevieve + self.hyperdiabolical = hyperdiabolical + self.hypocone = hypocone + self.irreverentially = irreverentially + self.jumart = jumart + self.mimosaceae = mimosaceae + self.mollicrush = mollicrush + self.nedder = nedder + self.retinasphalt = retinasphalt + self.sough = sough + self.steading = steading + self.theopaschitism = theopaschitism + self.undurableness = undurableness + self.unmingleable = unmingleable + } +} + +// MARK: Ressaut convenience initializers and mutators + +extension Ressaut { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Ressaut.self, from: data) + self.init(apperceptive: me.apperceptive, cuttoo: me.cuttoo, douser: me.douser, drinkproof: me.drinkproof, forementioned: me.forementioned, freesia: me.freesia, genevieve: me.genevieve, hyperdiabolical: me.hyperdiabolical, hypocone: me.hypocone, irreverentially: me.irreverentially, jumart: me.jumart, mimosaceae: me.mimosaceae, mollicrush: me.mollicrush, nedder: me.nedder, retinasphalt: me.retinasphalt, sough: me.sough, steading: me.steading, theopaschitism: me.theopaschitism, undurableness: me.undurableness, unmingleable: me.unmingleable) + } + + convenience 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) + } + + convenience 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 + ) -> Ressaut { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +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(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(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) + } + } +} + +// MARK: - RewriteClass +final class 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" + } + + init(accountancy: JSONNull?, cacotrophic: JSONNull?, contest: JSONNull?, couthily: JSONNull?, falculate: JSONNull?, foreseize: JSONNull?, hyades: JSONNull?, lemnad: JSONNull?, monotheistically: JSONNull?, nonflying: JSONNull?, ptenoglossa: JSONNull?, repatch: JSONNull?, rodman: JSONNull?, strung: JSONNull?, titmal: JSONNull?, twalpennyworth: JSONNull?, unblamable: JSONNull?, vertical: JSONNull?, whiggification: JSONNull?, yardman: JSONNull?) { + self.accountancy = accountancy + self.cacotrophic = cacotrophic + self.contest = contest + self.couthily = couthily + self.falculate = falculate + self.foreseize = foreseize + self.hyades = hyades + self.lemnad = lemnad + self.monotheistically = monotheistically + self.nonflying = nonflying + self.ptenoglossa = ptenoglossa + self.repatch = repatch + self.rodman = rodman + self.strung = strung + self.titmal = titmal + self.twalpennyworth = twalpennyworth + self.unblamable = unblamable + self.vertical = vertical + self.whiggification = whiggification + self.yardman = yardman + } +} + +// MARK: RewriteClass convenience initializers and mutators + +extension RewriteClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(RewriteClass.self, from: data) + self.init(accountancy: me.accountancy, cacotrophic: me.cacotrophic, contest: me.contest, couthily: me.couthily, falculate: me.falculate, foreseize: me.foreseize, hyades: me.hyades, lemnad: me.lemnad, monotheistically: me.monotheistically, nonflying: me.nonflying, ptenoglossa: me.ptenoglossa, repatch: me.repatch, rodman: me.rodman, strung: me.strung, titmal: me.titmal, twalpennyworth: me.twalpennyworth, unblamable: me.unblamable, vertical: me.vertical, whiggification: me.whiggification, yardman: me.yardman) + } + + convenience 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) + } + + convenience 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 + ) -> RewriteClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +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(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(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) + } + } +} + +// MARK: - SantirClass +final class 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" + } + + init(admiredly: JSONNull?, demicaponier: JSONNull?, epitympanic: JSONNull?, investitor: JSONNull?, lupiform: JSONNull?, monoflagellate: JSONNull?, paleoethnic: JSONNull?, prediscountable: JSONNull?, rhetoricals: JSONNull?, roomth: JSONNull?, saccharose: JSONNull?, septonasal: JSONNull?, serpenticide: JSONNull?, setarious: JSONNull?, spaework: JSONNull?, stylite: JSONNull?, suessiones: JSONNull?, timelily: JSONNull?, unprofaned: JSONNull?, vorticular: JSONNull?) { + self.admiredly = admiredly + self.demicaponier = demicaponier + self.epitympanic = epitympanic + self.investitor = investitor + self.lupiform = lupiform + self.monoflagellate = monoflagellate + self.paleoethnic = paleoethnic + self.prediscountable = prediscountable + self.rhetoricals = rhetoricals + self.roomth = roomth + self.saccharose = saccharose + self.septonasal = septonasal + self.serpenticide = serpenticide + self.setarious = setarious + self.spaework = spaework + self.stylite = stylite + self.suessiones = suessiones + self.timelily = timelily + self.unprofaned = unprofaned + self.vorticular = vorticular + } +} + +// MARK: SantirClass convenience initializers and mutators + +extension SantirClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(SantirClass.self, from: data) + self.init(admiredly: me.admiredly, demicaponier: me.demicaponier, epitympanic: me.epitympanic, investitor: me.investitor, lupiform: me.lupiform, monoflagellate: me.monoflagellate, paleoethnic: me.paleoethnic, prediscountable: me.prediscountable, rhetoricals: me.rhetoricals, roomth: me.roomth, saccharose: me.saccharose, septonasal: me.septonasal, serpenticide: me.serpenticide, setarious: me.setarious, spaework: me.spaework, stylite: me.stylite, suessiones: me.suessiones, timelily: me.timelily, unprofaned: me.unprofaned, vorticular: me.vorticular) + } + + convenience 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) + } + + convenience 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 + ) -> SantirClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +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(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(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) + } + } +} + +// MARK: - SaxtenClass +final class 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" + } + + init(algarrobilla: JSONNull?, bowgrace: JSONNull?, catharticalness: Double?, centaurid: JSONNull?, chirotherium: Int?, disdiapason: String?, flix: JSONNull?, germanely: JSONNull?, homocerc: Bool?, inhume: JSONNull?, lepidote: JSONNull?, megalochirous: JSONNull?, ninepenny: JSONNull?, nonbookish: JSONNull?, nondeist: JSONNull?, nymphaeaceous: JSONNull?, parietofrontal: JSONNull?, sancyite: JSONNull?, subjectivist: JSONNull?, tibiad: JSONNull?, transonic: JSONNull?, tripetalous: JSONNull?, trunchman: JSONNull?, urger: JSONNull?, withdrawnness: JSONNull?) { + self.algarrobilla = algarrobilla + self.bowgrace = bowgrace + self.catharticalness = catharticalness + self.centaurid = centaurid + self.chirotherium = chirotherium + self.disdiapason = disdiapason + self.flix = flix + self.germanely = germanely + self.homocerc = homocerc + self.inhume = inhume + self.lepidote = lepidote + self.megalochirous = megalochirous + self.ninepenny = ninepenny + self.nonbookish = nonbookish + self.nondeist = nondeist + self.nymphaeaceous = nymphaeaceous + self.parietofrontal = parietofrontal + self.sancyite = sancyite + self.subjectivist = subjectivist + self.tibiad = tibiad + self.transonic = transonic + self.tripetalous = tripetalous + self.trunchman = trunchman + self.urger = urger + self.withdrawnness = withdrawnness + } +} + +// MARK: SaxtenClass convenience initializers and mutators + +extension SaxtenClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(SaxtenClass.self, from: data) + self.init(algarrobilla: me.algarrobilla, bowgrace: me.bowgrace, catharticalness: me.catharticalness, centaurid: me.centaurid, chirotherium: me.chirotherium, disdiapason: me.disdiapason, flix: me.flix, germanely: me.germanely, homocerc: me.homocerc, inhume: me.inhume, lepidote: me.lepidote, megalochirous: me.megalochirous, ninepenny: me.ninepenny, nonbookish: me.nonbookish, nondeist: me.nondeist, nymphaeaceous: me.nymphaeaceous, parietofrontal: me.parietofrontal, sancyite: me.sancyite, subjectivist: me.subjectivist, tibiad: me.tibiad, transonic: me.transonic, tripetalous: me.tripetalous, trunchman: me.trunchman, urger: me.urger, withdrawnness: me.withdrawnness) + } + + convenience 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) + } + + convenience 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 + ) -> SaxtenClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - Scatty +final class 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" + } + + init(aeriferous: JSONNull?, antical: JSONNull?, antighostism: JSONNull?, arcanum: JSONNull?, autotrophy: JSONNull?, baronial: JSONNull?, caffeine: JSONNull?, gorgoniacean: JSONNull?, heroical: JSONNull?, hydropical: JSONNull?, mechanology: JSONNull?, musicopoetic: JSONNull?, officiality: JSONNull?, oftentimes: JSONNull?, ophthalmotonometer: JSONNull?, reflectively: JSONNull?, springer: JSONNull?, tabasco: JSONNull?, teleianthous: JSONNull?, uncombated: JSONNull?) { + self.aeriferous = aeriferous + self.antical = antical + self.antighostism = antighostism + self.arcanum = arcanum + self.autotrophy = autotrophy + self.baronial = baronial + self.caffeine = caffeine + self.gorgoniacean = gorgoniacean + self.heroical = heroical + self.hydropical = hydropical + self.mechanology = mechanology + self.musicopoetic = musicopoetic + self.officiality = officiality + self.oftentimes = oftentimes + self.ophthalmotonometer = ophthalmotonometer + self.reflectively = reflectively + self.springer = springer + self.tabasco = tabasco + self.teleianthous = teleianthous + self.uncombated = uncombated + } +} + +// MARK: Scatty convenience initializers and mutators + +extension Scatty { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Scatty.self, from: data) + self.init(aeriferous: me.aeriferous, antical: me.antical, antighostism: me.antighostism, arcanum: me.arcanum, autotrophy: me.autotrophy, baronial: me.baronial, caffeine: me.caffeine, gorgoniacean: me.gorgoniacean, heroical: me.heroical, hydropical: me.hydropical, mechanology: me.mechanology, musicopoetic: me.musicopoetic, officiality: me.officiality, oftentimes: me.oftentimes, ophthalmotonometer: me.ophthalmotonometer, reflectively: me.reflectively, springer: me.springer, tabasco: me.tabasco, teleianthous: me.teleianthous, uncombated: me.uncombated) + } + + convenience 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) + } + + convenience 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 + ) -> Scatty { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +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(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(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) + } + } +} + +// MARK: - SisteringClass +final class 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" + } + + init(amphicarpic: JSONNull?, chianti: JSONNull?, frigorific: JSONNull?, haplomi: JSONNull?, hyperkinesis: JSONNull?, laudable: JSONNull?, madwoman: JSONNull?, maimedly: JSONNull?, micropterygidae: JSONNull?, microrhabdus: JSONNull?, nondense: JSONNull?, phlebemphraxis: JSONNull?, redsear: JSONNull?, schismatical: JSONNull?, tartryl: JSONNull?, unabhorred: JSONNull?, undeliberateness: JSONNull?, unmixable: JSONNull?, untruckling: JSONNull?, vineal: JSONNull?) { + self.amphicarpic = amphicarpic + self.chianti = chianti + self.frigorific = frigorific + self.haplomi = haplomi + self.hyperkinesis = hyperkinesis + self.laudable = laudable + self.madwoman = madwoman + self.maimedly = maimedly + self.micropterygidae = micropterygidae + self.microrhabdus = microrhabdus + self.nondense = nondense + self.phlebemphraxis = phlebemphraxis + self.redsear = redsear + self.schismatical = schismatical + self.tartryl = tartryl + self.unabhorred = unabhorred + self.undeliberateness = undeliberateness + self.unmixable = unmixable + self.untruckling = untruckling + self.vineal = vineal + } +} + +// MARK: SisteringClass convenience initializers and mutators + +extension SisteringClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(SisteringClass.self, from: data) + self.init(amphicarpic: me.amphicarpic, chianti: me.chianti, frigorific: me.frigorific, haplomi: me.haplomi, hyperkinesis: me.hyperkinesis, laudable: me.laudable, madwoman: me.madwoman, maimedly: me.maimedly, micropterygidae: me.micropterygidae, microrhabdus: me.microrhabdus, nondense: me.nondense, phlebemphraxis: me.phlebemphraxis, redsear: me.redsear, schismatical: me.schismatical, tartryl: me.tartryl, unabhorred: me.unabhorred, undeliberateness: me.undeliberateness, unmixable: me.unmixable, untruckling: me.untruckling, vineal: me.vineal) + } + + convenience 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) + } + + convenience 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 + ) -> SisteringClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - Staghunting +final class 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" + } + + init(calorimetric: Int?, canid: Int?, catharticalness: Double?, chirotherium: Int?, disdiapason: String?, ditriglyphic: Int?, floriferousness: Int?, gamelike: Int?, grig: Int?, homocerc: Bool?, interloan: Int?, lithotomy: Int?, loric: Int?, membranocoriaceous: Int?, membranogenic: Int?, nonbookish: JSONNull?, overtrump: Int?, scotino: Int?, seasonable: Int?, sephen: Int?, stigmarioid: Int?, tired: Int?, trifid: Int?, undefeatedly: Int?, ungirlish: Int?) { + self.calorimetric = calorimetric + self.canid = canid + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.disdiapason = disdiapason + self.ditriglyphic = ditriglyphic + self.floriferousness = floriferousness + self.gamelike = gamelike + self.grig = grig + self.homocerc = homocerc + self.interloan = interloan + self.lithotomy = lithotomy + self.loric = loric + self.membranocoriaceous = membranocoriaceous + self.membranogenic = membranogenic + self.nonbookish = nonbookish + self.overtrump = overtrump + self.scotino = scotino + self.seasonable = seasonable + self.sephen = sephen + self.stigmarioid = stigmarioid + self.tired = tired + self.trifid = trifid + self.undefeatedly = undefeatedly + self.ungirlish = ungirlish + } +} + +// MARK: Staghunting convenience initializers and mutators + +extension Staghunting { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Staghunting.self, from: data) + self.init(calorimetric: me.calorimetric, canid: me.canid, catharticalness: me.catharticalness, chirotherium: me.chirotherium, disdiapason: me.disdiapason, ditriglyphic: me.ditriglyphic, floriferousness: me.floriferousness, gamelike: me.gamelike, grig: me.grig, homocerc: me.homocerc, interloan: me.interloan, lithotomy: me.lithotomy, loric: me.loric, membranocoriaceous: me.membranocoriaceous, membranogenic: me.membranogenic, nonbookish: me.nonbookish, overtrump: me.overtrump, scotino: me.scotino, seasonable: me.seasonable, sephen: me.sephen, stigmarioid: me.stigmarioid, tired: me.tired, trifid: me.trifid, undefeatedly: me.undefeatedly, ungirlish: me.ungirlish) + } + + convenience 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) + } + + convenience 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 + ) -> Staghunting { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +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(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(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) + } + } +} + +// MARK: - StrenuosityClass +final class 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" + } + + init(bliss: Int?, buccate: Int?, bulletproof: Int?, catharticalness: Double?, chirotherium: Int?, crumblingness: Int?, disdiapason: String?, engagedly: Int?, fightable: Int?, hoariness: Int?, homocerc: Bool?, hypopodium: Int?, luxurist: Int?, mechanician: Int?, nonbookish: JSONNull?, onopordon: Int?, podgily: Int?, reformableness: Int?, scatterbrains: Int?, seminuria: Int?, sodomite: Int?, tramp: Int?, undueness: Int?, worthily: Int?, yankeeist: Int?) { + self.bliss = bliss + self.buccate = buccate + self.bulletproof = bulletproof + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.crumblingness = crumblingness + self.disdiapason = disdiapason + self.engagedly = engagedly + self.fightable = fightable + self.hoariness = hoariness + self.homocerc = homocerc + self.hypopodium = hypopodium + self.luxurist = luxurist + self.mechanician = mechanician + self.nonbookish = nonbookish + self.onopordon = onopordon + self.podgily = podgily + self.reformableness = reformableness + self.scatterbrains = scatterbrains + self.seminuria = seminuria + self.sodomite = sodomite + self.tramp = tramp + self.undueness = undueness + self.worthily = worthily + self.yankeeist = yankeeist + } +} + +// MARK: StrenuosityClass convenience initializers and mutators + +extension StrenuosityClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(StrenuosityClass.self, from: data) + self.init(bliss: me.bliss, buccate: me.buccate, bulletproof: me.bulletproof, catharticalness: me.catharticalness, chirotherium: me.chirotherium, crumblingness: me.crumblingness, disdiapason: me.disdiapason, engagedly: me.engagedly, fightable: me.fightable, hoariness: me.hoariness, homocerc: me.homocerc, hypopodium: me.hypopodium, luxurist: me.luxurist, mechanician: me.mechanician, nonbookish: me.nonbookish, onopordon: me.onopordon, podgily: me.podgily, reformableness: me.reformableness, scatterbrains: me.scatterbrains, seminuria: me.seminuria, sodomite: me.sodomite, tramp: me.tramp, undueness: me.undueness, worthily: me.worthily, yankeeist: me.yankeeist) + } + + convenience 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) + } + + convenience 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 + ) -> StrenuosityClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +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(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(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(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(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(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(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(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(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) + } + } +} + +// MARK: - TruantcyClass +final class 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" + } + + init(alfiona: JSONNull?, ascaridiasis: JSONNull?, bungey: JSONNull?, catharticalness: Double?, ceroxyle: JSONNull?, chirotherium: Int?, chorology: JSONNull?, disdiapason: String?, enmarble: JSONNull?, epeira: JSONNull?, eurylaimi: JSONNull?, germination: JSONNull?, hallelujah: JSONNull?, homocerc: Bool?, lev: JSONNull?, mouthing: JSONNull?, nonbookish: JSONNull?, philliloo: JSONNull?, planetal: JSONNull?, poney: JSONNull?, punctualist: JSONNull?, returnlessly: JSONNull?, skelder: JSONNull?, windwaywardly: JSONNull?, yuman: JSONNull?) { + self.alfiona = alfiona + self.ascaridiasis = ascaridiasis + self.bungey = bungey + self.catharticalness = catharticalness + self.ceroxyle = ceroxyle + self.chirotherium = chirotherium + self.chorology = chorology + self.disdiapason = disdiapason + self.enmarble = enmarble + self.epeira = epeira + self.eurylaimi = eurylaimi + self.germination = germination + self.hallelujah = hallelujah + self.homocerc = homocerc + self.lev = lev + self.mouthing = mouthing + self.nonbookish = nonbookish + self.philliloo = philliloo + self.planetal = planetal + self.poney = poney + self.punctualist = punctualist + self.returnlessly = returnlessly + self.skelder = skelder + self.windwaywardly = windwaywardly + self.yuman = yuman + } +} + +// MARK: TruantcyClass convenience initializers and mutators + +extension TruantcyClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(TruantcyClass.self, from: data) + self.init(alfiona: me.alfiona, ascaridiasis: me.ascaridiasis, bungey: me.bungey, catharticalness: me.catharticalness, ceroxyle: me.ceroxyle, chirotherium: me.chirotherium, chorology: me.chorology, disdiapason: me.disdiapason, enmarble: me.enmarble, epeira: me.epeira, eurylaimi: me.eurylaimi, germination: me.germination, hallelujah: me.hallelujah, homocerc: me.homocerc, lev: me.lev, mouthing: me.mouthing, nonbookish: me.nonbookish, philliloo: me.philliloo, planetal: me.planetal, poney: me.poney, punctualist: me.punctualist, returnlessly: me.returnlessly, skelder: me.skelder, windwaywardly: me.windwaywardly, yuman: me.yuman) + } + + convenience 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) + } + + convenience 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 + ) -> TruantcyClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +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(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(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) + } + } +} + +// MARK: - UnimpeachablyClass +final class 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" + } + + init(acerin: Int?, bobadil: Int?, catharticalness: Double?, chirotherium: Int?, chlorophylligenous: Int?, conversational: Int?, demiowl: Int?, disdiapason: String?, ectorhinal: Int?, gamblesomeness: Int?, homocerc: Bool?, irrorate: Int?, kindergartening: Int?, lateritic: Int?, mespil: Int?, misconfiguration: Int?, nonbookish: JSONNull?, planometry: Int?, quiina: Int?, robert: Int?, rot: Int?, subcinctorium: Int?, tussocker: Int?, ultraproud: Int?, unsuggestedness: Int?) { + self.acerin = acerin + self.bobadil = bobadil + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.chlorophylligenous = chlorophylligenous + self.conversational = conversational + self.demiowl = demiowl + self.disdiapason = disdiapason + self.ectorhinal = ectorhinal + self.gamblesomeness = gamblesomeness + self.homocerc = homocerc + self.irrorate = irrorate + self.kindergartening = kindergartening + self.lateritic = lateritic + self.mespil = mespil + self.misconfiguration = misconfiguration + self.nonbookish = nonbookish + self.planometry = planometry + self.quiina = quiina + self.robert = robert + self.rot = rot + self.subcinctorium = subcinctorium + self.tussocker = tussocker + self.ultraproud = ultraproud + self.unsuggestedness = unsuggestedness + } +} + +// MARK: UnimpeachablyClass convenience initializers and mutators + +extension UnimpeachablyClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(UnimpeachablyClass.self, from: data) + self.init(acerin: me.acerin, bobadil: me.bobadil, catharticalness: me.catharticalness, chirotherium: me.chirotherium, chlorophylligenous: me.chlorophylligenous, conversational: me.conversational, demiowl: me.demiowl, disdiapason: me.disdiapason, ectorhinal: me.ectorhinal, gamblesomeness: me.gamblesomeness, homocerc: me.homocerc, irrorate: me.irrorate, kindergartening: me.kindergartening, lateritic: me.lateritic, mespil: me.mespil, misconfiguration: me.misconfiguration, nonbookish: me.nonbookish, planometry: me.planometry, quiina: me.quiina, robert: me.robert, rot: me.rot, subcinctorium: me.subcinctorium, tussocker: me.tussocker, ultraproud: me.ultraproud, unsuggestedness: me.unsuggestedness) + } + + convenience 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) + } + + convenience 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 + ) -> UnimpeachablyClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +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(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(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(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(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) + } + } +} + +// MARK: - UnstressedClass +final class 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" + } + + init(alain: JSONNull?, amphirhina: JSONNull?, antimachinery: JSONNull?, coldish: JSONNull?, crantara: JSONNull?, distinguishing: JSONNull?, elytroposis: JSONNull?, gentianwort: JSONNull?, heliosis: JSONNull?, instrumental: JSONNull?, introinflection: JSONNull?, kala: JSONNull?, lincolnian: JSONNull?, metad: JSONNull?, sarcophilus: JSONNull?, swingingly: JSONNull?, unconformity: JSONNull?, undecreed: JSONNull?, venerable: JSONNull?, vowellessness: JSONNull?) { + self.alain = alain + self.amphirhina = amphirhina + self.antimachinery = antimachinery + self.coldish = coldish + self.crantara = crantara + self.distinguishing = distinguishing + self.elytroposis = elytroposis + self.gentianwort = gentianwort + self.heliosis = heliosis + self.instrumental = instrumental + self.introinflection = introinflection + self.kala = kala + self.lincolnian = lincolnian + self.metad = metad + self.sarcophilus = sarcophilus + self.swingingly = swingingly + self.unconformity = unconformity + self.undecreed = undecreed + self.venerable = venerable + self.vowellessness = vowellessness + } +} + +// MARK: UnstressedClass convenience initializers and mutators + +extension UnstressedClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(UnstressedClass.self, from: data) + self.init(alain: me.alain, amphirhina: me.amphirhina, antimachinery: me.antimachinery, coldish: me.coldish, crantara: me.crantara, distinguishing: me.distinguishing, elytroposis: me.elytroposis, gentianwort: me.gentianwort, heliosis: me.heliosis, instrumental: me.instrumental, introinflection: me.introinflection, kala: me.kala, lincolnian: me.lincolnian, metad: me.metad, sarcophilus: me.sarcophilus, swingingly: me.swingingly, unconformity: me.unconformity, undecreed: me.undecreed, venerable: me.venerable, vowellessness: me.vowellessness) + } + + convenience 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) + } + + convenience 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 + ) -> UnstressedClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +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(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(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(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(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) + } + } +} + +// MARK: - WrothyClass +final class 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" + } + + init(aeschynanthus: JSONNull?, aquiferous: JSONNull?, cheapener: JSONNull?, enumeration: JSONNull?, ephesine: JSONNull?, escadrille: JSONNull?, estrous: JSONNull?, interestedly: JSONNull?, katakinetomer: JSONNull?, mortification: JSONNull?, morula: JSONNull?, orthosymmetrical: JSONNull?, overbark: JSONNull?, politist: JSONNull?, qualified: JSONNull?, sphenomalar: JSONNull?, throatful: JSONNull?, transhumance: JSONNull?, triandrian: JSONNull?, unbooked: JSONNull?) { + self.aeschynanthus = aeschynanthus + self.aquiferous = aquiferous + self.cheapener = cheapener + self.enumeration = enumeration + self.ephesine = ephesine + self.escadrille = escadrille + self.estrous = estrous + self.interestedly = interestedly + self.katakinetomer = katakinetomer + self.mortification = mortification + self.morula = morula + self.orthosymmetrical = orthosymmetrical + self.overbark = overbark + self.politist = politist + self.qualified = qualified + self.sphenomalar = sphenomalar + self.throatful = throatful + self.transhumance = transhumance + self.triandrian = triandrian + self.unbooked = unbooked + } +} + +// MARK: WrothyClass convenience initializers and mutators + +extension WrothyClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(WrothyClass.self, from: data) + self.init(aeschynanthus: me.aeschynanthus, aquiferous: me.aquiferous, cheapener: me.cheapener, enumeration: me.enumeration, ephesine: me.ephesine, escadrille: me.escadrille, estrous: me.estrous, interestedly: me.interestedly, katakinetomer: me.katakinetomer, mortification: me.mortification, morula: me.morula, orthosymmetrical: me.orthosymmetrical, overbark: me.overbark, politist: me.politist, qualified: me.qualified, sphenomalar: me.sphenomalar, throatful: me.throatful, transhumance: me.transhumance, triandrian: me.triandrian, unbooked: me.unbooked) + } + + convenience 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) + } + + convenience 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 + ) -> WrothyClass { + return 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 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:ss.SSSSSSXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder +} + +// MARK: - Encode/decode helpers + +final 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/protocol-hashable--739b516c7897/quicktype.swift b/head/swift/test/inputs/json/priority/combinations4.json/protocol-hashable--739b516c7897/quicktype.swift new file mode 100644 index 0000000..dac23fd --- /dev/null +++ b/head/swift/test/inputs/json/priority/combinations4.json/protocol-hashable--739b516c7897/quicktype.swift @@ -0,0 +1,3743 @@ +// 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) + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +import Foundation + +// MARK: - TopLevel +struct TopLevel: Codable, Hashable { + let protrusive: [Protrusive] + let pulpitism: [PulpitismElement] + let pyodermia: [PyodermiaElement] + let quebrachine: [QuebrachineElement] + let querier: [Querier] + let rebarbative: [Rebarbative] + let reimagine: [Reimagine] + let ressaut: Ressaut + let retrocervical: [Retrocervical] + let revert: [Revert] + let rewrite: [RewriteElement] + let saccoderm: [Saccoderm] + let santir: [SantirElement] + let saprophilous: [Saprophilous] + let saxten: [SaxtenElement] + let scatty: [Scatty?] + let scoffer: [Scoffer] + let scrampum: [Scrampum] + let semantic: Double + let serpentinic: [Serpentinic] + let shadowable: [Shadowable] + let sistering: [SisteringElement] + let staghunting: [Staghunting] + let stagmometer: [Stagmometer] + let stimulability: [Stimulability] + let strangleable: [Strangleable] + let strenuosity: [StrenuosityElement] + let tabaxir: [Tabaxir] + let talpiform: [Talpiform] + let thwack: [Thwack] + let to: [Double?] + let tortricine: [Tortricine] + let truantcy: [TruantcyElement] + let turgesce: [String] + let unbeginning: [Unbeginning] + let underdunged: [Double] + let undesirability: [Undesirability] + let unerasing: [Unerasing] + let unguentarium: [Unguentarium] + let unimpeachably: [UnimpeachablyElement] + let unmortgaged: [Unmortgaged] + let unobstructed: [Unobstructed] + let unreceptivity: [Unreceptivity] + let unsatisfactoriness: [Unsatisfactoriness] + let unsecurity: [Int] + let unstressed: [UnstressedElement] + let untasked: [Untasked] + let unvarying: [Unvarying] + let vehemently: [Vehemently] + let warriorship: [String: Bool] + let whitepot: [Whitepot] + let wrothy: [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" + } +} + +// 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( + protrusive: [Protrusive]? = nil, + pulpitism: [PulpitismElement]? = nil, + pyodermia: [PyodermiaElement]? = nil, + quebrachine: [QuebrachineElement]? = nil, + querier: [Querier]? = nil, + rebarbative: [Rebarbative]? = nil, + reimagine: [Reimagine]? = nil, + ressaut: Ressaut? = nil, + retrocervical: [Retrocervical]? = nil, + revert: [Revert]? = nil, + rewrite: [RewriteElement]? = nil, + saccoderm: [Saccoderm]? = nil, + santir: [SantirElement]? = nil, + saprophilous: [Saprophilous]? = nil, + saxten: [SaxtenElement]? = nil, + scatty: [Scatty?]? = nil, + scoffer: [Scoffer]? = nil, + scrampum: [Scrampum]? = nil, + semantic: Double? = nil, + serpentinic: [Serpentinic]? = nil, + shadowable: [Shadowable]? = nil, + sistering: [SisteringElement]? = nil, + staghunting: [Staghunting]? = nil, + stagmometer: [Stagmometer]? = nil, + stimulability: [Stimulability]? = nil, + strangleable: [Strangleable]? = nil, + strenuosity: [StrenuosityElement]? = nil, + tabaxir: [Tabaxir]? = nil, + talpiform: [Talpiform]? = nil, + thwack: [Thwack]? = nil, + to: [Double?]? = nil, + tortricine: [Tortricine]? = nil, + truantcy: [TruantcyElement]? = nil, + turgesce: [String]? = nil, + unbeginning: [Unbeginning]? = nil, + underdunged: [Double]? = nil, + undesirability: [Undesirability]? = nil, + unerasing: [Unerasing]? = nil, + unguentarium: [Unguentarium]? = nil, + unimpeachably: [UnimpeachablyElement]? = nil, + unmortgaged: [Unmortgaged]? = nil, + unobstructed: [Unobstructed]? = nil, + unreceptivity: [Unreceptivity]? = nil, + unsatisfactoriness: [Unsatisfactoriness]? = nil, + unsecurity: [Int]? = nil, + unstressed: [UnstressedElement]? = nil, + untasked: [Untasked]? = nil, + unvarying: [Unvarying]? = nil, + vehemently: [Vehemently]? = nil, + warriorship: [String: Bool]? = nil, + whitepot: [Whitepot]? = nil, + wrothy: [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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Protrusive: Codable, Hashable { + 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, Hashable { + case double(Double) + case integerArray([Int]) + case pulpitismClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - PulpitismClass +struct PulpitismClass: Codable, Hashable { + 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" + } +} + +// MARK: PulpitismClass convenience initializers and mutators + +extension PulpitismClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> PulpitismClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum PyodermiaElement: Codable, Hashable { + case integer(Int) + case pyodermiaClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - PyodermiaClass +struct PyodermiaClass: Codable, Hashable { + 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" + } +} + +// MARK: PyodermiaClass convenience initializers and mutators + +extension PyodermiaClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> PyodermiaClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum QuebrachineElement: Codable, Hashable { + case bool(Bool) + case quebrachineClass(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(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() + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - QuebrachineClass +struct QuebrachineClass: Codable, Hashable { + 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" + } +} + +// MARK: QuebrachineClass convenience initializers and mutators + +extension QuebrachineClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> QuebrachineClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Querier: Codable, Hashable { + 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, Hashable { + 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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - Reimagine +struct Reimagine: Codable, Hashable { + 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" + } +} + +// MARK: Reimagine convenience initializers and mutators + +extension Reimagine { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> Reimagine { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - Ressaut +struct Ressaut: Codable, Hashable { + 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" + } +} + +// MARK: Ressaut convenience initializers and mutators + +extension Ressaut { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> Ressaut { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Retrocervical: Codable, Hashable { + 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, Hashable { + 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, Hashable { + case double(Double) + case nullArray([JSONNull?]) + case rewriteClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - RewriteClass +struct RewriteClass: Codable, Hashable { + 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" + } +} + +// MARK: RewriteClass convenience initializers and mutators + +extension RewriteClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> RewriteClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Saccoderm: Codable, Hashable { + 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, Hashable { + case double(Double) + case santirClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - SantirClass +struct SantirClass: Codable, Hashable { + 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" + } +} + +// MARK: SantirClass convenience initializers and mutators + +extension SantirClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> SantirClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Saprophilous: Codable, Hashable { + 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, Hashable { + case saxtenClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - SaxtenClass +struct SaxtenClass: Codable, Hashable { + 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" + } +} + +// MARK: SaxtenClass convenience initializers and mutators + +extension SaxtenClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> SaxtenClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - Scatty +struct Scatty: Codable, Hashable { + 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" + } +} + +// MARK: Scatty convenience initializers and mutators + +extension Scatty { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> Scatty { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Scoffer: Codable, Hashable { + 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, Hashable { + 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, Hashable { + 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, Hashable { + 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, Hashable { + case integer(Int) + case nullArray([JSONNull?]) + case sisteringClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - SisteringClass +struct SisteringClass: Codable, Hashable { + 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" + } +} + +// MARK: SisteringClass convenience initializers and mutators + +extension SisteringClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> SisteringClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - Staghunting +struct Staghunting: Codable, Hashable { + 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" + } +} + +// MARK: Staghunting convenience initializers and mutators + +extension Staghunting { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> Staghunting { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Stagmometer: Codable, Hashable { + 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, Hashable { + 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, Hashable { + 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, Hashable { + case nullArray([JSONNull?]) + case strenuosityClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - StrenuosityClass +struct StrenuosityClass: Codable, Hashable { + 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" + } +} + +// MARK: StrenuosityClass convenience initializers and mutators + +extension StrenuosityClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> StrenuosityClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Tabaxir: Codable, Hashable { + 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, Hashable { + case double(Double) + case quebrachineClass(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(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, Hashable { + case bool(Bool) + case double(Double) + case quebrachineClass(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(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, Hashable { + case quebrachineClass(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(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, Hashable { + case bool(Bool) + case truantcyClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - TruantcyClass +struct TruantcyClass: Codable, Hashable { + 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" + } +} + +// MARK: TruantcyClass convenience initializers and mutators + +extension TruantcyClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> TruantcyClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Unbeginning: Codable, Hashable { + 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, Hashable { + 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, Hashable { + 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, Hashable { + 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, Hashable { + case bool(Bool) + case unimpeachablyClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - UnimpeachablyClass +struct UnimpeachablyClass: Codable, Hashable { + 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" + } +} + +// MARK: UnimpeachablyClass convenience initializers and mutators + +extension UnimpeachablyClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> UnimpeachablyClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Unmortgaged: Codable, Hashable { + 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, Hashable { + case integer(Int) + case quebrachineClass(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(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, Hashable { + 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, Hashable { + 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, Hashable { + case bool(Bool) + case string(String) + case unstressedClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - UnstressedClass +struct UnstressedClass: Codable, Hashable { + 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" + } +} + +// MARK: UnstressedClass convenience initializers and mutators + +extension UnstressedClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> UnstressedClass { + return 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 newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Untasked: Codable, Hashable { + 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, Hashable { + 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, Hashable { + 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, Hashable { + case double(Double) + case quebrachineClass(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(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, Hashable { + case nullArray([JSONNull?]) + case wrothyClass(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(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) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - WrothyClass +struct WrothyClass: Codable, Hashable { + 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: WrothyClass convenience initializers and mutators + +extension WrothyClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(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 + ) -> WrothyClass { + return 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 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:ss.SSSSSSXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder +} + +// 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/base/swift/test/inputs/json/priority/keywords.json/default/quicktype.swift b/head/swift/test/inputs/json/priority/keywords.json/default/quicktype.swift index 77836ce..542e12e 100644 --- a/base/swift/test/inputs/json/priority/keywords.json/default/quicktype.swift +++ b/head/swift/test/inputs/json/priority/keywords.json/default/quicktype.swift @@ -9596,6 +9596,7 @@ struct Obj4: Codable { let requires: Requires let restrict: Restrict let retain: Retain + let s: S let sbyte: Sbyte let sealed: Sealed let sel: Sel @@ -9663,6 +9664,7 @@ struct Obj4: Codable { case requires = "requires" case restrict = "restrict" case retain = "retain" + case s = "s" case sbyte = "sbyte" case sealed = "sealed" case sel = "SEL" @@ -9750,6 +9752,7 @@ extension Obj4 { requires: Requires? = nil, restrict: Restrict? = nil, retain: Retain? = nil, + s: S? = nil, sbyte: Sbyte? = nil, sealed: Sealed? = nil, sel: Sel? = nil, @@ -9817,6 +9820,7 @@ extension Obj4 { requires: requires ?? self.requires, restrict: restrict ?? self.restrict, retain: retain ?? self.retain, + s: s ?? self.s, sbyte: sbyte ?? self.sbyte, sealed: sealed ?? self.sealed, sel: sel ?? self.sel, @@ -11269,6 +11273,50 @@ extension Retain { } } +// MARK: - S +struct S: Codable { + let s: Int + + enum CodingKeys: String, CodingKey { + case s = "s" + } +} + +// MARK: S convenience initializers and mutators + +extension S { + init(data: Data) throws { + self = try newJSONDecoder().decode(S.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( + s: Int? = nil + ) -> S { + return S( + s: s ?? self.s + ) + } + + 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: - Sbyte struct Sbyte: Codable { let sbyte: Int diff --git a/base/swift/test/inputs/json/samples/simple-object.json/final-classes-true__struct-or-class-class--d3c62ec7414d/quicktype.swift b/base/swift/test/inputs/json/samples/simple-object.json/final-classes-true__struct-or-class-class--d3c62ec7414d/quicktype.swift deleted file mode 100644 index 86593ec..0000000 --- a/base/swift/test/inputs/json/samples/simple-object.json/final-classes-true__struct-or-class-class--d3c62ec7414d/quicktype.swift +++ /dev/null @@ -1,101 +0,0 @@ -// 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 -final class TopLevel: Codable { - let date: Int - let title: String - let validity: Bool - - enum CodingKeys: String, CodingKey { - case date = "date" - case title = "title" - case validity = "validity" - } - - init(date: Int, title: String, validity: Bool) { - self.date = date - self.title = title - self.validity = validity - } -} - -// MARK: TopLevel convenience initializers and mutators - -extension TopLevel { - convenience init(data: Data) throws { - let me = try newJSONDecoder().decode(TopLevel.self, from: data) - self.init(date: me.date, title: me.title, validity: me.validity) - } - - convenience 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) - } - - convenience init(fromURL url: URL) throws { - try self.init(data: try Data(contentsOf: url)) - } - - func with( - date: Int? = nil, - title: String? = nil, - validity: Bool? = nil - ) -> TopLevel { - return TopLevel( - date: date ?? self.date, - title: title ?? self.title, - validity: validity ?? self.validity - ) - } - - 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:ss.SSSSSSXXXXX" - encoder.dateEncodingStrategy = .formatted(formatter) - return encoder -} diff --git a/base/swift/test/inputs/json/samples/simple-object.json/protocol-hashable--739b516c7897/quicktype.swift b/base/swift/test/inputs/json/samples/simple-object.json/protocol-hashable--739b516c7897/quicktype.swift deleted file mode 100644 index 1188abe..0000000 --- a/base/swift/test/inputs/json/samples/simple-object.json/protocol-hashable--739b516c7897/quicktype.swift +++ /dev/null @@ -1,100 +0,0 @@ -// 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) - -// -// Hashable or Equatable: -// The compiler will not be able to synthesize the implementation of Hashable or Equatable -// for types that require the use of JSONAny, nor will the implementation of Hashable be -// synthesized for types that have collections (such as arrays or dictionaries). - -import Foundation - -// MARK: - TopLevel -struct TopLevel: Codable, Hashable { - let date: Int - let title: String - let validity: Bool - - enum CodingKeys: String, CodingKey { - case date = "date" - case title = "title" - case validity = "validity" - } -} - -// 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( - date: Int? = nil, - title: String? = nil, - validity: Bool? = nil - ) -> TopLevel { - return TopLevel( - date: date ?? self.date, - title: title ?? self.title, - validity: validity ?? self.validity - ) - } - - 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:ss.SSSSSSXXXXX" - encoder.dateEncodingStrategy = .formatted(formatter) - return encoder -} diff --git a/head/typescript/test/inputs/json/priority/combinations1.json/prefer-const-values-true--6b26e4d1265c/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations1.json/prefer-const-values-true--6b26e4d1265c/TopLevel.ts new file mode 100644 index 0000000..d56cf48 --- /dev/null +++ b/head/typescript/test/inputs/json/priority/combinations1.json/prefer-const-values-true--6b26e4d1265c/TopLevel.ts @@ -0,0 +1,909 @@ +// 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 { + centrodesmose: string; + cerograph: CerographElement[]; + chemotherapeutics: ChemotherapeuticElement[]; + cimelia: CimeliaElement[]; + citrated: number; + clinodome: Clinodome[]; + coadjust: CoadjustElement[]; + consilience: Consilience[]; + constructor: Constructor[]; + continuative: Continuative[]; + credulity: CredulityElement[]; + creviced: Creviced[]; + cubiculum: Array<(number | null)[]>; + deruralize: DeruralizeElement[]; + diaereses: DiaereseElement[]; + dissolution: (null[] | null)[]; + downstroke: Downstroke[]; + electrotautomerism: (number | null)[]; + eleutheromania: Eleutheromania[]; + encrust: Encrust; + entomoid: Entomoid[]; + epipaleolithic: Epipaleolithic[]; + expropriable: Expropriable[]; + faggingly: FagginglyElement[]; + fenks: FenkElement[]; + flagmaking: FlagmakingElement[]; + fluorometer: Fluorometer[]; + fulsome: (number | null)[]; + fuzzy: Fuzzy[]; + gardenwards: Gardenward[]; + generalissimo: Generalissimo[]; + habeas: ({ [key: string]: number } | null)[]; + hemicrystalline: Hemicrystalline[]; + hemocoele: HemocoeleElement[]; + hoister: Hoister[]; + hyperpiesis: Hyperpiesi[]; + hyppish: Hyppish[]; + idealizer: Idealizer[]; + incrustator: Incrustator[]; + intentiveness: Intentiveness[]; + interacinar: Interacinar; + intercorrelation: (number[] | null)[]; + jacutinga: Jacutinga[]; +} + +export type CerographElement = CerographClass | null | string; + +export interface CerographClass { + Tolowa: null; + apotropaion: null; + casuary: null; + creaker: null; + disqualification: null; + imperatorious: null; + impermeabilize: null; + metastoma: null; + noctidiurnal: null; + nonreserve: null; + ophthalmotonometry: null; + pailful: null; + pigfish: null; + pongee: null; + prosodical: null; + scrofuloderm: null; + storekeeping: null; + therologist: null; + tradeful: null; + unriveting: null; +} + +export type ChemotherapeuticElement = ChemotherapeuticClass | number; + +export interface ChemotherapeuticClass { + Chirotherium?: number; + Maureen?: null; + angioneurotic?: null; + availment?: null; + bladelet?: null; + catharticalness?: number; + caulis?: null; + chalcus?: null; + disdiapason?: string; + enteradenological?: null; + homocerc?: boolean; + imporosity?: null; + insistently?: null; + intraparietal?: null; + ivied?: null; + nonbookish?: null; + nostochine?: null; + nutcracker?: null; + ofttimes?: null; + phenocryst?: null; + precoincident?: null; + ramiferous?: null; + stagmometer?: null; + tetherball?: null; + unshy?: null; +} + +export type CimeliaElement = number[] | CimeliaClass | null; + +export interface CimeliaClass { + Chirotherium: number; + catharticalness: number; + disdiapason: string; + homocerc: boolean; + nonbookish: null; +} + +export type Clinodome = number | string; + +export type CoadjustElement = CoadjustClass | number; + +export interface CoadjustClass { + Benny?: null; + Chirotherium?: number; + Netherlandish?: null; + Phonelescope?: null; + Sedaceae?: null; + amidosulphonal?: null; + catharticalness?: number; + disdiapason?: string; + ensnare?: null; + homocerc?: boolean; + hybridizer?: null; + leastwise?: null; + lof?: null; + monkhood?: null; + nonbookish?: null; + peonism?: null; + porphyrogeniture?: null; + preindemnify?: null; + rosal?: null; + scalenous?: null; + scopine?: null; + suberinize?: null; + symbiot?: null; + tablefellow?: null; + unchargeable?: null; +} + +export type Consilience = number | { [key: string]: number }; + +export type Constructor = boolean | { [key: string]: number | null }; + +export type Continuative = { [key: string]: number } | string; + +export type CredulityElement = CredulityClass | number | string; + +export interface CredulityClass { + Flavia: null; + Hedychium: null; + Popean: null; + ammonolytic: null; + bushmaster: null; + considering: null; + consuetudinary: null; + embarras: null; + fineness: null; + flaithship: null; + gruffly: null; + leadwort: null; + overseriously: null; + parabola: null; + pectinatodenticulate: null; + pornocrat: null; + quadrisect: null; + seriality: null; + vamphorn: null; + wharp: null; +} + +export type Creviced = boolean | { [key: string]: number } | string; + +export type DeruralizeElement = null[] | boolean | DeruralizeClass; + +export interface DeruralizeClass { + Jehovistic: null; + Paninean: null; + Romney: null; + bockerel: null; + boulder: null; + churrus: null; + counterdigged: null; + dialogite: null; + digenic: null; + dunbird: null; + ergatogyne: null; + fiendful: null; + jackrod: null; + panther: null; + placentigerous: null; + sparm: null; + tocsin: null; + unnicked: null; + unstavable: null; + windfirm: null; +} + +export type DiaereseElement = number[] | boolean | DiaereseClass; + +export interface DiaereseClass { + Amoreuxia: null; + ani: null; + bernicle: null; + blackwasher: null; + blowhard: null; + broma: null; + closecross: null; + congregationalism: null; + grayly: null; + historically: null; + hoast: null; + irretentive: null; + parcener: null; + pedder: null; + pseudoanatomic: null; + rhizocarpian: null; + samel: null; + silker: null; + subdentated: null; + subobscure: null; +} + +export type Downstroke = null[] | boolean | string; + +export type Eleutheromania = number | { [key: string]: number } | string; + +export interface Encrust { + Hibernia: null; + Hibiscus: null; + Lepidosauria: null; + Syllidae: null; + comradely: null; + diacanthous: null; + feminineness: null; + gossamered: null; + lollingly: null; + manager: null; + mechanic: null; + overminuteness: null; + papelonne: null; + plebification: null; + pugmiller: null; + recoveror: null; + spermatoblastic: null; + ungyved: null; + whirlabout: null; + woodenware: null; +} + +export type Entomoid = CimeliaClass | number; + +export type Epipaleolithic = number[] | number; + +export type Expropriable = null[] | CimeliaClass | number; + +export type FagginglyElement = FagginglyClass | number; + +export interface FagginglyClass { + Anglic: null; + Heteromeri: null; + Poinsettia: null; + abranchian: null; + aculeiform: null; + adiaphoristic: null; + adoptionism: null; + antrotomy: null; + coerciveness: null; + decorist: null; + duckhood: null; + hypochnose: null; + lochage: null; + melee: null; + nonconformitant: null; + putatively: null; + semivolatile: null; + soleas: null; + unfastenable: null; + unmillinered: null; +} + +export type FenkElement = FenkClass | string; + +export interface FenkClass { + Dagomba: null; + Guyandot: null; + Reinwardtia: null; + Tritoness: null; + apoise: null; + astronomize: null; + cockhorse: null; + copular: null; + draffy: null; + foreigner: null; + neurogliosis: null; + osmious: null; + palpitate: null; + rebukeable: null; + reservatory: null; + scalt: null; + scripturalize: null; + tintometer: null; + undergrade: null; + undermountain: null; +} + +export type FlagmakingElement = boolean | FlagmakingClass | number; + +export interface FlagmakingClass { + Bunodonta: null; + Hydrocorisae: null; + Notacanthidae: null; + albarco: null; + hornify: null; + hypoglossus: null; + inexpiably: null; + ingratitude: null; + ladyfly: null; + medicament: null; + monogrammatic: null; + nobbut: null; + polyplacophore: null; + proexercise: null; + protoplast: null; + puzzling: null; + splanchnoskeleton: null; + unloveliness: null; + unquarantined: null; + unrenounceable: null; +} + +export type Fluorometer = number | null | string; + +export type Fuzzy = number | { [key: string]: number | null }; + +export type Gardenward = number[] | boolean | string; + +export type Generalissimo = boolean | { [key: string]: number } | null; + +export type Hemicrystalline = CimeliaClass | string; + +export type HemocoeleElement = number[] | HemocoeleClass; + +export interface HemocoeleClass { + Chirotherium?: number; + Walt?: null; + acrogamy?: null; + amelification?: null; + autobiographic?: null; + berat?: null; + catharticalness?: number; + disdiapason?: string; + disproportionably?: null; + erythrite?: null; + graphic?: null; + hepatological?: null; + homocerc?: boolean; + incommensurably?: null; + misaffirm?: null; + nonbookish?: null; + pocketbook?: null; + sclerometric?: null; + stambouline?: null; + stickpin?: null; + tubulure?: null; + undelated?: null; + unsalt?: null; + untutelar?: null; + vagrant?: null; +} + +export type Hoister = CimeliaClass | null | string; + +export type Hyperpiesi = null[] | CimeliaClass | null; + +export type Hyppish = boolean | null | string; + +export type Idealizer = null[] | CimeliaClass | number; + +export type Incrustator = number[] | number | string; + +export type Intentiveness = CimeliaClass | number | string; + +export interface Interacinar { + assapan: number; + benefactorship: boolean; + triseriatim: string; + tubbing: number; + untrimmed: null; +} + +export type Jacutinga = number[] | { [key: string]: number | null }; + +// 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("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) + : 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 i(typ: any) { + return { integer: typ }; +} + +function p(pattern: any) { + return { pattern }; +} + +function s(typ: any, min: any, max: any) { + return { string: typ, min, max }; +} + +function n(typ: any, min: any, max: any) { + return { number: typ, min, max }; +} + +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: "centrodesmose", js: "centrodesmose", typ: "" }, + { json: "cerograph", js: "cerograph", typ: a(u(r("CerographClass"), null, "")) }, + { json: "chemotherapeutics", js: "chemotherapeutics", typ: a(u(r("ChemotherapeuticClass"), i(0))) }, + { json: "cimelia", js: "cimelia", typ: a(u(a(i(0)), r("CimeliaClass"), null)) }, + { json: "citrated", js: "citrated", typ: i(0) }, + { json: "clinodome", js: "clinodome", typ: a(u(3.14, "")) }, + { json: "coadjust", js: "coadjust", typ: a(u(r("CoadjustClass"), 3.14)) }, + { json: "consilience", js: "consilience", typ: a(u(3.14, m(i(0)))) }, + { json: "constructor", js: "constructor", typ: a(u(true, m(u(i(0), null)))) }, + { json: "continuative", js: "continuative", typ: a(u(m(i(0)), "")) }, + { json: "credulity", js: "credulity", typ: a(u(r("CredulityClass"), i(0), "")) }, + { json: "creviced", js: "creviced", typ: a(u(true, m(i(0)), "")) }, + { json: "cubiculum", js: "cubiculum", typ: a(a(u(i(0), null))) }, + { json: "deruralize", js: "deruralize", typ: a(u(a(null), true, r("DeruralizeClass"))) }, + { json: "diaereses", js: "diaereses", typ: a(u(a(i(0)), true, r("DiaereseClass"))) }, + { json: "dissolution", js: "dissolution", typ: a(u(a(null), null)) }, + { json: "downstroke", js: "downstroke", typ: a(u(a(null), true, "")) }, + { json: "electrotautomerism", js: "electrotautomerism", typ: a(u(3.14, null)) }, + { json: "eleutheromania", js: "eleutheromania", typ: a(u(3.14, m(i(0)), "")) }, + { json: "encrust", js: "encrust", typ: r("Encrust") }, + { json: "entomoid", js: "entomoid", typ: a(u(r("CimeliaClass"), i(0))) }, + { json: "epipaleolithic", js: "epipaleolithic", typ: a(u(a(i(0)), 3.14)) }, + { json: "expropriable", js: "expropriable", typ: a(u(a(null), r("CimeliaClass"), 3.14)) }, + { json: "faggingly", js: "faggingly", typ: a(u(r("FagginglyClass"), 3.14)) }, + { json: "fenks", js: "fenks", typ: a(u(r("FenkClass"), "")) }, + { json: "flagmaking", js: "flagmaking", typ: a(u(true, r("FlagmakingClass"), 3.14)) }, + { json: "fluorometer", js: "fluorometer", typ: a(u(i(0), null, "")) }, + { json: "fulsome", js: "fulsome", typ: a(u(i(0), null)) }, + { json: "fuzzy", js: "fuzzy", typ: a(u(i(0), m(u(i(0), null)))) }, + { json: "gardenwards", js: "gardenwards", typ: a(u(a(i(0)), true, "")) }, + { json: "generalissimo", js: "generalissimo", typ: a(u(true, m(i(0)), null)) }, + { json: "habeas", js: "habeas", typ: a(u(m(i(0)), null)) }, + { json: "hemicrystalline", js: "hemicrystalline", typ: a(u(r("CimeliaClass"), "")) }, + { json: "hemocoele", js: "hemocoele", typ: a(u(a(i(0)), r("HemocoeleClass"))) }, + { json: "hoister", js: "hoister", typ: a(u(r("CimeliaClass"), null, "")) }, + { json: "hyperpiesis", js: "hyperpiesis", typ: a(u(a(null), r("CimeliaClass"), null)) }, + { json: "hyppish", js: "hyppish", typ: a(u(true, null, "")) }, + { json: "idealizer", js: "idealizer", typ: a(u(a(null), r("CimeliaClass"), i(0))) }, + { json: "incrustator", js: "incrustator", typ: a(u(a(i(0)), i(0), "")) }, + { json: "intentiveness", js: "intentiveness", typ: a(u(r("CimeliaClass"), 3.14, "")) }, + { json: "interacinar", js: "interacinar", typ: r("Interacinar") }, + { json: "intercorrelation", js: "intercorrelation", typ: a(u(a(i(0)), null)) }, + { json: "jacutinga", js: "jacutinga", typ: a(u(a(i(0)), m(u(i(0), null)))) }, + ], false), + "CerographClass": o([ + { json: "Tolowa", js: "Tolowa", typ: null }, + { json: "apotropaion", js: "apotropaion", typ: null }, + { json: "casuary", js: "casuary", typ: null }, + { json: "creaker", js: "creaker", typ: null }, + { json: "disqualification", js: "disqualification", typ: null }, + { json: "imperatorious", js: "imperatorious", typ: null }, + { json: "impermeabilize", js: "impermeabilize", typ: null }, + { json: "metastoma", js: "metastoma", typ: null }, + { json: "noctidiurnal", js: "noctidiurnal", typ: null }, + { json: "nonreserve", js: "nonreserve", typ: null }, + { json: "ophthalmotonometry", js: "ophthalmotonometry", typ: null }, + { json: "pailful", js: "pailful", typ: null }, + { json: "pigfish", js: "pigfish", typ: null }, + { json: "pongee", js: "pongee", typ: null }, + { json: "prosodical", js: "prosodical", typ: null }, + { json: "scrofuloderm", js: "scrofuloderm", typ: null }, + { json: "storekeeping", js: "storekeeping", typ: null }, + { json: "therologist", js: "therologist", typ: null }, + { json: "tradeful", js: "tradeful", typ: null }, + { json: "unriveting", js: "unriveting", typ: null }, + ], false), + "ChemotherapeuticClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Maureen", js: "Maureen", typ: u(undefined, null) }, + { json: "angioneurotic", js: "angioneurotic", typ: u(undefined, null) }, + { json: "availment", js: "availment", typ: u(undefined, null) }, + { json: "bladelet", js: "bladelet", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "caulis", js: "caulis", typ: u(undefined, null) }, + { json: "chalcus", js: "chalcus", typ: u(undefined, null) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "enteradenological", js: "enteradenological", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "imporosity", js: "imporosity", typ: u(undefined, null) }, + { json: "insistently", js: "insistently", typ: u(undefined, null) }, + { json: "intraparietal", js: "intraparietal", typ: u(undefined, null) }, + { json: "ivied", js: "ivied", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "nostochine", js: "nostochine", typ: u(undefined, null) }, + { json: "nutcracker", js: "nutcracker", typ: u(undefined, null) }, + { json: "ofttimes", js: "ofttimes", typ: u(undefined, null) }, + { json: "phenocryst", js: "phenocryst", typ: u(undefined, null) }, + { json: "precoincident", js: "precoincident", typ: u(undefined, null) }, + { json: "ramiferous", js: "ramiferous", typ: u(undefined, null) }, + { json: "stagmometer", js: "stagmometer", typ: u(undefined, null) }, + { json: "tetherball", js: "tetherball", typ: u(undefined, null) }, + { json: "unshy", js: "unshy", typ: u(undefined, null) }, + ], false), + "CimeliaClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: i(0) }, + { json: "catharticalness", js: "catharticalness", typ: 3.14 }, + { json: "disdiapason", js: "disdiapason", typ: "" }, + { json: "homocerc", js: "homocerc", typ: true }, + { json: "nonbookish", js: "nonbookish", typ: null }, + ], false), + "CoadjustClass": o([ + { json: "Benny", js: "Benny", typ: u(undefined, null) }, + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Netherlandish", js: "Netherlandish", typ: u(undefined, null) }, + { json: "Phonelescope", js: "Phonelescope", typ: u(undefined, null) }, + { json: "Sedaceae", js: "Sedaceae", typ: u(undefined, null) }, + { json: "amidosulphonal", js: "amidosulphonal", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "ensnare", js: "ensnare", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "hybridizer", js: "hybridizer", typ: u(undefined, null) }, + { json: "leastwise", js: "leastwise", typ: u(undefined, null) }, + { json: "lof", js: "lof", typ: u(undefined, null) }, + { json: "monkhood", js: "monkhood", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "peonism", js: "peonism", typ: u(undefined, null) }, + { json: "porphyrogeniture", js: "porphyrogeniture", typ: u(undefined, null) }, + { json: "preindemnify", js: "preindemnify", typ: u(undefined, null) }, + { json: "rosal", js: "rosal", typ: u(undefined, null) }, + { json: "scalenous", js: "scalenous", typ: u(undefined, null) }, + { json: "scopine", js: "scopine", typ: u(undefined, null) }, + { json: "suberinize", js: "suberinize", typ: u(undefined, null) }, + { json: "symbiot", js: "symbiot", typ: u(undefined, null) }, + { json: "tablefellow", js: "tablefellow", typ: u(undefined, null) }, + { json: "unchargeable", js: "unchargeable", typ: u(undefined, null) }, + ], false), + "CredulityClass": o([ + { json: "Flavia", js: "Flavia", typ: null }, + { json: "Hedychium", js: "Hedychium", typ: null }, + { json: "Popean", js: "Popean", typ: null }, + { json: "ammonolytic", js: "ammonolytic", typ: null }, + { json: "bushmaster", js: "bushmaster", typ: null }, + { json: "considering", js: "considering", typ: null }, + { json: "consuetudinary", js: "consuetudinary", typ: null }, + { json: "embarras", js: "embarras", typ: null }, + { json: "fineness", js: "fineness", typ: null }, + { json: "flaithship", js: "flaithship", typ: null }, + { json: "gruffly", js: "gruffly", typ: null }, + { json: "leadwort", js: "leadwort", typ: null }, + { json: "overseriously", js: "overseriously", typ: null }, + { json: "parabola", js: "parabola", typ: null }, + { json: "pectinatodenticulate", js: "pectinatodenticulate", typ: null }, + { json: "pornocrat", js: "pornocrat", typ: null }, + { json: "quadrisect", js: "quadrisect", typ: null }, + { json: "seriality", js: "seriality", typ: null }, + { json: "vamphorn", js: "vamphorn", typ: null }, + { json: "wharp", js: "wharp", typ: null }, + ], false), + "DeruralizeClass": o([ + { json: "Jehovistic", js: "Jehovistic", typ: null }, + { json: "Paninean", js: "Paninean", typ: null }, + { json: "Romney", js: "Romney", typ: null }, + { json: "bockerel", js: "bockerel", typ: null }, + { json: "boulder", js: "boulder", typ: null }, + { json: "churrus", js: "churrus", typ: null }, + { json: "counterdigged", js: "counterdigged", typ: null }, + { json: "dialogite", js: "dialogite", typ: null }, + { json: "digenic", js: "digenic", typ: null }, + { json: "dunbird", js: "dunbird", typ: null }, + { json: "ergatogyne", js: "ergatogyne", typ: null }, + { json: "fiendful", js: "fiendful", typ: null }, + { json: "jackrod", js: "jackrod", typ: null }, + { json: "panther", js: "panther", typ: null }, + { json: "placentigerous", js: "placentigerous", typ: null }, + { json: "sparm", js: "sparm", typ: null }, + { json: "tocsin", js: "tocsin", typ: null }, + { json: "unnicked", js: "unnicked", typ: null }, + { json: "unstavable", js: "unstavable", typ: null }, + { json: "windfirm", js: "windfirm", typ: null }, + ], false), + "DiaereseClass": o([ + { json: "Amoreuxia", js: "Amoreuxia", typ: null }, + { json: "ani", js: "ani", typ: null }, + { json: "bernicle", js: "bernicle", typ: null }, + { json: "blackwasher", js: "blackwasher", typ: null }, + { json: "blowhard", js: "blowhard", typ: null }, + { json: "broma", js: "broma", typ: null }, + { json: "closecross", js: "closecross", typ: null }, + { json: "congregationalism", js: "congregationalism", typ: null }, + { json: "grayly", js: "grayly", typ: null }, + { json: "historically", js: "historically", typ: null }, + { json: "hoast", js: "hoast", typ: null }, + { json: "irretentive", js: "irretentive", typ: null }, + { json: "parcener", js: "parcener", typ: null }, + { json: "pedder", js: "pedder", typ: null }, + { json: "pseudoanatomic", js: "pseudoanatomic", typ: null }, + { json: "rhizocarpian", js: "rhizocarpian", typ: null }, + { json: "samel", js: "samel", typ: null }, + { json: "silker", js: "silker", typ: null }, + { json: "subdentated", js: "subdentated", typ: null }, + { json: "subobscure", js: "subobscure", typ: null }, + ], false), + "Encrust": o([ + { json: "Hibernia", js: "Hibernia", typ: null }, + { json: "Hibiscus", js: "Hibiscus", typ: null }, + { json: "Lepidosauria", js: "Lepidosauria", typ: null }, + { json: "Syllidae", js: "Syllidae", typ: null }, + { json: "comradely", js: "comradely", typ: null }, + { json: "diacanthous", js: "diacanthous", typ: null }, + { json: "feminineness", js: "feminineness", typ: null }, + { json: "gossamered", js: "gossamered", typ: null }, + { json: "lollingly", js: "lollingly", typ: null }, + { json: "manager", js: "manager", typ: null }, + { json: "mechanic", js: "mechanic", typ: null }, + { json: "overminuteness", js: "overminuteness", typ: null }, + { json: "papelonne", js: "papelonne", typ: null }, + { json: "plebification", js: "plebification", typ: null }, + { json: "pugmiller", js: "pugmiller", typ: null }, + { json: "recoveror", js: "recoveror", typ: null }, + { json: "spermatoblastic", js: "spermatoblastic", typ: null }, + { json: "ungyved", js: "ungyved", typ: null }, + { json: "whirlabout", js: "whirlabout", typ: null }, + { json: "woodenware", js: "woodenware", typ: null }, + ], false), + "FagginglyClass": o([ + { json: "Anglic", js: "Anglic", typ: null }, + { json: "Heteromeri", js: "Heteromeri", typ: null }, + { json: "Poinsettia", js: "Poinsettia", typ: null }, + { json: "abranchian", js: "abranchian", typ: null }, + { json: "aculeiform", js: "aculeiform", typ: null }, + { json: "adiaphoristic", js: "adiaphoristic", typ: null }, + { json: "adoptionism", js: "adoptionism", typ: null }, + { json: "antrotomy", js: "antrotomy", typ: null }, + { json: "coerciveness", js: "coerciveness", typ: null }, + { json: "decorist", js: "decorist", typ: null }, + { json: "duckhood", js: "duckhood", typ: null }, + { json: "hypochnose", js: "hypochnose", typ: null }, + { json: "lochage", js: "lochage", typ: null }, + { json: "melee", js: "melee", typ: null }, + { json: "nonconformitant", js: "nonconformitant", typ: null }, + { json: "putatively", js: "putatively", typ: null }, + { json: "semivolatile", js: "semivolatile", typ: null }, + { json: "soleas", js: "soleas", typ: null }, + { json: "unfastenable", js: "unfastenable", typ: null }, + { json: "unmillinered", js: "unmillinered", typ: null }, + ], false), + "FenkClass": o([ + { json: "Dagomba", js: "Dagomba", typ: null }, + { json: "Guyandot", js: "Guyandot", typ: null }, + { json: "Reinwardtia", js: "Reinwardtia", typ: null }, + { json: "Tritoness", js: "Tritoness", typ: null }, + { json: "apoise", js: "apoise", typ: null }, + { json: "astronomize", js: "astronomize", typ: null }, + { json: "cockhorse", js: "cockhorse", typ: null }, + { json: "copular", js: "copular", typ: null }, + { json: "draffy", js: "draffy", typ: null }, + { json: "foreigner", js: "foreigner", typ: null }, + { json: "neurogliosis", js: "neurogliosis", typ: null }, + { json: "osmious", js: "osmious", typ: null }, + { json: "palpitate", js: "palpitate", typ: null }, + { json: "rebukeable", js: "rebukeable", typ: null }, + { json: "reservatory", js: "reservatory", typ: null }, + { json: "scalt", js: "scalt", typ: null }, + { json: "scripturalize", js: "scripturalize", typ: null }, + { json: "tintometer", js: "tintometer", typ: null }, + { json: "undergrade", js: "undergrade", typ: null }, + { json: "undermountain", js: "undermountain", typ: null }, + ], false), + "FlagmakingClass": o([ + { json: "Bunodonta", js: "Bunodonta", typ: null }, + { json: "Hydrocorisae", js: "Hydrocorisae", typ: null }, + { json: "Notacanthidae", js: "Notacanthidae", typ: null }, + { json: "albarco", js: "albarco", typ: null }, + { json: "hornify", js: "hornify", typ: null }, + { json: "hypoglossus", js: "hypoglossus", typ: null }, + { json: "inexpiably", js: "inexpiably", typ: null }, + { json: "ingratitude", js: "ingratitude", typ: null }, + { json: "ladyfly", js: "ladyfly", typ: null }, + { json: "medicament", js: "medicament", typ: null }, + { json: "monogrammatic", js: "monogrammatic", typ: null }, + { json: "nobbut", js: "nobbut", typ: null }, + { json: "polyplacophore", js: "polyplacophore", typ: null }, + { json: "proexercise", js: "proexercise", typ: null }, + { json: "protoplast", js: "protoplast", typ: null }, + { json: "puzzling", js: "puzzling", typ: null }, + { json: "splanchnoskeleton", js: "splanchnoskeleton", typ: null }, + { json: "unloveliness", js: "unloveliness", typ: null }, + { json: "unquarantined", js: "unquarantined", typ: null }, + { json: "unrenounceable", js: "unrenounceable", typ: null }, + ], false), + "HemocoeleClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Walt", js: "Walt", typ: u(undefined, null) }, + { json: "acrogamy", js: "acrogamy", typ: u(undefined, null) }, + { json: "amelification", js: "amelification", typ: u(undefined, null) }, + { json: "autobiographic", js: "autobiographic", typ: u(undefined, null) }, + { json: "berat", js: "berat", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "disproportionably", js: "disproportionably", typ: u(undefined, null) }, + { json: "erythrite", js: "erythrite", typ: u(undefined, null) }, + { json: "graphic", js: "graphic", typ: u(undefined, null) }, + { json: "hepatological", js: "hepatological", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "incommensurably", js: "incommensurably", typ: u(undefined, null) }, + { json: "misaffirm", js: "misaffirm", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "pocketbook", js: "pocketbook", typ: u(undefined, null) }, + { json: "sclerometric", js: "sclerometric", typ: u(undefined, null) }, + { json: "stambouline", js: "stambouline", typ: u(undefined, null) }, + { json: "stickpin", js: "stickpin", typ: u(undefined, null) }, + { json: "tubulure", js: "tubulure", typ: u(undefined, null) }, + { json: "undelated", js: "undelated", typ: u(undefined, null) }, + { json: "unsalt", js: "unsalt", typ: u(undefined, null) }, + { json: "untutelar", js: "untutelar", typ: u(undefined, null) }, + { json: "vagrant", js: "vagrant", typ: u(undefined, null) }, + ], false), + "Interacinar": o([ + { json: "assapan", js: "assapan", typ: 3.14 }, + { json: "benefactorship", js: "benefactorship", typ: true }, + { json: "triseriatim", js: "triseriatim", typ: "" }, + { json: "tubbing", js: "tubbing", typ: i(0) }, + { json: "untrimmed", js: "untrimmed", typ: null }, + ], false), +}; diff --git a/head/typescript/test/inputs/json/priority/combinations1.json/prefer-types-true--df33e18681f9/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations1.json/prefer-types-true--df33e18681f9/TopLevel.ts new file mode 100644 index 0000000..c24d914 --- /dev/null +++ b/head/typescript/test/inputs/json/priority/combinations1.json/prefer-types-true--df33e18681f9/TopLevel.ts @@ -0,0 +1,909 @@ +// 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 type TopLevel = { + centrodesmose: string; + cerograph: CerographElement[]; + chemotherapeutics: ChemotherapeuticElement[]; + cimelia: CimeliaElement[]; + citrated: number; + clinodome: Clinodome[]; + coadjust: CoadjustElement[]; + consilience: Consilience[]; + constructor: Constructor[]; + continuative: Continuative[]; + credulity: CredulityElement[]; + creviced: Creviced[]; + cubiculum: Array<(number | null)[]>; + deruralize: DeruralizeElement[]; + diaereses: DiaereseElement[]; + dissolution: (null[] | null)[]; + downstroke: Downstroke[]; + electrotautomerism: (number | null)[]; + eleutheromania: Eleutheromania[]; + encrust: Encrust; + entomoid: Entomoid[]; + epipaleolithic: Epipaleolithic[]; + expropriable: Expropriable[]; + faggingly: FagginglyElement[]; + fenks: FenkElement[]; + flagmaking: FlagmakingElement[]; + fluorometer: Fluorometer[]; + fulsome: (number | null)[]; + fuzzy: Fuzzy[]; + gardenwards: Gardenward[]; + generalissimo: Generalissimo[]; + habeas: ({ [key: string]: number } | null)[]; + hemicrystalline: Hemicrystalline[]; + hemocoele: HemocoeleElement[]; + hoister: Hoister[]; + hyperpiesis: Hyperpiesi[]; + hyppish: Hyppish[]; + idealizer: Idealizer[]; + incrustator: Incrustator[]; + intentiveness: Intentiveness[]; + interacinar: Interacinar; + intercorrelation: (number[] | null)[]; + jacutinga: Jacutinga[]; +} + +export type CerographElement = CerographClass | null | string; + +export type CerographClass = { + Tolowa: null; + apotropaion: null; + casuary: null; + creaker: null; + disqualification: null; + imperatorious: null; + impermeabilize: null; + metastoma: null; + noctidiurnal: null; + nonreserve: null; + ophthalmotonometry: null; + pailful: null; + pigfish: null; + pongee: null; + prosodical: null; + scrofuloderm: null; + storekeeping: null; + therologist: null; + tradeful: null; + unriveting: null; +} + +export type ChemotherapeuticElement = ChemotherapeuticClass | number; + +export type ChemotherapeuticClass = { + Chirotherium?: number; + Maureen?: null; + angioneurotic?: null; + availment?: null; + bladelet?: null; + catharticalness?: number; + caulis?: null; + chalcus?: null; + disdiapason?: string; + enteradenological?: null; + homocerc?: boolean; + imporosity?: null; + insistently?: null; + intraparietal?: null; + ivied?: null; + nonbookish?: null; + nostochine?: null; + nutcracker?: null; + ofttimes?: null; + phenocryst?: null; + precoincident?: null; + ramiferous?: null; + stagmometer?: null; + tetherball?: null; + unshy?: null; +} + +export type CimeliaElement = number[] | CimeliaClass | null; + +export type CimeliaClass = { + Chirotherium: number; + catharticalness: number; + disdiapason: string; + homocerc: boolean; + nonbookish: null; +} + +export type Clinodome = number | string; + +export type CoadjustElement = CoadjustClass | number; + +export type CoadjustClass = { + Benny?: null; + Chirotherium?: number; + Netherlandish?: null; + Phonelescope?: null; + Sedaceae?: null; + amidosulphonal?: null; + catharticalness?: number; + disdiapason?: string; + ensnare?: null; + homocerc?: boolean; + hybridizer?: null; + leastwise?: null; + lof?: null; + monkhood?: null; + nonbookish?: null; + peonism?: null; + porphyrogeniture?: null; + preindemnify?: null; + rosal?: null; + scalenous?: null; + scopine?: null; + suberinize?: null; + symbiot?: null; + tablefellow?: null; + unchargeable?: null; +} + +export type Consilience = number | { [key: string]: number }; + +export type Constructor = boolean | { [key: string]: number | null }; + +export type Continuative = { [key: string]: number } | string; + +export type CredulityElement = CredulityClass | number | string; + +export type CredulityClass = { + Flavia: null; + Hedychium: null; + Popean: null; + ammonolytic: null; + bushmaster: null; + considering: null; + consuetudinary: null; + embarras: null; + fineness: null; + flaithship: null; + gruffly: null; + leadwort: null; + overseriously: null; + parabola: null; + pectinatodenticulate: null; + pornocrat: null; + quadrisect: null; + seriality: null; + vamphorn: null; + wharp: null; +} + +export type Creviced = boolean | { [key: string]: number } | string; + +export type DeruralizeElement = null[] | boolean | DeruralizeClass; + +export type DeruralizeClass = { + Jehovistic: null; + Paninean: null; + Romney: null; + bockerel: null; + boulder: null; + churrus: null; + counterdigged: null; + dialogite: null; + digenic: null; + dunbird: null; + ergatogyne: null; + fiendful: null; + jackrod: null; + panther: null; + placentigerous: null; + sparm: null; + tocsin: null; + unnicked: null; + unstavable: null; + windfirm: null; +} + +export type DiaereseElement = number[] | boolean | DiaereseClass; + +export type DiaereseClass = { + Amoreuxia: null; + ani: null; + bernicle: null; + blackwasher: null; + blowhard: null; + broma: null; + closecross: null; + congregationalism: null; + grayly: null; + historically: null; + hoast: null; + irretentive: null; + parcener: null; + pedder: null; + pseudoanatomic: null; + rhizocarpian: null; + samel: null; + silker: null; + subdentated: null; + subobscure: null; +} + +export type Downstroke = null[] | boolean | string; + +export type Eleutheromania = number | { [key: string]: number } | string; + +export type Encrust = { + Hibernia: null; + Hibiscus: null; + Lepidosauria: null; + Syllidae: null; + comradely: null; + diacanthous: null; + feminineness: null; + gossamered: null; + lollingly: null; + manager: null; + mechanic: null; + overminuteness: null; + papelonne: null; + plebification: null; + pugmiller: null; + recoveror: null; + spermatoblastic: null; + ungyved: null; + whirlabout: null; + woodenware: null; +} + +export type Entomoid = CimeliaClass | number; + +export type Epipaleolithic = number[] | number; + +export type Expropriable = null[] | CimeliaClass | number; + +export type FagginglyElement = FagginglyClass | number; + +export type FagginglyClass = { + Anglic: null; + Heteromeri: null; + Poinsettia: null; + abranchian: null; + aculeiform: null; + adiaphoristic: null; + adoptionism: null; + antrotomy: null; + coerciveness: null; + decorist: null; + duckhood: null; + hypochnose: null; + lochage: null; + melee: null; + nonconformitant: null; + putatively: null; + semivolatile: null; + soleas: null; + unfastenable: null; + unmillinered: null; +} + +export type FenkElement = FenkClass | string; + +export type FenkClass = { + Dagomba: null; + Guyandot: null; + Reinwardtia: null; + Tritoness: null; + apoise: null; + astronomize: null; + cockhorse: null; + copular: null; + draffy: null; + foreigner: null; + neurogliosis: null; + osmious: null; + palpitate: null; + rebukeable: null; + reservatory: null; + scalt: null; + scripturalize: null; + tintometer: null; + undergrade: null; + undermountain: null; +} + +export type FlagmakingElement = boolean | FlagmakingClass | number; + +export type FlagmakingClass = { + Bunodonta: null; + Hydrocorisae: null; + Notacanthidae: null; + albarco: null; + hornify: null; + hypoglossus: null; + inexpiably: null; + ingratitude: null; + ladyfly: null; + medicament: null; + monogrammatic: null; + nobbut: null; + polyplacophore: null; + proexercise: null; + protoplast: null; + puzzling: null; + splanchnoskeleton: null; + unloveliness: null; + unquarantined: null; + unrenounceable: null; +} + +export type Fluorometer = number | null | string; + +export type Fuzzy = number | { [key: string]: number | null }; + +export type Gardenward = number[] | boolean | string; + +export type Generalissimo = boolean | { [key: string]: number } | null; + +export type Hemicrystalline = CimeliaClass | string; + +export type HemocoeleElement = number[] | HemocoeleClass; + +export type HemocoeleClass = { + Chirotherium?: number; + Walt?: null; + acrogamy?: null; + amelification?: null; + autobiographic?: null; + berat?: null; + catharticalness?: number; + disdiapason?: string; + disproportionably?: null; + erythrite?: null; + graphic?: null; + hepatological?: null; + homocerc?: boolean; + incommensurably?: null; + misaffirm?: null; + nonbookish?: null; + pocketbook?: null; + sclerometric?: null; + stambouline?: null; + stickpin?: null; + tubulure?: null; + undelated?: null; + unsalt?: null; + untutelar?: null; + vagrant?: null; +} + +export type Hoister = CimeliaClass | null | string; + +export type Hyperpiesi = null[] | CimeliaClass | null; + +export type Hyppish = boolean | null | string; + +export type Idealizer = null[] | CimeliaClass | number; + +export type Incrustator = number[] | number | string; + +export type Intentiveness = CimeliaClass | number | string; + +export type Interacinar = { + assapan: number; + benefactorship: boolean; + triseriatim: string; + tubbing: number; + untrimmed: null; +} + +export type Jacutinga = number[] | { [key: string]: number | null }; + +// 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("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) + : 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 i(typ: any) { + return { integer: typ }; +} + +function p(pattern: any) { + return { pattern }; +} + +function s(typ: any, min: any, max: any) { + return { string: typ, min, max }; +} + +function n(typ: any, min: any, max: any) { + return { number: typ, min, max }; +} + +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: "centrodesmose", js: "centrodesmose", typ: "" }, + { json: "cerograph", js: "cerograph", typ: a(u(r("CerographClass"), null, "")) }, + { json: "chemotherapeutics", js: "chemotherapeutics", typ: a(u(r("ChemotherapeuticClass"), i(0))) }, + { json: "cimelia", js: "cimelia", typ: a(u(a(i(0)), r("CimeliaClass"), null)) }, + { json: "citrated", js: "citrated", typ: i(0) }, + { json: "clinodome", js: "clinodome", typ: a(u(3.14, "")) }, + { json: "coadjust", js: "coadjust", typ: a(u(r("CoadjustClass"), 3.14)) }, + { json: "consilience", js: "consilience", typ: a(u(3.14, m(i(0)))) }, + { json: "constructor", js: "constructor", typ: a(u(true, m(u(i(0), null)))) }, + { json: "continuative", js: "continuative", typ: a(u(m(i(0)), "")) }, + { json: "credulity", js: "credulity", typ: a(u(r("CredulityClass"), i(0), "")) }, + { json: "creviced", js: "creviced", typ: a(u(true, m(i(0)), "")) }, + { json: "cubiculum", js: "cubiculum", typ: a(a(u(i(0), null))) }, + { json: "deruralize", js: "deruralize", typ: a(u(a(null), true, r("DeruralizeClass"))) }, + { json: "diaereses", js: "diaereses", typ: a(u(a(i(0)), true, r("DiaereseClass"))) }, + { json: "dissolution", js: "dissolution", typ: a(u(a(null), null)) }, + { json: "downstroke", js: "downstroke", typ: a(u(a(null), true, "")) }, + { json: "electrotautomerism", js: "electrotautomerism", typ: a(u(3.14, null)) }, + { json: "eleutheromania", js: "eleutheromania", typ: a(u(3.14, m(i(0)), "")) }, + { json: "encrust", js: "encrust", typ: r("Encrust") }, + { json: "entomoid", js: "entomoid", typ: a(u(r("CimeliaClass"), i(0))) }, + { json: "epipaleolithic", js: "epipaleolithic", typ: a(u(a(i(0)), 3.14)) }, + { json: "expropriable", js: "expropriable", typ: a(u(a(null), r("CimeliaClass"), 3.14)) }, + { json: "faggingly", js: "faggingly", typ: a(u(r("FagginglyClass"), 3.14)) }, + { json: "fenks", js: "fenks", typ: a(u(r("FenkClass"), "")) }, + { json: "flagmaking", js: "flagmaking", typ: a(u(true, r("FlagmakingClass"), 3.14)) }, + { json: "fluorometer", js: "fluorometer", typ: a(u(i(0), null, "")) }, + { json: "fulsome", js: "fulsome", typ: a(u(i(0), null)) }, + { json: "fuzzy", js: "fuzzy", typ: a(u(i(0), m(u(i(0), null)))) }, + { json: "gardenwards", js: "gardenwards", typ: a(u(a(i(0)), true, "")) }, + { json: "generalissimo", js: "generalissimo", typ: a(u(true, m(i(0)), null)) }, + { json: "habeas", js: "habeas", typ: a(u(m(i(0)), null)) }, + { json: "hemicrystalline", js: "hemicrystalline", typ: a(u(r("CimeliaClass"), "")) }, + { json: "hemocoele", js: "hemocoele", typ: a(u(a(i(0)), r("HemocoeleClass"))) }, + { json: "hoister", js: "hoister", typ: a(u(r("CimeliaClass"), null, "")) }, + { json: "hyperpiesis", js: "hyperpiesis", typ: a(u(a(null), r("CimeliaClass"), null)) }, + { json: "hyppish", js: "hyppish", typ: a(u(true, null, "")) }, + { json: "idealizer", js: "idealizer", typ: a(u(a(null), r("CimeliaClass"), i(0))) }, + { json: "incrustator", js: "incrustator", typ: a(u(a(i(0)), i(0), "")) }, + { json: "intentiveness", js: "intentiveness", typ: a(u(r("CimeliaClass"), 3.14, "")) }, + { json: "interacinar", js: "interacinar", typ: r("Interacinar") }, + { json: "intercorrelation", js: "intercorrelation", typ: a(u(a(i(0)), null)) }, + { json: "jacutinga", js: "jacutinga", typ: a(u(a(i(0)), m(u(i(0), null)))) }, + ], false), + "CerographClass": o([ + { json: "Tolowa", js: "Tolowa", typ: null }, + { json: "apotropaion", js: "apotropaion", typ: null }, + { json: "casuary", js: "casuary", typ: null }, + { json: "creaker", js: "creaker", typ: null }, + { json: "disqualification", js: "disqualification", typ: null }, + { json: "imperatorious", js: "imperatorious", typ: null }, + { json: "impermeabilize", js: "impermeabilize", typ: null }, + { json: "metastoma", js: "metastoma", typ: null }, + { json: "noctidiurnal", js: "noctidiurnal", typ: null }, + { json: "nonreserve", js: "nonreserve", typ: null }, + { json: "ophthalmotonometry", js: "ophthalmotonometry", typ: null }, + { json: "pailful", js: "pailful", typ: null }, + { json: "pigfish", js: "pigfish", typ: null }, + { json: "pongee", js: "pongee", typ: null }, + { json: "prosodical", js: "prosodical", typ: null }, + { json: "scrofuloderm", js: "scrofuloderm", typ: null }, + { json: "storekeeping", js: "storekeeping", typ: null }, + { json: "therologist", js: "therologist", typ: null }, + { json: "tradeful", js: "tradeful", typ: null }, + { json: "unriveting", js: "unriveting", typ: null }, + ], false), + "ChemotherapeuticClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Maureen", js: "Maureen", typ: u(undefined, null) }, + { json: "angioneurotic", js: "angioneurotic", typ: u(undefined, null) }, + { json: "availment", js: "availment", typ: u(undefined, null) }, + { json: "bladelet", js: "bladelet", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "caulis", js: "caulis", typ: u(undefined, null) }, + { json: "chalcus", js: "chalcus", typ: u(undefined, null) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "enteradenological", js: "enteradenological", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "imporosity", js: "imporosity", typ: u(undefined, null) }, + { json: "insistently", js: "insistently", typ: u(undefined, null) }, + { json: "intraparietal", js: "intraparietal", typ: u(undefined, null) }, + { json: "ivied", js: "ivied", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "nostochine", js: "nostochine", typ: u(undefined, null) }, + { json: "nutcracker", js: "nutcracker", typ: u(undefined, null) }, + { json: "ofttimes", js: "ofttimes", typ: u(undefined, null) }, + { json: "phenocryst", js: "phenocryst", typ: u(undefined, null) }, + { json: "precoincident", js: "precoincident", typ: u(undefined, null) }, + { json: "ramiferous", js: "ramiferous", typ: u(undefined, null) }, + { json: "stagmometer", js: "stagmometer", typ: u(undefined, null) }, + { json: "tetherball", js: "tetherball", typ: u(undefined, null) }, + { json: "unshy", js: "unshy", typ: u(undefined, null) }, + ], false), + "CimeliaClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: i(0) }, + { json: "catharticalness", js: "catharticalness", typ: 3.14 }, + { json: "disdiapason", js: "disdiapason", typ: "" }, + { json: "homocerc", js: "homocerc", typ: true }, + { json: "nonbookish", js: "nonbookish", typ: null }, + ], false), + "CoadjustClass": o([ + { json: "Benny", js: "Benny", typ: u(undefined, null) }, + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Netherlandish", js: "Netherlandish", typ: u(undefined, null) }, + { json: "Phonelescope", js: "Phonelescope", typ: u(undefined, null) }, + { json: "Sedaceae", js: "Sedaceae", typ: u(undefined, null) }, + { json: "amidosulphonal", js: "amidosulphonal", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "ensnare", js: "ensnare", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "hybridizer", js: "hybridizer", typ: u(undefined, null) }, + { json: "leastwise", js: "leastwise", typ: u(undefined, null) }, + { json: "lof", js: "lof", typ: u(undefined, null) }, + { json: "monkhood", js: "monkhood", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "peonism", js: "peonism", typ: u(undefined, null) }, + { json: "porphyrogeniture", js: "porphyrogeniture", typ: u(undefined, null) }, + { json: "preindemnify", js: "preindemnify", typ: u(undefined, null) }, + { json: "rosal", js: "rosal", typ: u(undefined, null) }, + { json: "scalenous", js: "scalenous", typ: u(undefined, null) }, + { json: "scopine", js: "scopine", typ: u(undefined, null) }, + { json: "suberinize", js: "suberinize", typ: u(undefined, null) }, + { json: "symbiot", js: "symbiot", typ: u(undefined, null) }, + { json: "tablefellow", js: "tablefellow", typ: u(undefined, null) }, + { json: "unchargeable", js: "unchargeable", typ: u(undefined, null) }, + ], false), + "CredulityClass": o([ + { json: "Flavia", js: "Flavia", typ: null }, + { json: "Hedychium", js: "Hedychium", typ: null }, + { json: "Popean", js: "Popean", typ: null }, + { json: "ammonolytic", js: "ammonolytic", typ: null }, + { json: "bushmaster", js: "bushmaster", typ: null }, + { json: "considering", js: "considering", typ: null }, + { json: "consuetudinary", js: "consuetudinary", typ: null }, + { json: "embarras", js: "embarras", typ: null }, + { json: "fineness", js: "fineness", typ: null }, + { json: "flaithship", js: "flaithship", typ: null }, + { json: "gruffly", js: "gruffly", typ: null }, + { json: "leadwort", js: "leadwort", typ: null }, + { json: "overseriously", js: "overseriously", typ: null }, + { json: "parabola", js: "parabola", typ: null }, + { json: "pectinatodenticulate", js: "pectinatodenticulate", typ: null }, + { json: "pornocrat", js: "pornocrat", typ: null }, + { json: "quadrisect", js: "quadrisect", typ: null }, + { json: "seriality", js: "seriality", typ: null }, + { json: "vamphorn", js: "vamphorn", typ: null }, + { json: "wharp", js: "wharp", typ: null }, + ], false), + "DeruralizeClass": o([ + { json: "Jehovistic", js: "Jehovistic", typ: null }, + { json: "Paninean", js: "Paninean", typ: null }, + { json: "Romney", js: "Romney", typ: null }, + { json: "bockerel", js: "bockerel", typ: null }, + { json: "boulder", js: "boulder", typ: null }, + { json: "churrus", js: "churrus", typ: null }, + { json: "counterdigged", js: "counterdigged", typ: null }, + { json: "dialogite", js: "dialogite", typ: null }, + { json: "digenic", js: "digenic", typ: null }, + { json: "dunbird", js: "dunbird", typ: null }, + { json: "ergatogyne", js: "ergatogyne", typ: null }, + { json: "fiendful", js: "fiendful", typ: null }, + { json: "jackrod", js: "jackrod", typ: null }, + { json: "panther", js: "panther", typ: null }, + { json: "placentigerous", js: "placentigerous", typ: null }, + { json: "sparm", js: "sparm", typ: null }, + { json: "tocsin", js: "tocsin", typ: null }, + { json: "unnicked", js: "unnicked", typ: null }, + { json: "unstavable", js: "unstavable", typ: null }, + { json: "windfirm", js: "windfirm", typ: null }, + ], false), + "DiaereseClass": o([ + { json: "Amoreuxia", js: "Amoreuxia", typ: null }, + { json: "ani", js: "ani", typ: null }, + { json: "bernicle", js: "bernicle", typ: null }, + { json: "blackwasher", js: "blackwasher", typ: null }, + { json: "blowhard", js: "blowhard", typ: null }, + { json: "broma", js: "broma", typ: null }, + { json: "closecross", js: "closecross", typ: null }, + { json: "congregationalism", js: "congregationalism", typ: null }, + { json: "grayly", js: "grayly", typ: null }, + { json: "historically", js: "historically", typ: null }, + { json: "hoast", js: "hoast", typ: null }, + { json: "irretentive", js: "irretentive", typ: null }, + { json: "parcener", js: "parcener", typ: null }, + { json: "pedder", js: "pedder", typ: null }, + { json: "pseudoanatomic", js: "pseudoanatomic", typ: null }, + { json: "rhizocarpian", js: "rhizocarpian", typ: null }, + { json: "samel", js: "samel", typ: null }, + { json: "silker", js: "silker", typ: null }, + { json: "subdentated", js: "subdentated", typ: null }, + { json: "subobscure", js: "subobscure", typ: null }, + ], false), + "Encrust": o([ + { json: "Hibernia", js: "Hibernia", typ: null }, + { json: "Hibiscus", js: "Hibiscus", typ: null }, + { json: "Lepidosauria", js: "Lepidosauria", typ: null }, + { json: "Syllidae", js: "Syllidae", typ: null }, + { json: "comradely", js: "comradely", typ: null }, + { json: "diacanthous", js: "diacanthous", typ: null }, + { json: "feminineness", js: "feminineness", typ: null }, + { json: "gossamered", js: "gossamered", typ: null }, + { json: "lollingly", js: "lollingly", typ: null }, + { json: "manager", js: "manager", typ: null }, + { json: "mechanic", js: "mechanic", typ: null }, + { json: "overminuteness", js: "overminuteness", typ: null }, + { json: "papelonne", js: "papelonne", typ: null }, + { json: "plebification", js: "plebification", typ: null }, + { json: "pugmiller", js: "pugmiller", typ: null }, + { json: "recoveror", js: "recoveror", typ: null }, + { json: "spermatoblastic", js: "spermatoblastic", typ: null }, + { json: "ungyved", js: "ungyved", typ: null }, + { json: "whirlabout", js: "whirlabout", typ: null }, + { json: "woodenware", js: "woodenware", typ: null }, + ], false), + "FagginglyClass": o([ + { json: "Anglic", js: "Anglic", typ: null }, + { json: "Heteromeri", js: "Heteromeri", typ: null }, + { json: "Poinsettia", js: "Poinsettia", typ: null }, + { json: "abranchian", js: "abranchian", typ: null }, + { json: "aculeiform", js: "aculeiform", typ: null }, + { json: "adiaphoristic", js: "adiaphoristic", typ: null }, + { json: "adoptionism", js: "adoptionism", typ: null }, + { json: "antrotomy", js: "antrotomy", typ: null }, + { json: "coerciveness", js: "coerciveness", typ: null }, + { json: "decorist", js: "decorist", typ: null }, + { json: "duckhood", js: "duckhood", typ: null }, + { json: "hypochnose", js: "hypochnose", typ: null }, + { json: "lochage", js: "lochage", typ: null }, + { json: "melee", js: "melee", typ: null }, + { json: "nonconformitant", js: "nonconformitant", typ: null }, + { json: "putatively", js: "putatively", typ: null }, + { json: "semivolatile", js: "semivolatile", typ: null }, + { json: "soleas", js: "soleas", typ: null }, + { json: "unfastenable", js: "unfastenable", typ: null }, + { json: "unmillinered", js: "unmillinered", typ: null }, + ], false), + "FenkClass": o([ + { json: "Dagomba", js: "Dagomba", typ: null }, + { json: "Guyandot", js: "Guyandot", typ: null }, + { json: "Reinwardtia", js: "Reinwardtia", typ: null }, + { json: "Tritoness", js: "Tritoness", typ: null }, + { json: "apoise", js: "apoise", typ: null }, + { json: "astronomize", js: "astronomize", typ: null }, + { json: "cockhorse", js: "cockhorse", typ: null }, + { json: "copular", js: "copular", typ: null }, + { json: "draffy", js: "draffy", typ: null }, + { json: "foreigner", js: "foreigner", typ: null }, + { json: "neurogliosis", js: "neurogliosis", typ: null }, + { json: "osmious", js: "osmious", typ: null }, + { json: "palpitate", js: "palpitate", typ: null }, + { json: "rebukeable", js: "rebukeable", typ: null }, + { json: "reservatory", js: "reservatory", typ: null }, + { json: "scalt", js: "scalt", typ: null }, + { json: "scripturalize", js: "scripturalize", typ: null }, + { json: "tintometer", js: "tintometer", typ: null }, + { json: "undergrade", js: "undergrade", typ: null }, + { json: "undermountain", js: "undermountain", typ: null }, + ], false), + "FlagmakingClass": o([ + { json: "Bunodonta", js: "Bunodonta", typ: null }, + { json: "Hydrocorisae", js: "Hydrocorisae", typ: null }, + { json: "Notacanthidae", js: "Notacanthidae", typ: null }, + { json: "albarco", js: "albarco", typ: null }, + { json: "hornify", js: "hornify", typ: null }, + { json: "hypoglossus", js: "hypoglossus", typ: null }, + { json: "inexpiably", js: "inexpiably", typ: null }, + { json: "ingratitude", js: "ingratitude", typ: null }, + { json: "ladyfly", js: "ladyfly", typ: null }, + { json: "medicament", js: "medicament", typ: null }, + { json: "monogrammatic", js: "monogrammatic", typ: null }, + { json: "nobbut", js: "nobbut", typ: null }, + { json: "polyplacophore", js: "polyplacophore", typ: null }, + { json: "proexercise", js: "proexercise", typ: null }, + { json: "protoplast", js: "protoplast", typ: null }, + { json: "puzzling", js: "puzzling", typ: null }, + { json: "splanchnoskeleton", js: "splanchnoskeleton", typ: null }, + { json: "unloveliness", js: "unloveliness", typ: null }, + { json: "unquarantined", js: "unquarantined", typ: null }, + { json: "unrenounceable", js: "unrenounceable", typ: null }, + ], false), + "HemocoeleClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Walt", js: "Walt", typ: u(undefined, null) }, + { json: "acrogamy", js: "acrogamy", typ: u(undefined, null) }, + { json: "amelification", js: "amelification", typ: u(undefined, null) }, + { json: "autobiographic", js: "autobiographic", typ: u(undefined, null) }, + { json: "berat", js: "berat", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "disproportionably", js: "disproportionably", typ: u(undefined, null) }, + { json: "erythrite", js: "erythrite", typ: u(undefined, null) }, + { json: "graphic", js: "graphic", typ: u(undefined, null) }, + { json: "hepatological", js: "hepatological", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "incommensurably", js: "incommensurably", typ: u(undefined, null) }, + { json: "misaffirm", js: "misaffirm", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "pocketbook", js: "pocketbook", typ: u(undefined, null) }, + { json: "sclerometric", js: "sclerometric", typ: u(undefined, null) }, + { json: "stambouline", js: "stambouline", typ: u(undefined, null) }, + { json: "stickpin", js: "stickpin", typ: u(undefined, null) }, + { json: "tubulure", js: "tubulure", typ: u(undefined, null) }, + { json: "undelated", js: "undelated", typ: u(undefined, null) }, + { json: "unsalt", js: "unsalt", typ: u(undefined, null) }, + { json: "untutelar", js: "untutelar", typ: u(undefined, null) }, + { json: "vagrant", js: "vagrant", typ: u(undefined, null) }, + ], false), + "Interacinar": o([ + { json: "assapan", js: "assapan", typ: 3.14 }, + { json: "benefactorship", js: "benefactorship", typ: true }, + { json: "triseriatim", js: "triseriatim", typ: "" }, + { json: "tubbing", js: "tubbing", typ: i(0) }, + { json: "untrimmed", js: "untrimmed", typ: null }, + ], false), +}; diff --git a/head/typescript/test/inputs/json/priority/combinations2.json/prefer-const-values-true--6b26e4d1265c/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations2.json/prefer-const-values-true--6b26e4d1265c/TopLevel.ts new file mode 100644 index 0000000..fd1800c --- /dev/null +++ b/head/typescript/test/inputs/json/priority/combinations2.json/prefer-const-values-true--6b26e4d1265c/TopLevel.ts @@ -0,0 +1,812 @@ +// 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 { + Abranchiata: Abranchiata[]; + Andriana: (null | string)[]; + Ansarie: AnsarieElement[]; + Chytridiaceae: ChytridiaceaeElement[]; + Discordia: DiscordiaElement[]; + Endomyces: Endomyce[]; + Epinephelidae: Epinephelidae[]; + Eupatorium: Eupatorium[]; + Gryphosaurus: GryphosaurusElement[]; + Koryak: Koryak[]; + Lavinia: LaviniaElement[]; + Oskar: OskarElement[]; + Rebecca: RebeccaElement[]; + Rhomboganoidei: Rhomboganoidei[]; + Rigsmal: boolean; + Ruellia: Ruellia[]; + School: School[]; + Shakespearolater: Shakespearolater[]; + Svan: number[]; + Wayao: { [key: string]: number }; + academe: Academe[]; + acquirable: Acquirable[]; + aerometry: Aerometry[]; + alexin: Alexin[]; + alleviate: AlleviateElement[]; + amaas: Amaa[]; + ambassage: Ambassage[]; + amphithyron: (Amphithyron | null)[]; + ankee: AnkeeElement[]; + annihilator: ({ [key: string]: number | null } | null)[]; + annulose: null; + aphasia: Aphasia[]; + asprawl: Asprawl[]; + attractive: (boolean | null)[]; + barksome: { [key: string]: number }; + bedesman: Bedesman[]; + belard: Belard[]; + bocking: Bocking[]; + brawlingly: Brawlingly[]; + brookie: Brookie[]; + bumboatman: Bumboatman[]; + bystreet: null[]; + calaverite: Calaverite[]; + catallactic: Catallactic[]; + cemental: Cemental[]; +} + +export type Abranchiata = number[] | number | null; + +export type AnsarieElement = number[] | AnsarieClass | null; + +export interface AnsarieClass { + Alida: null; + Ictonyx: null; + Ramist: null; + accension: null; + asteria: null; + beriberic: null; + edgebone: null; + gastrodialysis: null; + geographic: null; + metrocele: null; + misgraft: null; + monteith: null; + notcher: null; + prorestriction: null; + throatlet: null; + unfair: null; + unsynonymous: null; + water: null; + zestfully: null; + zincic: null; +} + +export type ChytridiaceaeElement = boolean | ChytridiaceaeClass | null; + +export interface ChytridiaceaeClass { + Batidaceae: null; + Brechites: null; + Emery: null; + Narraganset: null; + codespairer: null; + enervative: null; + excriminate: null; + goshenite: null; + grime: null; + gritten: null; + hectorly: null; + intermediation: null; + meeterly: null; + onymatic: null; + paddlecock: null; + thana: null; + thornily: null; + uckia: null; + unmettle: null; + vorticellid: null; +} + +export type DiscordiaElement = number[] | DiscordiaClass; + +export interface DiscordiaClass { + Altaic?: number; + Chirotherium?: number; + Patarin?: number; + amoristic?: number; + blennophthalmia?: number; + catharticalness?: number; + disciplinability?: number; + disdiapason?: string; + goofer?: number; + homocerc?: boolean; + laryngograph?: number; + leucitis?: number; + lymphocyst?: number; + microcosmology?: number; + nauseation?: number; + nonbookish?: null; + preliberal?: number; + prettifier?: number; + rangework?: number; + redient?: number; + subfusiform?: number; + suicidical?: number; + swow?: number; + wastrel?: number; + wingle?: number; +} + +export type Endomyce = number | string; + +export type Epinephelidae = boolean | number | string; + +export type Eupatorium = null[] | { [key: string]: number }; + +export type GryphosaurusElement = number[] | GryphosaurusClass | string; + +export interface GryphosaurusClass { + Burushaski: null; + Tahami: null; + amissibility: null; + citronin: null; + coplaintiff: null; + disquisitionary: null; + enoplan: null; + faintness: null; + hebetomy: null; + islandry: null; + lameduck: null; + overbattle: null; + overinterested: null; + phrenologic: null; + rainband: null; + shiningly: null; + stamineous: null; + subscapularis: null; + undaubed: null; + underntime: null; +} + +export type Koryak = { [key: string]: number | null } | string; + +export type LaviniaElement = LaviniaClass | string; + +export interface LaviniaClass { + Chirotherium?: number; + Tacana?: number; + agitable?: number; + asininity?: number; + benefiter?: number; + bronzelike?: number; + catharticalness?: number; + cholesteatomatous?: number; + deprivement?: number; + disdiapason?: string; + flippantness?: number; + fogproof?: number; + homocerc?: boolean; + merrymeeting?: number; + nonbookish?: null; + overcareful?: number; + panaris?: number; + preacceptance?: number; + quinoxaline?: number; + sig?: number; + superconfusion?: number; + tillotter?: number; + tranquillize?: number; + unquestionable?: number; + uproute?: number; +} + +export type OskarElement = number[] | OskarClass; + +export interface OskarClass { + Acrobates: null; + Cayuga: null; + Netherlandish: null; + beanshooter: null; + bearhound: null; + guarneri: null; + hypochondriacism: null; + indication: null; + jaculative: null; + nagana: null; + noctivagous: null; + nonphysiological: null; + praxis: null; + provision: null; + subterhuman: null; + sunlit: null; + syncraniate: null; + teachment: null; + unmutinous: null; + unstoppable: null; +} + +export type RebeccaElement = Rebecca | number | string; + +export interface Rebecca { + Chirotherium: number; + catharticalness: number; + disdiapason: string; + homocerc: boolean; + nonbookish: null; +} + +export type Rhomboganoidei = number[] | Rebecca | string; + +export type Ruellia = boolean | Rebecca | string; + +export type School = number | { [key: string]: number } | null; + +export type Shakespearolater = number[] | number | string; + +export type Academe = number[] | number | { [key: string]: number }; + +export type Acquirable = (number | null)[] | { [key: string]: number }; + +export type Aerometry = boolean | number; + +export type Alexin = number[] | boolean; + +export type AlleviateElement = (number | null)[] | AlleviateClass; + +export interface AlleviateClass { + Hulsean: null; + apriori: null; + beggarer: null; + brokenheartedly: null; + debilitation: null; + frike: null; + gastrolith: null; + orthocentric: null; + petaly: null; + probudgeting: null; + reacquire: null; + scow: null; + shutoff: null; + subcontiguous: null; + suffumigate: null; + transformable: null; + uncoroneted: null; + unparking: null; + unvarnishedness: null; + wherewithal: null; +} + +export type Amaa = boolean | Rebecca | number; + +export type Ambassage = null[] | string; + +export interface Amphithyron { + Chirotherium?: number; + Juniperus?: number; + Nazirite?: number; + Those?: number; + akroasis?: number; + antiphonical?: number; + basebred?: number; + catharticalness?: number; + conductometric?: number; + disdiapason?: string; + ensilation?: number; + eyebolt?: number; + fistulated?: number; + heteropod?: number; + homocerc?: boolean; + labyrinthically?: number; + martyrization?: number; + mispolicy?: number; + multipara?: number; + nonbookish?: null; + possessorial?: number; + shamed?: number; + shelfworn?: number; + stagnum?: number; + undecimal?: number; +} + +export type AnkeeElement = number[] | AnkeeClass | number; + +export interface AnkeeClass { + Anomoean: null; + Naja: null; + barleyhood: null; + befriender: null; + brutishness: null; + cephalalgy: null; + cirurgian: null; + conventionally: null; + jackshay: null; + milammeter: null; + ombrological: null; + phonasthenia: null; + retrievableness: null; + snakily: null; + swot: null; + tartlet: null; + thiofuran: null; + tracheophone: null; + tuglike: null; + unscratchingly: null; +} + +export type Aphasia = number[] | number; + +export type Asprawl = number | string; + +export type Bedesman = boolean | number | string; + +export type Belard = number[] | Rebecca | number; + +export type Bocking = number[] | boolean | { [key: string]: number }; + +export type Brawlingly = null[] | { [key: string]: number | null }; + +export type Brookie = number[] | Rebecca; + +export type Bumboatman = null[] | null | string; + +export type Calaverite = number[] | string; + +export type Catallactic = null[] | boolean | { [key: string]: number }; + +export type Cemental = number[] | number | { [key: string]: number }; + +// 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("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) + : 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 i(typ: any) { + return { integer: typ }; +} + +function p(pattern: any) { + return { pattern }; +} + +function s(typ: any, min: any, max: any) { + return { string: typ, min, max }; +} + +function n(typ: any, min: any, max: any) { + return { number: typ, min, max }; +} + +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: "Abranchiata", js: "Abranchiata", typ: a(u(a(i(0)), i(0), null)) }, + { json: "Andriana", js: "Andriana", typ: a(u(null, "")) }, + { json: "Ansarie", js: "Ansarie", typ: a(u(a(i(0)), r("AnsarieClass"), null)) }, + { json: "Chytridiaceae", js: "Chytridiaceae", typ: a(u(true, r("ChytridiaceaeClass"), null)) }, + { json: "Discordia", js: "Discordia", typ: a(u(a(i(0)), r("DiscordiaClass"))) }, + { json: "Endomyces", js: "Endomyces", typ: a(u(i(0), "")) }, + { json: "Epinephelidae", js: "Epinephelidae", typ: a(u(true, i(0), "")) }, + { json: "Eupatorium", js: "Eupatorium", typ: a(u(a(null), m(i(0)))) }, + { json: "Gryphosaurus", js: "Gryphosaurus", typ: a(u(a(i(0)), r("GryphosaurusClass"), "")) }, + { json: "Koryak", js: "Koryak", typ: a(u(m(u(i(0), null)), "")) }, + { json: "Lavinia", js: "Lavinia", typ: a(u(r("LaviniaClass"), "")) }, + { json: "Oskar", js: "Oskar", typ: a(u(a(i(0)), r("OskarClass"))) }, + { json: "Rebecca", js: "Rebecca", typ: a(u(r("Rebecca"), i(0), "")) }, + { json: "Rhomboganoidei", js: "Rhomboganoidei", typ: a(u(a(i(0)), r("Rebecca"), "")) }, + { json: "Rigsmal", js: "Rigsmal", typ: true }, + { json: "Ruellia", js: "Ruellia", typ: a(u(true, r("Rebecca"), "")) }, + { json: "School", js: "School", typ: a(u(i(0), m(i(0)), null)) }, + { json: "Shakespearolater", js: "Shakespearolater", typ: a(u(a(i(0)), 3.14, "")) }, + { json: "Svan", js: "Svan", typ: a(3.14) }, + { json: "Wayao", js: "Wayao", typ: m(3.14) }, + { json: "academe", js: "academe", typ: a(u(a(i(0)), i(0), m(i(0)))) }, + { json: "acquirable", js: "acquirable", typ: a(u(a(u(i(0), null)), m(i(0)))) }, + { json: "aerometry", js: "aerometry", typ: a(u(true, 3.14)) }, + { json: "alexin", js: "alexin", typ: a(u(a(i(0)), true)) }, + { json: "alleviate", js: "alleviate", typ: a(u(a(u(i(0), null)), r("AlleviateClass"))) }, + { json: "amaas", js: "amaas", typ: a(u(true, r("Rebecca"), i(0))) }, + { json: "ambassage", js: "ambassage", typ: a(u(a(null), "")) }, + { json: "amphithyron", js: "amphithyron", typ: a(u(r("Amphithyron"), null)) }, + { json: "ankee", js: "ankee", typ: a(u(a(i(0)), r("AnkeeClass"), i(0))) }, + { json: "annihilator", js: "annihilator", typ: a(u(m(u(i(0), null)), null)) }, + { json: "annulose", js: "annulose", typ: null }, + { json: "aphasia", js: "aphasia", typ: a(u(a(i(0)), i(0))) }, + { json: "asprawl", js: "asprawl", typ: a(u(3.14, "")) }, + { json: "attractive", js: "attractive", typ: a(u(true, null)) }, + { json: "barksome", js: "barksome", typ: m(i(0)) }, + { json: "bedesman", js: "bedesman", typ: a(u(true, 3.14, "")) }, + { json: "belard", js: "belard", typ: a(u(a(i(0)), r("Rebecca"), 3.14)) }, + { json: "bocking", js: "bocking", typ: a(u(a(i(0)), true, m(i(0)))) }, + { json: "brawlingly", js: "brawlingly", typ: a(u(a(null), m(u(i(0), null)))) }, + { json: "brookie", js: "brookie", typ: a(u(a(i(0)), r("Rebecca"))) }, + { json: "bumboatman", js: "bumboatman", typ: a(u(a(null), null, "")) }, + { json: "bystreet", js: "bystreet", typ: a(null) }, + { json: "calaverite", js: "calaverite", typ: a(u(a(i(0)), "")) }, + { json: "catallactic", js: "catallactic", typ: a(u(a(null), true, m(i(0)))) }, + { json: "cemental", js: "cemental", typ: a(u(a(i(0)), 3.14, m(i(0)))) }, + ], false), + "AnsarieClass": o([ + { json: "Alida", js: "Alida", typ: null }, + { json: "Ictonyx", js: "Ictonyx", typ: null }, + { json: "Ramist", js: "Ramist", typ: null }, + { json: "accension", js: "accension", typ: null }, + { json: "asteria", js: "asteria", typ: null }, + { json: "beriberic", js: "beriberic", typ: null }, + { json: "edgebone", js: "edgebone", typ: null }, + { json: "gastrodialysis", js: "gastrodialysis", typ: null }, + { json: "geographic", js: "geographic", typ: null }, + { json: "metrocele", js: "metrocele", typ: null }, + { json: "misgraft", js: "misgraft", typ: null }, + { json: "monteith", js: "monteith", typ: null }, + { json: "notcher", js: "notcher", typ: null }, + { json: "prorestriction", js: "prorestriction", typ: null }, + { json: "throatlet", js: "throatlet", typ: null }, + { json: "unfair", js: "unfair", typ: null }, + { json: "unsynonymous", js: "unsynonymous", typ: null }, + { json: "water", js: "water", typ: null }, + { json: "zestfully", js: "zestfully", typ: null }, + { json: "zincic", js: "zincic", typ: null }, + ], false), + "ChytridiaceaeClass": o([ + { json: "Batidaceae", js: "Batidaceae", typ: null }, + { json: "Brechites", js: "Brechites", typ: null }, + { json: "Emery", js: "Emery", typ: null }, + { json: "Narraganset", js: "Narraganset", typ: null }, + { json: "codespairer", js: "codespairer", typ: null }, + { json: "enervative", js: "enervative", typ: null }, + { json: "excriminate", js: "excriminate", typ: null }, + { json: "goshenite", js: "goshenite", typ: null }, + { json: "grime", js: "grime", typ: null }, + { json: "gritten", js: "gritten", typ: null }, + { json: "hectorly", js: "hectorly", typ: null }, + { json: "intermediation", js: "intermediation", typ: null }, + { json: "meeterly", js: "meeterly", typ: null }, + { json: "onymatic", js: "onymatic", typ: null }, + { json: "paddlecock", js: "paddlecock", typ: null }, + { json: "thana", js: "thana", typ: null }, + { json: "thornily", js: "thornily", typ: null }, + { json: "uckia", js: "uckia", typ: null }, + { json: "unmettle", js: "unmettle", typ: null }, + { json: "vorticellid", js: "vorticellid", typ: null }, + ], false), + "DiscordiaClass": o([ + { json: "Altaic", js: "Altaic", typ: u(undefined, i(0)) }, + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Patarin", js: "Patarin", typ: u(undefined, i(0)) }, + { json: "amoristic", js: "amoristic", typ: u(undefined, i(0)) }, + { json: "blennophthalmia", js: "blennophthalmia", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "disciplinability", js: "disciplinability", typ: u(undefined, i(0)) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "goofer", js: "goofer", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "laryngograph", js: "laryngograph", typ: u(undefined, i(0)) }, + { json: "leucitis", js: "leucitis", typ: u(undefined, i(0)) }, + { json: "lymphocyst", js: "lymphocyst", typ: u(undefined, i(0)) }, + { json: "microcosmology", js: "microcosmology", typ: u(undefined, i(0)) }, + { json: "nauseation", js: "nauseation", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "preliberal", js: "preliberal", typ: u(undefined, i(0)) }, + { json: "prettifier", js: "prettifier", typ: u(undefined, i(0)) }, + { json: "rangework", js: "rangework", typ: u(undefined, i(0)) }, + { json: "redient", js: "redient", typ: u(undefined, i(0)) }, + { json: "subfusiform", js: "subfusiform", typ: u(undefined, i(0)) }, + { json: "suicidical", js: "suicidical", typ: u(undefined, i(0)) }, + { json: "swow", js: "swow", typ: u(undefined, i(0)) }, + { json: "wastrel", js: "wastrel", typ: u(undefined, i(0)) }, + { json: "wingle", js: "wingle", typ: u(undefined, i(0)) }, + ], false), + "GryphosaurusClass": o([ + { json: "Burushaski", js: "Burushaski", typ: null }, + { json: "Tahami", js: "Tahami", typ: null }, + { json: "amissibility", js: "amissibility", typ: null }, + { json: "citronin", js: "citronin", typ: null }, + { json: "coplaintiff", js: "coplaintiff", typ: null }, + { json: "disquisitionary", js: "disquisitionary", typ: null }, + { json: "enoplan", js: "enoplan", typ: null }, + { json: "faintness", js: "faintness", typ: null }, + { json: "hebetomy", js: "hebetomy", typ: null }, + { json: "islandry", js: "islandry", typ: null }, + { json: "lameduck", js: "lameduck", typ: null }, + { json: "overbattle", js: "overbattle", typ: null }, + { json: "overinterested", js: "overinterested", typ: null }, + { json: "phrenologic", js: "phrenologic", typ: null }, + { json: "rainband", js: "rainband", typ: null }, + { json: "shiningly", js: "shiningly", typ: null }, + { json: "stamineous", js: "stamineous", typ: null }, + { json: "subscapularis", js: "subscapularis", typ: null }, + { json: "undaubed", js: "undaubed", typ: null }, + { json: "underntime", js: "underntime", typ: null }, + ], false), + "LaviniaClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Tacana", js: "Tacana", typ: u(undefined, i(0)) }, + { json: "agitable", js: "agitable", typ: u(undefined, i(0)) }, + { json: "asininity", js: "asininity", typ: u(undefined, i(0)) }, + { json: "benefiter", js: "benefiter", typ: u(undefined, i(0)) }, + { json: "bronzelike", js: "bronzelike", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "cholesteatomatous", js: "cholesteatomatous", typ: u(undefined, i(0)) }, + { json: "deprivement", js: "deprivement", typ: u(undefined, i(0)) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "flippantness", js: "flippantness", typ: u(undefined, i(0)) }, + { json: "fogproof", js: "fogproof", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "merrymeeting", js: "merrymeeting", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "overcareful", js: "overcareful", typ: u(undefined, i(0)) }, + { json: "panaris", js: "panaris", typ: u(undefined, i(0)) }, + { json: "preacceptance", js: "preacceptance", typ: u(undefined, i(0)) }, + { json: "quinoxaline", js: "quinoxaline", typ: u(undefined, i(0)) }, + { json: "sig", js: "sig", typ: u(undefined, i(0)) }, + { json: "superconfusion", js: "superconfusion", typ: u(undefined, i(0)) }, + { json: "tillotter", js: "tillotter", typ: u(undefined, i(0)) }, + { json: "tranquillize", js: "tranquillize", typ: u(undefined, i(0)) }, + { json: "unquestionable", js: "unquestionable", typ: u(undefined, i(0)) }, + { json: "uproute", js: "uproute", typ: u(undefined, i(0)) }, + ], false), + "OskarClass": o([ + { json: "Acrobates", js: "Acrobates", typ: null }, + { json: "Cayuga", js: "Cayuga", typ: null }, + { json: "Netherlandish", js: "Netherlandish", typ: null }, + { json: "beanshooter", js: "beanshooter", typ: null }, + { json: "bearhound", js: "bearhound", typ: null }, + { json: "guarneri", js: "guarneri", typ: null }, + { json: "hypochondriacism", js: "hypochondriacism", typ: null }, + { json: "indication", js: "indication", typ: null }, + { json: "jaculative", js: "jaculative", typ: null }, + { json: "nagana", js: "nagana", typ: null }, + { json: "noctivagous", js: "noctivagous", typ: null }, + { json: "nonphysiological", js: "nonphysiological", typ: null }, + { json: "praxis", js: "praxis", typ: null }, + { json: "provision", js: "provision", typ: null }, + { json: "subterhuman", js: "subterhuman", typ: null }, + { json: "sunlit", js: "sunlit", typ: null }, + { json: "syncraniate", js: "syncraniate", typ: null }, + { json: "teachment", js: "teachment", typ: null }, + { json: "unmutinous", js: "unmutinous", typ: null }, + { json: "unstoppable", js: "unstoppable", typ: null }, + ], false), + "Rebecca": o([ + { json: "Chirotherium", js: "Chirotherium", typ: i(0) }, + { json: "catharticalness", js: "catharticalness", typ: 3.14 }, + { json: "disdiapason", js: "disdiapason", typ: "" }, + { json: "homocerc", js: "homocerc", typ: true }, + { json: "nonbookish", js: "nonbookish", typ: null }, + ], false), + "AlleviateClass": o([ + { json: "Hulsean", js: "Hulsean", typ: null }, + { json: "apriori", js: "apriori", typ: null }, + { json: "beggarer", js: "beggarer", typ: null }, + { json: "brokenheartedly", js: "brokenheartedly", typ: null }, + { json: "debilitation", js: "debilitation", typ: null }, + { json: "frike", js: "frike", typ: null }, + { json: "gastrolith", js: "gastrolith", typ: null }, + { json: "orthocentric", js: "orthocentric", typ: null }, + { json: "petaly", js: "petaly", typ: null }, + { json: "probudgeting", js: "probudgeting", typ: null }, + { json: "reacquire", js: "reacquire", typ: null }, + { json: "scow", js: "scow", typ: null }, + { json: "shutoff", js: "shutoff", typ: null }, + { json: "subcontiguous", js: "subcontiguous", typ: null }, + { json: "suffumigate", js: "suffumigate", typ: null }, + { json: "transformable", js: "transformable", typ: null }, + { json: "uncoroneted", js: "uncoroneted", typ: null }, + { json: "unparking", js: "unparking", typ: null }, + { json: "unvarnishedness", js: "unvarnishedness", typ: null }, + { json: "wherewithal", js: "wherewithal", typ: null }, + ], false), + "Amphithyron": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Juniperus", js: "Juniperus", typ: u(undefined, i(0)) }, + { json: "Nazirite", js: "Nazirite", typ: u(undefined, i(0)) }, + { json: "Those", js: "Those", typ: u(undefined, i(0)) }, + { json: "akroasis", js: "akroasis", typ: u(undefined, i(0)) }, + { json: "antiphonical", js: "antiphonical", typ: u(undefined, i(0)) }, + { json: "basebred", js: "basebred", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "conductometric", js: "conductometric", typ: u(undefined, i(0)) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "ensilation", js: "ensilation", typ: u(undefined, i(0)) }, + { json: "eyebolt", js: "eyebolt", typ: u(undefined, i(0)) }, + { json: "fistulated", js: "fistulated", typ: u(undefined, i(0)) }, + { json: "heteropod", js: "heteropod", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "labyrinthically", js: "labyrinthically", typ: u(undefined, i(0)) }, + { json: "martyrization", js: "martyrization", typ: u(undefined, i(0)) }, + { json: "mispolicy", js: "mispolicy", typ: u(undefined, i(0)) }, + { json: "multipara", js: "multipara", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "possessorial", js: "possessorial", typ: u(undefined, i(0)) }, + { json: "shamed", js: "shamed", typ: u(undefined, i(0)) }, + { json: "shelfworn", js: "shelfworn", typ: u(undefined, i(0)) }, + { json: "stagnum", js: "stagnum", typ: u(undefined, i(0)) }, + { json: "undecimal", js: "undecimal", typ: u(undefined, i(0)) }, + ], false), + "AnkeeClass": o([ + { json: "Anomoean", js: "Anomoean", typ: null }, + { json: "Naja", js: "Naja", typ: null }, + { json: "barleyhood", js: "barleyhood", typ: null }, + { json: "befriender", js: "befriender", typ: null }, + { json: "brutishness", js: "brutishness", typ: null }, + { json: "cephalalgy", js: "cephalalgy", typ: null }, + { json: "cirurgian", js: "cirurgian", typ: null }, + { json: "conventionally", js: "conventionally", typ: null }, + { json: "jackshay", js: "jackshay", typ: null }, + { json: "milammeter", js: "milammeter", typ: null }, + { json: "ombrological", js: "ombrological", typ: null }, + { json: "phonasthenia", js: "phonasthenia", typ: null }, + { json: "retrievableness", js: "retrievableness", typ: null }, + { json: "snakily", js: "snakily", typ: null }, + { json: "swot", js: "swot", typ: null }, + { json: "tartlet", js: "tartlet", typ: null }, + { json: "thiofuran", js: "thiofuran", typ: null }, + { json: "tracheophone", js: "tracheophone", typ: null }, + { json: "tuglike", js: "tuglike", typ: null }, + { json: "unscratchingly", js: "unscratchingly", typ: null }, + ], false), +}; diff --git a/head/typescript/test/inputs/json/priority/combinations2.json/prefer-types-true--df33e18681f9/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations2.json/prefer-types-true--df33e18681f9/TopLevel.ts new file mode 100644 index 0000000..0a8840f --- /dev/null +++ b/head/typescript/test/inputs/json/priority/combinations2.json/prefer-types-true--df33e18681f9/TopLevel.ts @@ -0,0 +1,812 @@ +// 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 type TopLevel = { + Abranchiata: Abranchiata[]; + Andriana: (null | string)[]; + Ansarie: AnsarieElement[]; + Chytridiaceae: ChytridiaceaeElement[]; + Discordia: DiscordiaElement[]; + Endomyces: Endomyce[]; + Epinephelidae: Epinephelidae[]; + Eupatorium: Eupatorium[]; + Gryphosaurus: GryphosaurusElement[]; + Koryak: Koryak[]; + Lavinia: LaviniaElement[]; + Oskar: OskarElement[]; + Rebecca: RebeccaElement[]; + Rhomboganoidei: Rhomboganoidei[]; + Rigsmal: boolean; + Ruellia: Ruellia[]; + School: School[]; + Shakespearolater: Shakespearolater[]; + Svan: number[]; + Wayao: { [key: string]: number }; + academe: Academe[]; + acquirable: Acquirable[]; + aerometry: Aerometry[]; + alexin: Alexin[]; + alleviate: AlleviateElement[]; + amaas: Amaa[]; + ambassage: Ambassage[]; + amphithyron: (Amphithyron | null)[]; + ankee: AnkeeElement[]; + annihilator: ({ [key: string]: number | null } | null)[]; + annulose: null; + aphasia: Aphasia[]; + asprawl: Asprawl[]; + attractive: (boolean | null)[]; + barksome: { [key: string]: number }; + bedesman: Bedesman[]; + belard: Belard[]; + bocking: Bocking[]; + brawlingly: Brawlingly[]; + brookie: Brookie[]; + bumboatman: Bumboatman[]; + bystreet: null[]; + calaverite: Calaverite[]; + catallactic: Catallactic[]; + cemental: Cemental[]; +} + +export type Abranchiata = number[] | number | null; + +export type AnsarieElement = number[] | AnsarieClass | null; + +export type AnsarieClass = { + Alida: null; + Ictonyx: null; + Ramist: null; + accension: null; + asteria: null; + beriberic: null; + edgebone: null; + gastrodialysis: null; + geographic: null; + metrocele: null; + misgraft: null; + monteith: null; + notcher: null; + prorestriction: null; + throatlet: null; + unfair: null; + unsynonymous: null; + water: null; + zestfully: null; + zincic: null; +} + +export type ChytridiaceaeElement = boolean | ChytridiaceaeClass | null; + +export type ChytridiaceaeClass = { + Batidaceae: null; + Brechites: null; + Emery: null; + Narraganset: null; + codespairer: null; + enervative: null; + excriminate: null; + goshenite: null; + grime: null; + gritten: null; + hectorly: null; + intermediation: null; + meeterly: null; + onymatic: null; + paddlecock: null; + thana: null; + thornily: null; + uckia: null; + unmettle: null; + vorticellid: null; +} + +export type DiscordiaElement = number[] | DiscordiaClass; + +export type DiscordiaClass = { + Altaic?: number; + Chirotherium?: number; + Patarin?: number; + amoristic?: number; + blennophthalmia?: number; + catharticalness?: number; + disciplinability?: number; + disdiapason?: string; + goofer?: number; + homocerc?: boolean; + laryngograph?: number; + leucitis?: number; + lymphocyst?: number; + microcosmology?: number; + nauseation?: number; + nonbookish?: null; + preliberal?: number; + prettifier?: number; + rangework?: number; + redient?: number; + subfusiform?: number; + suicidical?: number; + swow?: number; + wastrel?: number; + wingle?: number; +} + +export type Endomyce = number | string; + +export type Epinephelidae = boolean | number | string; + +export type Eupatorium = null[] | { [key: string]: number }; + +export type GryphosaurusElement = number[] | GryphosaurusClass | string; + +export type GryphosaurusClass = { + Burushaski: null; + Tahami: null; + amissibility: null; + citronin: null; + coplaintiff: null; + disquisitionary: null; + enoplan: null; + faintness: null; + hebetomy: null; + islandry: null; + lameduck: null; + overbattle: null; + overinterested: null; + phrenologic: null; + rainband: null; + shiningly: null; + stamineous: null; + subscapularis: null; + undaubed: null; + underntime: null; +} + +export type Koryak = { [key: string]: number | null } | string; + +export type LaviniaElement = LaviniaClass | string; + +export type LaviniaClass = { + Chirotherium?: number; + Tacana?: number; + agitable?: number; + asininity?: number; + benefiter?: number; + bronzelike?: number; + catharticalness?: number; + cholesteatomatous?: number; + deprivement?: number; + disdiapason?: string; + flippantness?: number; + fogproof?: number; + homocerc?: boolean; + merrymeeting?: number; + nonbookish?: null; + overcareful?: number; + panaris?: number; + preacceptance?: number; + quinoxaline?: number; + sig?: number; + superconfusion?: number; + tillotter?: number; + tranquillize?: number; + unquestionable?: number; + uproute?: number; +} + +export type OskarElement = number[] | OskarClass; + +export type OskarClass = { + Acrobates: null; + Cayuga: null; + Netherlandish: null; + beanshooter: null; + bearhound: null; + guarneri: null; + hypochondriacism: null; + indication: null; + jaculative: null; + nagana: null; + noctivagous: null; + nonphysiological: null; + praxis: null; + provision: null; + subterhuman: null; + sunlit: null; + syncraniate: null; + teachment: null; + unmutinous: null; + unstoppable: null; +} + +export type RebeccaElement = Rebecca | number | string; + +export type Rebecca = { + Chirotherium: number; + catharticalness: number; + disdiapason: string; + homocerc: boolean; + nonbookish: null; +} + +export type Rhomboganoidei = number[] | Rebecca | string; + +export type Ruellia = boolean | Rebecca | string; + +export type School = number | { [key: string]: number } | null; + +export type Shakespearolater = number[] | number | string; + +export type Academe = number[] | number | { [key: string]: number }; + +export type Acquirable = (number | null)[] | { [key: string]: number }; + +export type Aerometry = boolean | number; + +export type Alexin = number[] | boolean; + +export type AlleviateElement = (number | null)[] | AlleviateClass; + +export type AlleviateClass = { + Hulsean: null; + apriori: null; + beggarer: null; + brokenheartedly: null; + debilitation: null; + frike: null; + gastrolith: null; + orthocentric: null; + petaly: null; + probudgeting: null; + reacquire: null; + scow: null; + shutoff: null; + subcontiguous: null; + suffumigate: null; + transformable: null; + uncoroneted: null; + unparking: null; + unvarnishedness: null; + wherewithal: null; +} + +export type Amaa = boolean | Rebecca | number; + +export type Ambassage = null[] | string; + +export type Amphithyron = { + Chirotherium?: number; + Juniperus?: number; + Nazirite?: number; + Those?: number; + akroasis?: number; + antiphonical?: number; + basebred?: number; + catharticalness?: number; + conductometric?: number; + disdiapason?: string; + ensilation?: number; + eyebolt?: number; + fistulated?: number; + heteropod?: number; + homocerc?: boolean; + labyrinthically?: number; + martyrization?: number; + mispolicy?: number; + multipara?: number; + nonbookish?: null; + possessorial?: number; + shamed?: number; + shelfworn?: number; + stagnum?: number; + undecimal?: number; +} + +export type AnkeeElement = number[] | AnkeeClass | number; + +export type AnkeeClass = { + Anomoean: null; + Naja: null; + barleyhood: null; + befriender: null; + brutishness: null; + cephalalgy: null; + cirurgian: null; + conventionally: null; + jackshay: null; + milammeter: null; + ombrological: null; + phonasthenia: null; + retrievableness: null; + snakily: null; + swot: null; + tartlet: null; + thiofuran: null; + tracheophone: null; + tuglike: null; + unscratchingly: null; +} + +export type Aphasia = number[] | number; + +export type Asprawl = number | string; + +export type Bedesman = boolean | number | string; + +export type Belard = number[] | Rebecca | number; + +export type Bocking = number[] | boolean | { [key: string]: number }; + +export type Brawlingly = null[] | { [key: string]: number | null }; + +export type Brookie = number[] | Rebecca; + +export type Bumboatman = null[] | null | string; + +export type Calaverite = number[] | string; + +export type Catallactic = null[] | boolean | { [key: string]: number }; + +export type Cemental = number[] | number | { [key: string]: number }; + +// 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("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) + : 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 i(typ: any) { + return { integer: typ }; +} + +function p(pattern: any) { + return { pattern }; +} + +function s(typ: any, min: any, max: any) { + return { string: typ, min, max }; +} + +function n(typ: any, min: any, max: any) { + return { number: typ, min, max }; +} + +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: "Abranchiata", js: "Abranchiata", typ: a(u(a(i(0)), i(0), null)) }, + { json: "Andriana", js: "Andriana", typ: a(u(null, "")) }, + { json: "Ansarie", js: "Ansarie", typ: a(u(a(i(0)), r("AnsarieClass"), null)) }, + { json: "Chytridiaceae", js: "Chytridiaceae", typ: a(u(true, r("ChytridiaceaeClass"), null)) }, + { json: "Discordia", js: "Discordia", typ: a(u(a(i(0)), r("DiscordiaClass"))) }, + { json: "Endomyces", js: "Endomyces", typ: a(u(i(0), "")) }, + { json: "Epinephelidae", js: "Epinephelidae", typ: a(u(true, i(0), "")) }, + { json: "Eupatorium", js: "Eupatorium", typ: a(u(a(null), m(i(0)))) }, + { json: "Gryphosaurus", js: "Gryphosaurus", typ: a(u(a(i(0)), r("GryphosaurusClass"), "")) }, + { json: "Koryak", js: "Koryak", typ: a(u(m(u(i(0), null)), "")) }, + { json: "Lavinia", js: "Lavinia", typ: a(u(r("LaviniaClass"), "")) }, + { json: "Oskar", js: "Oskar", typ: a(u(a(i(0)), r("OskarClass"))) }, + { json: "Rebecca", js: "Rebecca", typ: a(u(r("Rebecca"), i(0), "")) }, + { json: "Rhomboganoidei", js: "Rhomboganoidei", typ: a(u(a(i(0)), r("Rebecca"), "")) }, + { json: "Rigsmal", js: "Rigsmal", typ: true }, + { json: "Ruellia", js: "Ruellia", typ: a(u(true, r("Rebecca"), "")) }, + { json: "School", js: "School", typ: a(u(i(0), m(i(0)), null)) }, + { json: "Shakespearolater", js: "Shakespearolater", typ: a(u(a(i(0)), 3.14, "")) }, + { json: "Svan", js: "Svan", typ: a(3.14) }, + { json: "Wayao", js: "Wayao", typ: m(3.14) }, + { json: "academe", js: "academe", typ: a(u(a(i(0)), i(0), m(i(0)))) }, + { json: "acquirable", js: "acquirable", typ: a(u(a(u(i(0), null)), m(i(0)))) }, + { json: "aerometry", js: "aerometry", typ: a(u(true, 3.14)) }, + { json: "alexin", js: "alexin", typ: a(u(a(i(0)), true)) }, + { json: "alleviate", js: "alleviate", typ: a(u(a(u(i(0), null)), r("AlleviateClass"))) }, + { json: "amaas", js: "amaas", typ: a(u(true, r("Rebecca"), i(0))) }, + { json: "ambassage", js: "ambassage", typ: a(u(a(null), "")) }, + { json: "amphithyron", js: "amphithyron", typ: a(u(r("Amphithyron"), null)) }, + { json: "ankee", js: "ankee", typ: a(u(a(i(0)), r("AnkeeClass"), i(0))) }, + { json: "annihilator", js: "annihilator", typ: a(u(m(u(i(0), null)), null)) }, + { json: "annulose", js: "annulose", typ: null }, + { json: "aphasia", js: "aphasia", typ: a(u(a(i(0)), i(0))) }, + { json: "asprawl", js: "asprawl", typ: a(u(3.14, "")) }, + { json: "attractive", js: "attractive", typ: a(u(true, null)) }, + { json: "barksome", js: "barksome", typ: m(i(0)) }, + { json: "bedesman", js: "bedesman", typ: a(u(true, 3.14, "")) }, + { json: "belard", js: "belard", typ: a(u(a(i(0)), r("Rebecca"), 3.14)) }, + { json: "bocking", js: "bocking", typ: a(u(a(i(0)), true, m(i(0)))) }, + { json: "brawlingly", js: "brawlingly", typ: a(u(a(null), m(u(i(0), null)))) }, + { json: "brookie", js: "brookie", typ: a(u(a(i(0)), r("Rebecca"))) }, + { json: "bumboatman", js: "bumboatman", typ: a(u(a(null), null, "")) }, + { json: "bystreet", js: "bystreet", typ: a(null) }, + { json: "calaverite", js: "calaverite", typ: a(u(a(i(0)), "")) }, + { json: "catallactic", js: "catallactic", typ: a(u(a(null), true, m(i(0)))) }, + { json: "cemental", js: "cemental", typ: a(u(a(i(0)), 3.14, m(i(0)))) }, + ], false), + "AnsarieClass": o([ + { json: "Alida", js: "Alida", typ: null }, + { json: "Ictonyx", js: "Ictonyx", typ: null }, + { json: "Ramist", js: "Ramist", typ: null }, + { json: "accension", js: "accension", typ: null }, + { json: "asteria", js: "asteria", typ: null }, + { json: "beriberic", js: "beriberic", typ: null }, + { json: "edgebone", js: "edgebone", typ: null }, + { json: "gastrodialysis", js: "gastrodialysis", typ: null }, + { json: "geographic", js: "geographic", typ: null }, + { json: "metrocele", js: "metrocele", typ: null }, + { json: "misgraft", js: "misgraft", typ: null }, + { json: "monteith", js: "monteith", typ: null }, + { json: "notcher", js: "notcher", typ: null }, + { json: "prorestriction", js: "prorestriction", typ: null }, + { json: "throatlet", js: "throatlet", typ: null }, + { json: "unfair", js: "unfair", typ: null }, + { json: "unsynonymous", js: "unsynonymous", typ: null }, + { json: "water", js: "water", typ: null }, + { json: "zestfully", js: "zestfully", typ: null }, + { json: "zincic", js: "zincic", typ: null }, + ], false), + "ChytridiaceaeClass": o([ + { json: "Batidaceae", js: "Batidaceae", typ: null }, + { json: "Brechites", js: "Brechites", typ: null }, + { json: "Emery", js: "Emery", typ: null }, + { json: "Narraganset", js: "Narraganset", typ: null }, + { json: "codespairer", js: "codespairer", typ: null }, + { json: "enervative", js: "enervative", typ: null }, + { json: "excriminate", js: "excriminate", typ: null }, + { json: "goshenite", js: "goshenite", typ: null }, + { json: "grime", js: "grime", typ: null }, + { json: "gritten", js: "gritten", typ: null }, + { json: "hectorly", js: "hectorly", typ: null }, + { json: "intermediation", js: "intermediation", typ: null }, + { json: "meeterly", js: "meeterly", typ: null }, + { json: "onymatic", js: "onymatic", typ: null }, + { json: "paddlecock", js: "paddlecock", typ: null }, + { json: "thana", js: "thana", typ: null }, + { json: "thornily", js: "thornily", typ: null }, + { json: "uckia", js: "uckia", typ: null }, + { json: "unmettle", js: "unmettle", typ: null }, + { json: "vorticellid", js: "vorticellid", typ: null }, + ], false), + "DiscordiaClass": o([ + { json: "Altaic", js: "Altaic", typ: u(undefined, i(0)) }, + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Patarin", js: "Patarin", typ: u(undefined, i(0)) }, + { json: "amoristic", js: "amoristic", typ: u(undefined, i(0)) }, + { json: "blennophthalmia", js: "blennophthalmia", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "disciplinability", js: "disciplinability", typ: u(undefined, i(0)) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "goofer", js: "goofer", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "laryngograph", js: "laryngograph", typ: u(undefined, i(0)) }, + { json: "leucitis", js: "leucitis", typ: u(undefined, i(0)) }, + { json: "lymphocyst", js: "lymphocyst", typ: u(undefined, i(0)) }, + { json: "microcosmology", js: "microcosmology", typ: u(undefined, i(0)) }, + { json: "nauseation", js: "nauseation", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "preliberal", js: "preliberal", typ: u(undefined, i(0)) }, + { json: "prettifier", js: "prettifier", typ: u(undefined, i(0)) }, + { json: "rangework", js: "rangework", typ: u(undefined, i(0)) }, + { json: "redient", js: "redient", typ: u(undefined, i(0)) }, + { json: "subfusiform", js: "subfusiform", typ: u(undefined, i(0)) }, + { json: "suicidical", js: "suicidical", typ: u(undefined, i(0)) }, + { json: "swow", js: "swow", typ: u(undefined, i(0)) }, + { json: "wastrel", js: "wastrel", typ: u(undefined, i(0)) }, + { json: "wingle", js: "wingle", typ: u(undefined, i(0)) }, + ], false), + "GryphosaurusClass": o([ + { json: "Burushaski", js: "Burushaski", typ: null }, + { json: "Tahami", js: "Tahami", typ: null }, + { json: "amissibility", js: "amissibility", typ: null }, + { json: "citronin", js: "citronin", typ: null }, + { json: "coplaintiff", js: "coplaintiff", typ: null }, + { json: "disquisitionary", js: "disquisitionary", typ: null }, + { json: "enoplan", js: "enoplan", typ: null }, + { json: "faintness", js: "faintness", typ: null }, + { json: "hebetomy", js: "hebetomy", typ: null }, + { json: "islandry", js: "islandry", typ: null }, + { json: "lameduck", js: "lameduck", typ: null }, + { json: "overbattle", js: "overbattle", typ: null }, + { json: "overinterested", js: "overinterested", typ: null }, + { json: "phrenologic", js: "phrenologic", typ: null }, + { json: "rainband", js: "rainband", typ: null }, + { json: "shiningly", js: "shiningly", typ: null }, + { json: "stamineous", js: "stamineous", typ: null }, + { json: "subscapularis", js: "subscapularis", typ: null }, + { json: "undaubed", js: "undaubed", typ: null }, + { json: "underntime", js: "underntime", typ: null }, + ], false), + "LaviniaClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Tacana", js: "Tacana", typ: u(undefined, i(0)) }, + { json: "agitable", js: "agitable", typ: u(undefined, i(0)) }, + { json: "asininity", js: "asininity", typ: u(undefined, i(0)) }, + { json: "benefiter", js: "benefiter", typ: u(undefined, i(0)) }, + { json: "bronzelike", js: "bronzelike", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "cholesteatomatous", js: "cholesteatomatous", typ: u(undefined, i(0)) }, + { json: "deprivement", js: "deprivement", typ: u(undefined, i(0)) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "flippantness", js: "flippantness", typ: u(undefined, i(0)) }, + { json: "fogproof", js: "fogproof", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "merrymeeting", js: "merrymeeting", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "overcareful", js: "overcareful", typ: u(undefined, i(0)) }, + { json: "panaris", js: "panaris", typ: u(undefined, i(0)) }, + { json: "preacceptance", js: "preacceptance", typ: u(undefined, i(0)) }, + { json: "quinoxaline", js: "quinoxaline", typ: u(undefined, i(0)) }, + { json: "sig", js: "sig", typ: u(undefined, i(0)) }, + { json: "superconfusion", js: "superconfusion", typ: u(undefined, i(0)) }, + { json: "tillotter", js: "tillotter", typ: u(undefined, i(0)) }, + { json: "tranquillize", js: "tranquillize", typ: u(undefined, i(0)) }, + { json: "unquestionable", js: "unquestionable", typ: u(undefined, i(0)) }, + { json: "uproute", js: "uproute", typ: u(undefined, i(0)) }, + ], false), + "OskarClass": o([ + { json: "Acrobates", js: "Acrobates", typ: null }, + { json: "Cayuga", js: "Cayuga", typ: null }, + { json: "Netherlandish", js: "Netherlandish", typ: null }, + { json: "beanshooter", js: "beanshooter", typ: null }, + { json: "bearhound", js: "bearhound", typ: null }, + { json: "guarneri", js: "guarneri", typ: null }, + { json: "hypochondriacism", js: "hypochondriacism", typ: null }, + { json: "indication", js: "indication", typ: null }, + { json: "jaculative", js: "jaculative", typ: null }, + { json: "nagana", js: "nagana", typ: null }, + { json: "noctivagous", js: "noctivagous", typ: null }, + { json: "nonphysiological", js: "nonphysiological", typ: null }, + { json: "praxis", js: "praxis", typ: null }, + { json: "provision", js: "provision", typ: null }, + { json: "subterhuman", js: "subterhuman", typ: null }, + { json: "sunlit", js: "sunlit", typ: null }, + { json: "syncraniate", js: "syncraniate", typ: null }, + { json: "teachment", js: "teachment", typ: null }, + { json: "unmutinous", js: "unmutinous", typ: null }, + { json: "unstoppable", js: "unstoppable", typ: null }, + ], false), + "Rebecca": o([ + { json: "Chirotherium", js: "Chirotherium", typ: i(0) }, + { json: "catharticalness", js: "catharticalness", typ: 3.14 }, + { json: "disdiapason", js: "disdiapason", typ: "" }, + { json: "homocerc", js: "homocerc", typ: true }, + { json: "nonbookish", js: "nonbookish", typ: null }, + ], false), + "AlleviateClass": o([ + { json: "Hulsean", js: "Hulsean", typ: null }, + { json: "apriori", js: "apriori", typ: null }, + { json: "beggarer", js: "beggarer", typ: null }, + { json: "brokenheartedly", js: "brokenheartedly", typ: null }, + { json: "debilitation", js: "debilitation", typ: null }, + { json: "frike", js: "frike", typ: null }, + { json: "gastrolith", js: "gastrolith", typ: null }, + { json: "orthocentric", js: "orthocentric", typ: null }, + { json: "petaly", js: "petaly", typ: null }, + { json: "probudgeting", js: "probudgeting", typ: null }, + { json: "reacquire", js: "reacquire", typ: null }, + { json: "scow", js: "scow", typ: null }, + { json: "shutoff", js: "shutoff", typ: null }, + { json: "subcontiguous", js: "subcontiguous", typ: null }, + { json: "suffumigate", js: "suffumigate", typ: null }, + { json: "transformable", js: "transformable", typ: null }, + { json: "uncoroneted", js: "uncoroneted", typ: null }, + { json: "unparking", js: "unparking", typ: null }, + { json: "unvarnishedness", js: "unvarnishedness", typ: null }, + { json: "wherewithal", js: "wherewithal", typ: null }, + ], false), + "Amphithyron": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Juniperus", js: "Juniperus", typ: u(undefined, i(0)) }, + { json: "Nazirite", js: "Nazirite", typ: u(undefined, i(0)) }, + { json: "Those", js: "Those", typ: u(undefined, i(0)) }, + { json: "akroasis", js: "akroasis", typ: u(undefined, i(0)) }, + { json: "antiphonical", js: "antiphonical", typ: u(undefined, i(0)) }, + { json: "basebred", js: "basebred", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "conductometric", js: "conductometric", typ: u(undefined, i(0)) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "ensilation", js: "ensilation", typ: u(undefined, i(0)) }, + { json: "eyebolt", js: "eyebolt", typ: u(undefined, i(0)) }, + { json: "fistulated", js: "fistulated", typ: u(undefined, i(0)) }, + { json: "heteropod", js: "heteropod", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "labyrinthically", js: "labyrinthically", typ: u(undefined, i(0)) }, + { json: "martyrization", js: "martyrization", typ: u(undefined, i(0)) }, + { json: "mispolicy", js: "mispolicy", typ: u(undefined, i(0)) }, + { json: "multipara", js: "multipara", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "possessorial", js: "possessorial", typ: u(undefined, i(0)) }, + { json: "shamed", js: "shamed", typ: u(undefined, i(0)) }, + { json: "shelfworn", js: "shelfworn", typ: u(undefined, i(0)) }, + { json: "stagnum", js: "stagnum", typ: u(undefined, i(0)) }, + { json: "undecimal", js: "undecimal", typ: u(undefined, i(0)) }, + ], false), + "AnkeeClass": o([ + { json: "Anomoean", js: "Anomoean", typ: null }, + { json: "Naja", js: "Naja", typ: null }, + { json: "barleyhood", js: "barleyhood", typ: null }, + { json: "befriender", js: "befriender", typ: null }, + { json: "brutishness", js: "brutishness", typ: null }, + { json: "cephalalgy", js: "cephalalgy", typ: null }, + { json: "cirurgian", js: "cirurgian", typ: null }, + { json: "conventionally", js: "conventionally", typ: null }, + { json: "jackshay", js: "jackshay", typ: null }, + { json: "milammeter", js: "milammeter", typ: null }, + { json: "ombrological", js: "ombrological", typ: null }, + { json: "phonasthenia", js: "phonasthenia", typ: null }, + { json: "retrievableness", js: "retrievableness", typ: null }, + { json: "snakily", js: "snakily", typ: null }, + { json: "swot", js: "swot", typ: null }, + { json: "tartlet", js: "tartlet", typ: null }, + { json: "thiofuran", js: "thiofuran", typ: null }, + { json: "tracheophone", js: "tracheophone", typ: null }, + { json: "tuglike", js: "tuglike", typ: null }, + { json: "unscratchingly", js: "unscratchingly", typ: null }, + ], false), +}; diff --git a/head/typescript/test/inputs/json/priority/combinations3.json/prefer-const-values-true--6b26e4d1265c/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations3.json/prefer-const-values-true--6b26e4d1265c/TopLevel.ts new file mode 100644 index 0000000..e726dc5 --- /dev/null +++ b/head/typescript/test/inputs/json/priority/combinations3.json/prefer-const-values-true--6b26e4d1265c/TopLevel.ts @@ -0,0 +1,1016 @@ +// 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 { + juror: JurorElement[]; + kongoni: Kongoni[]; + ladronism: LadronismElement[]; + landlubberly: LandlubberlyElement[]; + listener: Listener[]; + lupus: LupusElement[]; + maslin: Maslin[]; + monazite: MonaziteElement[]; + monoliteral: Monoliteral[]; + monotheistically: MonotheisticallyElement[]; + montage: Montage[]; + moralness: Moralness[]; + mowra: (MonaziteClass | null)[]; + mulishly: Mulishly[]; + myoscope: Myoscope[]; + nach: ((number | null)[] | null)[]; + neuromastic: Neuromastic[]; + noncontributing: Noncontributing[]; + nonnervous: Nonnervous[]; + nonvaluation: Nonvaluation[]; + occupationalist: OccupationalistElement[]; + outrival: OutrivalElement[]; + paleographically: Paleographically[]; + pamphletwise: Pamphletwise[]; + pediatrics: Pediatric[]; + perceptive: boolean[]; + piaculum: PiaculumElement[]; + piccadilly: Piccadilly[]; + piffler: Piffler[]; + pithful: Pithful[]; + placuntitis: Placuntiti[]; + plectopterous: Plectopterous[]; + pneumocele: (Pneumocele | null)[]; + poliorcetic: Poliorcetic[]; + poormaster: Poormaster[]; + potwhisky: PotwhiskyElement[]; + practicalizer: Practicalizer[]; + prefreshman: PrefreshmanElement[]; + prehensility: Prehensility[]; + prevoidance: Prevoidance[]; + probant: { [key: string]: number | null }[]; + protext: Protext[]; +} + +export type JurorElement = boolean | JurorClass; + +export interface JurorClass { + Olea: null; + adipsy: null; + auxiliator: null; + benda: null; + benjamin: null; + brandling: null; + epicurishly: null; + eremochaetous: null; + marten: null; + monocline: null; + palgat: null; + pennyworth: null; + pioury: null; + pragmatistic: null; + stylelessness: null; + systematical: null; + thready: null; + uncontemporary: null; + uncouched: null; + uninhabitedness: null; +} + +export type Kongoni = number[] | { [key: string]: number }; + +export type LadronismElement = LadronismClass | number | string; + +export interface LadronismClass { + Prodenia: null; + acclaimer: null; + achree: null; + base: null; + conundrumize: null; + degerminator: null; + describable: null; + exasperatedly: null; + heroine: null; + indazin: null; + luteous: null; + papular: null; + pritch: null; + seege: null; + shopgirl: null; + tragedietta: null; + unsparse: null; + uplook: null; + vermiformis: null; + whafabout: null; +} + +export type LandlubberlyElement = boolean | LandlubberlyClass | number; + +export interface LandlubberlyClass { + Amyraldism: null; + acropoleis: null; + aminate: null; + bipenniform: null; + bugre: null; + calycule: null; + caoutchouc: null; + disprover: null; + fitroot: null; + fulgently: null; + kickup: null; + laevoversion: null; + moter: null; + objectivity: null; + posterity: null; + postnuptial: null; + precedentary: null; + saddling: null; + subcurrent: null; + unrecriminative: null; +} + +export type Listener = null[] | number; + +export type LupusElement = LupusClass | number; + +export interface LupusClass { + Chirotherium?: number; + Chlorioninae?: number; + Corvinae?: number; + Crassina?: number; + Thysanocarpus?: number; + catharticalness?: number; + disdiapason?: string; + exiguity?: number; + farcist?: number; + holographical?: number; + homocerc?: boolean; + ichthyophagan?: number; + implacable?: number; + nonbookish?: null; + outshiner?: number; + overweather?: number; + protonegroid?: number; + shallowish?: number; + snoke?: number; + snout?: number; + surveillance?: number; + threshingtime?: number; + unsignificantly?: number; + unsnap?: number; + vendible?: number; +} + +export interface Maslin { + Alicant?: number; + Bakuninist?: null; + Chirotherium?: number; + Dimitry?: number; + antiatonement?: null; + anticorrosive?: number; + aphidozer?: null; + be?: number; + catharticalness?: number; + chub?: number; + cuprosilicon?: number; + curtailedly?: number; + dellenite?: number; + disdiapason?: string; + edifying?: null; + ethmoiditis?: number; + gastralgy?: null; + goatherd?: number; + hammerdress?: number; + hangfire?: null; + homocerc?: boolean; + lacunosity?: number; + longiloquence?: null; + mameliere?: number; + motherless?: null; + nonbookish?: null; + noncorrodible?: null; + nonsensicality?: null; + oafishly?: number; + pfund?: null; + preadvisory?: null; + retroflexed?: null; + saccharulmic?: number; + scowlful?: number; + secluded?: null; + slackage?: null; + sphaeridial?: number; + spondulics?: null; + subsecive?: number; + swellmobsman?: null; + trachyglossate?: number; + trialogue?: null; + unassuaged?: number; + ungross?: null; + unjudiciously?: null; +} + +export type MonaziteElement = MonaziteClass | number; + +export interface MonaziteClass { + Chirotherium: number; + catharticalness: number; + disdiapason: string; + homocerc: boolean; + nonbookish: null; +} + +export type Monoliteral = null[] | boolean; + +export type MonotheisticallyElement = null[] | MonotheisticallyClass; + +export interface MonotheisticallyClass { + Chirotherium?: number; + blaspheme?: null; + catharticalness?: number; + celiosalpingectomy?: null; + consummativeness?: null; + disdiapason?: string; + egestive?: null; + enchylema?: null; + gasconade?: null; + holidayer?: null; + homocerc?: boolean; + intuitionalism?: null; + lophiostomate?: null; + nonbookish?: null; + nonvolition?: null; + palatableness?: null; + pimpery?: null; + previolation?: null; + reconveyance?: null; + registership?: null; + rhyacolite?: null; + smithereens?: null; + superedification?: null; + trust?: null; + whitestone?: null; +} + +export type Montage = null[] | number | string; + +export type Moralness = null[] | number | null; + +export type Mulishly = number[] | number | null; + +export type Myoscope = null[] | boolean | number; + +export type Neuromastic = null[] | number; + +export interface Noncontributing { + estevin: string; + jolterhead: number; + sauternes: number; + sparsely: boolean; + unrequested: null; +} + +export type Nonnervous = boolean | number; + +export type Nonvaluation = null[] | boolean | number; + +export type OccupationalistElement = null[] | OccupationalistClass | null; + +export interface OccupationalistClass { + Chimakum: null; + Fin: null; + beholdable: null; + brotuliform: null; + doodler: null; + emulsin: null; + flourishing: null; + flueless: null; + furtively: null; + gritter: null; + interwish: null; + monoxylic: null; + myristic: null; + nightwear: null; + peruser: null; + theoastrological: null; + thumby: null; + tingitid: null; + trailless: null; + unpocketed: null; +} + +export type OutrivalElement = OutrivalClass | number | null; + +export interface OutrivalClass { + Castoroides: null; + Czechoslovak: null; + Lingulidae: null; + adroitly: null; + bridehood: null; + diagenesis: null; + dihexahedron: null; + dopester: null; + eumerism: null; + flyness: null; + fouler: null; + laudanosine: null; + minutary: null; + mitra: null; + opisthorchiasis: null; + pensively: null; + pubigerous: null; + rebellious: null; + recodify: null; + unpaced: null; +} + +export type Paleographically = number | { [key: string]: number | null }; + +export type Pamphletwise = number | { [key: string]: number } | string; + +export type Pediatric = boolean | number | null; + +export type PiaculumElement = PiaculumClass | number; + +export interface PiaculumClass { + Chirotherium?: number; + Zipper?: number; + alada?: number; + amphistomous?: number; + boysenberry?: number; + catharticalness?: number; + decardinalize?: number; + discouragement?: number; + disdiapason?: string; + doitrified?: number; + hexaspermous?: number; + homocerc?: boolean; + insinking?: number; + loathfulness?: number; + miasmatical?: number; + neurofibril?: number; + nonbookish?: null; + phonendoscope?: number; + pilferment?: number; + predismissory?: number; + preinscription?: number; + quotative?: number; + sienna?: number; + thorax?: number; + yachting?: number; +} + +export type Piccadilly = number | null | string; + +export type Piffler = null[] | MonaziteClass; + +export type Pithful = boolean | number | null; + +export type Placuntiti = number | { [key: string]: number }; + +export type Plectopterous = number | { [key: string]: number }; + +export interface Pneumocele { + Carbonarism?: null; + Chirotherium?: number; + Koniga?: null; + Micky?: null; + catharticalness?: number; + cineolic?: null; + cobbly?: null; + conchyliferous?: null; + congregation?: null; + disdiapason?: string; + enterotomy?: null; + entophytal?: null; + fewtrils?: null; + herem?: null; + homocerc?: boolean; + meticulosity?: null; + mismarriage?: null; + neurotrophic?: null; + nonbookish?: null; + persuasively?: null; + replaceable?: null; + silex?: null; + taillight?: null; + unjealous?: null; + visitorial?: null; +} + +export type Poliorcetic = boolean | MonaziteClass; + +export type Poormaster = number[] | { [key: string]: number } | null; + +export type PotwhiskyElement = PotwhiskyClass | number | null; + +export interface PotwhiskyClass { + Euchorda: null; + Yoruba: null; + arciform: null; + cresolin: null; + disheartener: null; + disproportionable: null; + ferryway: null; + filamentiferous: null; + flemish: null; + forgainst: null; + grainering: null; + irrevoluble: null; + kindredship: null; + pinguitudinous: null; + simpletonic: null; + singsong: null; + submergement: null; + supraoesophagal: null; + thrashel: null; + tyremesis: null; +} + +export type Practicalizer = null[] | MonaziteClass | string; + +export type PrefreshmanElement = null[] | PrefreshmanClass | string; + +export interface PrefreshmanClass { + Dolphus: null; + Ficus: null; + Gemaric: null; + Phaet: null; + azorubine: null; + choroiditis: null; + coagulatory: null; + cyclorama: null; + duckhearted: null; + jugation: null; + myoliposis: null; + nonnomination: null; + palay: null; + pentactinal: null; + piquant: null; + registration: null; + remancipation: null; + scutatiform: null; + theodolite: null; + underward: null; +} + +export type Prehensility = null[] | boolean | MonaziteClass; + +export type Prevoidance = number[] | MonaziteClass | number; + +export type Protext = number[] | boolean | MonaziteClass; + +// 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("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) + : 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 i(typ: any) { + return { integer: typ }; +} + +function p(pattern: any) { + return { pattern }; +} + +function s(typ: any, min: any, max: any) { + return { string: typ, min, max }; +} + +function n(typ: any, min: any, max: any) { + return { number: typ, min, max }; +} + +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: "juror", js: "juror", typ: a(u(true, r("JurorClass"))) }, + { json: "kongoni", js: "kongoni", typ: a(u(a(i(0)), m(i(0)))) }, + { json: "ladronism", js: "ladronism", typ: a(u(r("LadronismClass"), 3.14, "")) }, + { json: "landlubberly", js: "landlubberly", typ: a(u(true, r("LandlubberlyClass"), i(0))) }, + { json: "listener", js: "listener", typ: a(u(a(null), i(0))) }, + { json: "lupus", js: "lupus", typ: a(u(r("LupusClass"), i(0))) }, + { json: "maslin", js: "maslin", typ: a(r("Maslin")) }, + { json: "monazite", js: "monazite", typ: a(u(r("MonaziteClass"), 3.14)) }, + { json: "monoliteral", js: "monoliteral", typ: a(u(a(null), true)) }, + { json: "monotheistically", js: "monotheistically", typ: a(u(a(null), r("MonotheisticallyClass"))) }, + { json: "montage", js: "montage", typ: a(u(a(null), 3.14, "")) }, + { json: "moralness", js: "moralness", typ: a(u(a(null), 3.14, null)) }, + { json: "mowra", js: "mowra", typ: a(u(r("MonaziteClass"), null)) }, + { json: "mulishly", js: "mulishly", typ: a(u(a(i(0)), 3.14, null)) }, + { json: "myoscope", js: "myoscope", typ: a(u(a(null), true, i(0))) }, + { json: "nach", js: "nach", typ: a(u(a(u(i(0), null)), null)) }, + { json: "neuromastic", js: "neuromastic", typ: a(u(a(null), 3.14)) }, + { json: "noncontributing", js: "noncontributing", typ: a(r("Noncontributing")) }, + { json: "nonnervous", js: "nonnervous", typ: a(u(true, i(0))) }, + { json: "nonvaluation", js: "nonvaluation", typ: a(u(a(null), true, 3.14)) }, + { json: "occupationalist", js: "occupationalist", typ: a(u(a(null), r("OccupationalistClass"), null)) }, + { json: "outrival", js: "outrival", typ: a(u(r("OutrivalClass"), 3.14, null)) }, + { json: "paleographically", js: "paleographically", typ: a(u(3.14, m(u(i(0), null)))) }, + { json: "pamphletwise", js: "pamphletwise", typ: a(u(i(0), m(i(0)), "")) }, + { json: "pediatrics", js: "pediatrics", typ: a(u(true, 3.14, null)) }, + { json: "perceptive", js: "perceptive", typ: a(true) }, + { json: "piaculum", js: "piaculum", typ: a(u(r("PiaculumClass"), 3.14)) }, + { json: "piccadilly", js: "piccadilly", typ: a(u(3.14, null, "")) }, + { json: "piffler", js: "piffler", typ: a(u(a(null), r("MonaziteClass"))) }, + { json: "pithful", js: "pithful", typ: a(u(true, i(0), null)) }, + { json: "placuntitis", js: "placuntitis", typ: a(u(i(0), m(i(0)))) }, + { json: "plectopterous", js: "plectopterous", typ: a(u(3.14, m(i(0)))) }, + { json: "pneumocele", js: "pneumocele", typ: a(u(r("Pneumocele"), null)) }, + { json: "poliorcetic", js: "poliorcetic", typ: a(u(true, r("MonaziteClass"))) }, + { json: "poormaster", js: "poormaster", typ: a(u(a(i(0)), m(i(0)), null)) }, + { json: "potwhisky", js: "potwhisky", typ: a(u(r("PotwhiskyClass"), i(0), null)) }, + { json: "practicalizer", js: "practicalizer", typ: a(u(a(null), r("MonaziteClass"), "")) }, + { json: "prefreshman", js: "prefreshman", typ: a(u(a(null), r("PrefreshmanClass"), "")) }, + { json: "prehensility", js: "prehensility", typ: a(u(a(null), true, r("MonaziteClass"))) }, + { json: "prevoidance", js: "prevoidance", typ: a(u(a(i(0)), r("MonaziteClass"), i(0))) }, + { json: "probant", js: "probant", typ: a(m(u(i(0), null))) }, + { json: "protext", js: "protext", typ: a(u(a(i(0)), true, r("MonaziteClass"))) }, + ], false), + "JurorClass": o([ + { json: "Olea", js: "Olea", typ: null }, + { json: "adipsy", js: "adipsy", typ: null }, + { json: "auxiliator", js: "auxiliator", typ: null }, + { json: "benda", js: "benda", typ: null }, + { json: "benjamin", js: "benjamin", typ: null }, + { json: "brandling", js: "brandling", typ: null }, + { json: "epicurishly", js: "epicurishly", typ: null }, + { json: "eremochaetous", js: "eremochaetous", typ: null }, + { json: "marten", js: "marten", typ: null }, + { json: "monocline", js: "monocline", typ: null }, + { json: "palgat", js: "palgat", typ: null }, + { json: "pennyworth", js: "pennyworth", typ: null }, + { json: "pioury", js: "pioury", typ: null }, + { json: "pragmatistic", js: "pragmatistic", typ: null }, + { json: "stylelessness", js: "stylelessness", typ: null }, + { json: "systematical", js: "systematical", typ: null }, + { json: "thready", js: "thready", typ: null }, + { json: "uncontemporary", js: "uncontemporary", typ: null }, + { json: "uncouched", js: "uncouched", typ: null }, + { json: "uninhabitedness", js: "uninhabitedness", typ: null }, + ], false), + "LadronismClass": o([ + { json: "Prodenia", js: "Prodenia", typ: null }, + { json: "acclaimer", js: "acclaimer", typ: null }, + { json: "achree", js: "achree", typ: null }, + { json: "base", js: "base", typ: null }, + { json: "conundrumize", js: "conundrumize", typ: null }, + { json: "degerminator", js: "degerminator", typ: null }, + { json: "describable", js: "describable", typ: null }, + { json: "exasperatedly", js: "exasperatedly", typ: null }, + { json: "heroine", js: "heroine", typ: null }, + { json: "indazin", js: "indazin", typ: null }, + { json: "luteous", js: "luteous", typ: null }, + { json: "papular", js: "papular", typ: null }, + { json: "pritch", js: "pritch", typ: null }, + { json: "seege", js: "seege", typ: null }, + { json: "shopgirl", js: "shopgirl", typ: null }, + { json: "tragedietta", js: "tragedietta", typ: null }, + { json: "unsparse", js: "unsparse", typ: null }, + { json: "uplook", js: "uplook", typ: null }, + { json: "vermiformis", js: "vermiformis", typ: null }, + { json: "whafabout", js: "whafabout", typ: null }, + ], false), + "LandlubberlyClass": o([ + { json: "Amyraldism", js: "Amyraldism", typ: null }, + { json: "acropoleis", js: "acropoleis", typ: null }, + { json: "aminate", js: "aminate", typ: null }, + { json: "bipenniform", js: "bipenniform", typ: null }, + { json: "bugre", js: "bugre", typ: null }, + { json: "calycule", js: "calycule", typ: null }, + { json: "caoutchouc", js: "caoutchouc", typ: null }, + { json: "disprover", js: "disprover", typ: null }, + { json: "fitroot", js: "fitroot", typ: null }, + { json: "fulgently", js: "fulgently", typ: null }, + { json: "kickup", js: "kickup", typ: null }, + { json: "laevoversion", js: "laevoversion", typ: null }, + { json: "moter", js: "moter", typ: null }, + { json: "objectivity", js: "objectivity", typ: null }, + { json: "posterity", js: "posterity", typ: null }, + { json: "postnuptial", js: "postnuptial", typ: null }, + { json: "precedentary", js: "precedentary", typ: null }, + { json: "saddling", js: "saddling", typ: null }, + { json: "subcurrent", js: "subcurrent", typ: null }, + { json: "unrecriminative", js: "unrecriminative", typ: null }, + ], false), + "LupusClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Chlorioninae", js: "Chlorioninae", typ: u(undefined, i(0)) }, + { json: "Corvinae", js: "Corvinae", typ: u(undefined, i(0)) }, + { json: "Crassina", js: "Crassina", typ: u(undefined, i(0)) }, + { json: "Thysanocarpus", js: "Thysanocarpus", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "exiguity", js: "exiguity", typ: u(undefined, i(0)) }, + { json: "farcist", js: "farcist", typ: u(undefined, i(0)) }, + { json: "holographical", js: "holographical", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "ichthyophagan", js: "ichthyophagan", typ: u(undefined, i(0)) }, + { json: "implacable", js: "implacable", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "outshiner", js: "outshiner", typ: u(undefined, i(0)) }, + { json: "overweather", js: "overweather", typ: u(undefined, i(0)) }, + { json: "protonegroid", js: "protonegroid", typ: u(undefined, i(0)) }, + { json: "shallowish", js: "shallowish", typ: u(undefined, i(0)) }, + { json: "snoke", js: "snoke", typ: u(undefined, i(0)) }, + { json: "snout", js: "snout", typ: u(undefined, i(0)) }, + { json: "surveillance", js: "surveillance", typ: u(undefined, i(0)) }, + { json: "threshingtime", js: "threshingtime", typ: u(undefined, i(0)) }, + { json: "unsignificantly", js: "unsignificantly", typ: u(undefined, i(0)) }, + { json: "unsnap", js: "unsnap", typ: u(undefined, i(0)) }, + { json: "vendible", js: "vendible", typ: u(undefined, i(0)) }, + ], false), + "Maslin": o([ + { json: "Alicant", js: "Alicant", typ: u(undefined, i(0)) }, + { json: "Bakuninist", js: "Bakuninist", typ: u(undefined, null) }, + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Dimitry", js: "Dimitry", typ: u(undefined, i(0)) }, + { json: "antiatonement", js: "antiatonement", typ: u(undefined, null) }, + { json: "anticorrosive", js: "anticorrosive", typ: u(undefined, i(0)) }, + { json: "aphidozer", js: "aphidozer", typ: u(undefined, null) }, + { json: "be", js: "be", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "chub", js: "chub", typ: u(undefined, i(0)) }, + { json: "cuprosilicon", js: "cuprosilicon", typ: u(undefined, i(0)) }, + { json: "curtailedly", js: "curtailedly", typ: u(undefined, i(0)) }, + { json: "dellenite", js: "dellenite", typ: u(undefined, i(0)) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "edifying", js: "edifying", typ: u(undefined, null) }, + { json: "ethmoiditis", js: "ethmoiditis", typ: u(undefined, i(0)) }, + { json: "gastralgy", js: "gastralgy", typ: u(undefined, null) }, + { json: "goatherd", js: "goatherd", typ: u(undefined, i(0)) }, + { json: "hammerdress", js: "hammerdress", typ: u(undefined, i(0)) }, + { json: "hangfire", js: "hangfire", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "lacunosity", js: "lacunosity", typ: u(undefined, i(0)) }, + { json: "longiloquence", js: "longiloquence", typ: u(undefined, null) }, + { json: "mameliere", js: "mameliere", typ: u(undefined, i(0)) }, + { json: "motherless", js: "motherless", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "noncorrodible", js: "noncorrodible", typ: u(undefined, null) }, + { json: "nonsensicality", js: "nonsensicality", typ: u(undefined, null) }, + { json: "oafishly", js: "oafishly", typ: u(undefined, i(0)) }, + { json: "pfund", js: "pfund", typ: u(undefined, null) }, + { json: "preadvisory", js: "preadvisory", typ: u(undefined, null) }, + { json: "retroflexed", js: "retroflexed", typ: u(undefined, null) }, + { json: "saccharulmic", js: "saccharulmic", typ: u(undefined, i(0)) }, + { json: "scowlful", js: "scowlful", typ: u(undefined, i(0)) }, + { json: "secluded", js: "secluded", typ: u(undefined, null) }, + { json: "slackage", js: "slackage", typ: u(undefined, null) }, + { json: "sphaeridial", js: "sphaeridial", typ: u(undefined, i(0)) }, + { json: "spondulics", js: "spondulics", typ: u(undefined, null) }, + { json: "subsecive", js: "subsecive", typ: u(undefined, i(0)) }, + { json: "swellmobsman", js: "swellmobsman", typ: u(undefined, null) }, + { json: "trachyglossate", js: "trachyglossate", typ: u(undefined, i(0)) }, + { json: "trialogue", js: "trialogue", typ: u(undefined, null) }, + { json: "unassuaged", js: "unassuaged", typ: u(undefined, i(0)) }, + { json: "ungross", js: "ungross", typ: u(undefined, null) }, + { json: "unjudiciously", js: "unjudiciously", typ: u(undefined, null) }, + ], false), + "MonaziteClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: i(0) }, + { json: "catharticalness", js: "catharticalness", typ: 3.14 }, + { json: "disdiapason", js: "disdiapason", typ: "" }, + { json: "homocerc", js: "homocerc", typ: true }, + { json: "nonbookish", js: "nonbookish", typ: null }, + ], false), + "MonotheisticallyClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "blaspheme", js: "blaspheme", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "celiosalpingectomy", js: "celiosalpingectomy", typ: u(undefined, null) }, + { json: "consummativeness", js: "consummativeness", typ: u(undefined, null) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "egestive", js: "egestive", typ: u(undefined, null) }, + { json: "enchylema", js: "enchylema", typ: u(undefined, null) }, + { json: "gasconade", js: "gasconade", typ: u(undefined, null) }, + { json: "holidayer", js: "holidayer", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "intuitionalism", js: "intuitionalism", typ: u(undefined, null) }, + { json: "lophiostomate", js: "lophiostomate", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "nonvolition", js: "nonvolition", typ: u(undefined, null) }, + { json: "palatableness", js: "palatableness", typ: u(undefined, null) }, + { json: "pimpery", js: "pimpery", typ: u(undefined, null) }, + { json: "previolation", js: "previolation", typ: u(undefined, null) }, + { json: "reconveyance", js: "reconveyance", typ: u(undefined, null) }, + { json: "registership", js: "registership", typ: u(undefined, null) }, + { json: "rhyacolite", js: "rhyacolite", typ: u(undefined, null) }, + { json: "smithereens", js: "smithereens", typ: u(undefined, null) }, + { json: "superedification", js: "superedification", typ: u(undefined, null) }, + { json: "trust", js: "trust", typ: u(undefined, null) }, + { json: "whitestone", js: "whitestone", typ: u(undefined, null) }, + ], false), + "Noncontributing": o([ + { json: "estevin", js: "estevin", typ: "" }, + { json: "jolterhead", js: "jolterhead", typ: 3.14 }, + { json: "sauternes", js: "sauternes", typ: i(0) }, + { json: "sparsely", js: "sparsely", typ: true }, + { json: "unrequested", js: "unrequested", typ: null }, + ], false), + "OccupationalistClass": o([ + { json: "Chimakum", js: "Chimakum", typ: null }, + { json: "Fin", js: "Fin", typ: null }, + { json: "beholdable", js: "beholdable", typ: null }, + { json: "brotuliform", js: "brotuliform", typ: null }, + { json: "doodler", js: "doodler", typ: null }, + { json: "emulsin", js: "emulsin", typ: null }, + { json: "flourishing", js: "flourishing", typ: null }, + { json: "flueless", js: "flueless", typ: null }, + { json: "furtively", js: "furtively", typ: null }, + { json: "gritter", js: "gritter", typ: null }, + { json: "interwish", js: "interwish", typ: null }, + { json: "monoxylic", js: "monoxylic", typ: null }, + { json: "myristic", js: "myristic", typ: null }, + { json: "nightwear", js: "nightwear", typ: null }, + { json: "peruser", js: "peruser", typ: null }, + { json: "theoastrological", js: "theoastrological", typ: null }, + { json: "thumby", js: "thumby", typ: null }, + { json: "tingitid", js: "tingitid", typ: null }, + { json: "trailless", js: "trailless", typ: null }, + { json: "unpocketed", js: "unpocketed", typ: null }, + ], false), + "OutrivalClass": o([ + { json: "Castoroides", js: "Castoroides", typ: null }, + { json: "Czechoslovak", js: "Czechoslovak", typ: null }, + { json: "Lingulidae", js: "Lingulidae", typ: null }, + { json: "adroitly", js: "adroitly", typ: null }, + { json: "bridehood", js: "bridehood", typ: null }, + { json: "diagenesis", js: "diagenesis", typ: null }, + { json: "dihexahedron", js: "dihexahedron", typ: null }, + { json: "dopester", js: "dopester", typ: null }, + { json: "eumerism", js: "eumerism", typ: null }, + { json: "flyness", js: "flyness", typ: null }, + { json: "fouler", js: "fouler", typ: null }, + { json: "laudanosine", js: "laudanosine", typ: null }, + { json: "minutary", js: "minutary", typ: null }, + { json: "mitra", js: "mitra", typ: null }, + { json: "opisthorchiasis", js: "opisthorchiasis", typ: null }, + { json: "pensively", js: "pensively", typ: null }, + { json: "pubigerous", js: "pubigerous", typ: null }, + { json: "rebellious", js: "rebellious", typ: null }, + { json: "recodify", js: "recodify", typ: null }, + { json: "unpaced", js: "unpaced", typ: null }, + ], false), + "PiaculumClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Zipper", js: "Zipper", typ: u(undefined, i(0)) }, + { json: "alada", js: "alada", typ: u(undefined, i(0)) }, + { json: "amphistomous", js: "amphistomous", typ: u(undefined, i(0)) }, + { json: "boysenberry", js: "boysenberry", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "decardinalize", js: "decardinalize", typ: u(undefined, i(0)) }, + { json: "discouragement", js: "discouragement", typ: u(undefined, i(0)) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "doitrified", js: "doitrified", typ: u(undefined, i(0)) }, + { json: "hexaspermous", js: "hexaspermous", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "insinking", js: "insinking", typ: u(undefined, i(0)) }, + { json: "loathfulness", js: "loathfulness", typ: u(undefined, i(0)) }, + { json: "miasmatical", js: "miasmatical", typ: u(undefined, i(0)) }, + { json: "neurofibril", js: "neurofibril", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "phonendoscope", js: "phonendoscope", typ: u(undefined, i(0)) }, + { json: "pilferment", js: "pilferment", typ: u(undefined, i(0)) }, + { json: "predismissory", js: "predismissory", typ: u(undefined, i(0)) }, + { json: "preinscription", js: "preinscription", typ: u(undefined, i(0)) }, + { json: "quotative", js: "quotative", typ: u(undefined, i(0)) }, + { json: "sienna", js: "sienna", typ: u(undefined, i(0)) }, + { json: "thorax", js: "thorax", typ: u(undefined, i(0)) }, + { json: "yachting", js: "yachting", typ: u(undefined, i(0)) }, + ], false), + "Pneumocele": o([ + { json: "Carbonarism", js: "Carbonarism", typ: u(undefined, null) }, + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Koniga", js: "Koniga", typ: u(undefined, null) }, + { json: "Micky", js: "Micky", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "cineolic", js: "cineolic", typ: u(undefined, null) }, + { json: "cobbly", js: "cobbly", typ: u(undefined, null) }, + { json: "conchyliferous", js: "conchyliferous", typ: u(undefined, null) }, + { json: "congregation", js: "congregation", typ: u(undefined, null) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "enterotomy", js: "enterotomy", typ: u(undefined, null) }, + { json: "entophytal", js: "entophytal", typ: u(undefined, null) }, + { json: "fewtrils", js: "fewtrils", typ: u(undefined, null) }, + { json: "herem", js: "herem", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "meticulosity", js: "meticulosity", typ: u(undefined, null) }, + { json: "mismarriage", js: "mismarriage", typ: u(undefined, null) }, + { json: "neurotrophic", js: "neurotrophic", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "persuasively", js: "persuasively", typ: u(undefined, null) }, + { json: "replaceable", js: "replaceable", typ: u(undefined, null) }, + { json: "silex", js: "silex", typ: u(undefined, null) }, + { json: "taillight", js: "taillight", typ: u(undefined, null) }, + { json: "unjealous", js: "unjealous", typ: u(undefined, null) }, + { json: "visitorial", js: "visitorial", typ: u(undefined, null) }, + ], false), + "PotwhiskyClass": o([ + { json: "Euchorda", js: "Euchorda", typ: null }, + { json: "Yoruba", js: "Yoruba", typ: null }, + { json: "arciform", js: "arciform", typ: null }, + { json: "cresolin", js: "cresolin", typ: null }, + { json: "disheartener", js: "disheartener", typ: null }, + { json: "disproportionable", js: "disproportionable", typ: null }, + { json: "ferryway", js: "ferryway", typ: null }, + { json: "filamentiferous", js: "filamentiferous", typ: null }, + { json: "flemish", js: "flemish", typ: null }, + { json: "forgainst", js: "forgainst", typ: null }, + { json: "grainering", js: "grainering", typ: null }, + { json: "irrevoluble", js: "irrevoluble", typ: null }, + { json: "kindredship", js: "kindredship", typ: null }, + { json: "pinguitudinous", js: "pinguitudinous", typ: null }, + { json: "simpletonic", js: "simpletonic", typ: null }, + { json: "singsong", js: "singsong", typ: null }, + { json: "submergement", js: "submergement", typ: null }, + { json: "supraoesophagal", js: "supraoesophagal", typ: null }, + { json: "thrashel", js: "thrashel", typ: null }, + { json: "tyremesis", js: "tyremesis", typ: null }, + ], false), + "PrefreshmanClass": o([ + { json: "Dolphus", js: "Dolphus", typ: null }, + { json: "Ficus", js: "Ficus", typ: null }, + { json: "Gemaric", js: "Gemaric", typ: null }, + { json: "Phaet", js: "Phaet", typ: null }, + { json: "azorubine", js: "azorubine", typ: null }, + { json: "choroiditis", js: "choroiditis", typ: null }, + { json: "coagulatory", js: "coagulatory", typ: null }, + { json: "cyclorama", js: "cyclorama", typ: null }, + { json: "duckhearted", js: "duckhearted", typ: null }, + { json: "jugation", js: "jugation", typ: null }, + { json: "myoliposis", js: "myoliposis", typ: null }, + { json: "nonnomination", js: "nonnomination", typ: null }, + { json: "palay", js: "palay", typ: null }, + { json: "pentactinal", js: "pentactinal", typ: null }, + { json: "piquant", js: "piquant", typ: null }, + { json: "registration", js: "registration", typ: null }, + { json: "remancipation", js: "remancipation", typ: null }, + { json: "scutatiform", js: "scutatiform", typ: null }, + { json: "theodolite", js: "theodolite", typ: null }, + { json: "underward", js: "underward", typ: null }, + ], false), +}; diff --git a/head/typescript/test/inputs/json/priority/combinations3.json/prefer-types-true--df33e18681f9/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations3.json/prefer-types-true--df33e18681f9/TopLevel.ts new file mode 100644 index 0000000..34087dc --- /dev/null +++ b/head/typescript/test/inputs/json/priority/combinations3.json/prefer-types-true--df33e18681f9/TopLevel.ts @@ -0,0 +1,1016 @@ +// 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 type TopLevel = { + juror: JurorElement[]; + kongoni: Kongoni[]; + ladronism: LadronismElement[]; + landlubberly: LandlubberlyElement[]; + listener: Listener[]; + lupus: LupusElement[]; + maslin: Maslin[]; + monazite: MonaziteElement[]; + monoliteral: Monoliteral[]; + monotheistically: MonotheisticallyElement[]; + montage: Montage[]; + moralness: Moralness[]; + mowra: (MonaziteClass | null)[]; + mulishly: Mulishly[]; + myoscope: Myoscope[]; + nach: ((number | null)[] | null)[]; + neuromastic: Neuromastic[]; + noncontributing: Noncontributing[]; + nonnervous: Nonnervous[]; + nonvaluation: Nonvaluation[]; + occupationalist: OccupationalistElement[]; + outrival: OutrivalElement[]; + paleographically: Paleographically[]; + pamphletwise: Pamphletwise[]; + pediatrics: Pediatric[]; + perceptive: boolean[]; + piaculum: PiaculumElement[]; + piccadilly: Piccadilly[]; + piffler: Piffler[]; + pithful: Pithful[]; + placuntitis: Placuntiti[]; + plectopterous: Plectopterous[]; + pneumocele: (Pneumocele | null)[]; + poliorcetic: Poliorcetic[]; + poormaster: Poormaster[]; + potwhisky: PotwhiskyElement[]; + practicalizer: Practicalizer[]; + prefreshman: PrefreshmanElement[]; + prehensility: Prehensility[]; + prevoidance: Prevoidance[]; + probant: { [key: string]: number | null }[]; + protext: Protext[]; +} + +export type JurorElement = boolean | JurorClass; + +export type JurorClass = { + Olea: null; + adipsy: null; + auxiliator: null; + benda: null; + benjamin: null; + brandling: null; + epicurishly: null; + eremochaetous: null; + marten: null; + monocline: null; + palgat: null; + pennyworth: null; + pioury: null; + pragmatistic: null; + stylelessness: null; + systematical: null; + thready: null; + uncontemporary: null; + uncouched: null; + uninhabitedness: null; +} + +export type Kongoni = number[] | { [key: string]: number }; + +export type LadronismElement = LadronismClass | number | string; + +export type LadronismClass = { + Prodenia: null; + acclaimer: null; + achree: null; + base: null; + conundrumize: null; + degerminator: null; + describable: null; + exasperatedly: null; + heroine: null; + indazin: null; + luteous: null; + papular: null; + pritch: null; + seege: null; + shopgirl: null; + tragedietta: null; + unsparse: null; + uplook: null; + vermiformis: null; + whafabout: null; +} + +export type LandlubberlyElement = boolean | LandlubberlyClass | number; + +export type LandlubberlyClass = { + Amyraldism: null; + acropoleis: null; + aminate: null; + bipenniform: null; + bugre: null; + calycule: null; + caoutchouc: null; + disprover: null; + fitroot: null; + fulgently: null; + kickup: null; + laevoversion: null; + moter: null; + objectivity: null; + posterity: null; + postnuptial: null; + precedentary: null; + saddling: null; + subcurrent: null; + unrecriminative: null; +} + +export type Listener = null[] | number; + +export type LupusElement = LupusClass | number; + +export type LupusClass = { + Chirotherium?: number; + Chlorioninae?: number; + Corvinae?: number; + Crassina?: number; + Thysanocarpus?: number; + catharticalness?: number; + disdiapason?: string; + exiguity?: number; + farcist?: number; + holographical?: number; + homocerc?: boolean; + ichthyophagan?: number; + implacable?: number; + nonbookish?: null; + outshiner?: number; + overweather?: number; + protonegroid?: number; + shallowish?: number; + snoke?: number; + snout?: number; + surveillance?: number; + threshingtime?: number; + unsignificantly?: number; + unsnap?: number; + vendible?: number; +} + +export type Maslin = { + Alicant?: number; + Bakuninist?: null; + Chirotherium?: number; + Dimitry?: number; + antiatonement?: null; + anticorrosive?: number; + aphidozer?: null; + be?: number; + catharticalness?: number; + chub?: number; + cuprosilicon?: number; + curtailedly?: number; + dellenite?: number; + disdiapason?: string; + edifying?: null; + ethmoiditis?: number; + gastralgy?: null; + goatherd?: number; + hammerdress?: number; + hangfire?: null; + homocerc?: boolean; + lacunosity?: number; + longiloquence?: null; + mameliere?: number; + motherless?: null; + nonbookish?: null; + noncorrodible?: null; + nonsensicality?: null; + oafishly?: number; + pfund?: null; + preadvisory?: null; + retroflexed?: null; + saccharulmic?: number; + scowlful?: number; + secluded?: null; + slackage?: null; + sphaeridial?: number; + spondulics?: null; + subsecive?: number; + swellmobsman?: null; + trachyglossate?: number; + trialogue?: null; + unassuaged?: number; + ungross?: null; + unjudiciously?: null; +} + +export type MonaziteElement = MonaziteClass | number; + +export type MonaziteClass = { + Chirotherium: number; + catharticalness: number; + disdiapason: string; + homocerc: boolean; + nonbookish: null; +} + +export type Monoliteral = null[] | boolean; + +export type MonotheisticallyElement = null[] | MonotheisticallyClass; + +export type MonotheisticallyClass = { + Chirotherium?: number; + blaspheme?: null; + catharticalness?: number; + celiosalpingectomy?: null; + consummativeness?: null; + disdiapason?: string; + egestive?: null; + enchylema?: null; + gasconade?: null; + holidayer?: null; + homocerc?: boolean; + intuitionalism?: null; + lophiostomate?: null; + nonbookish?: null; + nonvolition?: null; + palatableness?: null; + pimpery?: null; + previolation?: null; + reconveyance?: null; + registership?: null; + rhyacolite?: null; + smithereens?: null; + superedification?: null; + trust?: null; + whitestone?: null; +} + +export type Montage = null[] | number | string; + +export type Moralness = null[] | number | null; + +export type Mulishly = number[] | number | null; + +export type Myoscope = null[] | boolean | number; + +export type Neuromastic = null[] | number; + +export type Noncontributing = { + estevin: string; + jolterhead: number; + sauternes: number; + sparsely: boolean; + unrequested: null; +} + +export type Nonnervous = boolean | number; + +export type Nonvaluation = null[] | boolean | number; + +export type OccupationalistElement = null[] | OccupationalistClass | null; + +export type OccupationalistClass = { + Chimakum: null; + Fin: null; + beholdable: null; + brotuliform: null; + doodler: null; + emulsin: null; + flourishing: null; + flueless: null; + furtively: null; + gritter: null; + interwish: null; + monoxylic: null; + myristic: null; + nightwear: null; + peruser: null; + theoastrological: null; + thumby: null; + tingitid: null; + trailless: null; + unpocketed: null; +} + +export type OutrivalElement = OutrivalClass | number | null; + +export type OutrivalClass = { + Castoroides: null; + Czechoslovak: null; + Lingulidae: null; + adroitly: null; + bridehood: null; + diagenesis: null; + dihexahedron: null; + dopester: null; + eumerism: null; + flyness: null; + fouler: null; + laudanosine: null; + minutary: null; + mitra: null; + opisthorchiasis: null; + pensively: null; + pubigerous: null; + rebellious: null; + recodify: null; + unpaced: null; +} + +export type Paleographically = number | { [key: string]: number | null }; + +export type Pamphletwise = number | { [key: string]: number } | string; + +export type Pediatric = boolean | number | null; + +export type PiaculumElement = PiaculumClass | number; + +export type PiaculumClass = { + Chirotherium?: number; + Zipper?: number; + alada?: number; + amphistomous?: number; + boysenberry?: number; + catharticalness?: number; + decardinalize?: number; + discouragement?: number; + disdiapason?: string; + doitrified?: number; + hexaspermous?: number; + homocerc?: boolean; + insinking?: number; + loathfulness?: number; + miasmatical?: number; + neurofibril?: number; + nonbookish?: null; + phonendoscope?: number; + pilferment?: number; + predismissory?: number; + preinscription?: number; + quotative?: number; + sienna?: number; + thorax?: number; + yachting?: number; +} + +export type Piccadilly = number | null | string; + +export type Piffler = null[] | MonaziteClass; + +export type Pithful = boolean | number | null; + +export type Placuntiti = number | { [key: string]: number }; + +export type Plectopterous = number | { [key: string]: number }; + +export type Pneumocele = { + Carbonarism?: null; + Chirotherium?: number; + Koniga?: null; + Micky?: null; + catharticalness?: number; + cineolic?: null; + cobbly?: null; + conchyliferous?: null; + congregation?: null; + disdiapason?: string; + enterotomy?: null; + entophytal?: null; + fewtrils?: null; + herem?: null; + homocerc?: boolean; + meticulosity?: null; + mismarriage?: null; + neurotrophic?: null; + nonbookish?: null; + persuasively?: null; + replaceable?: null; + silex?: null; + taillight?: null; + unjealous?: null; + visitorial?: null; +} + +export type Poliorcetic = boolean | MonaziteClass; + +export type Poormaster = number[] | { [key: string]: number } | null; + +export type PotwhiskyElement = PotwhiskyClass | number | null; + +export type PotwhiskyClass = { + Euchorda: null; + Yoruba: null; + arciform: null; + cresolin: null; + disheartener: null; + disproportionable: null; + ferryway: null; + filamentiferous: null; + flemish: null; + forgainst: null; + grainering: null; + irrevoluble: null; + kindredship: null; + pinguitudinous: null; + simpletonic: null; + singsong: null; + submergement: null; + supraoesophagal: null; + thrashel: null; + tyremesis: null; +} + +export type Practicalizer = null[] | MonaziteClass | string; + +export type PrefreshmanElement = null[] | PrefreshmanClass | string; + +export type PrefreshmanClass = { + Dolphus: null; + Ficus: null; + Gemaric: null; + Phaet: null; + azorubine: null; + choroiditis: null; + coagulatory: null; + cyclorama: null; + duckhearted: null; + jugation: null; + myoliposis: null; + nonnomination: null; + palay: null; + pentactinal: null; + piquant: null; + registration: null; + remancipation: null; + scutatiform: null; + theodolite: null; + underward: null; +} + +export type Prehensility = null[] | boolean | MonaziteClass; + +export type Prevoidance = number[] | MonaziteClass | number; + +export type Protext = number[] | boolean | MonaziteClass; + +// 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("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) + : 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 i(typ: any) { + return { integer: typ }; +} + +function p(pattern: any) { + return { pattern }; +} + +function s(typ: any, min: any, max: any) { + return { string: typ, min, max }; +} + +function n(typ: any, min: any, max: any) { + return { number: typ, min, max }; +} + +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: "juror", js: "juror", typ: a(u(true, r("JurorClass"))) }, + { json: "kongoni", js: "kongoni", typ: a(u(a(i(0)), m(i(0)))) }, + { json: "ladronism", js: "ladronism", typ: a(u(r("LadronismClass"), 3.14, "")) }, + { json: "landlubberly", js: "landlubberly", typ: a(u(true, r("LandlubberlyClass"), i(0))) }, + { json: "listener", js: "listener", typ: a(u(a(null), i(0))) }, + { json: "lupus", js: "lupus", typ: a(u(r("LupusClass"), i(0))) }, + { json: "maslin", js: "maslin", typ: a(r("Maslin")) }, + { json: "monazite", js: "monazite", typ: a(u(r("MonaziteClass"), 3.14)) }, + { json: "monoliteral", js: "monoliteral", typ: a(u(a(null), true)) }, + { json: "monotheistically", js: "monotheistically", typ: a(u(a(null), r("MonotheisticallyClass"))) }, + { json: "montage", js: "montage", typ: a(u(a(null), 3.14, "")) }, + { json: "moralness", js: "moralness", typ: a(u(a(null), 3.14, null)) }, + { json: "mowra", js: "mowra", typ: a(u(r("MonaziteClass"), null)) }, + { json: "mulishly", js: "mulishly", typ: a(u(a(i(0)), 3.14, null)) }, + { json: "myoscope", js: "myoscope", typ: a(u(a(null), true, i(0))) }, + { json: "nach", js: "nach", typ: a(u(a(u(i(0), null)), null)) }, + { json: "neuromastic", js: "neuromastic", typ: a(u(a(null), 3.14)) }, + { json: "noncontributing", js: "noncontributing", typ: a(r("Noncontributing")) }, + { json: "nonnervous", js: "nonnervous", typ: a(u(true, i(0))) }, + { json: "nonvaluation", js: "nonvaluation", typ: a(u(a(null), true, 3.14)) }, + { json: "occupationalist", js: "occupationalist", typ: a(u(a(null), r("OccupationalistClass"), null)) }, + { json: "outrival", js: "outrival", typ: a(u(r("OutrivalClass"), 3.14, null)) }, + { json: "paleographically", js: "paleographically", typ: a(u(3.14, m(u(i(0), null)))) }, + { json: "pamphletwise", js: "pamphletwise", typ: a(u(i(0), m(i(0)), "")) }, + { json: "pediatrics", js: "pediatrics", typ: a(u(true, 3.14, null)) }, + { json: "perceptive", js: "perceptive", typ: a(true) }, + { json: "piaculum", js: "piaculum", typ: a(u(r("PiaculumClass"), 3.14)) }, + { json: "piccadilly", js: "piccadilly", typ: a(u(3.14, null, "")) }, + { json: "piffler", js: "piffler", typ: a(u(a(null), r("MonaziteClass"))) }, + { json: "pithful", js: "pithful", typ: a(u(true, i(0), null)) }, + { json: "placuntitis", js: "placuntitis", typ: a(u(i(0), m(i(0)))) }, + { json: "plectopterous", js: "plectopterous", typ: a(u(3.14, m(i(0)))) }, + { json: "pneumocele", js: "pneumocele", typ: a(u(r("Pneumocele"), null)) }, + { json: "poliorcetic", js: "poliorcetic", typ: a(u(true, r("MonaziteClass"))) }, + { json: "poormaster", js: "poormaster", typ: a(u(a(i(0)), m(i(0)), null)) }, + { json: "potwhisky", js: "potwhisky", typ: a(u(r("PotwhiskyClass"), i(0), null)) }, + { json: "practicalizer", js: "practicalizer", typ: a(u(a(null), r("MonaziteClass"), "")) }, + { json: "prefreshman", js: "prefreshman", typ: a(u(a(null), r("PrefreshmanClass"), "")) }, + { json: "prehensility", js: "prehensility", typ: a(u(a(null), true, r("MonaziteClass"))) }, + { json: "prevoidance", js: "prevoidance", typ: a(u(a(i(0)), r("MonaziteClass"), i(0))) }, + { json: "probant", js: "probant", typ: a(m(u(i(0), null))) }, + { json: "protext", js: "protext", typ: a(u(a(i(0)), true, r("MonaziteClass"))) }, + ], false), + "JurorClass": o([ + { json: "Olea", js: "Olea", typ: null }, + { json: "adipsy", js: "adipsy", typ: null }, + { json: "auxiliator", js: "auxiliator", typ: null }, + { json: "benda", js: "benda", typ: null }, + { json: "benjamin", js: "benjamin", typ: null }, + { json: "brandling", js: "brandling", typ: null }, + { json: "epicurishly", js: "epicurishly", typ: null }, + { json: "eremochaetous", js: "eremochaetous", typ: null }, + { json: "marten", js: "marten", typ: null }, + { json: "monocline", js: "monocline", typ: null }, + { json: "palgat", js: "palgat", typ: null }, + { json: "pennyworth", js: "pennyworth", typ: null }, + { json: "pioury", js: "pioury", typ: null }, + { json: "pragmatistic", js: "pragmatistic", typ: null }, + { json: "stylelessness", js: "stylelessness", typ: null }, + { json: "systematical", js: "systematical", typ: null }, + { json: "thready", js: "thready", typ: null }, + { json: "uncontemporary", js: "uncontemporary", typ: null }, + { json: "uncouched", js: "uncouched", typ: null }, + { json: "uninhabitedness", js: "uninhabitedness", typ: null }, + ], false), + "LadronismClass": o([ + { json: "Prodenia", js: "Prodenia", typ: null }, + { json: "acclaimer", js: "acclaimer", typ: null }, + { json: "achree", js: "achree", typ: null }, + { json: "base", js: "base", typ: null }, + { json: "conundrumize", js: "conundrumize", typ: null }, + { json: "degerminator", js: "degerminator", typ: null }, + { json: "describable", js: "describable", typ: null }, + { json: "exasperatedly", js: "exasperatedly", typ: null }, + { json: "heroine", js: "heroine", typ: null }, + { json: "indazin", js: "indazin", typ: null }, + { json: "luteous", js: "luteous", typ: null }, + { json: "papular", js: "papular", typ: null }, + { json: "pritch", js: "pritch", typ: null }, + { json: "seege", js: "seege", typ: null }, + { json: "shopgirl", js: "shopgirl", typ: null }, + { json: "tragedietta", js: "tragedietta", typ: null }, + { json: "unsparse", js: "unsparse", typ: null }, + { json: "uplook", js: "uplook", typ: null }, + { json: "vermiformis", js: "vermiformis", typ: null }, + { json: "whafabout", js: "whafabout", typ: null }, + ], false), + "LandlubberlyClass": o([ + { json: "Amyraldism", js: "Amyraldism", typ: null }, + { json: "acropoleis", js: "acropoleis", typ: null }, + { json: "aminate", js: "aminate", typ: null }, + { json: "bipenniform", js: "bipenniform", typ: null }, + { json: "bugre", js: "bugre", typ: null }, + { json: "calycule", js: "calycule", typ: null }, + { json: "caoutchouc", js: "caoutchouc", typ: null }, + { json: "disprover", js: "disprover", typ: null }, + { json: "fitroot", js: "fitroot", typ: null }, + { json: "fulgently", js: "fulgently", typ: null }, + { json: "kickup", js: "kickup", typ: null }, + { json: "laevoversion", js: "laevoversion", typ: null }, + { json: "moter", js: "moter", typ: null }, + { json: "objectivity", js: "objectivity", typ: null }, + { json: "posterity", js: "posterity", typ: null }, + { json: "postnuptial", js: "postnuptial", typ: null }, + { json: "precedentary", js: "precedentary", typ: null }, + { json: "saddling", js: "saddling", typ: null }, + { json: "subcurrent", js: "subcurrent", typ: null }, + { json: "unrecriminative", js: "unrecriminative", typ: null }, + ], false), + "LupusClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Chlorioninae", js: "Chlorioninae", typ: u(undefined, i(0)) }, + { json: "Corvinae", js: "Corvinae", typ: u(undefined, i(0)) }, + { json: "Crassina", js: "Crassina", typ: u(undefined, i(0)) }, + { json: "Thysanocarpus", js: "Thysanocarpus", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "exiguity", js: "exiguity", typ: u(undefined, i(0)) }, + { json: "farcist", js: "farcist", typ: u(undefined, i(0)) }, + { json: "holographical", js: "holographical", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "ichthyophagan", js: "ichthyophagan", typ: u(undefined, i(0)) }, + { json: "implacable", js: "implacable", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "outshiner", js: "outshiner", typ: u(undefined, i(0)) }, + { json: "overweather", js: "overweather", typ: u(undefined, i(0)) }, + { json: "protonegroid", js: "protonegroid", typ: u(undefined, i(0)) }, + { json: "shallowish", js: "shallowish", typ: u(undefined, i(0)) }, + { json: "snoke", js: "snoke", typ: u(undefined, i(0)) }, + { json: "snout", js: "snout", typ: u(undefined, i(0)) }, + { json: "surveillance", js: "surveillance", typ: u(undefined, i(0)) }, + { json: "threshingtime", js: "threshingtime", typ: u(undefined, i(0)) }, + { json: "unsignificantly", js: "unsignificantly", typ: u(undefined, i(0)) }, + { json: "unsnap", js: "unsnap", typ: u(undefined, i(0)) }, + { json: "vendible", js: "vendible", typ: u(undefined, i(0)) }, + ], false), + "Maslin": o([ + { json: "Alicant", js: "Alicant", typ: u(undefined, i(0)) }, + { json: "Bakuninist", js: "Bakuninist", typ: u(undefined, null) }, + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Dimitry", js: "Dimitry", typ: u(undefined, i(0)) }, + { json: "antiatonement", js: "antiatonement", typ: u(undefined, null) }, + { json: "anticorrosive", js: "anticorrosive", typ: u(undefined, i(0)) }, + { json: "aphidozer", js: "aphidozer", typ: u(undefined, null) }, + { json: "be", js: "be", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "chub", js: "chub", typ: u(undefined, i(0)) }, + { json: "cuprosilicon", js: "cuprosilicon", typ: u(undefined, i(0)) }, + { json: "curtailedly", js: "curtailedly", typ: u(undefined, i(0)) }, + { json: "dellenite", js: "dellenite", typ: u(undefined, i(0)) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "edifying", js: "edifying", typ: u(undefined, null) }, + { json: "ethmoiditis", js: "ethmoiditis", typ: u(undefined, i(0)) }, + { json: "gastralgy", js: "gastralgy", typ: u(undefined, null) }, + { json: "goatherd", js: "goatherd", typ: u(undefined, i(0)) }, + { json: "hammerdress", js: "hammerdress", typ: u(undefined, i(0)) }, + { json: "hangfire", js: "hangfire", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "lacunosity", js: "lacunosity", typ: u(undefined, i(0)) }, + { json: "longiloquence", js: "longiloquence", typ: u(undefined, null) }, + { json: "mameliere", js: "mameliere", typ: u(undefined, i(0)) }, + { json: "motherless", js: "motherless", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "noncorrodible", js: "noncorrodible", typ: u(undefined, null) }, + { json: "nonsensicality", js: "nonsensicality", typ: u(undefined, null) }, + { json: "oafishly", js: "oafishly", typ: u(undefined, i(0)) }, + { json: "pfund", js: "pfund", typ: u(undefined, null) }, + { json: "preadvisory", js: "preadvisory", typ: u(undefined, null) }, + { json: "retroflexed", js: "retroflexed", typ: u(undefined, null) }, + { json: "saccharulmic", js: "saccharulmic", typ: u(undefined, i(0)) }, + { json: "scowlful", js: "scowlful", typ: u(undefined, i(0)) }, + { json: "secluded", js: "secluded", typ: u(undefined, null) }, + { json: "slackage", js: "slackage", typ: u(undefined, null) }, + { json: "sphaeridial", js: "sphaeridial", typ: u(undefined, i(0)) }, + { json: "spondulics", js: "spondulics", typ: u(undefined, null) }, + { json: "subsecive", js: "subsecive", typ: u(undefined, i(0)) }, + { json: "swellmobsman", js: "swellmobsman", typ: u(undefined, null) }, + { json: "trachyglossate", js: "trachyglossate", typ: u(undefined, i(0)) }, + { json: "trialogue", js: "trialogue", typ: u(undefined, null) }, + { json: "unassuaged", js: "unassuaged", typ: u(undefined, i(0)) }, + { json: "ungross", js: "ungross", typ: u(undefined, null) }, + { json: "unjudiciously", js: "unjudiciously", typ: u(undefined, null) }, + ], false), + "MonaziteClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: i(0) }, + { json: "catharticalness", js: "catharticalness", typ: 3.14 }, + { json: "disdiapason", js: "disdiapason", typ: "" }, + { json: "homocerc", js: "homocerc", typ: true }, + { json: "nonbookish", js: "nonbookish", typ: null }, + ], false), + "MonotheisticallyClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "blaspheme", js: "blaspheme", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "celiosalpingectomy", js: "celiosalpingectomy", typ: u(undefined, null) }, + { json: "consummativeness", js: "consummativeness", typ: u(undefined, null) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "egestive", js: "egestive", typ: u(undefined, null) }, + { json: "enchylema", js: "enchylema", typ: u(undefined, null) }, + { json: "gasconade", js: "gasconade", typ: u(undefined, null) }, + { json: "holidayer", js: "holidayer", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "intuitionalism", js: "intuitionalism", typ: u(undefined, null) }, + { json: "lophiostomate", js: "lophiostomate", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "nonvolition", js: "nonvolition", typ: u(undefined, null) }, + { json: "palatableness", js: "palatableness", typ: u(undefined, null) }, + { json: "pimpery", js: "pimpery", typ: u(undefined, null) }, + { json: "previolation", js: "previolation", typ: u(undefined, null) }, + { json: "reconveyance", js: "reconveyance", typ: u(undefined, null) }, + { json: "registership", js: "registership", typ: u(undefined, null) }, + { json: "rhyacolite", js: "rhyacolite", typ: u(undefined, null) }, + { json: "smithereens", js: "smithereens", typ: u(undefined, null) }, + { json: "superedification", js: "superedification", typ: u(undefined, null) }, + { json: "trust", js: "trust", typ: u(undefined, null) }, + { json: "whitestone", js: "whitestone", typ: u(undefined, null) }, + ], false), + "Noncontributing": o([ + { json: "estevin", js: "estevin", typ: "" }, + { json: "jolterhead", js: "jolterhead", typ: 3.14 }, + { json: "sauternes", js: "sauternes", typ: i(0) }, + { json: "sparsely", js: "sparsely", typ: true }, + { json: "unrequested", js: "unrequested", typ: null }, + ], false), + "OccupationalistClass": o([ + { json: "Chimakum", js: "Chimakum", typ: null }, + { json: "Fin", js: "Fin", typ: null }, + { json: "beholdable", js: "beholdable", typ: null }, + { json: "brotuliform", js: "brotuliform", typ: null }, + { json: "doodler", js: "doodler", typ: null }, + { json: "emulsin", js: "emulsin", typ: null }, + { json: "flourishing", js: "flourishing", typ: null }, + { json: "flueless", js: "flueless", typ: null }, + { json: "furtively", js: "furtively", typ: null }, + { json: "gritter", js: "gritter", typ: null }, + { json: "interwish", js: "interwish", typ: null }, + { json: "monoxylic", js: "monoxylic", typ: null }, + { json: "myristic", js: "myristic", typ: null }, + { json: "nightwear", js: "nightwear", typ: null }, + { json: "peruser", js: "peruser", typ: null }, + { json: "theoastrological", js: "theoastrological", typ: null }, + { json: "thumby", js: "thumby", typ: null }, + { json: "tingitid", js: "tingitid", typ: null }, + { json: "trailless", js: "trailless", typ: null }, + { json: "unpocketed", js: "unpocketed", typ: null }, + ], false), + "OutrivalClass": o([ + { json: "Castoroides", js: "Castoroides", typ: null }, + { json: "Czechoslovak", js: "Czechoslovak", typ: null }, + { json: "Lingulidae", js: "Lingulidae", typ: null }, + { json: "adroitly", js: "adroitly", typ: null }, + { json: "bridehood", js: "bridehood", typ: null }, + { json: "diagenesis", js: "diagenesis", typ: null }, + { json: "dihexahedron", js: "dihexahedron", typ: null }, + { json: "dopester", js: "dopester", typ: null }, + { json: "eumerism", js: "eumerism", typ: null }, + { json: "flyness", js: "flyness", typ: null }, + { json: "fouler", js: "fouler", typ: null }, + { json: "laudanosine", js: "laudanosine", typ: null }, + { json: "minutary", js: "minutary", typ: null }, + { json: "mitra", js: "mitra", typ: null }, + { json: "opisthorchiasis", js: "opisthorchiasis", typ: null }, + { json: "pensively", js: "pensively", typ: null }, + { json: "pubigerous", js: "pubigerous", typ: null }, + { json: "rebellious", js: "rebellious", typ: null }, + { json: "recodify", js: "recodify", typ: null }, + { json: "unpaced", js: "unpaced", typ: null }, + ], false), + "PiaculumClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Zipper", js: "Zipper", typ: u(undefined, i(0)) }, + { json: "alada", js: "alada", typ: u(undefined, i(0)) }, + { json: "amphistomous", js: "amphistomous", typ: u(undefined, i(0)) }, + { json: "boysenberry", js: "boysenberry", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "decardinalize", js: "decardinalize", typ: u(undefined, i(0)) }, + { json: "discouragement", js: "discouragement", typ: u(undefined, i(0)) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "doitrified", js: "doitrified", typ: u(undefined, i(0)) }, + { json: "hexaspermous", js: "hexaspermous", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "insinking", js: "insinking", typ: u(undefined, i(0)) }, + { json: "loathfulness", js: "loathfulness", typ: u(undefined, i(0)) }, + { json: "miasmatical", js: "miasmatical", typ: u(undefined, i(0)) }, + { json: "neurofibril", js: "neurofibril", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "phonendoscope", js: "phonendoscope", typ: u(undefined, i(0)) }, + { json: "pilferment", js: "pilferment", typ: u(undefined, i(0)) }, + { json: "predismissory", js: "predismissory", typ: u(undefined, i(0)) }, + { json: "preinscription", js: "preinscription", typ: u(undefined, i(0)) }, + { json: "quotative", js: "quotative", typ: u(undefined, i(0)) }, + { json: "sienna", js: "sienna", typ: u(undefined, i(0)) }, + { json: "thorax", js: "thorax", typ: u(undefined, i(0)) }, + { json: "yachting", js: "yachting", typ: u(undefined, i(0)) }, + ], false), + "Pneumocele": o([ + { json: "Carbonarism", js: "Carbonarism", typ: u(undefined, null) }, + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Koniga", js: "Koniga", typ: u(undefined, null) }, + { json: "Micky", js: "Micky", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "cineolic", js: "cineolic", typ: u(undefined, null) }, + { json: "cobbly", js: "cobbly", typ: u(undefined, null) }, + { json: "conchyliferous", js: "conchyliferous", typ: u(undefined, null) }, + { json: "congregation", js: "congregation", typ: u(undefined, null) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "enterotomy", js: "enterotomy", typ: u(undefined, null) }, + { json: "entophytal", js: "entophytal", typ: u(undefined, null) }, + { json: "fewtrils", js: "fewtrils", typ: u(undefined, null) }, + { json: "herem", js: "herem", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "meticulosity", js: "meticulosity", typ: u(undefined, null) }, + { json: "mismarriage", js: "mismarriage", typ: u(undefined, null) }, + { json: "neurotrophic", js: "neurotrophic", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "persuasively", js: "persuasively", typ: u(undefined, null) }, + { json: "replaceable", js: "replaceable", typ: u(undefined, null) }, + { json: "silex", js: "silex", typ: u(undefined, null) }, + { json: "taillight", js: "taillight", typ: u(undefined, null) }, + { json: "unjealous", js: "unjealous", typ: u(undefined, null) }, + { json: "visitorial", js: "visitorial", typ: u(undefined, null) }, + ], false), + "PotwhiskyClass": o([ + { json: "Euchorda", js: "Euchorda", typ: null }, + { json: "Yoruba", js: "Yoruba", typ: null }, + { json: "arciform", js: "arciform", typ: null }, + { json: "cresolin", js: "cresolin", typ: null }, + { json: "disheartener", js: "disheartener", typ: null }, + { json: "disproportionable", js: "disproportionable", typ: null }, + { json: "ferryway", js: "ferryway", typ: null }, + { json: "filamentiferous", js: "filamentiferous", typ: null }, + { json: "flemish", js: "flemish", typ: null }, + { json: "forgainst", js: "forgainst", typ: null }, + { json: "grainering", js: "grainering", typ: null }, + { json: "irrevoluble", js: "irrevoluble", typ: null }, + { json: "kindredship", js: "kindredship", typ: null }, + { json: "pinguitudinous", js: "pinguitudinous", typ: null }, + { json: "simpletonic", js: "simpletonic", typ: null }, + { json: "singsong", js: "singsong", typ: null }, + { json: "submergement", js: "submergement", typ: null }, + { json: "supraoesophagal", js: "supraoesophagal", typ: null }, + { json: "thrashel", js: "thrashel", typ: null }, + { json: "tyremesis", js: "tyremesis", typ: null }, + ], false), + "PrefreshmanClass": o([ + { json: "Dolphus", js: "Dolphus", typ: null }, + { json: "Ficus", js: "Ficus", typ: null }, + { json: "Gemaric", js: "Gemaric", typ: null }, + { json: "Phaet", js: "Phaet", typ: null }, + { json: "azorubine", js: "azorubine", typ: null }, + { json: "choroiditis", js: "choroiditis", typ: null }, + { json: "coagulatory", js: "coagulatory", typ: null }, + { json: "cyclorama", js: "cyclorama", typ: null }, + { json: "duckhearted", js: "duckhearted", typ: null }, + { json: "jugation", js: "jugation", typ: null }, + { json: "myoliposis", js: "myoliposis", typ: null }, + { json: "nonnomination", js: "nonnomination", typ: null }, + { json: "palay", js: "palay", typ: null }, + { json: "pentactinal", js: "pentactinal", typ: null }, + { json: "piquant", js: "piquant", typ: null }, + { json: "registration", js: "registration", typ: null }, + { json: "remancipation", js: "remancipation", typ: null }, + { json: "scutatiform", js: "scutatiform", typ: null }, + { json: "theodolite", js: "theodolite", typ: null }, + { json: "underward", js: "underward", typ: null }, + ], false), +}; diff --git a/head/typescript/test/inputs/json/priority/combinations4.json/prefer-const-values-true--6b26e4d1265c/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations4.json/prefer-const-values-true--6b26e4d1265c/TopLevel.ts new file mode 100644 index 0000000..bcc98d6 --- /dev/null +++ b/head/typescript/test/inputs/json/priority/combinations4.json/prefer-const-values-true--6b26e4d1265c/TopLevel.ts @@ -0,0 +1,1140 @@ +// 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 { + protrusive: Protrusive[]; + pulpitism: PulpitismElement[]; + pyodermia: PyodermiaElement[]; + quebrachine: QuebrachineElement[]; + querier: Querier[]; + rebarbative: Rebarbative[]; + reimagine: Reimagine[]; + ressaut: Ressaut; + retrocervical: Retrocervical[]; + revert: Revert[]; + rewrite: RewriteElement[]; + saccoderm: Saccoderm[]; + santir: SantirElement[]; + saprophilous: Saprophilous[]; + saxten: SaxtenElement[]; + scatty: (Scatty | null)[]; + scoffer: Scoffer[]; + scrampum: Scrampum[]; + semantic: number; + serpentinic: Serpentinic[]; + shadowable: Shadowable[]; + sistering: SisteringElement[]; + staghunting: Staghunting[]; + stagmometer: Stagmometer[]; + stimulability: Stimulability[]; + strangleable: Strangleable[]; + strenuosity: StrenuosityElement[]; + tabaxir: Tabaxir[]; + talpiform: Talpiform[]; + thwack: Thwack[]; + to: (number | null)[]; + tortricine: Tortricine[]; + truantcy: TruantcyElement[]; + turgesce: string[]; + unbeginning: Unbeginning[]; + underdunged: number[]; + undesirability: Undesirability[]; + unerasing: Unerasing[]; + unguentarium: Unguentarium[]; + unimpeachably: UnimpeachablyElement[]; + unmortgaged: Unmortgaged[]; + unobstructed: Unobstructed[]; + unreceptivity: Unreceptivity[]; + unsatisfactoriness: Unsatisfactoriness[]; + unsecurity: number[]; + unstressed: UnstressedElement[]; + untasked: Untasked[]; + unvarying: Unvarying[]; + vehemently: Vehemently[]; + warriorship: { [key: string]: boolean }; + whitepot: Whitepot[]; + wrothy: WrothyElement[]; +} + +export type Protrusive = (number | null)[] | number; + +export type PulpitismElement = number[] | PulpitismClass | number; + +export interface PulpitismClass { + abnet: null; + buckhorn: null; + calciform: null; + chelophore: null; + cogitation: null; + decreeable: null; + despicable: null; + isodiazo: null; + jadedly: null; + leptochlorite: null; + nursling: null; + palamedean: null; + photoheliograph: null; + pipewood: null; + roberd: null; + statable: null; + superassume: null; + syllabe: null; + toughhead: null; + underburn: null; +} + +export type PyodermiaElement = PyodermiaClass | number; + +export interface PyodermiaClass { + Gyppo: null; + aphoristically: null; + apophyllous: null; + cognize: null; + dermonosology: null; + ither: null; + juglandaceous: null; + litho: null; + macropterous: null; + photographer: null; + romancing: null; + rumness: null; + somniloquist: null; + stressfully: null; + tactically: null; + tracheophony: null; + unappositely: null; + unclothedly: null; + unimplied: null; + unsyncopated: null; +} + +export type QuebrachineElement = boolean | QuebrachineClass | null; + +export interface QuebrachineClass { + Chirotherium: number; + catharticalness: number; + disdiapason: string; + homocerc: boolean; + nonbookish: null; +} + +export type Querier = boolean | { [key: string]: number }; + +export type Rebarbative = number[] | boolean | number; + +export interface Reimagine { + Chirotherium?: number; + Hermo?: null; + adducible?: null; + anabolin?: null; + brainy?: null; + catharticalness?: number; + chrysamine?: null; + disdiapason?: string; + fluxweed?: null; + glaucine?: null; + grobianism?: null; + hieroglyphist?: null; + homocerc?: boolean; + icteroid?: null; + immortal?: null; + impetulant?: null; + irrigate?: null; + myxedema?: null; + nonbookish?: null; + onyx?: null; + repasser?: null; + septomarginal?: null; + subdie?: null; + tibiometatarsal?: null; + waltzlike?: null; +} + +export interface Ressaut { + Freesia: string; + Genevieve: string; + Mimosaceae: string; + Theopaschitism: string; + apperceptive: string; + cuttoo: string; + douser: string; + drinkproof: string; + forementioned: string; + hyperdiabolical: string; + hypocone: string; + irreverentially: string; + jumart: string; + mollicrush: string; + nedder: string; + retinasphalt: string; + sough: string; + steading: string; + undurableness: string; + unmingleable: string; +} + +export type Retrocervical = (number | null)[] | number; + +export type Revert = boolean | string; + +export type RewriteElement = null[] | RewriteClass | number; + +export interface RewriteClass { + Hyades: null; + Ptenoglossa: null; + Whiggification: null; + accountancy: null; + cacotrophic: null; + contest: null; + couthily: null; + falculate: null; + foreseize: null; + lemnad: null; + monotheistically: null; + nonflying: null; + repatch: null; + rodman: null; + strung: null; + titmal: null; + twalpennyworth: null; + unblamable: null; + vertical: null; + yardman: null; +} + +export type Saccoderm = number[] | null | string; + +export type SantirElement = SantirClass | number; + +export interface SantirClass { + Suessiones: null; + admiredly: null; + demicaponier: null; + epitympanic: null; + investitor: null; + lupiform: null; + monoflagellate: null; + paleoethnic: null; + prediscountable: null; + rhetoricals: null; + roomth: null; + saccharose: null; + septonasal: null; + serpenticide: null; + setarious: null; + spaework: null; + stylite: null; + timelily: null; + unprofaned: null; + vorticular: null; +} + +export type Saprophilous = { [key: string]: number } | null | string; + +export type SaxtenElement = SaxtenClass | string; + +export interface SaxtenClass { + Centaurid?: null; + Chirotherium?: number; + algarrobilla?: null; + bowgrace?: null; + catharticalness?: number; + disdiapason?: string; + flix?: null; + germanely?: null; + homocerc?: boolean; + inhume?: null; + lepidote?: null; + megalochirous?: null; + ninepenny?: null; + nonbookish?: null; + nondeist?: null; + nymphaeaceous?: null; + parietofrontal?: null; + sancyite?: null; + subjectivist?: null; + tibiad?: null; + transonic?: null; + tripetalous?: null; + trunchman?: null; + urger?: null; + withdrawnness?: null; +} + +export interface Scatty { + Tabasco: null; + aeriferous: null; + antical: null; + antighostism: null; + arcanum: null; + autotrophy: null; + baronial: null; + caffeine: null; + gorgoniacean: null; + heroical: null; + hydropical: null; + mechanology: null; + musicopoetic: null; + officiality: null; + oftentimes: null; + ophthalmotonometer: null; + reflectively: null; + springer: null; + teleianthous: null; + uncombated: null; +} + +export type Scoffer = null[] | { [key: string]: number } | null; + +export type Scrampum = number[] | boolean | null; + +export type Serpentinic = number[] | number; + +export type Shadowable = (number | null)[] | boolean; + +export type SisteringElement = null[] | SisteringClass | number; + +export interface SisteringClass { + Chianti: null; + Haplomi: null; + Micropterygidae: null; + amphicarpic: null; + frigorific: null; + hyperkinesis: null; + laudable: null; + madwoman: null; + maimedly: null; + microrhabdus: null; + nondense: null; + phlebemphraxis: null; + redsear: null; + schismatical: null; + tartryl: null; + unabhorred: null; + undeliberateness: null; + unmixable: null; + untruckling: null; + vineal: null; +} + +export interface Staghunting { + Chirotherium?: number; + calorimetric?: number; + canid?: number; + catharticalness?: number; + disdiapason?: string; + ditriglyphic?: number; + floriferousness?: number; + gamelike?: number; + grig?: number; + homocerc?: boolean; + interloan?: number; + lithotomy?: number; + loric?: number; + membranocoriaceous?: number; + membranogenic?: number; + nonbookish?: null; + overtrump?: number; + scotino?: number; + seasonable?: number; + sephen?: number; + stigmarioid?: number; + tired?: number; + trifid?: number; + undefeatedly?: number; + ungirlish?: number; +} + +export type Stagmometer = (number | null)[] | string; + +export type Stimulability = boolean | number | { [key: string]: number }; + +export type Strangleable = null[] | number; + +export type StrenuosityElement = null[] | StrenuosityClass; + +export interface StrenuosityClass { + Chirotherium?: number; + Onopordon?: number; + Sodomite?: number; + Yankeeist?: number; + bliss?: number; + buccate?: number; + bulletproof?: number; + catharticalness?: number; + crumblingness?: number; + disdiapason?: string; + engagedly?: number; + fightable?: number; + hoariness?: number; + homocerc?: boolean; + hypopodium?: number; + luxurist?: number; + mechanician?: number; + nonbookish?: null; + podgily?: number; + reformableness?: number; + scatterbrains?: number; + seminuria?: number; + tramp?: number; + undueness?: number; + worthily?: number; +} + +export type Tabaxir = boolean | number; + +export type Talpiform = QuebrachineClass | number | null; + +export type Thwack = boolean | QuebrachineClass | number; + +export type Tortricine = (number | null)[] | QuebrachineClass; + +export type TruantcyElement = boolean | TruantcyClass; + +export interface TruantcyClass { + Chirotherium?: number; + Epeira?: null; + Eurylaimi?: null; + Yuman?: null; + alfiona?: null; + ascaridiasis?: null; + bungey?: null; + catharticalness?: number; + ceroxyle?: null; + chorology?: null; + disdiapason?: string; + enmarble?: null; + germination?: null; + hallelujah?: null; + homocerc?: boolean; + lev?: null; + mouthing?: null; + nonbookish?: null; + philliloo?: null; + planetal?: null; + poney?: null; + punctualist?: null; + returnlessly?: null; + skelder?: null; + windwaywardly?: null; +} + +export type Unbeginning = null[] | { [key: string]: number } | string; + +export type Undesirability = number[] | { [key: string]: number } | string; + +export type Unerasing = null[] | number | { [key: string]: number }; + +export type Unguentarium = null[] | number | null; + +export type UnimpeachablyElement = boolean | UnimpeachablyClass; + +export interface UnimpeachablyClass { + Bobadil?: number; + Chirotherium?: number; + Quiina?: number; + Robert?: number; + acerin?: number; + catharticalness?: number; + chlorophylligenous?: number; + conversational?: number; + demiowl?: number; + disdiapason?: string; + ectorhinal?: number; + gamblesomeness?: number; + homocerc?: boolean; + irrorate?: number; + kindergartening?: number; + lateritic?: number; + mespil?: number; + misconfiguration?: number; + nonbookish?: null; + planometry?: number; + rot?: number; + subcinctorium?: number; + tussocker?: number; + ultraproud?: number; + unsuggestedness?: number; +} + +export type Unmortgaged = number | { [key: string]: number } | null; + +export type Unobstructed = QuebrachineClass | number | null; + +export type Unreceptivity = null[] | number | string; + +export type Unsatisfactoriness = number[] | boolean | number; + +export type UnstressedElement = boolean | UnstressedClass | string; + +export interface UnstressedClass { + Alain: null; + Amphirhina: null; + Lincolnian: null; + Sarcophilus: null; + antimachinery: null; + coldish: null; + crantara: null; + distinguishing: null; + elytroposis: null; + gentianwort: null; + heliosis: null; + instrumental: null; + introinflection: null; + kala: null; + metad: null; + swingingly: null; + unconformity: null; + undecreed: null; + venerable: null; + vowellessness: null; +} + +export type Untasked = null[] | number | { [key: string]: number }; + +export type Unvarying = boolean | number | { [key: string]: number }; + +export type Vehemently = null[] | boolean | null; + +export type Whitepot = QuebrachineClass | number; + +export type WrothyElement = null[] | WrothyClass; + +export interface WrothyClass { + Aeschynanthus: null; + Ephesine: null; + aquiferous: null; + cheapener: null; + enumeration: null; + escadrille: null; + estrous: null; + interestedly: null; + katakinetomer: null; + mortification: null; + morula: null; + orthosymmetrical: null; + overbark: null; + politist: null; + qualified: null; + sphenomalar: null; + throatful: null; + transhumance: null; + triandrian: null; + unbooked: null; +} + +// 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("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) + : 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 i(typ: any) { + return { integer: typ }; +} + +function p(pattern: any) { + return { pattern }; +} + +function s(typ: any, min: any, max: any) { + return { string: typ, min, max }; +} + +function n(typ: any, min: any, max: any) { + return { number: typ, min, max }; +} + +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: "protrusive", js: "protrusive", typ: a(u(a(u(i(0), null)), 3.14)) }, + { json: "pulpitism", js: "pulpitism", typ: a(u(a(i(0)), r("PulpitismClass"), 3.14)) }, + { json: "pyodermia", js: "pyodermia", typ: a(u(r("PyodermiaClass"), i(0))) }, + { json: "quebrachine", js: "quebrachine", typ: a(u(true, r("QuebrachineClass"), null)) }, + { json: "querier", js: "querier", typ: a(u(true, m(i(0)))) }, + { json: "rebarbative", js: "rebarbative", typ: a(u(a(i(0)), true, 3.14)) }, + { json: "reimagine", js: "reimagine", typ: a(r("Reimagine")) }, + { json: "ressaut", js: "ressaut", typ: r("Ressaut") }, + { json: "retrocervical", js: "retrocervical", typ: a(u(a(u(i(0), null)), i(0))) }, + { json: "revert", js: "revert", typ: a(u(true, "")) }, + { json: "rewrite", js: "rewrite", typ: a(u(a(null), r("RewriteClass"), 3.14)) }, + { json: "saccoderm", js: "saccoderm", typ: a(u(a(i(0)), null, "")) }, + { json: "santir", js: "santir", typ: a(u(r("SantirClass"), 3.14)) }, + { json: "saprophilous", js: "saprophilous", typ: a(u(m(i(0)), null, "")) }, + { json: "saxten", js: "saxten", typ: a(u(r("SaxtenClass"), "")) }, + { json: "scatty", js: "scatty", typ: a(u(r("Scatty"), null)) }, + { json: "scoffer", js: "scoffer", typ: a(u(a(null), m(i(0)), null)) }, + { json: "scrampum", js: "scrampum", typ: a(u(a(i(0)), true, null)) }, + { json: "semantic", js: "semantic", typ: 3.14 }, + { json: "serpentinic", js: "serpentinic", typ: a(u(a(i(0)), 3.14)) }, + { json: "shadowable", js: "shadowable", typ: a(u(a(u(i(0), null)), true)) }, + { json: "sistering", js: "sistering", typ: a(u(a(null), r("SisteringClass"), i(0))) }, + { json: "staghunting", js: "staghunting", typ: a(r("Staghunting")) }, + { json: "stagmometer", js: "stagmometer", typ: a(u(a(u(i(0), null)), "")) }, + { json: "stimulability", js: "stimulability", typ: a(u(true, i(0), m(i(0)))) }, + { json: "strangleable", js: "strangleable", typ: a(u(a(null), 3.14)) }, + { json: "strenuosity", js: "strenuosity", typ: a(u(a(null), r("StrenuosityClass"))) }, + { json: "tabaxir", js: "tabaxir", typ: a(u(true, 3.14)) }, + { json: "talpiform", js: "talpiform", typ: a(u(r("QuebrachineClass"), 3.14, null)) }, + { json: "thwack", js: "thwack", typ: a(u(true, r("QuebrachineClass"), 3.14)) }, + { json: "to", js: "to", typ: a(u(3.14, null)) }, + { json: "tortricine", js: "tortricine", typ: a(u(a(u(i(0), null)), r("QuebrachineClass"))) }, + { json: "truantcy", js: "truantcy", typ: a(u(true, r("TruantcyClass"))) }, + { json: "turgesce", js: "turgesce", typ: a("") }, + { json: "unbeginning", js: "unbeginning", typ: a(u(a(null), m(i(0)), "")) }, + { json: "underdunged", js: "underdunged", typ: a(3.14) }, + { json: "undesirability", js: "undesirability", typ: a(u(a(i(0)), m(i(0)), "")) }, + { json: "unerasing", js: "unerasing", typ: a(u(a(null), i(0), m(i(0)))) }, + { json: "unguentarium", js: "unguentarium", typ: a(u(a(null), i(0), null)) }, + { json: "unimpeachably", js: "unimpeachably", typ: a(u(true, r("UnimpeachablyClass"))) }, + { json: "unmortgaged", js: "unmortgaged", typ: a(u(3.14, m(i(0)), null)) }, + { json: "unobstructed", js: "unobstructed", typ: a(u(r("QuebrachineClass"), i(0), null)) }, + { json: "unreceptivity", js: "unreceptivity", typ: a(u(a(null), i(0), "")) }, + { json: "unsatisfactoriness", js: "unsatisfactoriness", typ: a(u(a(i(0)), true, i(0))) }, + { json: "unsecurity", js: "unsecurity", typ: a(i(0)) }, + { json: "unstressed", js: "unstressed", typ: a(u(true, r("UnstressedClass"), "")) }, + { json: "untasked", js: "untasked", typ: a(u(a(null), 3.14, m(i(0)))) }, + { json: "unvarying", js: "unvarying", typ: a(u(true, 3.14, m(i(0)))) }, + { json: "vehemently", js: "vehemently", typ: a(u(a(null), true, null)) }, + { json: "warriorship", js: "warriorship", typ: m(true) }, + { json: "whitepot", js: "whitepot", typ: a(u(r("QuebrachineClass"), 3.14)) }, + { json: "wrothy", js: "wrothy", typ: a(u(a(null), r("WrothyClass"))) }, + ], false), + "PulpitismClass": o([ + { json: "abnet", js: "abnet", typ: null }, + { json: "buckhorn", js: "buckhorn", typ: null }, + { json: "calciform", js: "calciform", typ: null }, + { json: "chelophore", js: "chelophore", typ: null }, + { json: "cogitation", js: "cogitation", typ: null }, + { json: "decreeable", js: "decreeable", typ: null }, + { json: "despicable", js: "despicable", typ: null }, + { json: "isodiazo", js: "isodiazo", typ: null }, + { json: "jadedly", js: "jadedly", typ: null }, + { json: "leptochlorite", js: "leptochlorite", typ: null }, + { json: "nursling", js: "nursling", typ: null }, + { json: "palamedean", js: "palamedean", typ: null }, + { json: "photoheliograph", js: "photoheliograph", typ: null }, + { json: "pipewood", js: "pipewood", typ: null }, + { json: "roberd", js: "roberd", typ: null }, + { json: "statable", js: "statable", typ: null }, + { json: "superassume", js: "superassume", typ: null }, + { json: "syllabe", js: "syllabe", typ: null }, + { json: "toughhead", js: "toughhead", typ: null }, + { json: "underburn", js: "underburn", typ: null }, + ], false), + "PyodermiaClass": o([ + { json: "Gyppo", js: "Gyppo", typ: null }, + { json: "aphoristically", js: "aphoristically", typ: null }, + { json: "apophyllous", js: "apophyllous", typ: null }, + { json: "cognize", js: "cognize", typ: null }, + { json: "dermonosology", js: "dermonosology", typ: null }, + { json: "ither", js: "ither", typ: null }, + { json: "juglandaceous", js: "juglandaceous", typ: null }, + { json: "litho", js: "litho", typ: null }, + { json: "macropterous", js: "macropterous", typ: null }, + { json: "photographer", js: "photographer", typ: null }, + { json: "romancing", js: "romancing", typ: null }, + { json: "rumness", js: "rumness", typ: null }, + { json: "somniloquist", js: "somniloquist", typ: null }, + { json: "stressfully", js: "stressfully", typ: null }, + { json: "tactically", js: "tactically", typ: null }, + { json: "tracheophony", js: "tracheophony", typ: null }, + { json: "unappositely", js: "unappositely", typ: null }, + { json: "unclothedly", js: "unclothedly", typ: null }, + { json: "unimplied", js: "unimplied", typ: null }, + { json: "unsyncopated", js: "unsyncopated", typ: null }, + ], false), + "QuebrachineClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: i(0) }, + { json: "catharticalness", js: "catharticalness", typ: 3.14 }, + { json: "disdiapason", js: "disdiapason", typ: "" }, + { json: "homocerc", js: "homocerc", typ: true }, + { json: "nonbookish", js: "nonbookish", typ: null }, + ], false), + "Reimagine": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Hermo", js: "Hermo", typ: u(undefined, null) }, + { json: "adducible", js: "adducible", typ: u(undefined, null) }, + { json: "anabolin", js: "anabolin", typ: u(undefined, null) }, + { json: "brainy", js: "brainy", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "chrysamine", js: "chrysamine", typ: u(undefined, null) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "fluxweed", js: "fluxweed", typ: u(undefined, null) }, + { json: "glaucine", js: "glaucine", typ: u(undefined, null) }, + { json: "grobianism", js: "grobianism", typ: u(undefined, null) }, + { json: "hieroglyphist", js: "hieroglyphist", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "icteroid", js: "icteroid", typ: u(undefined, null) }, + { json: "immortal", js: "immortal", typ: u(undefined, null) }, + { json: "impetulant", js: "impetulant", typ: u(undefined, null) }, + { json: "irrigate", js: "irrigate", typ: u(undefined, null) }, + { json: "myxedema", js: "myxedema", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "onyx", js: "onyx", typ: u(undefined, null) }, + { json: "repasser", js: "repasser", typ: u(undefined, null) }, + { json: "septomarginal", js: "septomarginal", typ: u(undefined, null) }, + { json: "subdie", js: "subdie", typ: u(undefined, null) }, + { json: "tibiometatarsal", js: "tibiometatarsal", typ: u(undefined, null) }, + { json: "waltzlike", js: "waltzlike", typ: u(undefined, null) }, + ], false), + "Ressaut": o([ + { json: "Freesia", js: "Freesia", typ: "" }, + { json: "Genevieve", js: "Genevieve", typ: "" }, + { json: "Mimosaceae", js: "Mimosaceae", typ: "" }, + { json: "Theopaschitism", js: "Theopaschitism", typ: "" }, + { json: "apperceptive", js: "apperceptive", typ: "" }, + { json: "cuttoo", js: "cuttoo", typ: "" }, + { json: "douser", js: "douser", typ: "" }, + { json: "drinkproof", js: "drinkproof", typ: "" }, + { json: "forementioned", js: "forementioned", typ: "" }, + { json: "hyperdiabolical", js: "hyperdiabolical", typ: "" }, + { json: "hypocone", js: "hypocone", typ: "" }, + { json: "irreverentially", js: "irreverentially", typ: "" }, + { json: "jumart", js: "jumart", typ: "" }, + { json: "mollicrush", js: "mollicrush", typ: "" }, + { json: "nedder", js: "nedder", typ: "" }, + { json: "retinasphalt", js: "retinasphalt", typ: "" }, + { json: "sough", js: "sough", typ: "" }, + { json: "steading", js: "steading", typ: "" }, + { json: "undurableness", js: "undurableness", typ: "" }, + { json: "unmingleable", js: "unmingleable", typ: "" }, + ], false), + "RewriteClass": o([ + { json: "Hyades", js: "Hyades", typ: null }, + { json: "Ptenoglossa", js: "Ptenoglossa", typ: null }, + { json: "Whiggification", js: "Whiggification", typ: null }, + { json: "accountancy", js: "accountancy", typ: null }, + { json: "cacotrophic", js: "cacotrophic", typ: null }, + { json: "contest", js: "contest", typ: null }, + { json: "couthily", js: "couthily", typ: null }, + { json: "falculate", js: "falculate", typ: null }, + { json: "foreseize", js: "foreseize", typ: null }, + { json: "lemnad", js: "lemnad", typ: null }, + { json: "monotheistically", js: "monotheistically", typ: null }, + { json: "nonflying", js: "nonflying", typ: null }, + { json: "repatch", js: "repatch", typ: null }, + { json: "rodman", js: "rodman", typ: null }, + { json: "strung", js: "strung", typ: null }, + { json: "titmal", js: "titmal", typ: null }, + { json: "twalpennyworth", js: "twalpennyworth", typ: null }, + { json: "unblamable", js: "unblamable", typ: null }, + { json: "vertical", js: "vertical", typ: null }, + { json: "yardman", js: "yardman", typ: null }, + ], false), + "SantirClass": o([ + { json: "Suessiones", js: "Suessiones", typ: null }, + { json: "admiredly", js: "admiredly", typ: null }, + { json: "demicaponier", js: "demicaponier", typ: null }, + { json: "epitympanic", js: "epitympanic", typ: null }, + { json: "investitor", js: "investitor", typ: null }, + { json: "lupiform", js: "lupiform", typ: null }, + { json: "monoflagellate", js: "monoflagellate", typ: null }, + { json: "paleoethnic", js: "paleoethnic", typ: null }, + { json: "prediscountable", js: "prediscountable", typ: null }, + { json: "rhetoricals", js: "rhetoricals", typ: null }, + { json: "roomth", js: "roomth", typ: null }, + { json: "saccharose", js: "saccharose", typ: null }, + { json: "septonasal", js: "septonasal", typ: null }, + { json: "serpenticide", js: "serpenticide", typ: null }, + { json: "setarious", js: "setarious", typ: null }, + { json: "spaework", js: "spaework", typ: null }, + { json: "stylite", js: "stylite", typ: null }, + { json: "timelily", js: "timelily", typ: null }, + { json: "unprofaned", js: "unprofaned", typ: null }, + { json: "vorticular", js: "vorticular", typ: null }, + ], false), + "SaxtenClass": o([ + { json: "Centaurid", js: "Centaurid", typ: u(undefined, null) }, + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "algarrobilla", js: "algarrobilla", typ: u(undefined, null) }, + { json: "bowgrace", js: "bowgrace", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "flix", js: "flix", typ: u(undefined, null) }, + { json: "germanely", js: "germanely", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "inhume", js: "inhume", typ: u(undefined, null) }, + { json: "lepidote", js: "lepidote", typ: u(undefined, null) }, + { json: "megalochirous", js: "megalochirous", typ: u(undefined, null) }, + { json: "ninepenny", js: "ninepenny", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "nondeist", js: "nondeist", typ: u(undefined, null) }, + { json: "nymphaeaceous", js: "nymphaeaceous", typ: u(undefined, null) }, + { json: "parietofrontal", js: "parietofrontal", typ: u(undefined, null) }, + { json: "sancyite", js: "sancyite", typ: u(undefined, null) }, + { json: "subjectivist", js: "subjectivist", typ: u(undefined, null) }, + { json: "tibiad", js: "tibiad", typ: u(undefined, null) }, + { json: "transonic", js: "transonic", typ: u(undefined, null) }, + { json: "tripetalous", js: "tripetalous", typ: u(undefined, null) }, + { json: "trunchman", js: "trunchman", typ: u(undefined, null) }, + { json: "urger", js: "urger", typ: u(undefined, null) }, + { json: "withdrawnness", js: "withdrawnness", typ: u(undefined, null) }, + ], false), + "Scatty": o([ + { json: "Tabasco", js: "Tabasco", typ: null }, + { json: "aeriferous", js: "aeriferous", typ: null }, + { json: "antical", js: "antical", typ: null }, + { json: "antighostism", js: "antighostism", typ: null }, + { json: "arcanum", js: "arcanum", typ: null }, + { json: "autotrophy", js: "autotrophy", typ: null }, + { json: "baronial", js: "baronial", typ: null }, + { json: "caffeine", js: "caffeine", typ: null }, + { json: "gorgoniacean", js: "gorgoniacean", typ: null }, + { json: "heroical", js: "heroical", typ: null }, + { json: "hydropical", js: "hydropical", typ: null }, + { json: "mechanology", js: "mechanology", typ: null }, + { json: "musicopoetic", js: "musicopoetic", typ: null }, + { json: "officiality", js: "officiality", typ: null }, + { json: "oftentimes", js: "oftentimes", typ: null }, + { json: "ophthalmotonometer", js: "ophthalmotonometer", typ: null }, + { json: "reflectively", js: "reflectively", typ: null }, + { json: "springer", js: "springer", typ: null }, + { json: "teleianthous", js: "teleianthous", typ: null }, + { json: "uncombated", js: "uncombated", typ: null }, + ], false), + "SisteringClass": o([ + { json: "Chianti", js: "Chianti", typ: null }, + { json: "Haplomi", js: "Haplomi", typ: null }, + { json: "Micropterygidae", js: "Micropterygidae", typ: null }, + { json: "amphicarpic", js: "amphicarpic", typ: null }, + { json: "frigorific", js: "frigorific", typ: null }, + { json: "hyperkinesis", js: "hyperkinesis", typ: null }, + { json: "laudable", js: "laudable", typ: null }, + { json: "madwoman", js: "madwoman", typ: null }, + { json: "maimedly", js: "maimedly", typ: null }, + { json: "microrhabdus", js: "microrhabdus", typ: null }, + { json: "nondense", js: "nondense", typ: null }, + { json: "phlebemphraxis", js: "phlebemphraxis", typ: null }, + { json: "redsear", js: "redsear", typ: null }, + { json: "schismatical", js: "schismatical", typ: null }, + { json: "tartryl", js: "tartryl", typ: null }, + { json: "unabhorred", js: "unabhorred", typ: null }, + { json: "undeliberateness", js: "undeliberateness", typ: null }, + { json: "unmixable", js: "unmixable", typ: null }, + { json: "untruckling", js: "untruckling", typ: null }, + { json: "vineal", js: "vineal", typ: null }, + ], false), + "Staghunting": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "calorimetric", js: "calorimetric", typ: u(undefined, i(0)) }, + { json: "canid", js: "canid", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "ditriglyphic", js: "ditriglyphic", typ: u(undefined, i(0)) }, + { json: "floriferousness", js: "floriferousness", typ: u(undefined, i(0)) }, + { json: "gamelike", js: "gamelike", typ: u(undefined, i(0)) }, + { json: "grig", js: "grig", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "interloan", js: "interloan", typ: u(undefined, i(0)) }, + { json: "lithotomy", js: "lithotomy", typ: u(undefined, i(0)) }, + { json: "loric", js: "loric", typ: u(undefined, i(0)) }, + { json: "membranocoriaceous", js: "membranocoriaceous", typ: u(undefined, i(0)) }, + { json: "membranogenic", js: "membranogenic", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "overtrump", js: "overtrump", typ: u(undefined, i(0)) }, + { json: "scotino", js: "scotino", typ: u(undefined, i(0)) }, + { json: "seasonable", js: "seasonable", typ: u(undefined, i(0)) }, + { json: "sephen", js: "sephen", typ: u(undefined, i(0)) }, + { json: "stigmarioid", js: "stigmarioid", typ: u(undefined, i(0)) }, + { json: "tired", js: "tired", typ: u(undefined, i(0)) }, + { json: "trifid", js: "trifid", typ: u(undefined, i(0)) }, + { json: "undefeatedly", js: "undefeatedly", typ: u(undefined, i(0)) }, + { json: "ungirlish", js: "ungirlish", typ: u(undefined, i(0)) }, + ], false), + "StrenuosityClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Onopordon", js: "Onopordon", typ: u(undefined, i(0)) }, + { json: "Sodomite", js: "Sodomite", typ: u(undefined, i(0)) }, + { json: "Yankeeist", js: "Yankeeist", typ: u(undefined, i(0)) }, + { json: "bliss", js: "bliss", typ: u(undefined, i(0)) }, + { json: "buccate", js: "buccate", typ: u(undefined, i(0)) }, + { json: "bulletproof", js: "bulletproof", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "crumblingness", js: "crumblingness", typ: u(undefined, i(0)) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "engagedly", js: "engagedly", typ: u(undefined, i(0)) }, + { json: "fightable", js: "fightable", typ: u(undefined, i(0)) }, + { json: "hoariness", js: "hoariness", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "hypopodium", js: "hypopodium", typ: u(undefined, i(0)) }, + { json: "luxurist", js: "luxurist", typ: u(undefined, i(0)) }, + { json: "mechanician", js: "mechanician", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "podgily", js: "podgily", typ: u(undefined, i(0)) }, + { json: "reformableness", js: "reformableness", typ: u(undefined, i(0)) }, + { json: "scatterbrains", js: "scatterbrains", typ: u(undefined, i(0)) }, + { json: "seminuria", js: "seminuria", typ: u(undefined, i(0)) }, + { json: "tramp", js: "tramp", typ: u(undefined, i(0)) }, + { json: "undueness", js: "undueness", typ: u(undefined, i(0)) }, + { json: "worthily", js: "worthily", typ: u(undefined, i(0)) }, + ], false), + "TruantcyClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Epeira", js: "Epeira", typ: u(undefined, null) }, + { json: "Eurylaimi", js: "Eurylaimi", typ: u(undefined, null) }, + { json: "Yuman", js: "Yuman", typ: u(undefined, null) }, + { json: "alfiona", js: "alfiona", typ: u(undefined, null) }, + { json: "ascaridiasis", js: "ascaridiasis", typ: u(undefined, null) }, + { json: "bungey", js: "bungey", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "ceroxyle", js: "ceroxyle", typ: u(undefined, null) }, + { json: "chorology", js: "chorology", typ: u(undefined, null) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "enmarble", js: "enmarble", typ: u(undefined, null) }, + { json: "germination", js: "germination", typ: u(undefined, null) }, + { json: "hallelujah", js: "hallelujah", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "lev", js: "lev", typ: u(undefined, null) }, + { json: "mouthing", js: "mouthing", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "philliloo", js: "philliloo", typ: u(undefined, null) }, + { json: "planetal", js: "planetal", typ: u(undefined, null) }, + { json: "poney", js: "poney", typ: u(undefined, null) }, + { json: "punctualist", js: "punctualist", typ: u(undefined, null) }, + { json: "returnlessly", js: "returnlessly", typ: u(undefined, null) }, + { json: "skelder", js: "skelder", typ: u(undefined, null) }, + { json: "windwaywardly", js: "windwaywardly", typ: u(undefined, null) }, + ], false), + "UnimpeachablyClass": o([ + { json: "Bobadil", js: "Bobadil", typ: u(undefined, i(0)) }, + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Quiina", js: "Quiina", typ: u(undefined, i(0)) }, + { json: "Robert", js: "Robert", typ: u(undefined, i(0)) }, + { json: "acerin", js: "acerin", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "chlorophylligenous", js: "chlorophylligenous", typ: u(undefined, i(0)) }, + { json: "conversational", js: "conversational", typ: u(undefined, i(0)) }, + { json: "demiowl", js: "demiowl", typ: u(undefined, i(0)) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "ectorhinal", js: "ectorhinal", typ: u(undefined, i(0)) }, + { json: "gamblesomeness", js: "gamblesomeness", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "irrorate", js: "irrorate", typ: u(undefined, i(0)) }, + { json: "kindergartening", js: "kindergartening", typ: u(undefined, i(0)) }, + { json: "lateritic", js: "lateritic", typ: u(undefined, i(0)) }, + { json: "mespil", js: "mespil", typ: u(undefined, i(0)) }, + { json: "misconfiguration", js: "misconfiguration", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "planometry", js: "planometry", typ: u(undefined, i(0)) }, + { json: "rot", js: "rot", typ: u(undefined, i(0)) }, + { json: "subcinctorium", js: "subcinctorium", typ: u(undefined, i(0)) }, + { json: "tussocker", js: "tussocker", typ: u(undefined, i(0)) }, + { json: "ultraproud", js: "ultraproud", typ: u(undefined, i(0)) }, + { json: "unsuggestedness", js: "unsuggestedness", typ: u(undefined, i(0)) }, + ], false), + "UnstressedClass": o([ + { json: "Alain", js: "Alain", typ: null }, + { json: "Amphirhina", js: "Amphirhina", typ: null }, + { json: "Lincolnian", js: "Lincolnian", typ: null }, + { json: "Sarcophilus", js: "Sarcophilus", typ: null }, + { json: "antimachinery", js: "antimachinery", typ: null }, + { json: "coldish", js: "coldish", typ: null }, + { json: "crantara", js: "crantara", typ: null }, + { json: "distinguishing", js: "distinguishing", typ: null }, + { json: "elytroposis", js: "elytroposis", typ: null }, + { json: "gentianwort", js: "gentianwort", typ: null }, + { json: "heliosis", js: "heliosis", typ: null }, + { json: "instrumental", js: "instrumental", typ: null }, + { json: "introinflection", js: "introinflection", typ: null }, + { json: "kala", js: "kala", typ: null }, + { json: "metad", js: "metad", typ: null }, + { json: "swingingly", js: "swingingly", typ: null }, + { json: "unconformity", js: "unconformity", typ: null }, + { json: "undecreed", js: "undecreed", typ: null }, + { json: "venerable", js: "venerable", typ: null }, + { json: "vowellessness", js: "vowellessness", typ: null }, + ], false), + "WrothyClass": o([ + { json: "Aeschynanthus", js: "Aeschynanthus", typ: null }, + { json: "Ephesine", js: "Ephesine", typ: null }, + { json: "aquiferous", js: "aquiferous", typ: null }, + { json: "cheapener", js: "cheapener", typ: null }, + { json: "enumeration", js: "enumeration", typ: null }, + { json: "escadrille", js: "escadrille", typ: null }, + { json: "estrous", js: "estrous", typ: null }, + { json: "interestedly", js: "interestedly", typ: null }, + { json: "katakinetomer", js: "katakinetomer", typ: null }, + { json: "mortification", js: "mortification", typ: null }, + { json: "morula", js: "morula", typ: null }, + { json: "orthosymmetrical", js: "orthosymmetrical", typ: null }, + { json: "overbark", js: "overbark", typ: null }, + { json: "politist", js: "politist", typ: null }, + { json: "qualified", js: "qualified", typ: null }, + { json: "sphenomalar", js: "sphenomalar", typ: null }, + { json: "throatful", js: "throatful", typ: null }, + { json: "transhumance", js: "transhumance", typ: null }, + { json: "triandrian", js: "triandrian", typ: null }, + { json: "unbooked", js: "unbooked", typ: null }, + ], false), +}; diff --git a/head/typescript/test/inputs/json/priority/combinations4.json/prefer-types-true--df33e18681f9/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations4.json/prefer-types-true--df33e18681f9/TopLevel.ts new file mode 100644 index 0000000..fe60acc --- /dev/null +++ b/head/typescript/test/inputs/json/priority/combinations4.json/prefer-types-true--df33e18681f9/TopLevel.ts @@ -0,0 +1,1140 @@ +// 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 type TopLevel = { + protrusive: Protrusive[]; + pulpitism: PulpitismElement[]; + pyodermia: PyodermiaElement[]; + quebrachine: QuebrachineElement[]; + querier: Querier[]; + rebarbative: Rebarbative[]; + reimagine: Reimagine[]; + ressaut: Ressaut; + retrocervical: Retrocervical[]; + revert: Revert[]; + rewrite: RewriteElement[]; + saccoderm: Saccoderm[]; + santir: SantirElement[]; + saprophilous: Saprophilous[]; + saxten: SaxtenElement[]; + scatty: (Scatty | null)[]; + scoffer: Scoffer[]; + scrampum: Scrampum[]; + semantic: number; + serpentinic: Serpentinic[]; + shadowable: Shadowable[]; + sistering: SisteringElement[]; + staghunting: Staghunting[]; + stagmometer: Stagmometer[]; + stimulability: Stimulability[]; + strangleable: Strangleable[]; + strenuosity: StrenuosityElement[]; + tabaxir: Tabaxir[]; + talpiform: Talpiform[]; + thwack: Thwack[]; + to: (number | null)[]; + tortricine: Tortricine[]; + truantcy: TruantcyElement[]; + turgesce: string[]; + unbeginning: Unbeginning[]; + underdunged: number[]; + undesirability: Undesirability[]; + unerasing: Unerasing[]; + unguentarium: Unguentarium[]; + unimpeachably: UnimpeachablyElement[]; + unmortgaged: Unmortgaged[]; + unobstructed: Unobstructed[]; + unreceptivity: Unreceptivity[]; + unsatisfactoriness: Unsatisfactoriness[]; + unsecurity: number[]; + unstressed: UnstressedElement[]; + untasked: Untasked[]; + unvarying: Unvarying[]; + vehemently: Vehemently[]; + warriorship: { [key: string]: boolean }; + whitepot: Whitepot[]; + wrothy: WrothyElement[]; +} + +export type Protrusive = (number | null)[] | number; + +export type PulpitismElement = number[] | PulpitismClass | number; + +export type PulpitismClass = { + abnet: null; + buckhorn: null; + calciform: null; + chelophore: null; + cogitation: null; + decreeable: null; + despicable: null; + isodiazo: null; + jadedly: null; + leptochlorite: null; + nursling: null; + palamedean: null; + photoheliograph: null; + pipewood: null; + roberd: null; + statable: null; + superassume: null; + syllabe: null; + toughhead: null; + underburn: null; +} + +export type PyodermiaElement = PyodermiaClass | number; + +export type PyodermiaClass = { + Gyppo: null; + aphoristically: null; + apophyllous: null; + cognize: null; + dermonosology: null; + ither: null; + juglandaceous: null; + litho: null; + macropterous: null; + photographer: null; + romancing: null; + rumness: null; + somniloquist: null; + stressfully: null; + tactically: null; + tracheophony: null; + unappositely: null; + unclothedly: null; + unimplied: null; + unsyncopated: null; +} + +export type QuebrachineElement = boolean | QuebrachineClass | null; + +export type QuebrachineClass = { + Chirotherium: number; + catharticalness: number; + disdiapason: string; + homocerc: boolean; + nonbookish: null; +} + +export type Querier = boolean | { [key: string]: number }; + +export type Rebarbative = number[] | boolean | number; + +export type Reimagine = { + Chirotherium?: number; + Hermo?: null; + adducible?: null; + anabolin?: null; + brainy?: null; + catharticalness?: number; + chrysamine?: null; + disdiapason?: string; + fluxweed?: null; + glaucine?: null; + grobianism?: null; + hieroglyphist?: null; + homocerc?: boolean; + icteroid?: null; + immortal?: null; + impetulant?: null; + irrigate?: null; + myxedema?: null; + nonbookish?: null; + onyx?: null; + repasser?: null; + septomarginal?: null; + subdie?: null; + tibiometatarsal?: null; + waltzlike?: null; +} + +export type Ressaut = { + Freesia: string; + Genevieve: string; + Mimosaceae: string; + Theopaschitism: string; + apperceptive: string; + cuttoo: string; + douser: string; + drinkproof: string; + forementioned: string; + hyperdiabolical: string; + hypocone: string; + irreverentially: string; + jumart: string; + mollicrush: string; + nedder: string; + retinasphalt: string; + sough: string; + steading: string; + undurableness: string; + unmingleable: string; +} + +export type Retrocervical = (number | null)[] | number; + +export type Revert = boolean | string; + +export type RewriteElement = null[] | RewriteClass | number; + +export type RewriteClass = { + Hyades: null; + Ptenoglossa: null; + Whiggification: null; + accountancy: null; + cacotrophic: null; + contest: null; + couthily: null; + falculate: null; + foreseize: null; + lemnad: null; + monotheistically: null; + nonflying: null; + repatch: null; + rodman: null; + strung: null; + titmal: null; + twalpennyworth: null; + unblamable: null; + vertical: null; + yardman: null; +} + +export type Saccoderm = number[] | null | string; + +export type SantirElement = SantirClass | number; + +export type SantirClass = { + Suessiones: null; + admiredly: null; + demicaponier: null; + epitympanic: null; + investitor: null; + lupiform: null; + monoflagellate: null; + paleoethnic: null; + prediscountable: null; + rhetoricals: null; + roomth: null; + saccharose: null; + septonasal: null; + serpenticide: null; + setarious: null; + spaework: null; + stylite: null; + timelily: null; + unprofaned: null; + vorticular: null; +} + +export type Saprophilous = { [key: string]: number } | null | string; + +export type SaxtenElement = SaxtenClass | string; + +export type SaxtenClass = { + Centaurid?: null; + Chirotherium?: number; + algarrobilla?: null; + bowgrace?: null; + catharticalness?: number; + disdiapason?: string; + flix?: null; + germanely?: null; + homocerc?: boolean; + inhume?: null; + lepidote?: null; + megalochirous?: null; + ninepenny?: null; + nonbookish?: null; + nondeist?: null; + nymphaeaceous?: null; + parietofrontal?: null; + sancyite?: null; + subjectivist?: null; + tibiad?: null; + transonic?: null; + tripetalous?: null; + trunchman?: null; + urger?: null; + withdrawnness?: null; +} + +export type Scatty = { + Tabasco: null; + aeriferous: null; + antical: null; + antighostism: null; + arcanum: null; + autotrophy: null; + baronial: null; + caffeine: null; + gorgoniacean: null; + heroical: null; + hydropical: null; + mechanology: null; + musicopoetic: null; + officiality: null; + oftentimes: null; + ophthalmotonometer: null; + reflectively: null; + springer: null; + teleianthous: null; + uncombated: null; +} + +export type Scoffer = null[] | { [key: string]: number } | null; + +export type Scrampum = number[] | boolean | null; + +export type Serpentinic = number[] | number; + +export type Shadowable = (number | null)[] | boolean; + +export type SisteringElement = null[] | SisteringClass | number; + +export type SisteringClass = { + Chianti: null; + Haplomi: null; + Micropterygidae: null; + amphicarpic: null; + frigorific: null; + hyperkinesis: null; + laudable: null; + madwoman: null; + maimedly: null; + microrhabdus: null; + nondense: null; + phlebemphraxis: null; + redsear: null; + schismatical: null; + tartryl: null; + unabhorred: null; + undeliberateness: null; + unmixable: null; + untruckling: null; + vineal: null; +} + +export type Staghunting = { + Chirotherium?: number; + calorimetric?: number; + canid?: number; + catharticalness?: number; + disdiapason?: string; + ditriglyphic?: number; + floriferousness?: number; + gamelike?: number; + grig?: number; + homocerc?: boolean; + interloan?: number; + lithotomy?: number; + loric?: number; + membranocoriaceous?: number; + membranogenic?: number; + nonbookish?: null; + overtrump?: number; + scotino?: number; + seasonable?: number; + sephen?: number; + stigmarioid?: number; + tired?: number; + trifid?: number; + undefeatedly?: number; + ungirlish?: number; +} + +export type Stagmometer = (number | null)[] | string; + +export type Stimulability = boolean | number | { [key: string]: number }; + +export type Strangleable = null[] | number; + +export type StrenuosityElement = null[] | StrenuosityClass; + +export type StrenuosityClass = { + Chirotherium?: number; + Onopordon?: number; + Sodomite?: number; + Yankeeist?: number; + bliss?: number; + buccate?: number; + bulletproof?: number; + catharticalness?: number; + crumblingness?: number; + disdiapason?: string; + engagedly?: number; + fightable?: number; + hoariness?: number; + homocerc?: boolean; + hypopodium?: number; + luxurist?: number; + mechanician?: number; + nonbookish?: null; + podgily?: number; + reformableness?: number; + scatterbrains?: number; + seminuria?: number; + tramp?: number; + undueness?: number; + worthily?: number; +} + +export type Tabaxir = boolean | number; + +export type Talpiform = QuebrachineClass | number | null; + +export type Thwack = boolean | QuebrachineClass | number; + +export type Tortricine = (number | null)[] | QuebrachineClass; + +export type TruantcyElement = boolean | TruantcyClass; + +export type TruantcyClass = { + Chirotherium?: number; + Epeira?: null; + Eurylaimi?: null; + Yuman?: null; + alfiona?: null; + ascaridiasis?: null; + bungey?: null; + catharticalness?: number; + ceroxyle?: null; + chorology?: null; + disdiapason?: string; + enmarble?: null; + germination?: null; + hallelujah?: null; + homocerc?: boolean; + lev?: null; + mouthing?: null; + nonbookish?: null; + philliloo?: null; + planetal?: null; + poney?: null; + punctualist?: null; + returnlessly?: null; + skelder?: null; + windwaywardly?: null; +} + +export type Unbeginning = null[] | { [key: string]: number } | string; + +export type Undesirability = number[] | { [key: string]: number } | string; + +export type Unerasing = null[] | number | { [key: string]: number }; + +export type Unguentarium = null[] | number | null; + +export type UnimpeachablyElement = boolean | UnimpeachablyClass; + +export type UnimpeachablyClass = { + Bobadil?: number; + Chirotherium?: number; + Quiina?: number; + Robert?: number; + acerin?: number; + catharticalness?: number; + chlorophylligenous?: number; + conversational?: number; + demiowl?: number; + disdiapason?: string; + ectorhinal?: number; + gamblesomeness?: number; + homocerc?: boolean; + irrorate?: number; + kindergartening?: number; + lateritic?: number; + mespil?: number; + misconfiguration?: number; + nonbookish?: null; + planometry?: number; + rot?: number; + subcinctorium?: number; + tussocker?: number; + ultraproud?: number; + unsuggestedness?: number; +} + +export type Unmortgaged = number | { [key: string]: number } | null; + +export type Unobstructed = QuebrachineClass | number | null; + +export type Unreceptivity = null[] | number | string; + +export type Unsatisfactoriness = number[] | boolean | number; + +export type UnstressedElement = boolean | UnstressedClass | string; + +export type UnstressedClass = { + Alain: null; + Amphirhina: null; + Lincolnian: null; + Sarcophilus: null; + antimachinery: null; + coldish: null; + crantara: null; + distinguishing: null; + elytroposis: null; + gentianwort: null; + heliosis: null; + instrumental: null; + introinflection: null; + kala: null; + metad: null; + swingingly: null; + unconformity: null; + undecreed: null; + venerable: null; + vowellessness: null; +} + +export type Untasked = null[] | number | { [key: string]: number }; + +export type Unvarying = boolean | number | { [key: string]: number }; + +export type Vehemently = null[] | boolean | null; + +export type Whitepot = QuebrachineClass | number; + +export type WrothyElement = null[] | WrothyClass; + +export type WrothyClass = { + Aeschynanthus: null; + Ephesine: null; + aquiferous: null; + cheapener: null; + enumeration: null; + escadrille: null; + estrous: null; + interestedly: null; + katakinetomer: null; + mortification: null; + morula: null; + orthosymmetrical: null; + overbark: null; + politist: null; + qualified: null; + sphenomalar: null; + throatful: null; + transhumance: null; + triandrian: null; + unbooked: null; +} + +// 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("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) + : 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 i(typ: any) { + return { integer: typ }; +} + +function p(pattern: any) { + return { pattern }; +} + +function s(typ: any, min: any, max: any) { + return { string: typ, min, max }; +} + +function n(typ: any, min: any, max: any) { + return { number: typ, min, max }; +} + +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: "protrusive", js: "protrusive", typ: a(u(a(u(i(0), null)), 3.14)) }, + { json: "pulpitism", js: "pulpitism", typ: a(u(a(i(0)), r("PulpitismClass"), 3.14)) }, + { json: "pyodermia", js: "pyodermia", typ: a(u(r("PyodermiaClass"), i(0))) }, + { json: "quebrachine", js: "quebrachine", typ: a(u(true, r("QuebrachineClass"), null)) }, + { json: "querier", js: "querier", typ: a(u(true, m(i(0)))) }, + { json: "rebarbative", js: "rebarbative", typ: a(u(a(i(0)), true, 3.14)) }, + { json: "reimagine", js: "reimagine", typ: a(r("Reimagine")) }, + { json: "ressaut", js: "ressaut", typ: r("Ressaut") }, + { json: "retrocervical", js: "retrocervical", typ: a(u(a(u(i(0), null)), i(0))) }, + { json: "revert", js: "revert", typ: a(u(true, "")) }, + { json: "rewrite", js: "rewrite", typ: a(u(a(null), r("RewriteClass"), 3.14)) }, + { json: "saccoderm", js: "saccoderm", typ: a(u(a(i(0)), null, "")) }, + { json: "santir", js: "santir", typ: a(u(r("SantirClass"), 3.14)) }, + { json: "saprophilous", js: "saprophilous", typ: a(u(m(i(0)), null, "")) }, + { json: "saxten", js: "saxten", typ: a(u(r("SaxtenClass"), "")) }, + { json: "scatty", js: "scatty", typ: a(u(r("Scatty"), null)) }, + { json: "scoffer", js: "scoffer", typ: a(u(a(null), m(i(0)), null)) }, + { json: "scrampum", js: "scrampum", typ: a(u(a(i(0)), true, null)) }, + { json: "semantic", js: "semantic", typ: 3.14 }, + { json: "serpentinic", js: "serpentinic", typ: a(u(a(i(0)), 3.14)) }, + { json: "shadowable", js: "shadowable", typ: a(u(a(u(i(0), null)), true)) }, + { json: "sistering", js: "sistering", typ: a(u(a(null), r("SisteringClass"), i(0))) }, + { json: "staghunting", js: "staghunting", typ: a(r("Staghunting")) }, + { json: "stagmometer", js: "stagmometer", typ: a(u(a(u(i(0), null)), "")) }, + { json: "stimulability", js: "stimulability", typ: a(u(true, i(0), m(i(0)))) }, + { json: "strangleable", js: "strangleable", typ: a(u(a(null), 3.14)) }, + { json: "strenuosity", js: "strenuosity", typ: a(u(a(null), r("StrenuosityClass"))) }, + { json: "tabaxir", js: "tabaxir", typ: a(u(true, 3.14)) }, + { json: "talpiform", js: "talpiform", typ: a(u(r("QuebrachineClass"), 3.14, null)) }, + { json: "thwack", js: "thwack", typ: a(u(true, r("QuebrachineClass"), 3.14)) }, + { json: "to", js: "to", typ: a(u(3.14, null)) }, + { json: "tortricine", js: "tortricine", typ: a(u(a(u(i(0), null)), r("QuebrachineClass"))) }, + { json: "truantcy", js: "truantcy", typ: a(u(true, r("TruantcyClass"))) }, + { json: "turgesce", js: "turgesce", typ: a("") }, + { json: "unbeginning", js: "unbeginning", typ: a(u(a(null), m(i(0)), "")) }, + { json: "underdunged", js: "underdunged", typ: a(3.14) }, + { json: "undesirability", js: "undesirability", typ: a(u(a(i(0)), m(i(0)), "")) }, + { json: "unerasing", js: "unerasing", typ: a(u(a(null), i(0), m(i(0)))) }, + { json: "unguentarium", js: "unguentarium", typ: a(u(a(null), i(0), null)) }, + { json: "unimpeachably", js: "unimpeachably", typ: a(u(true, r("UnimpeachablyClass"))) }, + { json: "unmortgaged", js: "unmortgaged", typ: a(u(3.14, m(i(0)), null)) }, + { json: "unobstructed", js: "unobstructed", typ: a(u(r("QuebrachineClass"), i(0), null)) }, + { json: "unreceptivity", js: "unreceptivity", typ: a(u(a(null), i(0), "")) }, + { json: "unsatisfactoriness", js: "unsatisfactoriness", typ: a(u(a(i(0)), true, i(0))) }, + { json: "unsecurity", js: "unsecurity", typ: a(i(0)) }, + { json: "unstressed", js: "unstressed", typ: a(u(true, r("UnstressedClass"), "")) }, + { json: "untasked", js: "untasked", typ: a(u(a(null), 3.14, m(i(0)))) }, + { json: "unvarying", js: "unvarying", typ: a(u(true, 3.14, m(i(0)))) }, + { json: "vehemently", js: "vehemently", typ: a(u(a(null), true, null)) }, + { json: "warriorship", js: "warriorship", typ: m(true) }, + { json: "whitepot", js: "whitepot", typ: a(u(r("QuebrachineClass"), 3.14)) }, + { json: "wrothy", js: "wrothy", typ: a(u(a(null), r("WrothyClass"))) }, + ], false), + "PulpitismClass": o([ + { json: "abnet", js: "abnet", typ: null }, + { json: "buckhorn", js: "buckhorn", typ: null }, + { json: "calciform", js: "calciform", typ: null }, + { json: "chelophore", js: "chelophore", typ: null }, + { json: "cogitation", js: "cogitation", typ: null }, + { json: "decreeable", js: "decreeable", typ: null }, + { json: "despicable", js: "despicable", typ: null }, + { json: "isodiazo", js: "isodiazo", typ: null }, + { json: "jadedly", js: "jadedly", typ: null }, + { json: "leptochlorite", js: "leptochlorite", typ: null }, + { json: "nursling", js: "nursling", typ: null }, + { json: "palamedean", js: "palamedean", typ: null }, + { json: "photoheliograph", js: "photoheliograph", typ: null }, + { json: "pipewood", js: "pipewood", typ: null }, + { json: "roberd", js: "roberd", typ: null }, + { json: "statable", js: "statable", typ: null }, + { json: "superassume", js: "superassume", typ: null }, + { json: "syllabe", js: "syllabe", typ: null }, + { json: "toughhead", js: "toughhead", typ: null }, + { json: "underburn", js: "underburn", typ: null }, + ], false), + "PyodermiaClass": o([ + { json: "Gyppo", js: "Gyppo", typ: null }, + { json: "aphoristically", js: "aphoristically", typ: null }, + { json: "apophyllous", js: "apophyllous", typ: null }, + { json: "cognize", js: "cognize", typ: null }, + { json: "dermonosology", js: "dermonosology", typ: null }, + { json: "ither", js: "ither", typ: null }, + { json: "juglandaceous", js: "juglandaceous", typ: null }, + { json: "litho", js: "litho", typ: null }, + { json: "macropterous", js: "macropterous", typ: null }, + { json: "photographer", js: "photographer", typ: null }, + { json: "romancing", js: "romancing", typ: null }, + { json: "rumness", js: "rumness", typ: null }, + { json: "somniloquist", js: "somniloquist", typ: null }, + { json: "stressfully", js: "stressfully", typ: null }, + { json: "tactically", js: "tactically", typ: null }, + { json: "tracheophony", js: "tracheophony", typ: null }, + { json: "unappositely", js: "unappositely", typ: null }, + { json: "unclothedly", js: "unclothedly", typ: null }, + { json: "unimplied", js: "unimplied", typ: null }, + { json: "unsyncopated", js: "unsyncopated", typ: null }, + ], false), + "QuebrachineClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: i(0) }, + { json: "catharticalness", js: "catharticalness", typ: 3.14 }, + { json: "disdiapason", js: "disdiapason", typ: "" }, + { json: "homocerc", js: "homocerc", typ: true }, + { json: "nonbookish", js: "nonbookish", typ: null }, + ], false), + "Reimagine": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Hermo", js: "Hermo", typ: u(undefined, null) }, + { json: "adducible", js: "adducible", typ: u(undefined, null) }, + { json: "anabolin", js: "anabolin", typ: u(undefined, null) }, + { json: "brainy", js: "brainy", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "chrysamine", js: "chrysamine", typ: u(undefined, null) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "fluxweed", js: "fluxweed", typ: u(undefined, null) }, + { json: "glaucine", js: "glaucine", typ: u(undefined, null) }, + { json: "grobianism", js: "grobianism", typ: u(undefined, null) }, + { json: "hieroglyphist", js: "hieroglyphist", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "icteroid", js: "icteroid", typ: u(undefined, null) }, + { json: "immortal", js: "immortal", typ: u(undefined, null) }, + { json: "impetulant", js: "impetulant", typ: u(undefined, null) }, + { json: "irrigate", js: "irrigate", typ: u(undefined, null) }, + { json: "myxedema", js: "myxedema", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "onyx", js: "onyx", typ: u(undefined, null) }, + { json: "repasser", js: "repasser", typ: u(undefined, null) }, + { json: "septomarginal", js: "septomarginal", typ: u(undefined, null) }, + { json: "subdie", js: "subdie", typ: u(undefined, null) }, + { json: "tibiometatarsal", js: "tibiometatarsal", typ: u(undefined, null) }, + { json: "waltzlike", js: "waltzlike", typ: u(undefined, null) }, + ], false), + "Ressaut": o([ + { json: "Freesia", js: "Freesia", typ: "" }, + { json: "Genevieve", js: "Genevieve", typ: "" }, + { json: "Mimosaceae", js: "Mimosaceae", typ: "" }, + { json: "Theopaschitism", js: "Theopaschitism", typ: "" }, + { json: "apperceptive", js: "apperceptive", typ: "" }, + { json: "cuttoo", js: "cuttoo", typ: "" }, + { json: "douser", js: "douser", typ: "" }, + { json: "drinkproof", js: "drinkproof", typ: "" }, + { json: "forementioned", js: "forementioned", typ: "" }, + { json: "hyperdiabolical", js: "hyperdiabolical", typ: "" }, + { json: "hypocone", js: "hypocone", typ: "" }, + { json: "irreverentially", js: "irreverentially", typ: "" }, + { json: "jumart", js: "jumart", typ: "" }, + { json: "mollicrush", js: "mollicrush", typ: "" }, + { json: "nedder", js: "nedder", typ: "" }, + { json: "retinasphalt", js: "retinasphalt", typ: "" }, + { json: "sough", js: "sough", typ: "" }, + { json: "steading", js: "steading", typ: "" }, + { json: "undurableness", js: "undurableness", typ: "" }, + { json: "unmingleable", js: "unmingleable", typ: "" }, + ], false), + "RewriteClass": o([ + { json: "Hyades", js: "Hyades", typ: null }, + { json: "Ptenoglossa", js: "Ptenoglossa", typ: null }, + { json: "Whiggification", js: "Whiggification", typ: null }, + { json: "accountancy", js: "accountancy", typ: null }, + { json: "cacotrophic", js: "cacotrophic", typ: null }, + { json: "contest", js: "contest", typ: null }, + { json: "couthily", js: "couthily", typ: null }, + { json: "falculate", js: "falculate", typ: null }, + { json: "foreseize", js: "foreseize", typ: null }, + { json: "lemnad", js: "lemnad", typ: null }, + { json: "monotheistically", js: "monotheistically", typ: null }, + { json: "nonflying", js: "nonflying", typ: null }, + { json: "repatch", js: "repatch", typ: null }, + { json: "rodman", js: "rodman", typ: null }, + { json: "strung", js: "strung", typ: null }, + { json: "titmal", js: "titmal", typ: null }, + { json: "twalpennyworth", js: "twalpennyworth", typ: null }, + { json: "unblamable", js: "unblamable", typ: null }, + { json: "vertical", js: "vertical", typ: null }, + { json: "yardman", js: "yardman", typ: null }, + ], false), + "SantirClass": o([ + { json: "Suessiones", js: "Suessiones", typ: null }, + { json: "admiredly", js: "admiredly", typ: null }, + { json: "demicaponier", js: "demicaponier", typ: null }, + { json: "epitympanic", js: "epitympanic", typ: null }, + { json: "investitor", js: "investitor", typ: null }, + { json: "lupiform", js: "lupiform", typ: null }, + { json: "monoflagellate", js: "monoflagellate", typ: null }, + { json: "paleoethnic", js: "paleoethnic", typ: null }, + { json: "prediscountable", js: "prediscountable", typ: null }, + { json: "rhetoricals", js: "rhetoricals", typ: null }, + { json: "roomth", js: "roomth", typ: null }, + { json: "saccharose", js: "saccharose", typ: null }, + { json: "septonasal", js: "septonasal", typ: null }, + { json: "serpenticide", js: "serpenticide", typ: null }, + { json: "setarious", js: "setarious", typ: null }, + { json: "spaework", js: "spaework", typ: null }, + { json: "stylite", js: "stylite", typ: null }, + { json: "timelily", js: "timelily", typ: null }, + { json: "unprofaned", js: "unprofaned", typ: null }, + { json: "vorticular", js: "vorticular", typ: null }, + ], false), + "SaxtenClass": o([ + { json: "Centaurid", js: "Centaurid", typ: u(undefined, null) }, + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "algarrobilla", js: "algarrobilla", typ: u(undefined, null) }, + { json: "bowgrace", js: "bowgrace", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "flix", js: "flix", typ: u(undefined, null) }, + { json: "germanely", js: "germanely", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "inhume", js: "inhume", typ: u(undefined, null) }, + { json: "lepidote", js: "lepidote", typ: u(undefined, null) }, + { json: "megalochirous", js: "megalochirous", typ: u(undefined, null) }, + { json: "ninepenny", js: "ninepenny", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "nondeist", js: "nondeist", typ: u(undefined, null) }, + { json: "nymphaeaceous", js: "nymphaeaceous", typ: u(undefined, null) }, + { json: "parietofrontal", js: "parietofrontal", typ: u(undefined, null) }, + { json: "sancyite", js: "sancyite", typ: u(undefined, null) }, + { json: "subjectivist", js: "subjectivist", typ: u(undefined, null) }, + { json: "tibiad", js: "tibiad", typ: u(undefined, null) }, + { json: "transonic", js: "transonic", typ: u(undefined, null) }, + { json: "tripetalous", js: "tripetalous", typ: u(undefined, null) }, + { json: "trunchman", js: "trunchman", typ: u(undefined, null) }, + { json: "urger", js: "urger", typ: u(undefined, null) }, + { json: "withdrawnness", js: "withdrawnness", typ: u(undefined, null) }, + ], false), + "Scatty": o([ + { json: "Tabasco", js: "Tabasco", typ: null }, + { json: "aeriferous", js: "aeriferous", typ: null }, + { json: "antical", js: "antical", typ: null }, + { json: "antighostism", js: "antighostism", typ: null }, + { json: "arcanum", js: "arcanum", typ: null }, + { json: "autotrophy", js: "autotrophy", typ: null }, + { json: "baronial", js: "baronial", typ: null }, + { json: "caffeine", js: "caffeine", typ: null }, + { json: "gorgoniacean", js: "gorgoniacean", typ: null }, + { json: "heroical", js: "heroical", typ: null }, + { json: "hydropical", js: "hydropical", typ: null }, + { json: "mechanology", js: "mechanology", typ: null }, + { json: "musicopoetic", js: "musicopoetic", typ: null }, + { json: "officiality", js: "officiality", typ: null }, + { json: "oftentimes", js: "oftentimes", typ: null }, + { json: "ophthalmotonometer", js: "ophthalmotonometer", typ: null }, + { json: "reflectively", js: "reflectively", typ: null }, + { json: "springer", js: "springer", typ: null }, + { json: "teleianthous", js: "teleianthous", typ: null }, + { json: "uncombated", js: "uncombated", typ: null }, + ], false), + "SisteringClass": o([ + { json: "Chianti", js: "Chianti", typ: null }, + { json: "Haplomi", js: "Haplomi", typ: null }, + { json: "Micropterygidae", js: "Micropterygidae", typ: null }, + { json: "amphicarpic", js: "amphicarpic", typ: null }, + { json: "frigorific", js: "frigorific", typ: null }, + { json: "hyperkinesis", js: "hyperkinesis", typ: null }, + { json: "laudable", js: "laudable", typ: null }, + { json: "madwoman", js: "madwoman", typ: null }, + { json: "maimedly", js: "maimedly", typ: null }, + { json: "microrhabdus", js: "microrhabdus", typ: null }, + { json: "nondense", js: "nondense", typ: null }, + { json: "phlebemphraxis", js: "phlebemphraxis", typ: null }, + { json: "redsear", js: "redsear", typ: null }, + { json: "schismatical", js: "schismatical", typ: null }, + { json: "tartryl", js: "tartryl", typ: null }, + { json: "unabhorred", js: "unabhorred", typ: null }, + { json: "undeliberateness", js: "undeliberateness", typ: null }, + { json: "unmixable", js: "unmixable", typ: null }, + { json: "untruckling", js: "untruckling", typ: null }, + { json: "vineal", js: "vineal", typ: null }, + ], false), + "Staghunting": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "calorimetric", js: "calorimetric", typ: u(undefined, i(0)) }, + { json: "canid", js: "canid", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "ditriglyphic", js: "ditriglyphic", typ: u(undefined, i(0)) }, + { json: "floriferousness", js: "floriferousness", typ: u(undefined, i(0)) }, + { json: "gamelike", js: "gamelike", typ: u(undefined, i(0)) }, + { json: "grig", js: "grig", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "interloan", js: "interloan", typ: u(undefined, i(0)) }, + { json: "lithotomy", js: "lithotomy", typ: u(undefined, i(0)) }, + { json: "loric", js: "loric", typ: u(undefined, i(0)) }, + { json: "membranocoriaceous", js: "membranocoriaceous", typ: u(undefined, i(0)) }, + { json: "membranogenic", js: "membranogenic", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "overtrump", js: "overtrump", typ: u(undefined, i(0)) }, + { json: "scotino", js: "scotino", typ: u(undefined, i(0)) }, + { json: "seasonable", js: "seasonable", typ: u(undefined, i(0)) }, + { json: "sephen", js: "sephen", typ: u(undefined, i(0)) }, + { json: "stigmarioid", js: "stigmarioid", typ: u(undefined, i(0)) }, + { json: "tired", js: "tired", typ: u(undefined, i(0)) }, + { json: "trifid", js: "trifid", typ: u(undefined, i(0)) }, + { json: "undefeatedly", js: "undefeatedly", typ: u(undefined, i(0)) }, + { json: "ungirlish", js: "ungirlish", typ: u(undefined, i(0)) }, + ], false), + "StrenuosityClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Onopordon", js: "Onopordon", typ: u(undefined, i(0)) }, + { json: "Sodomite", js: "Sodomite", typ: u(undefined, i(0)) }, + { json: "Yankeeist", js: "Yankeeist", typ: u(undefined, i(0)) }, + { json: "bliss", js: "bliss", typ: u(undefined, i(0)) }, + { json: "buccate", js: "buccate", typ: u(undefined, i(0)) }, + { json: "bulletproof", js: "bulletproof", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "crumblingness", js: "crumblingness", typ: u(undefined, i(0)) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "engagedly", js: "engagedly", typ: u(undefined, i(0)) }, + { json: "fightable", js: "fightable", typ: u(undefined, i(0)) }, + { json: "hoariness", js: "hoariness", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "hypopodium", js: "hypopodium", typ: u(undefined, i(0)) }, + { json: "luxurist", js: "luxurist", typ: u(undefined, i(0)) }, + { json: "mechanician", js: "mechanician", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "podgily", js: "podgily", typ: u(undefined, i(0)) }, + { json: "reformableness", js: "reformableness", typ: u(undefined, i(0)) }, + { json: "scatterbrains", js: "scatterbrains", typ: u(undefined, i(0)) }, + { json: "seminuria", js: "seminuria", typ: u(undefined, i(0)) }, + { json: "tramp", js: "tramp", typ: u(undefined, i(0)) }, + { json: "undueness", js: "undueness", typ: u(undefined, i(0)) }, + { json: "worthily", js: "worthily", typ: u(undefined, i(0)) }, + ], false), + "TruantcyClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Epeira", js: "Epeira", typ: u(undefined, null) }, + { json: "Eurylaimi", js: "Eurylaimi", typ: u(undefined, null) }, + { json: "Yuman", js: "Yuman", typ: u(undefined, null) }, + { json: "alfiona", js: "alfiona", typ: u(undefined, null) }, + { json: "ascaridiasis", js: "ascaridiasis", typ: u(undefined, null) }, + { json: "bungey", js: "bungey", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "ceroxyle", js: "ceroxyle", typ: u(undefined, null) }, + { json: "chorology", js: "chorology", typ: u(undefined, null) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "enmarble", js: "enmarble", typ: u(undefined, null) }, + { json: "germination", js: "germination", typ: u(undefined, null) }, + { json: "hallelujah", js: "hallelujah", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "lev", js: "lev", typ: u(undefined, null) }, + { json: "mouthing", js: "mouthing", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "philliloo", js: "philliloo", typ: u(undefined, null) }, + { json: "planetal", js: "planetal", typ: u(undefined, null) }, + { json: "poney", js: "poney", typ: u(undefined, null) }, + { json: "punctualist", js: "punctualist", typ: u(undefined, null) }, + { json: "returnlessly", js: "returnlessly", typ: u(undefined, null) }, + { json: "skelder", js: "skelder", typ: u(undefined, null) }, + { json: "windwaywardly", js: "windwaywardly", typ: u(undefined, null) }, + ], false), + "UnimpeachablyClass": o([ + { json: "Bobadil", js: "Bobadil", typ: u(undefined, i(0)) }, + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Quiina", js: "Quiina", typ: u(undefined, i(0)) }, + { json: "Robert", js: "Robert", typ: u(undefined, i(0)) }, + { json: "acerin", js: "acerin", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "chlorophylligenous", js: "chlorophylligenous", typ: u(undefined, i(0)) }, + { json: "conversational", js: "conversational", typ: u(undefined, i(0)) }, + { json: "demiowl", js: "demiowl", typ: u(undefined, i(0)) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "ectorhinal", js: "ectorhinal", typ: u(undefined, i(0)) }, + { json: "gamblesomeness", js: "gamblesomeness", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "irrorate", js: "irrorate", typ: u(undefined, i(0)) }, + { json: "kindergartening", js: "kindergartening", typ: u(undefined, i(0)) }, + { json: "lateritic", js: "lateritic", typ: u(undefined, i(0)) }, + { json: "mespil", js: "mespil", typ: u(undefined, i(0)) }, + { json: "misconfiguration", js: "misconfiguration", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "planometry", js: "planometry", typ: u(undefined, i(0)) }, + { json: "rot", js: "rot", typ: u(undefined, i(0)) }, + { json: "subcinctorium", js: "subcinctorium", typ: u(undefined, i(0)) }, + { json: "tussocker", js: "tussocker", typ: u(undefined, i(0)) }, + { json: "ultraproud", js: "ultraproud", typ: u(undefined, i(0)) }, + { json: "unsuggestedness", js: "unsuggestedness", typ: u(undefined, i(0)) }, + ], false), + "UnstressedClass": o([ + { json: "Alain", js: "Alain", typ: null }, + { json: "Amphirhina", js: "Amphirhina", typ: null }, + { json: "Lincolnian", js: "Lincolnian", typ: null }, + { json: "Sarcophilus", js: "Sarcophilus", typ: null }, + { json: "antimachinery", js: "antimachinery", typ: null }, + { json: "coldish", js: "coldish", typ: null }, + { json: "crantara", js: "crantara", typ: null }, + { json: "distinguishing", js: "distinguishing", typ: null }, + { json: "elytroposis", js: "elytroposis", typ: null }, + { json: "gentianwort", js: "gentianwort", typ: null }, + { json: "heliosis", js: "heliosis", typ: null }, + { json: "instrumental", js: "instrumental", typ: null }, + { json: "introinflection", js: "introinflection", typ: null }, + { json: "kala", js: "kala", typ: null }, + { json: "metad", js: "metad", typ: null }, + { json: "swingingly", js: "swingingly", typ: null }, + { json: "unconformity", js: "unconformity", typ: null }, + { json: "undecreed", js: "undecreed", typ: null }, + { json: "venerable", js: "venerable", typ: null }, + { json: "vowellessness", js: "vowellessness", typ: null }, + ], false), + "WrothyClass": o([ + { json: "Aeschynanthus", js: "Aeschynanthus", typ: null }, + { json: "Ephesine", js: "Ephesine", typ: null }, + { json: "aquiferous", js: "aquiferous", typ: null }, + { json: "cheapener", js: "cheapener", typ: null }, + { json: "enumeration", js: "enumeration", typ: null }, + { json: "escadrille", js: "escadrille", typ: null }, + { json: "estrous", js: "estrous", typ: null }, + { json: "interestedly", js: "interestedly", typ: null }, + { json: "katakinetomer", js: "katakinetomer", typ: null }, + { json: "mortification", js: "mortification", typ: null }, + { json: "morula", js: "morula", typ: null }, + { json: "orthosymmetrical", js: "orthosymmetrical", typ: null }, + { json: "overbark", js: "overbark", typ: null }, + { json: "politist", js: "politist", typ: null }, + { json: "qualified", js: "qualified", typ: null }, + { json: "sphenomalar", js: "sphenomalar", typ: null }, + { json: "throatful", js: "throatful", typ: null }, + { json: "transhumance", js: "transhumance", typ: null }, + { json: "triandrian", js: "triandrian", typ: null }, + { json: "unbooked", js: "unbooked", typ: null }, + ], false), +}; diff --git a/base/typescript/test/inputs/json/priority/keywords.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/keywords.json/default/TopLevel.ts index 1f4c69d..30a7bb2 100644 --- a/base/typescript/test/inputs/json/priority/keywords.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/keywords.json/default/TopLevel.ts @@ -1026,6 +1026,7 @@ export interface Obj4 { rethrows: Rethrows; return: Return; right: Right; + s: S; sbyte: Sbyte; sealed: Sealed; select: Select; @@ -1155,6 +1156,10 @@ export interface Right { right: number; } +export interface S { + s: number; +} + export interface Sbyte { sbyte: number; } @@ -2438,6 +2443,7 @@ const typeMap: any = { { json: "rethrows", js: "rethrows", typ: r("Rethrows") }, { json: "return", js: "return", typ: r("Return") }, { json: "right", js: "right", typ: r("Right") }, + { json: "s", js: "s", typ: r("S") }, { json: "sbyte", js: "sbyte", typ: r("Sbyte") }, { json: "sealed", js: "sealed", typ: r("Sealed") }, { json: "select", js: "select", typ: r("Select") }, @@ -2545,6 +2551,9 @@ const typeMap: any = { "Right": o([ { json: "right", js: "right", typ: i(0) }, ], false), + "S": o([ + { json: "s", js: "s", typ: i(0) }, + ], false), "Sbyte": o([ { json: "sbyte", js: "sbyte", typ: i(0) }, ], false), diff --git a/base/typescript/test/inputs/json/samples/pokedex.json/prefer-types-true--df33e18681f9/TopLevel.ts b/base/typescript/test/inputs/json/samples/pokedex.json/prefer-types-true--df33e18681f9/TopLevel.ts deleted file mode 100644 index d496091..0000000 --- a/base/typescript/test/inputs/json/samples/pokedex.json/prefer-types-true--df33e18681f9/TopLevel.ts +++ /dev/null @@ -1,283 +0,0 @@ -// 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 type TopLevel = { - pokemon: Pokemon[]; -} - -export type Pokemon = { - avg_spawns: number; - candy: string; - candy_count?: number; - egg: Egg; - height: string; - id: number; - img: string; - multipliers: number[] | null; - name: string; - next_evolution?: Evolution[]; - num: string; - prev_evolution?: Evolution[]; - spawn_chance: number; - spawn_time: string; - type: Type[]; - weaknesses: Type[]; - weight: string; -} - -export type Egg = "2 km" | "Not in Eggs" | "5 km" | "10 km" | "Omanyte Candy"; - -export type Evolution = { - name: string; - num: string; -} - -export type Type = "Fire" | "Ice" | "Flying" | "Psychic" | "Water" | "Ground" | "Rock" | "Electric" | "Grass" | "Fighting" | "Poison" | "Bug" | "Fairy" | "Ghost" | "Dark" | "Steel" | "Dragon" | "Normal"; - -// 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("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) - : 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 i(typ: any) { - return { integer: typ }; -} - -function p(pattern: any) { - return { pattern }; -} - -function s(typ: any, min: any, max: any) { - return { string: typ, min, max }; -} - -function n(typ: any, min: any, max: any) { - return { number: typ, min, max }; -} - -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: "pokemon", js: "pokemon", typ: a(r("Pokemon")) }, - ], false), - "Pokemon": o([ - { json: "avg_spawns", js: "avg_spawns", typ: 3.14 }, - { json: "candy", js: "candy", typ: "" }, - { json: "candy_count", js: "candy_count", typ: u(undefined, i(0)) }, - { json: "egg", js: "egg", typ: r("Egg") }, - { json: "height", js: "height", typ: "" }, - { json: "id", js: "id", typ: i(0) }, - { json: "img", js: "img", typ: "" }, - { json: "multipliers", js: "multipliers", typ: u(a(3.14), null) }, - { json: "name", js: "name", typ: "" }, - { json: "next_evolution", js: "next_evolution", typ: u(undefined, a(r("Evolution"))) }, - { json: "num", js: "num", typ: "" }, - { json: "prev_evolution", js: "prev_evolution", typ: u(undefined, a(r("Evolution"))) }, - { json: "spawn_chance", js: "spawn_chance", typ: 3.14 }, - { json: "spawn_time", js: "spawn_time", typ: "" }, - { json: "type", js: "type", typ: a(r("Type")) }, - { json: "weaknesses", js: "weaknesses", typ: a(r("Type")) }, - { json: "weight", js: "weight", typ: "" }, - ], false), - "Evolution": o([ - { json: "name", js: "name", typ: "" }, - { json: "num", js: "num", typ: "" }, - ], false), - "Egg": [ - "2 km", - "Not in Eggs", - "5 km", - "10 km", - "Omanyte Candy", - ], - "Type": [ - "Fire", - "Ice", - "Flying", - "Psychic", - "Water", - "Ground", - "Rock", - "Electric", - "Grass", - "Fighting", - "Poison", - "Bug", - "Fairy", - "Ghost", - "Dark", - "Steel", - "Dragon", - "Normal", - ], -}; diff --git a/base/typescript-effect-schema/test/inputs/json/priority/keywords.json/default/TopLevel.ts b/head/typescript-effect-schema/test/inputs/json/priority/keywords.json/default/TopLevel.ts index e8faeb6..0f915b5 100644 --- a/base/typescript-effect-schema/test/inputs/json/priority/keywords.json/default/TopLevel.ts +++ b/head/typescript-effect-schema/test/inputs/json/priority/keywords.json/default/TopLevel.ts @@ -281,6 +281,10 @@ export class Sbyte extends S.Class("Sbyte")({ "sbyte": S.Int, }) {} +export class SClass extends S.Class("SClass")({ + "s": S.Int, +}) {} + export class Right extends S.Class("Right")({ "right": S.Int, }) {} @@ -383,6 +387,7 @@ export class Obj4 extends S.Class("Obj4")({ "rethrows": Rethrows, "return": Return, "right": Right, + "s": SClass, "sbyte": Sbyte, "sealed": Sealed, "SEL": Sel, diff --git a/base/typescript-zod/test/inputs/json/priority/keywords.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/keywords.json/default/TopLevel.ts index 2950ede..dd2c523 100644 --- a/base/typescript-zod/test/inputs/json/priority/keywords.json/default/TopLevel.ts +++ b/head/typescript-zod/test/inputs/json/priority/keywords.json/default/TopLevel.ts @@ -1076,6 +1076,11 @@ export const RightSchema = z.object({ }); export type Right = z.infer; +export const SSchema = z.object({ + "s": z.number().int(), +}); +export type S = z.infer; + export const SbyteSchema = z.object({ "sbyte": z.number().int(), }); @@ -1628,6 +1633,7 @@ export const Obj4Schema = z.object({ "rethrows": RethrowsSchema, "return": ReturnSchema, "right": RightSchema, + "s": SSchema, "sbyte": SbyteSchema, "sealed": SealedSchema, "SEL": SelSchema,