Generated-output differences

quicktype output changed between the PR base and tested PR merge revisions.
← Back to the pull request
6test cases
23files differ
0modified
20new
3deleted
40,249changed lines
+39,765 −484insertions / deletions
Base 28016cf15bb36300a7cb8ef21440bab3c8cfa690 · PR merge 9fede2517d17353c521b9d889e6015873007fa65 · Head 1965d78ee89fa965a13c60a3c7e50a8ee94a25f1 · raw patch
Test case

test/inputs/json/priority/combinations1.json

5 generated files · +9,251 −0
Adartfrom-map-true--d222f65b3fee / TopLevel.dart+1,329 −0
@@ -0,0 +1,1329 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromMap(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toMap());
10+
11+class TopLevel {
12+ final String centrodesmose;
13+ final List<dynamic> cerograph;
14+ final List<dynamic> chemotherapeutics;
15+ final List<dynamic> cimelia;
16+ final int citrated;
17+ final List<dynamic> clinodome;
18+ final List<dynamic> coadjust;
19+ final List<dynamic> consilience;
20+ final List<dynamic> constructor;
21+ final List<dynamic> continuative;
22+ final List<dynamic> credulity;
23+ final List<dynamic> creviced;
24+ final List<List<int?>> cubiculum;
25+ final List<dynamic> deruralize;
26+ final List<dynamic> diaereses;
27+ final List<List<dynamic>?> dissolution;
28+ final List<dynamic> downstroke;
29+ final List<double?> electrotautomerism;
30+ final List<dynamic> eleutheromania;
31+ final Encrust encrust;
32+ final List<dynamic> entomoid;
33+ final List<dynamic> epipaleolithic;
34+ final List<dynamic> expropriable;
35+ final List<dynamic> faggingly;
36+ final List<dynamic> fenks;
37+ final List<dynamic> flagmaking;
38+ final List<dynamic> fluorometer;
39+ final List<int?> fulsome;
40+ final List<dynamic> fuzzy;
41+ final List<dynamic> gardenwards;
42+ final List<dynamic> generalissimo;
43+ final List<Map<String, int>?> habeas;
44+ final List<dynamic> hemicrystalline;
45+ final List<dynamic> hemocoele;
46+ final List<dynamic> hoister;
47+ final List<dynamic> hyperpiesis;
48+ final List<dynamic> hyppish;
49+ final List<dynamic> idealizer;
50+ final List<dynamic> incrustator;
51+ final List<dynamic> intentiveness;
52+ final Interacinar interacinar;
53+ final List<List<int>?> intercorrelation;
54+ final List<dynamic> jacutinga;
55+
56+ TopLevel({
57+ required this.centrodesmose,
58+ required this.cerograph,
59+ required this.chemotherapeutics,
60+ required this.cimelia,
61+ required this.citrated,
62+ required this.clinodome,
63+ required this.coadjust,
64+ required this.consilience,
65+ required this.constructor,
66+ required this.continuative,
67+ required this.credulity,
68+ required this.creviced,
69+ required this.cubiculum,
70+ required this.deruralize,
71+ required this.diaereses,
72+ required this.dissolution,
73+ required this.downstroke,
74+ required this.electrotautomerism,
75+ required this.eleutheromania,
76+ required this.encrust,
77+ required this.entomoid,
78+ required this.epipaleolithic,
79+ required this.expropriable,
80+ required this.faggingly,
81+ required this.fenks,
82+ required this.flagmaking,
83+ required this.fluorometer,
84+ required this.fulsome,
85+ required this.fuzzy,
86+ required this.gardenwards,
87+ required this.generalissimo,
88+ required this.habeas,
89+ required this.hemicrystalline,
90+ required this.hemocoele,
91+ required this.hoister,
92+ required this.hyperpiesis,
93+ required this.hyppish,
94+ required this.idealizer,
95+ required this.incrustator,
96+ required this.intentiveness,
97+ required this.interacinar,
98+ required this.intercorrelation,
99+ required this.jacutinga,
100+ });
101+
102+ factory TopLevel.fromMap(Map<String, dynamic> json) => TopLevel(
103+ centrodesmose: json["centrodesmose"],
104+ cerograph: List<dynamic>.from(json["cerograph"].map((x) => x)),
105+ chemotherapeutics: List<dynamic>.from(json["chemotherapeutics"].map((x) => x)),
106+ cimelia: List<dynamic>.from(json["cimelia"].map((x) => x)),
107+ citrated: json["citrated"],
108+ clinodome: List<dynamic>.from(json["clinodome"].map((x) => x)),
109+ coadjust: List<dynamic>.from(json["coadjust"].map((x) => x)),
110+ consilience: List<dynamic>.from(json["consilience"].map((x) => x)),
111+ constructor: List<dynamic>.from(json["constructor"].map((x) => x)),
112+ continuative: List<dynamic>.from(json["continuative"].map((x) => x)),
113+ credulity: List<dynamic>.from(json["credulity"].map((x) => x)),
114+ creviced: List<dynamic>.from(json["creviced"].map((x) => x)),
115+ cubiculum: List<List<int?>>.from(json["cubiculum"].map((x) => List<int?>.from(x.map((x) => x)))),
116+ deruralize: List<dynamic>.from(json["deruralize"].map((x) => x)),
117+ diaereses: List<dynamic>.from(json["diaereses"].map((x) => x)),
118+ dissolution: List<List<dynamic>?>.from(json["dissolution"].map((x) => x == null ? null : List<dynamic>.from(x!.map((x) => x)))),
119+ downstroke: List<dynamic>.from(json["downstroke"].map((x) => x)),
120+ electrotautomerism: List<double?>.from(json["electrotautomerism"].map((x) => x?.toDouble())),
121+ eleutheromania: List<dynamic>.from(json["eleutheromania"].map((x) => x)),
122+ encrust: Encrust.fromMap(json["encrust"]),
123+ entomoid: List<dynamic>.from(json["entomoid"].map((x) => x)),
124+ epipaleolithic: List<dynamic>.from(json["epipaleolithic"].map((x) => x)),
125+ expropriable: List<dynamic>.from(json["expropriable"].map((x) => x)),
126+ faggingly: List<dynamic>.from(json["faggingly"].map((x) => x)),
127+ fenks: List<dynamic>.from(json["fenks"].map((x) => x)),
128+ flagmaking: List<dynamic>.from(json["flagmaking"].map((x) => x)),
129+ fluorometer: List<dynamic>.from(json["fluorometer"].map((x) => x)),
130+ fulsome: List<int?>.from(json["fulsome"].map((x) => x)),
131+ fuzzy: List<dynamic>.from(json["fuzzy"].map((x) => x)),
132+ gardenwards: List<dynamic>.from(json["gardenwards"].map((x) => x)),
133+ generalissimo: List<dynamic>.from(json["generalissimo"].map((x) => x)),
134+ habeas: List<Map<String, int>?>.from(json["habeas"].map((x) => x == null ? null : Map.from(x!).map((k, v) => MapEntry<String, int>(k, v)))),
135+ hemicrystalline: List<dynamic>.from(json["hemicrystalline"].map((x) => x)),
136+ hemocoele: List<dynamic>.from(json["hemocoele"].map((x) => x)),
137+ hoister: List<dynamic>.from(json["hoister"].map((x) => x)),
138+ hyperpiesis: List<dynamic>.from(json["hyperpiesis"].map((x) => x)),
139+ hyppish: List<dynamic>.from(json["hyppish"].map((x) => x)),
140+ idealizer: List<dynamic>.from(json["idealizer"].map((x) => x)),
141+ incrustator: List<dynamic>.from(json["incrustator"].map((x) => x)),
142+ intentiveness: List<dynamic>.from(json["intentiveness"].map((x) => x)),
143+ interacinar: Interacinar.fromMap(json["interacinar"]),
144+ intercorrelation: List<List<int>?>.from(json["intercorrelation"].map((x) => x == null ? null : List<int>.from(x!.map((x) => x)))),
145+ jacutinga: List<dynamic>.from(json["jacutinga"].map((x) => x)),
146+ );
147+
148+ Map<String, dynamic> toMap() => {
149+ "centrodesmose": centrodesmose,
150+ "cerograph": List<dynamic>.from(cerograph.map((x) => x)),
151+ "chemotherapeutics": List<dynamic>.from(chemotherapeutics.map((x) => x)),
152+ "cimelia": List<dynamic>.from(cimelia.map((x) => x)),
153+ "citrated": citrated,
154+ "clinodome": List<dynamic>.from(clinodome.map((x) => x)),
155+ "coadjust": List<dynamic>.from(coadjust.map((x) => x)),
156+ "consilience": List<dynamic>.from(consilience.map((x) => x)),
157+ "constructor": List<dynamic>.from(constructor.map((x) => x)),
158+ "continuative": List<dynamic>.from(continuative.map((x) => x)),
159+ "credulity": List<dynamic>.from(credulity.map((x) => x)),
160+ "creviced": List<dynamic>.from(creviced.map((x) => x)),
161+ "cubiculum": List<dynamic>.from(cubiculum.map((x) => List<dynamic>.from(x.map((x) => x)))),
162+ "deruralize": List<dynamic>.from(deruralize.map((x) => x)),
163+ "diaereses": List<dynamic>.from(diaereses.map((x) => x)),
164+ "dissolution": List<dynamic>.from(dissolution.map((x) => x == null ? null : List<dynamic>.from(x!.map((x) => x)))),
165+ "downstroke": List<dynamic>.from(downstroke.map((x) => x)),
166+ "electrotautomerism": List<dynamic>.from(electrotautomerism.map((x) => x)),
167+ "eleutheromania": List<dynamic>.from(eleutheromania.map((x) => x)),
168+ "encrust": encrust.toMap(),
169+ "entomoid": List<dynamic>.from(entomoid.map((x) => x)),
170+ "epipaleolithic": List<dynamic>.from(epipaleolithic.map((x) => x)),
171+ "expropriable": List<dynamic>.from(expropriable.map((x) => x)),
172+ "faggingly": List<dynamic>.from(faggingly.map((x) => x)),
173+ "fenks": List<dynamic>.from(fenks.map((x) => x)),
174+ "flagmaking": List<dynamic>.from(flagmaking.map((x) => x)),
175+ "fluorometer": List<dynamic>.from(fluorometer.map((x) => x)),
176+ "fulsome": List<dynamic>.from(fulsome.map((x) => x)),
177+ "fuzzy": List<dynamic>.from(fuzzy.map((x) => x)),
178+ "gardenwards": List<dynamic>.from(gardenwards.map((x) => x)),
179+ "generalissimo": List<dynamic>.from(generalissimo.map((x) => x)),
180+ "habeas": List<dynamic>.from(habeas.map((x) => x == null ? null : Map.from(x!).map((k, v) => MapEntry<String, dynamic>(k, v)))),
181+ "hemicrystalline": List<dynamic>.from(hemicrystalline.map((x) => x)),
182+ "hemocoele": List<dynamic>.from(hemocoele.map((x) => x)),
183+ "hoister": List<dynamic>.from(hoister.map((x) => x)),
184+ "hyperpiesis": List<dynamic>.from(hyperpiesis.map((x) => x)),
185+ "hyppish": List<dynamic>.from(hyppish.map((x) => x)),
186+ "idealizer": List<dynamic>.from(idealizer.map((x) => x)),
187+ "incrustator": List<dynamic>.from(incrustator.map((x) => x)),
188+ "intentiveness": List<dynamic>.from(intentiveness.map((x) => x)),
189+ "interacinar": interacinar.toMap(),
190+ "intercorrelation": List<dynamic>.from(intercorrelation.map((x) => x == null ? null : List<dynamic>.from(x!.map((x) => x)))),
191+ "jacutinga": List<dynamic>.from(jacutinga.map((x) => x)),
192+ };
193+}
194+
195+class CerographClass {
196+ final dynamic apotropaion;
197+ final dynamic casuary;
198+ final dynamic creaker;
199+ final dynamic disqualification;
200+ final dynamic imperatorious;
201+ final dynamic impermeabilize;
202+ final dynamic metastoma;
203+ final dynamic noctidiurnal;
204+ final dynamic nonreserve;
205+ final dynamic ophthalmotonometry;
206+ final dynamic pailful;
207+ final dynamic pigfish;
208+ final dynamic pongee;
209+ final dynamic prosodical;
210+ final dynamic scrofuloderm;
211+ final dynamic storekeeping;
212+ final dynamic therologist;
213+ final dynamic tolowa;
214+ final dynamic tradeful;
215+ final dynamic unriveting;
216+
217+ CerographClass({
218+ required this.apotropaion,
219+ required this.casuary,
220+ required this.creaker,
221+ required this.disqualification,
222+ required this.imperatorious,
223+ required this.impermeabilize,
224+ required this.metastoma,
225+ required this.noctidiurnal,
226+ required this.nonreserve,
227+ required this.ophthalmotonometry,
228+ required this.pailful,
229+ required this.pigfish,
230+ required this.pongee,
231+ required this.prosodical,
232+ required this.scrofuloderm,
233+ required this.storekeeping,
234+ required this.therologist,
235+ required this.tolowa,
236+ required this.tradeful,
237+ required this.unriveting,
238+ });
239+
240+ factory CerographClass.fromMap(Map<String, dynamic> json) => CerographClass(
241+ apotropaion: (json.containsKey("apotropaion") ? json["apotropaion"] : throw FormatException('Missing required property')),
242+ casuary: (json.containsKey("casuary") ? json["casuary"] : throw FormatException('Missing required property')),
243+ creaker: (json.containsKey("creaker") ? json["creaker"] : throw FormatException('Missing required property')),
244+ disqualification: (json.containsKey("disqualification") ? json["disqualification"] : throw FormatException('Missing required property')),
245+ imperatorious: (json.containsKey("imperatorious") ? json["imperatorious"] : throw FormatException('Missing required property')),
246+ impermeabilize: (json.containsKey("impermeabilize") ? json["impermeabilize"] : throw FormatException('Missing required property')),
247+ metastoma: (json.containsKey("metastoma") ? json["metastoma"] : throw FormatException('Missing required property')),
248+ noctidiurnal: (json.containsKey("noctidiurnal") ? json["noctidiurnal"] : throw FormatException('Missing required property')),
249+ nonreserve: (json.containsKey("nonreserve") ? json["nonreserve"] : throw FormatException('Missing required property')),
250+ ophthalmotonometry: (json.containsKey("ophthalmotonometry") ? json["ophthalmotonometry"] : throw FormatException('Missing required property')),
251+ pailful: (json.containsKey("pailful") ? json["pailful"] : throw FormatException('Missing required property')),
252+ pigfish: (json.containsKey("pigfish") ? json["pigfish"] : throw FormatException('Missing required property')),
253+ pongee: (json.containsKey("pongee") ? json["pongee"] : throw FormatException('Missing required property')),
254+ prosodical: (json.containsKey("prosodical") ? json["prosodical"] : throw FormatException('Missing required property')),
255+ scrofuloderm: (json.containsKey("scrofuloderm") ? json["scrofuloderm"] : throw FormatException('Missing required property')),
256+ storekeeping: (json.containsKey("storekeeping") ? json["storekeeping"] : throw FormatException('Missing required property')),
257+ therologist: (json.containsKey("therologist") ? json["therologist"] : throw FormatException('Missing required property')),
258+ tolowa: (json.containsKey("Tolowa") ? json["Tolowa"] : throw FormatException('Missing required property')),
259+ tradeful: (json.containsKey("tradeful") ? json["tradeful"] : throw FormatException('Missing required property')),
260+ unriveting: (json.containsKey("unriveting") ? json["unriveting"] : throw FormatException('Missing required property')),
261+ );
262+
263+ Map<String, dynamic> toMap() => {
264+ "apotropaion": apotropaion,
265+ "casuary": casuary,
266+ "creaker": creaker,
267+ "disqualification": disqualification,
268+ "imperatorious": imperatorious,
269+ "impermeabilize": impermeabilize,
270+ "metastoma": metastoma,
271+ "noctidiurnal": noctidiurnal,
272+ "nonreserve": nonreserve,
273+ "ophthalmotonometry": ophthalmotonometry,
274+ "pailful": pailful,
275+ "pigfish": pigfish,
276+ "pongee": pongee,
277+ "prosodical": prosodical,
278+ "scrofuloderm": scrofuloderm,
279+ "storekeeping": storekeeping,
280+ "therologist": therologist,
281+ "Tolowa": tolowa,
282+ "tradeful": tradeful,
283+ "unriveting": unriveting,
284+ };
285+}
286+
287+class ChemotherapeuticClass {
288+ final dynamic angioneurotic;
289+ final dynamic availment;
290+ final dynamic bladelet;
291+ final double? catharticalness;
292+ final dynamic caulis;
293+ final dynamic chalcus;
294+ final int? chirotherium;
295+ final String? disdiapason;
296+ final dynamic enteradenological;
297+ final bool? homocerc;
298+ final dynamic imporosity;
299+ final dynamic insistently;
300+ final dynamic intraparietal;
301+ final dynamic ivied;
302+ final dynamic maureen;
303+ final dynamic nonbookish;
304+ final dynamic nostochine;
305+ final dynamic nutcracker;
306+ final dynamic ofttimes;
307+ final dynamic phenocryst;
308+ final dynamic precoincident;
309+ final dynamic ramiferous;
310+ final dynamic stagmometer;
311+ final dynamic tetherball;
312+ final dynamic unshy;
313+
314+ ChemotherapeuticClass({
315+ this.angioneurotic,
316+ this.availment,
317+ this.bladelet,
318+ this.catharticalness,
319+ this.caulis,
320+ this.chalcus,
321+ this.chirotherium,
322+ this.disdiapason,
323+ this.enteradenological,
324+ this.homocerc,
325+ this.imporosity,
326+ this.insistently,
327+ this.intraparietal,
328+ this.ivied,
329+ this.maureen,
330+ this.nonbookish,
331+ this.nostochine,
332+ this.nutcracker,
333+ this.ofttimes,
334+ this.phenocryst,
335+ this.precoincident,
336+ this.ramiferous,
337+ this.stagmometer,
338+ this.tetherball,
339+ this.unshy,
340+ });
341+
342+ factory ChemotherapeuticClass.fromMap(Map<String, dynamic> json) => ChemotherapeuticClass(
343+ angioneurotic: json["angioneurotic"],
344+ availment: json["availment"],
345+ bladelet: json["bladelet"],
346+ catharticalness: json["catharticalness"]?.toDouble(),
347+ caulis: json["caulis"],
348+ chalcus: json["chalcus"],
349+ chirotherium: json["Chirotherium"],
350+ disdiapason: json["disdiapason"],
351+ enteradenological: json["enteradenological"],
352+ homocerc: json["homocerc"],
353+ imporosity: json["imporosity"],
354+ insistently: json["insistently"],
355+ intraparietal: json["intraparietal"],
356+ ivied: json["ivied"],
357+ maureen: json["Maureen"],
358+ nonbookish: json["nonbookish"],
359+ nostochine: json["nostochine"],
360+ nutcracker: json["nutcracker"],
361+ ofttimes: json["ofttimes"],
362+ phenocryst: json["phenocryst"],
363+ precoincident: json["precoincident"],
364+ ramiferous: json["ramiferous"],
365+ stagmometer: json["stagmometer"],
366+ tetherball: json["tetherball"],
367+ unshy: json["unshy"],
368+ );
369+
370+ Map<String, dynamic> toMap() => {
371+ "angioneurotic": angioneurotic,
372+ "availment": availment,
373+ "bladelet": bladelet,
374+ "catharticalness": catharticalness,
375+ "caulis": caulis,
376+ "chalcus": chalcus,
377+ "Chirotherium": chirotherium,
378+ "disdiapason": disdiapason,
379+ "enteradenological": enteradenological,
380+ "homocerc": homocerc,
381+ "imporosity": imporosity,
382+ "insistently": insistently,
383+ "intraparietal": intraparietal,
384+ "ivied": ivied,
385+ "Maureen": maureen,
386+ "nonbookish": nonbookish,
387+ "nostochine": nostochine,
388+ "nutcracker": nutcracker,
389+ "ofttimes": ofttimes,
390+ "phenocryst": phenocryst,
391+ "precoincident": precoincident,
392+ "ramiferous": ramiferous,
393+ "stagmometer": stagmometer,
394+ "tetherball": tetherball,
395+ "unshy": unshy,
396+ };
397+}
398+
399+class CimeliaClass {
400+ final double catharticalness;
401+ final int chirotherium;
402+ final String disdiapason;
403+ final bool homocerc;
404+ final dynamic nonbookish;
405+
406+ CimeliaClass({
407+ required this.catharticalness,
408+ required this.chirotherium,
409+ required this.disdiapason,
410+ required this.homocerc,
411+ required this.nonbookish,
412+ });
413+
414+ factory CimeliaClass.fromMap(Map<String, dynamic> json) => CimeliaClass(
415+ catharticalness: json["catharticalness"]?.toDouble(),
416+ chirotherium: json["Chirotherium"],
417+ disdiapason: json["disdiapason"],
418+ homocerc: json["homocerc"],
419+ nonbookish: (json.containsKey("nonbookish") ? json["nonbookish"] : throw FormatException('Missing required property')),
420+ );
421+
422+ Map<String, dynamic> toMap() => {
423+ "catharticalness": catharticalness,
424+ "Chirotherium": chirotherium,
425+ "disdiapason": disdiapason,
426+ "homocerc": homocerc,
427+ "nonbookish": nonbookish,
428+ };
429+}
430+
431+class CoadjustClass {
432+ final dynamic amidosulphonal;
433+ final dynamic benny;
434+ final double? catharticalness;
435+ final int? chirotherium;
436+ final String? disdiapason;
437+ final dynamic ensnare;
438+ final bool? homocerc;
439+ final dynamic hybridizer;
440+ final dynamic leastwise;
441+ final dynamic lof;
442+ final dynamic monkhood;
443+ final dynamic netherlandish;
444+ final dynamic nonbookish;
445+ final dynamic peonism;
446+ final dynamic phonelescope;
447+ final dynamic porphyrogeniture;
448+ final dynamic preindemnify;
449+ final dynamic rosal;
450+ final dynamic scalenous;
451+ final dynamic scopine;
452+ final dynamic sedaceae;
453+ final dynamic suberinize;
454+ final dynamic symbiot;
455+ final dynamic tablefellow;
456+ final dynamic unchargeable;
457+
458+ CoadjustClass({
459+ this.amidosulphonal,
460+ this.benny,
461+ this.catharticalness,
462+ this.chirotherium,
463+ this.disdiapason,
464+ this.ensnare,
465+ this.homocerc,
466+ this.hybridizer,
467+ this.leastwise,
468+ this.lof,
469+ this.monkhood,
470+ this.netherlandish,
471+ this.nonbookish,
472+ this.peonism,
473+ this.phonelescope,
474+ this.porphyrogeniture,
475+ this.preindemnify,
476+ this.rosal,
477+ this.scalenous,
478+ this.scopine,
479+ this.sedaceae,
480+ this.suberinize,
481+ this.symbiot,
482+ this.tablefellow,
483+ this.unchargeable,
484+ });
485+
486+ factory CoadjustClass.fromMap(Map<String, dynamic> json) => CoadjustClass(
487+ amidosulphonal: json["amidosulphonal"],
488+ benny: json["Benny"],
489+ catharticalness: json["catharticalness"]?.toDouble(),
490+ chirotherium: json["Chirotherium"],
491+ disdiapason: json["disdiapason"],
492+ ensnare: json["ensnare"],
493+ homocerc: json["homocerc"],
494+ hybridizer: json["hybridizer"],
495+ leastwise: json["leastwise"],
496+ lof: json["lof"],
497+ monkhood: json["monkhood"],
498+ netherlandish: json["Netherlandish"],
499+ nonbookish: json["nonbookish"],
500+ peonism: json["peonism"],
501+ phonelescope: json["Phonelescope"],
502+ porphyrogeniture: json["porphyrogeniture"],
503+ preindemnify: json["preindemnify"],
504+ rosal: json["rosal"],
505+ scalenous: json["scalenous"],
506+ scopine: json["scopine"],
507+ sedaceae: json["Sedaceae"],
508+ suberinize: json["suberinize"],
509+ symbiot: json["symbiot"],
510+ tablefellow: json["tablefellow"],
511+ unchargeable: json["unchargeable"],
512+ );
513+
514+ Map<String, dynamic> toMap() => {
515+ "amidosulphonal": amidosulphonal,
516+ "Benny": benny,
517+ "catharticalness": catharticalness,
518+ "Chirotherium": chirotherium,
519+ "disdiapason": disdiapason,
520+ "ensnare": ensnare,
521+ "homocerc": homocerc,
522+ "hybridizer": hybridizer,
523+ "leastwise": leastwise,
524+ "lof": lof,
525+ "monkhood": monkhood,
526+ "Netherlandish": netherlandish,
527+ "nonbookish": nonbookish,
528+ "peonism": peonism,
529+ "Phonelescope": phonelescope,
530+ "porphyrogeniture": porphyrogeniture,
531+ "preindemnify": preindemnify,
532+ "rosal": rosal,
533+ "scalenous": scalenous,
534+ "scopine": scopine,
535+ "Sedaceae": sedaceae,
536+ "suberinize": suberinize,
537+ "symbiot": symbiot,
538+ "tablefellow": tablefellow,
539+ "unchargeable": unchargeable,
540+ };
541+}
542+
543+class CredulityClass {
544+ final dynamic ammonolytic;
545+ final dynamic bushmaster;
546+ final dynamic considering;
547+ final dynamic consuetudinary;
548+ final dynamic embarras;
549+ final dynamic fineness;
550+ final dynamic flaithship;
551+ final dynamic flavia;
552+ final dynamic gruffly;
553+ final dynamic hedychium;
554+ final dynamic leadwort;
555+ final dynamic overseriously;
556+ final dynamic parabola;
557+ final dynamic pectinatodenticulate;
558+ final dynamic popean;
559+ final dynamic pornocrat;
560+ final dynamic quadrisect;
561+ final dynamic seriality;
562+ final dynamic vamphorn;
563+ final dynamic wharp;
564+
565+ CredulityClass({
566+ required this.ammonolytic,
567+ required this.bushmaster,
568+ required this.considering,
569+ required this.consuetudinary,
570+ required this.embarras,
571+ required this.fineness,
572+ required this.flaithship,
573+ required this.flavia,
574+ required this.gruffly,
575+ required this.hedychium,
576+ required this.leadwort,
577+ required this.overseriously,
578+ required this.parabola,
579+ required this.pectinatodenticulate,
580+ required this.popean,
581+ required this.pornocrat,
582+ required this.quadrisect,
583+ required this.seriality,
584+ required this.vamphorn,
585+ required this.wharp,
586+ });
587+
588+ factory CredulityClass.fromMap(Map<String, dynamic> json) => CredulityClass(
589+ ammonolytic: (json.containsKey("ammonolytic") ? json["ammonolytic"] : throw FormatException('Missing required property')),
590+ bushmaster: (json.containsKey("bushmaster") ? json["bushmaster"] : throw FormatException('Missing required property')),
591+ considering: (json.containsKey("considering") ? json["considering"] : throw FormatException('Missing required property')),
592+ consuetudinary: (json.containsKey("consuetudinary") ? json["consuetudinary"] : throw FormatException('Missing required property')),
593+ embarras: (json.containsKey("embarras") ? json["embarras"] : throw FormatException('Missing required property')),
594+ fineness: (json.containsKey("fineness") ? json["fineness"] : throw FormatException('Missing required property')),
595+ flaithship: (json.containsKey("flaithship") ? json["flaithship"] : throw FormatException('Missing required property')),
596+ flavia: (json.containsKey("Flavia") ? json["Flavia"] : throw FormatException('Missing required property')),
597+ gruffly: (json.containsKey("gruffly") ? json["gruffly"] : throw FormatException('Missing required property')),
598+ hedychium: (json.containsKey("Hedychium") ? json["Hedychium"] : throw FormatException('Missing required property')),
599+ leadwort: (json.containsKey("leadwort") ? json["leadwort"] : throw FormatException('Missing required property')),
600+ overseriously: (json.containsKey("overseriously") ? json["overseriously"] : throw FormatException('Missing required property')),
601+ parabola: (json.containsKey("parabola") ? json["parabola"] : throw FormatException('Missing required property')),
602+ pectinatodenticulate: (json.containsKey("pectinatodenticulate") ? json["pectinatodenticulate"] : throw FormatException('Missing required property')),
603+ popean: (json.containsKey("Popean") ? json["Popean"] : throw FormatException('Missing required property')),
604+ pornocrat: (json.containsKey("pornocrat") ? json["pornocrat"] : throw FormatException('Missing required property')),
605+ quadrisect: (json.containsKey("quadrisect") ? json["quadrisect"] : throw FormatException('Missing required property')),
606+ seriality: (json.containsKey("seriality") ? json["seriality"] : throw FormatException('Missing required property')),
607+ vamphorn: (json.containsKey("vamphorn") ? json["vamphorn"] : throw FormatException('Missing required property')),
608+ wharp: (json.containsKey("wharp") ? json["wharp"] : throw FormatException('Missing required property')),
609+ );
610+
611+ Map<String, dynamic> toMap() => {
612+ "ammonolytic": ammonolytic,
613+ "bushmaster": bushmaster,
614+ "considering": considering,
615+ "consuetudinary": consuetudinary,
616+ "embarras": embarras,
617+ "fineness": fineness,
618+ "flaithship": flaithship,
619+ "Flavia": flavia,
620+ "gruffly": gruffly,
621+ "Hedychium": hedychium,
622+ "leadwort": leadwort,
623+ "overseriously": overseriously,
624+ "parabola": parabola,
625+ "pectinatodenticulate": pectinatodenticulate,
626+ "Popean": popean,
627+ "pornocrat": pornocrat,
628+ "quadrisect": quadrisect,
629+ "seriality": seriality,
630+ "vamphorn": vamphorn,
631+ "wharp": wharp,
632+ };
633+}
634+
635+class DeruralizeClass {
636+ final dynamic bockerel;
637+ final dynamic boulder;
638+ final dynamic churrus;
639+ final dynamic counterdigged;
640+ final dynamic dialogite;
641+ final dynamic digenic;
642+ final dynamic dunbird;
643+ final dynamic ergatogyne;
644+ final dynamic fiendful;
645+ final dynamic jackrod;
646+ final dynamic jehovistic;
647+ final dynamic paninean;
648+ final dynamic panther;
649+ final dynamic placentigerous;
650+ final dynamic romney;
651+ final dynamic sparm;
652+ final dynamic tocsin;
653+ final dynamic unnicked;
654+ final dynamic unstavable;
655+ final dynamic windfirm;
656+
657+ DeruralizeClass({
658+ required this.bockerel,
659+ required this.boulder,
660+ required this.churrus,
661+ required this.counterdigged,
662+ required this.dialogite,
663+ required this.digenic,
664+ required this.dunbird,
665+ required this.ergatogyne,
666+ required this.fiendful,
667+ required this.jackrod,
668+ required this.jehovistic,
669+ required this.paninean,
670+ required this.panther,
671+ required this.placentigerous,
672+ required this.romney,
673+ required this.sparm,
674+ required this.tocsin,
675+ required this.unnicked,
676+ required this.unstavable,
677+ required this.windfirm,
678+ });
679+
680+ factory DeruralizeClass.fromMap(Map<String, dynamic> json) => DeruralizeClass(
681+ bockerel: (json.containsKey("bockerel") ? json["bockerel"] : throw FormatException('Missing required property')),
682+ boulder: (json.containsKey("boulder") ? json["boulder"] : throw FormatException('Missing required property')),
683+ churrus: (json.containsKey("churrus") ? json["churrus"] : throw FormatException('Missing required property')),
684+ counterdigged: (json.containsKey("counterdigged") ? json["counterdigged"] : throw FormatException('Missing required property')),
685+ dialogite: (json.containsKey("dialogite") ? json["dialogite"] : throw FormatException('Missing required property')),
686+ digenic: (json.containsKey("digenic") ? json["digenic"] : throw FormatException('Missing required property')),
687+ dunbird: (json.containsKey("dunbird") ? json["dunbird"] : throw FormatException('Missing required property')),
688+ ergatogyne: (json.containsKey("ergatogyne") ? json["ergatogyne"] : throw FormatException('Missing required property')),
689+ fiendful: (json.containsKey("fiendful") ? json["fiendful"] : throw FormatException('Missing required property')),
690+ jackrod: (json.containsKey("jackrod") ? json["jackrod"] : throw FormatException('Missing required property')),
691+ jehovistic: (json.containsKey("Jehovistic") ? json["Jehovistic"] : throw FormatException('Missing required property')),
692+ paninean: (json.containsKey("Paninean") ? json["Paninean"] : throw FormatException('Missing required property')),
693+ panther: (json.containsKey("panther") ? json["panther"] : throw FormatException('Missing required property')),
694+ placentigerous: (json.containsKey("placentigerous") ? json["placentigerous"] : throw FormatException('Missing required property')),
695+ romney: (json.containsKey("Romney") ? json["Romney"] : throw FormatException('Missing required property')),
696+ sparm: (json.containsKey("sparm") ? json["sparm"] : throw FormatException('Missing required property')),
697+ tocsin: (json.containsKey("tocsin") ? json["tocsin"] : throw FormatException('Missing required property')),
698+ unnicked: (json.containsKey("unnicked") ? json["unnicked"] : throw FormatException('Missing required property')),
699+ unstavable: (json.containsKey("unstavable") ? json["unstavable"] : throw FormatException('Missing required property')),
700+ windfirm: (json.containsKey("windfirm") ? json["windfirm"] : throw FormatException('Missing required property')),
701+ );
702+
703+ Map<String, dynamic> toMap() => {
704+ "bockerel": bockerel,
705+ "boulder": boulder,
706+ "churrus": churrus,
707+ "counterdigged": counterdigged,
708+ "dialogite": dialogite,
709+ "digenic": digenic,
710+ "dunbird": dunbird,
711+ "ergatogyne": ergatogyne,
712+ "fiendful": fiendful,
713+ "jackrod": jackrod,
714+ "Jehovistic": jehovistic,
715+ "Paninean": paninean,
716+ "panther": panther,
717+ "placentigerous": placentigerous,
718+ "Romney": romney,
719+ "sparm": sparm,
720+ "tocsin": tocsin,
721+ "unnicked": unnicked,
722+ "unstavable": unstavable,
723+ "windfirm": windfirm,
724+ };
725+}
726+
727+class DiaereseClass {
728+ final dynamic amoreuxia;
729+ final dynamic ani;
730+ final dynamic bernicle;
731+ final dynamic blackwasher;
732+ final dynamic blowhard;
733+ final dynamic broma;
734+ final dynamic closecross;
735+ final dynamic congregationalism;
736+ final dynamic grayly;
737+ final dynamic historically;
738+ final dynamic hoast;
739+ final dynamic irretentive;
740+ final dynamic parcener;
741+ final dynamic pedder;
742+ final dynamic pseudoanatomic;
743+ final dynamic rhizocarpian;
744+ final dynamic samel;
745+ final dynamic silker;
746+ final dynamic subdentated;
747+ final dynamic subobscure;
748+
749+ DiaereseClass({
750+ required this.amoreuxia,
751+ required this.ani,
752+ required this.bernicle,
753+ required this.blackwasher,
754+ required this.blowhard,
755+ required this.broma,
756+ required this.closecross,
757+ required this.congregationalism,
758+ required this.grayly,
759+ required this.historically,
760+ required this.hoast,
761+ required this.irretentive,
762+ required this.parcener,
763+ required this.pedder,
764+ required this.pseudoanatomic,
765+ required this.rhizocarpian,
766+ required this.samel,
767+ required this.silker,
768+ required this.subdentated,
769+ required this.subobscure,
770+ });
771+
772+ factory DiaereseClass.fromMap(Map<String, dynamic> json) => DiaereseClass(
773+ amoreuxia: (json.containsKey("Amoreuxia") ? json["Amoreuxia"] : throw FormatException('Missing required property')),
774+ ani: (json.containsKey("ani") ? json["ani"] : throw FormatException('Missing required property')),
775+ bernicle: (json.containsKey("bernicle") ? json["bernicle"] : throw FormatException('Missing required property')),
776+ blackwasher: (json.containsKey("blackwasher") ? json["blackwasher"] : throw FormatException('Missing required property')),
777+ blowhard: (json.containsKey("blowhard") ? json["blowhard"] : throw FormatException('Missing required property')),
778+ broma: (json.containsKey("broma") ? json["broma"] : throw FormatException('Missing required property')),
779+ closecross: (json.containsKey("closecross") ? json["closecross"] : throw FormatException('Missing required property')),
780+ congregationalism: (json.containsKey("congregationalism") ? json["congregationalism"] : throw FormatException('Missing required property')),
781+ grayly: (json.containsKey("grayly") ? json["grayly"] : throw FormatException('Missing required property')),
782+ historically: (json.containsKey("historically") ? json["historically"] : throw FormatException('Missing required property')),
783+ hoast: (json.containsKey("hoast") ? json["hoast"] : throw FormatException('Missing required property')),
784+ irretentive: (json.containsKey("irretentive") ? json["irretentive"] : throw FormatException('Missing required property')),
785+ parcener: (json.containsKey("parcener") ? json["parcener"] : throw FormatException('Missing required property')),
786+ pedder: (json.containsKey("pedder") ? json["pedder"] : throw FormatException('Missing required property')),
787+ pseudoanatomic: (json.containsKey("pseudoanatomic") ? json["pseudoanatomic"] : throw FormatException('Missing required property')),
788+ rhizocarpian: (json.containsKey("rhizocarpian") ? json["rhizocarpian"] : throw FormatException('Missing required property')),
789+ samel: (json.containsKey("samel") ? json["samel"] : throw FormatException('Missing required property')),
790+ silker: (json.containsKey("silker") ? json["silker"] : throw FormatException('Missing required property')),
791+ subdentated: (json.containsKey("subdentated") ? json["subdentated"] : throw FormatException('Missing required property')),
792+ subobscure: (json.containsKey("subobscure") ? json["subobscure"] : throw FormatException('Missing required property')),
793+ );
794+
795+ Map<String, dynamic> toMap() => {
796+ "Amoreuxia": amoreuxia,
797+ "ani": ani,
798+ "bernicle": bernicle,
799+ "blackwasher": blackwasher,
800+ "blowhard": blowhard,
801+ "broma": broma,
802+ "closecross": closecross,
803+ "congregationalism": congregationalism,
804+ "grayly": grayly,
805+ "historically": historically,
806+ "hoast": hoast,
807+ "irretentive": irretentive,
808+ "parcener": parcener,
809+ "pedder": pedder,
810+ "pseudoanatomic": pseudoanatomic,
811+ "rhizocarpian": rhizocarpian,
812+ "samel": samel,
813+ "silker": silker,
814+ "subdentated": subdentated,
815+ "subobscure": subobscure,
816+ };
817+}
818+
819+class Encrust {
820+ final dynamic comradely;
821+ final dynamic diacanthous;
822+ final dynamic feminineness;
823+ final dynamic gossamered;
824+ final dynamic hibernia;
825+ final dynamic hibiscus;
826+ final dynamic lepidosauria;
827+ final dynamic lollingly;
828+ final dynamic manager;
829+ final dynamic mechanic;
830+ final dynamic overminuteness;
831+ final dynamic papelonne;
832+ final dynamic plebification;
833+ final dynamic pugmiller;
834+ final dynamic recoveror;
835+ final dynamic spermatoblastic;
836+ final dynamic syllidae;
837+ final dynamic ungyved;
838+ final dynamic whirlabout;
839+ final dynamic woodenware;
840+
841+ Encrust({
842+ required this.comradely,
843+ required this.diacanthous,
844+ required this.feminineness,
845+ required this.gossamered,
846+ required this.hibernia,
847+ required this.hibiscus,
848+ required this.lepidosauria,
849+ required this.lollingly,
850+ required this.manager,
851+ required this.mechanic,
852+ required this.overminuteness,
853+ required this.papelonne,
854+ required this.plebification,
855+ required this.pugmiller,
856+ required this.recoveror,
857+ required this.spermatoblastic,
858+ required this.syllidae,
859+ required this.ungyved,
860+ required this.whirlabout,
861+ required this.woodenware,
862+ });
863+
864+ factory Encrust.fromMap(Map<String, dynamic> json) => Encrust(
865+ comradely: (json.containsKey("comradely") ? json["comradely"] : throw FormatException('Missing required property')),
866+ diacanthous: (json.containsKey("diacanthous") ? json["diacanthous"] : throw FormatException('Missing required property')),
867+ feminineness: (json.containsKey("feminineness") ? json["feminineness"] : throw FormatException('Missing required property')),
868+ gossamered: (json.containsKey("gossamered") ? json["gossamered"] : throw FormatException('Missing required property')),
869+ hibernia: (json.containsKey("Hibernia") ? json["Hibernia"] : throw FormatException('Missing required property')),
870+ hibiscus: (json.containsKey("Hibiscus") ? json["Hibiscus"] : throw FormatException('Missing required property')),
871+ lepidosauria: (json.containsKey("Lepidosauria") ? json["Lepidosauria"] : throw FormatException('Missing required property')),
872+ lollingly: (json.containsKey("lollingly") ? json["lollingly"] : throw FormatException('Missing required property')),
873+ manager: (json.containsKey("manager") ? json["manager"] : throw FormatException('Missing required property')),
874+ mechanic: (json.containsKey("mechanic") ? json["mechanic"] : throw FormatException('Missing required property')),
875+ overminuteness: (json.containsKey("overminuteness") ? json["overminuteness"] : throw FormatException('Missing required property')),
876+ papelonne: (json.containsKey("papelonne") ? json["papelonne"] : throw FormatException('Missing required property')),
877+ plebification: (json.containsKey("plebification") ? json["plebification"] : throw FormatException('Missing required property')),
878+ pugmiller: (json.containsKey("pugmiller") ? json["pugmiller"] : throw FormatException('Missing required property')),
879+ recoveror: (json.containsKey("recoveror") ? json["recoveror"] : throw FormatException('Missing required property')),
880+ spermatoblastic: (json.containsKey("spermatoblastic") ? json["spermatoblastic"] : throw FormatException('Missing required property')),
881+ syllidae: (json.containsKey("Syllidae") ? json["Syllidae"] : throw FormatException('Missing required property')),
882+ ungyved: (json.containsKey("ungyved") ? json["ungyved"] : throw FormatException('Missing required property')),
883+ whirlabout: (json.containsKey("whirlabout") ? json["whirlabout"] : throw FormatException('Missing required property')),
884+ woodenware: (json.containsKey("woodenware") ? json["woodenware"] : throw FormatException('Missing required property')),
885+ );
886+
887+ Map<String, dynamic> toMap() => {
888+ "comradely": comradely,
889+ "diacanthous": diacanthous,
890+ "feminineness": feminineness,
891+ "gossamered": gossamered,
892+ "Hibernia": hibernia,
893+ "Hibiscus": hibiscus,
894+ "Lepidosauria": lepidosauria,
895+ "lollingly": lollingly,
896+ "manager": manager,
897+ "mechanic": mechanic,
898+ "overminuteness": overminuteness,
899+ "papelonne": papelonne,
900+ "plebification": plebification,
901+ "pugmiller": pugmiller,
902+ "recoveror": recoveror,
903+ "spermatoblastic": spermatoblastic,
904+ "Syllidae": syllidae,
905+ "ungyved": ungyved,
906+ "whirlabout": whirlabout,
907+ "woodenware": woodenware,
908+ };
909+}
910+
911+class FagginglyClass {
912+ final dynamic abranchian;
913+ final dynamic aculeiform;
914+ final dynamic adiaphoristic;
915+ final dynamic adoptionism;
916+ final dynamic anglic;
917+ final dynamic antrotomy;
918+ final dynamic coerciveness;
919+ final dynamic decorist;
920+ final dynamic duckhood;
921+ final dynamic heteromeri;
922+ final dynamic hypochnose;
923+ final dynamic lochage;
924+ final dynamic melee;
925+ final dynamic nonconformitant;
926+ final dynamic poinsettia;
927+ final dynamic putatively;
928+ final dynamic semivolatile;
929+ final dynamic soleas;
930+ final dynamic unfastenable;
931+ final dynamic unmillinered;
932+
933+ FagginglyClass({
934+ required this.abranchian,
935+ required this.aculeiform,
936+ required this.adiaphoristic,
937+ required this.adoptionism,
938+ required this.anglic,
939+ required this.antrotomy,
940+ required this.coerciveness,
941+ required this.decorist,
942+ required this.duckhood,
943+ required this.heteromeri,
944+ required this.hypochnose,
945+ required this.lochage,
946+ required this.melee,
947+ required this.nonconformitant,
948+ required this.poinsettia,
949+ required this.putatively,
950+ required this.semivolatile,
951+ required this.soleas,
952+ required this.unfastenable,
953+ required this.unmillinered,
954+ });
955+
956+ factory FagginglyClass.fromMap(Map<String, dynamic> json) => FagginglyClass(
957+ abranchian: (json.containsKey("abranchian") ? json["abranchian"] : throw FormatException('Missing required property')),
958+ aculeiform: (json.containsKey("aculeiform") ? json["aculeiform"] : throw FormatException('Missing required property')),
959+ adiaphoristic: (json.containsKey("adiaphoristic") ? json["adiaphoristic"] : throw FormatException('Missing required property')),
960+ adoptionism: (json.containsKey("adoptionism") ? json["adoptionism"] : throw FormatException('Missing required property')),
961+ anglic: (json.containsKey("Anglic") ? json["Anglic"] : throw FormatException('Missing required property')),
962+ antrotomy: (json.containsKey("antrotomy") ? json["antrotomy"] : throw FormatException('Missing required property')),
963+ coerciveness: (json.containsKey("coerciveness") ? json["coerciveness"] : throw FormatException('Missing required property')),
964+ decorist: (json.containsKey("decorist") ? json["decorist"] : throw FormatException('Missing required property')),
965+ duckhood: (json.containsKey("duckhood") ? json["duckhood"] : throw FormatException('Missing required property')),
966+ heteromeri: (json.containsKey("Heteromeri") ? json["Heteromeri"] : throw FormatException('Missing required property')),
967+ hypochnose: (json.containsKey("hypochnose") ? json["hypochnose"] : throw FormatException('Missing required property')),
968+ lochage: (json.containsKey("lochage") ? json["lochage"] : throw FormatException('Missing required property')),
969+ melee: (json.containsKey("melee") ? json["melee"] : throw FormatException('Missing required property')),
970+ nonconformitant: (json.containsKey("nonconformitant") ? json["nonconformitant"] : throw FormatException('Missing required property')),
971+ poinsettia: (json.containsKey("Poinsettia") ? json["Poinsettia"] : throw FormatException('Missing required property')),
972+ putatively: (json.containsKey("putatively") ? json["putatively"] : throw FormatException('Missing required property')),
973+ semivolatile: (json.containsKey("semivolatile") ? json["semivolatile"] : throw FormatException('Missing required property')),
974+ soleas: (json.containsKey("soleas") ? json["soleas"] : throw FormatException('Missing required property')),
975+ unfastenable: (json.containsKey("unfastenable") ? json["unfastenable"] : throw FormatException('Missing required property')),
976+ unmillinered: (json.containsKey("unmillinered") ? json["unmillinered"] : throw FormatException('Missing required property')),
977+ );
978+
979+ Map<String, dynamic> toMap() => {
980+ "abranchian": abranchian,
981+ "aculeiform": aculeiform,
982+ "adiaphoristic": adiaphoristic,
983+ "adoptionism": adoptionism,
984+ "Anglic": anglic,
985+ "antrotomy": antrotomy,
986+ "coerciveness": coerciveness,
987+ "decorist": decorist,
988+ "duckhood": duckhood,
989+ "Heteromeri": heteromeri,
990+ "hypochnose": hypochnose,
991+ "lochage": lochage,
992+ "melee": melee,
993+ "nonconformitant": nonconformitant,
994+ "Poinsettia": poinsettia,
995+ "putatively": putatively,
996+ "semivolatile": semivolatile,
997+ "soleas": soleas,
998+ "unfastenable": unfastenable,
999+ "unmillinered": unmillinered,
1000+ };
1001+}
1002+
1003+class FenkClass {
1004+ final dynamic apoise;
1005+ final dynamic astronomize;
1006+ final dynamic cockhorse;
1007+ final dynamic copular;
1008+ final dynamic dagomba;
1009+ final dynamic draffy;
1010+ final dynamic foreigner;
1011+ final dynamic guyandot;
1012+ final dynamic neurogliosis;
1013+ final dynamic osmious;
1014+ final dynamic palpitate;
1015+ final dynamic rebukeable;
1016+ final dynamic reinwardtia;
1017+ final dynamic reservatory;
1018+ final dynamic scalt;
1019+ final dynamic scripturalize;
1020+ final dynamic tintometer;
1021+ final dynamic tritoness;
1022+ final dynamic undergrade;
1023+ final dynamic undermountain;
1024+
1025+ FenkClass({
1026+ required this.apoise,
1027+ required this.astronomize,
1028+ required this.cockhorse,
1029+ required this.copular,
1030+ required this.dagomba,
1031+ required this.draffy,
1032+ required this.foreigner,
1033+ required this.guyandot,
1034+ required this.neurogliosis,
1035+ required this.osmious,
1036+ required this.palpitate,
1037+ required this.rebukeable,
1038+ required this.reinwardtia,
1039+ required this.reservatory,
1040+ required this.scalt,
1041+ required this.scripturalize,
1042+ required this.tintometer,
1043+ required this.tritoness,
1044+ required this.undergrade,
1045+ required this.undermountain,
1046+ });
1047+
1048+ factory FenkClass.fromMap(Map<String, dynamic> json) => FenkClass(
1049+ apoise: (json.containsKey("apoise") ? json["apoise"] : throw FormatException('Missing required property')),
1050+ astronomize: (json.containsKey("astronomize") ? json["astronomize"] : throw FormatException('Missing required property')),
1051+ cockhorse: (json.containsKey("cockhorse") ? json["cockhorse"] : throw FormatException('Missing required property')),
1052+ copular: (json.containsKey("copular") ? json["copular"] : throw FormatException('Missing required property')),
1053+ dagomba: (json.containsKey("Dagomba") ? json["Dagomba"] : throw FormatException('Missing required property')),
1054+ draffy: (json.containsKey("draffy") ? json["draffy"] : throw FormatException('Missing required property')),
1055+ foreigner: (json.containsKey("foreigner") ? json["foreigner"] : throw FormatException('Missing required property')),
1056+ guyandot: (json.containsKey("Guyandot") ? json["Guyandot"] : throw FormatException('Missing required property')),
1057+ neurogliosis: (json.containsKey("neurogliosis") ? json["neurogliosis"] : throw FormatException('Missing required property')),
1058+ osmious: (json.containsKey("osmious") ? json["osmious"] : throw FormatException('Missing required property')),
1059+ palpitate: (json.containsKey("palpitate") ? json["palpitate"] : throw FormatException('Missing required property')),
1060+ rebukeable: (json.containsKey("rebukeable") ? json["rebukeable"] : throw FormatException('Missing required property')),
1061+ reinwardtia: (json.containsKey("Reinwardtia") ? json["Reinwardtia"] : throw FormatException('Missing required property')),
1062+ reservatory: (json.containsKey("reservatory") ? json["reservatory"] : throw FormatException('Missing required property')),
1063+ scalt: (json.containsKey("scalt") ? json["scalt"] : throw FormatException('Missing required property')),
1064+ scripturalize: (json.containsKey("scripturalize") ? json["scripturalize"] : throw FormatException('Missing required property')),
1065+ tintometer: (json.containsKey("tintometer") ? json["tintometer"] : throw FormatException('Missing required property')),
1066+ tritoness: (json.containsKey("Tritoness") ? json["Tritoness"] : throw FormatException('Missing required property')),
1067+ undergrade: (json.containsKey("undergrade") ? json["undergrade"] : throw FormatException('Missing required property')),
1068+ undermountain: (json.containsKey("undermountain") ? json["undermountain"] : throw FormatException('Missing required property')),
1069+ );
1070+
1071+ Map<String, dynamic> toMap() => {
1072+ "apoise": apoise,
1073+ "astronomize": astronomize,
1074+ "cockhorse": cockhorse,
1075+ "copular": copular,
1076+ "Dagomba": dagomba,
1077+ "draffy": draffy,
1078+ "foreigner": foreigner,
1079+ "Guyandot": guyandot,
1080+ "neurogliosis": neurogliosis,
1081+ "osmious": osmious,
1082+ "palpitate": palpitate,
1083+ "rebukeable": rebukeable,
1084+ "Reinwardtia": reinwardtia,
1085+ "reservatory": reservatory,
1086+ "scalt": scalt,
1087+ "scripturalize": scripturalize,
1088+ "tintometer": tintometer,
1089+ "Tritoness": tritoness,
1090+ "undergrade": undergrade,
1091+ "undermountain": undermountain,
1092+ };
1093+}
1094+
1095+class FlagmakingClass {
1096+ final dynamic albarco;
1097+ final dynamic bunodonta;
1098+ final dynamic hornify;
1099+ final dynamic hydrocorisae;
1100+ final dynamic hypoglossus;
1101+ final dynamic inexpiably;
1102+ final dynamic ingratitude;
1103+ final dynamic ladyfly;
1104+ final dynamic medicament;
1105+ final dynamic monogrammatic;
1106+ final dynamic nobbut;
1107+ final dynamic notacanthidae;
1108+ final dynamic polyplacophore;
1109+ final dynamic proexercise;
1110+ final dynamic protoplast;
1111+ final dynamic puzzling;
1112+ final dynamic splanchnoskeleton;
1113+ final dynamic unloveliness;
1114+ final dynamic unquarantined;
1115+ final dynamic unrenounceable;
1116+
1117+ FlagmakingClass({
1118+ required this.albarco,
1119+ required this.bunodonta,
1120+ required this.hornify,
1121+ required this.hydrocorisae,
1122+ required this.hypoglossus,
1123+ required this.inexpiably,
1124+ required this.ingratitude,
1125+ required this.ladyfly,
1126+ required this.medicament,
1127+ required this.monogrammatic,
1128+ required this.nobbut,
1129+ required this.notacanthidae,
1130+ required this.polyplacophore,
1131+ required this.proexercise,
1132+ required this.protoplast,
1133+ required this.puzzling,
1134+ required this.splanchnoskeleton,
1135+ required this.unloveliness,
1136+ required this.unquarantined,
1137+ required this.unrenounceable,
1138+ });
1139+
1140+ factory FlagmakingClass.fromMap(Map<String, dynamic> json) => FlagmakingClass(
1141+ albarco: (json.containsKey("albarco") ? json["albarco"] : throw FormatException('Missing required property')),
1142+ bunodonta: (json.containsKey("Bunodonta") ? json["Bunodonta"] : throw FormatException('Missing required property')),
1143+ hornify: (json.containsKey("hornify") ? json["hornify"] : throw FormatException('Missing required property')),
1144+ hydrocorisae: (json.containsKey("Hydrocorisae") ? json["Hydrocorisae"] : throw FormatException('Missing required property')),
1145+ hypoglossus: (json.containsKey("hypoglossus") ? json["hypoglossus"] : throw FormatException('Missing required property')),
1146+ inexpiably: (json.containsKey("inexpiably") ? json["inexpiably"] : throw FormatException('Missing required property')),
1147+ ingratitude: (json.containsKey("ingratitude") ? json["ingratitude"] : throw FormatException('Missing required property')),
1148+ ladyfly: (json.containsKey("ladyfly") ? json["ladyfly"] : throw FormatException('Missing required property')),
1149+ medicament: (json.containsKey("medicament") ? json["medicament"] : throw FormatException('Missing required property')),
1150+ monogrammatic: (json.containsKey("monogrammatic") ? json["monogrammatic"] : throw FormatException('Missing required property')),
1151+ nobbut: (json.containsKey("nobbut") ? json["nobbut"] : throw FormatException('Missing required property')),
1152+ notacanthidae: (json.containsKey("Notacanthidae") ? json["Notacanthidae"] : throw FormatException('Missing required property')),
1153+ polyplacophore: (json.containsKey("polyplacophore") ? json["polyplacophore"] : throw FormatException('Missing required property')),
1154+ proexercise: (json.containsKey("proexercise") ? json["proexercise"] : throw FormatException('Missing required property')),
1155+ protoplast: (json.containsKey("protoplast") ? json["protoplast"] : throw FormatException('Missing required property')),
1156+ puzzling: (json.containsKey("puzzling") ? json["puzzling"] : throw FormatException('Missing required property')),
1157+ splanchnoskeleton: (json.containsKey("splanchnoskeleton") ? json["splanchnoskeleton"] : throw FormatException('Missing required property')),
1158+ unloveliness: (json.containsKey("unloveliness") ? json["unloveliness"] : throw FormatException('Missing required property')),
1159+ unquarantined: (json.containsKey("unquarantined") ? json["unquarantined"] : throw FormatException('Missing required property')),
1160+ unrenounceable: (json.containsKey("unrenounceable") ? json["unrenounceable"] : throw FormatException('Missing required property')),
1161+ );
1162+
1163+ Map<String, dynamic> toMap() => {
1164+ "albarco": albarco,
1165+ "Bunodonta": bunodonta,
1166+ "hornify": hornify,
1167+ "Hydrocorisae": hydrocorisae,
1168+ "hypoglossus": hypoglossus,
1169+ "inexpiably": inexpiably,
1170+ "ingratitude": ingratitude,
1171+ "ladyfly": ladyfly,
1172+ "medicament": medicament,
1173+ "monogrammatic": monogrammatic,
1174+ "nobbut": nobbut,
1175+ "Notacanthidae": notacanthidae,
1176+ "polyplacophore": polyplacophore,
1177+ "proexercise": proexercise,
1178+ "protoplast": protoplast,
1179+ "puzzling": puzzling,
1180+ "splanchnoskeleton": splanchnoskeleton,
1181+ "unloveliness": unloveliness,
1182+ "unquarantined": unquarantined,
1183+ "unrenounceable": unrenounceable,
1184+ };
1185+}
1186+
1187+class HemocoeleClass {
1188+ final dynamic acrogamy;
1189+ final dynamic amelification;
1190+ final dynamic autobiographic;
1191+ final dynamic berat;
1192+ final double? catharticalness;
1193+ final int? chirotherium;
1194+ final String? disdiapason;
1195+ final dynamic disproportionably;
1196+ final dynamic erythrite;
1197+ final dynamic graphic;
1198+ final dynamic hepatological;
1199+ final bool? homocerc;
1200+ final dynamic incommensurably;
1201+ final dynamic misaffirm;
1202+ final dynamic nonbookish;
1203+ final dynamic pocketbook;
1204+ final dynamic sclerometric;
1205+ final dynamic stambouline;
1206+ final dynamic stickpin;
1207+ final dynamic tubulure;
1208+ final dynamic undelated;
1209+ final dynamic unsalt;
1210+ final dynamic untutelar;
1211+ final dynamic vagrant;
1212+ final dynamic walt;
1213+
1214+ HemocoeleClass({
1215+ this.acrogamy,
1216+ this.amelification,
1217+ this.autobiographic,
1218+ this.berat,
1219+ this.catharticalness,
1220+ this.chirotherium,
1221+ this.disdiapason,
1222+ this.disproportionably,
1223+ this.erythrite,
1224+ this.graphic,
1225+ this.hepatological,
1226+ this.homocerc,
1227+ this.incommensurably,
1228+ this.misaffirm,
1229+ this.nonbookish,
1230+ this.pocketbook,
1231+ this.sclerometric,
1232+ this.stambouline,
1233+ this.stickpin,
1234+ this.tubulure,
1235+ this.undelated,
1236+ this.unsalt,
1237+ this.untutelar,
1238+ this.vagrant,
1239+ this.walt,
1240+ });
1241+
1242+ factory HemocoeleClass.fromMap(Map<String, dynamic> json) => HemocoeleClass(
1243+ acrogamy: json["acrogamy"],
1244+ amelification: json["amelification"],
1245+ autobiographic: json["autobiographic"],
1246+ berat: json["berat"],
1247+ catharticalness: json["catharticalness"]?.toDouble(),
1248+ chirotherium: json["Chirotherium"],
1249+ disdiapason: json["disdiapason"],
1250+ disproportionably: json["disproportionably"],
1251+ erythrite: json["erythrite"],
1252+ graphic: json["graphic"],
1253+ hepatological: json["hepatological"],
1254+ homocerc: json["homocerc"],
1255+ incommensurably: json["incommensurably"],
1256+ misaffirm: json["misaffirm"],
1257+ nonbookish: json["nonbookish"],
1258+ pocketbook: json["pocketbook"],
1259+ sclerometric: json["sclerometric"],
1260+ stambouline: json["stambouline"],
1261+ stickpin: json["stickpin"],
1262+ tubulure: json["tubulure"],
1263+ undelated: json["undelated"],
1264+ unsalt: json["unsalt"],
1265+ untutelar: json["untutelar"],
1266+ vagrant: json["vagrant"],
1267+ walt: json["Walt"],
1268+ );
1269+
1270+ Map<String, dynamic> toMap() => {
1271+ "acrogamy": acrogamy,
1272+ "amelification": amelification,
1273+ "autobiographic": autobiographic,
1274+ "berat": berat,
1275+ "catharticalness": catharticalness,
1276+ "Chirotherium": chirotherium,
1277+ "disdiapason": disdiapason,
1278+ "disproportionably": disproportionably,
1279+ "erythrite": erythrite,
1280+ "graphic": graphic,
1281+ "hepatological": hepatological,
1282+ "homocerc": homocerc,
1283+ "incommensurably": incommensurably,
1284+ "misaffirm": misaffirm,
1285+ "nonbookish": nonbookish,
1286+ "pocketbook": pocketbook,
1287+ "sclerometric": sclerometric,
1288+ "stambouline": stambouline,
1289+ "stickpin": stickpin,
1290+ "tubulure": tubulure,
1291+ "undelated": undelated,
1292+ "unsalt": unsalt,
1293+ "untutelar": untutelar,
1294+ "vagrant": vagrant,
1295+ "Walt": walt,
1296+ };
1297+}
1298+
1299+class Interacinar {
1300+ final double assapan;
1301+ final bool benefactorship;
1302+ final String triseriatim;
1303+ final int tubbing;
1304+ final dynamic untrimmed;
1305+
1306+ Interacinar({
1307+ required this.assapan,
1308+ required this.benefactorship,
1309+ required this.triseriatim,
1310+ required this.tubbing,
1311+ required this.untrimmed,
1312+ });
1313+
1314+ factory Interacinar.fromMap(Map<String, dynamic> json) => Interacinar(
1315+ assapan: json["assapan"]?.toDouble(),
1316+ benefactorship: json["benefactorship"],
1317+ triseriatim: json["triseriatim"],
1318+ tubbing: json["tubbing"],
1319+ untrimmed: (json.containsKey("untrimmed") ? json["untrimmed"] : throw FormatException('Missing required property')),
1320+ );
1321+
1322+ Map<String, dynamic> toMap() => {
1323+ "assapan": assapan,
1324+ "benefactorship": benefactorship,
1325+ "triseriatim": triseriatim,
1326+ "tubbing": tubbing,
1327+ "untrimmed": untrimmed,
1328+ };
1329+}
Aswiftfinal-classes-true__struct-or-class-class--d3c62ec7414d / quicktype.swift+3,182 −0
@@ -0,0 +1,3182 @@
1+// This file was generated from JSON Schema using quicktype, do not modify it directly.
2+// To parse the JSON, add this file to your project and do:
3+//
4+// let topLevel = try TopLevel(json)
5+
6+import Foundation
7+
8+// MARK: - TopLevel
9+final class TopLevel: Codable {
10+ let centrodesmose: String
11+ let cerograph: [CerographElement]
12+ let chemotherapeutics: [ChemotherapeuticElement]
13+ let cimelia: [CimeliaElement]
14+ let citrated: Int
15+ let clinodome: [Clinodome]
16+ let coadjust: [CoadjustElement]
17+ let consilience: [Consilience]
18+ let constructor: [Constructor]
19+ let continuative: [Continuative]
20+ let credulity: [CredulityElement]
21+ let creviced: [Creviced]
22+ let cubiculum: [[Int?]]
23+ let deruralize: [DeruralizeElement]
24+ let diaereses: [DiaereseElement]
25+ let dissolution: [[JSONNull?]?]
26+ let downstroke: [Downstroke]
27+ let electrotautomerism: [Double?]
28+ let eleutheromania: [Eleutheromania]
29+ let encrust: Encrust
30+ let entomoid: [Entomoid]
31+ let epipaleolithic: [Epipaleolithic]
32+ let expropriable: [Expropriable]
33+ let faggingly: [FagginglyElement]
34+ let fenks: [FenkElement]
35+ let flagmaking: [FlagmakingElement]
36+ let fluorometer: [Fluorometer]
37+ let fulsome: [Int?]
38+ let fuzzy: [Fuzzy]
39+ let gardenwards: [Gardenward]
40+ let generalissimo: [Generalissimo]
41+ let habeas: [[String: Int]?]
42+ let hemicrystalline: [Hemicrystalline]
43+ let hemocoele: [HemocoeleElement]
44+ let hoister: [Hoister]
45+ let hyperpiesis: [Hyperpiesi]
46+ let hyppish: [Hyppish]
47+ let idealizer: [Idealizer]
48+ let incrustator: [Incrustator]
49+ let intentiveness: [Intentiveness]
50+ let interacinar: Interacinar
51+ let intercorrelation: [[Int]?]
52+ let jacutinga: [Jacutinga]
53+
54+ enum CodingKeys: String, CodingKey {
55+ case centrodesmose = "centrodesmose"
56+ case cerograph = "cerograph"
57+ case chemotherapeutics = "chemotherapeutics"
58+ case cimelia = "cimelia"
59+ case citrated = "citrated"
60+ case clinodome = "clinodome"
61+ case coadjust = "coadjust"
62+ case consilience = "consilience"
63+ case constructor = "constructor"
64+ case continuative = "continuative"
65+ case credulity = "credulity"
66+ case creviced = "creviced"
67+ case cubiculum = "cubiculum"
68+ case deruralize = "deruralize"
69+ case diaereses = "diaereses"
70+ case dissolution = "dissolution"
71+ case downstroke = "downstroke"
72+ case electrotautomerism = "electrotautomerism"
73+ case eleutheromania = "eleutheromania"
74+ case encrust = "encrust"
75+ case entomoid = "entomoid"
76+ case epipaleolithic = "epipaleolithic"
77+ case expropriable = "expropriable"
78+ case faggingly = "faggingly"
79+ case fenks = "fenks"
80+ case flagmaking = "flagmaking"
81+ case fluorometer = "fluorometer"
82+ case fulsome = "fulsome"
83+ case fuzzy = "fuzzy"
84+ case gardenwards = "gardenwards"
85+ case generalissimo = "generalissimo"
86+ case habeas = "habeas"
87+ case hemicrystalline = "hemicrystalline"
88+ case hemocoele = "hemocoele"
89+ case hoister = "hoister"
90+ case hyperpiesis = "hyperpiesis"
91+ case hyppish = "hyppish"
92+ case idealizer = "idealizer"
93+ case incrustator = "incrustator"
94+ case intentiveness = "intentiveness"
95+ case interacinar = "interacinar"
96+ case intercorrelation = "intercorrelation"
97+ case jacutinga = "jacutinga"
98+ }
99+
100+ 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]) {
101+ self.centrodesmose = centrodesmose
102+ self.cerograph = cerograph
103+ self.chemotherapeutics = chemotherapeutics
104+ self.cimelia = cimelia
105+ self.citrated = citrated
106+ self.clinodome = clinodome
107+ self.coadjust = coadjust
108+ self.consilience = consilience
109+ self.constructor = constructor
110+ self.continuative = continuative
111+ self.credulity = credulity
112+ self.creviced = creviced
113+ self.cubiculum = cubiculum
114+ self.deruralize = deruralize
115+ self.diaereses = diaereses
116+ self.dissolution = dissolution
117+ self.downstroke = downstroke
118+ self.electrotautomerism = electrotautomerism
119+ self.eleutheromania = eleutheromania
120+ self.encrust = encrust
121+ self.entomoid = entomoid
122+ self.epipaleolithic = epipaleolithic
123+ self.expropriable = expropriable
124+ self.faggingly = faggingly
125+ self.fenks = fenks
126+ self.flagmaking = flagmaking
127+ self.fluorometer = fluorometer
128+ self.fulsome = fulsome
129+ self.fuzzy = fuzzy
130+ self.gardenwards = gardenwards
131+ self.generalissimo = generalissimo
132+ self.habeas = habeas
133+ self.hemicrystalline = hemicrystalline
134+ self.hemocoele = hemocoele
135+ self.hoister = hoister
136+ self.hyperpiesis = hyperpiesis
137+ self.hyppish = hyppish
138+ self.idealizer = idealizer
139+ self.incrustator = incrustator
140+ self.intentiveness = intentiveness
141+ self.interacinar = interacinar
142+ self.intercorrelation = intercorrelation
143+ self.jacutinga = jacutinga
144+ }
145+}
146+
147+// MARK: TopLevel convenience initializers and mutators
148+
149+extension TopLevel {
150+ convenience init(data: Data) throws {
151+ let me = try newJSONDecoder().decode(TopLevel.self, from: data)
152+ 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)
153+ }
154+
155+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
156+ guard let data = json.data(using: encoding) else {
157+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
158+ }
159+ try self.init(data: data)
160+ }
161+
162+ convenience init(fromURL url: URL) throws {
163+ try self.init(data: try Data(contentsOf: url))
164+ }
165+
166+ func with(
167+ centrodesmose: String? = nil,
168+ cerograph: [CerographElement]? = nil,
169+ chemotherapeutics: [ChemotherapeuticElement]? = nil,
170+ cimelia: [CimeliaElement]? = nil,
171+ citrated: Int? = nil,
172+ clinodome: [Clinodome]? = nil,
173+ coadjust: [CoadjustElement]? = nil,
174+ consilience: [Consilience]? = nil,
175+ constructor: [Constructor]? = nil,
176+ continuative: [Continuative]? = nil,
177+ credulity: [CredulityElement]? = nil,
178+ creviced: [Creviced]? = nil,
179+ cubiculum: [[Int?]]? = nil,
180+ deruralize: [DeruralizeElement]? = nil,
181+ diaereses: [DiaereseElement]? = nil,
182+ dissolution: [[JSONNull?]?]? = nil,
183+ downstroke: [Downstroke]? = nil,
184+ electrotautomerism: [Double?]? = nil,
185+ eleutheromania: [Eleutheromania]? = nil,
186+ encrust: Encrust? = nil,
187+ entomoid: [Entomoid]? = nil,
188+ epipaleolithic: [Epipaleolithic]? = nil,
189+ expropriable: [Expropriable]? = nil,
190+ faggingly: [FagginglyElement]? = nil,
191+ fenks: [FenkElement]? = nil,
192+ flagmaking: [FlagmakingElement]? = nil,
193+ fluorometer: [Fluorometer]? = nil,
194+ fulsome: [Int?]? = nil,
195+ fuzzy: [Fuzzy]? = nil,
196+ gardenwards: [Gardenward]? = nil,
197+ generalissimo: [Generalissimo]? = nil,
198+ habeas: [[String: Int]?]? = nil,
199+ hemicrystalline: [Hemicrystalline]? = nil,
200+ hemocoele: [HemocoeleElement]? = nil,
201+ hoister: [Hoister]? = nil,
202+ hyperpiesis: [Hyperpiesi]? = nil,
203+ hyppish: [Hyppish]? = nil,
204+ idealizer: [Idealizer]? = nil,
205+ incrustator: [Incrustator]? = nil,
206+ intentiveness: [Intentiveness]? = nil,
207+ interacinar: Interacinar? = nil,
208+ intercorrelation: [[Int]?]? = nil,
209+ jacutinga: [Jacutinga]? = nil
210+ ) -> TopLevel {
211+ return TopLevel(
212+ centrodesmose: centrodesmose ?? self.centrodesmose,
213+ cerograph: cerograph ?? self.cerograph,
214+ chemotherapeutics: chemotherapeutics ?? self.chemotherapeutics,
215+ cimelia: cimelia ?? self.cimelia,
216+ citrated: citrated ?? self.citrated,
217+ clinodome: clinodome ?? self.clinodome,
218+ coadjust: coadjust ?? self.coadjust,
219+ consilience: consilience ?? self.consilience,
220+ constructor: constructor ?? self.constructor,
221+ continuative: continuative ?? self.continuative,
222+ credulity: credulity ?? self.credulity,
223+ creviced: creviced ?? self.creviced,
224+ cubiculum: cubiculum ?? self.cubiculum,
225+ deruralize: deruralize ?? self.deruralize,
226+ diaereses: diaereses ?? self.diaereses,
227+ dissolution: dissolution ?? self.dissolution,
228+ downstroke: downstroke ?? self.downstroke,
229+ electrotautomerism: electrotautomerism ?? self.electrotautomerism,
230+ eleutheromania: eleutheromania ?? self.eleutheromania,
231+ encrust: encrust ?? self.encrust,
232+ entomoid: entomoid ?? self.entomoid,
233+ epipaleolithic: epipaleolithic ?? self.epipaleolithic,
234+ expropriable: expropriable ?? self.expropriable,
235+ faggingly: faggingly ?? self.faggingly,
236+ fenks: fenks ?? self.fenks,
237+ flagmaking: flagmaking ?? self.flagmaking,
238+ fluorometer: fluorometer ?? self.fluorometer,
239+ fulsome: fulsome ?? self.fulsome,
240+ fuzzy: fuzzy ?? self.fuzzy,
241+ gardenwards: gardenwards ?? self.gardenwards,
242+ generalissimo: generalissimo ?? self.generalissimo,
243+ habeas: habeas ?? self.habeas,
244+ hemicrystalline: hemicrystalline ?? self.hemicrystalline,
245+ hemocoele: hemocoele ?? self.hemocoele,
246+ hoister: hoister ?? self.hoister,
247+ hyperpiesis: hyperpiesis ?? self.hyperpiesis,
248+ hyppish: hyppish ?? self.hyppish,
249+ idealizer: idealizer ?? self.idealizer,
250+ incrustator: incrustator ?? self.incrustator,
251+ intentiveness: intentiveness ?? self.intentiveness,
252+ interacinar: interacinar ?? self.interacinar,
253+ intercorrelation: intercorrelation ?? self.intercorrelation,
254+ jacutinga: jacutinga ?? self.jacutinga
255+ )
256+ }
257+
258+ func jsonData() throws -> Data {
259+ return try newJSONEncoder().encode(self)
260+ }
261+
262+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
263+ return String(data: try self.jsonData(), encoding: encoding)
264+ }
265+}
266+
267+enum CerographElement: Codable {
268+ case cerographClass(CerographClass)
269+ case string(String)
270+ case null
271+
272+ init(from decoder: Decoder) throws {
273+ let container = try decoder.singleValueContainer()
274+ if let x = try? container.decode(String.self) {
275+ self = .string(x)
276+ return
277+ }
278+ if let x = try? container.decode(CerographClass.self) {
279+ self = .cerographClass(x)
280+ return
281+ }
282+ if container.decodeNil() {
283+ self = .null
284+ return
285+ }
286+ throw DecodingError.typeMismatch(CerographElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CerographElement"))
287+ }
288+
289+ func encode(to encoder: Encoder) throws {
290+ var container = encoder.singleValueContainer()
291+ switch self {
292+ case .cerographClass(let x):
293+ try container.encode(x)
294+ case .string(let x):
295+ try container.encode(x)
296+ case .null:
297+ try container.encodeNil()
298+ }
299+ }
300+}
301+
302+// MARK: - CerographClass
303+final class CerographClass: Codable {
304+ let apotropaion: JSONNull?
305+ let casuary: JSONNull?
306+ let creaker: JSONNull?
307+ let disqualification: JSONNull?
308+ let imperatorious: JSONNull?
309+ let impermeabilize: JSONNull?
310+ let metastoma: JSONNull?
311+ let noctidiurnal: JSONNull?
312+ let nonreserve: JSONNull?
313+ let ophthalmotonometry: JSONNull?
314+ let pailful: JSONNull?
315+ let pigfish: JSONNull?
316+ let pongee: JSONNull?
317+ let prosodical: JSONNull?
318+ let scrofuloderm: JSONNull?
319+ let storekeeping: JSONNull?
320+ let therologist: JSONNull?
321+ let tolowa: JSONNull?
322+ let tradeful: JSONNull?
323+ let unriveting: JSONNull?
324+
325+ enum CodingKeys: String, CodingKey {
326+ case apotropaion = "apotropaion"
327+ case casuary = "casuary"
328+ case creaker = "creaker"
329+ case disqualification = "disqualification"
330+ case imperatorious = "imperatorious"
331+ case impermeabilize = "impermeabilize"
332+ case metastoma = "metastoma"
333+ case noctidiurnal = "noctidiurnal"
334+ case nonreserve = "nonreserve"
335+ case ophthalmotonometry = "ophthalmotonometry"
336+ case pailful = "pailful"
337+ case pigfish = "pigfish"
338+ case pongee = "pongee"
339+ case prosodical = "prosodical"
340+ case scrofuloderm = "scrofuloderm"
341+ case storekeeping = "storekeeping"
342+ case therologist = "therologist"
343+ case tolowa = "Tolowa"
344+ case tradeful = "tradeful"
345+ case unriveting = "unriveting"
346+ }
347+
348+ 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?) {
349+ self.apotropaion = apotropaion
350+ self.casuary = casuary
351+ self.creaker = creaker
352+ self.disqualification = disqualification
353+ self.imperatorious = imperatorious
354+ self.impermeabilize = impermeabilize
355+ self.metastoma = metastoma
356+ self.noctidiurnal = noctidiurnal
357+ self.nonreserve = nonreserve
358+ self.ophthalmotonometry = ophthalmotonometry
359+ self.pailful = pailful
360+ self.pigfish = pigfish
361+ self.pongee = pongee
362+ self.prosodical = prosodical
363+ self.scrofuloderm = scrofuloderm
364+ self.storekeeping = storekeeping
365+ self.therologist = therologist
366+ self.tolowa = tolowa
367+ self.tradeful = tradeful
368+ self.unriveting = unriveting
369+ }
370+}
371+
372+// MARK: CerographClass convenience initializers and mutators
373+
374+extension CerographClass {
375+ convenience init(data: Data) throws {
376+ let me = try newJSONDecoder().decode(CerographClass.self, from: data)
377+ 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)
378+ }
379+
380+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
381+ guard let data = json.data(using: encoding) else {
382+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
383+ }
384+ try self.init(data: data)
385+ }
386+
387+ convenience init(fromURL url: URL) throws {
388+ try self.init(data: try Data(contentsOf: url))
389+ }
390+
391+ func with(
392+ apotropaion: JSONNull?? = nil,
393+ casuary: JSONNull?? = nil,
394+ creaker: JSONNull?? = nil,
395+ disqualification: JSONNull?? = nil,
396+ imperatorious: JSONNull?? = nil,
397+ impermeabilize: JSONNull?? = nil,
398+ metastoma: JSONNull?? = nil,
399+ noctidiurnal: JSONNull?? = nil,
400+ nonreserve: JSONNull?? = nil,
401+ ophthalmotonometry: JSONNull?? = nil,
402+ pailful: JSONNull?? = nil,
403+ pigfish: JSONNull?? = nil,
404+ pongee: JSONNull?? = nil,
405+ prosodical: JSONNull?? = nil,
406+ scrofuloderm: JSONNull?? = nil,
407+ storekeeping: JSONNull?? = nil,
408+ therologist: JSONNull?? = nil,
409+ tolowa: JSONNull?? = nil,
410+ tradeful: JSONNull?? = nil,
411+ unriveting: JSONNull?? = nil
412+ ) -> CerographClass {
413+ return CerographClass(
414+ apotropaion: apotropaion ?? self.apotropaion,
415+ casuary: casuary ?? self.casuary,
416+ creaker: creaker ?? self.creaker,
417+ disqualification: disqualification ?? self.disqualification,
418+ imperatorious: imperatorious ?? self.imperatorious,
419+ impermeabilize: impermeabilize ?? self.impermeabilize,
420+ metastoma: metastoma ?? self.metastoma,
421+ noctidiurnal: noctidiurnal ?? self.noctidiurnal,
422+ nonreserve: nonreserve ?? self.nonreserve,
423+ ophthalmotonometry: ophthalmotonometry ?? self.ophthalmotonometry,
424+ pailful: pailful ?? self.pailful,
425+ pigfish: pigfish ?? self.pigfish,
426+ pongee: pongee ?? self.pongee,
427+ prosodical: prosodical ?? self.prosodical,
428+ scrofuloderm: scrofuloderm ?? self.scrofuloderm,
429+ storekeeping: storekeeping ?? self.storekeeping,
430+ therologist: therologist ?? self.therologist,
431+ tolowa: tolowa ?? self.tolowa,
432+ tradeful: tradeful ?? self.tradeful,
433+ unriveting: unriveting ?? self.unriveting
434+ )
435+ }
436+
437+ func jsonData() throws -> Data {
438+ return try newJSONEncoder().encode(self)
439+ }
440+
441+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
442+ return String(data: try self.jsonData(), encoding: encoding)
443+ }
444+}
445+
446+enum ChemotherapeuticElement: Codable {
447+ case chemotherapeuticClass(ChemotherapeuticClass)
448+ case integer(Int)
449+
450+ init(from decoder: Decoder) throws {
451+ let container = try decoder.singleValueContainer()
452+ if let x = try? container.decode(Int.self) {
453+ self = .integer(x)
454+ return
455+ }
456+ if let x = try? container.decode(ChemotherapeuticClass.self) {
457+ self = .chemotherapeuticClass(x)
458+ return
459+ }
460+ throw DecodingError.typeMismatch(ChemotherapeuticElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for ChemotherapeuticElement"))
461+ }
462+
463+ func encode(to encoder: Encoder) throws {
464+ var container = encoder.singleValueContainer()
465+ switch self {
466+ case .chemotherapeuticClass(let x):
467+ try container.encode(x)
468+ case .integer(let x):
469+ try container.encode(x)
470+ }
471+ }
472+}
473+
474+// MARK: - ChemotherapeuticClass
475+final class ChemotherapeuticClass: Codable {
476+ let angioneurotic: JSONNull?
477+ let availment: JSONNull?
478+ let bladelet: JSONNull?
479+ let catharticalness: Double?
480+ let caulis: JSONNull?
481+ let chalcus: JSONNull?
482+ let chirotherium: Int?
483+ let disdiapason: String?
484+ let enteradenological: JSONNull?
485+ let homocerc: Bool?
486+ let imporosity: JSONNull?
487+ let insistently: JSONNull?
488+ let intraparietal: JSONNull?
489+ let ivied: JSONNull?
490+ let maureen: JSONNull?
491+ let nonbookish: JSONNull?
492+ let nostochine: JSONNull?
493+ let nutcracker: JSONNull?
494+ let ofttimes: JSONNull?
495+ let phenocryst: JSONNull?
496+ let precoincident: JSONNull?
497+ let ramiferous: JSONNull?
498+ let stagmometer: JSONNull?
499+ let tetherball: JSONNull?
500+ let unshy: JSONNull?
501+
502+ enum CodingKeys: String, CodingKey {
503+ case angioneurotic = "angioneurotic"
504+ case availment = "availment"
505+ case bladelet = "bladelet"
506+ case catharticalness = "catharticalness"
507+ case caulis = "caulis"
508+ case chalcus = "chalcus"
509+ case chirotherium = "Chirotherium"
510+ case disdiapason = "disdiapason"
511+ case enteradenological = "enteradenological"
512+ case homocerc = "homocerc"
513+ case imporosity = "imporosity"
514+ case insistently = "insistently"
515+ case intraparietal = "intraparietal"
516+ case ivied = "ivied"
517+ case maureen = "Maureen"
518+ case nonbookish = "nonbookish"
519+ case nostochine = "nostochine"
520+ case nutcracker = "nutcracker"
521+ case ofttimes = "ofttimes"
522+ case phenocryst = "phenocryst"
523+ case precoincident = "precoincident"
524+ case ramiferous = "ramiferous"
525+ case stagmometer = "stagmometer"
526+ case tetherball = "tetherball"
527+ case unshy = "unshy"
528+ }
529+
530+ 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?) {
531+ self.angioneurotic = angioneurotic
532+ self.availment = availment
533+ self.bladelet = bladelet
534+ self.catharticalness = catharticalness
535+ self.caulis = caulis
536+ self.chalcus = chalcus
537+ self.chirotherium = chirotherium
538+ self.disdiapason = disdiapason
539+ self.enteradenological = enteradenological
540+ self.homocerc = homocerc
541+ self.imporosity = imporosity
542+ self.insistently = insistently
543+ self.intraparietal = intraparietal
544+ self.ivied = ivied
545+ self.maureen = maureen
546+ self.nonbookish = nonbookish
547+ self.nostochine = nostochine
548+ self.nutcracker = nutcracker
549+ self.ofttimes = ofttimes
550+ self.phenocryst = phenocryst
551+ self.precoincident = precoincident
552+ self.ramiferous = ramiferous
553+ self.stagmometer = stagmometer
554+ self.tetherball = tetherball
555+ self.unshy = unshy
556+ }
557+}
558+
559+// MARK: ChemotherapeuticClass convenience initializers and mutators
560+
561+extension ChemotherapeuticClass {
562+ convenience init(data: Data) throws {
563+ let me = try newJSONDecoder().decode(ChemotherapeuticClass.self, from: data)
564+ 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)
565+ }
566+
567+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
568+ guard let data = json.data(using: encoding) else {
569+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
570+ }
571+ try self.init(data: data)
572+ }
573+
574+ convenience init(fromURL url: URL) throws {
575+ try self.init(data: try Data(contentsOf: url))
576+ }
577+
578+ func with(
579+ angioneurotic: JSONNull?? = nil,
580+ availment: JSONNull?? = nil,
581+ bladelet: JSONNull?? = nil,
582+ catharticalness: Double?? = nil,
583+ caulis: JSONNull?? = nil,
584+ chalcus: JSONNull?? = nil,
585+ chirotherium: Int?? = nil,
586+ disdiapason: String?? = nil,
587+ enteradenological: JSONNull?? = nil,
588+ homocerc: Bool?? = nil,
589+ imporosity: JSONNull?? = nil,
590+ insistently: JSONNull?? = nil,
591+ intraparietal: JSONNull?? = nil,
592+ ivied: JSONNull?? = nil,
593+ maureen: JSONNull?? = nil,
594+ nonbookish: JSONNull?? = nil,
595+ nostochine: JSONNull?? = nil,
596+ nutcracker: JSONNull?? = nil,
597+ ofttimes: JSONNull?? = nil,
598+ phenocryst: JSONNull?? = nil,
599+ precoincident: JSONNull?? = nil,
600+ ramiferous: JSONNull?? = nil,
601+ stagmometer: JSONNull?? = nil,
602+ tetherball: JSONNull?? = nil,
603+ unshy: JSONNull?? = nil
604+ ) -> ChemotherapeuticClass {
605+ return ChemotherapeuticClass(
606+ angioneurotic: angioneurotic ?? self.angioneurotic,
607+ availment: availment ?? self.availment,
608+ bladelet: bladelet ?? self.bladelet,
609+ catharticalness: catharticalness ?? self.catharticalness,
610+ caulis: caulis ?? self.caulis,
611+ chalcus: chalcus ?? self.chalcus,
612+ chirotherium: chirotherium ?? self.chirotherium,
613+ disdiapason: disdiapason ?? self.disdiapason,
614+ enteradenological: enteradenological ?? self.enteradenological,
615+ homocerc: homocerc ?? self.homocerc,
616+ imporosity: imporosity ?? self.imporosity,
617+ insistently: insistently ?? self.insistently,
618+ intraparietal: intraparietal ?? self.intraparietal,
619+ ivied: ivied ?? self.ivied,
620+ maureen: maureen ?? self.maureen,
621+ nonbookish: nonbookish ?? self.nonbookish,
622+ nostochine: nostochine ?? self.nostochine,
623+ nutcracker: nutcracker ?? self.nutcracker,
624+ ofttimes: ofttimes ?? self.ofttimes,
625+ phenocryst: phenocryst ?? self.phenocryst,
626+ precoincident: precoincident ?? self.precoincident,
627+ ramiferous: ramiferous ?? self.ramiferous,
628+ stagmometer: stagmometer ?? self.stagmometer,
629+ tetherball: tetherball ?? self.tetherball,
630+ unshy: unshy ?? self.unshy
631+ )
632+ }
633+
634+ func jsonData() throws -> Data {
635+ return try newJSONEncoder().encode(self)
636+ }
637+
638+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
639+ return String(data: try self.jsonData(), encoding: encoding)
640+ }
641+}
642+
643+enum CimeliaElement: Codable {
644+ case cimeliaClass(CimeliaClass)
645+ case integerArray([Int])
646+ case null
647+
648+ init(from decoder: Decoder) throws {
649+ let container = try decoder.singleValueContainer()
650+ if let x = try? container.decode([Int].self) {
651+ self = .integerArray(x)
652+ return
653+ }
654+ if let x = try? container.decode(CimeliaClass.self) {
655+ self = .cimeliaClass(x)
656+ return
657+ }
658+ if container.decodeNil() {
659+ self = .null
660+ return
661+ }
662+ throw DecodingError.typeMismatch(CimeliaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CimeliaElement"))
663+ }
664+
665+ func encode(to encoder: Encoder) throws {
666+ var container = encoder.singleValueContainer()
667+ switch self {
668+ case .cimeliaClass(let x):
669+ try container.encode(x)
670+ case .integerArray(let x):
671+ try container.encode(x)
672+ case .null:
673+ try container.encodeNil()
674+ }
675+ }
676+}
677+
678+// MARK: - CimeliaClass
679+final class CimeliaClass: Codable {
680+ let catharticalness: Double
681+ let chirotherium: Int
682+ let disdiapason: String
683+ let homocerc: Bool
684+ let nonbookish: JSONNull?
685+
686+ enum CodingKeys: String, CodingKey {
687+ case catharticalness = "catharticalness"
688+ case chirotherium = "Chirotherium"
689+ case disdiapason = "disdiapason"
690+ case homocerc = "homocerc"
691+ case nonbookish = "nonbookish"
692+ }
693+
694+ init(catharticalness: Double, chirotherium: Int, disdiapason: String, homocerc: Bool, nonbookish: JSONNull?) {
695+ self.catharticalness = catharticalness
696+ self.chirotherium = chirotherium
697+ self.disdiapason = disdiapason
698+ self.homocerc = homocerc
699+ self.nonbookish = nonbookish
700+ }
701+}
702+
703+// MARK: CimeliaClass convenience initializers and mutators
704+
705+extension CimeliaClass {
706+ convenience init(data: Data) throws {
707+ let me = try newJSONDecoder().decode(CimeliaClass.self, from: data)
708+ self.init(catharticalness: me.catharticalness, chirotherium: me.chirotherium, disdiapason: me.disdiapason, homocerc: me.homocerc, nonbookish: me.nonbookish)
709+ }
710+
711+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
712+ guard let data = json.data(using: encoding) else {
713+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
714+ }
715+ try self.init(data: data)
716+ }
717+
718+ convenience init(fromURL url: URL) throws {
719+ try self.init(data: try Data(contentsOf: url))
720+ }
721+
722+ func with(
723+ catharticalness: Double? = nil,
724+ chirotherium: Int? = nil,
725+ disdiapason: String? = nil,
726+ homocerc: Bool? = nil,
727+ nonbookish: JSONNull?? = nil
728+ ) -> CimeliaClass {
729+ return CimeliaClass(
730+ catharticalness: catharticalness ?? self.catharticalness,
731+ chirotherium: chirotherium ?? self.chirotherium,
732+ disdiapason: disdiapason ?? self.disdiapason,
733+ homocerc: homocerc ?? self.homocerc,
734+ nonbookish: nonbookish ?? self.nonbookish
735+ )
736+ }
737+
738+ func jsonData() throws -> Data {
739+ return try newJSONEncoder().encode(self)
740+ }
741+
742+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
743+ return String(data: try self.jsonData(), encoding: encoding)
744+ }
745+}
746+
747+enum Clinodome: Codable {
748+ case double(Double)
749+ case string(String)
750+
751+ init(from decoder: Decoder) throws {
752+ let container = try decoder.singleValueContainer()
753+ if let x = try? container.decode(Double.self) {
754+ self = .double(x)
755+ return
756+ }
757+ if let x = try? container.decode(String.self) {
758+ self = .string(x)
759+ return
760+ }
761+ throw DecodingError.typeMismatch(Clinodome.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Clinodome"))
762+ }
763+
764+ func encode(to encoder: Encoder) throws {
765+ var container = encoder.singleValueContainer()
766+ switch self {
767+ case .double(let x):
768+ try container.encode(x)
769+ case .string(let x):
770+ try container.encode(x)
771+ }
772+ }
773+}
774+
775+enum CoadjustElement: Codable {
776+ case coadjustClass(CoadjustClass)
777+ case double(Double)
778+
779+ init(from decoder: Decoder) throws {
780+ let container = try decoder.singleValueContainer()
781+ if let x = try? container.decode(Double.self) {
782+ self = .double(x)
783+ return
784+ }
785+ if let x = try? container.decode(CoadjustClass.self) {
786+ self = .coadjustClass(x)
787+ return
788+ }
789+ throw DecodingError.typeMismatch(CoadjustElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CoadjustElement"))
790+ }
791+
792+ func encode(to encoder: Encoder) throws {
793+ var container = encoder.singleValueContainer()
794+ switch self {
795+ case .coadjustClass(let x):
796+ try container.encode(x)
797+ case .double(let x):
798+ try container.encode(x)
799+ }
800+ }
801+}
802+
803+// MARK: - CoadjustClass
804+final class CoadjustClass: Codable {
805+ let amidosulphonal: JSONNull?
806+ let benny: JSONNull?
807+ let catharticalness: Double?
808+ let chirotherium: Int?
809+ let disdiapason: String?
810+ let ensnare: JSONNull?
811+ let homocerc: Bool?
812+ let hybridizer: JSONNull?
813+ let leastwise: JSONNull?
814+ let lof: JSONNull?
815+ let monkhood: JSONNull?
816+ let netherlandish: JSONNull?
817+ let nonbookish: JSONNull?
818+ let peonism: JSONNull?
819+ let phonelescope: JSONNull?
820+ let porphyrogeniture: JSONNull?
821+ let preindemnify: JSONNull?
822+ let rosal: JSONNull?
823+ let scalenous: JSONNull?
824+ let scopine: JSONNull?
825+ let sedaceae: JSONNull?
826+ let suberinize: JSONNull?
827+ let symbiot: JSONNull?
828+ let tablefellow: JSONNull?
829+ let unchargeable: JSONNull?
830+
831+ enum CodingKeys: String, CodingKey {
832+ case amidosulphonal = "amidosulphonal"
833+ case benny = "Benny"
834+ case catharticalness = "catharticalness"
835+ case chirotherium = "Chirotherium"
836+ case disdiapason = "disdiapason"
837+ case ensnare = "ensnare"
838+ case homocerc = "homocerc"
839+ case hybridizer = "hybridizer"
840+ case leastwise = "leastwise"
841+ case lof = "lof"
842+ case monkhood = "monkhood"
843+ case netherlandish = "Netherlandish"
844+ case nonbookish = "nonbookish"
845+ case peonism = "peonism"
846+ case phonelescope = "Phonelescope"
847+ case porphyrogeniture = "porphyrogeniture"
848+ case preindemnify = "preindemnify"
849+ case rosal = "rosal"
850+ case scalenous = "scalenous"
851+ case scopine = "scopine"
852+ case sedaceae = "Sedaceae"
853+ case suberinize = "suberinize"
854+ case symbiot = "symbiot"
855+ case tablefellow = "tablefellow"
856+ case unchargeable = "unchargeable"
857+ }
858+
859+ 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?) {
860+ self.amidosulphonal = amidosulphonal
861+ self.benny = benny
862+ self.catharticalness = catharticalness
863+ self.chirotherium = chirotherium
864+ self.disdiapason = disdiapason
865+ self.ensnare = ensnare
866+ self.homocerc = homocerc
867+ self.hybridizer = hybridizer
868+ self.leastwise = leastwise
869+ self.lof = lof
870+ self.monkhood = monkhood
871+ self.netherlandish = netherlandish
872+ self.nonbookish = nonbookish
873+ self.peonism = peonism
874+ self.phonelescope = phonelescope
875+ self.porphyrogeniture = porphyrogeniture
876+ self.preindemnify = preindemnify
877+ self.rosal = rosal
878+ self.scalenous = scalenous
879+ self.scopine = scopine
880+ self.sedaceae = sedaceae
881+ self.suberinize = suberinize
882+ self.symbiot = symbiot
883+ self.tablefellow = tablefellow
884+ self.unchargeable = unchargeable
885+ }
886+}
887+
888+// MARK: CoadjustClass convenience initializers and mutators
889+
890+extension CoadjustClass {
891+ convenience init(data: Data) throws {
892+ let me = try newJSONDecoder().decode(CoadjustClass.self, from: data)
893+ 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)
894+ }
895+
896+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
897+ guard let data = json.data(using: encoding) else {
898+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
899+ }
900+ try self.init(data: data)
901+ }
902+
903+ convenience init(fromURL url: URL) throws {
904+ try self.init(data: try Data(contentsOf: url))
905+ }
906+
907+ func with(
908+ amidosulphonal: JSONNull?? = nil,
909+ benny: JSONNull?? = nil,
910+ catharticalness: Double?? = nil,
911+ chirotherium: Int?? = nil,
912+ disdiapason: String?? = nil,
913+ ensnare: JSONNull?? = nil,
914+ homocerc: Bool?? = nil,
915+ hybridizer: JSONNull?? = nil,
916+ leastwise: JSONNull?? = nil,
917+ lof: JSONNull?? = nil,
918+ monkhood: JSONNull?? = nil,
919+ netherlandish: JSONNull?? = nil,
920+ nonbookish: JSONNull?? = nil,
921+ peonism: JSONNull?? = nil,
922+ phonelescope: JSONNull?? = nil,
923+ porphyrogeniture: JSONNull?? = nil,
924+ preindemnify: JSONNull?? = nil,
925+ rosal: JSONNull?? = nil,
926+ scalenous: JSONNull?? = nil,
927+ scopine: JSONNull?? = nil,
928+ sedaceae: JSONNull?? = nil,
929+ suberinize: JSONNull?? = nil,
930+ symbiot: JSONNull?? = nil,
931+ tablefellow: JSONNull?? = nil,
932+ unchargeable: JSONNull?? = nil
933+ ) -> CoadjustClass {
934+ return CoadjustClass(
935+ amidosulphonal: amidosulphonal ?? self.amidosulphonal,
936+ benny: benny ?? self.benny,
937+ catharticalness: catharticalness ?? self.catharticalness,
938+ chirotherium: chirotherium ?? self.chirotherium,
939+ disdiapason: disdiapason ?? self.disdiapason,
940+ ensnare: ensnare ?? self.ensnare,
941+ homocerc: homocerc ?? self.homocerc,
942+ hybridizer: hybridizer ?? self.hybridizer,
943+ leastwise: leastwise ?? self.leastwise,
944+ lof: lof ?? self.lof,
945+ monkhood: monkhood ?? self.monkhood,
946+ netherlandish: netherlandish ?? self.netherlandish,
947+ nonbookish: nonbookish ?? self.nonbookish,
948+ peonism: peonism ?? self.peonism,
949+ phonelescope: phonelescope ?? self.phonelescope,
950+ porphyrogeniture: porphyrogeniture ?? self.porphyrogeniture,
951+ preindemnify: preindemnify ?? self.preindemnify,
952+ rosal: rosal ?? self.rosal,
953+ scalenous: scalenous ?? self.scalenous,
954+ scopine: scopine ?? self.scopine,
955+ sedaceae: sedaceae ?? self.sedaceae,
956+ suberinize: suberinize ?? self.suberinize,
957+ symbiot: symbiot ?? self.symbiot,
958+ tablefellow: tablefellow ?? self.tablefellow,
959+ unchargeable: unchargeable ?? self.unchargeable
960+ )
961+ }
962+
963+ func jsonData() throws -> Data {
964+ return try newJSONEncoder().encode(self)
965+ }
966+
967+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
968+ return String(data: try self.jsonData(), encoding: encoding)
969+ }
970+}
971+
972+enum Consilience: Codable {
973+ case double(Double)
974+ case integerMap([String: Int])
975+
976+ init(from decoder: Decoder) throws {
977+ let container = try decoder.singleValueContainer()
978+ if let x = try? container.decode(Double.self) {
979+ self = .double(x)
980+ return
981+ }
982+ if let x = try? container.decode([String: Int].self) {
983+ self = .integerMap(x)
984+ return
985+ }
986+ throw DecodingError.typeMismatch(Consilience.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Consilience"))
987+ }
988+
989+ func encode(to encoder: Encoder) throws {
990+ var container = encoder.singleValueContainer()
991+ switch self {
992+ case .double(let x):
993+ try container.encode(x)
994+ case .integerMap(let x):
995+ try container.encode(x)
996+ }
997+ }
998+}
999+
1000+enum Constructor: Codable {
1001+ case bool(Bool)
1002+ case unionMap([String: Int?])
1003+
1004+ init(from decoder: Decoder) throws {
1005+ let container = try decoder.singleValueContainer()
1006+ if let x = try? container.decode(Bool.self) {
1007+ self = .bool(x)
1008+ return
1009+ }
1010+ if let x = try? container.decode([String: Int?].self) {
1011+ self = .unionMap(x)
1012+ return
1013+ }
1014+ throw DecodingError.typeMismatch(Constructor.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Constructor"))
1015+ }
1016+
1017+ func encode(to encoder: Encoder) throws {
1018+ var container = encoder.singleValueContainer()
1019+ switch self {
1020+ case .bool(let x):
1021+ try container.encode(x)
1022+ case .unionMap(let x):
1023+ try container.encode(x)
1024+ }
1025+ }
1026+}
1027+
1028+enum Continuative: Codable {
1029+ case integerMap([String: Int])
1030+ case string(String)
1031+
1032+ init(from decoder: Decoder) throws {
1033+ let container = try decoder.singleValueContainer()
1034+ if let x = try? container.decode([String: Int].self) {
1035+ self = .integerMap(x)
1036+ return
1037+ }
1038+ if let x = try? container.decode(String.self) {
1039+ self = .string(x)
1040+ return
1041+ }
1042+ throw DecodingError.typeMismatch(Continuative.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Continuative"))
1043+ }
1044+
1045+ func encode(to encoder: Encoder) throws {
1046+ var container = encoder.singleValueContainer()
1047+ switch self {
1048+ case .integerMap(let x):
1049+ try container.encode(x)
1050+ case .string(let x):
1051+ try container.encode(x)
1052+ }
1053+ }
1054+}
1055+
1056+enum CredulityElement: Codable {
1057+ case credulityClass(CredulityClass)
1058+ case integer(Int)
1059+ case string(String)
1060+
1061+ init(from decoder: Decoder) throws {
1062+ let container = try decoder.singleValueContainer()
1063+ if let x = try? container.decode(Int.self) {
1064+ self = .integer(x)
1065+ return
1066+ }
1067+ if let x = try? container.decode(String.self) {
1068+ self = .string(x)
1069+ return
1070+ }
1071+ if let x = try? container.decode(CredulityClass.self) {
1072+ self = .credulityClass(x)
1073+ return
1074+ }
1075+ throw DecodingError.typeMismatch(CredulityElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CredulityElement"))
1076+ }
1077+
1078+ func encode(to encoder: Encoder) throws {
1079+ var container = encoder.singleValueContainer()
1080+ switch self {
1081+ case .credulityClass(let x):
1082+ try container.encode(x)
1083+ case .integer(let x):
1084+ try container.encode(x)
1085+ case .string(let x):
1086+ try container.encode(x)
1087+ }
1088+ }
1089+}
1090+
1091+// MARK: - CredulityClass
1092+final class CredulityClass: Codable {
1093+ let ammonolytic: JSONNull?
1094+ let bushmaster: JSONNull?
1095+ let considering: JSONNull?
1096+ let consuetudinary: JSONNull?
1097+ let embarras: JSONNull?
1098+ let fineness: JSONNull?
1099+ let flaithship: JSONNull?
1100+ let flavia: JSONNull?
1101+ let gruffly: JSONNull?
1102+ let hedychium: JSONNull?
1103+ let leadwort: JSONNull?
1104+ let overseriously: JSONNull?
1105+ let parabola: JSONNull?
1106+ let pectinatodenticulate: JSONNull?
1107+ let popean: JSONNull?
1108+ let pornocrat: JSONNull?
1109+ let quadrisect: JSONNull?
1110+ let seriality: JSONNull?
1111+ let vamphorn: JSONNull?
1112+ let wharp: JSONNull?
1113+
1114+ enum CodingKeys: String, CodingKey {
1115+ case ammonolytic = "ammonolytic"
1116+ case bushmaster = "bushmaster"
1117+ case considering = "considering"
1118+ case consuetudinary = "consuetudinary"
1119+ case embarras = "embarras"
1120+ case fineness = "fineness"
1121+ case flaithship = "flaithship"
1122+ case flavia = "Flavia"
1123+ case gruffly = "gruffly"
1124+ case hedychium = "Hedychium"
1125+ case leadwort = "leadwort"
1126+ case overseriously = "overseriously"
1127+ case parabola = "parabola"
1128+ case pectinatodenticulate = "pectinatodenticulate"
1129+ case popean = "Popean"
1130+ case pornocrat = "pornocrat"
1131+ case quadrisect = "quadrisect"
1132+ case seriality = "seriality"
1133+ case vamphorn = "vamphorn"
1134+ case wharp = "wharp"
1135+ }
1136+
1137+ 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?) {
1138+ self.ammonolytic = ammonolytic
1139+ self.bushmaster = bushmaster
1140+ self.considering = considering
1141+ self.consuetudinary = consuetudinary
1142+ self.embarras = embarras
1143+ self.fineness = fineness
1144+ self.flaithship = flaithship
1145+ self.flavia = flavia
1146+ self.gruffly = gruffly
1147+ self.hedychium = hedychium
1148+ self.leadwort = leadwort
1149+ self.overseriously = overseriously
1150+ self.parabola = parabola
1151+ self.pectinatodenticulate = pectinatodenticulate
1152+ self.popean = popean
1153+ self.pornocrat = pornocrat
1154+ self.quadrisect = quadrisect
1155+ self.seriality = seriality
1156+ self.vamphorn = vamphorn
1157+ self.wharp = wharp
1158+ }
1159+}
1160+
1161+// MARK: CredulityClass convenience initializers and mutators
1162+
1163+extension CredulityClass {
1164+ convenience init(data: Data) throws {
1165+ let me = try newJSONDecoder().decode(CredulityClass.self, from: data)
1166+ 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)
1167+ }
1168+
1169+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1170+ guard let data = json.data(using: encoding) else {
1171+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1172+ }
1173+ try self.init(data: data)
1174+ }
1175+
1176+ convenience init(fromURL url: URL) throws {
1177+ try self.init(data: try Data(contentsOf: url))
1178+ }
1179+
1180+ func with(
1181+ ammonolytic: JSONNull?? = nil,
1182+ bushmaster: JSONNull?? = nil,
1183+ considering: JSONNull?? = nil,
1184+ consuetudinary: JSONNull?? = nil,
1185+ embarras: JSONNull?? = nil,
1186+ fineness: JSONNull?? = nil,
1187+ flaithship: JSONNull?? = nil,
1188+ flavia: JSONNull?? = nil,
1189+ gruffly: JSONNull?? = nil,
1190+ hedychium: JSONNull?? = nil,
1191+ leadwort: JSONNull?? = nil,
1192+ overseriously: JSONNull?? = nil,
1193+ parabola: JSONNull?? = nil,
1194+ pectinatodenticulate: JSONNull?? = nil,
1195+ popean: JSONNull?? = nil,
1196+ pornocrat: JSONNull?? = nil,
1197+ quadrisect: JSONNull?? = nil,
1198+ seriality: JSONNull?? = nil,
1199+ vamphorn: JSONNull?? = nil,
1200+ wharp: JSONNull?? = nil
1201+ ) -> CredulityClass {
1202+ return CredulityClass(
1203+ ammonolytic: ammonolytic ?? self.ammonolytic,
1204+ bushmaster: bushmaster ?? self.bushmaster,
1205+ considering: considering ?? self.considering,
1206+ consuetudinary: consuetudinary ?? self.consuetudinary,
1207+ embarras: embarras ?? self.embarras,
1208+ fineness: fineness ?? self.fineness,
1209+ flaithship: flaithship ?? self.flaithship,
1210+ flavia: flavia ?? self.flavia,
1211+ gruffly: gruffly ?? self.gruffly,
1212+ hedychium: hedychium ?? self.hedychium,
1213+ leadwort: leadwort ?? self.leadwort,
1214+ overseriously: overseriously ?? self.overseriously,
1215+ parabola: parabola ?? self.parabola,
1216+ pectinatodenticulate: pectinatodenticulate ?? self.pectinatodenticulate,
1217+ popean: popean ?? self.popean,
1218+ pornocrat: pornocrat ?? self.pornocrat,
1219+ quadrisect: quadrisect ?? self.quadrisect,
1220+ seriality: seriality ?? self.seriality,
1221+ vamphorn: vamphorn ?? self.vamphorn,
1222+ wharp: wharp ?? self.wharp
1223+ )
1224+ }
1225+
1226+ func jsonData() throws -> Data {
1227+ return try newJSONEncoder().encode(self)
1228+ }
1229+
1230+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1231+ return String(data: try self.jsonData(), encoding: encoding)
1232+ }
1233+}
1234+
1235+enum Creviced: Codable {
1236+ case bool(Bool)
1237+ case integerMap([String: Int])
1238+ case string(String)
1239+
1240+ init(from decoder: Decoder) throws {
1241+ let container = try decoder.singleValueContainer()
1242+ if let x = try? container.decode(Bool.self) {
1243+ self = .bool(x)
1244+ return
1245+ }
1246+ if let x = try? container.decode([String: Int].self) {
1247+ self = .integerMap(x)
1248+ return
1249+ }
1250+ if let x = try? container.decode(String.self) {
1251+ self = .string(x)
1252+ return
1253+ }
1254+ throw DecodingError.typeMismatch(Creviced.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Creviced"))
1255+ }
1256+
1257+ func encode(to encoder: Encoder) throws {
1258+ var container = encoder.singleValueContainer()
1259+ switch self {
1260+ case .bool(let x):
1261+ try container.encode(x)
1262+ case .integerMap(let x):
1263+ try container.encode(x)
1264+ case .string(let x):
1265+ try container.encode(x)
1266+ }
1267+ }
1268+}
1269+
1270+enum DeruralizeElement: Codable {
1271+ case bool(Bool)
1272+ case deruralizeClass(DeruralizeClass)
1273+ case nullArray([JSONNull?])
1274+
1275+ init(from decoder: Decoder) throws {
1276+ let container = try decoder.singleValueContainer()
1277+ if let x = try? container.decode(Bool.self) {
1278+ self = .bool(x)
1279+ return
1280+ }
1281+ if let x = try? container.decode([JSONNull?].self) {
1282+ self = .nullArray(x)
1283+ return
1284+ }
1285+ if let x = try? container.decode(DeruralizeClass.self) {
1286+ self = .deruralizeClass(x)
1287+ return
1288+ }
1289+ throw DecodingError.typeMismatch(DeruralizeElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for DeruralizeElement"))
1290+ }
1291+
1292+ func encode(to encoder: Encoder) throws {
1293+ var container = encoder.singleValueContainer()
1294+ switch self {
1295+ case .bool(let x):
1296+ try container.encode(x)
1297+ case .deruralizeClass(let x):
1298+ try container.encode(x)
1299+ case .nullArray(let x):
1300+ try container.encode(x)
1301+ }
1302+ }
1303+}
1304+
1305+// MARK: - DeruralizeClass
1306+final class DeruralizeClass: Codable {
1307+ let bockerel: JSONNull?
1308+ let boulder: JSONNull?
1309+ let churrus: JSONNull?
1310+ let counterdigged: JSONNull?
1311+ let dialogite: JSONNull?
1312+ let digenic: JSONNull?
1313+ let dunbird: JSONNull?
1314+ let ergatogyne: JSONNull?
1315+ let fiendful: JSONNull?
1316+ let jackrod: JSONNull?
1317+ let jehovistic: JSONNull?
1318+ let paninean: JSONNull?
1319+ let panther: JSONNull?
1320+ let placentigerous: JSONNull?
1321+ let romney: JSONNull?
1322+ let sparm: JSONNull?
1323+ let tocsin: JSONNull?
1324+ let unnicked: JSONNull?
1325+ let unstavable: JSONNull?
1326+ let windfirm: JSONNull?
1327+
1328+ enum CodingKeys: String, CodingKey {
1329+ case bockerel = "bockerel"
1330+ case boulder = "boulder"
1331+ case churrus = "churrus"
1332+ case counterdigged = "counterdigged"
1333+ case dialogite = "dialogite"
1334+ case digenic = "digenic"
1335+ case dunbird = "dunbird"
1336+ case ergatogyne = "ergatogyne"
1337+ case fiendful = "fiendful"
1338+ case jackrod = "jackrod"
1339+ case jehovistic = "Jehovistic"
1340+ case paninean = "Paninean"
1341+ case panther = "panther"
1342+ case placentigerous = "placentigerous"
1343+ case romney = "Romney"
1344+ case sparm = "sparm"
1345+ case tocsin = "tocsin"
1346+ case unnicked = "unnicked"
1347+ case unstavable = "unstavable"
1348+ case windfirm = "windfirm"
1349+ }
1350+
1351+ 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?) {
1352+ self.bockerel = bockerel
1353+ self.boulder = boulder
1354+ self.churrus = churrus
1355+ self.counterdigged = counterdigged
1356+ self.dialogite = dialogite
1357+ self.digenic = digenic
1358+ self.dunbird = dunbird
1359+ self.ergatogyne = ergatogyne
1360+ self.fiendful = fiendful
1361+ self.jackrod = jackrod
1362+ self.jehovistic = jehovistic
1363+ self.paninean = paninean
1364+ self.panther = panther
1365+ self.placentigerous = placentigerous
1366+ self.romney = romney
1367+ self.sparm = sparm
1368+ self.tocsin = tocsin
1369+ self.unnicked = unnicked
1370+ self.unstavable = unstavable
1371+ self.windfirm = windfirm
1372+ }
1373+}
1374+
1375+// MARK: DeruralizeClass convenience initializers and mutators
1376+
1377+extension DeruralizeClass {
1378+ convenience init(data: Data) throws {
1379+ let me = try newJSONDecoder().decode(DeruralizeClass.self, from: data)
1380+ 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)
1381+ }
1382+
1383+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1384+ guard let data = json.data(using: encoding) else {
1385+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1386+ }
1387+ try self.init(data: data)
1388+ }
1389+
1390+ convenience init(fromURL url: URL) throws {
1391+ try self.init(data: try Data(contentsOf: url))
1392+ }
1393+
1394+ func with(
1395+ bockerel: JSONNull?? = nil,
1396+ boulder: JSONNull?? = nil,
1397+ churrus: JSONNull?? = nil,
1398+ counterdigged: JSONNull?? = nil,
1399+ dialogite: JSONNull?? = nil,
1400+ digenic: JSONNull?? = nil,
1401+ dunbird: JSONNull?? = nil,
1402+ ergatogyne: JSONNull?? = nil,
1403+ fiendful: JSONNull?? = nil,
1404+ jackrod: JSONNull?? = nil,
1405+ jehovistic: JSONNull?? = nil,
1406+ paninean: JSONNull?? = nil,
1407+ panther: JSONNull?? = nil,
1408+ placentigerous: JSONNull?? = nil,
1409+ romney: JSONNull?? = nil,
1410+ sparm: JSONNull?? = nil,
1411+ tocsin: JSONNull?? = nil,
1412+ unnicked: JSONNull?? = nil,
1413+ unstavable: JSONNull?? = nil,
1414+ windfirm: JSONNull?? = nil
1415+ ) -> DeruralizeClass {
1416+ return DeruralizeClass(
1417+ bockerel: bockerel ?? self.bockerel,
1418+ boulder: boulder ?? self.boulder,
1419+ churrus: churrus ?? self.churrus,
1420+ counterdigged: counterdigged ?? self.counterdigged,
1421+ dialogite: dialogite ?? self.dialogite,
1422+ digenic: digenic ?? self.digenic,
1423+ dunbird: dunbird ?? self.dunbird,
1424+ ergatogyne: ergatogyne ?? self.ergatogyne,
1425+ fiendful: fiendful ?? self.fiendful,
1426+ jackrod: jackrod ?? self.jackrod,
1427+ jehovistic: jehovistic ?? self.jehovistic,
1428+ paninean: paninean ?? self.paninean,
1429+ panther: panther ?? self.panther,
1430+ placentigerous: placentigerous ?? self.placentigerous,
1431+ romney: romney ?? self.romney,
1432+ sparm: sparm ?? self.sparm,
1433+ tocsin: tocsin ?? self.tocsin,
1434+ unnicked: unnicked ?? self.unnicked,
1435+ unstavable: unstavable ?? self.unstavable,
1436+ windfirm: windfirm ?? self.windfirm
1437+ )
1438+ }
1439+
1440+ func jsonData() throws -> Data {
1441+ return try newJSONEncoder().encode(self)
1442+ }
1443+
1444+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1445+ return String(data: try self.jsonData(), encoding: encoding)
1446+ }
1447+}
1448+
1449+enum DiaereseElement: Codable {
1450+ case bool(Bool)
1451+ case diaereseClass(DiaereseClass)
1452+ case integerArray([Int])
1453+
1454+ init(from decoder: Decoder) throws {
1455+ let container = try decoder.singleValueContainer()
1456+ if let x = try? container.decode(Bool.self) {
1457+ self = .bool(x)
1458+ return
1459+ }
1460+ if let x = try? container.decode([Int].self) {
1461+ self = .integerArray(x)
1462+ return
1463+ }
1464+ if let x = try? container.decode(DiaereseClass.self) {
1465+ self = .diaereseClass(x)
1466+ return
1467+ }
1468+ throw DecodingError.typeMismatch(DiaereseElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for DiaereseElement"))
1469+ }
1470+
1471+ func encode(to encoder: Encoder) throws {
1472+ var container = encoder.singleValueContainer()
1473+ switch self {
1474+ case .bool(let x):
1475+ try container.encode(x)
1476+ case .diaereseClass(let x):
1477+ try container.encode(x)
1478+ case .integerArray(let x):
1479+ try container.encode(x)
1480+ }
1481+ }
1482+}
1483+
1484+// MARK: - DiaereseClass
1485+final class DiaereseClass: Codable {
1486+ let amoreuxia: JSONNull?
1487+ let ani: JSONNull?
1488+ let bernicle: JSONNull?
1489+ let blackwasher: JSONNull?
1490+ let blowhard: JSONNull?
1491+ let broma: JSONNull?
1492+ let closecross: JSONNull?
1493+ let congregationalism: JSONNull?
1494+ let grayly: JSONNull?
1495+ let historically: JSONNull?
1496+ let hoast: JSONNull?
1497+ let irretentive: JSONNull?
1498+ let parcener: JSONNull?
1499+ let pedder: JSONNull?
1500+ let pseudoanatomic: JSONNull?
1501+ let rhizocarpian: JSONNull?
1502+ let samel: JSONNull?
1503+ let silker: JSONNull?
1504+ let subdentated: JSONNull?
1505+ let subobscure: JSONNull?
1506+
1507+ enum CodingKeys: String, CodingKey {
1508+ case amoreuxia = "Amoreuxia"
1509+ case ani = "ani"
1510+ case bernicle = "bernicle"
1511+ case blackwasher = "blackwasher"
1512+ case blowhard = "blowhard"
1513+ case broma = "broma"
1514+ case closecross = "closecross"
1515+ case congregationalism = "congregationalism"
1516+ case grayly = "grayly"
1517+ case historically = "historically"
1518+ case hoast = "hoast"
1519+ case irretentive = "irretentive"
1520+ case parcener = "parcener"
1521+ case pedder = "pedder"
1522+ case pseudoanatomic = "pseudoanatomic"
1523+ case rhizocarpian = "rhizocarpian"
1524+ case samel = "samel"
1525+ case silker = "silker"
1526+ case subdentated = "subdentated"
1527+ case subobscure = "subobscure"
1528+ }
1529+
1530+ 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?) {
1531+ self.amoreuxia = amoreuxia
1532+ self.ani = ani
1533+ self.bernicle = bernicle
1534+ self.blackwasher = blackwasher
1535+ self.blowhard = blowhard
1536+ self.broma = broma
1537+ self.closecross = closecross
1538+ self.congregationalism = congregationalism
1539+ self.grayly = grayly
1540+ self.historically = historically
1541+ self.hoast = hoast
1542+ self.irretentive = irretentive
1543+ self.parcener = parcener
1544+ self.pedder = pedder
1545+ self.pseudoanatomic = pseudoanatomic
1546+ self.rhizocarpian = rhizocarpian
1547+ self.samel = samel
1548+ self.silker = silker
1549+ self.subdentated = subdentated
1550+ self.subobscure = subobscure
1551+ }
1552+}
1553+
1554+// MARK: DiaereseClass convenience initializers and mutators
1555+
1556+extension DiaereseClass {
1557+ convenience init(data: Data) throws {
1558+ let me = try newJSONDecoder().decode(DiaereseClass.self, from: data)
1559+ 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)
1560+ }
1561+
1562+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1563+ guard let data = json.data(using: encoding) else {
1564+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1565+ }
1566+ try self.init(data: data)
1567+ }
1568+
1569+ convenience init(fromURL url: URL) throws {
1570+ try self.init(data: try Data(contentsOf: url))
1571+ }
1572+
1573+ func with(
1574+ amoreuxia: JSONNull?? = nil,
1575+ ani: JSONNull?? = nil,
1576+ bernicle: JSONNull?? = nil,
1577+ blackwasher: JSONNull?? = nil,
1578+ blowhard: JSONNull?? = nil,
1579+ broma: JSONNull?? = nil,
1580+ closecross: JSONNull?? = nil,
1581+ congregationalism: JSONNull?? = nil,
1582+ grayly: JSONNull?? = nil,
1583+ historically: JSONNull?? = nil,
1584+ hoast: JSONNull?? = nil,
1585+ irretentive: JSONNull?? = nil,
1586+ parcener: JSONNull?? = nil,
1587+ pedder: JSONNull?? = nil,
1588+ pseudoanatomic: JSONNull?? = nil,
1589+ rhizocarpian: JSONNull?? = nil,
1590+ samel: JSONNull?? = nil,
1591+ silker: JSONNull?? = nil,
1592+ subdentated: JSONNull?? = nil,
1593+ subobscure: JSONNull?? = nil
1594+ ) -> DiaereseClass {
1595+ return DiaereseClass(
1596+ amoreuxia: amoreuxia ?? self.amoreuxia,
1597+ ani: ani ?? self.ani,
1598+ bernicle: bernicle ?? self.bernicle,
1599+ blackwasher: blackwasher ?? self.blackwasher,
1600+ blowhard: blowhard ?? self.blowhard,
1601+ broma: broma ?? self.broma,
1602+ closecross: closecross ?? self.closecross,
1603+ congregationalism: congregationalism ?? self.congregationalism,
1604+ grayly: grayly ?? self.grayly,
1605+ historically: historically ?? self.historically,
1606+ hoast: hoast ?? self.hoast,
1607+ irretentive: irretentive ?? self.irretentive,
1608+ parcener: parcener ?? self.parcener,
1609+ pedder: pedder ?? self.pedder,
1610+ pseudoanatomic: pseudoanatomic ?? self.pseudoanatomic,
1611+ rhizocarpian: rhizocarpian ?? self.rhizocarpian,
1612+ samel: samel ?? self.samel,
1613+ silker: silker ?? self.silker,
1614+ subdentated: subdentated ?? self.subdentated,
1615+ subobscure: subobscure ?? self.subobscure
1616+ )
1617+ }
1618+
1619+ func jsonData() throws -> Data {
1620+ return try newJSONEncoder().encode(self)
1621+ }
1622+
1623+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1624+ return String(data: try self.jsonData(), encoding: encoding)
1625+ }
1626+}
1627+
1628+enum Downstroke: Codable {
1629+ case bool(Bool)
1630+ case nullArray([JSONNull?])
1631+ case string(String)
1632+
1633+ init(from decoder: Decoder) throws {
1634+ let container = try decoder.singleValueContainer()
1635+ if let x = try? container.decode(Bool.self) {
1636+ self = .bool(x)
1637+ return
1638+ }
1639+ if let x = try? container.decode([JSONNull?].self) {
1640+ self = .nullArray(x)
1641+ return
1642+ }
1643+ if let x = try? container.decode(String.self) {
1644+ self = .string(x)
1645+ return
1646+ }
1647+ throw DecodingError.typeMismatch(Downstroke.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Downstroke"))
1648+ }
1649+
1650+ func encode(to encoder: Encoder) throws {
1651+ var container = encoder.singleValueContainer()
1652+ switch self {
1653+ case .bool(let x):
1654+ try container.encode(x)
1655+ case .nullArray(let x):
1656+ try container.encode(x)
1657+ case .string(let x):
1658+ try container.encode(x)
1659+ }
1660+ }
1661+}
1662+
1663+enum Eleutheromania: Codable {
1664+ case double(Double)
1665+ case integerMap([String: Int])
1666+ case string(String)
1667+
1668+ init(from decoder: Decoder) throws {
1669+ let container = try decoder.singleValueContainer()
1670+ if let x = try? container.decode(Double.self) {
1671+ self = .double(x)
1672+ return
1673+ }
1674+ if let x = try? container.decode([String: Int].self) {
1675+ self = .integerMap(x)
1676+ return
1677+ }
1678+ if let x = try? container.decode(String.self) {
1679+ self = .string(x)
1680+ return
1681+ }
1682+ throw DecodingError.typeMismatch(Eleutheromania.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Eleutheromania"))
1683+ }
1684+
1685+ func encode(to encoder: Encoder) throws {
1686+ var container = encoder.singleValueContainer()
1687+ switch self {
1688+ case .double(let x):
1689+ try container.encode(x)
1690+ case .integerMap(let x):
1691+ try container.encode(x)
1692+ case .string(let x):
1693+ try container.encode(x)
1694+ }
1695+ }
1696+}
1697+
1698+// MARK: - Encrust
1699+final class Encrust: Codable {
1700+ let comradely: JSONNull?
1701+ let diacanthous: JSONNull?
1702+ let feminineness: JSONNull?
1703+ let gossamered: JSONNull?
1704+ let hibernia: JSONNull?
1705+ let hibiscus: JSONNull?
1706+ let lepidosauria: JSONNull?
1707+ let lollingly: JSONNull?
1708+ let manager: JSONNull?
1709+ let mechanic: JSONNull?
1710+ let overminuteness: JSONNull?
1711+ let papelonne: JSONNull?
1712+ let plebification: JSONNull?
1713+ let pugmiller: JSONNull?
1714+ let recoveror: JSONNull?
1715+ let spermatoblastic: JSONNull?
1716+ let syllidae: JSONNull?
1717+ let ungyved: JSONNull?
1718+ let whirlabout: JSONNull?
1719+ let woodenware: JSONNull?
1720+
1721+ enum CodingKeys: String, CodingKey {
1722+ case comradely = "comradely"
1723+ case diacanthous = "diacanthous"
1724+ case feminineness = "feminineness"
1725+ case gossamered = "gossamered"
1726+ case hibernia = "Hibernia"
1727+ case hibiscus = "Hibiscus"
1728+ case lepidosauria = "Lepidosauria"
1729+ case lollingly = "lollingly"
1730+ case manager = "manager"
1731+ case mechanic = "mechanic"
1732+ case overminuteness = "overminuteness"
1733+ case papelonne = "papelonne"
1734+ case plebification = "plebification"
1735+ case pugmiller = "pugmiller"
1736+ case recoveror = "recoveror"
1737+ case spermatoblastic = "spermatoblastic"
1738+ case syllidae = "Syllidae"
1739+ case ungyved = "ungyved"
1740+ case whirlabout = "whirlabout"
1741+ case woodenware = "woodenware"
1742+ }
1743+
1744+ 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?) {
1745+ self.comradely = comradely
1746+ self.diacanthous = diacanthous
1747+ self.feminineness = feminineness
1748+ self.gossamered = gossamered
1749+ self.hibernia = hibernia
1750+ self.hibiscus = hibiscus
1751+ self.lepidosauria = lepidosauria
1752+ self.lollingly = lollingly
1753+ self.manager = manager
1754+ self.mechanic = mechanic
1755+ self.overminuteness = overminuteness
1756+ self.papelonne = papelonne
1757+ self.plebification = plebification
1758+ self.pugmiller = pugmiller
1759+ self.recoveror = recoveror
1760+ self.spermatoblastic = spermatoblastic
1761+ self.syllidae = syllidae
1762+ self.ungyved = ungyved
1763+ self.whirlabout = whirlabout
1764+ self.woodenware = woodenware
1765+ }
1766+}
1767+
1768+// MARK: Encrust convenience initializers and mutators
1769+
1770+extension Encrust {
1771+ convenience init(data: Data) throws {
1772+ let me = try newJSONDecoder().decode(Encrust.self, from: data)
1773+ 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)
1774+ }
1775+
1776+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1777+ guard let data = json.data(using: encoding) else {
1778+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1779+ }
1780+ try self.init(data: data)
1781+ }
1782+
1783+ convenience init(fromURL url: URL) throws {
1784+ try self.init(data: try Data(contentsOf: url))
1785+ }
1786+
1787+ func with(
1788+ comradely: JSONNull?? = nil,
1789+ diacanthous: JSONNull?? = nil,
1790+ feminineness: JSONNull?? = nil,
1791+ gossamered: JSONNull?? = nil,
1792+ hibernia: JSONNull?? = nil,
1793+ hibiscus: JSONNull?? = nil,
1794+ lepidosauria: JSONNull?? = nil,
1795+ lollingly: JSONNull?? = nil,
1796+ manager: JSONNull?? = nil,
1797+ mechanic: JSONNull?? = nil,
1798+ overminuteness: JSONNull?? = nil,
1799+ papelonne: JSONNull?? = nil,
1800+ plebification: JSONNull?? = nil,
1801+ pugmiller: JSONNull?? = nil,
1802+ recoveror: JSONNull?? = nil,
1803+ spermatoblastic: JSONNull?? = nil,
1804+ syllidae: JSONNull?? = nil,
1805+ ungyved: JSONNull?? = nil,
1806+ whirlabout: JSONNull?? = nil,
1807+ woodenware: JSONNull?? = nil
1808+ ) -> Encrust {
1809+ return Encrust(
1810+ comradely: comradely ?? self.comradely,
1811+ diacanthous: diacanthous ?? self.diacanthous,
1812+ feminineness: feminineness ?? self.feminineness,
1813+ gossamered: gossamered ?? self.gossamered,
1814+ hibernia: hibernia ?? self.hibernia,
1815+ hibiscus: hibiscus ?? self.hibiscus,
1816+ lepidosauria: lepidosauria ?? self.lepidosauria,
1817+ lollingly: lollingly ?? self.lollingly,
1818+ manager: manager ?? self.manager,
1819+ mechanic: mechanic ?? self.mechanic,
1820+ overminuteness: overminuteness ?? self.overminuteness,
1821+ papelonne: papelonne ?? self.papelonne,
1822+ plebification: plebification ?? self.plebification,
1823+ pugmiller: pugmiller ?? self.pugmiller,
1824+ recoveror: recoveror ?? self.recoveror,
1825+ spermatoblastic: spermatoblastic ?? self.spermatoblastic,
1826+ syllidae: syllidae ?? self.syllidae,
1827+ ungyved: ungyved ?? self.ungyved,
1828+ whirlabout: whirlabout ?? self.whirlabout,
1829+ woodenware: woodenware ?? self.woodenware
1830+ )
1831+ }
1832+
1833+ func jsonData() throws -> Data {
1834+ return try newJSONEncoder().encode(self)
1835+ }
1836+
1837+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1838+ return String(data: try self.jsonData(), encoding: encoding)
1839+ }
1840+}
1841+
1842+enum Entomoid: Codable {
1843+ case cimeliaClass(CimeliaClass)
1844+ case integer(Int)
1845+
1846+ init(from decoder: Decoder) throws {
1847+ let container = try decoder.singleValueContainer()
1848+ if let x = try? container.decode(Int.self) {
1849+ self = .integer(x)
1850+ return
1851+ }
1852+ if let x = try? container.decode(CimeliaClass.self) {
1853+ self = .cimeliaClass(x)
1854+ return
1855+ }
1856+ throw DecodingError.typeMismatch(Entomoid.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Entomoid"))
1857+ }
1858+
1859+ func encode(to encoder: Encoder) throws {
1860+ var container = encoder.singleValueContainer()
1861+ switch self {
1862+ case .cimeliaClass(let x):
1863+ try container.encode(x)
1864+ case .integer(let x):
1865+ try container.encode(x)
1866+ }
1867+ }
1868+}
1869+
1870+enum Epipaleolithic: Codable {
1871+ case double(Double)
1872+ case integerArray([Int])
1873+
1874+ init(from decoder: Decoder) throws {
1875+ let container = try decoder.singleValueContainer()
1876+ if let x = try? container.decode([Int].self) {
1877+ self = .integerArray(x)
1878+ return
1879+ }
1880+ if let x = try? container.decode(Double.self) {
1881+ self = .double(x)
1882+ return
1883+ }
1884+ throw DecodingError.typeMismatch(Epipaleolithic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Epipaleolithic"))
1885+ }
1886+
1887+ func encode(to encoder: Encoder) throws {
1888+ var container = encoder.singleValueContainer()
1889+ switch self {
1890+ case .double(let x):
1891+ try container.encode(x)
1892+ case .integerArray(let x):
1893+ try container.encode(x)
1894+ }
1895+ }
1896+}
1897+
1898+enum Expropriable: Codable {
1899+ case cimeliaClass(CimeliaClass)
1900+ case double(Double)
1901+ case nullArray([JSONNull?])
1902+
1903+ init(from decoder: Decoder) throws {
1904+ let container = try decoder.singleValueContainer()
1905+ if let x = try? container.decode([JSONNull?].self) {
1906+ self = .nullArray(x)
1907+ return
1908+ }
1909+ if let x = try? container.decode(Double.self) {
1910+ self = .double(x)
1911+ return
1912+ }
1913+ if let x = try? container.decode(CimeliaClass.self) {
1914+ self = .cimeliaClass(x)
1915+ return
1916+ }
1917+ throw DecodingError.typeMismatch(Expropriable.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Expropriable"))
1918+ }
1919+
1920+ func encode(to encoder: Encoder) throws {
1921+ var container = encoder.singleValueContainer()
1922+ switch self {
1923+ case .cimeliaClass(let x):
1924+ try container.encode(x)
1925+ case .double(let x):
1926+ try container.encode(x)
1927+ case .nullArray(let x):
1928+ try container.encode(x)
1929+ }
1930+ }
1931+}
1932+
1933+enum FagginglyElement: Codable {
1934+ case double(Double)
1935+ case fagginglyClass(FagginglyClass)
1936+
1937+ init(from decoder: Decoder) throws {
1938+ let container = try decoder.singleValueContainer()
1939+ if let x = try? container.decode(Double.self) {
1940+ self = .double(x)
1941+ return
1942+ }
1943+ if let x = try? container.decode(FagginglyClass.self) {
1944+ self = .fagginglyClass(x)
1945+ return
1946+ }
1947+ throw DecodingError.typeMismatch(FagginglyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for FagginglyElement"))
1948+ }
1949+
1950+ func encode(to encoder: Encoder) throws {
1951+ var container = encoder.singleValueContainer()
1952+ switch self {
1953+ case .double(let x):
1954+ try container.encode(x)
1955+ case .fagginglyClass(let x):
1956+ try container.encode(x)
1957+ }
1958+ }
1959+}
1960+
1961+// MARK: - FagginglyClass
1962+final class FagginglyClass: Codable {
1963+ let abranchian: JSONNull?
1964+ let aculeiform: JSONNull?
1965+ let adiaphoristic: JSONNull?
1966+ let adoptionism: JSONNull?
1967+ let anglic: JSONNull?
1968+ let antrotomy: JSONNull?
1969+ let coerciveness: JSONNull?
1970+ let decorist: JSONNull?
1971+ let duckhood: JSONNull?
1972+ let heteromeri: JSONNull?
1973+ let hypochnose: JSONNull?
1974+ let lochage: JSONNull?
1975+ let melee: JSONNull?
1976+ let nonconformitant: JSONNull?
1977+ let poinsettia: JSONNull?
1978+ let putatively: JSONNull?
1979+ let semivolatile: JSONNull?
1980+ let soleas: JSONNull?
1981+ let unfastenable: JSONNull?
1982+ let unmillinered: JSONNull?
1983+
1984+ enum CodingKeys: String, CodingKey {
1985+ case abranchian = "abranchian"
1986+ case aculeiform = "aculeiform"
1987+ case adiaphoristic = "adiaphoristic"
1988+ case adoptionism = "adoptionism"
1989+ case anglic = "Anglic"
1990+ case antrotomy = "antrotomy"
1991+ case coerciveness = "coerciveness"
1992+ case decorist = "decorist"
1993+ case duckhood = "duckhood"
1994+ case heteromeri = "Heteromeri"
1995+ case hypochnose = "hypochnose"
1996+ case lochage = "lochage"
1997+ case melee = "melee"
1998+ case nonconformitant = "nonconformitant"
1999+ case poinsettia = "Poinsettia"
2000+ case putatively = "putatively"
2001+ case semivolatile = "semivolatile"
2002+ case soleas = "soleas"
2003+ case unfastenable = "unfastenable"
2004+ case unmillinered = "unmillinered"
2005+ }
2006+
2007+ 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?) {
2008+ self.abranchian = abranchian
2009+ self.aculeiform = aculeiform
2010+ self.adiaphoristic = adiaphoristic
2011+ self.adoptionism = adoptionism
2012+ self.anglic = anglic
2013+ self.antrotomy = antrotomy
2014+ self.coerciveness = coerciveness
2015+ self.decorist = decorist
2016+ self.duckhood = duckhood
2017+ self.heteromeri = heteromeri
2018+ self.hypochnose = hypochnose
2019+ self.lochage = lochage
2020+ self.melee = melee
2021+ self.nonconformitant = nonconformitant
2022+ self.poinsettia = poinsettia
2023+ self.putatively = putatively
2024+ self.semivolatile = semivolatile
2025+ self.soleas = soleas
2026+ self.unfastenable = unfastenable
2027+ self.unmillinered = unmillinered
2028+ }
2029+}
2030+
2031+// MARK: FagginglyClass convenience initializers and mutators
2032+
2033+extension FagginglyClass {
2034+ convenience init(data: Data) throws {
2035+ let me = try newJSONDecoder().decode(FagginglyClass.self, from: data)
2036+ 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)
2037+ }
2038+
2039+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2040+ guard let data = json.data(using: encoding) else {
2041+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2042+ }
2043+ try self.init(data: data)
2044+ }
2045+
2046+ convenience init(fromURL url: URL) throws {
2047+ try self.init(data: try Data(contentsOf: url))
2048+ }
2049+
2050+ func with(
2051+ abranchian: JSONNull?? = nil,
2052+ aculeiform: JSONNull?? = nil,
2053+ adiaphoristic: JSONNull?? = nil,
2054+ adoptionism: JSONNull?? = nil,
2055+ anglic: JSONNull?? = nil,
2056+ antrotomy: JSONNull?? = nil,
2057+ coerciveness: JSONNull?? = nil,
2058+ decorist: JSONNull?? = nil,
2059+ duckhood: JSONNull?? = nil,
2060+ heteromeri: JSONNull?? = nil,
2061+ hypochnose: JSONNull?? = nil,
2062+ lochage: JSONNull?? = nil,
2063+ melee: JSONNull?? = nil,
2064+ nonconformitant: JSONNull?? = nil,
2065+ poinsettia: JSONNull?? = nil,
2066+ putatively: JSONNull?? = nil,
2067+ semivolatile: JSONNull?? = nil,
2068+ soleas: JSONNull?? = nil,
2069+ unfastenable: JSONNull?? = nil,
2070+ unmillinered: JSONNull?? = nil
2071+ ) -> FagginglyClass {
2072+ return FagginglyClass(
2073+ abranchian: abranchian ?? self.abranchian,
2074+ aculeiform: aculeiform ?? self.aculeiform,
2075+ adiaphoristic: adiaphoristic ?? self.adiaphoristic,
2076+ adoptionism: adoptionism ?? self.adoptionism,
2077+ anglic: anglic ?? self.anglic,
2078+ antrotomy: antrotomy ?? self.antrotomy,
2079+ coerciveness: coerciveness ?? self.coerciveness,
2080+ decorist: decorist ?? self.decorist,
2081+ duckhood: duckhood ?? self.duckhood,
2082+ heteromeri: heteromeri ?? self.heteromeri,
2083+ hypochnose: hypochnose ?? self.hypochnose,
2084+ lochage: lochage ?? self.lochage,
2085+ melee: melee ?? self.melee,
2086+ nonconformitant: nonconformitant ?? self.nonconformitant,
2087+ poinsettia: poinsettia ?? self.poinsettia,
2088+ putatively: putatively ?? self.putatively,
2089+ semivolatile: semivolatile ?? self.semivolatile,
2090+ soleas: soleas ?? self.soleas,
2091+ unfastenable: unfastenable ?? self.unfastenable,
2092+ unmillinered: unmillinered ?? self.unmillinered
2093+ )
2094+ }
2095+
2096+ func jsonData() throws -> Data {
2097+ return try newJSONEncoder().encode(self)
2098+ }
2099+
2100+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2101+ return String(data: try self.jsonData(), encoding: encoding)
2102+ }
2103+}
2104+
2105+enum FenkElement: Codable {
2106+ case fenkClass(FenkClass)
2107+ case string(String)
2108+
2109+ init(from decoder: Decoder) throws {
2110+ let container = try decoder.singleValueContainer()
2111+ if let x = try? container.decode(String.self) {
2112+ self = .string(x)
2113+ return
2114+ }
2115+ if let x = try? container.decode(FenkClass.self) {
2116+ self = .fenkClass(x)
2117+ return
2118+ }
2119+ throw DecodingError.typeMismatch(FenkElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for FenkElement"))
2120+ }
2121+
2122+ func encode(to encoder: Encoder) throws {
2123+ var container = encoder.singleValueContainer()
2124+ switch self {
2125+ case .fenkClass(let x):
2126+ try container.encode(x)
2127+ case .string(let x):
2128+ try container.encode(x)
2129+ }
2130+ }
2131+}
2132+
2133+// MARK: - FenkClass
2134+final class FenkClass: Codable {
2135+ let apoise: JSONNull?
2136+ let astronomize: JSONNull?
2137+ let cockhorse: JSONNull?
2138+ let copular: JSONNull?
2139+ let dagomba: JSONNull?
2140+ let draffy: JSONNull?
2141+ let foreigner: JSONNull?
2142+ let guyandot: JSONNull?
2143+ let neurogliosis: JSONNull?
2144+ let osmious: JSONNull?
2145+ let palpitate: JSONNull?
2146+ let rebukeable: JSONNull?
2147+ let reinwardtia: JSONNull?
2148+ let reservatory: JSONNull?
2149+ let scalt: JSONNull?
2150+ let scripturalize: JSONNull?
2151+ let tintometer: JSONNull?
2152+ let tritoness: JSONNull?
2153+ let undergrade: JSONNull?
2154+ let undermountain: JSONNull?
2155+
2156+ enum CodingKeys: String, CodingKey {
2157+ case apoise = "apoise"
2158+ case astronomize = "astronomize"
2159+ case cockhorse = "cockhorse"
2160+ case copular = "copular"
2161+ case dagomba = "Dagomba"
2162+ case draffy = "draffy"
2163+ case foreigner = "foreigner"
2164+ case guyandot = "Guyandot"
2165+ case neurogliosis = "neurogliosis"
2166+ case osmious = "osmious"
2167+ case palpitate = "palpitate"
2168+ case rebukeable = "rebukeable"
2169+ case reinwardtia = "Reinwardtia"
2170+ case reservatory = "reservatory"
2171+ case scalt = "scalt"
2172+ case scripturalize = "scripturalize"
2173+ case tintometer = "tintometer"
2174+ case tritoness = "Tritoness"
2175+ case undergrade = "undergrade"
2176+ case undermountain = "undermountain"
2177+ }
2178+
2179+ 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?) {
2180+ self.apoise = apoise
2181+ self.astronomize = astronomize
2182+ self.cockhorse = cockhorse
2183+ self.copular = copular
2184+ self.dagomba = dagomba
2185+ self.draffy = draffy
2186+ self.foreigner = foreigner
2187+ self.guyandot = guyandot
2188+ self.neurogliosis = neurogliosis
2189+ self.osmious = osmious
2190+ self.palpitate = palpitate
2191+ self.rebukeable = rebukeable
2192+ self.reinwardtia = reinwardtia
2193+ self.reservatory = reservatory
2194+ self.scalt = scalt
2195+ self.scripturalize = scripturalize
2196+ self.tintometer = tintometer
2197+ self.tritoness = tritoness
2198+ self.undergrade = undergrade
2199+ self.undermountain = undermountain
2200+ }
2201+}
2202+
2203+// MARK: FenkClass convenience initializers and mutators
2204+
2205+extension FenkClass {
2206+ convenience init(data: Data) throws {
2207+ let me = try newJSONDecoder().decode(FenkClass.self, from: data)
2208+ 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)
2209+ }
2210+
2211+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2212+ guard let data = json.data(using: encoding) else {
2213+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2214+ }
2215+ try self.init(data: data)
2216+ }
2217+
2218+ convenience init(fromURL url: URL) throws {
2219+ try self.init(data: try Data(contentsOf: url))
2220+ }
2221+
2222+ func with(
2223+ apoise: JSONNull?? = nil,
2224+ astronomize: JSONNull?? = nil,
2225+ cockhorse: JSONNull?? = nil,
2226+ copular: JSONNull?? = nil,
2227+ dagomba: JSONNull?? = nil,
2228+ draffy: JSONNull?? = nil,
2229+ foreigner: JSONNull?? = nil,
2230+ guyandot: JSONNull?? = nil,
2231+ neurogliosis: JSONNull?? = nil,
2232+ osmious: JSONNull?? = nil,
2233+ palpitate: JSONNull?? = nil,
2234+ rebukeable: JSONNull?? = nil,
2235+ reinwardtia: JSONNull?? = nil,
2236+ reservatory: JSONNull?? = nil,
2237+ scalt: JSONNull?? = nil,
2238+ scripturalize: JSONNull?? = nil,
2239+ tintometer: JSONNull?? = nil,
2240+ tritoness: JSONNull?? = nil,
2241+ undergrade: JSONNull?? = nil,
2242+ undermountain: JSONNull?? = nil
2243+ ) -> FenkClass {
2244+ return FenkClass(
2245+ apoise: apoise ?? self.apoise,
2246+ astronomize: astronomize ?? self.astronomize,
2247+ cockhorse: cockhorse ?? self.cockhorse,
2248+ copular: copular ?? self.copular,
2249+ dagomba: dagomba ?? self.dagomba,
2250+ draffy: draffy ?? self.draffy,
2251+ foreigner: foreigner ?? self.foreigner,
2252+ guyandot: guyandot ?? self.guyandot,
2253+ neurogliosis: neurogliosis ?? self.neurogliosis,
2254+ osmious: osmious ?? self.osmious,
2255+ palpitate: palpitate ?? self.palpitate,
2256+ rebukeable: rebukeable ?? self.rebukeable,
2257+ reinwardtia: reinwardtia ?? self.reinwardtia,
2258+ reservatory: reservatory ?? self.reservatory,
2259+ scalt: scalt ?? self.scalt,
2260+ scripturalize: scripturalize ?? self.scripturalize,
2261+ tintometer: tintometer ?? self.tintometer,
2262+ tritoness: tritoness ?? self.tritoness,
2263+ undergrade: undergrade ?? self.undergrade,
2264+ undermountain: undermountain ?? self.undermountain
2265+ )
2266+ }
2267+
2268+ func jsonData() throws -> Data {
2269+ return try newJSONEncoder().encode(self)
2270+ }
2271+
2272+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2273+ return String(data: try self.jsonData(), encoding: encoding)
2274+ }
2275+}
2276+
2277+enum FlagmakingElement: Codable {
2278+ case bool(Bool)
2279+ case double(Double)
2280+ case flagmakingClass(FlagmakingClass)
2281+
2282+ init(from decoder: Decoder) throws {
2283+ let container = try decoder.singleValueContainer()
2284+ if let x = try? container.decode(Bool.self) {
2285+ self = .bool(x)
2286+ return
2287+ }
2288+ if let x = try? container.decode(Double.self) {
2289+ self = .double(x)
2290+ return
2291+ }
2292+ if let x = try? container.decode(FlagmakingClass.self) {
2293+ self = .flagmakingClass(x)
2294+ return
2295+ }
2296+ throw DecodingError.typeMismatch(FlagmakingElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for FlagmakingElement"))
2297+ }
2298+
2299+ func encode(to encoder: Encoder) throws {
2300+ var container = encoder.singleValueContainer()
2301+ switch self {
2302+ case .bool(let x):
2303+ try container.encode(x)
2304+ case .double(let x):
2305+ try container.encode(x)
2306+ case .flagmakingClass(let x):
2307+ try container.encode(x)
2308+ }
2309+ }
2310+}
2311+
2312+// MARK: - FlagmakingClass
2313+final class FlagmakingClass: Codable {
2314+ let albarco: JSONNull?
2315+ let bunodonta: JSONNull?
2316+ let hornify: JSONNull?
2317+ let hydrocorisae: JSONNull?
2318+ let hypoglossus: JSONNull?
2319+ let inexpiably: JSONNull?
2320+ let ingratitude: JSONNull?
2321+ let ladyfly: JSONNull?
2322+ let medicament: JSONNull?
2323+ let monogrammatic: JSONNull?
2324+ let nobbut: JSONNull?
2325+ let notacanthidae: JSONNull?
2326+ let polyplacophore: JSONNull?
2327+ let proexercise: JSONNull?
2328+ let protoplast: JSONNull?
2329+ let puzzling: JSONNull?
2330+ let splanchnoskeleton: JSONNull?
2331+ let unloveliness: JSONNull?
2332+ let unquarantined: JSONNull?
2333+ let unrenounceable: JSONNull?
2334+
2335+ enum CodingKeys: String, CodingKey {
2336+ case albarco = "albarco"
2337+ case bunodonta = "Bunodonta"
2338+ case hornify = "hornify"
2339+ case hydrocorisae = "Hydrocorisae"
2340+ case hypoglossus = "hypoglossus"
2341+ case inexpiably = "inexpiably"
2342+ case ingratitude = "ingratitude"
2343+ case ladyfly = "ladyfly"
2344+ case medicament = "medicament"
2345+ case monogrammatic = "monogrammatic"
2346+ case nobbut = "nobbut"
2347+ case notacanthidae = "Notacanthidae"
2348+ case polyplacophore = "polyplacophore"
2349+ case proexercise = "proexercise"
2350+ case protoplast = "protoplast"
2351+ case puzzling = "puzzling"
2352+ case splanchnoskeleton = "splanchnoskeleton"
2353+ case unloveliness = "unloveliness"
2354+ case unquarantined = "unquarantined"
2355+ case unrenounceable = "unrenounceable"
2356+ }
2357+
2358+ 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?) {
2359+ self.albarco = albarco
2360+ self.bunodonta = bunodonta
2361+ self.hornify = hornify
2362+ self.hydrocorisae = hydrocorisae
2363+ self.hypoglossus = hypoglossus
2364+ self.inexpiably = inexpiably
2365+ self.ingratitude = ingratitude
2366+ self.ladyfly = ladyfly
2367+ self.medicament = medicament
2368+ self.monogrammatic = monogrammatic
2369+ self.nobbut = nobbut
2370+ self.notacanthidae = notacanthidae
2371+ self.polyplacophore = polyplacophore
2372+ self.proexercise = proexercise
2373+ self.protoplast = protoplast
2374+ self.puzzling = puzzling
2375+ self.splanchnoskeleton = splanchnoskeleton
2376+ self.unloveliness = unloveliness
2377+ self.unquarantined = unquarantined
2378+ self.unrenounceable = unrenounceable
2379+ }
2380+}
2381+
2382+// MARK: FlagmakingClass convenience initializers and mutators
2383+
2384+extension FlagmakingClass {
2385+ convenience init(data: Data) throws {
2386+ let me = try newJSONDecoder().decode(FlagmakingClass.self, from: data)
2387+ 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)
2388+ }
2389+
2390+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2391+ guard let data = json.data(using: encoding) else {
2392+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2393+ }
2394+ try self.init(data: data)
2395+ }
2396+
2397+ convenience init(fromURL url: URL) throws {
2398+ try self.init(data: try Data(contentsOf: url))
2399+ }
2400+
2401+ func with(
2402+ albarco: JSONNull?? = nil,
2403+ bunodonta: JSONNull?? = nil,
2404+ hornify: JSONNull?? = nil,
2405+ hydrocorisae: JSONNull?? = nil,
2406+ hypoglossus: JSONNull?? = nil,
2407+ inexpiably: JSONNull?? = nil,
2408+ ingratitude: JSONNull?? = nil,
2409+ ladyfly: JSONNull?? = nil,
2410+ medicament: JSONNull?? = nil,
2411+ monogrammatic: JSONNull?? = nil,
2412+ nobbut: JSONNull?? = nil,
2413+ notacanthidae: JSONNull?? = nil,
2414+ polyplacophore: JSONNull?? = nil,
2415+ proexercise: JSONNull?? = nil,
2416+ protoplast: JSONNull?? = nil,
2417+ puzzling: JSONNull?? = nil,
2418+ splanchnoskeleton: JSONNull?? = nil,
2419+ unloveliness: JSONNull?? = nil,
2420+ unquarantined: JSONNull?? = nil,
2421+ unrenounceable: JSONNull?? = nil
2422+ ) -> FlagmakingClass {
2423+ return FlagmakingClass(
2424+ albarco: albarco ?? self.albarco,
2425+ bunodonta: bunodonta ?? self.bunodonta,
2426+ hornify: hornify ?? self.hornify,
2427+ hydrocorisae: hydrocorisae ?? self.hydrocorisae,
2428+ hypoglossus: hypoglossus ?? self.hypoglossus,
2429+ inexpiably: inexpiably ?? self.inexpiably,
2430+ ingratitude: ingratitude ?? self.ingratitude,
2431+ ladyfly: ladyfly ?? self.ladyfly,
2432+ medicament: medicament ?? self.medicament,
2433+ monogrammatic: monogrammatic ?? self.monogrammatic,
2434+ nobbut: nobbut ?? self.nobbut,
2435+ notacanthidae: notacanthidae ?? self.notacanthidae,
2436+ polyplacophore: polyplacophore ?? self.polyplacophore,
2437+ proexercise: proexercise ?? self.proexercise,
2438+ protoplast: protoplast ?? self.protoplast,
2439+ puzzling: puzzling ?? self.puzzling,
2440+ splanchnoskeleton: splanchnoskeleton ?? self.splanchnoskeleton,
2441+ unloveliness: unloveliness ?? self.unloveliness,
2442+ unquarantined: unquarantined ?? self.unquarantined,
2443+ unrenounceable: unrenounceable ?? self.unrenounceable
2444+ )
2445+ }
2446+
2447+ func jsonData() throws -> Data {
2448+ return try newJSONEncoder().encode(self)
2449+ }
2450+
2451+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2452+ return String(data: try self.jsonData(), encoding: encoding)
2453+ }
2454+}
2455+
2456+enum Fluorometer: Codable {
2457+ case integer(Int)
2458+ case string(String)
2459+ case null
2460+
2461+ init(from decoder: Decoder) throws {
2462+ let container = try decoder.singleValueContainer()
2463+ if let x = try? container.decode(Int.self) {
2464+ self = .integer(x)
2465+ return
2466+ }
2467+ if let x = try? container.decode(String.self) {
2468+ self = .string(x)
2469+ return
2470+ }
2471+ if container.decodeNil() {
2472+ self = .null
2473+ return
2474+ }
2475+ throw DecodingError.typeMismatch(Fluorometer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Fluorometer"))
2476+ }
2477+
2478+ func encode(to encoder: Encoder) throws {
2479+ var container = encoder.singleValueContainer()
2480+ switch self {
2481+ case .integer(let x):
2482+ try container.encode(x)
2483+ case .string(let x):
2484+ try container.encode(x)
2485+ case .null:
2486+ try container.encodeNil()
2487+ }
2488+ }
2489+}
2490+
2491+enum Fuzzy: Codable {
2492+ case integer(Int)
2493+ case unionMap([String: Int?])
2494+
2495+ init(from decoder: Decoder) throws {
2496+ let container = try decoder.singleValueContainer()
2497+ if let x = try? container.decode(Int.self) {
2498+ self = .integer(x)
2499+ return
2500+ }
2501+ if let x = try? container.decode([String: Int?].self) {
2502+ self = .unionMap(x)
2503+ return
2504+ }
2505+ throw DecodingError.typeMismatch(Fuzzy.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Fuzzy"))
2506+ }
2507+
2508+ func encode(to encoder: Encoder) throws {
2509+ var container = encoder.singleValueContainer()
2510+ switch self {
2511+ case .integer(let x):
2512+ try container.encode(x)
2513+ case .unionMap(let x):
2514+ try container.encode(x)
2515+ }
2516+ }
2517+}
2518+
2519+enum Gardenward: Codable {
2520+ case bool(Bool)
2521+ case integerArray([Int])
2522+ case string(String)
2523+
2524+ init(from decoder: Decoder) throws {
2525+ let container = try decoder.singleValueContainer()
2526+ if let x = try? container.decode(Bool.self) {
2527+ self = .bool(x)
2528+ return
2529+ }
2530+ if let x = try? container.decode([Int].self) {
2531+ self = .integerArray(x)
2532+ return
2533+ }
2534+ if let x = try? container.decode(String.self) {
2535+ self = .string(x)
2536+ return
2537+ }
2538+ throw DecodingError.typeMismatch(Gardenward.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Gardenward"))
2539+ }
2540+
2541+ func encode(to encoder: Encoder) throws {
2542+ var container = encoder.singleValueContainer()
2543+ switch self {
2544+ case .bool(let x):
2545+ try container.encode(x)
2546+ case .integerArray(let x):
2547+ try container.encode(x)
2548+ case .string(let x):
2549+ try container.encode(x)
2550+ }
2551+ }
2552+}
2553+
2554+enum Generalissimo: Codable {
2555+ case bool(Bool)
2556+ case integerMap([String: Int])
2557+ case null
2558+
2559+ init(from decoder: Decoder) throws {
2560+ let container = try decoder.singleValueContainer()
2561+ if let x = try? container.decode(Bool.self) {
2562+ self = .bool(x)
2563+ return
2564+ }
2565+ if let x = try? container.decode([String: Int].self) {
2566+ self = .integerMap(x)
2567+ return
2568+ }
2569+ if container.decodeNil() {
2570+ self = .null
2571+ return
2572+ }
2573+ throw DecodingError.typeMismatch(Generalissimo.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Generalissimo"))
2574+ }
2575+
2576+ func encode(to encoder: Encoder) throws {
2577+ var container = encoder.singleValueContainer()
2578+ switch self {
2579+ case .bool(let x):
2580+ try container.encode(x)
2581+ case .integerMap(let x):
2582+ try container.encode(x)
2583+ case .null:
2584+ try container.encodeNil()
2585+ }
2586+ }
2587+}
2588+
2589+enum Hemicrystalline: Codable {
2590+ case cimeliaClass(CimeliaClass)
2591+ case string(String)
2592+
2593+ init(from decoder: Decoder) throws {
2594+ let container = try decoder.singleValueContainer()
2595+ if let x = try? container.decode(String.self) {
2596+ self = .string(x)
2597+ return
2598+ }
2599+ if let x = try? container.decode(CimeliaClass.self) {
2600+ self = .cimeliaClass(x)
2601+ return
2602+ }
2603+ throw DecodingError.typeMismatch(Hemicrystalline.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hemicrystalline"))
2604+ }
2605+
2606+ func encode(to encoder: Encoder) throws {
2607+ var container = encoder.singleValueContainer()
2608+ switch self {
2609+ case .cimeliaClass(let x):
2610+ try container.encode(x)
2611+ case .string(let x):
2612+ try container.encode(x)
2613+ }
2614+ }
2615+}
2616+
2617+enum HemocoeleElement: Codable {
2618+ case hemocoeleClass(HemocoeleClass)
2619+ case integerArray([Int])
2620+
2621+ init(from decoder: Decoder) throws {
2622+ let container = try decoder.singleValueContainer()
2623+ if let x = try? container.decode([Int].self) {
2624+ self = .integerArray(x)
2625+ return
2626+ }
2627+ if let x = try? container.decode(HemocoeleClass.self) {
2628+ self = .hemocoeleClass(x)
2629+ return
2630+ }
2631+ throw DecodingError.typeMismatch(HemocoeleElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for HemocoeleElement"))
2632+ }
2633+
2634+ func encode(to encoder: Encoder) throws {
2635+ var container = encoder.singleValueContainer()
2636+ switch self {
2637+ case .hemocoeleClass(let x):
2638+ try container.encode(x)
2639+ case .integerArray(let x):
2640+ try container.encode(x)
2641+ }
2642+ }
2643+}
2644+
2645+// MARK: - HemocoeleClass
2646+final class HemocoeleClass: Codable {
2647+ let acrogamy: JSONNull?
2648+ let amelification: JSONNull?
2649+ let autobiographic: JSONNull?
2650+ let berat: JSONNull?
2651+ let catharticalness: Double?
2652+ let chirotherium: Int?
2653+ let disdiapason: String?
2654+ let disproportionably: JSONNull?
2655+ let erythrite: JSONNull?
2656+ let graphic: JSONNull?
2657+ let hepatological: JSONNull?
2658+ let homocerc: Bool?
2659+ let incommensurably: JSONNull?
2660+ let misaffirm: JSONNull?
2661+ let nonbookish: JSONNull?
2662+ let pocketbook: JSONNull?
2663+ let sclerometric: JSONNull?
2664+ let stambouline: JSONNull?
2665+ let stickpin: JSONNull?
2666+ let tubulure: JSONNull?
2667+ let undelated: JSONNull?
2668+ let unsalt: JSONNull?
2669+ let untutelar: JSONNull?
2670+ let vagrant: JSONNull?
2671+ let walt: JSONNull?
2672+
2673+ enum CodingKeys: String, CodingKey {
2674+ case acrogamy = "acrogamy"
2675+ case amelification = "amelification"
2676+ case autobiographic = "autobiographic"
2677+ case berat = "berat"
2678+ case catharticalness = "catharticalness"
2679+ case chirotherium = "Chirotherium"
2680+ case disdiapason = "disdiapason"
2681+ case disproportionably = "disproportionably"
2682+ case erythrite = "erythrite"
2683+ case graphic = "graphic"
2684+ case hepatological = "hepatological"
2685+ case homocerc = "homocerc"
2686+ case incommensurably = "incommensurably"
2687+ case misaffirm = "misaffirm"
2688+ case nonbookish = "nonbookish"
2689+ case pocketbook = "pocketbook"
2690+ case sclerometric = "sclerometric"
2691+ case stambouline = "stambouline"
2692+ case stickpin = "stickpin"
2693+ case tubulure = "tubulure"
2694+ case undelated = "undelated"
2695+ case unsalt = "unsalt"
2696+ case untutelar = "untutelar"
2697+ case vagrant = "vagrant"
2698+ case walt = "Walt"
2699+ }
2700+
2701+ 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?) {
2702+ self.acrogamy = acrogamy
2703+ self.amelification = amelification
2704+ self.autobiographic = autobiographic
2705+ self.berat = berat
2706+ self.catharticalness = catharticalness
2707+ self.chirotherium = chirotherium
2708+ self.disdiapason = disdiapason
2709+ self.disproportionably = disproportionably
2710+ self.erythrite = erythrite
2711+ self.graphic = graphic
2712+ self.hepatological = hepatological
2713+ self.homocerc = homocerc
2714+ self.incommensurably = incommensurably
2715+ self.misaffirm = misaffirm
2716+ self.nonbookish = nonbookish
2717+ self.pocketbook = pocketbook
2718+ self.sclerometric = sclerometric
2719+ self.stambouline = stambouline
2720+ self.stickpin = stickpin
2721+ self.tubulure = tubulure
2722+ self.undelated = undelated
2723+ self.unsalt = unsalt
2724+ self.untutelar = untutelar
2725+ self.vagrant = vagrant
2726+ self.walt = walt
2727+ }
2728+}
2729+
2730+// MARK: HemocoeleClass convenience initializers and mutators
2731+
2732+extension HemocoeleClass {
2733+ convenience init(data: Data) throws {
2734+ let me = try newJSONDecoder().decode(HemocoeleClass.self, from: data)
2735+ 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)
2736+ }
2737+
2738+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2739+ guard let data = json.data(using: encoding) else {
2740+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2741+ }
2742+ try self.init(data: data)
2743+ }
2744+
2745+ convenience init(fromURL url: URL) throws {
2746+ try self.init(data: try Data(contentsOf: url))
2747+ }
2748+
2749+ func with(
2750+ acrogamy: JSONNull?? = nil,
2751+ amelification: JSONNull?? = nil,
2752+ autobiographic: JSONNull?? = nil,
2753+ berat: JSONNull?? = nil,
2754+ catharticalness: Double?? = nil,
2755+ chirotherium: Int?? = nil,
2756+ disdiapason: String?? = nil,
2757+ disproportionably: JSONNull?? = nil,
2758+ erythrite: JSONNull?? = nil,
2759+ graphic: JSONNull?? = nil,
2760+ hepatological: JSONNull?? = nil,
2761+ homocerc: Bool?? = nil,
2762+ incommensurably: JSONNull?? = nil,
2763+ misaffirm: JSONNull?? = nil,
2764+ nonbookish: JSONNull?? = nil,
2765+ pocketbook: JSONNull?? = nil,
2766+ sclerometric: JSONNull?? = nil,
2767+ stambouline: JSONNull?? = nil,
2768+ stickpin: JSONNull?? = nil,
2769+ tubulure: JSONNull?? = nil,
2770+ undelated: JSONNull?? = nil,
2771+ unsalt: JSONNull?? = nil,
2772+ untutelar: JSONNull?? = nil,
2773+ vagrant: JSONNull?? = nil,
2774+ walt: JSONNull?? = nil
2775+ ) -> HemocoeleClass {
2776+ return HemocoeleClass(
2777+ acrogamy: acrogamy ?? self.acrogamy,
2778+ amelification: amelification ?? self.amelification,
2779+ autobiographic: autobiographic ?? self.autobiographic,
2780+ berat: berat ?? self.berat,
2781+ catharticalness: catharticalness ?? self.catharticalness,
2782+ chirotherium: chirotherium ?? self.chirotherium,
2783+ disdiapason: disdiapason ?? self.disdiapason,
2784+ disproportionably: disproportionably ?? self.disproportionably,
2785+ erythrite: erythrite ?? self.erythrite,
2786+ graphic: graphic ?? self.graphic,
2787+ hepatological: hepatological ?? self.hepatological,
2788+ homocerc: homocerc ?? self.homocerc,
2789+ incommensurably: incommensurably ?? self.incommensurably,
2790+ misaffirm: misaffirm ?? self.misaffirm,
2791+ nonbookish: nonbookish ?? self.nonbookish,
2792+ pocketbook: pocketbook ?? self.pocketbook,
2793+ sclerometric: sclerometric ?? self.sclerometric,
2794+ stambouline: stambouline ?? self.stambouline,
2795+ stickpin: stickpin ?? self.stickpin,
2796+ tubulure: tubulure ?? self.tubulure,
2797+ undelated: undelated ?? self.undelated,
2798+ unsalt: unsalt ?? self.unsalt,
2799+ untutelar: untutelar ?? self.untutelar,
2800+ vagrant: vagrant ?? self.vagrant,
2801+ walt: walt ?? self.walt
2802+ )
2803+ }
2804+
2805+ func jsonData() throws -> Data {
2806+ return try newJSONEncoder().encode(self)
2807+ }
2808+
2809+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2810+ return String(data: try self.jsonData(), encoding: encoding)
2811+ }
2812+}
2813+
2814+enum Hoister: Codable {
2815+ case cimeliaClass(CimeliaClass)
2816+ case string(String)
2817+ case null
2818+
2819+ init(from decoder: Decoder) throws {
2820+ let container = try decoder.singleValueContainer()
2821+ if let x = try? container.decode(String.self) {
2822+ self = .string(x)
2823+ return
2824+ }
2825+ if let x = try? container.decode(CimeliaClass.self) {
2826+ self = .cimeliaClass(x)
2827+ return
2828+ }
2829+ if container.decodeNil() {
2830+ self = .null
2831+ return
2832+ }
2833+ throw DecodingError.typeMismatch(Hoister.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hoister"))
2834+ }
2835+
2836+ func encode(to encoder: Encoder) throws {
2837+ var container = encoder.singleValueContainer()
2838+ switch self {
2839+ case .cimeliaClass(let x):
2840+ try container.encode(x)
2841+ case .string(let x):
2842+ try container.encode(x)
2843+ case .null:
2844+ try container.encodeNil()
2845+ }
2846+ }
2847+}
2848+
2849+enum Hyperpiesi: Codable {
2850+ case cimeliaClass(CimeliaClass)
2851+ case nullArray([JSONNull?])
2852+ case null
2853+
2854+ init(from decoder: Decoder) throws {
2855+ let container = try decoder.singleValueContainer()
2856+ if let x = try? container.decode([JSONNull?].self) {
2857+ self = .nullArray(x)
2858+ return
2859+ }
2860+ if let x = try? container.decode(CimeliaClass.self) {
2861+ self = .cimeliaClass(x)
2862+ return
2863+ }
2864+ if container.decodeNil() {
2865+ self = .null
2866+ return
2867+ }
2868+ throw DecodingError.typeMismatch(Hyperpiesi.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hyperpiesi"))
2869+ }
2870+
2871+ func encode(to encoder: Encoder) throws {
2872+ var container = encoder.singleValueContainer()
2873+ switch self {
2874+ case .cimeliaClass(let x):
2875+ try container.encode(x)
2876+ case .nullArray(let x):
2877+ try container.encode(x)
2878+ case .null:
2879+ try container.encodeNil()
2880+ }
2881+ }
2882+}
2883+
2884+enum Hyppish: Codable {
2885+ case bool(Bool)
2886+ case string(String)
2887+ case null
2888+
2889+ init(from decoder: Decoder) throws {
2890+ let container = try decoder.singleValueContainer()
2891+ if let x = try? container.decode(Bool.self) {
2892+ self = .bool(x)
2893+ return
2894+ }
2895+ if let x = try? container.decode(String.self) {
2896+ self = .string(x)
2897+ return
2898+ }
2899+ if container.decodeNil() {
2900+ self = .null
2901+ return
2902+ }
2903+ throw DecodingError.typeMismatch(Hyppish.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hyppish"))
2904+ }
2905+
2906+ func encode(to encoder: Encoder) throws {
2907+ var container = encoder.singleValueContainer()
2908+ switch self {
2909+ case .bool(let x):
2910+ try container.encode(x)
2911+ case .string(let x):
2912+ try container.encode(x)
2913+ case .null:
2914+ try container.encodeNil()
2915+ }
2916+ }
2917+}
2918+
2919+enum Idealizer: Codable {
2920+ case cimeliaClass(CimeliaClass)
2921+ case integer(Int)
2922+ case nullArray([JSONNull?])
2923+
2924+ init(from decoder: Decoder) throws {
2925+ let container = try decoder.singleValueContainer()
2926+ if let x = try? container.decode(Int.self) {
2927+ self = .integer(x)
2928+ return
2929+ }
2930+ if let x = try? container.decode([JSONNull?].self) {
2931+ self = .nullArray(x)
2932+ return
2933+ }
2934+ if let x = try? container.decode(CimeliaClass.self) {
2935+ self = .cimeliaClass(x)
2936+ return
2937+ }
2938+ throw DecodingError.typeMismatch(Idealizer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Idealizer"))
2939+ }
2940+
2941+ func encode(to encoder: Encoder) throws {
2942+ var container = encoder.singleValueContainer()
2943+ switch self {
2944+ case .cimeliaClass(let x):
2945+ try container.encode(x)
2946+ case .integer(let x):
2947+ try container.encode(x)
2948+ case .nullArray(let x):
2949+ try container.encode(x)
2950+ }
2951+ }
2952+}
2953+
2954+enum Incrustator: Codable {
2955+ case integer(Int)
2956+ case integerArray([Int])
2957+ case string(String)
2958+
2959+ init(from decoder: Decoder) throws {
2960+ let container = try decoder.singleValueContainer()
2961+ if let x = try? container.decode(Int.self) {
2962+ self = .integer(x)
2963+ return
2964+ }
2965+ if let x = try? container.decode([Int].self) {
2966+ self = .integerArray(x)
2967+ return
2968+ }
2969+ if let x = try? container.decode(String.self) {
2970+ self = .string(x)
2971+ return
2972+ }
2973+ throw DecodingError.typeMismatch(Incrustator.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Incrustator"))
2974+ }
2975+
2976+ func encode(to encoder: Encoder) throws {
2977+ var container = encoder.singleValueContainer()
2978+ switch self {
2979+ case .integer(let x):
2980+ try container.encode(x)
2981+ case .integerArray(let x):
2982+ try container.encode(x)
2983+ case .string(let x):
2984+ try container.encode(x)
2985+ }
2986+ }
2987+}
2988+
2989+enum Intentiveness: Codable {
2990+ case cimeliaClass(CimeliaClass)
2991+ case double(Double)
2992+ case string(String)
2993+
2994+ init(from decoder: Decoder) throws {
2995+ let container = try decoder.singleValueContainer()
2996+ if let x = try? container.decode(Double.self) {
2997+ self = .double(x)
2998+ return
2999+ }
3000+ if let x = try? container.decode(String.self) {
3001+ self = .string(x)
3002+ return
3003+ }
3004+ if let x = try? container.decode(CimeliaClass.self) {
3005+ self = .cimeliaClass(x)
3006+ return
3007+ }
3008+ throw DecodingError.typeMismatch(Intentiveness.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Intentiveness"))
3009+ }
3010+
3011+ func encode(to encoder: Encoder) throws {
3012+ var container = encoder.singleValueContainer()
3013+ switch self {
3014+ case .cimeliaClass(let x):
3015+ try container.encode(x)
3016+ case .double(let x):
3017+ try container.encode(x)
3018+ case .string(let x):
3019+ try container.encode(x)
3020+ }
3021+ }
3022+}
3023+
3024+// MARK: - Interacinar
3025+final class Interacinar: Codable {
3026+ let assapan: Double
3027+ let benefactorship: Bool
3028+ let triseriatim: String
3029+ let tubbing: Int
3030+ let untrimmed: JSONNull?
3031+
3032+ enum CodingKeys: String, CodingKey {
3033+ case assapan = "assapan"
3034+ case benefactorship = "benefactorship"
3035+ case triseriatim = "triseriatim"
3036+ case tubbing = "tubbing"
3037+ case untrimmed = "untrimmed"
3038+ }
3039+
3040+ init(assapan: Double, benefactorship: Bool, triseriatim: String, tubbing: Int, untrimmed: JSONNull?) {
3041+ self.assapan = assapan
3042+ self.benefactorship = benefactorship
3043+ self.triseriatim = triseriatim
3044+ self.tubbing = tubbing
3045+ self.untrimmed = untrimmed
3046+ }
3047+}
3048+
3049+// MARK: Interacinar convenience initializers and mutators
3050+
3051+extension Interacinar {
3052+ convenience init(data: Data) throws {
3053+ let me = try newJSONDecoder().decode(Interacinar.self, from: data)
3054+ self.init(assapan: me.assapan, benefactorship: me.benefactorship, triseriatim: me.triseriatim, tubbing: me.tubbing, untrimmed: me.untrimmed)
3055+ }
3056+
3057+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
3058+ guard let data = json.data(using: encoding) else {
3059+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
3060+ }
3061+ try self.init(data: data)
3062+ }
3063+
3064+ convenience init(fromURL url: URL) throws {
3065+ try self.init(data: try Data(contentsOf: url))
3066+ }
3067+
3068+ func with(
3069+ assapan: Double? = nil,
3070+ benefactorship: Bool? = nil,
3071+ triseriatim: String? = nil,
3072+ tubbing: Int? = nil,
3073+ untrimmed: JSONNull?? = nil
3074+ ) -> Interacinar {
3075+ return Interacinar(
3076+ assapan: assapan ?? self.assapan,
3077+ benefactorship: benefactorship ?? self.benefactorship,
3078+ triseriatim: triseriatim ?? self.triseriatim,
3079+ tubbing: tubbing ?? self.tubbing,
3080+ untrimmed: untrimmed ?? self.untrimmed
3081+ )
3082+ }
3083+
3084+ func jsonData() throws -> Data {
3085+ return try newJSONEncoder().encode(self)
3086+ }
3087+
3088+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
3089+ return String(data: try self.jsonData(), encoding: encoding)
3090+ }
3091+}
3092+
3093+enum Jacutinga: Codable {
3094+ case integerArray([Int])
3095+ case unionMap([String: Int?])
3096+
3097+ init(from decoder: Decoder) throws {
3098+ let container = try decoder.singleValueContainer()
3099+ if let x = try? container.decode([Int].self) {
3100+ self = .integerArray(x)
3101+ return
3102+ }
3103+ if let x = try? container.decode([String: Int?].self) {
3104+ self = .unionMap(x)
3105+ return
3106+ }
3107+ throw DecodingError.typeMismatch(Jacutinga.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Jacutinga"))
3108+ }
3109+
3110+ func encode(to encoder: Encoder) throws {
3111+ var container = encoder.singleValueContainer()
3112+ switch self {
3113+ case .integerArray(let x):
3114+ try container.encode(x)
3115+ case .unionMap(let x):
3116+ try container.encode(x)
3117+ }
3118+ }
3119+}
3120+
3121+// MARK: - Helper functions for creating encoders and decoders
3122+
3123+func newJSONDecoder() -> JSONDecoder {
3124+ let decoder = JSONDecoder()
3125+ decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in
3126+ let container = try decoder.singleValueContainer()
3127+ let dateStr = try container.decode(String.self)
3128+
3129+ let formatter = DateFormatter()
3130+ formatter.calendar = Calendar(identifier: .iso8601)
3131+ formatter.locale = Locale(identifier: "en_US_POSIX")
3132+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
3133+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX"
3134+ if let date = formatter.date(from: dateStr) {
3135+ return date
3136+ }
3137+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX"
3138+ if let date = formatter.date(from: dateStr) {
3139+ return date
3140+ }
3141+ throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date"))
3142+ })
3143+ return decoder
3144+}
3145+
3146+func newJSONEncoder() -> JSONEncoder {
3147+ let encoder = JSONEncoder()
3148+ let formatter = DateFormatter()
3149+ formatter.calendar = Calendar(identifier: .iso8601)
3150+ formatter.locale = Locale(identifier: "en_US_POSIX")
3151+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
3152+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSXXXXX"
3153+ encoder.dateEncodingStrategy = .formatted(formatter)
3154+ return encoder
3155+}
3156+
3157+// MARK: - Encode/decode helpers
3158+
3159+final class JSONNull: Codable, Hashable {
3160+
3161+ public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool {
3162+ return true
3163+ }
3164+
3165+ public func hash(into hasher: inout Hasher) {
3166+ hasher.combine(0)
3167+ }
3168+
3169+ public init() {}
3170+
3171+ public required init(from decoder: Decoder) throws {
3172+ let container = try decoder.singleValueContainer()
3173+ if !container.decodeNil() {
3174+ throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull"))
3175+ }
3176+ }
3177+
3178+ public func encode(to encoder: Encoder) throws {
3179+ var container = encoder.singleValueContainer()
3180+ try container.encodeNil()
3181+ }
3182+}
Aswiftprotocol-hashable--739b516c7897 / quicktype.swift+2,922 −0
@@ -0,0 +1,2922 @@
1+// This file was generated from JSON Schema using quicktype, do not modify it directly.
2+// To parse the JSON, add this file to your project and do:
3+//
4+// let topLevel = try TopLevel(json)
5+
6+//
7+// Hashable or Equatable:
8+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
9+// for types that require the use of JSONAny, nor will the implementation of Hashable be
10+// synthesized for types that have collections (such as arrays or dictionaries).
11+
12+import Foundation
13+
14+// MARK: - TopLevel
15+struct TopLevel: Codable, Hashable {
16+ let centrodesmose: String
17+ let cerograph: [CerographElement]
18+ let chemotherapeutics: [ChemotherapeuticElement]
19+ let cimelia: [CimeliaElement]
20+ let citrated: Int
21+ let clinodome: [Clinodome]
22+ let coadjust: [CoadjustElement]
23+ let consilience: [Consilience]
24+ let constructor: [Constructor]
25+ let continuative: [Continuative]
26+ let credulity: [CredulityElement]
27+ let creviced: [Creviced]
28+ let cubiculum: [[Int?]]
29+ let deruralize: [DeruralizeElement]
30+ let diaereses: [DiaereseElement]
31+ let dissolution: [[JSONNull?]?]
32+ let downstroke: [Downstroke]
33+ let electrotautomerism: [Double?]
34+ let eleutheromania: [Eleutheromania]
35+ let encrust: Encrust
36+ let entomoid: [Entomoid]
37+ let epipaleolithic: [Epipaleolithic]
38+ let expropriable: [Expropriable]
39+ let faggingly: [FagginglyElement]
40+ let fenks: [FenkElement]
41+ let flagmaking: [FlagmakingElement]
42+ let fluorometer: [Fluorometer]
43+ let fulsome: [Int?]
44+ let fuzzy: [Fuzzy]
45+ let gardenwards: [Gardenward]
46+ let generalissimo: [Generalissimo]
47+ let habeas: [[String: Int]?]
48+ let hemicrystalline: [Hemicrystalline]
49+ let hemocoele: [HemocoeleElement]
50+ let hoister: [Hoister]
51+ let hyperpiesis: [Hyperpiesi]
52+ let hyppish: [Hyppish]
53+ let idealizer: [Idealizer]
54+ let incrustator: [Incrustator]
55+ let intentiveness: [Intentiveness]
56+ let interacinar: Interacinar
57+ let intercorrelation: [[Int]?]
58+ let jacutinga: [Jacutinga]
59+
60+ enum CodingKeys: String, CodingKey {
61+ case centrodesmose = "centrodesmose"
62+ case cerograph = "cerograph"
63+ case chemotherapeutics = "chemotherapeutics"
64+ case cimelia = "cimelia"
65+ case citrated = "citrated"
66+ case clinodome = "clinodome"
67+ case coadjust = "coadjust"
68+ case consilience = "consilience"
69+ case constructor = "constructor"
70+ case continuative = "continuative"
71+ case credulity = "credulity"
72+ case creviced = "creviced"
73+ case cubiculum = "cubiculum"
74+ case deruralize = "deruralize"
75+ case diaereses = "diaereses"
76+ case dissolution = "dissolution"
77+ case downstroke = "downstroke"
78+ case electrotautomerism = "electrotautomerism"
79+ case eleutheromania = "eleutheromania"
80+ case encrust = "encrust"
81+ case entomoid = "entomoid"
82+ case epipaleolithic = "epipaleolithic"
83+ case expropriable = "expropriable"
84+ case faggingly = "faggingly"
85+ case fenks = "fenks"
86+ case flagmaking = "flagmaking"
87+ case fluorometer = "fluorometer"
88+ case fulsome = "fulsome"
89+ case fuzzy = "fuzzy"
90+ case gardenwards = "gardenwards"
91+ case generalissimo = "generalissimo"
92+ case habeas = "habeas"
93+ case hemicrystalline = "hemicrystalline"
94+ case hemocoele = "hemocoele"
95+ case hoister = "hoister"
96+ case hyperpiesis = "hyperpiesis"
97+ case hyppish = "hyppish"
98+ case idealizer = "idealizer"
99+ case incrustator = "incrustator"
100+ case intentiveness = "intentiveness"
101+ case interacinar = "interacinar"
102+ case intercorrelation = "intercorrelation"
103+ case jacutinga = "jacutinga"
104+ }
105+}
106+
107+// MARK: TopLevel convenience initializers and mutators
108+
109+extension TopLevel {
110+ init(data: Data) throws {
111+ self = try newJSONDecoder().decode(TopLevel.self, from: data)
112+ }
113+
114+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
115+ guard let data = json.data(using: encoding) else {
116+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
117+ }
118+ try self.init(data: data)
119+ }
120+
121+ init(fromURL url: URL) throws {
122+ try self.init(data: try Data(contentsOf: url))
123+ }
124+
125+ func with(
126+ centrodesmose: String? = nil,
127+ cerograph: [CerographElement]? = nil,
128+ chemotherapeutics: [ChemotherapeuticElement]? = nil,
129+ cimelia: [CimeliaElement]? = nil,
130+ citrated: Int? = nil,
131+ clinodome: [Clinodome]? = nil,
132+ coadjust: [CoadjustElement]? = nil,
133+ consilience: [Consilience]? = nil,
134+ constructor: [Constructor]? = nil,
135+ continuative: [Continuative]? = nil,
136+ credulity: [CredulityElement]? = nil,
137+ creviced: [Creviced]? = nil,
138+ cubiculum: [[Int?]]? = nil,
139+ deruralize: [DeruralizeElement]? = nil,
140+ diaereses: [DiaereseElement]? = nil,
141+ dissolution: [[JSONNull?]?]? = nil,
142+ downstroke: [Downstroke]? = nil,
143+ electrotautomerism: [Double?]? = nil,
144+ eleutheromania: [Eleutheromania]? = nil,
145+ encrust: Encrust? = nil,
146+ entomoid: [Entomoid]? = nil,
147+ epipaleolithic: [Epipaleolithic]? = nil,
148+ expropriable: [Expropriable]? = nil,
149+ faggingly: [FagginglyElement]? = nil,
150+ fenks: [FenkElement]? = nil,
151+ flagmaking: [FlagmakingElement]? = nil,
152+ fluorometer: [Fluorometer]? = nil,
153+ fulsome: [Int?]? = nil,
154+ fuzzy: [Fuzzy]? = nil,
155+ gardenwards: [Gardenward]? = nil,
156+ generalissimo: [Generalissimo]? = nil,
157+ habeas: [[String: Int]?]? = nil,
158+ hemicrystalline: [Hemicrystalline]? = nil,
159+ hemocoele: [HemocoeleElement]? = nil,
160+ hoister: [Hoister]? = nil,
161+ hyperpiesis: [Hyperpiesi]? = nil,
162+ hyppish: [Hyppish]? = nil,
163+ idealizer: [Idealizer]? = nil,
164+ incrustator: [Incrustator]? = nil,
165+ intentiveness: [Intentiveness]? = nil,
166+ interacinar: Interacinar? = nil,
167+ intercorrelation: [[Int]?]? = nil,
168+ jacutinga: [Jacutinga]? = nil
169+ ) -> TopLevel {
170+ return TopLevel(
171+ centrodesmose: centrodesmose ?? self.centrodesmose,
172+ cerograph: cerograph ?? self.cerograph,
173+ chemotherapeutics: chemotherapeutics ?? self.chemotherapeutics,
174+ cimelia: cimelia ?? self.cimelia,
175+ citrated: citrated ?? self.citrated,
176+ clinodome: clinodome ?? self.clinodome,
177+ coadjust: coadjust ?? self.coadjust,
178+ consilience: consilience ?? self.consilience,
179+ constructor: constructor ?? self.constructor,
180+ continuative: continuative ?? self.continuative,
181+ credulity: credulity ?? self.credulity,
182+ creviced: creviced ?? self.creviced,
183+ cubiculum: cubiculum ?? self.cubiculum,
184+ deruralize: deruralize ?? self.deruralize,
185+ diaereses: diaereses ?? self.diaereses,
186+ dissolution: dissolution ?? self.dissolution,
187+ downstroke: downstroke ?? self.downstroke,
188+ electrotautomerism: electrotautomerism ?? self.electrotautomerism,
189+ eleutheromania: eleutheromania ?? self.eleutheromania,
190+ encrust: encrust ?? self.encrust,
191+ entomoid: entomoid ?? self.entomoid,
192+ epipaleolithic: epipaleolithic ?? self.epipaleolithic,
193+ expropriable: expropriable ?? self.expropriable,
194+ faggingly: faggingly ?? self.faggingly,
195+ fenks: fenks ?? self.fenks,
196+ flagmaking: flagmaking ?? self.flagmaking,
197+ fluorometer: fluorometer ?? self.fluorometer,
198+ fulsome: fulsome ?? self.fulsome,
199+ fuzzy: fuzzy ?? self.fuzzy,
200+ gardenwards: gardenwards ?? self.gardenwards,
201+ generalissimo: generalissimo ?? self.generalissimo,
202+ habeas: habeas ?? self.habeas,
203+ hemicrystalline: hemicrystalline ?? self.hemicrystalline,
204+ hemocoele: hemocoele ?? self.hemocoele,
205+ hoister: hoister ?? self.hoister,
206+ hyperpiesis: hyperpiesis ?? self.hyperpiesis,
207+ hyppish: hyppish ?? self.hyppish,
208+ idealizer: idealizer ?? self.idealizer,
209+ incrustator: incrustator ?? self.incrustator,
210+ intentiveness: intentiveness ?? self.intentiveness,
211+ interacinar: interacinar ?? self.interacinar,
212+ intercorrelation: intercorrelation ?? self.intercorrelation,
213+ jacutinga: jacutinga ?? self.jacutinga
214+ )
215+ }
216+
217+ func jsonData() throws -> Data {
218+ return try newJSONEncoder().encode(self)
219+ }
220+
221+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
222+ return String(data: try self.jsonData(), encoding: encoding)
223+ }
224+}
225+
226+enum CerographElement: Codable, Hashable {
227+ case cerographClass(CerographClass)
228+ case string(String)
229+ case null
230+
231+ init(from decoder: Decoder) throws {
232+ let container = try decoder.singleValueContainer()
233+ if let x = try? container.decode(String.self) {
234+ self = .string(x)
235+ return
236+ }
237+ if let x = try? container.decode(CerographClass.self) {
238+ self = .cerographClass(x)
239+ return
240+ }
241+ if container.decodeNil() {
242+ self = .null
243+ return
244+ }
245+ throw DecodingError.typeMismatch(CerographElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CerographElement"))
246+ }
247+
248+ func encode(to encoder: Encoder) throws {
249+ var container = encoder.singleValueContainer()
250+ switch self {
251+ case .cerographClass(let x):
252+ try container.encode(x)
253+ case .string(let x):
254+ try container.encode(x)
255+ case .null:
256+ try container.encodeNil()
257+ }
258+ }
259+}
260+
261+//
262+// Hashable or Equatable:
263+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
264+// for types that require the use of JSONAny, nor will the implementation of Hashable be
265+// synthesized for types that have collections (such as arrays or dictionaries).
266+
267+// MARK: - CerographClass
268+struct CerographClass: Codable, Hashable {
269+ let apotropaion: JSONNull?
270+ let casuary: JSONNull?
271+ let creaker: JSONNull?
272+ let disqualification: JSONNull?
273+ let imperatorious: JSONNull?
274+ let impermeabilize: JSONNull?
275+ let metastoma: JSONNull?
276+ let noctidiurnal: JSONNull?
277+ let nonreserve: JSONNull?
278+ let ophthalmotonometry: JSONNull?
279+ let pailful: JSONNull?
280+ let pigfish: JSONNull?
281+ let pongee: JSONNull?
282+ let prosodical: JSONNull?
283+ let scrofuloderm: JSONNull?
284+ let storekeeping: JSONNull?
285+ let therologist: JSONNull?
286+ let tolowa: JSONNull?
287+ let tradeful: JSONNull?
288+ let unriveting: JSONNull?
289+
290+ enum CodingKeys: String, CodingKey {
291+ case apotropaion = "apotropaion"
292+ case casuary = "casuary"
293+ case creaker = "creaker"
294+ case disqualification = "disqualification"
295+ case imperatorious = "imperatorious"
296+ case impermeabilize = "impermeabilize"
297+ case metastoma = "metastoma"
298+ case noctidiurnal = "noctidiurnal"
299+ case nonreserve = "nonreserve"
300+ case ophthalmotonometry = "ophthalmotonometry"
301+ case pailful = "pailful"
302+ case pigfish = "pigfish"
303+ case pongee = "pongee"
304+ case prosodical = "prosodical"
305+ case scrofuloderm = "scrofuloderm"
306+ case storekeeping = "storekeeping"
307+ case therologist = "therologist"
308+ case tolowa = "Tolowa"
309+ case tradeful = "tradeful"
310+ case unriveting = "unriveting"
311+ }
312+}
313+
314+// MARK: CerographClass convenience initializers and mutators
315+
316+extension CerographClass {
317+ init(data: Data) throws {
318+ self = try newJSONDecoder().decode(CerographClass.self, from: data)
319+ }
320+
321+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
322+ guard let data = json.data(using: encoding) else {
323+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
324+ }
325+ try self.init(data: data)
326+ }
327+
328+ init(fromURL url: URL) throws {
329+ try self.init(data: try Data(contentsOf: url))
330+ }
331+
332+ func with(
333+ apotropaion: JSONNull?? = nil,
334+ casuary: JSONNull?? = nil,
335+ creaker: JSONNull?? = nil,
336+ disqualification: JSONNull?? = nil,
337+ imperatorious: JSONNull?? = nil,
338+ impermeabilize: JSONNull?? = nil,
339+ metastoma: JSONNull?? = nil,
340+ noctidiurnal: JSONNull?? = nil,
341+ nonreserve: JSONNull?? = nil,
342+ ophthalmotonometry: JSONNull?? = nil,
343+ pailful: JSONNull?? = nil,
344+ pigfish: JSONNull?? = nil,
345+ pongee: JSONNull?? = nil,
346+ prosodical: JSONNull?? = nil,
347+ scrofuloderm: JSONNull?? = nil,
348+ storekeeping: JSONNull?? = nil,
349+ therologist: JSONNull?? = nil,
350+ tolowa: JSONNull?? = nil,
351+ tradeful: JSONNull?? = nil,
352+ unriveting: JSONNull?? = nil
353+ ) -> CerographClass {
354+ return CerographClass(
355+ apotropaion: apotropaion ?? self.apotropaion,
356+ casuary: casuary ?? self.casuary,
357+ creaker: creaker ?? self.creaker,
358+ disqualification: disqualification ?? self.disqualification,
359+ imperatorious: imperatorious ?? self.imperatorious,
360+ impermeabilize: impermeabilize ?? self.impermeabilize,
361+ metastoma: metastoma ?? self.metastoma,
362+ noctidiurnal: noctidiurnal ?? self.noctidiurnal,
363+ nonreserve: nonreserve ?? self.nonreserve,
364+ ophthalmotonometry: ophthalmotonometry ?? self.ophthalmotonometry,
365+ pailful: pailful ?? self.pailful,
366+ pigfish: pigfish ?? self.pigfish,
367+ pongee: pongee ?? self.pongee,
368+ prosodical: prosodical ?? self.prosodical,
369+ scrofuloderm: scrofuloderm ?? self.scrofuloderm,
370+ storekeeping: storekeeping ?? self.storekeeping,
371+ therologist: therologist ?? self.therologist,
372+ tolowa: tolowa ?? self.tolowa,
373+ tradeful: tradeful ?? self.tradeful,
374+ unriveting: unriveting ?? self.unriveting
375+ )
376+ }
377+
378+ func jsonData() throws -> Data {
379+ return try newJSONEncoder().encode(self)
380+ }
381+
382+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
383+ return String(data: try self.jsonData(), encoding: encoding)
384+ }
385+}
386+
387+enum ChemotherapeuticElement: Codable, Hashable {
388+ case chemotherapeuticClass(ChemotherapeuticClass)
389+ case integer(Int)
390+
391+ init(from decoder: Decoder) throws {
392+ let container = try decoder.singleValueContainer()
393+ if let x = try? container.decode(Int.self) {
394+ self = .integer(x)
395+ return
396+ }
397+ if let x = try? container.decode(ChemotherapeuticClass.self) {
398+ self = .chemotherapeuticClass(x)
399+ return
400+ }
401+ throw DecodingError.typeMismatch(ChemotherapeuticElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for ChemotherapeuticElement"))
402+ }
403+
404+ func encode(to encoder: Encoder) throws {
405+ var container = encoder.singleValueContainer()
406+ switch self {
407+ case .chemotherapeuticClass(let x):
408+ try container.encode(x)
409+ case .integer(let x):
410+ try container.encode(x)
411+ }
412+ }
413+}
414+
415+//
416+// Hashable or Equatable:
417+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
418+// for types that require the use of JSONAny, nor will the implementation of Hashable be
419+// synthesized for types that have collections (such as arrays or dictionaries).
420+
421+// MARK: - ChemotherapeuticClass
422+struct ChemotherapeuticClass: Codable, Hashable {
423+ let angioneurotic: JSONNull?
424+ let availment: JSONNull?
425+ let bladelet: JSONNull?
426+ let catharticalness: Double?
427+ let caulis: JSONNull?
428+ let chalcus: JSONNull?
429+ let chirotherium: Int?
430+ let disdiapason: String?
431+ let enteradenological: JSONNull?
432+ let homocerc: Bool?
433+ let imporosity: JSONNull?
434+ let insistently: JSONNull?
435+ let intraparietal: JSONNull?
436+ let ivied: JSONNull?
437+ let maureen: JSONNull?
438+ let nonbookish: JSONNull?
439+ let nostochine: JSONNull?
440+ let nutcracker: JSONNull?
441+ let ofttimes: JSONNull?
442+ let phenocryst: JSONNull?
443+ let precoincident: JSONNull?
444+ let ramiferous: JSONNull?
445+ let stagmometer: JSONNull?
446+ let tetherball: JSONNull?
447+ let unshy: JSONNull?
448+
449+ enum CodingKeys: String, CodingKey {
450+ case angioneurotic = "angioneurotic"
451+ case availment = "availment"
452+ case bladelet = "bladelet"
453+ case catharticalness = "catharticalness"
454+ case caulis = "caulis"
455+ case chalcus = "chalcus"
456+ case chirotherium = "Chirotherium"
457+ case disdiapason = "disdiapason"
458+ case enteradenological = "enteradenological"
459+ case homocerc = "homocerc"
460+ case imporosity = "imporosity"
461+ case insistently = "insistently"
462+ case intraparietal = "intraparietal"
463+ case ivied = "ivied"
464+ case maureen = "Maureen"
465+ case nonbookish = "nonbookish"
466+ case nostochine = "nostochine"
467+ case nutcracker = "nutcracker"
468+ case ofttimes = "ofttimes"
469+ case phenocryst = "phenocryst"
470+ case precoincident = "precoincident"
471+ case ramiferous = "ramiferous"
472+ case stagmometer = "stagmometer"
473+ case tetherball = "tetherball"
474+ case unshy = "unshy"
475+ }
476+}
477+
478+// MARK: ChemotherapeuticClass convenience initializers and mutators
479+
480+extension ChemotherapeuticClass {
481+ init(data: Data) throws {
482+ self = try newJSONDecoder().decode(ChemotherapeuticClass.self, from: data)
483+ }
484+
485+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
486+ guard let data = json.data(using: encoding) else {
487+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
488+ }
489+ try self.init(data: data)
490+ }
491+
492+ init(fromURL url: URL) throws {
493+ try self.init(data: try Data(contentsOf: url))
494+ }
495+
496+ func with(
497+ angioneurotic: JSONNull?? = nil,
498+ availment: JSONNull?? = nil,
499+ bladelet: JSONNull?? = nil,
500+ catharticalness: Double?? = nil,
501+ caulis: JSONNull?? = nil,
502+ chalcus: JSONNull?? = nil,
503+ chirotherium: Int?? = nil,
504+ disdiapason: String?? = nil,
505+ enteradenological: JSONNull?? = nil,
506+ homocerc: Bool?? = nil,
507+ imporosity: JSONNull?? = nil,
508+ insistently: JSONNull?? = nil,
509+ intraparietal: JSONNull?? = nil,
510+ ivied: JSONNull?? = nil,
511+ maureen: JSONNull?? = nil,
512+ nonbookish: JSONNull?? = nil,
513+ nostochine: JSONNull?? = nil,
514+ nutcracker: JSONNull?? = nil,
515+ ofttimes: JSONNull?? = nil,
516+ phenocryst: JSONNull?? = nil,
517+ precoincident: JSONNull?? = nil,
518+ ramiferous: JSONNull?? = nil,
519+ stagmometer: JSONNull?? = nil,
520+ tetherball: JSONNull?? = nil,
521+ unshy: JSONNull?? = nil
522+ ) -> ChemotherapeuticClass {
523+ return ChemotherapeuticClass(
524+ angioneurotic: angioneurotic ?? self.angioneurotic,
525+ availment: availment ?? self.availment,
526+ bladelet: bladelet ?? self.bladelet,
527+ catharticalness: catharticalness ?? self.catharticalness,
528+ caulis: caulis ?? self.caulis,
529+ chalcus: chalcus ?? self.chalcus,
530+ chirotherium: chirotherium ?? self.chirotherium,
531+ disdiapason: disdiapason ?? self.disdiapason,
532+ enteradenological: enteradenological ?? self.enteradenological,
533+ homocerc: homocerc ?? self.homocerc,
534+ imporosity: imporosity ?? self.imporosity,
535+ insistently: insistently ?? self.insistently,
536+ intraparietal: intraparietal ?? self.intraparietal,
537+ ivied: ivied ?? self.ivied,
538+ maureen: maureen ?? self.maureen,
539+ nonbookish: nonbookish ?? self.nonbookish,
540+ nostochine: nostochine ?? self.nostochine,
541+ nutcracker: nutcracker ?? self.nutcracker,
542+ ofttimes: ofttimes ?? self.ofttimes,
543+ phenocryst: phenocryst ?? self.phenocryst,
544+ precoincident: precoincident ?? self.precoincident,
545+ ramiferous: ramiferous ?? self.ramiferous,
546+ stagmometer: stagmometer ?? self.stagmometer,
547+ tetherball: tetherball ?? self.tetherball,
548+ unshy: unshy ?? self.unshy
549+ )
550+ }
551+
552+ func jsonData() throws -> Data {
553+ return try newJSONEncoder().encode(self)
554+ }
555+
556+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
557+ return String(data: try self.jsonData(), encoding: encoding)
558+ }
559+}
560+
561+enum CimeliaElement: Codable, Hashable {
562+ case cimeliaClass(CimeliaClass)
563+ case integerArray([Int])
564+ case null
565+
566+ init(from decoder: Decoder) throws {
567+ let container = try decoder.singleValueContainer()
568+ if let x = try? container.decode([Int].self) {
569+ self = .integerArray(x)
570+ return
571+ }
572+ if let x = try? container.decode(CimeliaClass.self) {
573+ self = .cimeliaClass(x)
574+ return
575+ }
576+ if container.decodeNil() {
577+ self = .null
578+ return
579+ }
580+ throw DecodingError.typeMismatch(CimeliaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CimeliaElement"))
581+ }
582+
583+ func encode(to encoder: Encoder) throws {
584+ var container = encoder.singleValueContainer()
585+ switch self {
586+ case .cimeliaClass(let x):
587+ try container.encode(x)
588+ case .integerArray(let x):
589+ try container.encode(x)
590+ case .null:
591+ try container.encodeNil()
592+ }
593+ }
594+}
595+
596+//
597+// Hashable or Equatable:
598+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
599+// for types that require the use of JSONAny, nor will the implementation of Hashable be
600+// synthesized for types that have collections (such as arrays or dictionaries).
601+
602+// MARK: - CimeliaClass
603+struct CimeliaClass: Codable, Hashable {
604+ let catharticalness: Double
605+ let chirotherium: Int
606+ let disdiapason: String
607+ let homocerc: Bool
608+ let nonbookish: JSONNull?
609+
610+ enum CodingKeys: String, CodingKey {
611+ case catharticalness = "catharticalness"
612+ case chirotherium = "Chirotherium"
613+ case disdiapason = "disdiapason"
614+ case homocerc = "homocerc"
615+ case nonbookish = "nonbookish"
616+ }
617+}
618+
619+// MARK: CimeliaClass convenience initializers and mutators
620+
621+extension CimeliaClass {
622+ init(data: Data) throws {
623+ self = try newJSONDecoder().decode(CimeliaClass.self, from: data)
624+ }
625+
626+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
627+ guard let data = json.data(using: encoding) else {
628+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
629+ }
630+ try self.init(data: data)
631+ }
632+
633+ init(fromURL url: URL) throws {
634+ try self.init(data: try Data(contentsOf: url))
635+ }
636+
637+ func with(
638+ catharticalness: Double? = nil,
639+ chirotherium: Int? = nil,
640+ disdiapason: String? = nil,
641+ homocerc: Bool? = nil,
642+ nonbookish: JSONNull?? = nil
643+ ) -> CimeliaClass {
644+ return CimeliaClass(
645+ catharticalness: catharticalness ?? self.catharticalness,
646+ chirotherium: chirotherium ?? self.chirotherium,
647+ disdiapason: disdiapason ?? self.disdiapason,
648+ homocerc: homocerc ?? self.homocerc,
649+ nonbookish: nonbookish ?? self.nonbookish
650+ )
651+ }
652+
653+ func jsonData() throws -> Data {
654+ return try newJSONEncoder().encode(self)
655+ }
656+
657+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
658+ return String(data: try self.jsonData(), encoding: encoding)
659+ }
660+}
661+
662+enum Clinodome: Codable, Hashable {
663+ case double(Double)
664+ case string(String)
665+
666+ init(from decoder: Decoder) throws {
667+ let container = try decoder.singleValueContainer()
668+ if let x = try? container.decode(Double.self) {
669+ self = .double(x)
670+ return
671+ }
672+ if let x = try? container.decode(String.self) {
673+ self = .string(x)
674+ return
675+ }
676+ throw DecodingError.typeMismatch(Clinodome.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Clinodome"))
677+ }
678+
679+ func encode(to encoder: Encoder) throws {
680+ var container = encoder.singleValueContainer()
681+ switch self {
682+ case .double(let x):
683+ try container.encode(x)
684+ case .string(let x):
685+ try container.encode(x)
686+ }
687+ }
688+}
689+
690+enum CoadjustElement: Codable, Hashable {
691+ case coadjustClass(CoadjustClass)
692+ case double(Double)
693+
694+ init(from decoder: Decoder) throws {
695+ let container = try decoder.singleValueContainer()
696+ if let x = try? container.decode(Double.self) {
697+ self = .double(x)
698+ return
699+ }
700+ if let x = try? container.decode(CoadjustClass.self) {
701+ self = .coadjustClass(x)
702+ return
703+ }
704+ throw DecodingError.typeMismatch(CoadjustElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CoadjustElement"))
705+ }
706+
707+ func encode(to encoder: Encoder) throws {
708+ var container = encoder.singleValueContainer()
709+ switch self {
710+ case .coadjustClass(let x):
711+ try container.encode(x)
712+ case .double(let x):
713+ try container.encode(x)
714+ }
715+ }
716+}
717+
718+//
719+// Hashable or Equatable:
720+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
721+// for types that require the use of JSONAny, nor will the implementation of Hashable be
722+// synthesized for types that have collections (such as arrays or dictionaries).
723+
724+// MARK: - CoadjustClass
725+struct CoadjustClass: Codable, Hashable {
726+ let amidosulphonal: JSONNull?
727+ let benny: JSONNull?
728+ let catharticalness: Double?
729+ let chirotherium: Int?
730+ let disdiapason: String?
731+ let ensnare: JSONNull?
732+ let homocerc: Bool?
733+ let hybridizer: JSONNull?
734+ let leastwise: JSONNull?
735+ let lof: JSONNull?
736+ let monkhood: JSONNull?
737+ let netherlandish: JSONNull?
738+ let nonbookish: JSONNull?
739+ let peonism: JSONNull?
740+ let phonelescope: JSONNull?
741+ let porphyrogeniture: JSONNull?
742+ let preindemnify: JSONNull?
743+ let rosal: JSONNull?
744+ let scalenous: JSONNull?
745+ let scopine: JSONNull?
746+ let sedaceae: JSONNull?
747+ let suberinize: JSONNull?
748+ let symbiot: JSONNull?
749+ let tablefellow: JSONNull?
750+ let unchargeable: JSONNull?
751+
752+ enum CodingKeys: String, CodingKey {
753+ case amidosulphonal = "amidosulphonal"
754+ case benny = "Benny"
755+ case catharticalness = "catharticalness"
756+ case chirotherium = "Chirotherium"
757+ case disdiapason = "disdiapason"
758+ case ensnare = "ensnare"
759+ case homocerc = "homocerc"
760+ case hybridizer = "hybridizer"
761+ case leastwise = "leastwise"
762+ case lof = "lof"
763+ case monkhood = "monkhood"
764+ case netherlandish = "Netherlandish"
765+ case nonbookish = "nonbookish"
766+ case peonism = "peonism"
767+ case phonelescope = "Phonelescope"
768+ case porphyrogeniture = "porphyrogeniture"
769+ case preindemnify = "preindemnify"
770+ case rosal = "rosal"
771+ case scalenous = "scalenous"
772+ case scopine = "scopine"
773+ case sedaceae = "Sedaceae"
774+ case suberinize = "suberinize"
775+ case symbiot = "symbiot"
776+ case tablefellow = "tablefellow"
777+ case unchargeable = "unchargeable"
778+ }
779+}
780+
781+// MARK: CoadjustClass convenience initializers and mutators
782+
783+extension CoadjustClass {
784+ init(data: Data) throws {
785+ self = try newJSONDecoder().decode(CoadjustClass.self, from: data)
786+ }
787+
788+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
789+ guard let data = json.data(using: encoding) else {
790+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
791+ }
792+ try self.init(data: data)
793+ }
794+
795+ init(fromURL url: URL) throws {
796+ try self.init(data: try Data(contentsOf: url))
797+ }
798+
799+ func with(
800+ amidosulphonal: JSONNull?? = nil,
801+ benny: JSONNull?? = nil,
802+ catharticalness: Double?? = nil,
803+ chirotherium: Int?? = nil,
804+ disdiapason: String?? = nil,
805+ ensnare: JSONNull?? = nil,
806+ homocerc: Bool?? = nil,
807+ hybridizer: JSONNull?? = nil,
808+ leastwise: JSONNull?? = nil,
809+ lof: JSONNull?? = nil,
810+ monkhood: JSONNull?? = nil,
811+ netherlandish: JSONNull?? = nil,
812+ nonbookish: JSONNull?? = nil,
813+ peonism: JSONNull?? = nil,
814+ phonelescope: JSONNull?? = nil,
815+ porphyrogeniture: JSONNull?? = nil,
816+ preindemnify: JSONNull?? = nil,
817+ rosal: JSONNull?? = nil,
818+ scalenous: JSONNull?? = nil,
819+ scopine: JSONNull?? = nil,
820+ sedaceae: JSONNull?? = nil,
821+ suberinize: JSONNull?? = nil,
822+ symbiot: JSONNull?? = nil,
823+ tablefellow: JSONNull?? = nil,
824+ unchargeable: JSONNull?? = nil
825+ ) -> CoadjustClass {
826+ return CoadjustClass(
827+ amidosulphonal: amidosulphonal ?? self.amidosulphonal,
828+ benny: benny ?? self.benny,
829+ catharticalness: catharticalness ?? self.catharticalness,
830+ chirotherium: chirotherium ?? self.chirotherium,
831+ disdiapason: disdiapason ?? self.disdiapason,
832+ ensnare: ensnare ?? self.ensnare,
833+ homocerc: homocerc ?? self.homocerc,
834+ hybridizer: hybridizer ?? self.hybridizer,
835+ leastwise: leastwise ?? self.leastwise,
836+ lof: lof ?? self.lof,
837+ monkhood: monkhood ?? self.monkhood,
838+ netherlandish: netherlandish ?? self.netherlandish,
839+ nonbookish: nonbookish ?? self.nonbookish,
840+ peonism: peonism ?? self.peonism,
841+ phonelescope: phonelescope ?? self.phonelescope,
842+ porphyrogeniture: porphyrogeniture ?? self.porphyrogeniture,
843+ preindemnify: preindemnify ?? self.preindemnify,
844+ rosal: rosal ?? self.rosal,
845+ scalenous: scalenous ?? self.scalenous,
846+ scopine: scopine ?? self.scopine,
847+ sedaceae: sedaceae ?? self.sedaceae,
848+ suberinize: suberinize ?? self.suberinize,
849+ symbiot: symbiot ?? self.symbiot,
850+ tablefellow: tablefellow ?? self.tablefellow,
851+ unchargeable: unchargeable ?? self.unchargeable
852+ )
853+ }
854+
855+ func jsonData() throws -> Data {
856+ return try newJSONEncoder().encode(self)
857+ }
858+
859+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
860+ return String(data: try self.jsonData(), encoding: encoding)
861+ }
862+}
863+
864+enum Consilience: Codable, Hashable {
865+ case double(Double)
866+ case integerMap([String: Int])
867+
868+ init(from decoder: Decoder) throws {
869+ let container = try decoder.singleValueContainer()
870+ if let x = try? container.decode(Double.self) {
871+ self = .double(x)
872+ return
873+ }
874+ if let x = try? container.decode([String: Int].self) {
875+ self = .integerMap(x)
876+ return
877+ }
878+ throw DecodingError.typeMismatch(Consilience.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Consilience"))
879+ }
880+
881+ func encode(to encoder: Encoder) throws {
882+ var container = encoder.singleValueContainer()
883+ switch self {
884+ case .double(let x):
885+ try container.encode(x)
886+ case .integerMap(let x):
887+ try container.encode(x)
888+ }
889+ }
890+}
891+
892+enum Constructor: Codable, Hashable {
893+ case bool(Bool)
894+ case unionMap([String: Int?])
895+
896+ init(from decoder: Decoder) throws {
897+ let container = try decoder.singleValueContainer()
898+ if let x = try? container.decode(Bool.self) {
899+ self = .bool(x)
900+ return
901+ }
902+ if let x = try? container.decode([String: Int?].self) {
903+ self = .unionMap(x)
904+ return
905+ }
906+ throw DecodingError.typeMismatch(Constructor.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Constructor"))
907+ }
908+
909+ func encode(to encoder: Encoder) throws {
910+ var container = encoder.singleValueContainer()
911+ switch self {
912+ case .bool(let x):
913+ try container.encode(x)
914+ case .unionMap(let x):
915+ try container.encode(x)
916+ }
917+ }
918+}
919+
920+enum Continuative: Codable, Hashable {
921+ case integerMap([String: Int])
922+ case string(String)
923+
924+ init(from decoder: Decoder) throws {
925+ let container = try decoder.singleValueContainer()
926+ if let x = try? container.decode([String: Int].self) {
927+ self = .integerMap(x)
928+ return
929+ }
930+ if let x = try? container.decode(String.self) {
931+ self = .string(x)
932+ return
933+ }
934+ throw DecodingError.typeMismatch(Continuative.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Continuative"))
935+ }
936+
937+ func encode(to encoder: Encoder) throws {
938+ var container = encoder.singleValueContainer()
939+ switch self {
940+ case .integerMap(let x):
941+ try container.encode(x)
942+ case .string(let x):
943+ try container.encode(x)
944+ }
945+ }
946+}
947+
948+enum CredulityElement: Codable, Hashable {
949+ case credulityClass(CredulityClass)
950+ case integer(Int)
951+ case string(String)
952+
953+ init(from decoder: Decoder) throws {
954+ let container = try decoder.singleValueContainer()
955+ if let x = try? container.decode(Int.self) {
956+ self = .integer(x)
957+ return
958+ }
959+ if let x = try? container.decode(String.self) {
960+ self = .string(x)
961+ return
962+ }
963+ if let x = try? container.decode(CredulityClass.self) {
964+ self = .credulityClass(x)
965+ return
966+ }
967+ throw DecodingError.typeMismatch(CredulityElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CredulityElement"))
968+ }
969+
970+ func encode(to encoder: Encoder) throws {
971+ var container = encoder.singleValueContainer()
972+ switch self {
973+ case .credulityClass(let x):
974+ try container.encode(x)
975+ case .integer(let x):
976+ try container.encode(x)
977+ case .string(let x):
978+ try container.encode(x)
979+ }
980+ }
981+}
982+
983+//
984+// Hashable or Equatable:
985+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
986+// for types that require the use of JSONAny, nor will the implementation of Hashable be
987+// synthesized for types that have collections (such as arrays or dictionaries).
988+
989+// MARK: - CredulityClass
990+struct CredulityClass: Codable, Hashable {
991+ let ammonolytic: JSONNull?
992+ let bushmaster: JSONNull?
993+ let considering: JSONNull?
994+ let consuetudinary: JSONNull?
995+ let embarras: JSONNull?
996+ let fineness: JSONNull?
997+ let flaithship: JSONNull?
998+ let flavia: JSONNull?
999+ let gruffly: JSONNull?
1000+ let hedychium: JSONNull?
1001+ let leadwort: JSONNull?
1002+ let overseriously: JSONNull?
1003+ let parabola: JSONNull?
1004+ let pectinatodenticulate: JSONNull?
1005+ let popean: JSONNull?
1006+ let pornocrat: JSONNull?
1007+ let quadrisect: JSONNull?
1008+ let seriality: JSONNull?
1009+ let vamphorn: JSONNull?
1010+ let wharp: JSONNull?
1011+
1012+ enum CodingKeys: String, CodingKey {
1013+ case ammonolytic = "ammonolytic"
1014+ case bushmaster = "bushmaster"
1015+ case considering = "considering"
1016+ case consuetudinary = "consuetudinary"
1017+ case embarras = "embarras"
1018+ case fineness = "fineness"
1019+ case flaithship = "flaithship"
1020+ case flavia = "Flavia"
1021+ case gruffly = "gruffly"
1022+ case hedychium = "Hedychium"
1023+ case leadwort = "leadwort"
1024+ case overseriously = "overseriously"
1025+ case parabola = "parabola"
1026+ case pectinatodenticulate = "pectinatodenticulate"
1027+ case popean = "Popean"
1028+ case pornocrat = "pornocrat"
1029+ case quadrisect = "quadrisect"
1030+ case seriality = "seriality"
1031+ case vamphorn = "vamphorn"
1032+ case wharp = "wharp"
1033+ }
1034+}
1035+
1036+// MARK: CredulityClass convenience initializers and mutators
1037+
1038+extension CredulityClass {
1039+ init(data: Data) throws {
1040+ self = try newJSONDecoder().decode(CredulityClass.self, from: data)
1041+ }
1042+
1043+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1044+ guard let data = json.data(using: encoding) else {
1045+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1046+ }
1047+ try self.init(data: data)
1048+ }
1049+
1050+ init(fromURL url: URL) throws {
1051+ try self.init(data: try Data(contentsOf: url))
1052+ }
1053+
1054+ func with(
1055+ ammonolytic: JSONNull?? = nil,
1056+ bushmaster: JSONNull?? = nil,
1057+ considering: JSONNull?? = nil,
1058+ consuetudinary: JSONNull?? = nil,
1059+ embarras: JSONNull?? = nil,
1060+ fineness: JSONNull?? = nil,
1061+ flaithship: JSONNull?? = nil,
1062+ flavia: JSONNull?? = nil,
1063+ gruffly: JSONNull?? = nil,
1064+ hedychium: JSONNull?? = nil,
1065+ leadwort: JSONNull?? = nil,
1066+ overseriously: JSONNull?? = nil,
1067+ parabola: JSONNull?? = nil,
1068+ pectinatodenticulate: JSONNull?? = nil,
1069+ popean: JSONNull?? = nil,
1070+ pornocrat: JSONNull?? = nil,
1071+ quadrisect: JSONNull?? = nil,
1072+ seriality: JSONNull?? = nil,
1073+ vamphorn: JSONNull?? = nil,
1074+ wharp: JSONNull?? = nil
1075+ ) -> CredulityClass {
1076+ return CredulityClass(
1077+ ammonolytic: ammonolytic ?? self.ammonolytic,
1078+ bushmaster: bushmaster ?? self.bushmaster,
1079+ considering: considering ?? self.considering,
1080+ consuetudinary: consuetudinary ?? self.consuetudinary,
1081+ embarras: embarras ?? self.embarras,
1082+ fineness: fineness ?? self.fineness,
1083+ flaithship: flaithship ?? self.flaithship,
1084+ flavia: flavia ?? self.flavia,
1085+ gruffly: gruffly ?? self.gruffly,
1086+ hedychium: hedychium ?? self.hedychium,
1087+ leadwort: leadwort ?? self.leadwort,
1088+ overseriously: overseriously ?? self.overseriously,
1089+ parabola: parabola ?? self.parabola,
1090+ pectinatodenticulate: pectinatodenticulate ?? self.pectinatodenticulate,
1091+ popean: popean ?? self.popean,
1092+ pornocrat: pornocrat ?? self.pornocrat,
1093+ quadrisect: quadrisect ?? self.quadrisect,
1094+ seriality: seriality ?? self.seriality,
1095+ vamphorn: vamphorn ?? self.vamphorn,
1096+ wharp: wharp ?? self.wharp
1097+ )
1098+ }
1099+
1100+ func jsonData() throws -> Data {
1101+ return try newJSONEncoder().encode(self)
1102+ }
1103+
1104+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1105+ return String(data: try self.jsonData(), encoding: encoding)
1106+ }
1107+}
1108+
1109+enum Creviced: Codable, Hashable {
1110+ case bool(Bool)
1111+ case integerMap([String: Int])
1112+ case string(String)
1113+
1114+ init(from decoder: Decoder) throws {
1115+ let container = try decoder.singleValueContainer()
1116+ if let x = try? container.decode(Bool.self) {
1117+ self = .bool(x)
1118+ return
1119+ }
1120+ if let x = try? container.decode([String: Int].self) {
1121+ self = .integerMap(x)
1122+ return
1123+ }
1124+ if let x = try? container.decode(String.self) {
1125+ self = .string(x)
1126+ return
1127+ }
1128+ throw DecodingError.typeMismatch(Creviced.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Creviced"))
1129+ }
1130+
1131+ func encode(to encoder: Encoder) throws {
1132+ var container = encoder.singleValueContainer()
1133+ switch self {
1134+ case .bool(let x):
1135+ try container.encode(x)
1136+ case .integerMap(let x):
1137+ try container.encode(x)
1138+ case .string(let x):
1139+ try container.encode(x)
1140+ }
1141+ }
1142+}
1143+
1144+enum DeruralizeElement: Codable, Hashable {
1145+ case bool(Bool)
1146+ case deruralizeClass(DeruralizeClass)
1147+ case nullArray([JSONNull?])
1148+
1149+ init(from decoder: Decoder) throws {
1150+ let container = try decoder.singleValueContainer()
1151+ if let x = try? container.decode(Bool.self) {
1152+ self = .bool(x)
1153+ return
1154+ }
1155+ if let x = try? container.decode([JSONNull?].self) {
1156+ self = .nullArray(x)
1157+ return
1158+ }
1159+ if let x = try? container.decode(DeruralizeClass.self) {
1160+ self = .deruralizeClass(x)
1161+ return
1162+ }
1163+ throw DecodingError.typeMismatch(DeruralizeElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for DeruralizeElement"))
1164+ }
1165+
1166+ func encode(to encoder: Encoder) throws {
1167+ var container = encoder.singleValueContainer()
1168+ switch self {
1169+ case .bool(let x):
1170+ try container.encode(x)
1171+ case .deruralizeClass(let x):
1172+ try container.encode(x)
1173+ case .nullArray(let x):
1174+ try container.encode(x)
1175+ }
1176+ }
1177+}
1178+
1179+//
1180+// Hashable or Equatable:
1181+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
1182+// for types that require the use of JSONAny, nor will the implementation of Hashable be
1183+// synthesized for types that have collections (such as arrays or dictionaries).
1184+
1185+// MARK: - DeruralizeClass
1186+struct DeruralizeClass: Codable, Hashable {
1187+ let bockerel: JSONNull?
1188+ let boulder: JSONNull?
1189+ let churrus: JSONNull?
1190+ let counterdigged: JSONNull?
1191+ let dialogite: JSONNull?
1192+ let digenic: JSONNull?
1193+ let dunbird: JSONNull?
1194+ let ergatogyne: JSONNull?
1195+ let fiendful: JSONNull?
1196+ let jackrod: JSONNull?
1197+ let jehovistic: JSONNull?
1198+ let paninean: JSONNull?
1199+ let panther: JSONNull?
1200+ let placentigerous: JSONNull?
1201+ let romney: JSONNull?
1202+ let sparm: JSONNull?
1203+ let tocsin: JSONNull?
1204+ let unnicked: JSONNull?
1205+ let unstavable: JSONNull?
1206+ let windfirm: JSONNull?
1207+
1208+ enum CodingKeys: String, CodingKey {
1209+ case bockerel = "bockerel"
1210+ case boulder = "boulder"
1211+ case churrus = "churrus"
1212+ case counterdigged = "counterdigged"
1213+ case dialogite = "dialogite"
1214+ case digenic = "digenic"
1215+ case dunbird = "dunbird"
1216+ case ergatogyne = "ergatogyne"
1217+ case fiendful = "fiendful"
1218+ case jackrod = "jackrod"
1219+ case jehovistic = "Jehovistic"
1220+ case paninean = "Paninean"
1221+ case panther = "panther"
1222+ case placentigerous = "placentigerous"
1223+ case romney = "Romney"
1224+ case sparm = "sparm"
1225+ case tocsin = "tocsin"
1226+ case unnicked = "unnicked"
1227+ case unstavable = "unstavable"
1228+ case windfirm = "windfirm"
1229+ }
1230+}
1231+
1232+// MARK: DeruralizeClass convenience initializers and mutators
1233+
1234+extension DeruralizeClass {
1235+ init(data: Data) throws {
1236+ self = try newJSONDecoder().decode(DeruralizeClass.self, from: data)
1237+ }
1238+
1239+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1240+ guard let data = json.data(using: encoding) else {
1241+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1242+ }
1243+ try self.init(data: data)
1244+ }
1245+
1246+ init(fromURL url: URL) throws {
1247+ try self.init(data: try Data(contentsOf: url))
1248+ }
1249+
1250+ func with(
1251+ bockerel: JSONNull?? = nil,
1252+ boulder: JSONNull?? = nil,
1253+ churrus: JSONNull?? = nil,
1254+ counterdigged: JSONNull?? = nil,
1255+ dialogite: JSONNull?? = nil,
1256+ digenic: JSONNull?? = nil,
1257+ dunbird: JSONNull?? = nil,
1258+ ergatogyne: JSONNull?? = nil,
1259+ fiendful: JSONNull?? = nil,
1260+ jackrod: JSONNull?? = nil,
1261+ jehovistic: JSONNull?? = nil,
1262+ paninean: JSONNull?? = nil,
1263+ panther: JSONNull?? = nil,
1264+ placentigerous: JSONNull?? = nil,
1265+ romney: JSONNull?? = nil,
1266+ sparm: JSONNull?? = nil,
1267+ tocsin: JSONNull?? = nil,
1268+ unnicked: JSONNull?? = nil,
1269+ unstavable: JSONNull?? = nil,
1270+ windfirm: JSONNull?? = nil
1271+ ) -> DeruralizeClass {
1272+ return DeruralizeClass(
1273+ bockerel: bockerel ?? self.bockerel,
1274+ boulder: boulder ?? self.boulder,
1275+ churrus: churrus ?? self.churrus,
1276+ counterdigged: counterdigged ?? self.counterdigged,
1277+ dialogite: dialogite ?? self.dialogite,
1278+ digenic: digenic ?? self.digenic,
1279+ dunbird: dunbird ?? self.dunbird,
1280+ ergatogyne: ergatogyne ?? self.ergatogyne,
1281+ fiendful: fiendful ?? self.fiendful,
1282+ jackrod: jackrod ?? self.jackrod,
1283+ jehovistic: jehovistic ?? self.jehovistic,
1284+ paninean: paninean ?? self.paninean,
1285+ panther: panther ?? self.panther,
1286+ placentigerous: placentigerous ?? self.placentigerous,
1287+ romney: romney ?? self.romney,
1288+ sparm: sparm ?? self.sparm,
1289+ tocsin: tocsin ?? self.tocsin,
1290+ unnicked: unnicked ?? self.unnicked,
1291+ unstavable: unstavable ?? self.unstavable,
1292+ windfirm: windfirm ?? self.windfirm
1293+ )
1294+ }
1295+
1296+ func jsonData() throws -> Data {
1297+ return try newJSONEncoder().encode(self)
1298+ }
1299+
1300+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1301+ return String(data: try self.jsonData(), encoding: encoding)
1302+ }
1303+}
1304+
1305+enum DiaereseElement: Codable, Hashable {
1306+ case bool(Bool)
1307+ case diaereseClass(DiaereseClass)
1308+ case integerArray([Int])
1309+
1310+ init(from decoder: Decoder) throws {
1311+ let container = try decoder.singleValueContainer()
1312+ if let x = try? container.decode(Bool.self) {
1313+ self = .bool(x)
1314+ return
1315+ }
1316+ if let x = try? container.decode([Int].self) {
1317+ self = .integerArray(x)
1318+ return
1319+ }
1320+ if let x = try? container.decode(DiaereseClass.self) {
1321+ self = .diaereseClass(x)
1322+ return
1323+ }
1324+ throw DecodingError.typeMismatch(DiaereseElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for DiaereseElement"))
1325+ }
1326+
1327+ func encode(to encoder: Encoder) throws {
1328+ var container = encoder.singleValueContainer()
1329+ switch self {
1330+ case .bool(let x):
1331+ try container.encode(x)
1332+ case .diaereseClass(let x):
1333+ try container.encode(x)
1334+ case .integerArray(let x):
1335+ try container.encode(x)
1336+ }
1337+ }
1338+}
1339+
1340+//
1341+// Hashable or Equatable:
1342+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
1343+// for types that require the use of JSONAny, nor will the implementation of Hashable be
1344+// synthesized for types that have collections (such as arrays or dictionaries).
1345+
1346+// MARK: - DiaereseClass
1347+struct DiaereseClass: Codable, Hashable {
1348+ let amoreuxia: JSONNull?
1349+ let ani: JSONNull?
1350+ let bernicle: JSONNull?
1351+ let blackwasher: JSONNull?
1352+ let blowhard: JSONNull?
1353+ let broma: JSONNull?
1354+ let closecross: JSONNull?
1355+ let congregationalism: JSONNull?
1356+ let grayly: JSONNull?
1357+ let historically: JSONNull?
1358+ let hoast: JSONNull?
1359+ let irretentive: JSONNull?
1360+ let parcener: JSONNull?
1361+ let pedder: JSONNull?
1362+ let pseudoanatomic: JSONNull?
1363+ let rhizocarpian: JSONNull?
1364+ let samel: JSONNull?
1365+ let silker: JSONNull?
1366+ let subdentated: JSONNull?
1367+ let subobscure: JSONNull?
1368+
1369+ enum CodingKeys: String, CodingKey {
1370+ case amoreuxia = "Amoreuxia"
1371+ case ani = "ani"
1372+ case bernicle = "bernicle"
1373+ case blackwasher = "blackwasher"
1374+ case blowhard = "blowhard"
1375+ case broma = "broma"
1376+ case closecross = "closecross"
1377+ case congregationalism = "congregationalism"
1378+ case grayly = "grayly"
1379+ case historically = "historically"
1380+ case hoast = "hoast"
1381+ case irretentive = "irretentive"
1382+ case parcener = "parcener"
1383+ case pedder = "pedder"
1384+ case pseudoanatomic = "pseudoanatomic"
1385+ case rhizocarpian = "rhizocarpian"
1386+ case samel = "samel"
1387+ case silker = "silker"
1388+ case subdentated = "subdentated"
1389+ case subobscure = "subobscure"
1390+ }
1391+}
1392+
1393+// MARK: DiaereseClass convenience initializers and mutators
1394+
1395+extension DiaereseClass {
1396+ init(data: Data) throws {
1397+ self = try newJSONDecoder().decode(DiaereseClass.self, from: data)
1398+ }
1399+
1400+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1401+ guard let data = json.data(using: encoding) else {
1402+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1403+ }
1404+ try self.init(data: data)
1405+ }
1406+
1407+ init(fromURL url: URL) throws {
1408+ try self.init(data: try Data(contentsOf: url))
1409+ }
1410+
1411+ func with(
1412+ amoreuxia: JSONNull?? = nil,
1413+ ani: JSONNull?? = nil,
1414+ bernicle: JSONNull?? = nil,
1415+ blackwasher: JSONNull?? = nil,
1416+ blowhard: JSONNull?? = nil,
1417+ broma: JSONNull?? = nil,
1418+ closecross: JSONNull?? = nil,
1419+ congregationalism: JSONNull?? = nil,
1420+ grayly: JSONNull?? = nil,
1421+ historically: JSONNull?? = nil,
1422+ hoast: JSONNull?? = nil,
1423+ irretentive: JSONNull?? = nil,
1424+ parcener: JSONNull?? = nil,
1425+ pedder: JSONNull?? = nil,
1426+ pseudoanatomic: JSONNull?? = nil,
1427+ rhizocarpian: JSONNull?? = nil,
1428+ samel: JSONNull?? = nil,
1429+ silker: JSONNull?? = nil,
1430+ subdentated: JSONNull?? = nil,
1431+ subobscure: JSONNull?? = nil
1432+ ) -> DiaereseClass {
1433+ return DiaereseClass(
1434+ amoreuxia: amoreuxia ?? self.amoreuxia,
1435+ ani: ani ?? self.ani,
1436+ bernicle: bernicle ?? self.bernicle,
1437+ blackwasher: blackwasher ?? self.blackwasher,
1438+ blowhard: blowhard ?? self.blowhard,
1439+ broma: broma ?? self.broma,
1440+ closecross: closecross ?? self.closecross,
1441+ congregationalism: congregationalism ?? self.congregationalism,
1442+ grayly: grayly ?? self.grayly,
1443+ historically: historically ?? self.historically,
1444+ hoast: hoast ?? self.hoast,
1445+ irretentive: irretentive ?? self.irretentive,
1446+ parcener: parcener ?? self.parcener,
1447+ pedder: pedder ?? self.pedder,
1448+ pseudoanatomic: pseudoanatomic ?? self.pseudoanatomic,
1449+ rhizocarpian: rhizocarpian ?? self.rhizocarpian,
1450+ samel: samel ?? self.samel,
1451+ silker: silker ?? self.silker,
1452+ subdentated: subdentated ?? self.subdentated,
1453+ subobscure: subobscure ?? self.subobscure
1454+ )
1455+ }
1456+
1457+ func jsonData() throws -> Data {
1458+ return try newJSONEncoder().encode(self)
1459+ }
1460+
1461+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1462+ return String(data: try self.jsonData(), encoding: encoding)
1463+ }
1464+}
1465+
1466+enum Downstroke: Codable, Hashable {
1467+ case bool(Bool)
1468+ case nullArray([JSONNull?])
1469+ case string(String)
1470+
1471+ init(from decoder: Decoder) throws {
1472+ let container = try decoder.singleValueContainer()
1473+ if let x = try? container.decode(Bool.self) {
1474+ self = .bool(x)
1475+ return
1476+ }
1477+ if let x = try? container.decode([JSONNull?].self) {
1478+ self = .nullArray(x)
1479+ return
1480+ }
1481+ if let x = try? container.decode(String.self) {
1482+ self = .string(x)
1483+ return
1484+ }
1485+ throw DecodingError.typeMismatch(Downstroke.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Downstroke"))
1486+ }
1487+
1488+ func encode(to encoder: Encoder) throws {
1489+ var container = encoder.singleValueContainer()
1490+ switch self {
1491+ case .bool(let x):
1492+ try container.encode(x)
1493+ case .nullArray(let x):
1494+ try container.encode(x)
1495+ case .string(let x):
1496+ try container.encode(x)
1497+ }
1498+ }
1499+}
1500+
1501+enum Eleutheromania: Codable, Hashable {
1502+ case double(Double)
1503+ case integerMap([String: Int])
1504+ case string(String)
1505+
1506+ init(from decoder: Decoder) throws {
1507+ let container = try decoder.singleValueContainer()
1508+ if let x = try? container.decode(Double.self) {
1509+ self = .double(x)
1510+ return
1511+ }
1512+ if let x = try? container.decode([String: Int].self) {
1513+ self = .integerMap(x)
1514+ return
1515+ }
1516+ if let x = try? container.decode(String.self) {
1517+ self = .string(x)
1518+ return
1519+ }
1520+ throw DecodingError.typeMismatch(Eleutheromania.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Eleutheromania"))
1521+ }
1522+
1523+ func encode(to encoder: Encoder) throws {
1524+ var container = encoder.singleValueContainer()
1525+ switch self {
1526+ case .double(let x):
1527+ try container.encode(x)
1528+ case .integerMap(let x):
1529+ try container.encode(x)
1530+ case .string(let x):
1531+ try container.encode(x)
1532+ }
1533+ }
1534+}
1535+
1536+//
1537+// Hashable or Equatable:
1538+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
1539+// for types that require the use of JSONAny, nor will the implementation of Hashable be
1540+// synthesized for types that have collections (such as arrays or dictionaries).
1541+
1542+// MARK: - Encrust
1543+struct Encrust: Codable, Hashable {
1544+ let comradely: JSONNull?
1545+ let diacanthous: JSONNull?
1546+ let feminineness: JSONNull?
1547+ let gossamered: JSONNull?
1548+ let hibernia: JSONNull?
1549+ let hibiscus: JSONNull?
1550+ let lepidosauria: JSONNull?
1551+ let lollingly: JSONNull?
1552+ let manager: JSONNull?
1553+ let mechanic: JSONNull?
1554+ let overminuteness: JSONNull?
1555+ let papelonne: JSONNull?
1556+ let plebification: JSONNull?
1557+ let pugmiller: JSONNull?
1558+ let recoveror: JSONNull?
1559+ let spermatoblastic: JSONNull?
1560+ let syllidae: JSONNull?
1561+ let ungyved: JSONNull?
1562+ let whirlabout: JSONNull?
1563+ let woodenware: JSONNull?
1564+
1565+ enum CodingKeys: String, CodingKey {
1566+ case comradely = "comradely"
1567+ case diacanthous = "diacanthous"
1568+ case feminineness = "feminineness"
1569+ case gossamered = "gossamered"
1570+ case hibernia = "Hibernia"
1571+ case hibiscus = "Hibiscus"
1572+ case lepidosauria = "Lepidosauria"
1573+ case lollingly = "lollingly"
1574+ case manager = "manager"
1575+ case mechanic = "mechanic"
1576+ case overminuteness = "overminuteness"
1577+ case papelonne = "papelonne"
1578+ case plebification = "plebification"
1579+ case pugmiller = "pugmiller"
1580+ case recoveror = "recoveror"
1581+ case spermatoblastic = "spermatoblastic"
1582+ case syllidae = "Syllidae"
1583+ case ungyved = "ungyved"
1584+ case whirlabout = "whirlabout"
1585+ case woodenware = "woodenware"
1586+ }
1587+}
1588+
1589+// MARK: Encrust convenience initializers and mutators
1590+
1591+extension Encrust {
1592+ init(data: Data) throws {
1593+ self = try newJSONDecoder().decode(Encrust.self, from: data)
1594+ }
1595+
1596+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1597+ guard let data = json.data(using: encoding) else {
1598+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1599+ }
1600+ try self.init(data: data)
1601+ }
1602+
1603+ init(fromURL url: URL) throws {
1604+ try self.init(data: try Data(contentsOf: url))
1605+ }
1606+
1607+ func with(
1608+ comradely: JSONNull?? = nil,
1609+ diacanthous: JSONNull?? = nil,
1610+ feminineness: JSONNull?? = nil,
1611+ gossamered: JSONNull?? = nil,
1612+ hibernia: JSONNull?? = nil,
1613+ hibiscus: JSONNull?? = nil,
1614+ lepidosauria: JSONNull?? = nil,
1615+ lollingly: JSONNull?? = nil,
1616+ manager: JSONNull?? = nil,
1617+ mechanic: JSONNull?? = nil,
1618+ overminuteness: JSONNull?? = nil,
1619+ papelonne: JSONNull?? = nil,
1620+ plebification: JSONNull?? = nil,
1621+ pugmiller: JSONNull?? = nil,
1622+ recoveror: JSONNull?? = nil,
1623+ spermatoblastic: JSONNull?? = nil,
1624+ syllidae: JSONNull?? = nil,
1625+ ungyved: JSONNull?? = nil,
1626+ whirlabout: JSONNull?? = nil,
1627+ woodenware: JSONNull?? = nil
1628+ ) -> Encrust {
1629+ return Encrust(
1630+ comradely: comradely ?? self.comradely,
1631+ diacanthous: diacanthous ?? self.diacanthous,
1632+ feminineness: feminineness ?? self.feminineness,
1633+ gossamered: gossamered ?? self.gossamered,
1634+ hibernia: hibernia ?? self.hibernia,
1635+ hibiscus: hibiscus ?? self.hibiscus,
1636+ lepidosauria: lepidosauria ?? self.lepidosauria,
1637+ lollingly: lollingly ?? self.lollingly,
1638+ manager: manager ?? self.manager,
1639+ mechanic: mechanic ?? self.mechanic,
1640+ overminuteness: overminuteness ?? self.overminuteness,
1641+ papelonne: papelonne ?? self.papelonne,
1642+ plebification: plebification ?? self.plebification,
1643+ pugmiller: pugmiller ?? self.pugmiller,
1644+ recoveror: recoveror ?? self.recoveror,
1645+ spermatoblastic: spermatoblastic ?? self.spermatoblastic,
1646+ syllidae: syllidae ?? self.syllidae,
1647+ ungyved: ungyved ?? self.ungyved,
1648+ whirlabout: whirlabout ?? self.whirlabout,
1649+ woodenware: woodenware ?? self.woodenware
1650+ )
1651+ }
1652+
1653+ func jsonData() throws -> Data {
1654+ return try newJSONEncoder().encode(self)
1655+ }
1656+
1657+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1658+ return String(data: try self.jsonData(), encoding: encoding)
1659+ }
1660+}
1661+
1662+enum Entomoid: Codable, Hashable {
1663+ case cimeliaClass(CimeliaClass)
1664+ case integer(Int)
1665+
1666+ init(from decoder: Decoder) throws {
1667+ let container = try decoder.singleValueContainer()
1668+ if let x = try? container.decode(Int.self) {
1669+ self = .integer(x)
1670+ return
1671+ }
1672+ if let x = try? container.decode(CimeliaClass.self) {
1673+ self = .cimeliaClass(x)
1674+ return
1675+ }
1676+ throw DecodingError.typeMismatch(Entomoid.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Entomoid"))
1677+ }
1678+
1679+ func encode(to encoder: Encoder) throws {
1680+ var container = encoder.singleValueContainer()
1681+ switch self {
1682+ case .cimeliaClass(let x):
1683+ try container.encode(x)
1684+ case .integer(let x):
1685+ try container.encode(x)
1686+ }
1687+ }
1688+}
1689+
1690+enum Epipaleolithic: Codable, Hashable {
1691+ case double(Double)
1692+ case integerArray([Int])
1693+
1694+ init(from decoder: Decoder) throws {
1695+ let container = try decoder.singleValueContainer()
1696+ if let x = try? container.decode([Int].self) {
1697+ self = .integerArray(x)
1698+ return
1699+ }
1700+ if let x = try? container.decode(Double.self) {
1701+ self = .double(x)
1702+ return
1703+ }
1704+ throw DecodingError.typeMismatch(Epipaleolithic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Epipaleolithic"))
1705+ }
1706+
1707+ func encode(to encoder: Encoder) throws {
1708+ var container = encoder.singleValueContainer()
1709+ switch self {
1710+ case .double(let x):
1711+ try container.encode(x)
1712+ case .integerArray(let x):
1713+ try container.encode(x)
1714+ }
1715+ }
1716+}
1717+
1718+enum Expropriable: Codable, Hashable {
1719+ case cimeliaClass(CimeliaClass)
1720+ case double(Double)
1721+ case nullArray([JSONNull?])
1722+
1723+ init(from decoder: Decoder) throws {
1724+ let container = try decoder.singleValueContainer()
1725+ if let x = try? container.decode([JSONNull?].self) {
1726+ self = .nullArray(x)
1727+ return
1728+ }
1729+ if let x = try? container.decode(Double.self) {
1730+ self = .double(x)
1731+ return
1732+ }
1733+ if let x = try? container.decode(CimeliaClass.self) {
1734+ self = .cimeliaClass(x)
1735+ return
1736+ }
1737+ throw DecodingError.typeMismatch(Expropriable.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Expropriable"))
1738+ }
1739+
1740+ func encode(to encoder: Encoder) throws {
1741+ var container = encoder.singleValueContainer()
1742+ switch self {
1743+ case .cimeliaClass(let x):
1744+ try container.encode(x)
1745+ case .double(let x):
1746+ try container.encode(x)
1747+ case .nullArray(let x):
1748+ try container.encode(x)
1749+ }
1750+ }
1751+}
1752+
1753+enum FagginglyElement: Codable, Hashable {
1754+ case double(Double)
1755+ case fagginglyClass(FagginglyClass)
1756+
1757+ init(from decoder: Decoder) throws {
1758+ let container = try decoder.singleValueContainer()
1759+ if let x = try? container.decode(Double.self) {
1760+ self = .double(x)
1761+ return
1762+ }
1763+ if let x = try? container.decode(FagginglyClass.self) {
1764+ self = .fagginglyClass(x)
1765+ return
1766+ }
1767+ throw DecodingError.typeMismatch(FagginglyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for FagginglyElement"))
1768+ }
1769+
1770+ func encode(to encoder: Encoder) throws {
1771+ var container = encoder.singleValueContainer()
1772+ switch self {
1773+ case .double(let x):
1774+ try container.encode(x)
1775+ case .fagginglyClass(let x):
1776+ try container.encode(x)
1777+ }
1778+ }
1779+}
1780+
1781+//
1782+// Hashable or Equatable:
1783+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
1784+// for types that require the use of JSONAny, nor will the implementation of Hashable be
1785+// synthesized for types that have collections (such as arrays or dictionaries).
1786+
1787+// MARK: - FagginglyClass
1788+struct FagginglyClass: Codable, Hashable {
1789+ let abranchian: JSONNull?
1790+ let aculeiform: JSONNull?
1791+ let adiaphoristic: JSONNull?
1792+ let adoptionism: JSONNull?
1793+ let anglic: JSONNull?
1794+ let antrotomy: JSONNull?
1795+ let coerciveness: JSONNull?
1796+ let decorist: JSONNull?
1797+ let duckhood: JSONNull?
1798+ let heteromeri: JSONNull?
1799+ let hypochnose: JSONNull?
1800+ let lochage: JSONNull?
1801+ let melee: JSONNull?
1802+ let nonconformitant: JSONNull?
1803+ let poinsettia: JSONNull?
1804+ let putatively: JSONNull?
1805+ let semivolatile: JSONNull?
1806+ let soleas: JSONNull?
1807+ let unfastenable: JSONNull?
1808+ let unmillinered: JSONNull?
1809+
1810+ enum CodingKeys: String, CodingKey {
1811+ case abranchian = "abranchian"
1812+ case aculeiform = "aculeiform"
1813+ case adiaphoristic = "adiaphoristic"
1814+ case adoptionism = "adoptionism"
1815+ case anglic = "Anglic"
1816+ case antrotomy = "antrotomy"
1817+ case coerciveness = "coerciveness"
1818+ case decorist = "decorist"
1819+ case duckhood = "duckhood"
1820+ case heteromeri = "Heteromeri"
1821+ case hypochnose = "hypochnose"
1822+ case lochage = "lochage"
1823+ case melee = "melee"
1824+ case nonconformitant = "nonconformitant"
1825+ case poinsettia = "Poinsettia"
1826+ case putatively = "putatively"
1827+ case semivolatile = "semivolatile"
1828+ case soleas = "soleas"
1829+ case unfastenable = "unfastenable"
1830+ case unmillinered = "unmillinered"
1831+ }
1832+}
1833+
1834+// MARK: FagginglyClass convenience initializers and mutators
1835+
1836+extension FagginglyClass {
1837+ init(data: Data) throws {
1838+ self = try newJSONDecoder().decode(FagginglyClass.self, from: data)
1839+ }
1840+
1841+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1842+ guard let data = json.data(using: encoding) else {
1843+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1844+ }
1845+ try self.init(data: data)
1846+ }
1847+
1848+ init(fromURL url: URL) throws {
1849+ try self.init(data: try Data(contentsOf: url))
1850+ }
1851+
1852+ func with(
1853+ abranchian: JSONNull?? = nil,
1854+ aculeiform: JSONNull?? = nil,
1855+ adiaphoristic: JSONNull?? = nil,
1856+ adoptionism: JSONNull?? = nil,
1857+ anglic: JSONNull?? = nil,
1858+ antrotomy: JSONNull?? = nil,
1859+ coerciveness: JSONNull?? = nil,
1860+ decorist: JSONNull?? = nil,
1861+ duckhood: JSONNull?? = nil,
1862+ heteromeri: JSONNull?? = nil,
1863+ hypochnose: JSONNull?? = nil,
1864+ lochage: JSONNull?? = nil,
1865+ melee: JSONNull?? = nil,
1866+ nonconformitant: JSONNull?? = nil,
1867+ poinsettia: JSONNull?? = nil,
1868+ putatively: JSONNull?? = nil,
1869+ semivolatile: JSONNull?? = nil,
1870+ soleas: JSONNull?? = nil,
1871+ unfastenable: JSONNull?? = nil,
1872+ unmillinered: JSONNull?? = nil
1873+ ) -> FagginglyClass {
1874+ return FagginglyClass(
1875+ abranchian: abranchian ?? self.abranchian,
1876+ aculeiform: aculeiform ?? self.aculeiform,
1877+ adiaphoristic: adiaphoristic ?? self.adiaphoristic,
1878+ adoptionism: adoptionism ?? self.adoptionism,
1879+ anglic: anglic ?? self.anglic,
1880+ antrotomy: antrotomy ?? self.antrotomy,
1881+ coerciveness: coerciveness ?? self.coerciveness,
1882+ decorist: decorist ?? self.decorist,
1883+ duckhood: duckhood ?? self.duckhood,
1884+ heteromeri: heteromeri ?? self.heteromeri,
1885+ hypochnose: hypochnose ?? self.hypochnose,
1886+ lochage: lochage ?? self.lochage,
1887+ melee: melee ?? self.melee,
1888+ nonconformitant: nonconformitant ?? self.nonconformitant,
1889+ poinsettia: poinsettia ?? self.poinsettia,
1890+ putatively: putatively ?? self.putatively,
1891+ semivolatile: semivolatile ?? self.semivolatile,
1892+ soleas: soleas ?? self.soleas,
1893+ unfastenable: unfastenable ?? self.unfastenable,
1894+ unmillinered: unmillinered ?? self.unmillinered
1895+ )
1896+ }
1897+
1898+ func jsonData() throws -> Data {
1899+ return try newJSONEncoder().encode(self)
1900+ }
1901+
1902+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1903+ return String(data: try self.jsonData(), encoding: encoding)
1904+ }
1905+}
1906+
1907+enum FenkElement: Codable, Hashable {
1908+ case fenkClass(FenkClass)
1909+ case string(String)
1910+
1911+ init(from decoder: Decoder) throws {
1912+ let container = try decoder.singleValueContainer()
1913+ if let x = try? container.decode(String.self) {
1914+ self = .string(x)
1915+ return
1916+ }
1917+ if let x = try? container.decode(FenkClass.self) {
1918+ self = .fenkClass(x)
1919+ return
1920+ }
1921+ throw DecodingError.typeMismatch(FenkElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for FenkElement"))
1922+ }
1923+
1924+ func encode(to encoder: Encoder) throws {
1925+ var container = encoder.singleValueContainer()
1926+ switch self {
1927+ case .fenkClass(let x):
1928+ try container.encode(x)
1929+ case .string(let x):
1930+ try container.encode(x)
1931+ }
1932+ }
1933+}
1934+
1935+//
1936+// Hashable or Equatable:
1937+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
1938+// for types that require the use of JSONAny, nor will the implementation of Hashable be
1939+// synthesized for types that have collections (such as arrays or dictionaries).
1940+
1941+// MARK: - FenkClass
1942+struct FenkClass: Codable, Hashable {
1943+ let apoise: JSONNull?
1944+ let astronomize: JSONNull?
1945+ let cockhorse: JSONNull?
1946+ let copular: JSONNull?
1947+ let dagomba: JSONNull?
1948+ let draffy: JSONNull?
1949+ let foreigner: JSONNull?
1950+ let guyandot: JSONNull?
1951+ let neurogliosis: JSONNull?
1952+ let osmious: JSONNull?
1953+ let palpitate: JSONNull?
1954+ let rebukeable: JSONNull?
1955+ let reinwardtia: JSONNull?
1956+ let reservatory: JSONNull?
1957+ let scalt: JSONNull?
1958+ let scripturalize: JSONNull?
1959+ let tintometer: JSONNull?
1960+ let tritoness: JSONNull?
1961+ let undergrade: JSONNull?
1962+ let undermountain: JSONNull?
1963+
1964+ enum CodingKeys: String, CodingKey {
1965+ case apoise = "apoise"
1966+ case astronomize = "astronomize"
1967+ case cockhorse = "cockhorse"
1968+ case copular = "copular"
1969+ case dagomba = "Dagomba"
1970+ case draffy = "draffy"
1971+ case foreigner = "foreigner"
1972+ case guyandot = "Guyandot"
1973+ case neurogliosis = "neurogliosis"
1974+ case osmious = "osmious"
1975+ case palpitate = "palpitate"
1976+ case rebukeable = "rebukeable"
1977+ case reinwardtia = "Reinwardtia"
1978+ case reservatory = "reservatory"
1979+ case scalt = "scalt"
1980+ case scripturalize = "scripturalize"
1981+ case tintometer = "tintometer"
1982+ case tritoness = "Tritoness"
1983+ case undergrade = "undergrade"
1984+ case undermountain = "undermountain"
1985+ }
1986+}
1987+
1988+// MARK: FenkClass convenience initializers and mutators
1989+
1990+extension FenkClass {
1991+ init(data: Data) throws {
1992+ self = try newJSONDecoder().decode(FenkClass.self, from: data)
1993+ }
1994+
1995+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1996+ guard let data = json.data(using: encoding) else {
1997+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1998+ }
1999+ try self.init(data: data)
2000+ }
2001+
2002+ init(fromURL url: URL) throws {
2003+ try self.init(data: try Data(contentsOf: url))
2004+ }
2005+
2006+ func with(
2007+ apoise: JSONNull?? = nil,
2008+ astronomize: JSONNull?? = nil,
2009+ cockhorse: JSONNull?? = nil,
2010+ copular: JSONNull?? = nil,
2011+ dagomba: JSONNull?? = nil,
2012+ draffy: JSONNull?? = nil,
2013+ foreigner: JSONNull?? = nil,
2014+ guyandot: JSONNull?? = nil,
2015+ neurogliosis: JSONNull?? = nil,
2016+ osmious: JSONNull?? = nil,
2017+ palpitate: JSONNull?? = nil,
2018+ rebukeable: JSONNull?? = nil,
2019+ reinwardtia: JSONNull?? = nil,
2020+ reservatory: JSONNull?? = nil,
2021+ scalt: JSONNull?? = nil,
2022+ scripturalize: JSONNull?? = nil,
2023+ tintometer: JSONNull?? = nil,
2024+ tritoness: JSONNull?? = nil,
2025+ undergrade: JSONNull?? = nil,
2026+ undermountain: JSONNull?? = nil
2027+ ) -> FenkClass {
2028+ return FenkClass(
2029+ apoise: apoise ?? self.apoise,
2030+ astronomize: astronomize ?? self.astronomize,
2031+ cockhorse: cockhorse ?? self.cockhorse,
2032+ copular: copular ?? self.copular,
2033+ dagomba: dagomba ?? self.dagomba,
2034+ draffy: draffy ?? self.draffy,
2035+ foreigner: foreigner ?? self.foreigner,
2036+ guyandot: guyandot ?? self.guyandot,
2037+ neurogliosis: neurogliosis ?? self.neurogliosis,
2038+ osmious: osmious ?? self.osmious,
2039+ palpitate: palpitate ?? self.palpitate,
2040+ rebukeable: rebukeable ?? self.rebukeable,
2041+ reinwardtia: reinwardtia ?? self.reinwardtia,
2042+ reservatory: reservatory ?? self.reservatory,
2043+ scalt: scalt ?? self.scalt,
2044+ scripturalize: scripturalize ?? self.scripturalize,
2045+ tintometer: tintometer ?? self.tintometer,
2046+ tritoness: tritoness ?? self.tritoness,
2047+ undergrade: undergrade ?? self.undergrade,
2048+ undermountain: undermountain ?? self.undermountain
2049+ )
2050+ }
2051+
2052+ func jsonData() throws -> Data {
2053+ return try newJSONEncoder().encode(self)
2054+ }
2055+
2056+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2057+ return String(data: try self.jsonData(), encoding: encoding)
2058+ }
2059+}
2060+
2061+enum FlagmakingElement: Codable, Hashable {
2062+ case bool(Bool)
2063+ case double(Double)
2064+ case flagmakingClass(FlagmakingClass)
2065+
2066+ init(from decoder: Decoder) throws {
2067+ let container = try decoder.singleValueContainer()
2068+ if let x = try? container.decode(Bool.self) {
2069+ self = .bool(x)
2070+ return
2071+ }
2072+ if let x = try? container.decode(Double.self) {
2073+ self = .double(x)
2074+ return
2075+ }
2076+ if let x = try? container.decode(FlagmakingClass.self) {
2077+ self = .flagmakingClass(x)
2078+ return
2079+ }
2080+ throw DecodingError.typeMismatch(FlagmakingElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for FlagmakingElement"))
2081+ }
2082+
2083+ func encode(to encoder: Encoder) throws {
2084+ var container = encoder.singleValueContainer()
2085+ switch self {
2086+ case .bool(let x):
2087+ try container.encode(x)
2088+ case .double(let x):
2089+ try container.encode(x)
2090+ case .flagmakingClass(let x):
2091+ try container.encode(x)
2092+ }
2093+ }
2094+}
2095+
2096+//
2097+// Hashable or Equatable:
2098+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
2099+// for types that require the use of JSONAny, nor will the implementation of Hashable be
2100+// synthesized for types that have collections (such as arrays or dictionaries).
2101+
2102+// MARK: - FlagmakingClass
2103+struct FlagmakingClass: Codable, Hashable {
2104+ let albarco: JSONNull?
2105+ let bunodonta: JSONNull?
2106+ let hornify: JSONNull?
2107+ let hydrocorisae: JSONNull?
2108+ let hypoglossus: JSONNull?
2109+ let inexpiably: JSONNull?
2110+ let ingratitude: JSONNull?
2111+ let ladyfly: JSONNull?
2112+ let medicament: JSONNull?
2113+ let monogrammatic: JSONNull?
2114+ let nobbut: JSONNull?
2115+ let notacanthidae: JSONNull?
2116+ let polyplacophore: JSONNull?
2117+ let proexercise: JSONNull?
2118+ let protoplast: JSONNull?
2119+ let puzzling: JSONNull?
2120+ let splanchnoskeleton: JSONNull?
2121+ let unloveliness: JSONNull?
2122+ let unquarantined: JSONNull?
2123+ let unrenounceable: JSONNull?
2124+
2125+ enum CodingKeys: String, CodingKey {
2126+ case albarco = "albarco"
2127+ case bunodonta = "Bunodonta"
2128+ case hornify = "hornify"
2129+ case hydrocorisae = "Hydrocorisae"
2130+ case hypoglossus = "hypoglossus"
2131+ case inexpiably = "inexpiably"
2132+ case ingratitude = "ingratitude"
2133+ case ladyfly = "ladyfly"
2134+ case medicament = "medicament"
2135+ case monogrammatic = "monogrammatic"
2136+ case nobbut = "nobbut"
2137+ case notacanthidae = "Notacanthidae"
2138+ case polyplacophore = "polyplacophore"
2139+ case proexercise = "proexercise"
2140+ case protoplast = "protoplast"
2141+ case puzzling = "puzzling"
2142+ case splanchnoskeleton = "splanchnoskeleton"
2143+ case unloveliness = "unloveliness"
2144+ case unquarantined = "unquarantined"
2145+ case unrenounceable = "unrenounceable"
2146+ }
2147+}
2148+
2149+// MARK: FlagmakingClass convenience initializers and mutators
2150+
2151+extension FlagmakingClass {
2152+ init(data: Data) throws {
2153+ self = try newJSONDecoder().decode(FlagmakingClass.self, from: data)
2154+ }
2155+
2156+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2157+ guard let data = json.data(using: encoding) else {
2158+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2159+ }
2160+ try self.init(data: data)
2161+ }
2162+
2163+ init(fromURL url: URL) throws {
2164+ try self.init(data: try Data(contentsOf: url))
2165+ }
2166+
2167+ func with(
2168+ albarco: JSONNull?? = nil,
2169+ bunodonta: JSONNull?? = nil,
2170+ hornify: JSONNull?? = nil,
2171+ hydrocorisae: JSONNull?? = nil,
2172+ hypoglossus: JSONNull?? = nil,
2173+ inexpiably: JSONNull?? = nil,
2174+ ingratitude: JSONNull?? = nil,
2175+ ladyfly: JSONNull?? = nil,
2176+ medicament: JSONNull?? = nil,
2177+ monogrammatic: JSONNull?? = nil,
2178+ nobbut: JSONNull?? = nil,
2179+ notacanthidae: JSONNull?? = nil,
2180+ polyplacophore: JSONNull?? = nil,
2181+ proexercise: JSONNull?? = nil,
2182+ protoplast: JSONNull?? = nil,
2183+ puzzling: JSONNull?? = nil,
2184+ splanchnoskeleton: JSONNull?? = nil,
2185+ unloveliness: JSONNull?? = nil,
2186+ unquarantined: JSONNull?? = nil,
2187+ unrenounceable: JSONNull?? = nil
2188+ ) -> FlagmakingClass {
2189+ return FlagmakingClass(
2190+ albarco: albarco ?? self.albarco,
2191+ bunodonta: bunodonta ?? self.bunodonta,
2192+ hornify: hornify ?? self.hornify,
2193+ hydrocorisae: hydrocorisae ?? self.hydrocorisae,
2194+ hypoglossus: hypoglossus ?? self.hypoglossus,
2195+ inexpiably: inexpiably ?? self.inexpiably,
2196+ ingratitude: ingratitude ?? self.ingratitude,
2197+ ladyfly: ladyfly ?? self.ladyfly,
2198+ medicament: medicament ?? self.medicament,
2199+ monogrammatic: monogrammatic ?? self.monogrammatic,
2200+ nobbut: nobbut ?? self.nobbut,
2201+ notacanthidae: notacanthidae ?? self.notacanthidae,
2202+ polyplacophore: polyplacophore ?? self.polyplacophore,
2203+ proexercise: proexercise ?? self.proexercise,
2204+ protoplast: protoplast ?? self.protoplast,
2205+ puzzling: puzzling ?? self.puzzling,
2206+ splanchnoskeleton: splanchnoskeleton ?? self.splanchnoskeleton,
2207+ unloveliness: unloveliness ?? self.unloveliness,
2208+ unquarantined: unquarantined ?? self.unquarantined,
2209+ unrenounceable: unrenounceable ?? self.unrenounceable
2210+ )
2211+ }
2212+
2213+ func jsonData() throws -> Data {
2214+ return try newJSONEncoder().encode(self)
2215+ }
2216+
2217+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2218+ return String(data: try self.jsonData(), encoding: encoding)
2219+ }
2220+}
2221+
2222+enum Fluorometer: Codable, Hashable {
2223+ case integer(Int)
2224+ case string(String)
2225+ case null
2226+
2227+ init(from decoder: Decoder) throws {
2228+ let container = try decoder.singleValueContainer()
2229+ if let x = try? container.decode(Int.self) {
2230+ self = .integer(x)
2231+ return
2232+ }
2233+ if let x = try? container.decode(String.self) {
2234+ self = .string(x)
2235+ return
2236+ }
2237+ if container.decodeNil() {
2238+ self = .null
2239+ return
2240+ }
2241+ throw DecodingError.typeMismatch(Fluorometer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Fluorometer"))
2242+ }
2243+
2244+ func encode(to encoder: Encoder) throws {
2245+ var container = encoder.singleValueContainer()
2246+ switch self {
2247+ case .integer(let x):
2248+ try container.encode(x)
2249+ case .string(let x):
2250+ try container.encode(x)
2251+ case .null:
2252+ try container.encodeNil()
2253+ }
2254+ }
2255+}
2256+
2257+enum Fuzzy: Codable, Hashable {
2258+ case integer(Int)
2259+ case unionMap([String: Int?])
2260+
2261+ init(from decoder: Decoder) throws {
2262+ let container = try decoder.singleValueContainer()
2263+ if let x = try? container.decode(Int.self) {
2264+ self = .integer(x)
2265+ return
2266+ }
2267+ if let x = try? container.decode([String: Int?].self) {
2268+ self = .unionMap(x)
2269+ return
2270+ }
2271+ throw DecodingError.typeMismatch(Fuzzy.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Fuzzy"))
2272+ }
2273+
2274+ func encode(to encoder: Encoder) throws {
2275+ var container = encoder.singleValueContainer()
2276+ switch self {
2277+ case .integer(let x):
2278+ try container.encode(x)
2279+ case .unionMap(let x):
2280+ try container.encode(x)
2281+ }
2282+ }
2283+}
2284+
2285+enum Gardenward: Codable, Hashable {
2286+ case bool(Bool)
2287+ case integerArray([Int])
2288+ case string(String)
2289+
2290+ init(from decoder: Decoder) throws {
2291+ let container = try decoder.singleValueContainer()
2292+ if let x = try? container.decode(Bool.self) {
2293+ self = .bool(x)
2294+ return
2295+ }
2296+ if let x = try? container.decode([Int].self) {
2297+ self = .integerArray(x)
2298+ return
2299+ }
2300+ if let x = try? container.decode(String.self) {
2301+ self = .string(x)
2302+ return
2303+ }
2304+ throw DecodingError.typeMismatch(Gardenward.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Gardenward"))
2305+ }
2306+
2307+ func encode(to encoder: Encoder) throws {
2308+ var container = encoder.singleValueContainer()
2309+ switch self {
2310+ case .bool(let x):
2311+ try container.encode(x)
2312+ case .integerArray(let x):
2313+ try container.encode(x)
2314+ case .string(let x):
2315+ try container.encode(x)
2316+ }
2317+ }
2318+}
2319+
2320+enum Generalissimo: Codable, Hashable {
2321+ case bool(Bool)
2322+ case integerMap([String: Int])
2323+ case null
2324+
2325+ init(from decoder: Decoder) throws {
2326+ let container = try decoder.singleValueContainer()
2327+ if let x = try? container.decode(Bool.self) {
2328+ self = .bool(x)
2329+ return
2330+ }
2331+ if let x = try? container.decode([String: Int].self) {
2332+ self = .integerMap(x)
2333+ return
2334+ }
2335+ if container.decodeNil() {
2336+ self = .null
2337+ return
2338+ }
2339+ throw DecodingError.typeMismatch(Generalissimo.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Generalissimo"))
2340+ }
2341+
2342+ func encode(to encoder: Encoder) throws {
2343+ var container = encoder.singleValueContainer()
2344+ switch self {
2345+ case .bool(let x):
2346+ try container.encode(x)
2347+ case .integerMap(let x):
2348+ try container.encode(x)
2349+ case .null:
2350+ try container.encodeNil()
2351+ }
2352+ }
2353+}
2354+
2355+enum Hemicrystalline: Codable, Hashable {
2356+ case cimeliaClass(CimeliaClass)
2357+ case string(String)
2358+
2359+ init(from decoder: Decoder) throws {
2360+ let container = try decoder.singleValueContainer()
2361+ if let x = try? container.decode(String.self) {
2362+ self = .string(x)
2363+ return
2364+ }
2365+ if let x = try? container.decode(CimeliaClass.self) {
2366+ self = .cimeliaClass(x)
2367+ return
2368+ }
2369+ throw DecodingError.typeMismatch(Hemicrystalline.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hemicrystalline"))
2370+ }
2371+
2372+ func encode(to encoder: Encoder) throws {
2373+ var container = encoder.singleValueContainer()
2374+ switch self {
2375+ case .cimeliaClass(let x):
2376+ try container.encode(x)
2377+ case .string(let x):
2378+ try container.encode(x)
2379+ }
2380+ }
2381+}
2382+
2383+enum HemocoeleElement: Codable, Hashable {
2384+ case hemocoeleClass(HemocoeleClass)
2385+ case integerArray([Int])
2386+
2387+ init(from decoder: Decoder) throws {
2388+ let container = try decoder.singleValueContainer()
2389+ if let x = try? container.decode([Int].self) {
2390+ self = .integerArray(x)
2391+ return
2392+ }
2393+ if let x = try? container.decode(HemocoeleClass.self) {
2394+ self = .hemocoeleClass(x)
2395+ return
2396+ }
2397+ throw DecodingError.typeMismatch(HemocoeleElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for HemocoeleElement"))
2398+ }
2399+
2400+ func encode(to encoder: Encoder) throws {
2401+ var container = encoder.singleValueContainer()
2402+ switch self {
2403+ case .hemocoeleClass(let x):
2404+ try container.encode(x)
2405+ case .integerArray(let x):
2406+ try container.encode(x)
2407+ }
2408+ }
2409+}
2410+
2411+//
2412+// Hashable or Equatable:
2413+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
2414+// for types that require the use of JSONAny, nor will the implementation of Hashable be
2415+// synthesized for types that have collections (such as arrays or dictionaries).
2416+
2417+// MARK: - HemocoeleClass
2418+struct HemocoeleClass: Codable, Hashable {
2419+ let acrogamy: JSONNull?
2420+ let amelification: JSONNull?
2421+ let autobiographic: JSONNull?
2422+ let berat: JSONNull?
2423+ let catharticalness: Double?
2424+ let chirotherium: Int?
2425+ let disdiapason: String?
2426+ let disproportionably: JSONNull?
2427+ let erythrite: JSONNull?
2428+ let graphic: JSONNull?
2429+ let hepatological: JSONNull?
2430+ let homocerc: Bool?
2431+ let incommensurably: JSONNull?
2432+ let misaffirm: JSONNull?
2433+ let nonbookish: JSONNull?
2434+ let pocketbook: JSONNull?
2435+ let sclerometric: JSONNull?
2436+ let stambouline: JSONNull?
2437+ let stickpin: JSONNull?
2438+ let tubulure: JSONNull?
2439+ let undelated: JSONNull?
2440+ let unsalt: JSONNull?
2441+ let untutelar: JSONNull?
2442+ let vagrant: JSONNull?
2443+ let walt: JSONNull?
2444+
2445+ enum CodingKeys: String, CodingKey {
2446+ case acrogamy = "acrogamy"
2447+ case amelification = "amelification"
2448+ case autobiographic = "autobiographic"
2449+ case berat = "berat"
2450+ case catharticalness = "catharticalness"
2451+ case chirotherium = "Chirotherium"
2452+ case disdiapason = "disdiapason"
2453+ case disproportionably = "disproportionably"
2454+ case erythrite = "erythrite"
2455+ case graphic = "graphic"
2456+ case hepatological = "hepatological"
2457+ case homocerc = "homocerc"
2458+ case incommensurably = "incommensurably"
2459+ case misaffirm = "misaffirm"
2460+ case nonbookish = "nonbookish"
2461+ case pocketbook = "pocketbook"
2462+ case sclerometric = "sclerometric"
2463+ case stambouline = "stambouline"
2464+ case stickpin = "stickpin"
2465+ case tubulure = "tubulure"
2466+ case undelated = "undelated"
2467+ case unsalt = "unsalt"
2468+ case untutelar = "untutelar"
2469+ case vagrant = "vagrant"
2470+ case walt = "Walt"
2471+ }
2472+}
2473+
2474+// MARK: HemocoeleClass convenience initializers and mutators
2475+
2476+extension HemocoeleClass {
2477+ init(data: Data) throws {
2478+ self = try newJSONDecoder().decode(HemocoeleClass.self, from: data)
2479+ }
2480+
2481+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2482+ guard let data = json.data(using: encoding) else {
2483+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2484+ }
2485+ try self.init(data: data)
2486+ }
2487+
2488+ init(fromURL url: URL) throws {
2489+ try self.init(data: try Data(contentsOf: url))
2490+ }
2491+
2492+ func with(
2493+ acrogamy: JSONNull?? = nil,
2494+ amelification: JSONNull?? = nil,
2495+ autobiographic: JSONNull?? = nil,
2496+ berat: JSONNull?? = nil,
2497+ catharticalness: Double?? = nil,
2498+ chirotherium: Int?? = nil,
2499+ disdiapason: String?? = nil,
2500+ disproportionably: JSONNull?? = nil,
2501+ erythrite: JSONNull?? = nil,
2502+ graphic: JSONNull?? = nil,
2503+ hepatological: JSONNull?? = nil,
2504+ homocerc: Bool?? = nil,
2505+ incommensurably: JSONNull?? = nil,
2506+ misaffirm: JSONNull?? = nil,
2507+ nonbookish: JSONNull?? = nil,
2508+ pocketbook: JSONNull?? = nil,
2509+ sclerometric: JSONNull?? = nil,
2510+ stambouline: JSONNull?? = nil,
2511+ stickpin: JSONNull?? = nil,
2512+ tubulure: JSONNull?? = nil,
2513+ undelated: JSONNull?? = nil,
2514+ unsalt: JSONNull?? = nil,
2515+ untutelar: JSONNull?? = nil,
2516+ vagrant: JSONNull?? = nil,
2517+ walt: JSONNull?? = nil
2518+ ) -> HemocoeleClass {
2519+ return HemocoeleClass(
2520+ acrogamy: acrogamy ?? self.acrogamy,
2521+ amelification: amelification ?? self.amelification,
2522+ autobiographic: autobiographic ?? self.autobiographic,
2523+ berat: berat ?? self.berat,
2524+ catharticalness: catharticalness ?? self.catharticalness,
2525+ chirotherium: chirotherium ?? self.chirotherium,
2526+ disdiapason: disdiapason ?? self.disdiapason,
2527+ disproportionably: disproportionably ?? self.disproportionably,
2528+ erythrite: erythrite ?? self.erythrite,
2529+ graphic: graphic ?? self.graphic,
2530+ hepatological: hepatological ?? self.hepatological,
2531+ homocerc: homocerc ?? self.homocerc,
2532+ incommensurably: incommensurably ?? self.incommensurably,
2533+ misaffirm: misaffirm ?? self.misaffirm,
2534+ nonbookish: nonbookish ?? self.nonbookish,
2535+ pocketbook: pocketbook ?? self.pocketbook,
2536+ sclerometric: sclerometric ?? self.sclerometric,
2537+ stambouline: stambouline ?? self.stambouline,
2538+ stickpin: stickpin ?? self.stickpin,
2539+ tubulure: tubulure ?? self.tubulure,
2540+ undelated: undelated ?? self.undelated,
2541+ unsalt: unsalt ?? self.unsalt,
2542+ untutelar: untutelar ?? self.untutelar,
2543+ vagrant: vagrant ?? self.vagrant,
2544+ walt: walt ?? self.walt
2545+ )
2546+ }
2547+
2548+ func jsonData() throws -> Data {
2549+ return try newJSONEncoder().encode(self)
2550+ }
2551+
2552+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2553+ return String(data: try self.jsonData(), encoding: encoding)
2554+ }
2555+}
2556+
2557+enum Hoister: Codable, Hashable {
2558+ case cimeliaClass(CimeliaClass)
2559+ case string(String)
2560+ case null
2561+
2562+ init(from decoder: Decoder) throws {
2563+ let container = try decoder.singleValueContainer()
2564+ if let x = try? container.decode(String.self) {
2565+ self = .string(x)
2566+ return
2567+ }
2568+ if let x = try? container.decode(CimeliaClass.self) {
2569+ self = .cimeliaClass(x)
2570+ return
2571+ }
2572+ if container.decodeNil() {
2573+ self = .null
2574+ return
2575+ }
2576+ throw DecodingError.typeMismatch(Hoister.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hoister"))
2577+ }
2578+
2579+ func encode(to encoder: Encoder) throws {
2580+ var container = encoder.singleValueContainer()
2581+ switch self {
2582+ case .cimeliaClass(let x):
2583+ try container.encode(x)
2584+ case .string(let x):
2585+ try container.encode(x)
2586+ case .null:
2587+ try container.encodeNil()
2588+ }
2589+ }
2590+}
2591+
2592+enum Hyperpiesi: Codable, Hashable {
2593+ case cimeliaClass(CimeliaClass)
2594+ case nullArray([JSONNull?])
2595+ case null
2596+
2597+ init(from decoder: Decoder) throws {
2598+ let container = try decoder.singleValueContainer()
2599+ if let x = try? container.decode([JSONNull?].self) {
2600+ self = .nullArray(x)
2601+ return
2602+ }
2603+ if let x = try? container.decode(CimeliaClass.self) {
2604+ self = .cimeliaClass(x)
2605+ return
2606+ }
2607+ if container.decodeNil() {
2608+ self = .null
2609+ return
2610+ }
2611+ throw DecodingError.typeMismatch(Hyperpiesi.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hyperpiesi"))
2612+ }
2613+
2614+ func encode(to encoder: Encoder) throws {
2615+ var container = encoder.singleValueContainer()
2616+ switch self {
2617+ case .cimeliaClass(let x):
2618+ try container.encode(x)
2619+ case .nullArray(let x):
2620+ try container.encode(x)
2621+ case .null:
2622+ try container.encodeNil()
2623+ }
2624+ }
2625+}
2626+
2627+enum Hyppish: Codable, Hashable {
2628+ case bool(Bool)
2629+ case string(String)
2630+ case null
2631+
2632+ init(from decoder: Decoder) throws {
2633+ let container = try decoder.singleValueContainer()
2634+ if let x = try? container.decode(Bool.self) {
2635+ self = .bool(x)
2636+ return
2637+ }
2638+ if let x = try? container.decode(String.self) {
2639+ self = .string(x)
2640+ return
2641+ }
2642+ if container.decodeNil() {
2643+ self = .null
2644+ return
2645+ }
2646+ throw DecodingError.typeMismatch(Hyppish.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hyppish"))
2647+ }
2648+
2649+ func encode(to encoder: Encoder) throws {
2650+ var container = encoder.singleValueContainer()
2651+ switch self {
2652+ case .bool(let x):
2653+ try container.encode(x)
2654+ case .string(let x):
2655+ try container.encode(x)
2656+ case .null:
2657+ try container.encodeNil()
2658+ }
2659+ }
2660+}
2661+
2662+enum Idealizer: Codable, Hashable {
2663+ case cimeliaClass(CimeliaClass)
2664+ case integer(Int)
2665+ case nullArray([JSONNull?])
2666+
2667+ init(from decoder: Decoder) throws {
2668+ let container = try decoder.singleValueContainer()
2669+ if let x = try? container.decode(Int.self) {
2670+ self = .integer(x)
2671+ return
2672+ }
2673+ if let x = try? container.decode([JSONNull?].self) {
2674+ self = .nullArray(x)
2675+ return
2676+ }
2677+ if let x = try? container.decode(CimeliaClass.self) {
2678+ self = .cimeliaClass(x)
2679+ return
2680+ }
2681+ throw DecodingError.typeMismatch(Idealizer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Idealizer"))
2682+ }
2683+
2684+ func encode(to encoder: Encoder) throws {
2685+ var container = encoder.singleValueContainer()
2686+ switch self {
2687+ case .cimeliaClass(let x):
2688+ try container.encode(x)
2689+ case .integer(let x):
2690+ try container.encode(x)
2691+ case .nullArray(let x):
2692+ try container.encode(x)
2693+ }
2694+ }
2695+}
2696+
2697+enum Incrustator: Codable, Hashable {
2698+ case integer(Int)
2699+ case integerArray([Int])
2700+ case string(String)
2701+
2702+ init(from decoder: Decoder) throws {
2703+ let container = try decoder.singleValueContainer()
2704+ if let x = try? container.decode(Int.self) {
2705+ self = .integer(x)
2706+ return
2707+ }
2708+ if let x = try? container.decode([Int].self) {
2709+ self = .integerArray(x)
2710+ return
2711+ }
2712+ if let x = try? container.decode(String.self) {
2713+ self = .string(x)
2714+ return
2715+ }
2716+ throw DecodingError.typeMismatch(Incrustator.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Incrustator"))
2717+ }
2718+
2719+ func encode(to encoder: Encoder) throws {
2720+ var container = encoder.singleValueContainer()
2721+ switch self {
2722+ case .integer(let x):
2723+ try container.encode(x)
2724+ case .integerArray(let x):
2725+ try container.encode(x)
2726+ case .string(let x):
2727+ try container.encode(x)
2728+ }
2729+ }
2730+}
2731+
2732+enum Intentiveness: Codable, Hashable {
2733+ case cimeliaClass(CimeliaClass)
2734+ case double(Double)
2735+ case string(String)
2736+
2737+ init(from decoder: Decoder) throws {
2738+ let container = try decoder.singleValueContainer()
2739+ if let x = try? container.decode(Double.self) {
2740+ self = .double(x)
2741+ return
2742+ }
2743+ if let x = try? container.decode(String.self) {
2744+ self = .string(x)
2745+ return
2746+ }
2747+ if let x = try? container.decode(CimeliaClass.self) {
2748+ self = .cimeliaClass(x)
2749+ return
2750+ }
2751+ throw DecodingError.typeMismatch(Intentiveness.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Intentiveness"))
2752+ }
2753+
2754+ func encode(to encoder: Encoder) throws {
2755+ var container = encoder.singleValueContainer()
2756+ switch self {
2757+ case .cimeliaClass(let x):
2758+ try container.encode(x)
2759+ case .double(let x):
2760+ try container.encode(x)
2761+ case .string(let x):
2762+ try container.encode(x)
2763+ }
2764+ }
2765+}
2766+
2767+//
2768+// Hashable or Equatable:
2769+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
2770+// for types that require the use of JSONAny, nor will the implementation of Hashable be
2771+// synthesized for types that have collections (such as arrays or dictionaries).
2772+
2773+// MARK: - Interacinar
2774+struct Interacinar: Codable, Hashable {
2775+ let assapan: Double
2776+ let benefactorship: Bool
2777+ let triseriatim: String
2778+ let tubbing: Int
2779+ let untrimmed: JSONNull?
2780+
2781+ enum CodingKeys: String, CodingKey {
2782+ case assapan = "assapan"
2783+ case benefactorship = "benefactorship"
2784+ case triseriatim = "triseriatim"
2785+ case tubbing = "tubbing"
2786+ case untrimmed = "untrimmed"
2787+ }
2788+}
2789+
2790+// MARK: Interacinar convenience initializers and mutators
2791+
2792+extension Interacinar {
2793+ init(data: Data) throws {
2794+ self = try newJSONDecoder().decode(Interacinar.self, from: data)
2795+ }
2796+
2797+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2798+ guard let data = json.data(using: encoding) else {
2799+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2800+ }
2801+ try self.init(data: data)
2802+ }
2803+
2804+ init(fromURL url: URL) throws {
2805+ try self.init(data: try Data(contentsOf: url))
2806+ }
2807+
2808+ func with(
2809+ assapan: Double? = nil,
2810+ benefactorship: Bool? = nil,
2811+ triseriatim: String? = nil,
2812+ tubbing: Int? = nil,
2813+ untrimmed: JSONNull?? = nil
2814+ ) -> Interacinar {
2815+ return Interacinar(
2816+ assapan: assapan ?? self.assapan,
2817+ benefactorship: benefactorship ?? self.benefactorship,
2818+ triseriatim: triseriatim ?? self.triseriatim,
2819+ tubbing: tubbing ?? self.tubbing,
2820+ untrimmed: untrimmed ?? self.untrimmed
2821+ )
2822+ }
2823+
2824+ func jsonData() throws -> Data {
2825+ return try newJSONEncoder().encode(self)
2826+ }
2827+
2828+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2829+ return String(data: try self.jsonData(), encoding: encoding)
2830+ }
2831+}
2832+
2833+enum Jacutinga: Codable, Hashable {
2834+ case integerArray([Int])
2835+ case unionMap([String: Int?])
2836+
2837+ init(from decoder: Decoder) throws {
2838+ let container = try decoder.singleValueContainer()
2839+ if let x = try? container.decode([Int].self) {
2840+ self = .integerArray(x)
2841+ return
2842+ }
2843+ if let x = try? container.decode([String: Int?].self) {
2844+ self = .unionMap(x)
2845+ return
2846+ }
2847+ throw DecodingError.typeMismatch(Jacutinga.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Jacutinga"))
2848+ }
2849+
2850+ func encode(to encoder: Encoder) throws {
2851+ var container = encoder.singleValueContainer()
2852+ switch self {
2853+ case .integerArray(let x):
2854+ try container.encode(x)
2855+ case .unionMap(let x):
2856+ try container.encode(x)
2857+ }
2858+ }
2859+}
2860+
2861+// MARK: - Helper functions for creating encoders and decoders
2862+
2863+func newJSONDecoder() -> JSONDecoder {
2864+ let decoder = JSONDecoder()
2865+ decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in
2866+ let container = try decoder.singleValueContainer()
2867+ let dateStr = try container.decode(String.self)
2868+
2869+ let formatter = DateFormatter()
2870+ formatter.calendar = Calendar(identifier: .iso8601)
2871+ formatter.locale = Locale(identifier: "en_US_POSIX")
2872+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
2873+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX"
2874+ if let date = formatter.date(from: dateStr) {
2875+ return date
2876+ }
2877+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX"
2878+ if let date = formatter.date(from: dateStr) {
2879+ return date
2880+ }
2881+ throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date"))
2882+ })
2883+ return decoder
2884+}
2885+
2886+func newJSONEncoder() -> JSONEncoder {
2887+ let encoder = JSONEncoder()
2888+ let formatter = DateFormatter()
2889+ formatter.calendar = Calendar(identifier: .iso8601)
2890+ formatter.locale = Locale(identifier: "en_US_POSIX")
2891+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
2892+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSXXXXX"
2893+ encoder.dateEncodingStrategy = .formatted(formatter)
2894+ return encoder
2895+}
2896+
2897+// MARK: - Encode/decode helpers
2898+
2899+class JSONNull: Codable, Hashable {
2900+
2901+ public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool {
2902+ return true
2903+ }
2904+
2905+ public func hash(into hasher: inout Hasher) {
2906+ hasher.combine(0)
2907+ }
2908+
2909+ public init() {}
2910+
2911+ public required init(from decoder: Decoder) throws {
2912+ let container = try decoder.singleValueContainer()
2913+ if !container.decodeNil() {
2914+ throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull"))
2915+ }
2916+ }
2917+
2918+ public func encode(to encoder: Encoder) throws {
2919+ var container = encoder.singleValueContainer()
2920+ try container.encodeNil()
2921+ }
2922+}
Atypescriptprefer-const-values-true--6b26e4d1265c / TopLevel.ts+909 −0
@@ -0,0 +1,909 @@
1+// To parse this data:
2+//
3+// import { Convert, TopLevel } from "./TopLevel";
4+//
5+// const topLevel = Convert.toTopLevel(json);
6+//
7+// These functions will throw an error if the JSON doesn't
8+// match the expected interface, even if the JSON is valid.
9+
10+export interface TopLevel {
11+ centrodesmose: string;
12+ cerograph: CerographElement[];
13+ chemotherapeutics: ChemotherapeuticElement[];
14+ cimelia: CimeliaElement[];
15+ citrated: number;
16+ clinodome: Clinodome[];
17+ coadjust: CoadjustElement[];
18+ consilience: Consilience[];
19+ constructor: Constructor[];
20+ continuative: Continuative[];
21+ credulity: CredulityElement[];
22+ creviced: Creviced[];
23+ cubiculum: Array<(number | null)[]>;
24+ deruralize: DeruralizeElement[];
25+ diaereses: DiaereseElement[];
26+ dissolution: (null[] | null)[];
27+ downstroke: Downstroke[];
28+ electrotautomerism: (number | null)[];
29+ eleutheromania: Eleutheromania[];
30+ encrust: Encrust;
31+ entomoid: Entomoid[];
32+ epipaleolithic: Epipaleolithic[];
33+ expropriable: Expropriable[];
34+ faggingly: FagginglyElement[];
35+ fenks: FenkElement[];
36+ flagmaking: FlagmakingElement[];
37+ fluorometer: Fluorometer[];
38+ fulsome: (number | null)[];
39+ fuzzy: Fuzzy[];
40+ gardenwards: Gardenward[];
41+ generalissimo: Generalissimo[];
42+ habeas: ({ [key: string]: number } | null)[];
43+ hemicrystalline: Hemicrystalline[];
44+ hemocoele: HemocoeleElement[];
45+ hoister: Hoister[];
46+ hyperpiesis: Hyperpiesi[];
47+ hyppish: Hyppish[];
48+ idealizer: Idealizer[];
49+ incrustator: Incrustator[];
50+ intentiveness: Intentiveness[];
51+ interacinar: Interacinar;
52+ intercorrelation: (number[] | null)[];
53+ jacutinga: Jacutinga[];
54+}
55+
56+export type CerographElement = CerographClass | null | string;
57+
58+export interface CerographClass {
59+ Tolowa: null;
60+ apotropaion: null;
61+ casuary: null;
62+ creaker: null;
63+ disqualification: null;
64+ imperatorious: null;
65+ impermeabilize: null;
66+ metastoma: null;
67+ noctidiurnal: null;
68+ nonreserve: null;
69+ ophthalmotonometry: null;
70+ pailful: null;
71+ pigfish: null;
72+ pongee: null;
73+ prosodical: null;
74+ scrofuloderm: null;
75+ storekeeping: null;
76+ therologist: null;
77+ tradeful: null;
78+ unriveting: null;
79+}
80+
81+export type ChemotherapeuticElement = ChemotherapeuticClass | number;
82+
83+export interface ChemotherapeuticClass {
84+ Chirotherium?: number;
85+ Maureen?: null;
86+ angioneurotic?: null;
87+ availment?: null;
88+ bladelet?: null;
89+ catharticalness?: number;
90+ caulis?: null;
91+ chalcus?: null;
92+ disdiapason?: string;
93+ enteradenological?: null;
94+ homocerc?: boolean;
95+ imporosity?: null;
96+ insistently?: null;
97+ intraparietal?: null;
98+ ivied?: null;
99+ nonbookish?: null;
100+ nostochine?: null;
101+ nutcracker?: null;
102+ ofttimes?: null;
103+ phenocryst?: null;
104+ precoincident?: null;
105+ ramiferous?: null;
106+ stagmometer?: null;
107+ tetherball?: null;
108+ unshy?: null;
109+}
110+
111+export type CimeliaElement = number[] | CimeliaClass | null;
112+
113+export interface CimeliaClass {
114+ Chirotherium: number;
115+ catharticalness: number;
116+ disdiapason: string;
117+ homocerc: boolean;
118+ nonbookish: null;
119+}
120+
121+export type Clinodome = number | string;
122+
123+export type CoadjustElement = CoadjustClass | number;
124+
125+export interface CoadjustClass {
126+ Benny?: null;
127+ Chirotherium?: number;
128+ Netherlandish?: null;
129+ Phonelescope?: null;
130+ Sedaceae?: null;
131+ amidosulphonal?: null;
132+ catharticalness?: number;
133+ disdiapason?: string;
134+ ensnare?: null;
135+ homocerc?: boolean;
136+ hybridizer?: null;
137+ leastwise?: null;
138+ lof?: null;
139+ monkhood?: null;
140+ nonbookish?: null;
141+ peonism?: null;
142+ porphyrogeniture?: null;
143+ preindemnify?: null;
144+ rosal?: null;
145+ scalenous?: null;
146+ scopine?: null;
147+ suberinize?: null;
148+ symbiot?: null;
149+ tablefellow?: null;
150+ unchargeable?: null;
151+}
152+
153+export type Consilience = number | { [key: string]: number };
154+
155+export type Constructor = boolean | { [key: string]: number | null };
156+
157+export type Continuative = { [key: string]: number } | string;
158+
159+export type CredulityElement = CredulityClass | number | string;
160+
161+export interface CredulityClass {
162+ Flavia: null;
163+ Hedychium: null;
164+ Popean: null;
165+ ammonolytic: null;
166+ bushmaster: null;
167+ considering: null;
168+ consuetudinary: null;
169+ embarras: null;
170+ fineness: null;
171+ flaithship: null;
172+ gruffly: null;
173+ leadwort: null;
174+ overseriously: null;
175+ parabola: null;
176+ pectinatodenticulate: null;
177+ pornocrat: null;
178+ quadrisect: null;
179+ seriality: null;
180+ vamphorn: null;
181+ wharp: null;
182+}
183+
184+export type Creviced = boolean | { [key: string]: number } | string;
185+
186+export type DeruralizeElement = null[] | boolean | DeruralizeClass;
187+
188+export interface DeruralizeClass {
189+ Jehovistic: null;
190+ Paninean: null;
191+ Romney: null;
192+ bockerel: null;
193+ boulder: null;
194+ churrus: null;
195+ counterdigged: null;
196+ dialogite: null;
197+ digenic: null;
198+ dunbird: null;
199+ ergatogyne: null;
200+ fiendful: null;
201+ jackrod: null;
202+ panther: null;
203+ placentigerous: null;
204+ sparm: null;
205+ tocsin: null;
206+ unnicked: null;
207+ unstavable: null;
208+ windfirm: null;
209+}
210+
211+export type DiaereseElement = number[] | boolean | DiaereseClass;
212+
213+export interface DiaereseClass {
214+ Amoreuxia: null;
215+ ani: null;
216+ bernicle: null;
217+ blackwasher: null;
218+ blowhard: null;
219+ broma: null;
220+ closecross: null;
221+ congregationalism: null;
222+ grayly: null;
223+ historically: null;
224+ hoast: null;
225+ irretentive: null;
226+ parcener: null;
227+ pedder: null;
228+ pseudoanatomic: null;
229+ rhizocarpian: null;
230+ samel: null;
231+ silker: null;
232+ subdentated: null;
233+ subobscure: null;
234+}
235+
236+export type Downstroke = null[] | boolean | string;
237+
238+export type Eleutheromania = number | { [key: string]: number } | string;
239+
240+export interface Encrust {
241+ Hibernia: null;
242+ Hibiscus: null;
243+ Lepidosauria: null;
244+ Syllidae: null;
245+ comradely: null;
246+ diacanthous: null;
247+ feminineness: null;
248+ gossamered: null;
249+ lollingly: null;
250+ manager: null;
251+ mechanic: null;
252+ overminuteness: null;
253+ papelonne: null;
254+ plebification: null;
255+ pugmiller: null;
256+ recoveror: null;
257+ spermatoblastic: null;
258+ ungyved: null;
259+ whirlabout: null;
260+ woodenware: null;
261+}
262+
263+export type Entomoid = CimeliaClass | number;
264+
265+export type Epipaleolithic = number[] | number;
266+
267+export type Expropriable = null[] | CimeliaClass | number;
268+
269+export type FagginglyElement = FagginglyClass | number;
270+
271+export interface FagginglyClass {
272+ Anglic: null;
273+ Heteromeri: null;
274+ Poinsettia: null;
275+ abranchian: null;
276+ aculeiform: null;
277+ adiaphoristic: null;
278+ adoptionism: null;
279+ antrotomy: null;
280+ coerciveness: null;
281+ decorist: null;
282+ duckhood: null;
283+ hypochnose: null;
284+ lochage: null;
285+ melee: null;
286+ nonconformitant: null;
287+ putatively: null;
288+ semivolatile: null;
289+ soleas: null;
290+ unfastenable: null;
291+ unmillinered: null;
292+}
293+
294+export type FenkElement = FenkClass | string;
295+
296+export interface FenkClass {
297+ Dagomba: null;
298+ Guyandot: null;
299+ Reinwardtia: null;
300+ Tritoness: null;
301+ apoise: null;
302+ astronomize: null;
303+ cockhorse: null;
304+ copular: null;
305+ draffy: null;
306+ foreigner: null;
307+ neurogliosis: null;
308+ osmious: null;
309+ palpitate: null;
310+ rebukeable: null;
311+ reservatory: null;
312+ scalt: null;
313+ scripturalize: null;
314+ tintometer: null;
315+ undergrade: null;
316+ undermountain: null;
317+}
318+
319+export type FlagmakingElement = boolean | FlagmakingClass | number;
320+
321+export interface FlagmakingClass {
322+ Bunodonta: null;
323+ Hydrocorisae: null;
324+ Notacanthidae: null;
325+ albarco: null;
326+ hornify: null;
327+ hypoglossus: null;
328+ inexpiably: null;
329+ ingratitude: null;
330+ ladyfly: null;
331+ medicament: null;
332+ monogrammatic: null;
333+ nobbut: null;
334+ polyplacophore: null;
335+ proexercise: null;
336+ protoplast: null;
337+ puzzling: null;
338+ splanchnoskeleton: null;
339+ unloveliness: null;
340+ unquarantined: null;
341+ unrenounceable: null;
342+}
343+
344+export type Fluorometer = number | null | string;
345+
346+export type Fuzzy = number | { [key: string]: number | null };
347+
348+export type Gardenward = number[] | boolean | string;
349+
350+export type Generalissimo = boolean | { [key: string]: number } | null;
351+
352+export type Hemicrystalline = CimeliaClass | string;
353+
354+export type HemocoeleElement = number[] | HemocoeleClass;
355+
356+export interface HemocoeleClass {
357+ Chirotherium?: number;
358+ Walt?: null;
359+ acrogamy?: null;
360+ amelification?: null;
361+ autobiographic?: null;
362+ berat?: null;
363+ catharticalness?: number;
364+ disdiapason?: string;
365+ disproportionably?: null;
366+ erythrite?: null;
367+ graphic?: null;
368+ hepatological?: null;
369+ homocerc?: boolean;
370+ incommensurably?: null;
371+ misaffirm?: null;
372+ nonbookish?: null;
373+ pocketbook?: null;
374+ sclerometric?: null;
375+ stambouline?: null;
376+ stickpin?: null;
377+ tubulure?: null;
378+ undelated?: null;
379+ unsalt?: null;
380+ untutelar?: null;
381+ vagrant?: null;
382+}
383+
384+export type Hoister = CimeliaClass | null | string;
385+
386+export type Hyperpiesi = null[] | CimeliaClass | null;
387+
388+export type Hyppish = boolean | null | string;
389+
390+export type Idealizer = null[] | CimeliaClass | number;
391+
392+export type Incrustator = number[] | number | string;
393+
394+export type Intentiveness = CimeliaClass | number | string;
395+
396+export interface Interacinar {
397+ assapan: number;
398+ benefactorship: boolean;
399+ triseriatim: string;
400+ tubbing: number;
401+ untrimmed: null;
402+}
403+
404+export type Jacutinga = number[] | { [key: string]: number | null };
405+
406+// Converts JSON strings to/from your types
407+// and asserts the results of JSON.parse at runtime
408+export class Convert {
409+ public static toTopLevel(json: string): TopLevel {
410+ return cast(JSON.parse(json), r("TopLevel"));
411+ }
412+
413+ public static topLevelToJson(value: TopLevel): string {
414+ return JSON.stringify(uncast(value, r("TopLevel")), null, 2);
415+ }
416+}
417+
418+function invalidValue(typ: any, val: any, key: any, parent: any = ''): never {
419+ const prettyTyp = prettyTypeName(typ);
420+ const parentText = parent ? ` on ${parent}` : '';
421+ const keyText = key ? ` for key "${key}"` : '';
422+ throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`);
423+}
424+
425+function prettyTypeName(typ: any): string {
426+ if (Array.isArray(typ)) {
427+ if (typ.length === 2 && typ[0] === undefined) {
428+ return `an optional ${prettyTypeName(typ[1])}`;
429+ } else {
430+ return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`;
431+ }
432+ } else if (typeof typ === "object" && typ.literal !== undefined) {
433+ return typ.literal;
434+ } else {
435+ return typeof typ;
436+ }
437+}
438+
439+function jsonToJSProps(typ: any): any {
440+ if (typ.jsonToJS === undefined) {
441+ const map: any = {};
442+ typ.props.forEach((p: any) => map[p.json] = { key: p.js, typ: p.typ });
443+ typ.jsonToJS = map;
444+ }
445+ return typ.jsonToJS;
446+}
447+
448+function jsToJSONProps(typ: any): any {
449+ if (typ.jsToJSON === undefined) {
450+ const map: any = {};
451+ typ.props.forEach((p: any) => map[p.js] = { key: p.json, typ: p.typ });
452+ typ.jsToJSON = map;
453+ }
454+ return typ.jsToJSON;
455+}
456+
457+function transform(val: any, typ: any, getProps: any, key: any = '', parent: any = ''): any {
458+ function transformPrimitive(typ: string, val: any): any {
459+ if (typeof typ === typeof val) return val;
460+ return invalidValue(typ, val, key, parent);
461+ }
462+
463+ function transformUnion(typs: any[], val: any): any {
464+ // val must validate against one typ in typs
465+ const l = typs.length;
466+ for (let i = 0; i < l; i++) {
467+ const typ = typs[i];
468+ try {
469+ return transform(val, typ, getProps);
470+ } catch (_) {}
471+ }
472+ return invalidValue(typs, val, key, parent);
473+ }
474+
475+ function transformEnum(cases: string[], val: any): any {
476+ if (cases.indexOf(val) !== -1) return val;
477+ return invalidValue(cases.map(a => { return l(a); }), val, key, parent);
478+ }
479+
480+ function transformArray(typ: any, val: any): any {
481+ // val must be an array with no invalid elements
482+ if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent);
483+
484+ return val.map(el => transform(el, typ, getProps));
485+ }
486+
487+ function transformDate(val: any): any {
488+ if (val === null) {
489+ return null;
490+ }
491+ const d = new Date(val);
492+ if (isNaN(d.valueOf())) {
493+ return invalidValue(l("Date"), val, key, parent);
494+ }
495+ return d;
496+ }
497+
498+ function transformObject(props: { [k: string]: any }, additional: any, val: any): any {
499+ if (val === null || typeof val !== "object" || Array.isArray(val)) {
500+ return invalidValue(l(ref || "object"), val, key, parent);
501+ }
502+ const result: any = {};
503+ Object.getOwnPropertyNames(props).forEach(key => {
504+ const prop = props[key];
505+ const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined;
506+ result[prop.key] = transform(v, prop.typ, getProps, key, ref);
507+ });
508+ Object.getOwnPropertyNames(val).forEach(key => {
509+ if (!Object.prototype.hasOwnProperty.call(props, key)) {
510+ result[key] = transform(val[key], additional, getProps, key, ref);
511+ }
512+ });
513+ return result;
514+ }
515+
516+ if (typ === "any") return val;
517+ if (typ === null) {
518+ if (val === null) return val;
519+ return invalidValue(typ, val, key, parent);
520+ }
521+ if (typ === false) return invalidValue(typ, val, key, parent);
522+ let ref: any = undefined;
523+ while (typeof typ === "object" && typ.ref !== undefined) {
524+ ref = typ.ref;
525+ typ = typeMap[typ.ref];
526+ }
527+ if (Array.isArray(typ)) return transformEnum(typ, val);
528+ if (typeof typ === "object") {
529+ return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent)
530+ : 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)
531+ : 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)
532+ : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent)
533+ : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val)
534+ : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val)
535+ : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val)
536+ : invalidValue(typ, val, key, parent);
537+ }
538+ // Numbers can be parsed by Date but shouldn't be.
539+ if (typ === Date && typeof val !== "number") return transformDate(val);
540+ return transformPrimitive(typ, val);
541+}
542+
543+function cast<T>(val: any, typ: any): T {
544+ return transform(val, typ, jsonToJSProps);
545+}
546+
547+function uncast<T>(val: T, typ: any): any {
548+ return transform(val, typ, jsToJSONProps);
549+}
550+
551+function l(typ: any) {
552+ return { literal: typ };
553+}
554+
555+function a(typ: any) {
556+ return { arrayItems: typ };
557+}
558+
559+function i(typ: any) {
560+ return { integer: typ };
561+}
562+
563+function p(pattern: any) {
564+ return { pattern };
565+}
566+
567+function s(typ: any, min: any, max: any) {
568+ return { string: typ, min, max };
569+}
570+
571+function n(typ: any, min: any, max: any) {
572+ return { number: typ, min, max };
573+}
574+
575+function u(...typs: any[]) {
576+ return { unionMembers: typs };
577+}
578+
579+function o(props: any[], additional: any) {
580+ return { props, additional };
581+}
582+
583+function m(additional: any) {
584+ const props: any[] = [];
585+ return { props, additional };
586+}
587+
588+function r(name: string) {
589+ return { ref: name };
590+}
591+
592+const typeMap: any = {
593+ "TopLevel": o([
594+ { json: "centrodesmose", js: "centrodesmose", typ: "" },
595+ { json: "cerograph", js: "cerograph", typ: a(u(r("CerographClass"), null, "")) },
596+ { json: "chemotherapeutics", js: "chemotherapeutics", typ: a(u(r("ChemotherapeuticClass"), i(0))) },
597+ { json: "cimelia", js: "cimelia", typ: a(u(a(i(0)), r("CimeliaClass"), null)) },
598+ { json: "citrated", js: "citrated", typ: i(0) },
599+ { json: "clinodome", js: "clinodome", typ: a(u(3.14, "")) },
600+ { json: "coadjust", js: "coadjust", typ: a(u(r("CoadjustClass"), 3.14)) },
601+ { json: "consilience", js: "consilience", typ: a(u(3.14, m(i(0)))) },
602+ { json: "constructor", js: "constructor", typ: a(u(true, m(u(i(0), null)))) },
603+ { json: "continuative", js: "continuative", typ: a(u(m(i(0)), "")) },
604+ { json: "credulity", js: "credulity", typ: a(u(r("CredulityClass"), i(0), "")) },
605+ { json: "creviced", js: "creviced", typ: a(u(true, m(i(0)), "")) },
606+ { json: "cubiculum", js: "cubiculum", typ: a(a(u(i(0), null))) },
607+ { json: "deruralize", js: "deruralize", typ: a(u(a(null), true, r("DeruralizeClass"))) },
608+ { json: "diaereses", js: "diaereses", typ: a(u(a(i(0)), true, r("DiaereseClass"))) },
609+ { json: "dissolution", js: "dissolution", typ: a(u(a(null), null)) },
610+ { json: "downstroke", js: "downstroke", typ: a(u(a(null), true, "")) },
611+ { json: "electrotautomerism", js: "electrotautomerism", typ: a(u(3.14, null)) },
612+ { json: "eleutheromania", js: "eleutheromania", typ: a(u(3.14, m(i(0)), "")) },
613+ { json: "encrust", js: "encrust", typ: r("Encrust") },
614+ { json: "entomoid", js: "entomoid", typ: a(u(r("CimeliaClass"), i(0))) },
615+ { json: "epipaleolithic", js: "epipaleolithic", typ: a(u(a(i(0)), 3.14)) },
616+ { json: "expropriable", js: "expropriable", typ: a(u(a(null), r("CimeliaClass"), 3.14)) },
617+ { json: "faggingly", js: "faggingly", typ: a(u(r("FagginglyClass"), 3.14)) },
618+ { json: "fenks", js: "fenks", typ: a(u(r("FenkClass"), "")) },
619+ { json: "flagmaking", js: "flagmaking", typ: a(u(true, r("FlagmakingClass"), 3.14)) },
620+ { json: "fluorometer", js: "fluorometer", typ: a(u(i(0), null, "")) },
621+ { json: "fulsome", js: "fulsome", typ: a(u(i(0), null)) },
622+ { json: "fuzzy", js: "fuzzy", typ: a(u(i(0), m(u(i(0), null)))) },
623+ { json: "gardenwards", js: "gardenwards", typ: a(u(a(i(0)), true, "")) },
624+ { json: "generalissimo", js: "generalissimo", typ: a(u(true, m(i(0)), null)) },
625+ { json: "habeas", js: "habeas", typ: a(u(m(i(0)), null)) },
626+ { json: "hemicrystalline", js: "hemicrystalline", typ: a(u(r("CimeliaClass"), "")) },
627+ { json: "hemocoele", js: "hemocoele", typ: a(u(a(i(0)), r("HemocoeleClass"))) },
628+ { json: "hoister", js: "hoister", typ: a(u(r("CimeliaClass"), null, "")) },
629+ { json: "hyperpiesis", js: "hyperpiesis", typ: a(u(a(null), r("CimeliaClass"), null)) },
630+ { json: "hyppish", js: "hyppish", typ: a(u(true, null, "")) },
631+ { json: "idealizer", js: "idealizer", typ: a(u(a(null), r("CimeliaClass"), i(0))) },
632+ { json: "incrustator", js: "incrustator", typ: a(u(a(i(0)), i(0), "")) },
633+ { json: "intentiveness", js: "intentiveness", typ: a(u(r("CimeliaClass"), 3.14, "")) },
634+ { json: "interacinar", js: "interacinar", typ: r("Interacinar") },
635+ { json: "intercorrelation", js: "intercorrelation", typ: a(u(a(i(0)), null)) },
636+ { json: "jacutinga", js: "jacutinga", typ: a(u(a(i(0)), m(u(i(0), null)))) },
637+ ], false),
638+ "CerographClass": o([
639+ { json: "Tolowa", js: "Tolowa", typ: null },
640+ { json: "apotropaion", js: "apotropaion", typ: null },
641+ { json: "casuary", js: "casuary", typ: null },
642+ { json: "creaker", js: "creaker", typ: null },
643+ { json: "disqualification", js: "disqualification", typ: null },
644+ { json: "imperatorious", js: "imperatorious", typ: null },
645+ { json: "impermeabilize", js: "impermeabilize", typ: null },
646+ { json: "metastoma", js: "metastoma", typ: null },
647+ { json: "noctidiurnal", js: "noctidiurnal", typ: null },
648+ { json: "nonreserve", js: "nonreserve", typ: null },
649+ { json: "ophthalmotonometry", js: "ophthalmotonometry", typ: null },
650+ { json: "pailful", js: "pailful", typ: null },
651+ { json: "pigfish", js: "pigfish", typ: null },
652+ { json: "pongee", js: "pongee", typ: null },
653+ { json: "prosodical", js: "prosodical", typ: null },
654+ { json: "scrofuloderm", js: "scrofuloderm", typ: null },
655+ { json: "storekeeping", js: "storekeeping", typ: null },
656+ { json: "therologist", js: "therologist", typ: null },
657+ { json: "tradeful", js: "tradeful", typ: null },
658+ { json: "unriveting", js: "unriveting", typ: null },
659+ ], false),
660+ "ChemotherapeuticClass": o([
661+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
662+ { json: "Maureen", js: "Maureen", typ: u(undefined, null) },
663+ { json: "angioneurotic", js: "angioneurotic", typ: u(undefined, null) },
664+ { json: "availment", js: "availment", typ: u(undefined, null) },
665+ { json: "bladelet", js: "bladelet", typ: u(undefined, null) },
666+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
667+ { json: "caulis", js: "caulis", typ: u(undefined, null) },
668+ { json: "chalcus", js: "chalcus", typ: u(undefined, null) },
669+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
670+ { json: "enteradenological", js: "enteradenological", typ: u(undefined, null) },
671+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
672+ { json: "imporosity", js: "imporosity", typ: u(undefined, null) },
673+ { json: "insistently", js: "insistently", typ: u(undefined, null) },
674+ { json: "intraparietal", js: "intraparietal", typ: u(undefined, null) },
675+ { json: "ivied", js: "ivied", typ: u(undefined, null) },
676+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
677+ { json: "nostochine", js: "nostochine", typ: u(undefined, null) },
678+ { json: "nutcracker", js: "nutcracker", typ: u(undefined, null) },
679+ { json: "ofttimes", js: "ofttimes", typ: u(undefined, null) },
680+ { json: "phenocryst", js: "phenocryst", typ: u(undefined, null) },
681+ { json: "precoincident", js: "precoincident", typ: u(undefined, null) },
682+ { json: "ramiferous", js: "ramiferous", typ: u(undefined, null) },
683+ { json: "stagmometer", js: "stagmometer", typ: u(undefined, null) },
684+ { json: "tetherball", js: "tetherball", typ: u(undefined, null) },
685+ { json: "unshy", js: "unshy", typ: u(undefined, null) },
686+ ], false),
687+ "CimeliaClass": o([
688+ { json: "Chirotherium", js: "Chirotherium", typ: i(0) },
689+ { json: "catharticalness", js: "catharticalness", typ: 3.14 },
690+ { json: "disdiapason", js: "disdiapason", typ: "" },
691+ { json: "homocerc", js: "homocerc", typ: true },
692+ { json: "nonbookish", js: "nonbookish", typ: null },
693+ ], false),
694+ "CoadjustClass": o([
695+ { json: "Benny", js: "Benny", typ: u(undefined, null) },
696+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
697+ { json: "Netherlandish", js: "Netherlandish", typ: u(undefined, null) },
698+ { json: "Phonelescope", js: "Phonelescope", typ: u(undefined, null) },
699+ { json: "Sedaceae", js: "Sedaceae", typ: u(undefined, null) },
700+ { json: "amidosulphonal", js: "amidosulphonal", typ: u(undefined, null) },
701+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
702+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
703+ { json: "ensnare", js: "ensnare", typ: u(undefined, null) },
704+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
705+ { json: "hybridizer", js: "hybridizer", typ: u(undefined, null) },
706+ { json: "leastwise", js: "leastwise", typ: u(undefined, null) },
707+ { json: "lof", js: "lof", typ: u(undefined, null) },
708+ { json: "monkhood", js: "monkhood", typ: u(undefined, null) },
709+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
710+ { json: "peonism", js: "peonism", typ: u(undefined, null) },
711+ { json: "porphyrogeniture", js: "porphyrogeniture", typ: u(undefined, null) },
712+ { json: "preindemnify", js: "preindemnify", typ: u(undefined, null) },
713+ { json: "rosal", js: "rosal", typ: u(undefined, null) },
714+ { json: "scalenous", js: "scalenous", typ: u(undefined, null) },
715+ { json: "scopine", js: "scopine", typ: u(undefined, null) },
716+ { json: "suberinize", js: "suberinize", typ: u(undefined, null) },
717+ { json: "symbiot", js: "symbiot", typ: u(undefined, null) },
718+ { json: "tablefellow", js: "tablefellow", typ: u(undefined, null) },
719+ { json: "unchargeable", js: "unchargeable", typ: u(undefined, null) },
720+ ], false),
721+ "CredulityClass": o([
722+ { json: "Flavia", js: "Flavia", typ: null },
723+ { json: "Hedychium", js: "Hedychium", typ: null },
724+ { json: "Popean", js: "Popean", typ: null },
725+ { json: "ammonolytic", js: "ammonolytic", typ: null },
726+ { json: "bushmaster", js: "bushmaster", typ: null },
727+ { json: "considering", js: "considering", typ: null },
728+ { json: "consuetudinary", js: "consuetudinary", typ: null },
729+ { json: "embarras", js: "embarras", typ: null },
730+ { json: "fineness", js: "fineness", typ: null },
731+ { json: "flaithship", js: "flaithship", typ: null },
732+ { json: "gruffly", js: "gruffly", typ: null },
733+ { json: "leadwort", js: "leadwort", typ: null },
734+ { json: "overseriously", js: "overseriously", typ: null },
735+ { json: "parabola", js: "parabola", typ: null },
736+ { json: "pectinatodenticulate", js: "pectinatodenticulate", typ: null },
737+ { json: "pornocrat", js: "pornocrat", typ: null },
738+ { json: "quadrisect", js: "quadrisect", typ: null },
739+ { json: "seriality", js: "seriality", typ: null },
740+ { json: "vamphorn", js: "vamphorn", typ: null },
741+ { json: "wharp", js: "wharp", typ: null },
742+ ], false),
743+ "DeruralizeClass": o([
744+ { json: "Jehovistic", js: "Jehovistic", typ: null },
745+ { json: "Paninean", js: "Paninean", typ: null },
746+ { json: "Romney", js: "Romney", typ: null },
747+ { json: "bockerel", js: "bockerel", typ: null },
748+ { json: "boulder", js: "boulder", typ: null },
749+ { json: "churrus", js: "churrus", typ: null },
750+ { json: "counterdigged", js: "counterdigged", typ: null },
751+ { json: "dialogite", js: "dialogite", typ: null },
752+ { json: "digenic", js: "digenic", typ: null },
753+ { json: "dunbird", js: "dunbird", typ: null },
754+ { json: "ergatogyne", js: "ergatogyne", typ: null },
755+ { json: "fiendful", js: "fiendful", typ: null },
756+ { json: "jackrod", js: "jackrod", typ: null },
757+ { json: "panther", js: "panther", typ: null },
758+ { json: "placentigerous", js: "placentigerous", typ: null },
759+ { json: "sparm", js: "sparm", typ: null },
760+ { json: "tocsin", js: "tocsin", typ: null },
761+ { json: "unnicked", js: "unnicked", typ: null },
762+ { json: "unstavable", js: "unstavable", typ: null },
763+ { json: "windfirm", js: "windfirm", typ: null },
764+ ], false),
765+ "DiaereseClass": o([
766+ { json: "Amoreuxia", js: "Amoreuxia", typ: null },
767+ { json: "ani", js: "ani", typ: null },
768+ { json: "bernicle", js: "bernicle", typ: null },
769+ { json: "blackwasher", js: "blackwasher", typ: null },
770+ { json: "blowhard", js: "blowhard", typ: null },
771+ { json: "broma", js: "broma", typ: null },
772+ { json: "closecross", js: "closecross", typ: null },
773+ { json: "congregationalism", js: "congregationalism", typ: null },
774+ { json: "grayly", js: "grayly", typ: null },
775+ { json: "historically", js: "historically", typ: null },
776+ { json: "hoast", js: "hoast", typ: null },
777+ { json: "irretentive", js: "irretentive", typ: null },
778+ { json: "parcener", js: "parcener", typ: null },
779+ { json: "pedder", js: "pedder", typ: null },
780+ { json: "pseudoanatomic", js: "pseudoanatomic", typ: null },
781+ { json: "rhizocarpian", js: "rhizocarpian", typ: null },
782+ { json: "samel", js: "samel", typ: null },
783+ { json: "silker", js: "silker", typ: null },
784+ { json: "subdentated", js: "subdentated", typ: null },
785+ { json: "subobscure", js: "subobscure", typ: null },
786+ ], false),
787+ "Encrust": o([
788+ { json: "Hibernia", js: "Hibernia", typ: null },
789+ { json: "Hibiscus", js: "Hibiscus", typ: null },
790+ { json: "Lepidosauria", js: "Lepidosauria", typ: null },
791+ { json: "Syllidae", js: "Syllidae", typ: null },
792+ { json: "comradely", js: "comradely", typ: null },
793+ { json: "diacanthous", js: "diacanthous", typ: null },
794+ { json: "feminineness", js: "feminineness", typ: null },
795+ { json: "gossamered", js: "gossamered", typ: null },
796+ { json: "lollingly", js: "lollingly", typ: null },
797+ { json: "manager", js: "manager", typ: null },
798+ { json: "mechanic", js: "mechanic", typ: null },
799+ { json: "overminuteness", js: "overminuteness", typ: null },
800+ { json: "papelonne", js: "papelonne", typ: null },
801+ { json: "plebification", js: "plebification", typ: null },
802+ { json: "pugmiller", js: "pugmiller", typ: null },
803+ { json: "recoveror", js: "recoveror", typ: null },
804+ { json: "spermatoblastic", js: "spermatoblastic", typ: null },
805+ { json: "ungyved", js: "ungyved", typ: null },
806+ { json: "whirlabout", js: "whirlabout", typ: null },
807+ { json: "woodenware", js: "woodenware", typ: null },
808+ ], false),
809+ "FagginglyClass": o([
810+ { json: "Anglic", js: "Anglic", typ: null },
811+ { json: "Heteromeri", js: "Heteromeri", typ: null },
812+ { json: "Poinsettia", js: "Poinsettia", typ: null },
813+ { json: "abranchian", js: "abranchian", typ: null },
814+ { json: "aculeiform", js: "aculeiform", typ: null },
815+ { json: "adiaphoristic", js: "adiaphoristic", typ: null },
816+ { json: "adoptionism", js: "adoptionism", typ: null },
817+ { json: "antrotomy", js: "antrotomy", typ: null },
818+ { json: "coerciveness", js: "coerciveness", typ: null },
819+ { json: "decorist", js: "decorist", typ: null },
820+ { json: "duckhood", js: "duckhood", typ: null },
821+ { json: "hypochnose", js: "hypochnose", typ: null },
822+ { json: "lochage", js: "lochage", typ: null },
823+ { json: "melee", js: "melee", typ: null },
824+ { json: "nonconformitant", js: "nonconformitant", typ: null },
825+ { json: "putatively", js: "putatively", typ: null },
826+ { json: "semivolatile", js: "semivolatile", typ: null },
827+ { json: "soleas", js: "soleas", typ: null },
828+ { json: "unfastenable", js: "unfastenable", typ: null },
829+ { json: "unmillinered", js: "unmillinered", typ: null },
830+ ], false),
831+ "FenkClass": o([
832+ { json: "Dagomba", js: "Dagomba", typ: null },
833+ { json: "Guyandot", js: "Guyandot", typ: null },
834+ { json: "Reinwardtia", js: "Reinwardtia", typ: null },
835+ { json: "Tritoness", js: "Tritoness", typ: null },
836+ { json: "apoise", js: "apoise", typ: null },
837+ { json: "astronomize", js: "astronomize", typ: null },
838+ { json: "cockhorse", js: "cockhorse", typ: null },
839+ { json: "copular", js: "copular", typ: null },
840+ { json: "draffy", js: "draffy", typ: null },
841+ { json: "foreigner", js: "foreigner", typ: null },
842+ { json: "neurogliosis", js: "neurogliosis", typ: null },
843+ { json: "osmious", js: "osmious", typ: null },
844+ { json: "palpitate", js: "palpitate", typ: null },
845+ { json: "rebukeable", js: "rebukeable", typ: null },
846+ { json: "reservatory", js: "reservatory", typ: null },
847+ { json: "scalt", js: "scalt", typ: null },
848+ { json: "scripturalize", js: "scripturalize", typ: null },
849+ { json: "tintometer", js: "tintometer", typ: null },
850+ { json: "undergrade", js: "undergrade", typ: null },
851+ { json: "undermountain", js: "undermountain", typ: null },
852+ ], false),
853+ "FlagmakingClass": o([
854+ { json: "Bunodonta", js: "Bunodonta", typ: null },
855+ { json: "Hydrocorisae", js: "Hydrocorisae", typ: null },
856+ { json: "Notacanthidae", js: "Notacanthidae", typ: null },
857+ { json: "albarco", js: "albarco", typ: null },
858+ { json: "hornify", js: "hornify", typ: null },
859+ { json: "hypoglossus", js: "hypoglossus", typ: null },
860+ { json: "inexpiably", js: "inexpiably", typ: null },
861+ { json: "ingratitude", js: "ingratitude", typ: null },
862+ { json: "ladyfly", js: "ladyfly", typ: null },
863+ { json: "medicament", js: "medicament", typ: null },
864+ { json: "monogrammatic", js: "monogrammatic", typ: null },
865+ { json: "nobbut", js: "nobbut", typ: null },
866+ { json: "polyplacophore", js: "polyplacophore", typ: null },
867+ { json: "proexercise", js: "proexercise", typ: null },
868+ { json: "protoplast", js: "protoplast", typ: null },
869+ { json: "puzzling", js: "puzzling", typ: null },
870+ { json: "splanchnoskeleton", js: "splanchnoskeleton", typ: null },
871+ { json: "unloveliness", js: "unloveliness", typ: null },
872+ { json: "unquarantined", js: "unquarantined", typ: null },
873+ { json: "unrenounceable", js: "unrenounceable", typ: null },
874+ ], false),
875+ "HemocoeleClass": o([
876+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
877+ { json: "Walt", js: "Walt", typ: u(undefined, null) },
878+ { json: "acrogamy", js: "acrogamy", typ: u(undefined, null) },
879+ { json: "amelification", js: "amelification", typ: u(undefined, null) },
880+ { json: "autobiographic", js: "autobiographic", typ: u(undefined, null) },
881+ { json: "berat", js: "berat", typ: u(undefined, null) },
882+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
883+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
884+ { json: "disproportionably", js: "disproportionably", typ: u(undefined, null) },
885+ { json: "erythrite", js: "erythrite", typ: u(undefined, null) },
886+ { json: "graphic", js: "graphic", typ: u(undefined, null) },
887+ { json: "hepatological", js: "hepatological", typ: u(undefined, null) },
888+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
889+ { json: "incommensurably", js: "incommensurably", typ: u(undefined, null) },
890+ { json: "misaffirm", js: "misaffirm", typ: u(undefined, null) },
891+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
892+ { json: "pocketbook", js: "pocketbook", typ: u(undefined, null) },
893+ { json: "sclerometric", js: "sclerometric", typ: u(undefined, null) },
894+ { json: "stambouline", js: "stambouline", typ: u(undefined, null) },
895+ { json: "stickpin", js: "stickpin", typ: u(undefined, null) },
896+ { json: "tubulure", js: "tubulure", typ: u(undefined, null) },
897+ { json: "undelated", js: "undelated", typ: u(undefined, null) },
898+ { json: "unsalt", js: "unsalt", typ: u(undefined, null) },
899+ { json: "untutelar", js: "untutelar", typ: u(undefined, null) },
900+ { json: "vagrant", js: "vagrant", typ: u(undefined, null) },
901+ ], false),
902+ "Interacinar": o([
903+ { json: "assapan", js: "assapan", typ: 3.14 },
904+ { json: "benefactorship", js: "benefactorship", typ: true },
905+ { json: "triseriatim", js: "triseriatim", typ: "" },
906+ { json: "tubbing", js: "tubbing", typ: i(0) },
907+ { json: "untrimmed", js: "untrimmed", typ: null },
908+ ], false),
909+};
Atypescriptprefer-types-true--df33e18681f9 / TopLevel.ts+909 −0
@@ -0,0 +1,909 @@
1+// To parse this data:
2+//
3+// import { Convert, TopLevel } from "./TopLevel";
4+//
5+// const topLevel = Convert.toTopLevel(json);
6+//
7+// These functions will throw an error if the JSON doesn't
8+// match the expected interface, even if the JSON is valid.
9+
10+export type TopLevel = {
11+ centrodesmose: string;
12+ cerograph: CerographElement[];
13+ chemotherapeutics: ChemotherapeuticElement[];
14+ cimelia: CimeliaElement[];
15+ citrated: number;
16+ clinodome: Clinodome[];
17+ coadjust: CoadjustElement[];
18+ consilience: Consilience[];
19+ constructor: Constructor[];
20+ continuative: Continuative[];
21+ credulity: CredulityElement[];
22+ creviced: Creviced[];
23+ cubiculum: Array<(number | null)[]>;
24+ deruralize: DeruralizeElement[];
25+ diaereses: DiaereseElement[];
26+ dissolution: (null[] | null)[];
27+ downstroke: Downstroke[];
28+ electrotautomerism: (number | null)[];
29+ eleutheromania: Eleutheromania[];
30+ encrust: Encrust;
31+ entomoid: Entomoid[];
32+ epipaleolithic: Epipaleolithic[];
33+ expropriable: Expropriable[];
34+ faggingly: FagginglyElement[];
35+ fenks: FenkElement[];
36+ flagmaking: FlagmakingElement[];
37+ fluorometer: Fluorometer[];
38+ fulsome: (number | null)[];
39+ fuzzy: Fuzzy[];
40+ gardenwards: Gardenward[];
41+ generalissimo: Generalissimo[];
42+ habeas: ({ [key: string]: number } | null)[];
43+ hemicrystalline: Hemicrystalline[];
44+ hemocoele: HemocoeleElement[];
45+ hoister: Hoister[];
46+ hyperpiesis: Hyperpiesi[];
47+ hyppish: Hyppish[];
48+ idealizer: Idealizer[];
49+ incrustator: Incrustator[];
50+ intentiveness: Intentiveness[];
51+ interacinar: Interacinar;
52+ intercorrelation: (number[] | null)[];
53+ jacutinga: Jacutinga[];
54+}
55+
56+export type CerographElement = CerographClass | null | string;
57+
58+export type CerographClass = {
59+ Tolowa: null;
60+ apotropaion: null;
61+ casuary: null;
62+ creaker: null;
63+ disqualification: null;
64+ imperatorious: null;
65+ impermeabilize: null;
66+ metastoma: null;
67+ noctidiurnal: null;
68+ nonreserve: null;
69+ ophthalmotonometry: null;
70+ pailful: null;
71+ pigfish: null;
72+ pongee: null;
73+ prosodical: null;
74+ scrofuloderm: null;
75+ storekeeping: null;
76+ therologist: null;
77+ tradeful: null;
78+ unriveting: null;
79+}
80+
81+export type ChemotherapeuticElement = ChemotherapeuticClass | number;
82+
83+export type ChemotherapeuticClass = {
84+ Chirotherium?: number;
85+ Maureen?: null;
86+ angioneurotic?: null;
87+ availment?: null;
88+ bladelet?: null;
89+ catharticalness?: number;
90+ caulis?: null;
91+ chalcus?: null;
92+ disdiapason?: string;
93+ enteradenological?: null;
94+ homocerc?: boolean;
95+ imporosity?: null;
96+ insistently?: null;
97+ intraparietal?: null;
98+ ivied?: null;
99+ nonbookish?: null;
100+ nostochine?: null;
101+ nutcracker?: null;
102+ ofttimes?: null;
103+ phenocryst?: null;
104+ precoincident?: null;
105+ ramiferous?: null;
106+ stagmometer?: null;
107+ tetherball?: null;
108+ unshy?: null;
109+}
110+
111+export type CimeliaElement = number[] | CimeliaClass | null;
112+
113+export type CimeliaClass = {
114+ Chirotherium: number;
115+ catharticalness: number;
116+ disdiapason: string;
117+ homocerc: boolean;
118+ nonbookish: null;
119+}
120+
121+export type Clinodome = number | string;
122+
123+export type CoadjustElement = CoadjustClass | number;
124+
125+export type CoadjustClass = {
126+ Benny?: null;
127+ Chirotherium?: number;
128+ Netherlandish?: null;
129+ Phonelescope?: null;
130+ Sedaceae?: null;
131+ amidosulphonal?: null;
132+ catharticalness?: number;
133+ disdiapason?: string;
134+ ensnare?: null;
135+ homocerc?: boolean;
136+ hybridizer?: null;
137+ leastwise?: null;
138+ lof?: null;
139+ monkhood?: null;
140+ nonbookish?: null;
141+ peonism?: null;
142+ porphyrogeniture?: null;
143+ preindemnify?: null;
144+ rosal?: null;
145+ scalenous?: null;
146+ scopine?: null;
147+ suberinize?: null;
148+ symbiot?: null;
149+ tablefellow?: null;
150+ unchargeable?: null;
151+}
152+
153+export type Consilience = number | { [key: string]: number };
154+
155+export type Constructor = boolean | { [key: string]: number | null };
156+
157+export type Continuative = { [key: string]: number } | string;
158+
159+export type CredulityElement = CredulityClass | number | string;
160+
161+export type CredulityClass = {
162+ Flavia: null;
163+ Hedychium: null;
164+ Popean: null;
165+ ammonolytic: null;
166+ bushmaster: null;
167+ considering: null;
168+ consuetudinary: null;
169+ embarras: null;
170+ fineness: null;
171+ flaithship: null;
172+ gruffly: null;
173+ leadwort: null;
174+ overseriously: null;
175+ parabola: null;
176+ pectinatodenticulate: null;
177+ pornocrat: null;
178+ quadrisect: null;
179+ seriality: null;
180+ vamphorn: null;
181+ wharp: null;
182+}
183+
184+export type Creviced = boolean | { [key: string]: number } | string;
185+
186+export type DeruralizeElement = null[] | boolean | DeruralizeClass;
187+
188+export type DeruralizeClass = {
189+ Jehovistic: null;
190+ Paninean: null;
191+ Romney: null;
192+ bockerel: null;
193+ boulder: null;
194+ churrus: null;
195+ counterdigged: null;
196+ dialogite: null;
197+ digenic: null;
198+ dunbird: null;
199+ ergatogyne: null;
200+ fiendful: null;
201+ jackrod: null;
202+ panther: null;
203+ placentigerous: null;
204+ sparm: null;
205+ tocsin: null;
206+ unnicked: null;
207+ unstavable: null;
208+ windfirm: null;
209+}
210+
211+export type DiaereseElement = number[] | boolean | DiaereseClass;
212+
213+export type DiaereseClass = {
214+ Amoreuxia: null;
215+ ani: null;
216+ bernicle: null;
217+ blackwasher: null;
218+ blowhard: null;
219+ broma: null;
220+ closecross: null;
221+ congregationalism: null;
222+ grayly: null;
223+ historically: null;
224+ hoast: null;
225+ irretentive: null;
226+ parcener: null;
227+ pedder: null;
228+ pseudoanatomic: null;
229+ rhizocarpian: null;
230+ samel: null;
231+ silker: null;
232+ subdentated: null;
233+ subobscure: null;
234+}
235+
236+export type Downstroke = null[] | boolean | string;
237+
238+export type Eleutheromania = number | { [key: string]: number } | string;
239+
240+export type Encrust = {
241+ Hibernia: null;
242+ Hibiscus: null;
243+ Lepidosauria: null;
244+ Syllidae: null;
245+ comradely: null;
246+ diacanthous: null;
247+ feminineness: null;
248+ gossamered: null;
249+ lollingly: null;
250+ manager: null;
251+ mechanic: null;
252+ overminuteness: null;
253+ papelonne: null;
254+ plebification: null;
255+ pugmiller: null;
256+ recoveror: null;
257+ spermatoblastic: null;
258+ ungyved: null;
259+ whirlabout: null;
260+ woodenware: null;
261+}
262+
263+export type Entomoid = CimeliaClass | number;
264+
265+export type Epipaleolithic = number[] | number;
266+
267+export type Expropriable = null[] | CimeliaClass | number;
268+
269+export type FagginglyElement = FagginglyClass | number;
270+
271+export type FagginglyClass = {
272+ Anglic: null;
273+ Heteromeri: null;
274+ Poinsettia: null;
275+ abranchian: null;
276+ aculeiform: null;
277+ adiaphoristic: null;
278+ adoptionism: null;
279+ antrotomy: null;
280+ coerciveness: null;
281+ decorist: null;
282+ duckhood: null;
283+ hypochnose: null;
284+ lochage: null;
285+ melee: null;
286+ nonconformitant: null;
287+ putatively: null;
288+ semivolatile: null;
289+ soleas: null;
290+ unfastenable: null;
291+ unmillinered: null;
292+}
293+
294+export type FenkElement = FenkClass | string;
295+
296+export type FenkClass = {
297+ Dagomba: null;
298+ Guyandot: null;
299+ Reinwardtia: null;
300+ Tritoness: null;
301+ apoise: null;
302+ astronomize: null;
303+ cockhorse: null;
304+ copular: null;
305+ draffy: null;
306+ foreigner: null;
307+ neurogliosis: null;
308+ osmious: null;
309+ palpitate: null;
310+ rebukeable: null;
311+ reservatory: null;
312+ scalt: null;
313+ scripturalize: null;
314+ tintometer: null;
315+ undergrade: null;
316+ undermountain: null;
317+}
318+
319+export type FlagmakingElement = boolean | FlagmakingClass | number;
320+
321+export type FlagmakingClass = {
322+ Bunodonta: null;
323+ Hydrocorisae: null;
324+ Notacanthidae: null;
325+ albarco: null;
326+ hornify: null;
327+ hypoglossus: null;
328+ inexpiably: null;
329+ ingratitude: null;
330+ ladyfly: null;
331+ medicament: null;
332+ monogrammatic: null;
333+ nobbut: null;
334+ polyplacophore: null;
335+ proexercise: null;
336+ protoplast: null;
337+ puzzling: null;
338+ splanchnoskeleton: null;
339+ unloveliness: null;
340+ unquarantined: null;
341+ unrenounceable: null;
342+}
343+
344+export type Fluorometer = number | null | string;
345+
346+export type Fuzzy = number | { [key: string]: number | null };
347+
348+export type Gardenward = number[] | boolean | string;
349+
350+export type Generalissimo = boolean | { [key: string]: number } | null;
351+
352+export type Hemicrystalline = CimeliaClass | string;
353+
354+export type HemocoeleElement = number[] | HemocoeleClass;
355+
356+export type HemocoeleClass = {
357+ Chirotherium?: number;
358+ Walt?: null;
359+ acrogamy?: null;
360+ amelification?: null;
361+ autobiographic?: null;
362+ berat?: null;
363+ catharticalness?: number;
364+ disdiapason?: string;
365+ disproportionably?: null;
366+ erythrite?: null;
367+ graphic?: null;
368+ hepatological?: null;
369+ homocerc?: boolean;
370+ incommensurably?: null;
371+ misaffirm?: null;
372+ nonbookish?: null;
373+ pocketbook?: null;
374+ sclerometric?: null;
375+ stambouline?: null;
376+ stickpin?: null;
377+ tubulure?: null;
378+ undelated?: null;
379+ unsalt?: null;
380+ untutelar?: null;
381+ vagrant?: null;
382+}
383+
384+export type Hoister = CimeliaClass | null | string;
385+
386+export type Hyperpiesi = null[] | CimeliaClass | null;
387+
388+export type Hyppish = boolean | null | string;
389+
390+export type Idealizer = null[] | CimeliaClass | number;
391+
392+export type Incrustator = number[] | number | string;
393+
394+export type Intentiveness = CimeliaClass | number | string;
395+
396+export type Interacinar = {
397+ assapan: number;
398+ benefactorship: boolean;
399+ triseriatim: string;
400+ tubbing: number;
401+ untrimmed: null;
402+}
403+
404+export type Jacutinga = number[] | { [key: string]: number | null };
405+
406+// Converts JSON strings to/from your types
407+// and asserts the results of JSON.parse at runtime
408+export class Convert {
409+ public static toTopLevel(json: string): TopLevel {
410+ return cast(JSON.parse(json), r("TopLevel"));
411+ }
412+
413+ public static topLevelToJson(value: TopLevel): string {
414+ return JSON.stringify(uncast(value, r("TopLevel")), null, 2);
415+ }
416+}
417+
418+function invalidValue(typ: any, val: any, key: any, parent: any = ''): never {
419+ const prettyTyp = prettyTypeName(typ);
420+ const parentText = parent ? ` on ${parent}` : '';
421+ const keyText = key ? ` for key "${key}"` : '';
422+ throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`);
423+}
424+
425+function prettyTypeName(typ: any): string {
426+ if (Array.isArray(typ)) {
427+ if (typ.length === 2 && typ[0] === undefined) {
428+ return `an optional ${prettyTypeName(typ[1])}`;
429+ } else {
430+ return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`;
431+ }
432+ } else if (typeof typ === "object" && typ.literal !== undefined) {
433+ return typ.literal;
434+ } else {
435+ return typeof typ;
436+ }
437+}
438+
439+function jsonToJSProps(typ: any): any {
440+ if (typ.jsonToJS === undefined) {
441+ const map: any = {};
442+ typ.props.forEach((p: any) => map[p.json] = { key: p.js, typ: p.typ });
443+ typ.jsonToJS = map;
444+ }
445+ return typ.jsonToJS;
446+}
447+
448+function jsToJSONProps(typ: any): any {
449+ if (typ.jsToJSON === undefined) {
450+ const map: any = {};
451+ typ.props.forEach((p: any) => map[p.js] = { key: p.json, typ: p.typ });
452+ typ.jsToJSON = map;
453+ }
454+ return typ.jsToJSON;
455+}
456+
457+function transform(val: any, typ: any, getProps: any, key: any = '', parent: any = ''): any {
458+ function transformPrimitive(typ: string, val: any): any {
459+ if (typeof typ === typeof val) return val;
460+ return invalidValue(typ, val, key, parent);
461+ }
462+
463+ function transformUnion(typs: any[], val: any): any {
464+ // val must validate against one typ in typs
465+ const l = typs.length;
466+ for (let i = 0; i < l; i++) {
467+ const typ = typs[i];
468+ try {
469+ return transform(val, typ, getProps);
470+ } catch (_) {}
471+ }
472+ return invalidValue(typs, val, key, parent);
473+ }
474+
475+ function transformEnum(cases: string[], val: any): any {
476+ if (cases.indexOf(val) !== -1) return val;
477+ return invalidValue(cases.map(a => { return l(a); }), val, key, parent);
478+ }
479+
480+ function transformArray(typ: any, val: any): any {
481+ // val must be an array with no invalid elements
482+ if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent);
483+
484+ return val.map(el => transform(el, typ, getProps));
485+ }
486+
487+ function transformDate(val: any): any {
488+ if (val === null) {
489+ return null;
490+ }
491+ const d = new Date(val);
492+ if (isNaN(d.valueOf())) {
493+ return invalidValue(l("Date"), val, key, parent);
494+ }
495+ return d;
496+ }
497+
498+ function transformObject(props: { [k: string]: any }, additional: any, val: any): any {
499+ if (val === null || typeof val !== "object" || Array.isArray(val)) {
500+ return invalidValue(l(ref || "object"), val, key, parent);
501+ }
502+ const result: any = {};
503+ Object.getOwnPropertyNames(props).forEach(key => {
504+ const prop = props[key];
505+ const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined;
506+ result[prop.key] = transform(v, prop.typ, getProps, key, ref);
507+ });
508+ Object.getOwnPropertyNames(val).forEach(key => {
509+ if (!Object.prototype.hasOwnProperty.call(props, key)) {
510+ result[key] = transform(val[key], additional, getProps, key, ref);
511+ }
512+ });
513+ return result;
514+ }
515+
516+ if (typ === "any") return val;
517+ if (typ === null) {
518+ if (val === null) return val;
519+ return invalidValue(typ, val, key, parent);
520+ }
521+ if (typ === false) return invalidValue(typ, val, key, parent);
522+ let ref: any = undefined;
523+ while (typeof typ === "object" && typ.ref !== undefined) {
524+ ref = typ.ref;
525+ typ = typeMap[typ.ref];
526+ }
527+ if (Array.isArray(typ)) return transformEnum(typ, val);
528+ if (typeof typ === "object") {
529+ return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent)
530+ : 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)
531+ : 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)
532+ : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent)
533+ : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val)
534+ : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val)
535+ : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val)
536+ : invalidValue(typ, val, key, parent);
537+ }
538+ // Numbers can be parsed by Date but shouldn't be.
539+ if (typ === Date && typeof val !== "number") return transformDate(val);
540+ return transformPrimitive(typ, val);
541+}
542+
543+function cast<T>(val: any, typ: any): T {
544+ return transform(val, typ, jsonToJSProps);
545+}
546+
547+function uncast<T>(val: T, typ: any): any {
548+ return transform(val, typ, jsToJSONProps);
549+}
550+
551+function l(typ: any) {
552+ return { literal: typ };
553+}
554+
555+function a(typ: any) {
556+ return { arrayItems: typ };
557+}
558+
559+function i(typ: any) {
560+ return { integer: typ };
561+}
562+
563+function p(pattern: any) {
564+ return { pattern };
565+}
566+
567+function s(typ: any, min: any, max: any) {
568+ return { string: typ, min, max };
569+}
570+
571+function n(typ: any, min: any, max: any) {
572+ return { number: typ, min, max };
573+}
574+
575+function u(...typs: any[]) {
576+ return { unionMembers: typs };
577+}
578+
579+function o(props: any[], additional: any) {
580+ return { props, additional };
581+}
582+
583+function m(additional: any) {
584+ const props: any[] = [];
585+ return { props, additional };
586+}
587+
588+function r(name: string) {
589+ return { ref: name };
590+}
591+
592+const typeMap: any = {
593+ "TopLevel": o([
594+ { json: "centrodesmose", js: "centrodesmose", typ: "" },
595+ { json: "cerograph", js: "cerograph", typ: a(u(r("CerographClass"), null, "")) },
596+ { json: "chemotherapeutics", js: "chemotherapeutics", typ: a(u(r("ChemotherapeuticClass"), i(0))) },
597+ { json: "cimelia", js: "cimelia", typ: a(u(a(i(0)), r("CimeliaClass"), null)) },
598+ { json: "citrated", js: "citrated", typ: i(0) },
599+ { json: "clinodome", js: "clinodome", typ: a(u(3.14, "")) },
600+ { json: "coadjust", js: "coadjust", typ: a(u(r("CoadjustClass"), 3.14)) },
601+ { json: "consilience", js: "consilience", typ: a(u(3.14, m(i(0)))) },
602+ { json: "constructor", js: "constructor", typ: a(u(true, m(u(i(0), null)))) },
603+ { json: "continuative", js: "continuative", typ: a(u(m(i(0)), "")) },
604+ { json: "credulity", js: "credulity", typ: a(u(r("CredulityClass"), i(0), "")) },
605+ { json: "creviced", js: "creviced", typ: a(u(true, m(i(0)), "")) },
606+ { json: "cubiculum", js: "cubiculum", typ: a(a(u(i(0), null))) },
607+ { json: "deruralize", js: "deruralize", typ: a(u(a(null), true, r("DeruralizeClass"))) },
608+ { json: "diaereses", js: "diaereses", typ: a(u(a(i(0)), true, r("DiaereseClass"))) },
609+ { json: "dissolution", js: "dissolution", typ: a(u(a(null), null)) },
610+ { json: "downstroke", js: "downstroke", typ: a(u(a(null), true, "")) },
611+ { json: "electrotautomerism", js: "electrotautomerism", typ: a(u(3.14, null)) },
612+ { json: "eleutheromania", js: "eleutheromania", typ: a(u(3.14, m(i(0)), "")) },
613+ { json: "encrust", js: "encrust", typ: r("Encrust") },
614+ { json: "entomoid", js: "entomoid", typ: a(u(r("CimeliaClass"), i(0))) },
615+ { json: "epipaleolithic", js: "epipaleolithic", typ: a(u(a(i(0)), 3.14)) },
616+ { json: "expropriable", js: "expropriable", typ: a(u(a(null), r("CimeliaClass"), 3.14)) },
617+ { json: "faggingly", js: "faggingly", typ: a(u(r("FagginglyClass"), 3.14)) },
618+ { json: "fenks", js: "fenks", typ: a(u(r("FenkClass"), "")) },
619+ { json: "flagmaking", js: "flagmaking", typ: a(u(true, r("FlagmakingClass"), 3.14)) },
620+ { json: "fluorometer", js: "fluorometer", typ: a(u(i(0), null, "")) },
621+ { json: "fulsome", js: "fulsome", typ: a(u(i(0), null)) },
622+ { json: "fuzzy", js: "fuzzy", typ: a(u(i(0), m(u(i(0), null)))) },
623+ { json: "gardenwards", js: "gardenwards", typ: a(u(a(i(0)), true, "")) },
624+ { json: "generalissimo", js: "generalissimo", typ: a(u(true, m(i(0)), null)) },
625+ { json: "habeas", js: "habeas", typ: a(u(m(i(0)), null)) },
626+ { json: "hemicrystalline", js: "hemicrystalline", typ: a(u(r("CimeliaClass"), "")) },
627+ { json: "hemocoele", js: "hemocoele", typ: a(u(a(i(0)), r("HemocoeleClass"))) },
628+ { json: "hoister", js: "hoister", typ: a(u(r("CimeliaClass"), null, "")) },
629+ { json: "hyperpiesis", js: "hyperpiesis", typ: a(u(a(null), r("CimeliaClass"), null)) },
630+ { json: "hyppish", js: "hyppish", typ: a(u(true, null, "")) },
631+ { json: "idealizer", js: "idealizer", typ: a(u(a(null), r("CimeliaClass"), i(0))) },
632+ { json: "incrustator", js: "incrustator", typ: a(u(a(i(0)), i(0), "")) },
633+ { json: "intentiveness", js: "intentiveness", typ: a(u(r("CimeliaClass"), 3.14, "")) },
634+ { json: "interacinar", js: "interacinar", typ: r("Interacinar") },
635+ { json: "intercorrelation", js: "intercorrelation", typ: a(u(a(i(0)), null)) },
636+ { json: "jacutinga", js: "jacutinga", typ: a(u(a(i(0)), m(u(i(0), null)))) },
637+ ], false),
638+ "CerographClass": o([
639+ { json: "Tolowa", js: "Tolowa", typ: null },
640+ { json: "apotropaion", js: "apotropaion", typ: null },
641+ { json: "casuary", js: "casuary", typ: null },
642+ { json: "creaker", js: "creaker", typ: null },
643+ { json: "disqualification", js: "disqualification", typ: null },
644+ { json: "imperatorious", js: "imperatorious", typ: null },
645+ { json: "impermeabilize", js: "impermeabilize", typ: null },
646+ { json: "metastoma", js: "metastoma", typ: null },
647+ { json: "noctidiurnal", js: "noctidiurnal", typ: null },
648+ { json: "nonreserve", js: "nonreserve", typ: null },
649+ { json: "ophthalmotonometry", js: "ophthalmotonometry", typ: null },
650+ { json: "pailful", js: "pailful", typ: null },
651+ { json: "pigfish", js: "pigfish", typ: null },
652+ { json: "pongee", js: "pongee", typ: null },
653+ { json: "prosodical", js: "prosodical", typ: null },
654+ { json: "scrofuloderm", js: "scrofuloderm", typ: null },
655+ { json: "storekeeping", js: "storekeeping", typ: null },
656+ { json: "therologist", js: "therologist", typ: null },
657+ { json: "tradeful", js: "tradeful", typ: null },
658+ { json: "unriveting", js: "unriveting", typ: null },
659+ ], false),
660+ "ChemotherapeuticClass": o([
661+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
662+ { json: "Maureen", js: "Maureen", typ: u(undefined, null) },
663+ { json: "angioneurotic", js: "angioneurotic", typ: u(undefined, null) },
664+ { json: "availment", js: "availment", typ: u(undefined, null) },
665+ { json: "bladelet", js: "bladelet", typ: u(undefined, null) },
666+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
667+ { json: "caulis", js: "caulis", typ: u(undefined, null) },
668+ { json: "chalcus", js: "chalcus", typ: u(undefined, null) },
669+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
670+ { json: "enteradenological", js: "enteradenological", typ: u(undefined, null) },
671+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
672+ { json: "imporosity", js: "imporosity", typ: u(undefined, null) },
673+ { json: "insistently", js: "insistently", typ: u(undefined, null) },
674+ { json: "intraparietal", js: "intraparietal", typ: u(undefined, null) },
675+ { json: "ivied", js: "ivied", typ: u(undefined, null) },
676+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
677+ { json: "nostochine", js: "nostochine", typ: u(undefined, null) },
678+ { json: "nutcracker", js: "nutcracker", typ: u(undefined, null) },
679+ { json: "ofttimes", js: "ofttimes", typ: u(undefined, null) },
680+ { json: "phenocryst", js: "phenocryst", typ: u(undefined, null) },
681+ { json: "precoincident", js: "precoincident", typ: u(undefined, null) },
682+ { json: "ramiferous", js: "ramiferous", typ: u(undefined, null) },
683+ { json: "stagmometer", js: "stagmometer", typ: u(undefined, null) },
684+ { json: "tetherball", js: "tetherball", typ: u(undefined, null) },
685+ { json: "unshy", js: "unshy", typ: u(undefined, null) },
686+ ], false),
687+ "CimeliaClass": o([
688+ { json: "Chirotherium", js: "Chirotherium", typ: i(0) },
689+ { json: "catharticalness", js: "catharticalness", typ: 3.14 },
690+ { json: "disdiapason", js: "disdiapason", typ: "" },
691+ { json: "homocerc", js: "homocerc", typ: true },
692+ { json: "nonbookish", js: "nonbookish", typ: null },
693+ ], false),
694+ "CoadjustClass": o([
695+ { json: "Benny", js: "Benny", typ: u(undefined, null) },
696+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
697+ { json: "Netherlandish", js: "Netherlandish", typ: u(undefined, null) },
698+ { json: "Phonelescope", js: "Phonelescope", typ: u(undefined, null) },
699+ { json: "Sedaceae", js: "Sedaceae", typ: u(undefined, null) },
700+ { json: "amidosulphonal", js: "amidosulphonal", typ: u(undefined, null) },
701+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
702+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
703+ { json: "ensnare", js: "ensnare", typ: u(undefined, null) },
704+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
705+ { json: "hybridizer", js: "hybridizer", typ: u(undefined, null) },
706+ { json: "leastwise", js: "leastwise", typ: u(undefined, null) },
707+ { json: "lof", js: "lof", typ: u(undefined, null) },
708+ { json: "monkhood", js: "monkhood", typ: u(undefined, null) },
709+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
710+ { json: "peonism", js: "peonism", typ: u(undefined, null) },
711+ { json: "porphyrogeniture", js: "porphyrogeniture", typ: u(undefined, null) },
712+ { json: "preindemnify", js: "preindemnify", typ: u(undefined, null) },
713+ { json: "rosal", js: "rosal", typ: u(undefined, null) },
714+ { json: "scalenous", js: "scalenous", typ: u(undefined, null) },
715+ { json: "scopine", js: "scopine", typ: u(undefined, null) },
716+ { json: "suberinize", js: "suberinize", typ: u(undefined, null) },
717+ { json: "symbiot", js: "symbiot", typ: u(undefined, null) },
718+ { json: "tablefellow", js: "tablefellow", typ: u(undefined, null) },
719+ { json: "unchargeable", js: "unchargeable", typ: u(undefined, null) },
720+ ], false),
721+ "CredulityClass": o([
722+ { json: "Flavia", js: "Flavia", typ: null },
723+ { json: "Hedychium", js: "Hedychium", typ: null },
724+ { json: "Popean", js: "Popean", typ: null },
725+ { json: "ammonolytic", js: "ammonolytic", typ: null },
726+ { json: "bushmaster", js: "bushmaster", typ: null },
727+ { json: "considering", js: "considering", typ: null },
728+ { json: "consuetudinary", js: "consuetudinary", typ: null },
729+ { json: "embarras", js: "embarras", typ: null },
730+ { json: "fineness", js: "fineness", typ: null },
731+ { json: "flaithship", js: "flaithship", typ: null },
732+ { json: "gruffly", js: "gruffly", typ: null },
733+ { json: "leadwort", js: "leadwort", typ: null },
734+ { json: "overseriously", js: "overseriously", typ: null },
735+ { json: "parabola", js: "parabola", typ: null },
736+ { json: "pectinatodenticulate", js: "pectinatodenticulate", typ: null },
737+ { json: "pornocrat", js: "pornocrat", typ: null },
738+ { json: "quadrisect", js: "quadrisect", typ: null },
739+ { json: "seriality", js: "seriality", typ: null },
740+ { json: "vamphorn", js: "vamphorn", typ: null },
741+ { json: "wharp", js: "wharp", typ: null },
742+ ], false),
743+ "DeruralizeClass": o([
744+ { json: "Jehovistic", js: "Jehovistic", typ: null },
745+ { json: "Paninean", js: "Paninean", typ: null },
746+ { json: "Romney", js: "Romney", typ: null },
747+ { json: "bockerel", js: "bockerel", typ: null },
748+ { json: "boulder", js: "boulder", typ: null },
749+ { json: "churrus", js: "churrus", typ: null },
750+ { json: "counterdigged", js: "counterdigged", typ: null },
751+ { json: "dialogite", js: "dialogite", typ: null },
752+ { json: "digenic", js: "digenic", typ: null },
753+ { json: "dunbird", js: "dunbird", typ: null },
754+ { json: "ergatogyne", js: "ergatogyne", typ: null },
755+ { json: "fiendful", js: "fiendful", typ: null },
756+ { json: "jackrod", js: "jackrod", typ: null },
757+ { json: "panther", js: "panther", typ: null },
758+ { json: "placentigerous", js: "placentigerous", typ: null },
759+ { json: "sparm", js: "sparm", typ: null },
760+ { json: "tocsin", js: "tocsin", typ: null },
761+ { json: "unnicked", js: "unnicked", typ: null },
762+ { json: "unstavable", js: "unstavable", typ: null },
763+ { json: "windfirm", js: "windfirm", typ: null },
764+ ], false),
765+ "DiaereseClass": o([
766+ { json: "Amoreuxia", js: "Amoreuxia", typ: null },
767+ { json: "ani", js: "ani", typ: null },
768+ { json: "bernicle", js: "bernicle", typ: null },
769+ { json: "blackwasher", js: "blackwasher", typ: null },
770+ { json: "blowhard", js: "blowhard", typ: null },
771+ { json: "broma", js: "broma", typ: null },
772+ { json: "closecross", js: "closecross", typ: null },
773+ { json: "congregationalism", js: "congregationalism", typ: null },
774+ { json: "grayly", js: "grayly", typ: null },
775+ { json: "historically", js: "historically", typ: null },
776+ { json: "hoast", js: "hoast", typ: null },
777+ { json: "irretentive", js: "irretentive", typ: null },
778+ { json: "parcener", js: "parcener", typ: null },
779+ { json: "pedder", js: "pedder", typ: null },
780+ { json: "pseudoanatomic", js: "pseudoanatomic", typ: null },
781+ { json: "rhizocarpian", js: "rhizocarpian", typ: null },
782+ { json: "samel", js: "samel", typ: null },
783+ { json: "silker", js: "silker", typ: null },
784+ { json: "subdentated", js: "subdentated", typ: null },
785+ { json: "subobscure", js: "subobscure", typ: null },
786+ ], false),
787+ "Encrust": o([
788+ { json: "Hibernia", js: "Hibernia", typ: null },
789+ { json: "Hibiscus", js: "Hibiscus", typ: null },
790+ { json: "Lepidosauria", js: "Lepidosauria", typ: null },
791+ { json: "Syllidae", js: "Syllidae", typ: null },
792+ { json: "comradely", js: "comradely", typ: null },
793+ { json: "diacanthous", js: "diacanthous", typ: null },
794+ { json: "feminineness", js: "feminineness", typ: null },
795+ { json: "gossamered", js: "gossamered", typ: null },
796+ { json: "lollingly", js: "lollingly", typ: null },
797+ { json: "manager", js: "manager", typ: null },
798+ { json: "mechanic", js: "mechanic", typ: null },
799+ { json: "overminuteness", js: "overminuteness", typ: null },
800+ { json: "papelonne", js: "papelonne", typ: null },
801+ { json: "plebification", js: "plebification", typ: null },
802+ { json: "pugmiller", js: "pugmiller", typ: null },
803+ { json: "recoveror", js: "recoveror", typ: null },
804+ { json: "spermatoblastic", js: "spermatoblastic", typ: null },
805+ { json: "ungyved", js: "ungyved", typ: null },
806+ { json: "whirlabout", js: "whirlabout", typ: null },
807+ { json: "woodenware", js: "woodenware", typ: null },
808+ ], false),
809+ "FagginglyClass": o([
810+ { json: "Anglic", js: "Anglic", typ: null },
811+ { json: "Heteromeri", js: "Heteromeri", typ: null },
812+ { json: "Poinsettia", js: "Poinsettia", typ: null },
813+ { json: "abranchian", js: "abranchian", typ: null },
814+ { json: "aculeiform", js: "aculeiform", typ: null },
815+ { json: "adiaphoristic", js: "adiaphoristic", typ: null },
816+ { json: "adoptionism", js: "adoptionism", typ: null },
817+ { json: "antrotomy", js: "antrotomy", typ: null },
818+ { json: "coerciveness", js: "coerciveness", typ: null },
819+ { json: "decorist", js: "decorist", typ: null },
820+ { json: "duckhood", js: "duckhood", typ: null },
821+ { json: "hypochnose", js: "hypochnose", typ: null },
822+ { json: "lochage", js: "lochage", typ: null },
823+ { json: "melee", js: "melee", typ: null },
824+ { json: "nonconformitant", js: "nonconformitant", typ: null },
825+ { json: "putatively", js: "putatively", typ: null },
826+ { json: "semivolatile", js: "semivolatile", typ: null },
827+ { json: "soleas", js: "soleas", typ: null },
828+ { json: "unfastenable", js: "unfastenable", typ: null },
829+ { json: "unmillinered", js: "unmillinered", typ: null },
830+ ], false),
831+ "FenkClass": o([
832+ { json: "Dagomba", js: "Dagomba", typ: null },
833+ { json: "Guyandot", js: "Guyandot", typ: null },
834+ { json: "Reinwardtia", js: "Reinwardtia", typ: null },
835+ { json: "Tritoness", js: "Tritoness", typ: null },
836+ { json: "apoise", js: "apoise", typ: null },
837+ { json: "astronomize", js: "astronomize", typ: null },
838+ { json: "cockhorse", js: "cockhorse", typ: null },
839+ { json: "copular", js: "copular", typ: null },
840+ { json: "draffy", js: "draffy", typ: null },
841+ { json: "foreigner", js: "foreigner", typ: null },
842+ { json: "neurogliosis", js: "neurogliosis", typ: null },
843+ { json: "osmious", js: "osmious", typ: null },
844+ { json: "palpitate", js: "palpitate", typ: null },
845+ { json: "rebukeable", js: "rebukeable", typ: null },
846+ { json: "reservatory", js: "reservatory", typ: null },
847+ { json: "scalt", js: "scalt", typ: null },
848+ { json: "scripturalize", js: "scripturalize", typ: null },
849+ { json: "tintometer", js: "tintometer", typ: null },
850+ { json: "undergrade", js: "undergrade", typ: null },
851+ { json: "undermountain", js: "undermountain", typ: null },
852+ ], false),
853+ "FlagmakingClass": o([
854+ { json: "Bunodonta", js: "Bunodonta", typ: null },
855+ { json: "Hydrocorisae", js: "Hydrocorisae", typ: null },
856+ { json: "Notacanthidae", js: "Notacanthidae", typ: null },
857+ { json: "albarco", js: "albarco", typ: null },
858+ { json: "hornify", js: "hornify", typ: null },
859+ { json: "hypoglossus", js: "hypoglossus", typ: null },
860+ { json: "inexpiably", js: "inexpiably", typ: null },
861+ { json: "ingratitude", js: "ingratitude", typ: null },
862+ { json: "ladyfly", js: "ladyfly", typ: null },
863+ { json: "medicament", js: "medicament", typ: null },
864+ { json: "monogrammatic", js: "monogrammatic", typ: null },
865+ { json: "nobbut", js: "nobbut", typ: null },
866+ { json: "polyplacophore", js: "polyplacophore", typ: null },
867+ { json: "proexercise", js: "proexercise", typ: null },
868+ { json: "protoplast", js: "protoplast", typ: null },
869+ { json: "puzzling", js: "puzzling", typ: null },
870+ { json: "splanchnoskeleton", js: "splanchnoskeleton", typ: null },
871+ { json: "unloveliness", js: "unloveliness", typ: null },
872+ { json: "unquarantined", js: "unquarantined", typ: null },
873+ { json: "unrenounceable", js: "unrenounceable", typ: null },
874+ ], false),
875+ "HemocoeleClass": o([
876+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
877+ { json: "Walt", js: "Walt", typ: u(undefined, null) },
878+ { json: "acrogamy", js: "acrogamy", typ: u(undefined, null) },
879+ { json: "amelification", js: "amelification", typ: u(undefined, null) },
880+ { json: "autobiographic", js: "autobiographic", typ: u(undefined, null) },
881+ { json: "berat", js: "berat", typ: u(undefined, null) },
882+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
883+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
884+ { json: "disproportionably", js: "disproportionably", typ: u(undefined, null) },
885+ { json: "erythrite", js: "erythrite", typ: u(undefined, null) },
886+ { json: "graphic", js: "graphic", typ: u(undefined, null) },
887+ { json: "hepatological", js: "hepatological", typ: u(undefined, null) },
888+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
889+ { json: "incommensurably", js: "incommensurably", typ: u(undefined, null) },
890+ { json: "misaffirm", js: "misaffirm", typ: u(undefined, null) },
891+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
892+ { json: "pocketbook", js: "pocketbook", typ: u(undefined, null) },
893+ { json: "sclerometric", js: "sclerometric", typ: u(undefined, null) },
894+ { json: "stambouline", js: "stambouline", typ: u(undefined, null) },
895+ { json: "stickpin", js: "stickpin", typ: u(undefined, null) },
896+ { json: "tubulure", js: "tubulure", typ: u(undefined, null) },
897+ { json: "undelated", js: "undelated", typ: u(undefined, null) },
898+ { json: "unsalt", js: "unsalt", typ: u(undefined, null) },
899+ { json: "untutelar", js: "untutelar", typ: u(undefined, null) },
900+ { json: "vagrant", js: "vagrant", typ: u(undefined, null) },
901+ ], false),
902+ "Interacinar": o([
903+ { json: "assapan", js: "assapan", typ: 3.14 },
904+ { json: "benefactorship", js: "benefactorship", typ: true },
905+ { json: "triseriatim", js: "triseriatim", typ: "" },
906+ { json: "tubbing", js: "tubbing", typ: i(0) },
907+ { json: "untrimmed", js: "untrimmed", typ: null },
908+ ], false),
909+};
Test case

test/inputs/json/priority/combinations2.json

5 generated files · +8,304 −0
Adartfrom-map-true--d222f65b3fee / TopLevel.dart+1,121 −0
@@ -0,0 +1,1121 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromMap(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toMap());
10+
11+class TopLevel {
12+ final List<dynamic> abranchiata;
13+ final List<dynamic> academe;
14+ final List<dynamic> acquirable;
15+ final List<dynamic> aerometry;
16+ final List<dynamic> alexin;
17+ final List<dynamic> alleviate;
18+ final List<dynamic> amaas;
19+ final List<dynamic> ambassage;
20+ final List<Amphithyron?> amphithyron;
21+ final List<String?> andriana;
22+ final List<dynamic> ankee;
23+ final List<Map<String, int?>?> annihilator;
24+ final dynamic annulose;
25+ final List<dynamic> ansarie;
26+ final List<dynamic> aphasia;
27+ final List<dynamic> asprawl;
28+ final List<bool?> attractive;
29+ final Map<String, int> barksome;
30+ final List<dynamic> bedesman;
31+ final List<dynamic> belard;
32+ final List<dynamic> bocking;
33+ final List<dynamic> brawlingly;
34+ final List<dynamic> brookie;
35+ final List<dynamic> bumboatman;
36+ final List<dynamic> bystreet;
37+ final List<dynamic> calaverite;
38+ final List<dynamic> catallactic;
39+ final List<dynamic> cemental;
40+ final List<dynamic> chytridiaceae;
41+ final List<dynamic> discordia;
42+ final List<dynamic> endomyces;
43+ final List<dynamic> epinephelidae;
44+ final List<dynamic> eupatorium;
45+ final List<dynamic> gryphosaurus;
46+ final List<dynamic> koryak;
47+ final List<dynamic> lavinia;
48+ final List<dynamic> oskar;
49+ final List<dynamic> rebecca;
50+ final List<dynamic> rhomboganoidei;
51+ final bool rigsmal;
52+ final List<dynamic> ruellia;
53+ final List<dynamic> school;
54+ final List<dynamic> shakespearolater;
55+ final List<double> svan;
56+ final Map<String, double> wayao;
57+
58+ TopLevel({
59+ required this.abranchiata,
60+ required this.academe,
61+ required this.acquirable,
62+ required this.aerometry,
63+ required this.alexin,
64+ required this.alleviate,
65+ required this.amaas,
66+ required this.ambassage,
67+ required this.amphithyron,
68+ required this.andriana,
69+ required this.ankee,
70+ required this.annihilator,
71+ required this.annulose,
72+ required this.ansarie,
73+ required this.aphasia,
74+ required this.asprawl,
75+ required this.attractive,
76+ required this.barksome,
77+ required this.bedesman,
78+ required this.belard,
79+ required this.bocking,
80+ required this.brawlingly,
81+ required this.brookie,
82+ required this.bumboatman,
83+ required this.bystreet,
84+ required this.calaverite,
85+ required this.catallactic,
86+ required this.cemental,
87+ required this.chytridiaceae,
88+ required this.discordia,
89+ required this.endomyces,
90+ required this.epinephelidae,
91+ required this.eupatorium,
92+ required this.gryphosaurus,
93+ required this.koryak,
94+ required this.lavinia,
95+ required this.oskar,
96+ required this.rebecca,
97+ required this.rhomboganoidei,
98+ required this.rigsmal,
99+ required this.ruellia,
100+ required this.school,
101+ required this.shakespearolater,
102+ required this.svan,
103+ required this.wayao,
104+ });
105+
106+ factory TopLevel.fromMap(Map<String, dynamic> json) => TopLevel(
107+ abranchiata: List<dynamic>.from(json["Abranchiata"].map((x) => x)),
108+ academe: List<dynamic>.from(json["academe"].map((x) => x)),
109+ acquirable: List<dynamic>.from(json["acquirable"].map((x) => x)),
110+ aerometry: List<dynamic>.from(json["aerometry"].map((x) => x)),
111+ alexin: List<dynamic>.from(json["alexin"].map((x) => x)),
112+ alleviate: List<dynamic>.from(json["alleviate"].map((x) => x)),
113+ amaas: List<dynamic>.from(json["amaas"].map((x) => x)),
114+ ambassage: List<dynamic>.from(json["ambassage"].map((x) => x)),
115+ amphithyron: List<Amphithyron?>.from(json["amphithyron"].map((x) => x == null ? null : Amphithyron.fromMap(x))),
116+ andriana: List<String?>.from(json["Andriana"].map((x) => x)),
117+ ankee: List<dynamic>.from(json["ankee"].map((x) => x)),
118+ annihilator: List<Map<String, int?>?>.from(json["annihilator"].map((x) => x == null ? null : Map.from(x!).map((k, v) => MapEntry<String, int?>(k, v)))),
119+ annulose: (json.containsKey("annulose") ? json["annulose"] : throw FormatException('Missing required property')),
120+ ansarie: List<dynamic>.from(json["Ansarie"].map((x) => x)),
121+ aphasia: List<dynamic>.from(json["aphasia"].map((x) => x)),
122+ asprawl: List<dynamic>.from(json["asprawl"].map((x) => x)),
123+ attractive: List<bool?>.from(json["attractive"].map((x) => x)),
124+ barksome: Map.from(json["barksome"]).map((k, v) => MapEntry<String, int>(k, v)),
125+ bedesman: List<dynamic>.from(json["bedesman"].map((x) => x)),
126+ belard: List<dynamic>.from(json["belard"].map((x) => x)),
127+ bocking: List<dynamic>.from(json["bocking"].map((x) => x)),
128+ brawlingly: List<dynamic>.from(json["brawlingly"].map((x) => x)),
129+ brookie: List<dynamic>.from(json["brookie"].map((x) => x)),
130+ bumboatman: List<dynamic>.from(json["bumboatman"].map((x) => x)),
131+ bystreet: List<dynamic>.from(json["bystreet"].map((x) => x)),
132+ calaverite: List<dynamic>.from(json["calaverite"].map((x) => x)),
133+ catallactic: List<dynamic>.from(json["catallactic"].map((x) => x)),
134+ cemental: List<dynamic>.from(json["cemental"].map((x) => x)),
135+ chytridiaceae: List<dynamic>.from(json["Chytridiaceae"].map((x) => x)),
136+ discordia: List<dynamic>.from(json["Discordia"].map((x) => x)),
137+ endomyces: List<dynamic>.from(json["Endomyces"].map((x) => x)),
138+ epinephelidae: List<dynamic>.from(json["Epinephelidae"].map((x) => x)),
139+ eupatorium: List<dynamic>.from(json["Eupatorium"].map((x) => x)),
140+ gryphosaurus: List<dynamic>.from(json["Gryphosaurus"].map((x) => x)),
141+ koryak: List<dynamic>.from(json["Koryak"].map((x) => x)),
142+ lavinia: List<dynamic>.from(json["Lavinia"].map((x) => x)),
143+ oskar: List<dynamic>.from(json["Oskar"].map((x) => x)),
144+ rebecca: List<dynamic>.from(json["Rebecca"].map((x) => x)),
145+ rhomboganoidei: List<dynamic>.from(json["Rhomboganoidei"].map((x) => x)),
146+ rigsmal: json["Rigsmal"],
147+ ruellia: List<dynamic>.from(json["Ruellia"].map((x) => x)),
148+ school: List<dynamic>.from(json["School"].map((x) => x)),
149+ shakespearolater: List<dynamic>.from(json["Shakespearolater"].map((x) => x)),
150+ svan: List<double>.from(json["Svan"].map((x) => x?.toDouble())),
151+ wayao: Map.from(json["Wayao"]).map((k, v) => MapEntry<String, double>(k, v?.toDouble())),
152+ );
153+
154+ Map<String, dynamic> toMap() => {
155+ "Abranchiata": List<dynamic>.from(abranchiata.map((x) => x)),
156+ "academe": List<dynamic>.from(academe.map((x) => x)),
157+ "acquirable": List<dynamic>.from(acquirable.map((x) => x)),
158+ "aerometry": List<dynamic>.from(aerometry.map((x) => x)),
159+ "alexin": List<dynamic>.from(alexin.map((x) => x)),
160+ "alleviate": List<dynamic>.from(alleviate.map((x) => x)),
161+ "amaas": List<dynamic>.from(amaas.map((x) => x)),
162+ "ambassage": List<dynamic>.from(ambassage.map((x) => x)),
163+ "amphithyron": List<dynamic>.from(amphithyron.map((x) => x?.toMap())),
164+ "Andriana": List<dynamic>.from(andriana.map((x) => x)),
165+ "ankee": List<dynamic>.from(ankee.map((x) => x)),
166+ "annihilator": List<dynamic>.from(annihilator.map((x) => x == null ? null : Map.from(x!).map((k, v) => MapEntry<String, dynamic>(k, v)))),
167+ "annulose": annulose,
168+ "Ansarie": List<dynamic>.from(ansarie.map((x) => x)),
169+ "aphasia": List<dynamic>.from(aphasia.map((x) => x)),
170+ "asprawl": List<dynamic>.from(asprawl.map((x) => x)),
171+ "attractive": List<dynamic>.from(attractive.map((x) => x)),
172+ "barksome": Map.from(barksome).map((k, v) => MapEntry<String, dynamic>(k, v)),
173+ "bedesman": List<dynamic>.from(bedesman.map((x) => x)),
174+ "belard": List<dynamic>.from(belard.map((x) => x)),
175+ "bocking": List<dynamic>.from(bocking.map((x) => x)),
176+ "brawlingly": List<dynamic>.from(brawlingly.map((x) => x)),
177+ "brookie": List<dynamic>.from(brookie.map((x) => x)),
178+ "bumboatman": List<dynamic>.from(bumboatman.map((x) => x)),
179+ "bystreet": List<dynamic>.from(bystreet.map((x) => x)),
180+ "calaverite": List<dynamic>.from(calaverite.map((x) => x)),
181+ "catallactic": List<dynamic>.from(catallactic.map((x) => x)),
182+ "cemental": List<dynamic>.from(cemental.map((x) => x)),
183+ "Chytridiaceae": List<dynamic>.from(chytridiaceae.map((x) => x)),
184+ "Discordia": List<dynamic>.from(discordia.map((x) => x)),
185+ "Endomyces": List<dynamic>.from(endomyces.map((x) => x)),
186+ "Epinephelidae": List<dynamic>.from(epinephelidae.map((x) => x)),
187+ "Eupatorium": List<dynamic>.from(eupatorium.map((x) => x)),
188+ "Gryphosaurus": List<dynamic>.from(gryphosaurus.map((x) => x)),
189+ "Koryak": List<dynamic>.from(koryak.map((x) => x)),
190+ "Lavinia": List<dynamic>.from(lavinia.map((x) => x)),
191+ "Oskar": List<dynamic>.from(oskar.map((x) => x)),
192+ "Rebecca": List<dynamic>.from(rebecca.map((x) => x)),
193+ "Rhomboganoidei": List<dynamic>.from(rhomboganoidei.map((x) => x)),
194+ "Rigsmal": rigsmal,
195+ "Ruellia": List<dynamic>.from(ruellia.map((x) => x)),
196+ "School": List<dynamic>.from(school.map((x) => x)),
197+ "Shakespearolater": List<dynamic>.from(shakespearolater.map((x) => x)),
198+ "Svan": List<dynamic>.from(svan.map((x) => x)),
199+ "Wayao": Map.from(wayao).map((k, v) => MapEntry<String, dynamic>(k, v)),
200+ };
201+}
202+
203+class AlleviateClass {
204+ final dynamic apriori;
205+ final dynamic beggarer;
206+ final dynamic brokenheartedly;
207+ final dynamic debilitation;
208+ final dynamic frike;
209+ final dynamic gastrolith;
210+ final dynamic hulsean;
211+ final dynamic orthocentric;
212+ final dynamic petaly;
213+ final dynamic probudgeting;
214+ final dynamic reacquire;
215+ final dynamic scow;
216+ final dynamic shutoff;
217+ final dynamic subcontiguous;
218+ final dynamic suffumigate;
219+ final dynamic transformable;
220+ final dynamic uncoroneted;
221+ final dynamic unparking;
222+ final dynamic unvarnishedness;
223+ final dynamic wherewithal;
224+
225+ AlleviateClass({
226+ required this.apriori,
227+ required this.beggarer,
228+ required this.brokenheartedly,
229+ required this.debilitation,
230+ required this.frike,
231+ required this.gastrolith,
232+ required this.hulsean,
233+ required this.orthocentric,
234+ required this.petaly,
235+ required this.probudgeting,
236+ required this.reacquire,
237+ required this.scow,
238+ required this.shutoff,
239+ required this.subcontiguous,
240+ required this.suffumigate,
241+ required this.transformable,
242+ required this.uncoroneted,
243+ required this.unparking,
244+ required this.unvarnishedness,
245+ required this.wherewithal,
246+ });
247+
248+ factory AlleviateClass.fromMap(Map<String, dynamic> json) => AlleviateClass(
249+ apriori: (json.containsKey("apriori") ? json["apriori"] : throw FormatException('Missing required property')),
250+ beggarer: (json.containsKey("beggarer") ? json["beggarer"] : throw FormatException('Missing required property')),
251+ brokenheartedly: (json.containsKey("brokenheartedly") ? json["brokenheartedly"] : throw FormatException('Missing required property')),
252+ debilitation: (json.containsKey("debilitation") ? json["debilitation"] : throw FormatException('Missing required property')),
253+ frike: (json.containsKey("frike") ? json["frike"] : throw FormatException('Missing required property')),
254+ gastrolith: (json.containsKey("gastrolith") ? json["gastrolith"] : throw FormatException('Missing required property')),
255+ hulsean: (json.containsKey("Hulsean") ? json["Hulsean"] : throw FormatException('Missing required property')),
256+ orthocentric: (json.containsKey("orthocentric") ? json["orthocentric"] : throw FormatException('Missing required property')),
257+ petaly: (json.containsKey("petaly") ? json["petaly"] : throw FormatException('Missing required property')),
258+ probudgeting: (json.containsKey("probudgeting") ? json["probudgeting"] : throw FormatException('Missing required property')),
259+ reacquire: (json.containsKey("reacquire") ? json["reacquire"] : throw FormatException('Missing required property')),
260+ scow: (json.containsKey("scow") ? json["scow"] : throw FormatException('Missing required property')),
261+ shutoff: (json.containsKey("shutoff") ? json["shutoff"] : throw FormatException('Missing required property')),
262+ subcontiguous: (json.containsKey("subcontiguous") ? json["subcontiguous"] : throw FormatException('Missing required property')),
263+ suffumigate: (json.containsKey("suffumigate") ? json["suffumigate"] : throw FormatException('Missing required property')),
264+ transformable: (json.containsKey("transformable") ? json["transformable"] : throw FormatException('Missing required property')),
265+ uncoroneted: (json.containsKey("uncoroneted") ? json["uncoroneted"] : throw FormatException('Missing required property')),
266+ unparking: (json.containsKey("unparking") ? json["unparking"] : throw FormatException('Missing required property')),
267+ unvarnishedness: (json.containsKey("unvarnishedness") ? json["unvarnishedness"] : throw FormatException('Missing required property')),
268+ wherewithal: (json.containsKey("wherewithal") ? json["wherewithal"] : throw FormatException('Missing required property')),
269+ );
270+
271+ Map<String, dynamic> toMap() => {
272+ "apriori": apriori,
273+ "beggarer": beggarer,
274+ "brokenheartedly": brokenheartedly,
275+ "debilitation": debilitation,
276+ "frike": frike,
277+ "gastrolith": gastrolith,
278+ "Hulsean": hulsean,
279+ "orthocentric": orthocentric,
280+ "petaly": petaly,
281+ "probudgeting": probudgeting,
282+ "reacquire": reacquire,
283+ "scow": scow,
284+ "shutoff": shutoff,
285+ "subcontiguous": subcontiguous,
286+ "suffumigate": suffumigate,
287+ "transformable": transformable,
288+ "uncoroneted": uncoroneted,
289+ "unparking": unparking,
290+ "unvarnishedness": unvarnishedness,
291+ "wherewithal": wherewithal,
292+ };
293+}
294+
295+class Rebecca {
296+ final double catharticalness;
297+ final int chirotherium;
298+ final String disdiapason;
299+ final bool homocerc;
300+ final dynamic nonbookish;
301+
302+ Rebecca({
303+ required this.catharticalness,
304+ required this.chirotherium,
305+ required this.disdiapason,
306+ required this.homocerc,
307+ required this.nonbookish,
308+ });
309+
310+ factory Rebecca.fromMap(Map<String, dynamic> json) => Rebecca(
311+ catharticalness: json["catharticalness"]?.toDouble(),
312+ chirotherium: json["Chirotherium"],
313+ disdiapason: json["disdiapason"],
314+ homocerc: json["homocerc"],
315+ nonbookish: (json.containsKey("nonbookish") ? json["nonbookish"] : throw FormatException('Missing required property')),
316+ );
317+
318+ Map<String, dynamic> toMap() => {
319+ "catharticalness": catharticalness,
320+ "Chirotherium": chirotherium,
321+ "disdiapason": disdiapason,
322+ "homocerc": homocerc,
323+ "nonbookish": nonbookish,
324+ };
325+}
326+
327+class Amphithyron {
328+ final int? akroasis;
329+ final int? antiphonical;
330+ final int? basebred;
331+ final double? catharticalness;
332+ final int? chirotherium;
333+ final int? conductometric;
334+ final String? disdiapason;
335+ final int? ensilation;
336+ final int? eyebolt;
337+ final int? fistulated;
338+ final int? heteropod;
339+ final bool? homocerc;
340+ final int? juniperus;
341+ final int? labyrinthically;
342+ final int? martyrization;
343+ final int? mispolicy;
344+ final int? multipara;
345+ final int? nazirite;
346+ final dynamic nonbookish;
347+ final int? possessorial;
348+ final int? shamed;
349+ final int? shelfworn;
350+ final int? stagnum;
351+ final int? those;
352+ final int? undecimal;
353+
354+ Amphithyron({
355+ this.akroasis,
356+ this.antiphonical,
357+ this.basebred,
358+ this.catharticalness,
359+ this.chirotherium,
360+ this.conductometric,
361+ this.disdiapason,
362+ this.ensilation,
363+ this.eyebolt,
364+ this.fistulated,
365+ this.heteropod,
366+ this.homocerc,
367+ this.juniperus,
368+ this.labyrinthically,
369+ this.martyrization,
370+ this.mispolicy,
371+ this.multipara,
372+ this.nazirite,
373+ this.nonbookish,
374+ this.possessorial,
375+ this.shamed,
376+ this.shelfworn,
377+ this.stagnum,
378+ this.those,
379+ this.undecimal,
380+ });
381+
382+ factory Amphithyron.fromMap(Map<String, dynamic> json) => Amphithyron(
383+ akroasis: json["akroasis"],
384+ antiphonical: json["antiphonical"],
385+ basebred: json["basebred"],
386+ catharticalness: json["catharticalness"]?.toDouble(),
387+ chirotherium: json["Chirotherium"],
388+ conductometric: json["conductometric"],
389+ disdiapason: json["disdiapason"],
390+ ensilation: json["ensilation"],
391+ eyebolt: json["eyebolt"],
392+ fistulated: json["fistulated"],
393+ heteropod: json["heteropod"],
394+ homocerc: json["homocerc"],
395+ juniperus: json["Juniperus"],
396+ labyrinthically: json["labyrinthically"],
397+ martyrization: json["martyrization"],
398+ mispolicy: json["mispolicy"],
399+ multipara: json["multipara"],
400+ nazirite: json["Nazirite"],
401+ nonbookish: json["nonbookish"],
402+ possessorial: json["possessorial"],
403+ shamed: json["shamed"],
404+ shelfworn: json["shelfworn"],
405+ stagnum: json["stagnum"],
406+ those: json["Those"],
407+ undecimal: json["undecimal"],
408+ );
409+
410+ Map<String, dynamic> toMap() => {
411+ "akroasis": akroasis,
412+ "antiphonical": antiphonical,
413+ "basebred": basebred,
414+ "catharticalness": catharticalness,
415+ "Chirotherium": chirotherium,
416+ "conductometric": conductometric,
417+ "disdiapason": disdiapason,
418+ "ensilation": ensilation,
419+ "eyebolt": eyebolt,
420+ "fistulated": fistulated,
421+ "heteropod": heteropod,
422+ "homocerc": homocerc,
423+ "Juniperus": juniperus,
424+ "labyrinthically": labyrinthically,
425+ "martyrization": martyrization,
426+ "mispolicy": mispolicy,
427+ "multipara": multipara,
428+ "Nazirite": nazirite,
429+ "nonbookish": nonbookish,
430+ "possessorial": possessorial,
431+ "shamed": shamed,
432+ "shelfworn": shelfworn,
433+ "stagnum": stagnum,
434+ "Those": those,
435+ "undecimal": undecimal,
436+ };
437+}
438+
439+class AnkeeClass {
440+ final dynamic anomoean;
441+ final dynamic barleyhood;
442+ final dynamic befriender;
443+ final dynamic brutishness;
444+ final dynamic cephalalgy;
445+ final dynamic cirurgian;
446+ final dynamic conventionally;
447+ final dynamic jackshay;
448+ final dynamic milammeter;
449+ final dynamic naja;
450+ final dynamic ombrological;
451+ final dynamic phonasthenia;
452+ final dynamic retrievableness;
453+ final dynamic snakily;
454+ final dynamic swot;
455+ final dynamic tartlet;
456+ final dynamic thiofuran;
457+ final dynamic tracheophone;
458+ final dynamic tuglike;
459+ final dynamic unscratchingly;
460+
461+ AnkeeClass({
462+ required this.anomoean,
463+ required this.barleyhood,
464+ required this.befriender,
465+ required this.brutishness,
466+ required this.cephalalgy,
467+ required this.cirurgian,
468+ required this.conventionally,
469+ required this.jackshay,
470+ required this.milammeter,
471+ required this.naja,
472+ required this.ombrological,
473+ required this.phonasthenia,
474+ required this.retrievableness,
475+ required this.snakily,
476+ required this.swot,
477+ required this.tartlet,
478+ required this.thiofuran,
479+ required this.tracheophone,
480+ required this.tuglike,
481+ required this.unscratchingly,
482+ });
483+
484+ factory AnkeeClass.fromMap(Map<String, dynamic> json) => AnkeeClass(
485+ anomoean: (json.containsKey("Anomoean") ? json["Anomoean"] : throw FormatException('Missing required property')),
486+ barleyhood: (json.containsKey("barleyhood") ? json["barleyhood"] : throw FormatException('Missing required property')),
487+ befriender: (json.containsKey("befriender") ? json["befriender"] : throw FormatException('Missing required property')),
488+ brutishness: (json.containsKey("brutishness") ? json["brutishness"] : throw FormatException('Missing required property')),
489+ cephalalgy: (json.containsKey("cephalalgy") ? json["cephalalgy"] : throw FormatException('Missing required property')),
490+ cirurgian: (json.containsKey("cirurgian") ? json["cirurgian"] : throw FormatException('Missing required property')),
491+ conventionally: (json.containsKey("conventionally") ? json["conventionally"] : throw FormatException('Missing required property')),
492+ jackshay: (json.containsKey("jackshay") ? json["jackshay"] : throw FormatException('Missing required property')),
493+ milammeter: (json.containsKey("milammeter") ? json["milammeter"] : throw FormatException('Missing required property')),
494+ naja: (json.containsKey("Naja") ? json["Naja"] : throw FormatException('Missing required property')),
495+ ombrological: (json.containsKey("ombrological") ? json["ombrological"] : throw FormatException('Missing required property')),
496+ phonasthenia: (json.containsKey("phonasthenia") ? json["phonasthenia"] : throw FormatException('Missing required property')),
497+ retrievableness: (json.containsKey("retrievableness") ? json["retrievableness"] : throw FormatException('Missing required property')),
498+ snakily: (json.containsKey("snakily") ? json["snakily"] : throw FormatException('Missing required property')),
499+ swot: (json.containsKey("swot") ? json["swot"] : throw FormatException('Missing required property')),
500+ tartlet: (json.containsKey("tartlet") ? json["tartlet"] : throw FormatException('Missing required property')),
501+ thiofuran: (json.containsKey("thiofuran") ? json["thiofuran"] : throw FormatException('Missing required property')),
502+ tracheophone: (json.containsKey("tracheophone") ? json["tracheophone"] : throw FormatException('Missing required property')),
503+ tuglike: (json.containsKey("tuglike") ? json["tuglike"] : throw FormatException('Missing required property')),
504+ unscratchingly: (json.containsKey("unscratchingly") ? json["unscratchingly"] : throw FormatException('Missing required property')),
505+ );
506+
507+ Map<String, dynamic> toMap() => {
508+ "Anomoean": anomoean,
509+ "barleyhood": barleyhood,
510+ "befriender": befriender,
511+ "brutishness": brutishness,
512+ "cephalalgy": cephalalgy,
513+ "cirurgian": cirurgian,
514+ "conventionally": conventionally,
515+ "jackshay": jackshay,
516+ "milammeter": milammeter,
517+ "Naja": naja,
518+ "ombrological": ombrological,
519+ "phonasthenia": phonasthenia,
520+ "retrievableness": retrievableness,
521+ "snakily": snakily,
522+ "swot": swot,
523+ "tartlet": tartlet,
524+ "thiofuran": thiofuran,
525+ "tracheophone": tracheophone,
526+ "tuglike": tuglike,
527+ "unscratchingly": unscratchingly,
528+ };
529+}
530+
531+class AnsarieClass {
532+ final dynamic accension;
533+ final dynamic alida;
534+ final dynamic asteria;
535+ final dynamic beriberic;
536+ final dynamic edgebone;
537+ final dynamic gastrodialysis;
538+ final dynamic geographic;
539+ final dynamic ictonyx;
540+ final dynamic metrocele;
541+ final dynamic misgraft;
542+ final dynamic monteith;
543+ final dynamic notcher;
544+ final dynamic prorestriction;
545+ final dynamic ramist;
546+ final dynamic throatlet;
547+ final dynamic unfair;
548+ final dynamic unsynonymous;
549+ final dynamic water;
550+ final dynamic zestfully;
551+ final dynamic zincic;
552+
553+ AnsarieClass({
554+ required this.accension,
555+ required this.alida,
556+ required this.asteria,
557+ required this.beriberic,
558+ required this.edgebone,
559+ required this.gastrodialysis,
560+ required this.geographic,
561+ required this.ictonyx,
562+ required this.metrocele,
563+ required this.misgraft,
564+ required this.monteith,
565+ required this.notcher,
566+ required this.prorestriction,
567+ required this.ramist,
568+ required this.throatlet,
569+ required this.unfair,
570+ required this.unsynonymous,
571+ required this.water,
572+ required this.zestfully,
573+ required this.zincic,
574+ });
575+
576+ factory AnsarieClass.fromMap(Map<String, dynamic> json) => AnsarieClass(
577+ accension: (json.containsKey("accension") ? json["accension"] : throw FormatException('Missing required property')),
578+ alida: (json.containsKey("Alida") ? json["Alida"] : throw FormatException('Missing required property')),
579+ asteria: (json.containsKey("asteria") ? json["asteria"] : throw FormatException('Missing required property')),
580+ beriberic: (json.containsKey("beriberic") ? json["beriberic"] : throw FormatException('Missing required property')),
581+ edgebone: (json.containsKey("edgebone") ? json["edgebone"] : throw FormatException('Missing required property')),
582+ gastrodialysis: (json.containsKey("gastrodialysis") ? json["gastrodialysis"] : throw FormatException('Missing required property')),
583+ geographic: (json.containsKey("geographic") ? json["geographic"] : throw FormatException('Missing required property')),
584+ ictonyx: (json.containsKey("Ictonyx") ? json["Ictonyx"] : throw FormatException('Missing required property')),
585+ metrocele: (json.containsKey("metrocele") ? json["metrocele"] : throw FormatException('Missing required property')),
586+ misgraft: (json.containsKey("misgraft") ? json["misgraft"] : throw FormatException('Missing required property')),
587+ monteith: (json.containsKey("monteith") ? json["monteith"] : throw FormatException('Missing required property')),
588+ notcher: (json.containsKey("notcher") ? json["notcher"] : throw FormatException('Missing required property')),
589+ prorestriction: (json.containsKey("prorestriction") ? json["prorestriction"] : throw FormatException('Missing required property')),
590+ ramist: (json.containsKey("Ramist") ? json["Ramist"] : throw FormatException('Missing required property')),
591+ throatlet: (json.containsKey("throatlet") ? json["throatlet"] : throw FormatException('Missing required property')),
592+ unfair: (json.containsKey("unfair") ? json["unfair"] : throw FormatException('Missing required property')),
593+ unsynonymous: (json.containsKey("unsynonymous") ? json["unsynonymous"] : throw FormatException('Missing required property')),
594+ water: (json.containsKey("water") ? json["water"] : throw FormatException('Missing required property')),
595+ zestfully: (json.containsKey("zestfully") ? json["zestfully"] : throw FormatException('Missing required property')),
596+ zincic: (json.containsKey("zincic") ? json["zincic"] : throw FormatException('Missing required property')),
597+ );
598+
599+ Map<String, dynamic> toMap() => {
600+ "accension": accension,
601+ "Alida": alida,
602+ "asteria": asteria,
603+ "beriberic": beriberic,
604+ "edgebone": edgebone,
605+ "gastrodialysis": gastrodialysis,
606+ "geographic": geographic,
607+ "Ictonyx": ictonyx,
608+ "metrocele": metrocele,
609+ "misgraft": misgraft,
610+ "monteith": monteith,
611+ "notcher": notcher,
612+ "prorestriction": prorestriction,
613+ "Ramist": ramist,
614+ "throatlet": throatlet,
615+ "unfair": unfair,
616+ "unsynonymous": unsynonymous,
617+ "water": water,
618+ "zestfully": zestfully,
619+ "zincic": zincic,
620+ };
621+}
622+
623+class ChytridiaceaeClass {
624+ final dynamic batidaceae;
625+ final dynamic brechites;
626+ final dynamic codespairer;
627+ final dynamic emery;
628+ final dynamic enervative;
629+ final dynamic excriminate;
630+ final dynamic goshenite;
631+ final dynamic grime;
632+ final dynamic gritten;
633+ final dynamic hectorly;
634+ final dynamic intermediation;
635+ final dynamic meeterly;
636+ final dynamic narraganset;
637+ final dynamic onymatic;
638+ final dynamic paddlecock;
639+ final dynamic thana;
640+ final dynamic thornily;
641+ final dynamic uckia;
642+ final dynamic unmettle;
643+ final dynamic vorticellid;
644+
645+ ChytridiaceaeClass({
646+ required this.batidaceae,
647+ required this.brechites,
648+ required this.codespairer,
649+ required this.emery,
650+ required this.enervative,
651+ required this.excriminate,
652+ required this.goshenite,
653+ required this.grime,
654+ required this.gritten,
655+ required this.hectorly,
656+ required this.intermediation,
657+ required this.meeterly,
658+ required this.narraganset,
659+ required this.onymatic,
660+ required this.paddlecock,
661+ required this.thana,
662+ required this.thornily,
663+ required this.uckia,
664+ required this.unmettle,
665+ required this.vorticellid,
666+ });
667+
668+ factory ChytridiaceaeClass.fromMap(Map<String, dynamic> json) => ChytridiaceaeClass(
669+ batidaceae: (json.containsKey("Batidaceae") ? json["Batidaceae"] : throw FormatException('Missing required property')),
670+ brechites: (json.containsKey("Brechites") ? json["Brechites"] : throw FormatException('Missing required property')),
671+ codespairer: (json.containsKey("codespairer") ? json["codespairer"] : throw FormatException('Missing required property')),
672+ emery: (json.containsKey("Emery") ? json["Emery"] : throw FormatException('Missing required property')),
673+ enervative: (json.containsKey("enervative") ? json["enervative"] : throw FormatException('Missing required property')),
674+ excriminate: (json.containsKey("excriminate") ? json["excriminate"] : throw FormatException('Missing required property')),
675+ goshenite: (json.containsKey("goshenite") ? json["goshenite"] : throw FormatException('Missing required property')),
676+ grime: (json.containsKey("grime") ? json["grime"] : throw FormatException('Missing required property')),
677+ gritten: (json.containsKey("gritten") ? json["gritten"] : throw FormatException('Missing required property')),
678+ hectorly: (json.containsKey("hectorly") ? json["hectorly"] : throw FormatException('Missing required property')),
679+ intermediation: (json.containsKey("intermediation") ? json["intermediation"] : throw FormatException('Missing required property')),
680+ meeterly: (json.containsKey("meeterly") ? json["meeterly"] : throw FormatException('Missing required property')),
681+ narraganset: (json.containsKey("Narraganset") ? json["Narraganset"] : throw FormatException('Missing required property')),
682+ onymatic: (json.containsKey("onymatic") ? json["onymatic"] : throw FormatException('Missing required property')),
683+ paddlecock: (json.containsKey("paddlecock") ? json["paddlecock"] : throw FormatException('Missing required property')),
684+ thana: (json.containsKey("thana") ? json["thana"] : throw FormatException('Missing required property')),
685+ thornily: (json.containsKey("thornily") ? json["thornily"] : throw FormatException('Missing required property')),
686+ uckia: (json.containsKey("uckia") ? json["uckia"] : throw FormatException('Missing required property')),
687+ unmettle: (json.containsKey("unmettle") ? json["unmettle"] : throw FormatException('Missing required property')),
688+ vorticellid: (json.containsKey("vorticellid") ? json["vorticellid"] : throw FormatException('Missing required property')),
689+ );
690+
691+ Map<String, dynamic> toMap() => {
692+ "Batidaceae": batidaceae,
693+ "Brechites": brechites,
694+ "codespairer": codespairer,
695+ "Emery": emery,
696+ "enervative": enervative,
697+ "excriminate": excriminate,
698+ "goshenite": goshenite,
699+ "grime": grime,
700+ "gritten": gritten,
701+ "hectorly": hectorly,
702+ "intermediation": intermediation,
703+ "meeterly": meeterly,
704+ "Narraganset": narraganset,
705+ "onymatic": onymatic,
706+ "paddlecock": paddlecock,
707+ "thana": thana,
708+ "thornily": thornily,
709+ "uckia": uckia,
710+ "unmettle": unmettle,
711+ "vorticellid": vorticellid,
712+ };
713+}
714+
715+class DiscordiaClass {
716+ final int? altaic;
717+ final int? amoristic;
718+ final int? blennophthalmia;
719+ final double? catharticalness;
720+ final int? chirotherium;
721+ final int? disciplinability;
722+ final String? disdiapason;
723+ final int? goofer;
724+ final bool? homocerc;
725+ final int? laryngograph;
726+ final int? leucitis;
727+ final int? lymphocyst;
728+ final int? microcosmology;
729+ final int? nauseation;
730+ final dynamic nonbookish;
731+ final int? patarin;
732+ final int? preliberal;
733+ final int? prettifier;
734+ final int? rangework;
735+ final int? redient;
736+ final int? subfusiform;
737+ final int? suicidical;
738+ final int? swow;
739+ final int? wastrel;
740+ final int? wingle;
741+
742+ DiscordiaClass({
743+ this.altaic,
744+ this.amoristic,
745+ this.blennophthalmia,
746+ this.catharticalness,
747+ this.chirotherium,
748+ this.disciplinability,
749+ this.disdiapason,
750+ this.goofer,
751+ this.homocerc,
752+ this.laryngograph,
753+ this.leucitis,
754+ this.lymphocyst,
755+ this.microcosmology,
756+ this.nauseation,
757+ this.nonbookish,
758+ this.patarin,
759+ this.preliberal,
760+ this.prettifier,
761+ this.rangework,
762+ this.redient,
763+ this.subfusiform,
764+ this.suicidical,
765+ this.swow,
766+ this.wastrel,
767+ this.wingle,
768+ });
769+
770+ factory DiscordiaClass.fromMap(Map<String, dynamic> json) => DiscordiaClass(
771+ altaic: json["Altaic"],
772+ amoristic: json["amoristic"],
773+ blennophthalmia: json["blennophthalmia"],
774+ catharticalness: json["catharticalness"]?.toDouble(),
775+ chirotherium: json["Chirotherium"],
776+ disciplinability: json["disciplinability"],
777+ disdiapason: json["disdiapason"],
778+ goofer: json["goofer"],
779+ homocerc: json["homocerc"],
780+ laryngograph: json["laryngograph"],
781+ leucitis: json["leucitis"],
782+ lymphocyst: json["lymphocyst"],
783+ microcosmology: json["microcosmology"],
784+ nauseation: json["nauseation"],
785+ nonbookish: json["nonbookish"],
786+ patarin: json["Patarin"],
787+ preliberal: json["preliberal"],
788+ prettifier: json["prettifier"],
789+ rangework: json["rangework"],
790+ redient: json["redient"],
791+ subfusiform: json["subfusiform"],
792+ suicidical: json["suicidical"],
793+ swow: json["swow"],
794+ wastrel: json["wastrel"],
795+ wingle: json["wingle"],
796+ );
797+
798+ Map<String, dynamic> toMap() => {
799+ "Altaic": altaic,
800+ "amoristic": amoristic,
801+ "blennophthalmia": blennophthalmia,
802+ "catharticalness": catharticalness,
803+ "Chirotherium": chirotherium,
804+ "disciplinability": disciplinability,
805+ "disdiapason": disdiapason,
806+ "goofer": goofer,
807+ "homocerc": homocerc,
808+ "laryngograph": laryngograph,
809+ "leucitis": leucitis,
810+ "lymphocyst": lymphocyst,
811+ "microcosmology": microcosmology,
812+ "nauseation": nauseation,
813+ "nonbookish": nonbookish,
814+ "Patarin": patarin,
815+ "preliberal": preliberal,
816+ "prettifier": prettifier,
817+ "rangework": rangework,
818+ "redient": redient,
819+ "subfusiform": subfusiform,
820+ "suicidical": suicidical,
821+ "swow": swow,
822+ "wastrel": wastrel,
823+ "wingle": wingle,
824+ };
825+}
826+
827+class GryphosaurusClass {
828+ final dynamic amissibility;
829+ final dynamic burushaski;
830+ final dynamic citronin;
831+ final dynamic coplaintiff;
832+ final dynamic disquisitionary;
833+ final dynamic enoplan;
834+ final dynamic faintness;
835+ final dynamic hebetomy;
836+ final dynamic islandry;
837+ final dynamic lameduck;
838+ final dynamic overbattle;
839+ final dynamic overinterested;
840+ final dynamic phrenologic;
841+ final dynamic rainband;
842+ final dynamic shiningly;
843+ final dynamic stamineous;
844+ final dynamic subscapularis;
845+ final dynamic tahami;
846+ final dynamic undaubed;
847+ final dynamic underntime;
848+
849+ GryphosaurusClass({
850+ required this.amissibility,
851+ required this.burushaski,
852+ required this.citronin,
853+ required this.coplaintiff,
854+ required this.disquisitionary,
855+ required this.enoplan,
856+ required this.faintness,
857+ required this.hebetomy,
858+ required this.islandry,
859+ required this.lameduck,
860+ required this.overbattle,
861+ required this.overinterested,
862+ required this.phrenologic,
863+ required this.rainband,
864+ required this.shiningly,
865+ required this.stamineous,
866+ required this.subscapularis,
867+ required this.tahami,
868+ required this.undaubed,
869+ required this.underntime,
870+ });
871+
872+ factory GryphosaurusClass.fromMap(Map<String, dynamic> json) => GryphosaurusClass(
873+ amissibility: (json.containsKey("amissibility") ? json["amissibility"] : throw FormatException('Missing required property')),
874+ burushaski: (json.containsKey("Burushaski") ? json["Burushaski"] : throw FormatException('Missing required property')),
875+ citronin: (json.containsKey("citronin") ? json["citronin"] : throw FormatException('Missing required property')),
876+ coplaintiff: (json.containsKey("coplaintiff") ? json["coplaintiff"] : throw FormatException('Missing required property')),
877+ disquisitionary: (json.containsKey("disquisitionary") ? json["disquisitionary"] : throw FormatException('Missing required property')),
878+ enoplan: (json.containsKey("enoplan") ? json["enoplan"] : throw FormatException('Missing required property')),
879+ faintness: (json.containsKey("faintness") ? json["faintness"] : throw FormatException('Missing required property')),
880+ hebetomy: (json.containsKey("hebetomy") ? json["hebetomy"] : throw FormatException('Missing required property')),
881+ islandry: (json.containsKey("islandry") ? json["islandry"] : throw FormatException('Missing required property')),
882+ lameduck: (json.containsKey("lameduck") ? json["lameduck"] : throw FormatException('Missing required property')),
883+ overbattle: (json.containsKey("overbattle") ? json["overbattle"] : throw FormatException('Missing required property')),
884+ overinterested: (json.containsKey("overinterested") ? json["overinterested"] : throw FormatException('Missing required property')),
885+ phrenologic: (json.containsKey("phrenologic") ? json["phrenologic"] : throw FormatException('Missing required property')),
886+ rainband: (json.containsKey("rainband") ? json["rainband"] : throw FormatException('Missing required property')),
887+ shiningly: (json.containsKey("shiningly") ? json["shiningly"] : throw FormatException('Missing required property')),
888+ stamineous: (json.containsKey("stamineous") ? json["stamineous"] : throw FormatException('Missing required property')),
889+ subscapularis: (json.containsKey("subscapularis") ? json["subscapularis"] : throw FormatException('Missing required property')),
890+ tahami: (json.containsKey("Tahami") ? json["Tahami"] : throw FormatException('Missing required property')),
891+ undaubed: (json.containsKey("undaubed") ? json["undaubed"] : throw FormatException('Missing required property')),
892+ underntime: (json.containsKey("underntime") ? json["underntime"] : throw FormatException('Missing required property')),
893+ );
894+
895+ Map<String, dynamic> toMap() => {
896+ "amissibility": amissibility,
897+ "Burushaski": burushaski,
898+ "citronin": citronin,
899+ "coplaintiff": coplaintiff,
900+ "disquisitionary": disquisitionary,
901+ "enoplan": enoplan,
902+ "faintness": faintness,
903+ "hebetomy": hebetomy,
904+ "islandry": islandry,
905+ "lameduck": lameduck,
906+ "overbattle": overbattle,
907+ "overinterested": overinterested,
908+ "phrenologic": phrenologic,
909+ "rainband": rainband,
910+ "shiningly": shiningly,
911+ "stamineous": stamineous,
912+ "subscapularis": subscapularis,
913+ "Tahami": tahami,
914+ "undaubed": undaubed,
915+ "underntime": underntime,
916+ };
917+}
918+
919+class LaviniaClass {
920+ final int? agitable;
921+ final int? asininity;
922+ final int? benefiter;
923+ final int? bronzelike;
924+ final double? catharticalness;
925+ final int? chirotherium;
926+ final int? cholesteatomatous;
927+ final int? deprivement;
928+ final String? disdiapason;
929+ final int? flippantness;
930+ final int? fogproof;
931+ final bool? homocerc;
932+ final int? merrymeeting;
933+ final dynamic nonbookish;
934+ final int? overcareful;
935+ final int? panaris;
936+ final int? preacceptance;
937+ final int? quinoxaline;
938+ final int? sig;
939+ final int? superconfusion;
940+ final int? tacana;
941+ final int? tillotter;
942+ final int? tranquillize;
943+ final int? unquestionable;
944+ final int? uproute;
945+
946+ LaviniaClass({
947+ this.agitable,
948+ this.asininity,
949+ this.benefiter,
950+ this.bronzelike,
951+ this.catharticalness,
952+ this.chirotherium,
953+ this.cholesteatomatous,
954+ this.deprivement,
955+ this.disdiapason,
956+ this.flippantness,
957+ this.fogproof,
958+ this.homocerc,
959+ this.merrymeeting,
960+ this.nonbookish,
961+ this.overcareful,
962+ this.panaris,
963+ this.preacceptance,
964+ this.quinoxaline,
965+ this.sig,
966+ this.superconfusion,
967+ this.tacana,
968+ this.tillotter,
969+ this.tranquillize,
970+ this.unquestionable,
971+ this.uproute,
972+ });
973+
974+ factory LaviniaClass.fromMap(Map<String, dynamic> json) => LaviniaClass(
975+ agitable: json["agitable"],
976+ asininity: json["asininity"],
977+ benefiter: json["benefiter"],
978+ bronzelike: json["bronzelike"],
979+ catharticalness: json["catharticalness"]?.toDouble(),
980+ chirotherium: json["Chirotherium"],
981+ cholesteatomatous: json["cholesteatomatous"],
982+ deprivement: json["deprivement"],
983+ disdiapason: json["disdiapason"],
984+ flippantness: json["flippantness"],
985+ fogproof: json["fogproof"],
986+ homocerc: json["homocerc"],
987+ merrymeeting: json["merrymeeting"],
988+ nonbookish: json["nonbookish"],
989+ overcareful: json["overcareful"],
990+ panaris: json["panaris"],
991+ preacceptance: json["preacceptance"],
992+ quinoxaline: json["quinoxaline"],
993+ sig: json["sig"],
994+ superconfusion: json["superconfusion"],
995+ tacana: json["Tacana"],
996+ tillotter: json["tillotter"],
997+ tranquillize: json["tranquillize"],
998+ unquestionable: json["unquestionable"],
999+ uproute: json["uproute"],
1000+ );
1001+
1002+ Map<String, dynamic> toMap() => {
1003+ "agitable": agitable,
1004+ "asininity": asininity,
1005+ "benefiter": benefiter,
1006+ "bronzelike": bronzelike,
1007+ "catharticalness": catharticalness,
1008+ "Chirotherium": chirotherium,
1009+ "cholesteatomatous": cholesteatomatous,
1010+ "deprivement": deprivement,
1011+ "disdiapason": disdiapason,
1012+ "flippantness": flippantness,
1013+ "fogproof": fogproof,
1014+ "homocerc": homocerc,
1015+ "merrymeeting": merrymeeting,
1016+ "nonbookish": nonbookish,
1017+ "overcareful": overcareful,
1018+ "panaris": panaris,
1019+ "preacceptance": preacceptance,
1020+ "quinoxaline": quinoxaline,
1021+ "sig": sig,
1022+ "superconfusion": superconfusion,
1023+ "Tacana": tacana,
1024+ "tillotter": tillotter,
1025+ "tranquillize": tranquillize,
1026+ "unquestionable": unquestionable,
1027+ "uproute": uproute,
1028+ };
1029+}
1030+
1031+class OskarClass {
1032+ final dynamic acrobates;
1033+ final dynamic beanshooter;
1034+ final dynamic bearhound;
1035+ final dynamic cayuga;
1036+ final dynamic guarneri;
1037+ final dynamic hypochondriacism;
1038+ final dynamic indication;
1039+ final dynamic jaculative;
1040+ final dynamic nagana;
1041+ final dynamic netherlandish;
1042+ final dynamic noctivagous;
1043+ final dynamic nonphysiological;
1044+ final dynamic praxis;
1045+ final dynamic provision;
1046+ final dynamic subterhuman;
1047+ final dynamic sunlit;
1048+ final dynamic syncraniate;
1049+ final dynamic teachment;
1050+ final dynamic unmutinous;
1051+ final dynamic unstoppable;
1052+
1053+ OskarClass({
1054+ required this.acrobates,
1055+ required this.beanshooter,
1056+ required this.bearhound,
1057+ required this.cayuga,
1058+ required this.guarneri,
1059+ required this.hypochondriacism,
1060+ required this.indication,
1061+ required this.jaculative,
1062+ required this.nagana,
1063+ required this.netherlandish,
1064+ required this.noctivagous,
1065+ required this.nonphysiological,
1066+ required this.praxis,
1067+ required this.provision,
1068+ required this.subterhuman,
1069+ required this.sunlit,
1070+ required this.syncraniate,
1071+ required this.teachment,
1072+ required this.unmutinous,
1073+ required this.unstoppable,
1074+ });
1075+
1076+ factory OskarClass.fromMap(Map<String, dynamic> json) => OskarClass(
1077+ acrobates: (json.containsKey("Acrobates") ? json["Acrobates"] : throw FormatException('Missing required property')),
1078+ beanshooter: (json.containsKey("beanshooter") ? json["beanshooter"] : throw FormatException('Missing required property')),
1079+ bearhound: (json.containsKey("bearhound") ? json["bearhound"] : throw FormatException('Missing required property')),
1080+ cayuga: (json.containsKey("Cayuga") ? json["Cayuga"] : throw FormatException('Missing required property')),
1081+ guarneri: (json.containsKey("guarneri") ? json["guarneri"] : throw FormatException('Missing required property')),
1082+ hypochondriacism: (json.containsKey("hypochondriacism") ? json["hypochondriacism"] : throw FormatException('Missing required property')),
1083+ indication: (json.containsKey("indication") ? json["indication"] : throw FormatException('Missing required property')),
1084+ jaculative: (json.containsKey("jaculative") ? json["jaculative"] : throw FormatException('Missing required property')),
1085+ nagana: (json.containsKey("nagana") ? json["nagana"] : throw FormatException('Missing required property')),
1086+ netherlandish: (json.containsKey("Netherlandish") ? json["Netherlandish"] : throw FormatException('Missing required property')),
1087+ noctivagous: (json.containsKey("noctivagous") ? json["noctivagous"] : throw FormatException('Missing required property')),
1088+ nonphysiological: (json.containsKey("nonphysiological") ? json["nonphysiological"] : throw FormatException('Missing required property')),
1089+ praxis: (json.containsKey("praxis") ? json["praxis"] : throw FormatException('Missing required property')),
1090+ provision: (json.containsKey("provision") ? json["provision"] : throw FormatException('Missing required property')),
1091+ subterhuman: (json.containsKey("subterhuman") ? json["subterhuman"] : throw FormatException('Missing required property')),
1092+ sunlit: (json.containsKey("sunlit") ? json["sunlit"] : throw FormatException('Missing required property')),
1093+ syncraniate: (json.containsKey("syncraniate") ? json["syncraniate"] : throw FormatException('Missing required property')),
1094+ teachment: (json.containsKey("teachment") ? json["teachment"] : throw FormatException('Missing required property')),
1095+ unmutinous: (json.containsKey("unmutinous") ? json["unmutinous"] : throw FormatException('Missing required property')),
1096+ unstoppable: (json.containsKey("unstoppable") ? json["unstoppable"] : throw FormatException('Missing required property')),
1097+ );
1098+
1099+ Map<String, dynamic> toMap() => {
1100+ "Acrobates": acrobates,
1101+ "beanshooter": beanshooter,
1102+ "bearhound": bearhound,
1103+ "Cayuga": cayuga,
1104+ "guarneri": guarneri,
1105+ "hypochondriacism": hypochondriacism,
1106+ "indication": indication,
1107+ "jaculative": jaculative,
1108+ "nagana": nagana,
1109+ "Netherlandish": netherlandish,
1110+ "noctivagous": noctivagous,
1111+ "nonphysiological": nonphysiological,
1112+ "praxis": praxis,
1113+ "provision": provision,
1114+ "subterhuman": subterhuman,
1115+ "sunlit": sunlit,
1116+ "syncraniate": syncraniate,
1117+ "teachment": teachment,
1118+ "unmutinous": unmutinous,
1119+ "unstoppable": unstoppable,
1120+ };
1121+}
Aswiftfinal-classes-true__struct-or-class-class--d3c62ec7414d / quicktype.swift+2,891 −0
@@ -0,0 +1,2891 @@
1+// This file was generated from JSON Schema using quicktype, do not modify it directly.
2+// To parse the JSON, add this file to your project and do:
3+//
4+// let topLevel = try TopLevel(json)
5+
6+import Foundation
7+
8+// MARK: - TopLevel
9+final class TopLevel: Codable {
10+ let abranchiata: [Abranchiata]
11+ let academe: [Academe]
12+ let acquirable: [Acquirable]
13+ let aerometry: [Aerometry]
14+ let alexin: [Alexin]
15+ let alleviate: [AlleviateElement]
16+ let amaas: [Amaa]
17+ let ambassage: [Ambassage]
18+ let amphithyron: [Amphithyron?]
19+ let andriana: [String?]
20+ let ankee: [AnkeeElement]
21+ let annihilator: [[String: Int?]?]
22+ let annulose: JSONNull?
23+ let ansarie: [AnsarieElement]
24+ let aphasia: [Aphasia]
25+ let asprawl: [Asprawl]
26+ let attractive: [Bool?]
27+ let barksome: [String: Int]
28+ let bedesman: [Bedesman]
29+ let belard: [Belard]
30+ let bocking: [Bocking]
31+ let brawlingly: [Brawlingly]
32+ let brookie: [Brookie]
33+ let bumboatman: [Bumboatman]
34+ let bystreet: [JSONNull?]
35+ let calaverite: [Calaverite]
36+ let catallactic: [Catallactic]
37+ let cemental: [Cemental]
38+ let chytridiaceae: [ChytridiaceaeElement]
39+ let discordia: [DiscordiaElement]
40+ let endomyces: [Endomyce]
41+ let epinephelidae: [Epinephelidae]
42+ let eupatorium: [Eupatorium]
43+ let gryphosaurus: [GryphosaurusElement]
44+ let koryak: [Koryak]
45+ let lavinia: [LaviniaElement]
46+ let oskar: [OskarElement]
47+ let rebecca: [RebeccaElement]
48+ let rhomboganoidei: [Rhomboganoidei]
49+ let rigsmal: Bool
50+ let ruellia: [Ruellia]
51+ let school: [School]
52+ let shakespearolater: [Shakespearolater]
53+ let svan: [Double]
54+ let wayao: [String: Double]
55+
56+ enum CodingKeys: String, CodingKey {
57+ case abranchiata = "Abranchiata"
58+ case academe = "academe"
59+ case acquirable = "acquirable"
60+ case aerometry = "aerometry"
61+ case alexin = "alexin"
62+ case alleviate = "alleviate"
63+ case amaas = "amaas"
64+ case ambassage = "ambassage"
65+ case amphithyron = "amphithyron"
66+ case andriana = "Andriana"
67+ case ankee = "ankee"
68+ case annihilator = "annihilator"
69+ case annulose = "annulose"
70+ case ansarie = "Ansarie"
71+ case aphasia = "aphasia"
72+ case asprawl = "asprawl"
73+ case attractive = "attractive"
74+ case barksome = "barksome"
75+ case bedesman = "bedesman"
76+ case belard = "belard"
77+ case bocking = "bocking"
78+ case brawlingly = "brawlingly"
79+ case brookie = "brookie"
80+ case bumboatman = "bumboatman"
81+ case bystreet = "bystreet"
82+ case calaverite = "calaverite"
83+ case catallactic = "catallactic"
84+ case cemental = "cemental"
85+ case chytridiaceae = "Chytridiaceae"
86+ case discordia = "Discordia"
87+ case endomyces = "Endomyces"
88+ case epinephelidae = "Epinephelidae"
89+ case eupatorium = "Eupatorium"
90+ case gryphosaurus = "Gryphosaurus"
91+ case koryak = "Koryak"
92+ case lavinia = "Lavinia"
93+ case oskar = "Oskar"
94+ case rebecca = "Rebecca"
95+ case rhomboganoidei = "Rhomboganoidei"
96+ case rigsmal = "Rigsmal"
97+ case ruellia = "Ruellia"
98+ case school = "School"
99+ case shakespearolater = "Shakespearolater"
100+ case svan = "Svan"
101+ case wayao = "Wayao"
102+ }
103+
104+ 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]) {
105+ self.abranchiata = abranchiata
106+ self.academe = academe
107+ self.acquirable = acquirable
108+ self.aerometry = aerometry
109+ self.alexin = alexin
110+ self.alleviate = alleviate
111+ self.amaas = amaas
112+ self.ambassage = ambassage
113+ self.amphithyron = amphithyron
114+ self.andriana = andriana
115+ self.ankee = ankee
116+ self.annihilator = annihilator
117+ self.annulose = annulose
118+ self.ansarie = ansarie
119+ self.aphasia = aphasia
120+ self.asprawl = asprawl
121+ self.attractive = attractive
122+ self.barksome = barksome
123+ self.bedesman = bedesman
124+ self.belard = belard
125+ self.bocking = bocking
126+ self.brawlingly = brawlingly
127+ self.brookie = brookie
128+ self.bumboatman = bumboatman
129+ self.bystreet = bystreet
130+ self.calaverite = calaverite
131+ self.catallactic = catallactic
132+ self.cemental = cemental
133+ self.chytridiaceae = chytridiaceae
134+ self.discordia = discordia
135+ self.endomyces = endomyces
136+ self.epinephelidae = epinephelidae
137+ self.eupatorium = eupatorium
138+ self.gryphosaurus = gryphosaurus
139+ self.koryak = koryak
140+ self.lavinia = lavinia
141+ self.oskar = oskar
142+ self.rebecca = rebecca
143+ self.rhomboganoidei = rhomboganoidei
144+ self.rigsmal = rigsmal
145+ self.ruellia = ruellia
146+ self.school = school
147+ self.shakespearolater = shakespearolater
148+ self.svan = svan
149+ self.wayao = wayao
150+ }
151+}
152+
153+// MARK: TopLevel convenience initializers and mutators
154+
155+extension TopLevel {
156+ convenience init(data: Data) throws {
157+ let me = try newJSONDecoder().decode(TopLevel.self, from: data)
158+ 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)
159+ }
160+
161+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
162+ guard let data = json.data(using: encoding) else {
163+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
164+ }
165+ try self.init(data: data)
166+ }
167+
168+ convenience init(fromURL url: URL) throws {
169+ try self.init(data: try Data(contentsOf: url))
170+ }
171+
172+ func with(
173+ abranchiata: [Abranchiata]? = nil,
174+ academe: [Academe]? = nil,
175+ acquirable: [Acquirable]? = nil,
176+ aerometry: [Aerometry]? = nil,
177+ alexin: [Alexin]? = nil,
178+ alleviate: [AlleviateElement]? = nil,
179+ amaas: [Amaa]? = nil,
180+ ambassage: [Ambassage]? = nil,
181+ amphithyron: [Amphithyron?]? = nil,
182+ andriana: [String?]? = nil,
183+ ankee: [AnkeeElement]? = nil,
184+ annihilator: [[String: Int?]?]? = nil,
185+ annulose: JSONNull?? = nil,
186+ ansarie: [AnsarieElement]? = nil,
187+ aphasia: [Aphasia]? = nil,
188+ asprawl: [Asprawl]? = nil,
189+ attractive: [Bool?]? = nil,
190+ barksome: [String: Int]? = nil,
191+ bedesman: [Bedesman]? = nil,
192+ belard: [Belard]? = nil,
193+ bocking: [Bocking]? = nil,
194+ brawlingly: [Brawlingly]? = nil,
195+ brookie: [Brookie]? = nil,
196+ bumboatman: [Bumboatman]? = nil,
197+ bystreet: [JSONNull?]? = nil,
198+ calaverite: [Calaverite]? = nil,
199+ catallactic: [Catallactic]? = nil,
200+ cemental: [Cemental]? = nil,
201+ chytridiaceae: [ChytridiaceaeElement]? = nil,
202+ discordia: [DiscordiaElement]? = nil,
203+ endomyces: [Endomyce]? = nil,
204+ epinephelidae: [Epinephelidae]? = nil,
205+ eupatorium: [Eupatorium]? = nil,
206+ gryphosaurus: [GryphosaurusElement]? = nil,
207+ koryak: [Koryak]? = nil,
208+ lavinia: [LaviniaElement]? = nil,
209+ oskar: [OskarElement]? = nil,
210+ rebecca: [RebeccaElement]? = nil,
211+ rhomboganoidei: [Rhomboganoidei]? = nil,
212+ rigsmal: Bool? = nil,
213+ ruellia: [Ruellia]? = nil,
214+ school: [School]? = nil,
215+ shakespearolater: [Shakespearolater]? = nil,
216+ svan: [Double]? = nil,
217+ wayao: [String: Double]? = nil
218+ ) -> TopLevel {
219+ return TopLevel(
220+ abranchiata: abranchiata ?? self.abranchiata,
221+ academe: academe ?? self.academe,
222+ acquirable: acquirable ?? self.acquirable,
223+ aerometry: aerometry ?? self.aerometry,
224+ alexin: alexin ?? self.alexin,
225+ alleviate: alleviate ?? self.alleviate,
226+ amaas: amaas ?? self.amaas,
227+ ambassage: ambassage ?? self.ambassage,
228+ amphithyron: amphithyron ?? self.amphithyron,
229+ andriana: andriana ?? self.andriana,
230+ ankee: ankee ?? self.ankee,
231+ annihilator: annihilator ?? self.annihilator,
232+ annulose: annulose ?? self.annulose,
233+ ansarie: ansarie ?? self.ansarie,
234+ aphasia: aphasia ?? self.aphasia,
235+ asprawl: asprawl ?? self.asprawl,
236+ attractive: attractive ?? self.attractive,
237+ barksome: barksome ?? self.barksome,
238+ bedesman: bedesman ?? self.bedesman,
239+ belard: belard ?? self.belard,
240+ bocking: bocking ?? self.bocking,
241+ brawlingly: brawlingly ?? self.brawlingly,
242+ brookie: brookie ?? self.brookie,
243+ bumboatman: bumboatman ?? self.bumboatman,
244+ bystreet: bystreet ?? self.bystreet,
245+ calaverite: calaverite ?? self.calaverite,
246+ catallactic: catallactic ?? self.catallactic,
247+ cemental: cemental ?? self.cemental,
248+ chytridiaceae: chytridiaceae ?? self.chytridiaceae,
249+ discordia: discordia ?? self.discordia,
250+ endomyces: endomyces ?? self.endomyces,
251+ epinephelidae: epinephelidae ?? self.epinephelidae,
252+ eupatorium: eupatorium ?? self.eupatorium,
253+ gryphosaurus: gryphosaurus ?? self.gryphosaurus,
254+ koryak: koryak ?? self.koryak,
255+ lavinia: lavinia ?? self.lavinia,
256+ oskar: oskar ?? self.oskar,
257+ rebecca: rebecca ?? self.rebecca,
258+ rhomboganoidei: rhomboganoidei ?? self.rhomboganoidei,
259+ rigsmal: rigsmal ?? self.rigsmal,
260+ ruellia: ruellia ?? self.ruellia,
261+ school: school ?? self.school,
262+ shakespearolater: shakespearolater ?? self.shakespearolater,
263+ svan: svan ?? self.svan,
264+ wayao: wayao ?? self.wayao
265+ )
266+ }
267+
268+ func jsonData() throws -> Data {
269+ return try newJSONEncoder().encode(self)
270+ }
271+
272+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
273+ return String(data: try self.jsonData(), encoding: encoding)
274+ }
275+}
276+
277+enum Abranchiata: Codable {
278+ case integer(Int)
279+ case integerArray([Int])
280+ case null
281+
282+ init(from decoder: Decoder) throws {
283+ let container = try decoder.singleValueContainer()
284+ if let x = try? container.decode(Int.self) {
285+ self = .integer(x)
286+ return
287+ }
288+ if let x = try? container.decode([Int].self) {
289+ self = .integerArray(x)
290+ return
291+ }
292+ if container.decodeNil() {
293+ self = .null
294+ return
295+ }
296+ throw DecodingError.typeMismatch(Abranchiata.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Abranchiata"))
297+ }
298+
299+ func encode(to encoder: Encoder) throws {
300+ var container = encoder.singleValueContainer()
301+ switch self {
302+ case .integer(let x):
303+ try container.encode(x)
304+ case .integerArray(let x):
305+ try container.encode(x)
306+ case .null:
307+ try container.encodeNil()
308+ }
309+ }
310+}
311+
312+enum Academe: Codable {
313+ case integer(Int)
314+ case integerArray([Int])
315+ case integerMap([String: Int])
316+
317+ init(from decoder: Decoder) throws {
318+ let container = try decoder.singleValueContainer()
319+ if let x = try? container.decode(Int.self) {
320+ self = .integer(x)
321+ return
322+ }
323+ if let x = try? container.decode([Int].self) {
324+ self = .integerArray(x)
325+ return
326+ }
327+ if let x = try? container.decode([String: Int].self) {
328+ self = .integerMap(x)
329+ return
330+ }
331+ throw DecodingError.typeMismatch(Academe.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Academe"))
332+ }
333+
334+ func encode(to encoder: Encoder) throws {
335+ var container = encoder.singleValueContainer()
336+ switch self {
337+ case .integer(let x):
338+ try container.encode(x)
339+ case .integerArray(let x):
340+ try container.encode(x)
341+ case .integerMap(let x):
342+ try container.encode(x)
343+ }
344+ }
345+}
346+
347+enum Acquirable: Codable {
348+ case integerMap([String: Int])
349+ case unionArray([Int?])
350+
351+ init(from decoder: Decoder) throws {
352+ let container = try decoder.singleValueContainer()
353+ if let x = try? container.decode([Int?].self) {
354+ self = .unionArray(x)
355+ return
356+ }
357+ if let x = try? container.decode([String: Int].self) {
358+ self = .integerMap(x)
359+ return
360+ }
361+ throw DecodingError.typeMismatch(Acquirable.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Acquirable"))
362+ }
363+
364+ func encode(to encoder: Encoder) throws {
365+ var container = encoder.singleValueContainer()
366+ switch self {
367+ case .integerMap(let x):
368+ try container.encode(x)
369+ case .unionArray(let x):
370+ try container.encode(x)
371+ }
372+ }
373+}
374+
375+enum Aerometry: Codable {
376+ case bool(Bool)
377+ case double(Double)
378+
379+ init(from decoder: Decoder) throws {
380+ let container = try decoder.singleValueContainer()
381+ if let x = try? container.decode(Bool.self) {
382+ self = .bool(x)
383+ return
384+ }
385+ if let x = try? container.decode(Double.self) {
386+ self = .double(x)
387+ return
388+ }
389+ throw DecodingError.typeMismatch(Aerometry.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Aerometry"))
390+ }
391+
392+ func encode(to encoder: Encoder) throws {
393+ var container = encoder.singleValueContainer()
394+ switch self {
395+ case .bool(let x):
396+ try container.encode(x)
397+ case .double(let x):
398+ try container.encode(x)
399+ }
400+ }
401+}
402+
403+enum Alexin: Codable {
404+ case bool(Bool)
405+ case integerArray([Int])
406+
407+ init(from decoder: Decoder) throws {
408+ let container = try decoder.singleValueContainer()
409+ if let x = try? container.decode(Bool.self) {
410+ self = .bool(x)
411+ return
412+ }
413+ if let x = try? container.decode([Int].self) {
414+ self = .integerArray(x)
415+ return
416+ }
417+ throw DecodingError.typeMismatch(Alexin.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Alexin"))
418+ }
419+
420+ func encode(to encoder: Encoder) throws {
421+ var container = encoder.singleValueContainer()
422+ switch self {
423+ case .bool(let x):
424+ try container.encode(x)
425+ case .integerArray(let x):
426+ try container.encode(x)
427+ }
428+ }
429+}
430+
431+enum AlleviateElement: Codable {
432+ case alleviateClass(AlleviateClass)
433+ case unionArray([Int?])
434+
435+ init(from decoder: Decoder) throws {
436+ let container = try decoder.singleValueContainer()
437+ if let x = try? container.decode([Int?].self) {
438+ self = .unionArray(x)
439+ return
440+ }
441+ if let x = try? container.decode(AlleviateClass.self) {
442+ self = .alleviateClass(x)
443+ return
444+ }
445+ throw DecodingError.typeMismatch(AlleviateElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for AlleviateElement"))
446+ }
447+
448+ func encode(to encoder: Encoder) throws {
449+ var container = encoder.singleValueContainer()
450+ switch self {
451+ case .alleviateClass(let x):
452+ try container.encode(x)
453+ case .unionArray(let x):
454+ try container.encode(x)
455+ }
456+ }
457+}
458+
459+// MARK: - AlleviateClass
460+final class AlleviateClass: Codable {
461+ let apriori: JSONNull?
462+ let beggarer: JSONNull?
463+ let brokenheartedly: JSONNull?
464+ let debilitation: JSONNull?
465+ let frike: JSONNull?
466+ let gastrolith: JSONNull?
467+ let hulsean: JSONNull?
468+ let orthocentric: JSONNull?
469+ let petaly: JSONNull?
470+ let probudgeting: JSONNull?
471+ let reacquire: JSONNull?
472+ let scow: JSONNull?
473+ let shutoff: JSONNull?
474+ let subcontiguous: JSONNull?
475+ let suffumigate: JSONNull?
476+ let transformable: JSONNull?
477+ let uncoroneted: JSONNull?
478+ let unparking: JSONNull?
479+ let unvarnishedness: JSONNull?
480+ let wherewithal: JSONNull?
481+
482+ enum CodingKeys: String, CodingKey {
483+ case apriori = "apriori"
484+ case beggarer = "beggarer"
485+ case brokenheartedly = "brokenheartedly"
486+ case debilitation = "debilitation"
487+ case frike = "frike"
488+ case gastrolith = "gastrolith"
489+ case hulsean = "Hulsean"
490+ case orthocentric = "orthocentric"
491+ case petaly = "petaly"
492+ case probudgeting = "probudgeting"
493+ case reacquire = "reacquire"
494+ case scow = "scow"
495+ case shutoff = "shutoff"
496+ case subcontiguous = "subcontiguous"
497+ case suffumigate = "suffumigate"
498+ case transformable = "transformable"
499+ case uncoroneted = "uncoroneted"
500+ case unparking = "unparking"
501+ case unvarnishedness = "unvarnishedness"
502+ case wherewithal = "wherewithal"
503+ }
504+
505+ 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?) {
506+ self.apriori = apriori
507+ self.beggarer = beggarer
508+ self.brokenheartedly = brokenheartedly
509+ self.debilitation = debilitation
510+ self.frike = frike
511+ self.gastrolith = gastrolith
512+ self.hulsean = hulsean
513+ self.orthocentric = orthocentric
514+ self.petaly = petaly
515+ self.probudgeting = probudgeting
516+ self.reacquire = reacquire
517+ self.scow = scow
518+ self.shutoff = shutoff
519+ self.subcontiguous = subcontiguous
520+ self.suffumigate = suffumigate
521+ self.transformable = transformable
522+ self.uncoroneted = uncoroneted
523+ self.unparking = unparking
524+ self.unvarnishedness = unvarnishedness
525+ self.wherewithal = wherewithal
526+ }
527+}
528+
529+// MARK: AlleviateClass convenience initializers and mutators
530+
531+extension AlleviateClass {
532+ convenience init(data: Data) throws {
533+ let me = try newJSONDecoder().decode(AlleviateClass.self, from: data)
534+ 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)
535+ }
536+
537+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
538+ guard let data = json.data(using: encoding) else {
539+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
540+ }
541+ try self.init(data: data)
542+ }
543+
544+ convenience init(fromURL url: URL) throws {
545+ try self.init(data: try Data(contentsOf: url))
546+ }
547+
548+ func with(
549+ apriori: JSONNull?? = nil,
550+ beggarer: JSONNull?? = nil,
551+ brokenheartedly: JSONNull?? = nil,
552+ debilitation: JSONNull?? = nil,
553+ frike: JSONNull?? = nil,
554+ gastrolith: JSONNull?? = nil,
555+ hulsean: JSONNull?? = nil,
556+ orthocentric: JSONNull?? = nil,
557+ petaly: JSONNull?? = nil,
558+ probudgeting: JSONNull?? = nil,
559+ reacquire: JSONNull?? = nil,
560+ scow: JSONNull?? = nil,
561+ shutoff: JSONNull?? = nil,
562+ subcontiguous: JSONNull?? = nil,
563+ suffumigate: JSONNull?? = nil,
564+ transformable: JSONNull?? = nil,
565+ uncoroneted: JSONNull?? = nil,
566+ unparking: JSONNull?? = nil,
567+ unvarnishedness: JSONNull?? = nil,
568+ wherewithal: JSONNull?? = nil
569+ ) -> AlleviateClass {
570+ return AlleviateClass(
571+ apriori: apriori ?? self.apriori,
572+ beggarer: beggarer ?? self.beggarer,
573+ brokenheartedly: brokenheartedly ?? self.brokenheartedly,
574+ debilitation: debilitation ?? self.debilitation,
575+ frike: frike ?? self.frike,
576+ gastrolith: gastrolith ?? self.gastrolith,
577+ hulsean: hulsean ?? self.hulsean,
578+ orthocentric: orthocentric ?? self.orthocentric,
579+ petaly: petaly ?? self.petaly,
580+ probudgeting: probudgeting ?? self.probudgeting,
581+ reacquire: reacquire ?? self.reacquire,
582+ scow: scow ?? self.scow,
583+ shutoff: shutoff ?? self.shutoff,
584+ subcontiguous: subcontiguous ?? self.subcontiguous,
585+ suffumigate: suffumigate ?? self.suffumigate,
586+ transformable: transformable ?? self.transformable,
587+ uncoroneted: uncoroneted ?? self.uncoroneted,
588+ unparking: unparking ?? self.unparking,
589+ unvarnishedness: unvarnishedness ?? self.unvarnishedness,
590+ wherewithal: wherewithal ?? self.wherewithal
591+ )
592+ }
593+
594+ func jsonData() throws -> Data {
595+ return try newJSONEncoder().encode(self)
596+ }
597+
598+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
599+ return String(data: try self.jsonData(), encoding: encoding)
600+ }
601+}
602+
603+enum Amaa: Codable {
604+ case bool(Bool)
605+ case integer(Int)
606+ case rebecca(Rebecca)
607+
608+ init(from decoder: Decoder) throws {
609+ let container = try decoder.singleValueContainer()
610+ if let x = try? container.decode(Bool.self) {
611+ self = .bool(x)
612+ return
613+ }
614+ if let x = try? container.decode(Int.self) {
615+ self = .integer(x)
616+ return
617+ }
618+ if let x = try? container.decode(Rebecca.self) {
619+ self = .rebecca(x)
620+ return
621+ }
622+ throw DecodingError.typeMismatch(Amaa.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Amaa"))
623+ }
624+
625+ func encode(to encoder: Encoder) throws {
626+ var container = encoder.singleValueContainer()
627+ switch self {
628+ case .bool(let x):
629+ try container.encode(x)
630+ case .integer(let x):
631+ try container.encode(x)
632+ case .rebecca(let x):
633+ try container.encode(x)
634+ }
635+ }
636+}
637+
638+// MARK: - Rebecca
639+final class Rebecca: Codable {
640+ let catharticalness: Double
641+ let chirotherium: Int
642+ let disdiapason: String
643+ let homocerc: Bool
644+ let nonbookish: JSONNull?
645+
646+ enum CodingKeys: String, CodingKey {
647+ case catharticalness = "catharticalness"
648+ case chirotherium = "Chirotherium"
649+ case disdiapason = "disdiapason"
650+ case homocerc = "homocerc"
651+ case nonbookish = "nonbookish"
652+ }
653+
654+ init(catharticalness: Double, chirotherium: Int, disdiapason: String, homocerc: Bool, nonbookish: JSONNull?) {
655+ self.catharticalness = catharticalness
656+ self.chirotherium = chirotherium
657+ self.disdiapason = disdiapason
658+ self.homocerc = homocerc
659+ self.nonbookish = nonbookish
660+ }
661+}
662+
663+// MARK: Rebecca convenience initializers and mutators
664+
665+extension Rebecca {
666+ convenience init(data: Data) throws {
667+ let me = try newJSONDecoder().decode(Rebecca.self, from: data)
668+ self.init(catharticalness: me.catharticalness, chirotherium: me.chirotherium, disdiapason: me.disdiapason, homocerc: me.homocerc, nonbookish: me.nonbookish)
669+ }
670+
671+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
672+ guard let data = json.data(using: encoding) else {
673+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
674+ }
675+ try self.init(data: data)
676+ }
677+
678+ convenience init(fromURL url: URL) throws {
679+ try self.init(data: try Data(contentsOf: url))
680+ }
681+
682+ func with(
683+ catharticalness: Double? = nil,
684+ chirotherium: Int? = nil,
685+ disdiapason: String? = nil,
686+ homocerc: Bool? = nil,
687+ nonbookish: JSONNull?? = nil
688+ ) -> Rebecca {
689+ return Rebecca(
690+ catharticalness: catharticalness ?? self.catharticalness,
691+ chirotherium: chirotherium ?? self.chirotherium,
692+ disdiapason: disdiapason ?? self.disdiapason,
693+ homocerc: homocerc ?? self.homocerc,
694+ nonbookish: nonbookish ?? self.nonbookish
695+ )
696+ }
697+
698+ func jsonData() throws -> Data {
699+ return try newJSONEncoder().encode(self)
700+ }
701+
702+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
703+ return String(data: try self.jsonData(), encoding: encoding)
704+ }
705+}
706+
707+enum Ambassage: Codable {
708+ case nullArray([JSONNull?])
709+ case string(String)
710+
711+ init(from decoder: Decoder) throws {
712+ let container = try decoder.singleValueContainer()
713+ if let x = try? container.decode([JSONNull?].self) {
714+ self = .nullArray(x)
715+ return
716+ }
717+ if let x = try? container.decode(String.self) {
718+ self = .string(x)
719+ return
720+ }
721+ throw DecodingError.typeMismatch(Ambassage.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Ambassage"))
722+ }
723+
724+ func encode(to encoder: Encoder) throws {
725+ var container = encoder.singleValueContainer()
726+ switch self {
727+ case .nullArray(let x):
728+ try container.encode(x)
729+ case .string(let x):
730+ try container.encode(x)
731+ }
732+ }
733+}
734+
735+// MARK: - Amphithyron
736+final class Amphithyron: Codable {
737+ let akroasis: Int?
738+ let antiphonical: Int?
739+ let basebred: Int?
740+ let catharticalness: Double?
741+ let chirotherium: Int?
742+ let conductometric: Int?
743+ let disdiapason: String?
744+ let ensilation: Int?
745+ let eyebolt: Int?
746+ let fistulated: Int?
747+ let heteropod: Int?
748+ let homocerc: Bool?
749+ let juniperus: Int?
750+ let labyrinthically: Int?
751+ let martyrization: Int?
752+ let mispolicy: Int?
753+ let multipara: Int?
754+ let nazirite: Int?
755+ let nonbookish: JSONNull?
756+ let possessorial: Int?
757+ let shamed: Int?
758+ let shelfworn: Int?
759+ let stagnum: Int?
760+ let those: Int?
761+ let undecimal: Int?
762+
763+ enum CodingKeys: String, CodingKey {
764+ case akroasis = "akroasis"
765+ case antiphonical = "antiphonical"
766+ case basebred = "basebred"
767+ case catharticalness = "catharticalness"
768+ case chirotherium = "Chirotherium"
769+ case conductometric = "conductometric"
770+ case disdiapason = "disdiapason"
771+ case ensilation = "ensilation"
772+ case eyebolt = "eyebolt"
773+ case fistulated = "fistulated"
774+ case heteropod = "heteropod"
775+ case homocerc = "homocerc"
776+ case juniperus = "Juniperus"
777+ case labyrinthically = "labyrinthically"
778+ case martyrization = "martyrization"
779+ case mispolicy = "mispolicy"
780+ case multipara = "multipara"
781+ case nazirite = "Nazirite"
782+ case nonbookish = "nonbookish"
783+ case possessorial = "possessorial"
784+ case shamed = "shamed"
785+ case shelfworn = "shelfworn"
786+ case stagnum = "stagnum"
787+ case those = "Those"
788+ case undecimal = "undecimal"
789+ }
790+
791+ 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?) {
792+ self.akroasis = akroasis
793+ self.antiphonical = antiphonical
794+ self.basebred = basebred
795+ self.catharticalness = catharticalness
796+ self.chirotherium = chirotherium
797+ self.conductometric = conductometric
798+ self.disdiapason = disdiapason
799+ self.ensilation = ensilation
800+ self.eyebolt = eyebolt
801+ self.fistulated = fistulated
802+ self.heteropod = heteropod
803+ self.homocerc = homocerc
804+ self.juniperus = juniperus
805+ self.labyrinthically = labyrinthically
806+ self.martyrization = martyrization
807+ self.mispolicy = mispolicy
808+ self.multipara = multipara
809+ self.nazirite = nazirite
810+ self.nonbookish = nonbookish
811+ self.possessorial = possessorial
812+ self.shamed = shamed
813+ self.shelfworn = shelfworn
814+ self.stagnum = stagnum
815+ self.those = those
816+ self.undecimal = undecimal
817+ }
818+}
819+
820+// MARK: Amphithyron convenience initializers and mutators
821+
822+extension Amphithyron {
823+ convenience init(data: Data) throws {
824+ let me = try newJSONDecoder().decode(Amphithyron.self, from: data)
825+ 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)
826+ }
827+
828+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
829+ guard let data = json.data(using: encoding) else {
830+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
831+ }
832+ try self.init(data: data)
833+ }
834+
835+ convenience init(fromURL url: URL) throws {
836+ try self.init(data: try Data(contentsOf: url))
837+ }
838+
839+ func with(
840+ akroasis: Int?? = nil,
841+ antiphonical: Int?? = nil,
842+ basebred: Int?? = nil,
843+ catharticalness: Double?? = nil,
844+ chirotherium: Int?? = nil,
845+ conductometric: Int?? = nil,
846+ disdiapason: String?? = nil,
847+ ensilation: Int?? = nil,
848+ eyebolt: Int?? = nil,
849+ fistulated: Int?? = nil,
850+ heteropod: Int?? = nil,
851+ homocerc: Bool?? = nil,
852+ juniperus: Int?? = nil,
853+ labyrinthically: Int?? = nil,
854+ martyrization: Int?? = nil,
855+ mispolicy: Int?? = nil,
856+ multipara: Int?? = nil,
857+ nazirite: Int?? = nil,
858+ nonbookish: JSONNull?? = nil,
859+ possessorial: Int?? = nil,
860+ shamed: Int?? = nil,
861+ shelfworn: Int?? = nil,
862+ stagnum: Int?? = nil,
863+ those: Int?? = nil,
864+ undecimal: Int?? = nil
865+ ) -> Amphithyron {
866+ return Amphithyron(
867+ akroasis: akroasis ?? self.akroasis,
868+ antiphonical: antiphonical ?? self.antiphonical,
869+ basebred: basebred ?? self.basebred,
870+ catharticalness: catharticalness ?? self.catharticalness,
871+ chirotherium: chirotherium ?? self.chirotherium,
872+ conductometric: conductometric ?? self.conductometric,
873+ disdiapason: disdiapason ?? self.disdiapason,
874+ ensilation: ensilation ?? self.ensilation,
875+ eyebolt: eyebolt ?? self.eyebolt,
876+ fistulated: fistulated ?? self.fistulated,
877+ heteropod: heteropod ?? self.heteropod,
878+ homocerc: homocerc ?? self.homocerc,
879+ juniperus: juniperus ?? self.juniperus,
880+ labyrinthically: labyrinthically ?? self.labyrinthically,
881+ martyrization: martyrization ?? self.martyrization,
882+ mispolicy: mispolicy ?? self.mispolicy,
883+ multipara: multipara ?? self.multipara,
884+ nazirite: nazirite ?? self.nazirite,
885+ nonbookish: nonbookish ?? self.nonbookish,
886+ possessorial: possessorial ?? self.possessorial,
887+ shamed: shamed ?? self.shamed,
888+ shelfworn: shelfworn ?? self.shelfworn,
889+ stagnum: stagnum ?? self.stagnum,
890+ those: those ?? self.those,
891+ undecimal: undecimal ?? self.undecimal
892+ )
893+ }
894+
895+ func jsonData() throws -> Data {
896+ return try newJSONEncoder().encode(self)
897+ }
898+
899+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
900+ return String(data: try self.jsonData(), encoding: encoding)
901+ }
902+}
903+
904+enum AnkeeElement: Codable {
905+ case ankeeClass(AnkeeClass)
906+ case integer(Int)
907+ case integerArray([Int])
908+
909+ init(from decoder: Decoder) throws {
910+ let container = try decoder.singleValueContainer()
911+ if let x = try? container.decode(Int.self) {
912+ self = .integer(x)
913+ return
914+ }
915+ if let x = try? container.decode([Int].self) {
916+ self = .integerArray(x)
917+ return
918+ }
919+ if let x = try? container.decode(AnkeeClass.self) {
920+ self = .ankeeClass(x)
921+ return
922+ }
923+ throw DecodingError.typeMismatch(AnkeeElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for AnkeeElement"))
924+ }
925+
926+ func encode(to encoder: Encoder) throws {
927+ var container = encoder.singleValueContainer()
928+ switch self {
929+ case .ankeeClass(let x):
930+ try container.encode(x)
931+ case .integer(let x):
932+ try container.encode(x)
933+ case .integerArray(let x):
934+ try container.encode(x)
935+ }
936+ }
937+}
938+
939+// MARK: - AnkeeClass
940+final class AnkeeClass: Codable {
941+ let anomoean: JSONNull?
942+ let barleyhood: JSONNull?
943+ let befriender: JSONNull?
944+ let brutishness: JSONNull?
945+ let cephalalgy: JSONNull?
946+ let cirurgian: JSONNull?
947+ let conventionally: JSONNull?
948+ let jackshay: JSONNull?
949+ let milammeter: JSONNull?
950+ let naja: JSONNull?
951+ let ombrological: JSONNull?
952+ let phonasthenia: JSONNull?
953+ let retrievableness: JSONNull?
954+ let snakily: JSONNull?
955+ let swot: JSONNull?
956+ let tartlet: JSONNull?
957+ let thiofuran: JSONNull?
958+ let tracheophone: JSONNull?
959+ let tuglike: JSONNull?
960+ let unscratchingly: JSONNull?
961+
962+ enum CodingKeys: String, CodingKey {
963+ case anomoean = "Anomoean"
964+ case barleyhood = "barleyhood"
965+ case befriender = "befriender"
966+ case brutishness = "brutishness"
967+ case cephalalgy = "cephalalgy"
968+ case cirurgian = "cirurgian"
969+ case conventionally = "conventionally"
970+ case jackshay = "jackshay"
971+ case milammeter = "milammeter"
972+ case naja = "Naja"
973+ case ombrological = "ombrological"
974+ case phonasthenia = "phonasthenia"
975+ case retrievableness = "retrievableness"
976+ case snakily = "snakily"
977+ case swot = "swot"
978+ case tartlet = "tartlet"
979+ case thiofuran = "thiofuran"
980+ case tracheophone = "tracheophone"
981+ case tuglike = "tuglike"
982+ case unscratchingly = "unscratchingly"
983+ }
984+
985+ 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?) {
986+ self.anomoean = anomoean
987+ self.barleyhood = barleyhood
988+ self.befriender = befriender
989+ self.brutishness = brutishness
990+ self.cephalalgy = cephalalgy
991+ self.cirurgian = cirurgian
992+ self.conventionally = conventionally
993+ self.jackshay = jackshay
994+ self.milammeter = milammeter
995+ self.naja = naja
996+ self.ombrological = ombrological
997+ self.phonasthenia = phonasthenia
998+ self.retrievableness = retrievableness
999+ self.snakily = snakily
1000+ self.swot = swot
1001+ self.tartlet = tartlet
1002+ self.thiofuran = thiofuran
1003+ self.tracheophone = tracheophone
1004+ self.tuglike = tuglike
1005+ self.unscratchingly = unscratchingly
1006+ }
1007+}
1008+
1009+// MARK: AnkeeClass convenience initializers and mutators
1010+
1011+extension AnkeeClass {
1012+ convenience init(data: Data) throws {
1013+ let me = try newJSONDecoder().decode(AnkeeClass.self, from: data)
1014+ 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)
1015+ }
1016+
1017+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1018+ guard let data = json.data(using: encoding) else {
1019+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1020+ }
1021+ try self.init(data: data)
1022+ }
1023+
1024+ convenience init(fromURL url: URL) throws {
1025+ try self.init(data: try Data(contentsOf: url))
1026+ }
1027+
1028+ func with(
1029+ anomoean: JSONNull?? = nil,
1030+ barleyhood: JSONNull?? = nil,
1031+ befriender: JSONNull?? = nil,
1032+ brutishness: JSONNull?? = nil,
1033+ cephalalgy: JSONNull?? = nil,
1034+ cirurgian: JSONNull?? = nil,
1035+ conventionally: JSONNull?? = nil,
1036+ jackshay: JSONNull?? = nil,
1037+ milammeter: JSONNull?? = nil,
1038+ naja: JSONNull?? = nil,
1039+ ombrological: JSONNull?? = nil,
1040+ phonasthenia: JSONNull?? = nil,
1041+ retrievableness: JSONNull?? = nil,
1042+ snakily: JSONNull?? = nil,
1043+ swot: JSONNull?? = nil,
1044+ tartlet: JSONNull?? = nil,
1045+ thiofuran: JSONNull?? = nil,
1046+ tracheophone: JSONNull?? = nil,
1047+ tuglike: JSONNull?? = nil,
1048+ unscratchingly: JSONNull?? = nil
1049+ ) -> AnkeeClass {
1050+ return AnkeeClass(
1051+ anomoean: anomoean ?? self.anomoean,
1052+ barleyhood: barleyhood ?? self.barleyhood,
1053+ befriender: befriender ?? self.befriender,
1054+ brutishness: brutishness ?? self.brutishness,
1055+ cephalalgy: cephalalgy ?? self.cephalalgy,
1056+ cirurgian: cirurgian ?? self.cirurgian,
1057+ conventionally: conventionally ?? self.conventionally,
1058+ jackshay: jackshay ?? self.jackshay,
1059+ milammeter: milammeter ?? self.milammeter,
1060+ naja: naja ?? self.naja,
1061+ ombrological: ombrological ?? self.ombrological,
1062+ phonasthenia: phonasthenia ?? self.phonasthenia,
1063+ retrievableness: retrievableness ?? self.retrievableness,
1064+ snakily: snakily ?? self.snakily,
1065+ swot: swot ?? self.swot,
1066+ tartlet: tartlet ?? self.tartlet,
1067+ thiofuran: thiofuran ?? self.thiofuran,
1068+ tracheophone: tracheophone ?? self.tracheophone,
1069+ tuglike: tuglike ?? self.tuglike,
1070+ unscratchingly: unscratchingly ?? self.unscratchingly
1071+ )
1072+ }
1073+
1074+ func jsonData() throws -> Data {
1075+ return try newJSONEncoder().encode(self)
1076+ }
1077+
1078+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1079+ return String(data: try self.jsonData(), encoding: encoding)
1080+ }
1081+}
1082+
1083+enum AnsarieElement: Codable {
1084+ case ansarieClass(AnsarieClass)
1085+ case integerArray([Int])
1086+ case null
1087+
1088+ init(from decoder: Decoder) throws {
1089+ let container = try decoder.singleValueContainer()
1090+ if let x = try? container.decode([Int].self) {
1091+ self = .integerArray(x)
1092+ return
1093+ }
1094+ if let x = try? container.decode(AnsarieClass.self) {
1095+ self = .ansarieClass(x)
1096+ return
1097+ }
1098+ if container.decodeNil() {
1099+ self = .null
1100+ return
1101+ }
1102+ throw DecodingError.typeMismatch(AnsarieElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for AnsarieElement"))
1103+ }
1104+
1105+ func encode(to encoder: Encoder) throws {
1106+ var container = encoder.singleValueContainer()
1107+ switch self {
1108+ case .ansarieClass(let x):
1109+ try container.encode(x)
1110+ case .integerArray(let x):
1111+ try container.encode(x)
1112+ case .null:
1113+ try container.encodeNil()
1114+ }
1115+ }
1116+}
1117+
1118+// MARK: - AnsarieClass
1119+final class AnsarieClass: Codable {
1120+ let accension: JSONNull?
1121+ let alida: JSONNull?
1122+ let asteria: JSONNull?
1123+ let beriberic: JSONNull?
1124+ let edgebone: JSONNull?
1125+ let gastrodialysis: JSONNull?
1126+ let geographic: JSONNull?
1127+ let ictonyx: JSONNull?
1128+ let metrocele: JSONNull?
1129+ let misgraft: JSONNull?
1130+ let monteith: JSONNull?
1131+ let notcher: JSONNull?
1132+ let prorestriction: JSONNull?
1133+ let ramist: JSONNull?
1134+ let throatlet: JSONNull?
1135+ let unfair: JSONNull?
1136+ let unsynonymous: JSONNull?
1137+ let water: JSONNull?
1138+ let zestfully: JSONNull?
1139+ let zincic: JSONNull?
1140+
1141+ enum CodingKeys: String, CodingKey {
1142+ case accension = "accension"
1143+ case alida = "Alida"
1144+ case asteria = "asteria"
1145+ case beriberic = "beriberic"
1146+ case edgebone = "edgebone"
1147+ case gastrodialysis = "gastrodialysis"
1148+ case geographic = "geographic"
1149+ case ictonyx = "Ictonyx"
1150+ case metrocele = "metrocele"
1151+ case misgraft = "misgraft"
1152+ case monteith = "monteith"
1153+ case notcher = "notcher"
1154+ case prorestriction = "prorestriction"
1155+ case ramist = "Ramist"
1156+ case throatlet = "throatlet"
1157+ case unfair = "unfair"
1158+ case unsynonymous = "unsynonymous"
1159+ case water = "water"
1160+ case zestfully = "zestfully"
1161+ case zincic = "zincic"
1162+ }
1163+
1164+ 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?) {
1165+ self.accension = accension
1166+ self.alida = alida
1167+ self.asteria = asteria
1168+ self.beriberic = beriberic
1169+ self.edgebone = edgebone
1170+ self.gastrodialysis = gastrodialysis
1171+ self.geographic = geographic
1172+ self.ictonyx = ictonyx
1173+ self.metrocele = metrocele
1174+ self.misgraft = misgraft
1175+ self.monteith = monteith
1176+ self.notcher = notcher
1177+ self.prorestriction = prorestriction
1178+ self.ramist = ramist
1179+ self.throatlet = throatlet
1180+ self.unfair = unfair
1181+ self.unsynonymous = unsynonymous
1182+ self.water = water
1183+ self.zestfully = zestfully
1184+ self.zincic = zincic
1185+ }
1186+}
1187+
1188+// MARK: AnsarieClass convenience initializers and mutators
1189+
1190+extension AnsarieClass {
1191+ convenience init(data: Data) throws {
1192+ let me = try newJSONDecoder().decode(AnsarieClass.self, from: data)
1193+ 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)
1194+ }
1195+
1196+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1197+ guard let data = json.data(using: encoding) else {
1198+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1199+ }
1200+ try self.init(data: data)
1201+ }
1202+
1203+ convenience init(fromURL url: URL) throws {
1204+ try self.init(data: try Data(contentsOf: url))
1205+ }
1206+
1207+ func with(
1208+ accension: JSONNull?? = nil,
1209+ alida: JSONNull?? = nil,
1210+ asteria: JSONNull?? = nil,
1211+ beriberic: JSONNull?? = nil,
1212+ edgebone: JSONNull?? = nil,
1213+ gastrodialysis: JSONNull?? = nil,
1214+ geographic: JSONNull?? = nil,
1215+ ictonyx: JSONNull?? = nil,
1216+ metrocele: JSONNull?? = nil,
1217+ misgraft: JSONNull?? = nil,
1218+ monteith: JSONNull?? = nil,
1219+ notcher: JSONNull?? = nil,
1220+ prorestriction: JSONNull?? = nil,
1221+ ramist: JSONNull?? = nil,
1222+ throatlet: JSONNull?? = nil,
1223+ unfair: JSONNull?? = nil,
1224+ unsynonymous: JSONNull?? = nil,
1225+ water: JSONNull?? = nil,
1226+ zestfully: JSONNull?? = nil,
1227+ zincic: JSONNull?? = nil
1228+ ) -> AnsarieClass {
1229+ return AnsarieClass(
1230+ accension: accension ?? self.accension,
1231+ alida: alida ?? self.alida,
1232+ asteria: asteria ?? self.asteria,
1233+ beriberic: beriberic ?? self.beriberic,
1234+ edgebone: edgebone ?? self.edgebone,
1235+ gastrodialysis: gastrodialysis ?? self.gastrodialysis,
1236+ geographic: geographic ?? self.geographic,
1237+ ictonyx: ictonyx ?? self.ictonyx,
1238+ metrocele: metrocele ?? self.metrocele,
1239+ misgraft: misgraft ?? self.misgraft,
1240+ monteith: monteith ?? self.monteith,
1241+ notcher: notcher ?? self.notcher,
1242+ prorestriction: prorestriction ?? self.prorestriction,
1243+ ramist: ramist ?? self.ramist,
1244+ throatlet: throatlet ?? self.throatlet,
1245+ unfair: unfair ?? self.unfair,
1246+ unsynonymous: unsynonymous ?? self.unsynonymous,
1247+ water: water ?? self.water,
1248+ zestfully: zestfully ?? self.zestfully,
1249+ zincic: zincic ?? self.zincic
1250+ )
1251+ }
1252+
1253+ func jsonData() throws -> Data {
1254+ return try newJSONEncoder().encode(self)
1255+ }
1256+
1257+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1258+ return String(data: try self.jsonData(), encoding: encoding)
1259+ }
1260+}
1261+
1262+enum Aphasia: Codable {
1263+ case integer(Int)
1264+ case integerArray([Int])
1265+
1266+ init(from decoder: Decoder) throws {
1267+ let container = try decoder.singleValueContainer()
1268+ if let x = try? container.decode(Int.self) {
1269+ self = .integer(x)
1270+ return
1271+ }
1272+ if let x = try? container.decode([Int].self) {
1273+ self = .integerArray(x)
1274+ return
1275+ }
1276+ throw DecodingError.typeMismatch(Aphasia.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Aphasia"))
1277+ }
1278+
1279+ func encode(to encoder: Encoder) throws {
1280+ var container = encoder.singleValueContainer()
1281+ switch self {
1282+ case .integer(let x):
1283+ try container.encode(x)
1284+ case .integerArray(let x):
1285+ try container.encode(x)
1286+ }
1287+ }
1288+}
1289+
1290+enum Asprawl: Codable {
1291+ case double(Double)
1292+ case string(String)
1293+
1294+ init(from decoder: Decoder) throws {
1295+ let container = try decoder.singleValueContainer()
1296+ if let x = try? container.decode(Double.self) {
1297+ self = .double(x)
1298+ return
1299+ }
1300+ if let x = try? container.decode(String.self) {
1301+ self = .string(x)
1302+ return
1303+ }
1304+ throw DecodingError.typeMismatch(Asprawl.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Asprawl"))
1305+ }
1306+
1307+ func encode(to encoder: Encoder) throws {
1308+ var container = encoder.singleValueContainer()
1309+ switch self {
1310+ case .double(let x):
1311+ try container.encode(x)
1312+ case .string(let x):
1313+ try container.encode(x)
1314+ }
1315+ }
1316+}
1317+
1318+enum Bedesman: Codable {
1319+ case bool(Bool)
1320+ case double(Double)
1321+ case string(String)
1322+
1323+ init(from decoder: Decoder) throws {
1324+ let container = try decoder.singleValueContainer()
1325+ if let x = try? container.decode(Bool.self) {
1326+ self = .bool(x)
1327+ return
1328+ }
1329+ if let x = try? container.decode(Double.self) {
1330+ self = .double(x)
1331+ return
1332+ }
1333+ if let x = try? container.decode(String.self) {
1334+ self = .string(x)
1335+ return
1336+ }
1337+ throw DecodingError.typeMismatch(Bedesman.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Bedesman"))
1338+ }
1339+
1340+ func encode(to encoder: Encoder) throws {
1341+ var container = encoder.singleValueContainer()
1342+ switch self {
1343+ case .bool(let x):
1344+ try container.encode(x)
1345+ case .double(let x):
1346+ try container.encode(x)
1347+ case .string(let x):
1348+ try container.encode(x)
1349+ }
1350+ }
1351+}
1352+
1353+enum Belard: Codable {
1354+ case double(Double)
1355+ case integerArray([Int])
1356+ case rebecca(Rebecca)
1357+
1358+ init(from decoder: Decoder) throws {
1359+ let container = try decoder.singleValueContainer()
1360+ if let x = try? container.decode([Int].self) {
1361+ self = .integerArray(x)
1362+ return
1363+ }
1364+ if let x = try? container.decode(Double.self) {
1365+ self = .double(x)
1366+ return
1367+ }
1368+ if let x = try? container.decode(Rebecca.self) {
1369+ self = .rebecca(x)
1370+ return
1371+ }
1372+ throw DecodingError.typeMismatch(Belard.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Belard"))
1373+ }
1374+
1375+ func encode(to encoder: Encoder) throws {
1376+ var container = encoder.singleValueContainer()
1377+ switch self {
1378+ case .double(let x):
1379+ try container.encode(x)
1380+ case .integerArray(let x):
1381+ try container.encode(x)
1382+ case .rebecca(let x):
1383+ try container.encode(x)
1384+ }
1385+ }
1386+}
1387+
1388+enum Bocking: Codable {
1389+ case bool(Bool)
1390+ case integerArray([Int])
1391+ case integerMap([String: Int])
1392+
1393+ init(from decoder: Decoder) throws {
1394+ let container = try decoder.singleValueContainer()
1395+ if let x = try? container.decode(Bool.self) {
1396+ self = .bool(x)
1397+ return
1398+ }
1399+ if let x = try? container.decode([Int].self) {
1400+ self = .integerArray(x)
1401+ return
1402+ }
1403+ if let x = try? container.decode([String: Int].self) {
1404+ self = .integerMap(x)
1405+ return
1406+ }
1407+ throw DecodingError.typeMismatch(Bocking.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Bocking"))
1408+ }
1409+
1410+ func encode(to encoder: Encoder) throws {
1411+ var container = encoder.singleValueContainer()
1412+ switch self {
1413+ case .bool(let x):
1414+ try container.encode(x)
1415+ case .integerArray(let x):
1416+ try container.encode(x)
1417+ case .integerMap(let x):
1418+ try container.encode(x)
1419+ }
1420+ }
1421+}
1422+
1423+enum Brawlingly: Codable {
1424+ case nullArray([JSONNull?])
1425+ case unionMap([String: Int?])
1426+
1427+ init(from decoder: Decoder) throws {
1428+ let container = try decoder.singleValueContainer()
1429+ if let x = try? container.decode([JSONNull?].self) {
1430+ self = .nullArray(x)
1431+ return
1432+ }
1433+ if let x = try? container.decode([String: Int?].self) {
1434+ self = .unionMap(x)
1435+ return
1436+ }
1437+ throw DecodingError.typeMismatch(Brawlingly.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Brawlingly"))
1438+ }
1439+
1440+ func encode(to encoder: Encoder) throws {
1441+ var container = encoder.singleValueContainer()
1442+ switch self {
1443+ case .nullArray(let x):
1444+ try container.encode(x)
1445+ case .unionMap(let x):
1446+ try container.encode(x)
1447+ }
1448+ }
1449+}
1450+
1451+enum Brookie: Codable {
1452+ case integerArray([Int])
1453+ case rebecca(Rebecca)
1454+
1455+ init(from decoder: Decoder) throws {
1456+ let container = try decoder.singleValueContainer()
1457+ if let x = try? container.decode([Int].self) {
1458+ self = .integerArray(x)
1459+ return
1460+ }
1461+ if let x = try? container.decode(Rebecca.self) {
1462+ self = .rebecca(x)
1463+ return
1464+ }
1465+ throw DecodingError.typeMismatch(Brookie.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Brookie"))
1466+ }
1467+
1468+ func encode(to encoder: Encoder) throws {
1469+ var container = encoder.singleValueContainer()
1470+ switch self {
1471+ case .integerArray(let x):
1472+ try container.encode(x)
1473+ case .rebecca(let x):
1474+ try container.encode(x)
1475+ }
1476+ }
1477+}
1478+
1479+enum Bumboatman: Codable {
1480+ case nullArray([JSONNull?])
1481+ case string(String)
1482+ case null
1483+
1484+ init(from decoder: Decoder) throws {
1485+ let container = try decoder.singleValueContainer()
1486+ if let x = try? container.decode([JSONNull?].self) {
1487+ self = .nullArray(x)
1488+ return
1489+ }
1490+ if let x = try? container.decode(String.self) {
1491+ self = .string(x)
1492+ return
1493+ }
1494+ if container.decodeNil() {
1495+ self = .null
1496+ return
1497+ }
1498+ throw DecodingError.typeMismatch(Bumboatman.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Bumboatman"))
1499+ }
1500+
1501+ func encode(to encoder: Encoder) throws {
1502+ var container = encoder.singleValueContainer()
1503+ switch self {
1504+ case .nullArray(let x):
1505+ try container.encode(x)
1506+ case .string(let x):
1507+ try container.encode(x)
1508+ case .null:
1509+ try container.encodeNil()
1510+ }
1511+ }
1512+}
1513+
1514+enum Calaverite: Codable {
1515+ case integerArray([Int])
1516+ case string(String)
1517+
1518+ init(from decoder: Decoder) throws {
1519+ let container = try decoder.singleValueContainer()
1520+ if let x = try? container.decode([Int].self) {
1521+ self = .integerArray(x)
1522+ return
1523+ }
1524+ if let x = try? container.decode(String.self) {
1525+ self = .string(x)
1526+ return
1527+ }
1528+ throw DecodingError.typeMismatch(Calaverite.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Calaverite"))
1529+ }
1530+
1531+ func encode(to encoder: Encoder) throws {
1532+ var container = encoder.singleValueContainer()
1533+ switch self {
1534+ case .integerArray(let x):
1535+ try container.encode(x)
1536+ case .string(let x):
1537+ try container.encode(x)
1538+ }
1539+ }
1540+}
1541+
1542+enum Catallactic: Codable {
1543+ case bool(Bool)
1544+ case integerMap([String: Int])
1545+ case nullArray([JSONNull?])
1546+
1547+ init(from decoder: Decoder) throws {
1548+ let container = try decoder.singleValueContainer()
1549+ if let x = try? container.decode(Bool.self) {
1550+ self = .bool(x)
1551+ return
1552+ }
1553+ if let x = try? container.decode([JSONNull?].self) {
1554+ self = .nullArray(x)
1555+ return
1556+ }
1557+ if let x = try? container.decode([String: Int].self) {
1558+ self = .integerMap(x)
1559+ return
1560+ }
1561+ throw DecodingError.typeMismatch(Catallactic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Catallactic"))
1562+ }
1563+
1564+ func encode(to encoder: Encoder) throws {
1565+ var container = encoder.singleValueContainer()
1566+ switch self {
1567+ case .bool(let x):
1568+ try container.encode(x)
1569+ case .integerMap(let x):
1570+ try container.encode(x)
1571+ case .nullArray(let x):
1572+ try container.encode(x)
1573+ }
1574+ }
1575+}
1576+
1577+enum Cemental: Codable {
1578+ case double(Double)
1579+ case integerArray([Int])
1580+ case integerMap([String: Int])
1581+
1582+ init(from decoder: Decoder) throws {
1583+ let container = try decoder.singleValueContainer()
1584+ if let x = try? container.decode([Int].self) {
1585+ self = .integerArray(x)
1586+ return
1587+ }
1588+ if let x = try? container.decode(Double.self) {
1589+ self = .double(x)
1590+ return
1591+ }
1592+ if let x = try? container.decode([String: Int].self) {
1593+ self = .integerMap(x)
1594+ return
1595+ }
1596+ throw DecodingError.typeMismatch(Cemental.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Cemental"))
1597+ }
1598+
1599+ func encode(to encoder: Encoder) throws {
1600+ var container = encoder.singleValueContainer()
1601+ switch self {
1602+ case .double(let x):
1603+ try container.encode(x)
1604+ case .integerArray(let x):
1605+ try container.encode(x)
1606+ case .integerMap(let x):
1607+ try container.encode(x)
1608+ }
1609+ }
1610+}
1611+
1612+enum ChytridiaceaeElement: Codable {
1613+ case bool(Bool)
1614+ case chytridiaceaeClass(ChytridiaceaeClass)
1615+ case null
1616+
1617+ init(from decoder: Decoder) throws {
1618+ let container = try decoder.singleValueContainer()
1619+ if let x = try? container.decode(Bool.self) {
1620+ self = .bool(x)
1621+ return
1622+ }
1623+ if let x = try? container.decode(ChytridiaceaeClass.self) {
1624+ self = .chytridiaceaeClass(x)
1625+ return
1626+ }
1627+ if container.decodeNil() {
1628+ self = .null
1629+ return
1630+ }
1631+ throw DecodingError.typeMismatch(ChytridiaceaeElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for ChytridiaceaeElement"))
1632+ }
1633+
1634+ func encode(to encoder: Encoder) throws {
1635+ var container = encoder.singleValueContainer()
1636+ switch self {
1637+ case .bool(let x):
1638+ try container.encode(x)
1639+ case .chytridiaceaeClass(let x):
1640+ try container.encode(x)
1641+ case .null:
1642+ try container.encodeNil()
1643+ }
1644+ }
1645+}
1646+
1647+// MARK: - ChytridiaceaeClass
1648+final class ChytridiaceaeClass: Codable {
1649+ let batidaceae: JSONNull?
1650+ let brechites: JSONNull?
1651+ let codespairer: JSONNull?
1652+ let emery: JSONNull?
1653+ let enervative: JSONNull?
1654+ let excriminate: JSONNull?
1655+ let goshenite: JSONNull?
1656+ let grime: JSONNull?
1657+ let gritten: JSONNull?
1658+ let hectorly: JSONNull?
1659+ let intermediation: JSONNull?
1660+ let meeterly: JSONNull?
1661+ let narraganset: JSONNull?
1662+ let onymatic: JSONNull?
1663+ let paddlecock: JSONNull?
1664+ let thana: JSONNull?
1665+ let thornily: JSONNull?
1666+ let uckia: JSONNull?
1667+ let unmettle: JSONNull?
1668+ let vorticellid: JSONNull?
1669+
1670+ enum CodingKeys: String, CodingKey {
1671+ case batidaceae = "Batidaceae"
1672+ case brechites = "Brechites"
1673+ case codespairer = "codespairer"
1674+ case emery = "Emery"
1675+ case enervative = "enervative"
1676+ case excriminate = "excriminate"
1677+ case goshenite = "goshenite"
1678+ case grime = "grime"
1679+ case gritten = "gritten"
1680+ case hectorly = "hectorly"
1681+ case intermediation = "intermediation"
1682+ case meeterly = "meeterly"
1683+ case narraganset = "Narraganset"
1684+ case onymatic = "onymatic"
1685+ case paddlecock = "paddlecock"
1686+ case thana = "thana"
1687+ case thornily = "thornily"
1688+ case uckia = "uckia"
1689+ case unmettle = "unmettle"
1690+ case vorticellid = "vorticellid"
1691+ }
1692+
1693+ 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?) {
1694+ self.batidaceae = batidaceae
1695+ self.brechites = brechites
1696+ self.codespairer = codespairer
1697+ self.emery = emery
1698+ self.enervative = enervative
1699+ self.excriminate = excriminate
1700+ self.goshenite = goshenite
1701+ self.grime = grime
1702+ self.gritten = gritten
1703+ self.hectorly = hectorly
1704+ self.intermediation = intermediation
1705+ self.meeterly = meeterly
1706+ self.narraganset = narraganset
1707+ self.onymatic = onymatic
1708+ self.paddlecock = paddlecock
1709+ self.thana = thana
1710+ self.thornily = thornily
1711+ self.uckia = uckia
1712+ self.unmettle = unmettle
1713+ self.vorticellid = vorticellid
1714+ }
1715+}
1716+
1717+// MARK: ChytridiaceaeClass convenience initializers and mutators
1718+
1719+extension ChytridiaceaeClass {
1720+ convenience init(data: Data) throws {
1721+ let me = try newJSONDecoder().decode(ChytridiaceaeClass.self, from: data)
1722+ 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)
1723+ }
1724+
1725+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1726+ guard let data = json.data(using: encoding) else {
1727+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1728+ }
1729+ try self.init(data: data)
1730+ }
1731+
1732+ convenience init(fromURL url: URL) throws {
1733+ try self.init(data: try Data(contentsOf: url))
1734+ }
1735+
1736+ func with(
1737+ batidaceae: JSONNull?? = nil,
1738+ brechites: JSONNull?? = nil,
1739+ codespairer: JSONNull?? = nil,
1740+ emery: JSONNull?? = nil,
1741+ enervative: JSONNull?? = nil,
1742+ excriminate: JSONNull?? = nil,
1743+ goshenite: JSONNull?? = nil,
1744+ grime: JSONNull?? = nil,
1745+ gritten: JSONNull?? = nil,
1746+ hectorly: JSONNull?? = nil,
1747+ intermediation: JSONNull?? = nil,
1748+ meeterly: JSONNull?? = nil,
1749+ narraganset: JSONNull?? = nil,
1750+ onymatic: JSONNull?? = nil,
1751+ paddlecock: JSONNull?? = nil,
1752+ thana: JSONNull?? = nil,
1753+ thornily: JSONNull?? = nil,
1754+ uckia: JSONNull?? = nil,
1755+ unmettle: JSONNull?? = nil,
1756+ vorticellid: JSONNull?? = nil
1757+ ) -> ChytridiaceaeClass {
1758+ return ChytridiaceaeClass(
1759+ batidaceae: batidaceae ?? self.batidaceae,
1760+ brechites: brechites ?? self.brechites,
1761+ codespairer: codespairer ?? self.codespairer,
1762+ emery: emery ?? self.emery,
1763+ enervative: enervative ?? self.enervative,
1764+ excriminate: excriminate ?? self.excriminate,
1765+ goshenite: goshenite ?? self.goshenite,
1766+ grime: grime ?? self.grime,
1767+ gritten: gritten ?? self.gritten,
1768+ hectorly: hectorly ?? self.hectorly,
1769+ intermediation: intermediation ?? self.intermediation,
1770+ meeterly: meeterly ?? self.meeterly,
1771+ narraganset: narraganset ?? self.narraganset,
1772+ onymatic: onymatic ?? self.onymatic,
1773+ paddlecock: paddlecock ?? self.paddlecock,
1774+ thana: thana ?? self.thana,
1775+ thornily: thornily ?? self.thornily,
1776+ uckia: uckia ?? self.uckia,
1777+ unmettle: unmettle ?? self.unmettle,
1778+ vorticellid: vorticellid ?? self.vorticellid
1779+ )
1780+ }
1781+
1782+ func jsonData() throws -> Data {
1783+ return try newJSONEncoder().encode(self)
1784+ }
1785+
1786+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1787+ return String(data: try self.jsonData(), encoding: encoding)
1788+ }
1789+}
1790+
1791+enum DiscordiaElement: Codable {
1792+ case discordiaClass(DiscordiaClass)
1793+ case integerArray([Int])
1794+
1795+ init(from decoder: Decoder) throws {
1796+ let container = try decoder.singleValueContainer()
1797+ if let x = try? container.decode([Int].self) {
1798+ self = .integerArray(x)
1799+ return
1800+ }
1801+ if let x = try? container.decode(DiscordiaClass.self) {
1802+ self = .discordiaClass(x)
1803+ return
1804+ }
1805+ throw DecodingError.typeMismatch(DiscordiaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for DiscordiaElement"))
1806+ }
1807+
1808+ func encode(to encoder: Encoder) throws {
1809+ var container = encoder.singleValueContainer()
1810+ switch self {
1811+ case .discordiaClass(let x):
1812+ try container.encode(x)
1813+ case .integerArray(let x):
1814+ try container.encode(x)
1815+ }
1816+ }
1817+}
1818+
1819+// MARK: - DiscordiaClass
1820+final class DiscordiaClass: Codable {
1821+ let altaic: Int?
1822+ let amoristic: Int?
1823+ let blennophthalmia: Int?
1824+ let catharticalness: Double?
1825+ let chirotherium: Int?
1826+ let disciplinability: Int?
1827+ let disdiapason: String?
1828+ let goofer: Int?
1829+ let homocerc: Bool?
1830+ let laryngograph: Int?
1831+ let leucitis: Int?
1832+ let lymphocyst: Int?
1833+ let microcosmology: Int?
1834+ let nauseation: Int?
1835+ let nonbookish: JSONNull?
1836+ let patarin: Int?
1837+ let preliberal: Int?
1838+ let prettifier: Int?
1839+ let rangework: Int?
1840+ let redient: Int?
1841+ let subfusiform: Int?
1842+ let suicidical: Int?
1843+ let swow: Int?
1844+ let wastrel: Int?
1845+ let wingle: Int?
1846+
1847+ enum CodingKeys: String, CodingKey {
1848+ case altaic = "Altaic"
1849+ case amoristic = "amoristic"
1850+ case blennophthalmia = "blennophthalmia"
1851+ case catharticalness = "catharticalness"
1852+ case chirotherium = "Chirotherium"
1853+ case disciplinability = "disciplinability"
1854+ case disdiapason = "disdiapason"
1855+ case goofer = "goofer"
1856+ case homocerc = "homocerc"
1857+ case laryngograph = "laryngograph"
1858+ case leucitis = "leucitis"
1859+ case lymphocyst = "lymphocyst"
1860+ case microcosmology = "microcosmology"
1861+ case nauseation = "nauseation"
1862+ case nonbookish = "nonbookish"
1863+ case patarin = "Patarin"
1864+ case preliberal = "preliberal"
1865+ case prettifier = "prettifier"
1866+ case rangework = "rangework"
1867+ case redient = "redient"
1868+ case subfusiform = "subfusiform"
1869+ case suicidical = "suicidical"
1870+ case swow = "swow"
1871+ case wastrel = "wastrel"
1872+ case wingle = "wingle"
1873+ }
1874+
1875+ 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?) {
1876+ self.altaic = altaic
1877+ self.amoristic = amoristic
1878+ self.blennophthalmia = blennophthalmia
1879+ self.catharticalness = catharticalness
1880+ self.chirotherium = chirotherium
1881+ self.disciplinability = disciplinability
1882+ self.disdiapason = disdiapason
1883+ self.goofer = goofer
1884+ self.homocerc = homocerc
1885+ self.laryngograph = laryngograph
1886+ self.leucitis = leucitis
1887+ self.lymphocyst = lymphocyst
1888+ self.microcosmology = microcosmology
1889+ self.nauseation = nauseation
1890+ self.nonbookish = nonbookish
1891+ self.patarin = patarin
1892+ self.preliberal = preliberal
1893+ self.prettifier = prettifier
1894+ self.rangework = rangework
1895+ self.redient = redient
1896+ self.subfusiform = subfusiform
1897+ self.suicidical = suicidical
1898+ self.swow = swow
1899+ self.wastrel = wastrel
1900+ self.wingle = wingle
1901+ }
1902+}
1903+
1904+// MARK: DiscordiaClass convenience initializers and mutators
1905+
1906+extension DiscordiaClass {
1907+ convenience init(data: Data) throws {
1908+ let me = try newJSONDecoder().decode(DiscordiaClass.self, from: data)
1909+ 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)
1910+ }
1911+
1912+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1913+ guard let data = json.data(using: encoding) else {
1914+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1915+ }
1916+ try self.init(data: data)
1917+ }
1918+
1919+ convenience init(fromURL url: URL) throws {
1920+ try self.init(data: try Data(contentsOf: url))
1921+ }
1922+
1923+ func with(
1924+ altaic: Int?? = nil,
1925+ amoristic: Int?? = nil,
1926+ blennophthalmia: Int?? = nil,
1927+ catharticalness: Double?? = nil,
1928+ chirotherium: Int?? = nil,
1929+ disciplinability: Int?? = nil,
1930+ disdiapason: String?? = nil,
1931+ goofer: Int?? = nil,
1932+ homocerc: Bool?? = nil,
1933+ laryngograph: Int?? = nil,
1934+ leucitis: Int?? = nil,
1935+ lymphocyst: Int?? = nil,
1936+ microcosmology: Int?? = nil,
1937+ nauseation: Int?? = nil,
1938+ nonbookish: JSONNull?? = nil,
1939+ patarin: Int?? = nil,
1940+ preliberal: Int?? = nil,
1941+ prettifier: Int?? = nil,
1942+ rangework: Int?? = nil,
1943+ redient: Int?? = nil,
1944+ subfusiform: Int?? = nil,
1945+ suicidical: Int?? = nil,
1946+ swow: Int?? = nil,
1947+ wastrel: Int?? = nil,
1948+ wingle: Int?? = nil
1949+ ) -> DiscordiaClass {
1950+ return DiscordiaClass(
1951+ altaic: altaic ?? self.altaic,
1952+ amoristic: amoristic ?? self.amoristic,
1953+ blennophthalmia: blennophthalmia ?? self.blennophthalmia,
1954+ catharticalness: catharticalness ?? self.catharticalness,
1955+ chirotherium: chirotherium ?? self.chirotherium,
1956+ disciplinability: disciplinability ?? self.disciplinability,
1957+ disdiapason: disdiapason ?? self.disdiapason,
1958+ goofer: goofer ?? self.goofer,
1959+ homocerc: homocerc ?? self.homocerc,
1960+ laryngograph: laryngograph ?? self.laryngograph,
1961+ leucitis: leucitis ?? self.leucitis,
1962+ lymphocyst: lymphocyst ?? self.lymphocyst,
1963+ microcosmology: microcosmology ?? self.microcosmology,
1964+ nauseation: nauseation ?? self.nauseation,
1965+ nonbookish: nonbookish ?? self.nonbookish,
1966+ patarin: patarin ?? self.patarin,
1967+ preliberal: preliberal ?? self.preliberal,
1968+ prettifier: prettifier ?? self.prettifier,
1969+ rangework: rangework ?? self.rangework,
1970+ redient: redient ?? self.redient,
1971+ subfusiform: subfusiform ?? self.subfusiform,
1972+ suicidical: suicidical ?? self.suicidical,
1973+ swow: swow ?? self.swow,
1974+ wastrel: wastrel ?? self.wastrel,
1975+ wingle: wingle ?? self.wingle
1976+ )
1977+ }
1978+
1979+ func jsonData() throws -> Data {
1980+ return try newJSONEncoder().encode(self)
1981+ }
1982+
1983+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1984+ return String(data: try self.jsonData(), encoding: encoding)
1985+ }
1986+}
1987+
1988+enum Endomyce: Codable {
1989+ case integer(Int)
1990+ case string(String)
1991+
1992+ init(from decoder: Decoder) throws {
1993+ let container = try decoder.singleValueContainer()
1994+ if let x = try? container.decode(Int.self) {
1995+ self = .integer(x)
1996+ return
1997+ }
1998+ if let x = try? container.decode(String.self) {
1999+ self = .string(x)
2000+ return
2001+ }
2002+ throw DecodingError.typeMismatch(Endomyce.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Endomyce"))
2003+ }
2004+
2005+ func encode(to encoder: Encoder) throws {
2006+ var container = encoder.singleValueContainer()
2007+ switch self {
2008+ case .integer(let x):
2009+ try container.encode(x)
2010+ case .string(let x):
2011+ try container.encode(x)
2012+ }
2013+ }
2014+}
2015+
2016+enum Epinephelidae: Codable {
2017+ case bool(Bool)
2018+ case integer(Int)
2019+ case string(String)
2020+
2021+ init(from decoder: Decoder) throws {
2022+ let container = try decoder.singleValueContainer()
2023+ if let x = try? container.decode(Bool.self) {
2024+ self = .bool(x)
2025+ return
2026+ }
2027+ if let x = try? container.decode(Int.self) {
2028+ self = .integer(x)
2029+ return
2030+ }
2031+ if let x = try? container.decode(String.self) {
2032+ self = .string(x)
2033+ return
2034+ }
2035+ throw DecodingError.typeMismatch(Epinephelidae.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Epinephelidae"))
2036+ }
2037+
2038+ func encode(to encoder: Encoder) throws {
2039+ var container = encoder.singleValueContainer()
2040+ switch self {
2041+ case .bool(let x):
2042+ try container.encode(x)
2043+ case .integer(let x):
2044+ try container.encode(x)
2045+ case .string(let x):
2046+ try container.encode(x)
2047+ }
2048+ }
2049+}
2050+
2051+enum Eupatorium: Codable {
2052+ case integerMap([String: Int])
2053+ case nullArray([JSONNull?])
2054+
2055+ init(from decoder: Decoder) throws {
2056+ let container = try decoder.singleValueContainer()
2057+ if let x = try? container.decode([JSONNull?].self) {
2058+ self = .nullArray(x)
2059+ return
2060+ }
2061+ if let x = try? container.decode([String: Int].self) {
2062+ self = .integerMap(x)
2063+ return
2064+ }
2065+ throw DecodingError.typeMismatch(Eupatorium.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Eupatorium"))
2066+ }
2067+
2068+ func encode(to encoder: Encoder) throws {
2069+ var container = encoder.singleValueContainer()
2070+ switch self {
2071+ case .integerMap(let x):
2072+ try container.encode(x)
2073+ case .nullArray(let x):
2074+ try container.encode(x)
2075+ }
2076+ }
2077+}
2078+
2079+enum GryphosaurusElement: Codable {
2080+ case gryphosaurusClass(GryphosaurusClass)
2081+ case integerArray([Int])
2082+ case string(String)
2083+
2084+ init(from decoder: Decoder) throws {
2085+ let container = try decoder.singleValueContainer()
2086+ if let x = try? container.decode([Int].self) {
2087+ self = .integerArray(x)
2088+ return
2089+ }
2090+ if let x = try? container.decode(String.self) {
2091+ self = .string(x)
2092+ return
2093+ }
2094+ if let x = try? container.decode(GryphosaurusClass.self) {
2095+ self = .gryphosaurusClass(x)
2096+ return
2097+ }
2098+ throw DecodingError.typeMismatch(GryphosaurusElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for GryphosaurusElement"))
2099+ }
2100+
2101+ func encode(to encoder: Encoder) throws {
2102+ var container = encoder.singleValueContainer()
2103+ switch self {
2104+ case .gryphosaurusClass(let x):
2105+ try container.encode(x)
2106+ case .integerArray(let x):
2107+ try container.encode(x)
2108+ case .string(let x):
2109+ try container.encode(x)
2110+ }
2111+ }
2112+}
2113+
2114+// MARK: - GryphosaurusClass
2115+final class GryphosaurusClass: Codable {
2116+ let amissibility: JSONNull?
2117+ let burushaski: JSONNull?
2118+ let citronin: JSONNull?
2119+ let coplaintiff: JSONNull?
2120+ let disquisitionary: JSONNull?
2121+ let enoplan: JSONNull?
2122+ let faintness: JSONNull?
2123+ let hebetomy: JSONNull?
2124+ let islandry: JSONNull?
2125+ let lameduck: JSONNull?
2126+ let overbattle: JSONNull?
2127+ let overinterested: JSONNull?
2128+ let phrenologic: JSONNull?
2129+ let rainband: JSONNull?
2130+ let shiningly: JSONNull?
2131+ let stamineous: JSONNull?
2132+ let subscapularis: JSONNull?
2133+ let tahami: JSONNull?
2134+ let undaubed: JSONNull?
2135+ let underntime: JSONNull?
2136+
2137+ enum CodingKeys: String, CodingKey {
2138+ case amissibility = "amissibility"
2139+ case burushaski = "Burushaski"
2140+ case citronin = "citronin"
2141+ case coplaintiff = "coplaintiff"
2142+ case disquisitionary = "disquisitionary"
2143+ case enoplan = "enoplan"
2144+ case faintness = "faintness"
2145+ case hebetomy = "hebetomy"
2146+ case islandry = "islandry"
2147+ case lameduck = "lameduck"
2148+ case overbattle = "overbattle"
2149+ case overinterested = "overinterested"
2150+ case phrenologic = "phrenologic"
2151+ case rainband = "rainband"
2152+ case shiningly = "shiningly"
2153+ case stamineous = "stamineous"
2154+ case subscapularis = "subscapularis"
2155+ case tahami = "Tahami"
2156+ case undaubed = "undaubed"
2157+ case underntime = "underntime"
2158+ }
2159+
2160+ 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?) {
2161+ self.amissibility = amissibility
2162+ self.burushaski = burushaski
2163+ self.citronin = citronin
2164+ self.coplaintiff = coplaintiff
2165+ self.disquisitionary = disquisitionary
2166+ self.enoplan = enoplan
2167+ self.faintness = faintness
2168+ self.hebetomy = hebetomy
2169+ self.islandry = islandry
2170+ self.lameduck = lameduck
2171+ self.overbattle = overbattle
2172+ self.overinterested = overinterested
2173+ self.phrenologic = phrenologic
2174+ self.rainband = rainband
2175+ self.shiningly = shiningly
2176+ self.stamineous = stamineous
2177+ self.subscapularis = subscapularis
2178+ self.tahami = tahami
2179+ self.undaubed = undaubed
2180+ self.underntime = underntime
2181+ }
2182+}
2183+
2184+// MARK: GryphosaurusClass convenience initializers and mutators
2185+
2186+extension GryphosaurusClass {
2187+ convenience init(data: Data) throws {
2188+ let me = try newJSONDecoder().decode(GryphosaurusClass.self, from: data)
2189+ 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)
2190+ }
2191+
2192+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2193+ guard let data = json.data(using: encoding) else {
2194+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2195+ }
2196+ try self.init(data: data)
2197+ }
2198+
2199+ convenience init(fromURL url: URL) throws {
2200+ try self.init(data: try Data(contentsOf: url))
2201+ }
2202+
2203+ func with(
2204+ amissibility: JSONNull?? = nil,
2205+ burushaski: JSONNull?? = nil,
2206+ citronin: JSONNull?? = nil,
2207+ coplaintiff: JSONNull?? = nil,
2208+ disquisitionary: JSONNull?? = nil,
2209+ enoplan: JSONNull?? = nil,
2210+ faintness: JSONNull?? = nil,
2211+ hebetomy: JSONNull?? = nil,
2212+ islandry: JSONNull?? = nil,
2213+ lameduck: JSONNull?? = nil,
2214+ overbattle: JSONNull?? = nil,
2215+ overinterested: JSONNull?? = nil,
2216+ phrenologic: JSONNull?? = nil,
2217+ rainband: JSONNull?? = nil,
2218+ shiningly: JSONNull?? = nil,
2219+ stamineous: JSONNull?? = nil,
2220+ subscapularis: JSONNull?? = nil,
2221+ tahami: JSONNull?? = nil,
2222+ undaubed: JSONNull?? = nil,
2223+ underntime: JSONNull?? = nil
2224+ ) -> GryphosaurusClass {
2225+ return GryphosaurusClass(
2226+ amissibility: amissibility ?? self.amissibility,
2227+ burushaski: burushaski ?? self.burushaski,
2228+ citronin: citronin ?? self.citronin,
2229+ coplaintiff: coplaintiff ?? self.coplaintiff,
2230+ disquisitionary: disquisitionary ?? self.disquisitionary,
2231+ enoplan: enoplan ?? self.enoplan,
2232+ faintness: faintness ?? self.faintness,
2233+ hebetomy: hebetomy ?? self.hebetomy,
2234+ islandry: islandry ?? self.islandry,
2235+ lameduck: lameduck ?? self.lameduck,
2236+ overbattle: overbattle ?? self.overbattle,
2237+ overinterested: overinterested ?? self.overinterested,
2238+ phrenologic: phrenologic ?? self.phrenologic,
2239+ rainband: rainband ?? self.rainband,
2240+ shiningly: shiningly ?? self.shiningly,
2241+ stamineous: stamineous ?? self.stamineous,
2242+ subscapularis: subscapularis ?? self.subscapularis,
2243+ tahami: tahami ?? self.tahami,
2244+ undaubed: undaubed ?? self.undaubed,
2245+ underntime: underntime ?? self.underntime
2246+ )
2247+ }
2248+
2249+ func jsonData() throws -> Data {
2250+ return try newJSONEncoder().encode(self)
2251+ }
2252+
2253+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2254+ return String(data: try self.jsonData(), encoding: encoding)
2255+ }
2256+}
2257+
2258+enum Koryak: Codable {
2259+ case string(String)
2260+ case unionMap([String: Int?])
2261+
2262+ init(from decoder: Decoder) throws {
2263+ let container = try decoder.singleValueContainer()
2264+ if let x = try? container.decode([String: Int?].self) {
2265+ self = .unionMap(x)
2266+ return
2267+ }
2268+ if let x = try? container.decode(String.self) {
2269+ self = .string(x)
2270+ return
2271+ }
2272+ throw DecodingError.typeMismatch(Koryak.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Koryak"))
2273+ }
2274+
2275+ func encode(to encoder: Encoder) throws {
2276+ var container = encoder.singleValueContainer()
2277+ switch self {
2278+ case .string(let x):
2279+ try container.encode(x)
2280+ case .unionMap(let x):
2281+ try container.encode(x)
2282+ }
2283+ }
2284+}
2285+
2286+enum LaviniaElement: Codable {
2287+ case laviniaClass(LaviniaClass)
2288+ case string(String)
2289+
2290+ init(from decoder: Decoder) throws {
2291+ let container = try decoder.singleValueContainer()
2292+ if let x = try? container.decode(String.self) {
2293+ self = .string(x)
2294+ return
2295+ }
2296+ if let x = try? container.decode(LaviniaClass.self) {
2297+ self = .laviniaClass(x)
2298+ return
2299+ }
2300+ throw DecodingError.typeMismatch(LaviniaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for LaviniaElement"))
2301+ }
2302+
2303+ func encode(to encoder: Encoder) throws {
2304+ var container = encoder.singleValueContainer()
2305+ switch self {
2306+ case .laviniaClass(let x):
2307+ try container.encode(x)
2308+ case .string(let x):
2309+ try container.encode(x)
2310+ }
2311+ }
2312+}
2313+
2314+// MARK: - LaviniaClass
2315+final class LaviniaClass: Codable {
2316+ let agitable: Int?
2317+ let asininity: Int?
2318+ let benefiter: Int?
2319+ let bronzelike: Int?
2320+ let catharticalness: Double?
2321+ let chirotherium: Int?
2322+ let cholesteatomatous: Int?
2323+ let deprivement: Int?
2324+ let disdiapason: String?
2325+ let flippantness: Int?
2326+ let fogproof: Int?
2327+ let homocerc: Bool?
2328+ let merrymeeting: Int?
2329+ let nonbookish: JSONNull?
2330+ let overcareful: Int?
2331+ let panaris: Int?
2332+ let preacceptance: Int?
2333+ let quinoxaline: Int?
2334+ let sig: Int?
2335+ let superconfusion: Int?
2336+ let tacana: Int?
2337+ let tillotter: Int?
2338+ let tranquillize: Int?
2339+ let unquestionable: Int?
2340+ let uproute: Int?
2341+
2342+ enum CodingKeys: String, CodingKey {
2343+ case agitable = "agitable"
2344+ case asininity = "asininity"
2345+ case benefiter = "benefiter"
2346+ case bronzelike = "bronzelike"
2347+ case catharticalness = "catharticalness"
2348+ case chirotherium = "Chirotherium"
2349+ case cholesteatomatous = "cholesteatomatous"
2350+ case deprivement = "deprivement"
2351+ case disdiapason = "disdiapason"
2352+ case flippantness = "flippantness"
2353+ case fogproof = "fogproof"
2354+ case homocerc = "homocerc"
2355+ case merrymeeting = "merrymeeting"
2356+ case nonbookish = "nonbookish"
2357+ case overcareful = "overcareful"
2358+ case panaris = "panaris"
2359+ case preacceptance = "preacceptance"
2360+ case quinoxaline = "quinoxaline"
2361+ case sig = "sig"
2362+ case superconfusion = "superconfusion"
2363+ case tacana = "Tacana"
2364+ case tillotter = "tillotter"
2365+ case tranquillize = "tranquillize"
2366+ case unquestionable = "unquestionable"
2367+ case uproute = "uproute"
2368+ }
2369+
2370+ 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?) {
2371+ self.agitable = agitable
2372+ self.asininity = asininity
2373+ self.benefiter = benefiter
2374+ self.bronzelike = bronzelike
2375+ self.catharticalness = catharticalness
2376+ self.chirotherium = chirotherium
2377+ self.cholesteatomatous = cholesteatomatous
2378+ self.deprivement = deprivement
2379+ self.disdiapason = disdiapason
2380+ self.flippantness = flippantness
2381+ self.fogproof = fogproof
2382+ self.homocerc = homocerc
2383+ self.merrymeeting = merrymeeting
2384+ self.nonbookish = nonbookish
2385+ self.overcareful = overcareful
2386+ self.panaris = panaris
2387+ self.preacceptance = preacceptance
2388+ self.quinoxaline = quinoxaline
2389+ self.sig = sig
2390+ self.superconfusion = superconfusion
2391+ self.tacana = tacana
2392+ self.tillotter = tillotter
2393+ self.tranquillize = tranquillize
2394+ self.unquestionable = unquestionable
2395+ self.uproute = uproute
2396+ }
2397+}
2398+
2399+// MARK: LaviniaClass convenience initializers and mutators
2400+
2401+extension LaviniaClass {
2402+ convenience init(data: Data) throws {
2403+ let me = try newJSONDecoder().decode(LaviniaClass.self, from: data)
2404+ 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)
2405+ }
2406+
2407+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2408+ guard let data = json.data(using: encoding) else {
2409+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2410+ }
2411+ try self.init(data: data)
2412+ }
2413+
2414+ convenience init(fromURL url: URL) throws {
2415+ try self.init(data: try Data(contentsOf: url))
2416+ }
2417+
2418+ func with(
2419+ agitable: Int?? = nil,
2420+ asininity: Int?? = nil,
2421+ benefiter: Int?? = nil,
2422+ bronzelike: Int?? = nil,
2423+ catharticalness: Double?? = nil,
2424+ chirotherium: Int?? = nil,
2425+ cholesteatomatous: Int?? = nil,
2426+ deprivement: Int?? = nil,
2427+ disdiapason: String?? = nil,
2428+ flippantness: Int?? = nil,
2429+ fogproof: Int?? = nil,
2430+ homocerc: Bool?? = nil,
2431+ merrymeeting: Int?? = nil,
2432+ nonbookish: JSONNull?? = nil,
2433+ overcareful: Int?? = nil,
2434+ panaris: Int?? = nil,
2435+ preacceptance: Int?? = nil,
2436+ quinoxaline: Int?? = nil,
2437+ sig: Int?? = nil,
2438+ superconfusion: Int?? = nil,
2439+ tacana: Int?? = nil,
2440+ tillotter: Int?? = nil,
2441+ tranquillize: Int?? = nil,
2442+ unquestionable: Int?? = nil,
2443+ uproute: Int?? = nil
2444+ ) -> LaviniaClass {
2445+ return LaviniaClass(
2446+ agitable: agitable ?? self.agitable,
2447+ asininity: asininity ?? self.asininity,
2448+ benefiter: benefiter ?? self.benefiter,
2449+ bronzelike: bronzelike ?? self.bronzelike,
2450+ catharticalness: catharticalness ?? self.catharticalness,
2451+ chirotherium: chirotherium ?? self.chirotherium,
2452+ cholesteatomatous: cholesteatomatous ?? self.cholesteatomatous,
2453+ deprivement: deprivement ?? self.deprivement,
2454+ disdiapason: disdiapason ?? self.disdiapason,
2455+ flippantness: flippantness ?? self.flippantness,
2456+ fogproof: fogproof ?? self.fogproof,
2457+ homocerc: homocerc ?? self.homocerc,
2458+ merrymeeting: merrymeeting ?? self.merrymeeting,
2459+ nonbookish: nonbookish ?? self.nonbookish,
2460+ overcareful: overcareful ?? self.overcareful,
2461+ panaris: panaris ?? self.panaris,
2462+ preacceptance: preacceptance ?? self.preacceptance,
2463+ quinoxaline: quinoxaline ?? self.quinoxaline,
2464+ sig: sig ?? self.sig,
2465+ superconfusion: superconfusion ?? self.superconfusion,
2466+ tacana: tacana ?? self.tacana,
2467+ tillotter: tillotter ?? self.tillotter,
2468+ tranquillize: tranquillize ?? self.tranquillize,
2469+ unquestionable: unquestionable ?? self.unquestionable,
2470+ uproute: uproute ?? self.uproute
2471+ )
2472+ }
2473+
2474+ func jsonData() throws -> Data {
2475+ return try newJSONEncoder().encode(self)
2476+ }
2477+
2478+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2479+ return String(data: try self.jsonData(), encoding: encoding)
2480+ }
2481+}
2482+
2483+enum OskarElement: Codable {
2484+ case integerArray([Int])
2485+ case oskarClass(OskarClass)
2486+
2487+ init(from decoder: Decoder) throws {
2488+ let container = try decoder.singleValueContainer()
2489+ if let x = try? container.decode([Int].self) {
2490+ self = .integerArray(x)
2491+ return
2492+ }
2493+ if let x = try? container.decode(OskarClass.self) {
2494+ self = .oskarClass(x)
2495+ return
2496+ }
2497+ throw DecodingError.typeMismatch(OskarElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for OskarElement"))
2498+ }
2499+
2500+ func encode(to encoder: Encoder) throws {
2501+ var container = encoder.singleValueContainer()
2502+ switch self {
2503+ case .integerArray(let x):
2504+ try container.encode(x)
2505+ case .oskarClass(let x):
2506+ try container.encode(x)
2507+ }
2508+ }
2509+}
2510+
2511+// MARK: - OskarClass
2512+final class OskarClass: Codable {
2513+ let acrobates: JSONNull?
2514+ let beanshooter: JSONNull?
2515+ let bearhound: JSONNull?
2516+ let cayuga: JSONNull?
2517+ let guarneri: JSONNull?
2518+ let hypochondriacism: JSONNull?
2519+ let indication: JSONNull?
2520+ let jaculative: JSONNull?
2521+ let nagana: JSONNull?
2522+ let netherlandish: JSONNull?
2523+ let noctivagous: JSONNull?
2524+ let nonphysiological: JSONNull?
2525+ let praxis: JSONNull?
2526+ let provision: JSONNull?
2527+ let subterhuman: JSONNull?
2528+ let sunlit: JSONNull?
2529+ let syncraniate: JSONNull?
2530+ let teachment: JSONNull?
2531+ let unmutinous: JSONNull?
2532+ let unstoppable: JSONNull?
2533+
2534+ enum CodingKeys: String, CodingKey {
2535+ case acrobates = "Acrobates"
2536+ case beanshooter = "beanshooter"
2537+ case bearhound = "bearhound"
2538+ case cayuga = "Cayuga"
2539+ case guarneri = "guarneri"
2540+ case hypochondriacism = "hypochondriacism"
2541+ case indication = "indication"
2542+ case jaculative = "jaculative"
2543+ case nagana = "nagana"
2544+ case netherlandish = "Netherlandish"
2545+ case noctivagous = "noctivagous"
2546+ case nonphysiological = "nonphysiological"
2547+ case praxis = "praxis"
2548+ case provision = "provision"
2549+ case subterhuman = "subterhuman"
2550+ case sunlit = "sunlit"
2551+ case syncraniate = "syncraniate"
2552+ case teachment = "teachment"
2553+ case unmutinous = "unmutinous"
2554+ case unstoppable = "unstoppable"
2555+ }
2556+
2557+ 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?) {
2558+ self.acrobates = acrobates
2559+ self.beanshooter = beanshooter
2560+ self.bearhound = bearhound
2561+ self.cayuga = cayuga
2562+ self.guarneri = guarneri
2563+ self.hypochondriacism = hypochondriacism
2564+ self.indication = indication
2565+ self.jaculative = jaculative
2566+ self.nagana = nagana
2567+ self.netherlandish = netherlandish
2568+ self.noctivagous = noctivagous
2569+ self.nonphysiological = nonphysiological
2570+ self.praxis = praxis
2571+ self.provision = provision
2572+ self.subterhuman = subterhuman
2573+ self.sunlit = sunlit
2574+ self.syncraniate = syncraniate
2575+ self.teachment = teachment
2576+ self.unmutinous = unmutinous
2577+ self.unstoppable = unstoppable
2578+ }
2579+}
2580+
2581+// MARK: OskarClass convenience initializers and mutators
2582+
2583+extension OskarClass {
2584+ convenience init(data: Data) throws {
2585+ let me = try newJSONDecoder().decode(OskarClass.self, from: data)
2586+ 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)
2587+ }
2588+
2589+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2590+ guard let data = json.data(using: encoding) else {
2591+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2592+ }
2593+ try self.init(data: data)
2594+ }
2595+
2596+ convenience init(fromURL url: URL) throws {
2597+ try self.init(data: try Data(contentsOf: url))
2598+ }
2599+
2600+ func with(
2601+ acrobates: JSONNull?? = nil,
2602+ beanshooter: JSONNull?? = nil,
2603+ bearhound: JSONNull?? = nil,
2604+ cayuga: JSONNull?? = nil,
2605+ guarneri: JSONNull?? = nil,
2606+ hypochondriacism: JSONNull?? = nil,
2607+ indication: JSONNull?? = nil,
2608+ jaculative: JSONNull?? = nil,
2609+ nagana: JSONNull?? = nil,
2610+ netherlandish: JSONNull?? = nil,
2611+ noctivagous: JSONNull?? = nil,
2612+ nonphysiological: JSONNull?? = nil,
2613+ praxis: JSONNull?? = nil,
2614+ provision: JSONNull?? = nil,
2615+ subterhuman: JSONNull?? = nil,
2616+ sunlit: JSONNull?? = nil,
2617+ syncraniate: JSONNull?? = nil,
2618+ teachment: JSONNull?? = nil,
2619+ unmutinous: JSONNull?? = nil,
2620+ unstoppable: JSONNull?? = nil
2621+ ) -> OskarClass {
2622+ return OskarClass(
2623+ acrobates: acrobates ?? self.acrobates,
2624+ beanshooter: beanshooter ?? self.beanshooter,
2625+ bearhound: bearhound ?? self.bearhound,
2626+ cayuga: cayuga ?? self.cayuga,
2627+ guarneri: guarneri ?? self.guarneri,
2628+ hypochondriacism: hypochondriacism ?? self.hypochondriacism,
2629+ indication: indication ?? self.indication,
2630+ jaculative: jaculative ?? self.jaculative,
2631+ nagana: nagana ?? self.nagana,
2632+ netherlandish: netherlandish ?? self.netherlandish,
2633+ noctivagous: noctivagous ?? self.noctivagous,
2634+ nonphysiological: nonphysiological ?? self.nonphysiological,
2635+ praxis: praxis ?? self.praxis,
2636+ provision: provision ?? self.provision,
2637+ subterhuman: subterhuman ?? self.subterhuman,
2638+ sunlit: sunlit ?? self.sunlit,
2639+ syncraniate: syncraniate ?? self.syncraniate,
2640+ teachment: teachment ?? self.teachment,
2641+ unmutinous: unmutinous ?? self.unmutinous,
2642+ unstoppable: unstoppable ?? self.unstoppable
2643+ )
2644+ }
2645+
2646+ func jsonData() throws -> Data {
2647+ return try newJSONEncoder().encode(self)
2648+ }
2649+
2650+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2651+ return String(data: try self.jsonData(), encoding: encoding)
2652+ }
2653+}
2654+
2655+enum RebeccaElement: Codable {
2656+ case integer(Int)
2657+ case rebecca(Rebecca)
2658+ case string(String)
2659+
2660+ init(from decoder: Decoder) throws {
2661+ let container = try decoder.singleValueContainer()
2662+ if let x = try? container.decode(Int.self) {
2663+ self = .integer(x)
2664+ return
2665+ }
2666+ if let x = try? container.decode(String.self) {
2667+ self = .string(x)
2668+ return
2669+ }
2670+ if let x = try? container.decode(Rebecca.self) {
2671+ self = .rebecca(x)
2672+ return
2673+ }
2674+ throw DecodingError.typeMismatch(RebeccaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for RebeccaElement"))
2675+ }
2676+
2677+ func encode(to encoder: Encoder) throws {
2678+ var container = encoder.singleValueContainer()
2679+ switch self {
2680+ case .integer(let x):
2681+ try container.encode(x)
2682+ case .rebecca(let x):
2683+ try container.encode(x)
2684+ case .string(let x):
2685+ try container.encode(x)
2686+ }
2687+ }
2688+}
2689+
2690+enum Rhomboganoidei: Codable {
2691+ case integerArray([Int])
2692+ case rebecca(Rebecca)
2693+ case string(String)
2694+
2695+ init(from decoder: Decoder) throws {
2696+ let container = try decoder.singleValueContainer()
2697+ if let x = try? container.decode([Int].self) {
2698+ self = .integerArray(x)
2699+ return
2700+ }
2701+ if let x = try? container.decode(String.self) {
2702+ self = .string(x)
2703+ return
2704+ }
2705+ if let x = try? container.decode(Rebecca.self) {
2706+ self = .rebecca(x)
2707+ return
2708+ }
2709+ throw DecodingError.typeMismatch(Rhomboganoidei.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Rhomboganoidei"))
2710+ }
2711+
2712+ func encode(to encoder: Encoder) throws {
2713+ var container = encoder.singleValueContainer()
2714+ switch self {
2715+ case .integerArray(let x):
2716+ try container.encode(x)
2717+ case .rebecca(let x):
2718+ try container.encode(x)
2719+ case .string(let x):
2720+ try container.encode(x)
2721+ }
2722+ }
2723+}
2724+
2725+enum Ruellia: Codable {
2726+ case bool(Bool)
2727+ case rebecca(Rebecca)
2728+ case string(String)
2729+
2730+ init(from decoder: Decoder) throws {
2731+ let container = try decoder.singleValueContainer()
2732+ if let x = try? container.decode(Bool.self) {
2733+ self = .bool(x)
2734+ return
2735+ }
2736+ if let x = try? container.decode(String.self) {
2737+ self = .string(x)
2738+ return
2739+ }
2740+ if let x = try? container.decode(Rebecca.self) {
2741+ self = .rebecca(x)
2742+ return
2743+ }
2744+ throw DecodingError.typeMismatch(Ruellia.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Ruellia"))
2745+ }
2746+
2747+ func encode(to encoder: Encoder) throws {
2748+ var container = encoder.singleValueContainer()
2749+ switch self {
2750+ case .bool(let x):
2751+ try container.encode(x)
2752+ case .rebecca(let x):
2753+ try container.encode(x)
2754+ case .string(let x):
2755+ try container.encode(x)
2756+ }
2757+ }
2758+}
2759+
2760+enum School: Codable {
2761+ case integer(Int)
2762+ case integerMap([String: Int])
2763+ case null
2764+
2765+ init(from decoder: Decoder) throws {
2766+ let container = try decoder.singleValueContainer()
2767+ if let x = try? container.decode(Int.self) {
2768+ self = .integer(x)
2769+ return
2770+ }
2771+ if let x = try? container.decode([String: Int].self) {
2772+ self = .integerMap(x)
2773+ return
2774+ }
2775+ if container.decodeNil() {
2776+ self = .null
2777+ return
2778+ }
2779+ throw DecodingError.typeMismatch(School.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for School"))
2780+ }
2781+
2782+ func encode(to encoder: Encoder) throws {
2783+ var container = encoder.singleValueContainer()
2784+ switch self {
2785+ case .integer(let x):
2786+ try container.encode(x)
2787+ case .integerMap(let x):
2788+ try container.encode(x)
2789+ case .null:
2790+ try container.encodeNil()
2791+ }
2792+ }
2793+}
2794+
2795+enum Shakespearolater: Codable {
2796+ case double(Double)
2797+ case integerArray([Int])
2798+ case string(String)
2799+
2800+ init(from decoder: Decoder) throws {
2801+ let container = try decoder.singleValueContainer()
2802+ if let x = try? container.decode([Int].self) {
2803+ self = .integerArray(x)
2804+ return
2805+ }
2806+ if let x = try? container.decode(Double.self) {
2807+ self = .double(x)
2808+ return
2809+ }
2810+ if let x = try? container.decode(String.self) {
2811+ self = .string(x)
2812+ return
2813+ }
2814+ throw DecodingError.typeMismatch(Shakespearolater.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Shakespearolater"))
2815+ }
2816+
2817+ func encode(to encoder: Encoder) throws {
2818+ var container = encoder.singleValueContainer()
2819+ switch self {
2820+ case .double(let x):
2821+ try container.encode(x)
2822+ case .integerArray(let x):
2823+ try container.encode(x)
2824+ case .string(let x):
2825+ try container.encode(x)
2826+ }
2827+ }
2828+}
2829+
2830+// MARK: - Helper functions for creating encoders and decoders
2831+
2832+func newJSONDecoder() -> JSONDecoder {
2833+ let decoder = JSONDecoder()
2834+ decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in
2835+ let container = try decoder.singleValueContainer()
2836+ let dateStr = try container.decode(String.self)
2837+
2838+ let formatter = DateFormatter()
2839+ formatter.calendar = Calendar(identifier: .iso8601)
2840+ formatter.locale = Locale(identifier: "en_US_POSIX")
2841+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
2842+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX"
2843+ if let date = formatter.date(from: dateStr) {
2844+ return date
2845+ }
2846+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX"
2847+ if let date = formatter.date(from: dateStr) {
2848+ return date
2849+ }
2850+ throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date"))
2851+ })
2852+ return decoder
2853+}
2854+
2855+func newJSONEncoder() -> JSONEncoder {
2856+ let encoder = JSONEncoder()
2857+ let formatter = DateFormatter()
2858+ formatter.calendar = Calendar(identifier: .iso8601)
2859+ formatter.locale = Locale(identifier: "en_US_POSIX")
2860+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
2861+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSXXXXX"
2862+ encoder.dateEncodingStrategy = .formatted(formatter)
2863+ return encoder
2864+}
2865+
2866+// MARK: - Encode/decode helpers
2867+
2868+final class JSONNull: Codable, Hashable {
2869+
2870+ public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool {
2871+ return true
2872+ }
2873+
2874+ public func hash(into hasher: inout Hasher) {
2875+ hasher.combine(0)
2876+ }
2877+
2878+ public init() {}
2879+
2880+ public required init(from decoder: Decoder) throws {
2881+ let container = try decoder.singleValueContainer()
2882+ if !container.decodeNil() {
2883+ throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull"))
2884+ }
2885+ }
2886+
2887+ public func encode(to encoder: Encoder) throws {
2888+ var container = encoder.singleValueContainer()
2889+ try container.encodeNil()
2890+ }
2891+}
Aswiftprotocol-hashable--739b516c7897 / quicktype.swift+2,668 −0
@@ -0,0 +1,2668 @@
1+// This file was generated from JSON Schema using quicktype, do not modify it directly.
2+// To parse the JSON, add this file to your project and do:
3+//
4+// let topLevel = try TopLevel(json)
5+
6+//
7+// Hashable or Equatable:
8+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
9+// for types that require the use of JSONAny, nor will the implementation of Hashable be
10+// synthesized for types that have collections (such as arrays or dictionaries).
11+
12+import Foundation
13+
14+// MARK: - TopLevel
15+struct TopLevel: Codable, Hashable {
16+ let abranchiata: [Abranchiata]
17+ let academe: [Academe]
18+ let acquirable: [Acquirable]
19+ let aerometry: [Aerometry]
20+ let alexin: [Alexin]
21+ let alleviate: [AlleviateElement]
22+ let amaas: [Amaa]
23+ let ambassage: [Ambassage]
24+ let amphithyron: [Amphithyron?]
25+ let andriana: [String?]
26+ let ankee: [AnkeeElement]
27+ let annihilator: [[String: Int?]?]
28+ let annulose: JSONNull?
29+ let ansarie: [AnsarieElement]
30+ let aphasia: [Aphasia]
31+ let asprawl: [Asprawl]
32+ let attractive: [Bool?]
33+ let barksome: [String: Int]
34+ let bedesman: [Bedesman]
35+ let belard: [Belard]
36+ let bocking: [Bocking]
37+ let brawlingly: [Brawlingly]
38+ let brookie: [Brookie]
39+ let bumboatman: [Bumboatman]
40+ let bystreet: [JSONNull?]
41+ let calaverite: [Calaverite]
42+ let catallactic: [Catallactic]
43+ let cemental: [Cemental]
44+ let chytridiaceae: [ChytridiaceaeElement]
45+ let discordia: [DiscordiaElement]
46+ let endomyces: [Endomyce]
47+ let epinephelidae: [Epinephelidae]
48+ let eupatorium: [Eupatorium]
49+ let gryphosaurus: [GryphosaurusElement]
50+ let koryak: [Koryak]
51+ let lavinia: [LaviniaElement]
52+ let oskar: [OskarElement]
53+ let rebecca: [RebeccaElement]
54+ let rhomboganoidei: [Rhomboganoidei]
55+ let rigsmal: Bool
56+ let ruellia: [Ruellia]
57+ let school: [School]
58+ let shakespearolater: [Shakespearolater]
59+ let svan: [Double]
60+ let wayao: [String: Double]
61+
62+ enum CodingKeys: String, CodingKey {
63+ case abranchiata = "Abranchiata"
64+ case academe = "academe"
65+ case acquirable = "acquirable"
66+ case aerometry = "aerometry"
67+ case alexin = "alexin"
68+ case alleviate = "alleviate"
69+ case amaas = "amaas"
70+ case ambassage = "ambassage"
71+ case amphithyron = "amphithyron"
72+ case andriana = "Andriana"
73+ case ankee = "ankee"
74+ case annihilator = "annihilator"
75+ case annulose = "annulose"
76+ case ansarie = "Ansarie"
77+ case aphasia = "aphasia"
78+ case asprawl = "asprawl"
79+ case attractive = "attractive"
80+ case barksome = "barksome"
81+ case bedesman = "bedesman"
82+ case belard = "belard"
83+ case bocking = "bocking"
84+ case brawlingly = "brawlingly"
85+ case brookie = "brookie"
86+ case bumboatman = "bumboatman"
87+ case bystreet = "bystreet"
88+ case calaverite = "calaverite"
89+ case catallactic = "catallactic"
90+ case cemental = "cemental"
91+ case chytridiaceae = "Chytridiaceae"
92+ case discordia = "Discordia"
93+ case endomyces = "Endomyces"
94+ case epinephelidae = "Epinephelidae"
95+ case eupatorium = "Eupatorium"
96+ case gryphosaurus = "Gryphosaurus"
97+ case koryak = "Koryak"
98+ case lavinia = "Lavinia"
99+ case oskar = "Oskar"
100+ case rebecca = "Rebecca"
101+ case rhomboganoidei = "Rhomboganoidei"
102+ case rigsmal = "Rigsmal"
103+ case ruellia = "Ruellia"
104+ case school = "School"
105+ case shakespearolater = "Shakespearolater"
106+ case svan = "Svan"
107+ case wayao = "Wayao"
108+ }
109+}
110+
111+// MARK: TopLevel convenience initializers and mutators
112+
113+extension TopLevel {
114+ init(data: Data) throws {
115+ self = try newJSONDecoder().decode(TopLevel.self, from: data)
116+ }
117+
118+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
119+ guard let data = json.data(using: encoding) else {
120+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
121+ }
122+ try self.init(data: data)
123+ }
124+
125+ init(fromURL url: URL) throws {
126+ try self.init(data: try Data(contentsOf: url))
127+ }
128+
129+ func with(
130+ abranchiata: [Abranchiata]? = nil,
131+ academe: [Academe]? = nil,
132+ acquirable: [Acquirable]? = nil,
133+ aerometry: [Aerometry]? = nil,
134+ alexin: [Alexin]? = nil,
135+ alleviate: [AlleviateElement]? = nil,
136+ amaas: [Amaa]? = nil,
137+ ambassage: [Ambassage]? = nil,
138+ amphithyron: [Amphithyron?]? = nil,
139+ andriana: [String?]? = nil,
140+ ankee: [AnkeeElement]? = nil,
141+ annihilator: [[String: Int?]?]? = nil,
142+ annulose: JSONNull?? = nil,
143+ ansarie: [AnsarieElement]? = nil,
144+ aphasia: [Aphasia]? = nil,
145+ asprawl: [Asprawl]? = nil,
146+ attractive: [Bool?]? = nil,
147+ barksome: [String: Int]? = nil,
148+ bedesman: [Bedesman]? = nil,
149+ belard: [Belard]? = nil,
150+ bocking: [Bocking]? = nil,
151+ brawlingly: [Brawlingly]? = nil,
152+ brookie: [Brookie]? = nil,
153+ bumboatman: [Bumboatman]? = nil,
154+ bystreet: [JSONNull?]? = nil,
155+ calaverite: [Calaverite]? = nil,
156+ catallactic: [Catallactic]? = nil,
157+ cemental: [Cemental]? = nil,
158+ chytridiaceae: [ChytridiaceaeElement]? = nil,
159+ discordia: [DiscordiaElement]? = nil,
160+ endomyces: [Endomyce]? = nil,
161+ epinephelidae: [Epinephelidae]? = nil,
162+ eupatorium: [Eupatorium]? = nil,
163+ gryphosaurus: [GryphosaurusElement]? = nil,
164+ koryak: [Koryak]? = nil,
165+ lavinia: [LaviniaElement]? = nil,
166+ oskar: [OskarElement]? = nil,
167+ rebecca: [RebeccaElement]? = nil,
168+ rhomboganoidei: [Rhomboganoidei]? = nil,
169+ rigsmal: Bool? = nil,
170+ ruellia: [Ruellia]? = nil,
171+ school: [School]? = nil,
172+ shakespearolater: [Shakespearolater]? = nil,
173+ svan: [Double]? = nil,
174+ wayao: [String: Double]? = nil
175+ ) -> TopLevel {
176+ return TopLevel(
177+ abranchiata: abranchiata ?? self.abranchiata,
178+ academe: academe ?? self.academe,
179+ acquirable: acquirable ?? self.acquirable,
180+ aerometry: aerometry ?? self.aerometry,
181+ alexin: alexin ?? self.alexin,
182+ alleviate: alleviate ?? self.alleviate,
183+ amaas: amaas ?? self.amaas,
184+ ambassage: ambassage ?? self.ambassage,
185+ amphithyron: amphithyron ?? self.amphithyron,
186+ andriana: andriana ?? self.andriana,
187+ ankee: ankee ?? self.ankee,
188+ annihilator: annihilator ?? self.annihilator,
189+ annulose: annulose ?? self.annulose,
190+ ansarie: ansarie ?? self.ansarie,
191+ aphasia: aphasia ?? self.aphasia,
192+ asprawl: asprawl ?? self.asprawl,
193+ attractive: attractive ?? self.attractive,
194+ barksome: barksome ?? self.barksome,
195+ bedesman: bedesman ?? self.bedesman,
196+ belard: belard ?? self.belard,
197+ bocking: bocking ?? self.bocking,
198+ brawlingly: brawlingly ?? self.brawlingly,
199+ brookie: brookie ?? self.brookie,
200+ bumboatman: bumboatman ?? self.bumboatman,
201+ bystreet: bystreet ?? self.bystreet,
202+ calaverite: calaverite ?? self.calaverite,
203+ catallactic: catallactic ?? self.catallactic,
204+ cemental: cemental ?? self.cemental,
205+ chytridiaceae: chytridiaceae ?? self.chytridiaceae,
206+ discordia: discordia ?? self.discordia,
207+ endomyces: endomyces ?? self.endomyces,
208+ epinephelidae: epinephelidae ?? self.epinephelidae,
209+ eupatorium: eupatorium ?? self.eupatorium,
210+ gryphosaurus: gryphosaurus ?? self.gryphosaurus,
211+ koryak: koryak ?? self.koryak,
212+ lavinia: lavinia ?? self.lavinia,
213+ oskar: oskar ?? self.oskar,
214+ rebecca: rebecca ?? self.rebecca,
215+ rhomboganoidei: rhomboganoidei ?? self.rhomboganoidei,
216+ rigsmal: rigsmal ?? self.rigsmal,
217+ ruellia: ruellia ?? self.ruellia,
218+ school: school ?? self.school,
219+ shakespearolater: shakespearolater ?? self.shakespearolater,
220+ svan: svan ?? self.svan,
221+ wayao: wayao ?? self.wayao
222+ )
223+ }
224+
225+ func jsonData() throws -> Data {
226+ return try newJSONEncoder().encode(self)
227+ }
228+
229+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
230+ return String(data: try self.jsonData(), encoding: encoding)
231+ }
232+}
233+
234+enum Abranchiata: Codable, Hashable {
235+ case integer(Int)
236+ case integerArray([Int])
237+ case null
238+
239+ init(from decoder: Decoder) throws {
240+ let container = try decoder.singleValueContainer()
241+ if let x = try? container.decode(Int.self) {
242+ self = .integer(x)
243+ return
244+ }
245+ if let x = try? container.decode([Int].self) {
246+ self = .integerArray(x)
247+ return
248+ }
249+ if container.decodeNil() {
250+ self = .null
251+ return
252+ }
253+ throw DecodingError.typeMismatch(Abranchiata.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Abranchiata"))
254+ }
255+
256+ func encode(to encoder: Encoder) throws {
257+ var container = encoder.singleValueContainer()
258+ switch self {
259+ case .integer(let x):
260+ try container.encode(x)
261+ case .integerArray(let x):
262+ try container.encode(x)
263+ case .null:
264+ try container.encodeNil()
265+ }
266+ }
267+}
268+
269+enum Academe: Codable, Hashable {
270+ case integer(Int)
271+ case integerArray([Int])
272+ case integerMap([String: Int])
273+
274+ init(from decoder: Decoder) throws {
275+ let container = try decoder.singleValueContainer()
276+ if let x = try? container.decode(Int.self) {
277+ self = .integer(x)
278+ return
279+ }
280+ if let x = try? container.decode([Int].self) {
281+ self = .integerArray(x)
282+ return
283+ }
284+ if let x = try? container.decode([String: Int].self) {
285+ self = .integerMap(x)
286+ return
287+ }
288+ throw DecodingError.typeMismatch(Academe.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Academe"))
289+ }
290+
291+ func encode(to encoder: Encoder) throws {
292+ var container = encoder.singleValueContainer()
293+ switch self {
294+ case .integer(let x):
295+ try container.encode(x)
296+ case .integerArray(let x):
297+ try container.encode(x)
298+ case .integerMap(let x):
299+ try container.encode(x)
300+ }
301+ }
302+}
303+
304+enum Acquirable: Codable, Hashable {
305+ case integerMap([String: Int])
306+ case unionArray([Int?])
307+
308+ init(from decoder: Decoder) throws {
309+ let container = try decoder.singleValueContainer()
310+ if let x = try? container.decode([Int?].self) {
311+ self = .unionArray(x)
312+ return
313+ }
314+ if let x = try? container.decode([String: Int].self) {
315+ self = .integerMap(x)
316+ return
317+ }
318+ throw DecodingError.typeMismatch(Acquirable.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Acquirable"))
319+ }
320+
321+ func encode(to encoder: Encoder) throws {
322+ var container = encoder.singleValueContainer()
323+ switch self {
324+ case .integerMap(let x):
325+ try container.encode(x)
326+ case .unionArray(let x):
327+ try container.encode(x)
328+ }
329+ }
330+}
331+
332+enum Aerometry: Codable, Hashable {
333+ case bool(Bool)
334+ case double(Double)
335+
336+ init(from decoder: Decoder) throws {
337+ let container = try decoder.singleValueContainer()
338+ if let x = try? container.decode(Bool.self) {
339+ self = .bool(x)
340+ return
341+ }
342+ if let x = try? container.decode(Double.self) {
343+ self = .double(x)
344+ return
345+ }
346+ throw DecodingError.typeMismatch(Aerometry.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Aerometry"))
347+ }
348+
349+ func encode(to encoder: Encoder) throws {
350+ var container = encoder.singleValueContainer()
351+ switch self {
352+ case .bool(let x):
353+ try container.encode(x)
354+ case .double(let x):
355+ try container.encode(x)
356+ }
357+ }
358+}
359+
360+enum Alexin: Codable, Hashable {
361+ case bool(Bool)
362+ case integerArray([Int])
363+
364+ init(from decoder: Decoder) throws {
365+ let container = try decoder.singleValueContainer()
366+ if let x = try? container.decode(Bool.self) {
367+ self = .bool(x)
368+ return
369+ }
370+ if let x = try? container.decode([Int].self) {
371+ self = .integerArray(x)
372+ return
373+ }
374+ throw DecodingError.typeMismatch(Alexin.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Alexin"))
375+ }
376+
377+ func encode(to encoder: Encoder) throws {
378+ var container = encoder.singleValueContainer()
379+ switch self {
380+ case .bool(let x):
381+ try container.encode(x)
382+ case .integerArray(let x):
383+ try container.encode(x)
384+ }
385+ }
386+}
387+
388+enum AlleviateElement: Codable, Hashable {
389+ case alleviateClass(AlleviateClass)
390+ case unionArray([Int?])
391+
392+ init(from decoder: Decoder) throws {
393+ let container = try decoder.singleValueContainer()
394+ if let x = try? container.decode([Int?].self) {
395+ self = .unionArray(x)
396+ return
397+ }
398+ if let x = try? container.decode(AlleviateClass.self) {
399+ self = .alleviateClass(x)
400+ return
401+ }
402+ throw DecodingError.typeMismatch(AlleviateElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for AlleviateElement"))
403+ }
404+
405+ func encode(to encoder: Encoder) throws {
406+ var container = encoder.singleValueContainer()
407+ switch self {
408+ case .alleviateClass(let x):
409+ try container.encode(x)
410+ case .unionArray(let x):
411+ try container.encode(x)
412+ }
413+ }
414+}
415+
416+//
417+// Hashable or Equatable:
418+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
419+// for types that require the use of JSONAny, nor will the implementation of Hashable be
420+// synthesized for types that have collections (such as arrays or dictionaries).
421+
422+// MARK: - AlleviateClass
423+struct AlleviateClass: Codable, Hashable {
424+ let apriori: JSONNull?
425+ let beggarer: JSONNull?
426+ let brokenheartedly: JSONNull?
427+ let debilitation: JSONNull?
428+ let frike: JSONNull?
429+ let gastrolith: JSONNull?
430+ let hulsean: JSONNull?
431+ let orthocentric: JSONNull?
432+ let petaly: JSONNull?
433+ let probudgeting: JSONNull?
434+ let reacquire: JSONNull?
435+ let scow: JSONNull?
436+ let shutoff: JSONNull?
437+ let subcontiguous: JSONNull?
438+ let suffumigate: JSONNull?
439+ let transformable: JSONNull?
440+ let uncoroneted: JSONNull?
441+ let unparking: JSONNull?
442+ let unvarnishedness: JSONNull?
443+ let wherewithal: JSONNull?
444+
445+ enum CodingKeys: String, CodingKey {
446+ case apriori = "apriori"
447+ case beggarer = "beggarer"
448+ case brokenheartedly = "brokenheartedly"
449+ case debilitation = "debilitation"
450+ case frike = "frike"
451+ case gastrolith = "gastrolith"
452+ case hulsean = "Hulsean"
453+ case orthocentric = "orthocentric"
454+ case petaly = "petaly"
455+ case probudgeting = "probudgeting"
456+ case reacquire = "reacquire"
457+ case scow = "scow"
458+ case shutoff = "shutoff"
459+ case subcontiguous = "subcontiguous"
460+ case suffumigate = "suffumigate"
461+ case transformable = "transformable"
462+ case uncoroneted = "uncoroneted"
463+ case unparking = "unparking"
464+ case unvarnishedness = "unvarnishedness"
465+ case wherewithal = "wherewithal"
466+ }
467+}
468+
469+// MARK: AlleviateClass convenience initializers and mutators
470+
471+extension AlleviateClass {
472+ init(data: Data) throws {
473+ self = try newJSONDecoder().decode(AlleviateClass.self, from: data)
474+ }
475+
476+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
477+ guard let data = json.data(using: encoding) else {
478+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
479+ }
480+ try self.init(data: data)
481+ }
482+
483+ init(fromURL url: URL) throws {
484+ try self.init(data: try Data(contentsOf: url))
485+ }
486+
487+ func with(
488+ apriori: JSONNull?? = nil,
489+ beggarer: JSONNull?? = nil,
490+ brokenheartedly: JSONNull?? = nil,
491+ debilitation: JSONNull?? = nil,
492+ frike: JSONNull?? = nil,
493+ gastrolith: JSONNull?? = nil,
494+ hulsean: JSONNull?? = nil,
495+ orthocentric: JSONNull?? = nil,
496+ petaly: JSONNull?? = nil,
497+ probudgeting: JSONNull?? = nil,
498+ reacquire: JSONNull?? = nil,
499+ scow: JSONNull?? = nil,
500+ shutoff: JSONNull?? = nil,
501+ subcontiguous: JSONNull?? = nil,
502+ suffumigate: JSONNull?? = nil,
503+ transformable: JSONNull?? = nil,
504+ uncoroneted: JSONNull?? = nil,
505+ unparking: JSONNull?? = nil,
506+ unvarnishedness: JSONNull?? = nil,
507+ wherewithal: JSONNull?? = nil
508+ ) -> AlleviateClass {
509+ return AlleviateClass(
510+ apriori: apriori ?? self.apriori,
511+ beggarer: beggarer ?? self.beggarer,
512+ brokenheartedly: brokenheartedly ?? self.brokenheartedly,
513+ debilitation: debilitation ?? self.debilitation,
514+ frike: frike ?? self.frike,
515+ gastrolith: gastrolith ?? self.gastrolith,
516+ hulsean: hulsean ?? self.hulsean,
517+ orthocentric: orthocentric ?? self.orthocentric,
518+ petaly: petaly ?? self.petaly,
519+ probudgeting: probudgeting ?? self.probudgeting,
520+ reacquire: reacquire ?? self.reacquire,
521+ scow: scow ?? self.scow,
522+ shutoff: shutoff ?? self.shutoff,
523+ subcontiguous: subcontiguous ?? self.subcontiguous,
524+ suffumigate: suffumigate ?? self.suffumigate,
525+ transformable: transformable ?? self.transformable,
526+ uncoroneted: uncoroneted ?? self.uncoroneted,
527+ unparking: unparking ?? self.unparking,
528+ unvarnishedness: unvarnishedness ?? self.unvarnishedness,
529+ wherewithal: wherewithal ?? self.wherewithal
530+ )
531+ }
532+
533+ func jsonData() throws -> Data {
534+ return try newJSONEncoder().encode(self)
535+ }
536+
537+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
538+ return String(data: try self.jsonData(), encoding: encoding)
539+ }
540+}
541+
542+enum Amaa: Codable, Hashable {
543+ case bool(Bool)
544+ case integer(Int)
545+ case rebecca(Rebecca)
546+
547+ init(from decoder: Decoder) throws {
548+ let container = try decoder.singleValueContainer()
549+ if let x = try? container.decode(Bool.self) {
550+ self = .bool(x)
551+ return
552+ }
553+ if let x = try? container.decode(Int.self) {
554+ self = .integer(x)
555+ return
556+ }
557+ if let x = try? container.decode(Rebecca.self) {
558+ self = .rebecca(x)
559+ return
560+ }
561+ throw DecodingError.typeMismatch(Amaa.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Amaa"))
562+ }
563+
564+ func encode(to encoder: Encoder) throws {
565+ var container = encoder.singleValueContainer()
566+ switch self {
567+ case .bool(let x):
568+ try container.encode(x)
569+ case .integer(let x):
570+ try container.encode(x)
571+ case .rebecca(let x):
572+ try container.encode(x)
573+ }
574+ }
575+}
576+
577+//
578+// Hashable or Equatable:
579+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
580+// for types that require the use of JSONAny, nor will the implementation of Hashable be
581+// synthesized for types that have collections (such as arrays or dictionaries).
582+
583+// MARK: - Rebecca
584+struct Rebecca: Codable, Hashable {
585+ let catharticalness: Double
586+ let chirotherium: Int
587+ let disdiapason: String
588+ let homocerc: Bool
589+ let nonbookish: JSONNull?
590+
591+ enum CodingKeys: String, CodingKey {
592+ case catharticalness = "catharticalness"
593+ case chirotherium = "Chirotherium"
594+ case disdiapason = "disdiapason"
595+ case homocerc = "homocerc"
596+ case nonbookish = "nonbookish"
597+ }
598+}
599+
600+// MARK: Rebecca convenience initializers and mutators
601+
602+extension Rebecca {
603+ init(data: Data) throws {
604+ self = try newJSONDecoder().decode(Rebecca.self, from: data)
605+ }
606+
607+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
608+ guard let data = json.data(using: encoding) else {
609+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
610+ }
611+ try self.init(data: data)
612+ }
613+
614+ init(fromURL url: URL) throws {
615+ try self.init(data: try Data(contentsOf: url))
616+ }
617+
618+ func with(
619+ catharticalness: Double? = nil,
620+ chirotherium: Int? = nil,
621+ disdiapason: String? = nil,
622+ homocerc: Bool? = nil,
623+ nonbookish: JSONNull?? = nil
624+ ) -> Rebecca {
625+ return Rebecca(
626+ catharticalness: catharticalness ?? self.catharticalness,
627+ chirotherium: chirotherium ?? self.chirotherium,
628+ disdiapason: disdiapason ?? self.disdiapason,
629+ homocerc: homocerc ?? self.homocerc,
630+ nonbookish: nonbookish ?? self.nonbookish
631+ )
632+ }
633+
634+ func jsonData() throws -> Data {
635+ return try newJSONEncoder().encode(self)
636+ }
637+
638+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
639+ return String(data: try self.jsonData(), encoding: encoding)
640+ }
641+}
642+
643+enum Ambassage: Codable, Hashable {
644+ case nullArray([JSONNull?])
645+ case string(String)
646+
647+ init(from decoder: Decoder) throws {
648+ let container = try decoder.singleValueContainer()
649+ if let x = try? container.decode([JSONNull?].self) {
650+ self = .nullArray(x)
651+ return
652+ }
653+ if let x = try? container.decode(String.self) {
654+ self = .string(x)
655+ return
656+ }
657+ throw DecodingError.typeMismatch(Ambassage.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Ambassage"))
658+ }
659+
660+ func encode(to encoder: Encoder) throws {
661+ var container = encoder.singleValueContainer()
662+ switch self {
663+ case .nullArray(let x):
664+ try container.encode(x)
665+ case .string(let x):
666+ try container.encode(x)
667+ }
668+ }
669+}
670+
671+//
672+// Hashable or Equatable:
673+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
674+// for types that require the use of JSONAny, nor will the implementation of Hashable be
675+// synthesized for types that have collections (such as arrays or dictionaries).
676+
677+// MARK: - Amphithyron
678+struct Amphithyron: Codable, Hashable {
679+ let akroasis: Int?
680+ let antiphonical: Int?
681+ let basebred: Int?
682+ let catharticalness: Double?
683+ let chirotherium: Int?
684+ let conductometric: Int?
685+ let disdiapason: String?
686+ let ensilation: Int?
687+ let eyebolt: Int?
688+ let fistulated: Int?
689+ let heteropod: Int?
690+ let homocerc: Bool?
691+ let juniperus: Int?
692+ let labyrinthically: Int?
693+ let martyrization: Int?
694+ let mispolicy: Int?
695+ let multipara: Int?
696+ let nazirite: Int?
697+ let nonbookish: JSONNull?
698+ let possessorial: Int?
699+ let shamed: Int?
700+ let shelfworn: Int?
701+ let stagnum: Int?
702+ let those: Int?
703+ let undecimal: Int?
704+
705+ enum CodingKeys: String, CodingKey {
706+ case akroasis = "akroasis"
707+ case antiphonical = "antiphonical"
708+ case basebred = "basebred"
709+ case catharticalness = "catharticalness"
710+ case chirotherium = "Chirotherium"
711+ case conductometric = "conductometric"
712+ case disdiapason = "disdiapason"
713+ case ensilation = "ensilation"
714+ case eyebolt = "eyebolt"
715+ case fistulated = "fistulated"
716+ case heteropod = "heteropod"
717+ case homocerc = "homocerc"
718+ case juniperus = "Juniperus"
719+ case labyrinthically = "labyrinthically"
720+ case martyrization = "martyrization"
721+ case mispolicy = "mispolicy"
722+ case multipara = "multipara"
723+ case nazirite = "Nazirite"
724+ case nonbookish = "nonbookish"
725+ case possessorial = "possessorial"
726+ case shamed = "shamed"
727+ case shelfworn = "shelfworn"
728+ case stagnum = "stagnum"
729+ case those = "Those"
730+ case undecimal = "undecimal"
731+ }
732+}
733+
734+// MARK: Amphithyron convenience initializers and mutators
735+
736+extension Amphithyron {
737+ init(data: Data) throws {
738+ self = try newJSONDecoder().decode(Amphithyron.self, from: data)
739+ }
740+
741+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
742+ guard let data = json.data(using: encoding) else {
743+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
744+ }
745+ try self.init(data: data)
746+ }
747+
748+ init(fromURL url: URL) throws {
749+ try self.init(data: try Data(contentsOf: url))
750+ }
751+
752+ func with(
753+ akroasis: Int?? = nil,
754+ antiphonical: Int?? = nil,
755+ basebred: Int?? = nil,
756+ catharticalness: Double?? = nil,
757+ chirotherium: Int?? = nil,
758+ conductometric: Int?? = nil,
759+ disdiapason: String?? = nil,
760+ ensilation: Int?? = nil,
761+ eyebolt: Int?? = nil,
762+ fistulated: Int?? = nil,
763+ heteropod: Int?? = nil,
764+ homocerc: Bool?? = nil,
765+ juniperus: Int?? = nil,
766+ labyrinthically: Int?? = nil,
767+ martyrization: Int?? = nil,
768+ mispolicy: Int?? = nil,
769+ multipara: Int?? = nil,
770+ nazirite: Int?? = nil,
771+ nonbookish: JSONNull?? = nil,
772+ possessorial: Int?? = nil,
773+ shamed: Int?? = nil,
774+ shelfworn: Int?? = nil,
775+ stagnum: Int?? = nil,
776+ those: Int?? = nil,
777+ undecimal: Int?? = nil
778+ ) -> Amphithyron {
779+ return Amphithyron(
780+ akroasis: akroasis ?? self.akroasis,
781+ antiphonical: antiphonical ?? self.antiphonical,
782+ basebred: basebred ?? self.basebred,
783+ catharticalness: catharticalness ?? self.catharticalness,
784+ chirotherium: chirotherium ?? self.chirotherium,
785+ conductometric: conductometric ?? self.conductometric,
786+ disdiapason: disdiapason ?? self.disdiapason,
787+ ensilation: ensilation ?? self.ensilation,
788+ eyebolt: eyebolt ?? self.eyebolt,
789+ fistulated: fistulated ?? self.fistulated,
790+ heteropod: heteropod ?? self.heteropod,
791+ homocerc: homocerc ?? self.homocerc,
792+ juniperus: juniperus ?? self.juniperus,
793+ labyrinthically: labyrinthically ?? self.labyrinthically,
794+ martyrization: martyrization ?? self.martyrization,
795+ mispolicy: mispolicy ?? self.mispolicy,
796+ multipara: multipara ?? self.multipara,
797+ nazirite: nazirite ?? self.nazirite,
798+ nonbookish: nonbookish ?? self.nonbookish,
799+ possessorial: possessorial ?? self.possessorial,
800+ shamed: shamed ?? self.shamed,
801+ shelfworn: shelfworn ?? self.shelfworn,
802+ stagnum: stagnum ?? self.stagnum,
803+ those: those ?? self.those,
804+ undecimal: undecimal ?? self.undecimal
805+ )
806+ }
807+
808+ func jsonData() throws -> Data {
809+ return try newJSONEncoder().encode(self)
810+ }
811+
812+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
813+ return String(data: try self.jsonData(), encoding: encoding)
814+ }
815+}
816+
817+enum AnkeeElement: Codable, Hashable {
818+ case ankeeClass(AnkeeClass)
819+ case integer(Int)
820+ case integerArray([Int])
821+
822+ init(from decoder: Decoder) throws {
823+ let container = try decoder.singleValueContainer()
824+ if let x = try? container.decode(Int.self) {
825+ self = .integer(x)
826+ return
827+ }
828+ if let x = try? container.decode([Int].self) {
829+ self = .integerArray(x)
830+ return
831+ }
832+ if let x = try? container.decode(AnkeeClass.self) {
833+ self = .ankeeClass(x)
834+ return
835+ }
836+ throw DecodingError.typeMismatch(AnkeeElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for AnkeeElement"))
837+ }
838+
839+ func encode(to encoder: Encoder) throws {
840+ var container = encoder.singleValueContainer()
841+ switch self {
842+ case .ankeeClass(let x):
843+ try container.encode(x)
844+ case .integer(let x):
845+ try container.encode(x)
846+ case .integerArray(let x):
847+ try container.encode(x)
848+ }
849+ }
850+}
851+
852+//
853+// Hashable or Equatable:
854+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
855+// for types that require the use of JSONAny, nor will the implementation of Hashable be
856+// synthesized for types that have collections (such as arrays or dictionaries).
857+
858+// MARK: - AnkeeClass
859+struct AnkeeClass: Codable, Hashable {
860+ let anomoean: JSONNull?
861+ let barleyhood: JSONNull?
862+ let befriender: JSONNull?
863+ let brutishness: JSONNull?
864+ let cephalalgy: JSONNull?
865+ let cirurgian: JSONNull?
866+ let conventionally: JSONNull?
867+ let jackshay: JSONNull?
868+ let milammeter: JSONNull?
869+ let naja: JSONNull?
870+ let ombrological: JSONNull?
871+ let phonasthenia: JSONNull?
872+ let retrievableness: JSONNull?
873+ let snakily: JSONNull?
874+ let swot: JSONNull?
875+ let tartlet: JSONNull?
876+ let thiofuran: JSONNull?
877+ let tracheophone: JSONNull?
878+ let tuglike: JSONNull?
879+ let unscratchingly: JSONNull?
880+
881+ enum CodingKeys: String, CodingKey {
882+ case anomoean = "Anomoean"
883+ case barleyhood = "barleyhood"
884+ case befriender = "befriender"
885+ case brutishness = "brutishness"
886+ case cephalalgy = "cephalalgy"
887+ case cirurgian = "cirurgian"
888+ case conventionally = "conventionally"
889+ case jackshay = "jackshay"
890+ case milammeter = "milammeter"
891+ case naja = "Naja"
892+ case ombrological = "ombrological"
893+ case phonasthenia = "phonasthenia"
894+ case retrievableness = "retrievableness"
895+ case snakily = "snakily"
896+ case swot = "swot"
897+ case tartlet = "tartlet"
898+ case thiofuran = "thiofuran"
899+ case tracheophone = "tracheophone"
900+ case tuglike = "tuglike"
901+ case unscratchingly = "unscratchingly"
902+ }
903+}
904+
905+// MARK: AnkeeClass convenience initializers and mutators
906+
907+extension AnkeeClass {
908+ init(data: Data) throws {
909+ self = try newJSONDecoder().decode(AnkeeClass.self, from: data)
910+ }
911+
912+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
913+ guard let data = json.data(using: encoding) else {
914+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
915+ }
916+ try self.init(data: data)
917+ }
918+
919+ init(fromURL url: URL) throws {
920+ try self.init(data: try Data(contentsOf: url))
921+ }
922+
923+ func with(
924+ anomoean: JSONNull?? = nil,
925+ barleyhood: JSONNull?? = nil,
926+ befriender: JSONNull?? = nil,
927+ brutishness: JSONNull?? = nil,
928+ cephalalgy: JSONNull?? = nil,
929+ cirurgian: JSONNull?? = nil,
930+ conventionally: JSONNull?? = nil,
931+ jackshay: JSONNull?? = nil,
932+ milammeter: JSONNull?? = nil,
933+ naja: JSONNull?? = nil,
934+ ombrological: JSONNull?? = nil,
935+ phonasthenia: JSONNull?? = nil,
936+ retrievableness: JSONNull?? = nil,
937+ snakily: JSONNull?? = nil,
938+ swot: JSONNull?? = nil,
939+ tartlet: JSONNull?? = nil,
940+ thiofuran: JSONNull?? = nil,
941+ tracheophone: JSONNull?? = nil,
942+ tuglike: JSONNull?? = nil,
943+ unscratchingly: JSONNull?? = nil
944+ ) -> AnkeeClass {
945+ return AnkeeClass(
946+ anomoean: anomoean ?? self.anomoean,
947+ barleyhood: barleyhood ?? self.barleyhood,
948+ befriender: befriender ?? self.befriender,
949+ brutishness: brutishness ?? self.brutishness,
950+ cephalalgy: cephalalgy ?? self.cephalalgy,
951+ cirurgian: cirurgian ?? self.cirurgian,
952+ conventionally: conventionally ?? self.conventionally,
953+ jackshay: jackshay ?? self.jackshay,
954+ milammeter: milammeter ?? self.milammeter,
955+ naja: naja ?? self.naja,
956+ ombrological: ombrological ?? self.ombrological,
957+ phonasthenia: phonasthenia ?? self.phonasthenia,
958+ retrievableness: retrievableness ?? self.retrievableness,
959+ snakily: snakily ?? self.snakily,
960+ swot: swot ?? self.swot,
961+ tartlet: tartlet ?? self.tartlet,
962+ thiofuran: thiofuran ?? self.thiofuran,
963+ tracheophone: tracheophone ?? self.tracheophone,
964+ tuglike: tuglike ?? self.tuglike,
965+ unscratchingly: unscratchingly ?? self.unscratchingly
966+ )
967+ }
968+
969+ func jsonData() throws -> Data {
970+ return try newJSONEncoder().encode(self)
971+ }
972+
973+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
974+ return String(data: try self.jsonData(), encoding: encoding)
975+ }
976+}
977+
978+enum AnsarieElement: Codable, Hashable {
979+ case ansarieClass(AnsarieClass)
980+ case integerArray([Int])
981+ case null
982+
983+ init(from decoder: Decoder) throws {
984+ let container = try decoder.singleValueContainer()
985+ if let x = try? container.decode([Int].self) {
986+ self = .integerArray(x)
987+ return
988+ }
989+ if let x = try? container.decode(AnsarieClass.self) {
990+ self = .ansarieClass(x)
991+ return
992+ }
993+ if container.decodeNil() {
994+ self = .null
995+ return
996+ }
997+ throw DecodingError.typeMismatch(AnsarieElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for AnsarieElement"))
998+ }
999+
1000+ func encode(to encoder: Encoder) throws {
1001+ var container = encoder.singleValueContainer()
1002+ switch self {
1003+ case .ansarieClass(let x):
1004+ try container.encode(x)
1005+ case .integerArray(let x):
1006+ try container.encode(x)
1007+ case .null:
1008+ try container.encodeNil()
1009+ }
1010+ }
1011+}
1012+
1013+//
1014+// Hashable or Equatable:
1015+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
1016+// for types that require the use of JSONAny, nor will the implementation of Hashable be
1017+// synthesized for types that have collections (such as arrays or dictionaries).
1018+
1019+// MARK: - AnsarieClass
1020+struct AnsarieClass: Codable, Hashable {
1021+ let accension: JSONNull?
1022+ let alida: JSONNull?
1023+ let asteria: JSONNull?
1024+ let beriberic: JSONNull?
1025+ let edgebone: JSONNull?
1026+ let gastrodialysis: JSONNull?
1027+ let geographic: JSONNull?
1028+ let ictonyx: JSONNull?
1029+ let metrocele: JSONNull?
1030+ let misgraft: JSONNull?
1031+ let monteith: JSONNull?
1032+ let notcher: JSONNull?
1033+ let prorestriction: JSONNull?
1034+ let ramist: JSONNull?
1035+ let throatlet: JSONNull?
1036+ let unfair: JSONNull?
1037+ let unsynonymous: JSONNull?
1038+ let water: JSONNull?
1039+ let zestfully: JSONNull?
1040+ let zincic: JSONNull?
1041+
1042+ enum CodingKeys: String, CodingKey {
1043+ case accension = "accension"
1044+ case alida = "Alida"
1045+ case asteria = "asteria"
1046+ case beriberic = "beriberic"
1047+ case edgebone = "edgebone"
1048+ case gastrodialysis = "gastrodialysis"
1049+ case geographic = "geographic"
1050+ case ictonyx = "Ictonyx"
1051+ case metrocele = "metrocele"
1052+ case misgraft = "misgraft"
1053+ case monteith = "monteith"
1054+ case notcher = "notcher"
1055+ case prorestriction = "prorestriction"
1056+ case ramist = "Ramist"
1057+ case throatlet = "throatlet"
1058+ case unfair = "unfair"
1059+ case unsynonymous = "unsynonymous"
1060+ case water = "water"
1061+ case zestfully = "zestfully"
1062+ case zincic = "zincic"
1063+ }
1064+}
1065+
1066+// MARK: AnsarieClass convenience initializers and mutators
1067+
1068+extension AnsarieClass {
1069+ init(data: Data) throws {
1070+ self = try newJSONDecoder().decode(AnsarieClass.self, from: data)
1071+ }
1072+
1073+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1074+ guard let data = json.data(using: encoding) else {
1075+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1076+ }
1077+ try self.init(data: data)
1078+ }
1079+
1080+ init(fromURL url: URL) throws {
1081+ try self.init(data: try Data(contentsOf: url))
1082+ }
1083+
1084+ func with(
1085+ accension: JSONNull?? = nil,
1086+ alida: JSONNull?? = nil,
1087+ asteria: JSONNull?? = nil,
1088+ beriberic: JSONNull?? = nil,
1089+ edgebone: JSONNull?? = nil,
1090+ gastrodialysis: JSONNull?? = nil,
1091+ geographic: JSONNull?? = nil,
1092+ ictonyx: JSONNull?? = nil,
1093+ metrocele: JSONNull?? = nil,
1094+ misgraft: JSONNull?? = nil,
1095+ monteith: JSONNull?? = nil,
1096+ notcher: JSONNull?? = nil,
1097+ prorestriction: JSONNull?? = nil,
1098+ ramist: JSONNull?? = nil,
1099+ throatlet: JSONNull?? = nil,
1100+ unfair: JSONNull?? = nil,
1101+ unsynonymous: JSONNull?? = nil,
1102+ water: JSONNull?? = nil,
1103+ zestfully: JSONNull?? = nil,
1104+ zincic: JSONNull?? = nil
1105+ ) -> AnsarieClass {
1106+ return AnsarieClass(
1107+ accension: accension ?? self.accension,
1108+ alida: alida ?? self.alida,
1109+ asteria: asteria ?? self.asteria,
1110+ beriberic: beriberic ?? self.beriberic,
1111+ edgebone: edgebone ?? self.edgebone,
1112+ gastrodialysis: gastrodialysis ?? self.gastrodialysis,
1113+ geographic: geographic ?? self.geographic,
1114+ ictonyx: ictonyx ?? self.ictonyx,
1115+ metrocele: metrocele ?? self.metrocele,
1116+ misgraft: misgraft ?? self.misgraft,
1117+ monteith: monteith ?? self.monteith,
1118+ notcher: notcher ?? self.notcher,
1119+ prorestriction: prorestriction ?? self.prorestriction,
1120+ ramist: ramist ?? self.ramist,
1121+ throatlet: throatlet ?? self.throatlet,
1122+ unfair: unfair ?? self.unfair,
1123+ unsynonymous: unsynonymous ?? self.unsynonymous,
1124+ water: water ?? self.water,
1125+ zestfully: zestfully ?? self.zestfully,
1126+ zincic: zincic ?? self.zincic
1127+ )
1128+ }
1129+
1130+ func jsonData() throws -> Data {
1131+ return try newJSONEncoder().encode(self)
1132+ }
1133+
1134+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1135+ return String(data: try self.jsonData(), encoding: encoding)
1136+ }
1137+}
1138+
1139+enum Aphasia: Codable, Hashable {
1140+ case integer(Int)
1141+ case integerArray([Int])
1142+
1143+ init(from decoder: Decoder) throws {
1144+ let container = try decoder.singleValueContainer()
1145+ if let x = try? container.decode(Int.self) {
1146+ self = .integer(x)
1147+ return
1148+ }
1149+ if let x = try? container.decode([Int].self) {
1150+ self = .integerArray(x)
1151+ return
1152+ }
1153+ throw DecodingError.typeMismatch(Aphasia.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Aphasia"))
1154+ }
1155+
1156+ func encode(to encoder: Encoder) throws {
1157+ var container = encoder.singleValueContainer()
1158+ switch self {
1159+ case .integer(let x):
1160+ try container.encode(x)
1161+ case .integerArray(let x):
1162+ try container.encode(x)
1163+ }
1164+ }
1165+}
1166+
1167+enum Asprawl: Codable, Hashable {
1168+ case double(Double)
1169+ case string(String)
1170+
1171+ init(from decoder: Decoder) throws {
1172+ let container = try decoder.singleValueContainer()
1173+ if let x = try? container.decode(Double.self) {
1174+ self = .double(x)
1175+ return
1176+ }
1177+ if let x = try? container.decode(String.self) {
1178+ self = .string(x)
1179+ return
1180+ }
1181+ throw DecodingError.typeMismatch(Asprawl.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Asprawl"))
1182+ }
1183+
1184+ func encode(to encoder: Encoder) throws {
1185+ var container = encoder.singleValueContainer()
1186+ switch self {
1187+ case .double(let x):
1188+ try container.encode(x)
1189+ case .string(let x):
1190+ try container.encode(x)
1191+ }
1192+ }
1193+}
1194+
1195+enum Bedesman: Codable, Hashable {
1196+ case bool(Bool)
1197+ case double(Double)
1198+ case string(String)
1199+
1200+ init(from decoder: Decoder) throws {
1201+ let container = try decoder.singleValueContainer()
1202+ if let x = try? container.decode(Bool.self) {
1203+ self = .bool(x)
1204+ return
1205+ }
1206+ if let x = try? container.decode(Double.self) {
1207+ self = .double(x)
1208+ return
1209+ }
1210+ if let x = try? container.decode(String.self) {
1211+ self = .string(x)
1212+ return
1213+ }
1214+ throw DecodingError.typeMismatch(Bedesman.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Bedesman"))
1215+ }
1216+
1217+ func encode(to encoder: Encoder) throws {
1218+ var container = encoder.singleValueContainer()
1219+ switch self {
1220+ case .bool(let x):
1221+ try container.encode(x)
1222+ case .double(let x):
1223+ try container.encode(x)
1224+ case .string(let x):
1225+ try container.encode(x)
1226+ }
1227+ }
1228+}
1229+
1230+enum Belard: Codable, Hashable {
1231+ case double(Double)
1232+ case integerArray([Int])
1233+ case rebecca(Rebecca)
1234+
1235+ init(from decoder: Decoder) throws {
1236+ let container = try decoder.singleValueContainer()
1237+ if let x = try? container.decode([Int].self) {
1238+ self = .integerArray(x)
1239+ return
1240+ }
1241+ if let x = try? container.decode(Double.self) {
1242+ self = .double(x)
1243+ return
1244+ }
1245+ if let x = try? container.decode(Rebecca.self) {
1246+ self = .rebecca(x)
1247+ return
1248+ }
1249+ throw DecodingError.typeMismatch(Belard.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Belard"))
1250+ }
1251+
1252+ func encode(to encoder: Encoder) throws {
1253+ var container = encoder.singleValueContainer()
1254+ switch self {
1255+ case .double(let x):
1256+ try container.encode(x)
1257+ case .integerArray(let x):
1258+ try container.encode(x)
1259+ case .rebecca(let x):
1260+ try container.encode(x)
1261+ }
1262+ }
1263+}
1264+
1265+enum Bocking: Codable, Hashable {
1266+ case bool(Bool)
1267+ case integerArray([Int])
1268+ case integerMap([String: Int])
1269+
1270+ init(from decoder: Decoder) throws {
1271+ let container = try decoder.singleValueContainer()
1272+ if let x = try? container.decode(Bool.self) {
1273+ self = .bool(x)
1274+ return
1275+ }
1276+ if let x = try? container.decode([Int].self) {
1277+ self = .integerArray(x)
1278+ return
1279+ }
1280+ if let x = try? container.decode([String: Int].self) {
1281+ self = .integerMap(x)
1282+ return
1283+ }
1284+ throw DecodingError.typeMismatch(Bocking.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Bocking"))
1285+ }
1286+
1287+ func encode(to encoder: Encoder) throws {
1288+ var container = encoder.singleValueContainer()
1289+ switch self {
1290+ case .bool(let x):
1291+ try container.encode(x)
1292+ case .integerArray(let x):
1293+ try container.encode(x)
1294+ case .integerMap(let x):
1295+ try container.encode(x)
1296+ }
1297+ }
1298+}
1299+
1300+enum Brawlingly: Codable, Hashable {
1301+ case nullArray([JSONNull?])
1302+ case unionMap([String: Int?])
1303+
1304+ init(from decoder: Decoder) throws {
1305+ let container = try decoder.singleValueContainer()
1306+ if let x = try? container.decode([JSONNull?].self) {
1307+ self = .nullArray(x)
1308+ return
1309+ }
1310+ if let x = try? container.decode([String: Int?].self) {
1311+ self = .unionMap(x)
1312+ return
1313+ }
1314+ throw DecodingError.typeMismatch(Brawlingly.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Brawlingly"))
1315+ }
1316+
1317+ func encode(to encoder: Encoder) throws {
1318+ var container = encoder.singleValueContainer()
1319+ switch self {
1320+ case .nullArray(let x):
1321+ try container.encode(x)
1322+ case .unionMap(let x):
1323+ try container.encode(x)
1324+ }
1325+ }
1326+}
1327+
1328+enum Brookie: Codable, Hashable {
1329+ case integerArray([Int])
1330+ case rebecca(Rebecca)
1331+
1332+ init(from decoder: Decoder) throws {
1333+ let container = try decoder.singleValueContainer()
1334+ if let x = try? container.decode([Int].self) {
1335+ self = .integerArray(x)
1336+ return
1337+ }
1338+ if let x = try? container.decode(Rebecca.self) {
1339+ self = .rebecca(x)
1340+ return
1341+ }
1342+ throw DecodingError.typeMismatch(Brookie.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Brookie"))
1343+ }
1344+
1345+ func encode(to encoder: Encoder) throws {
1346+ var container = encoder.singleValueContainer()
1347+ switch self {
1348+ case .integerArray(let x):
1349+ try container.encode(x)
1350+ case .rebecca(let x):
1351+ try container.encode(x)
1352+ }
1353+ }
1354+}
1355+
1356+enum Bumboatman: Codable, Hashable {
1357+ case nullArray([JSONNull?])
1358+ case string(String)
1359+ case null
1360+
1361+ init(from decoder: Decoder) throws {
1362+ let container = try decoder.singleValueContainer()
1363+ if let x = try? container.decode([JSONNull?].self) {
1364+ self = .nullArray(x)
1365+ return
1366+ }
1367+ if let x = try? container.decode(String.self) {
1368+ self = .string(x)
1369+ return
1370+ }
1371+ if container.decodeNil() {
1372+ self = .null
1373+ return
1374+ }
1375+ throw DecodingError.typeMismatch(Bumboatman.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Bumboatman"))
1376+ }
1377+
1378+ func encode(to encoder: Encoder) throws {
1379+ var container = encoder.singleValueContainer()
1380+ switch self {
1381+ case .nullArray(let x):
1382+ try container.encode(x)
1383+ case .string(let x):
1384+ try container.encode(x)
1385+ case .null:
1386+ try container.encodeNil()
1387+ }
1388+ }
1389+}
1390+
1391+enum Calaverite: Codable, Hashable {
1392+ case integerArray([Int])
1393+ case string(String)
1394+
1395+ init(from decoder: Decoder) throws {
1396+ let container = try decoder.singleValueContainer()
1397+ if let x = try? container.decode([Int].self) {
1398+ self = .integerArray(x)
1399+ return
1400+ }
1401+ if let x = try? container.decode(String.self) {
1402+ self = .string(x)
1403+ return
1404+ }
1405+ throw DecodingError.typeMismatch(Calaverite.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Calaverite"))
1406+ }
1407+
1408+ func encode(to encoder: Encoder) throws {
1409+ var container = encoder.singleValueContainer()
1410+ switch self {
1411+ case .integerArray(let x):
1412+ try container.encode(x)
1413+ case .string(let x):
1414+ try container.encode(x)
1415+ }
1416+ }
1417+}
1418+
1419+enum Catallactic: Codable, Hashable {
1420+ case bool(Bool)
1421+ case integerMap([String: Int])
1422+ case nullArray([JSONNull?])
1423+
1424+ init(from decoder: Decoder) throws {
1425+ let container = try decoder.singleValueContainer()
1426+ if let x = try? container.decode(Bool.self) {
1427+ self = .bool(x)
1428+ return
1429+ }
1430+ if let x = try? container.decode([JSONNull?].self) {
1431+ self = .nullArray(x)
1432+ return
1433+ }
1434+ if let x = try? container.decode([String: Int].self) {
1435+ self = .integerMap(x)
1436+ return
1437+ }
1438+ throw DecodingError.typeMismatch(Catallactic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Catallactic"))
1439+ }
1440+
1441+ func encode(to encoder: Encoder) throws {
1442+ var container = encoder.singleValueContainer()
1443+ switch self {
1444+ case .bool(let x):
1445+ try container.encode(x)
1446+ case .integerMap(let x):
1447+ try container.encode(x)
1448+ case .nullArray(let x):
1449+ try container.encode(x)
1450+ }
1451+ }
1452+}
1453+
1454+enum Cemental: Codable, Hashable {
1455+ case double(Double)
1456+ case integerArray([Int])
1457+ case integerMap([String: Int])
1458+
1459+ init(from decoder: Decoder) throws {
1460+ let container = try decoder.singleValueContainer()
1461+ if let x = try? container.decode([Int].self) {
1462+ self = .integerArray(x)
1463+ return
1464+ }
1465+ if let x = try? container.decode(Double.self) {
1466+ self = .double(x)
1467+ return
1468+ }
1469+ if let x = try? container.decode([String: Int].self) {
1470+ self = .integerMap(x)
1471+ return
1472+ }
1473+ throw DecodingError.typeMismatch(Cemental.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Cemental"))
1474+ }
1475+
1476+ func encode(to encoder: Encoder) throws {
1477+ var container = encoder.singleValueContainer()
1478+ switch self {
1479+ case .double(let x):
1480+ try container.encode(x)
1481+ case .integerArray(let x):
1482+ try container.encode(x)
1483+ case .integerMap(let x):
1484+ try container.encode(x)
1485+ }
1486+ }
1487+}
1488+
1489+enum ChytridiaceaeElement: Codable, Hashable {
1490+ case bool(Bool)
1491+ case chytridiaceaeClass(ChytridiaceaeClass)
1492+ case null
1493+
1494+ init(from decoder: Decoder) throws {
1495+ let container = try decoder.singleValueContainer()
1496+ if let x = try? container.decode(Bool.self) {
1497+ self = .bool(x)
1498+ return
1499+ }
1500+ if let x = try? container.decode(ChytridiaceaeClass.self) {
1501+ self = .chytridiaceaeClass(x)
1502+ return
1503+ }
1504+ if container.decodeNil() {
1505+ self = .null
1506+ return
1507+ }
1508+ throw DecodingError.typeMismatch(ChytridiaceaeElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for ChytridiaceaeElement"))
1509+ }
1510+
1511+ func encode(to encoder: Encoder) throws {
1512+ var container = encoder.singleValueContainer()
1513+ switch self {
1514+ case .bool(let x):
1515+ try container.encode(x)
1516+ case .chytridiaceaeClass(let x):
1517+ try container.encode(x)
1518+ case .null:
1519+ try container.encodeNil()
1520+ }
1521+ }
1522+}
1523+
1524+//
1525+// Hashable or Equatable:
1526+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
1527+// for types that require the use of JSONAny, nor will the implementation of Hashable be
1528+// synthesized for types that have collections (such as arrays or dictionaries).
1529+
1530+// MARK: - ChytridiaceaeClass
1531+struct ChytridiaceaeClass: Codable, Hashable {
1532+ let batidaceae: JSONNull?
1533+ let brechites: JSONNull?
1534+ let codespairer: JSONNull?
1535+ let emery: JSONNull?
1536+ let enervative: JSONNull?
1537+ let excriminate: JSONNull?
1538+ let goshenite: JSONNull?
1539+ let grime: JSONNull?
1540+ let gritten: JSONNull?
1541+ let hectorly: JSONNull?
1542+ let intermediation: JSONNull?
1543+ let meeterly: JSONNull?
1544+ let narraganset: JSONNull?
1545+ let onymatic: JSONNull?
1546+ let paddlecock: JSONNull?
1547+ let thana: JSONNull?
1548+ let thornily: JSONNull?
1549+ let uckia: JSONNull?
1550+ let unmettle: JSONNull?
1551+ let vorticellid: JSONNull?
1552+
1553+ enum CodingKeys: String, CodingKey {
1554+ case batidaceae = "Batidaceae"
1555+ case brechites = "Brechites"
1556+ case codespairer = "codespairer"
1557+ case emery = "Emery"
1558+ case enervative = "enervative"
1559+ case excriminate = "excriminate"
1560+ case goshenite = "goshenite"
1561+ case grime = "grime"
1562+ case gritten = "gritten"
1563+ case hectorly = "hectorly"
1564+ case intermediation = "intermediation"
1565+ case meeterly = "meeterly"
1566+ case narraganset = "Narraganset"
1567+ case onymatic = "onymatic"
1568+ case paddlecock = "paddlecock"
1569+ case thana = "thana"
1570+ case thornily = "thornily"
1571+ case uckia = "uckia"
1572+ case unmettle = "unmettle"
1573+ case vorticellid = "vorticellid"
1574+ }
1575+}
1576+
1577+// MARK: ChytridiaceaeClass convenience initializers and mutators
1578+
1579+extension ChytridiaceaeClass {
1580+ init(data: Data) throws {
1581+ self = try newJSONDecoder().decode(ChytridiaceaeClass.self, from: data)
1582+ }
1583+
1584+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1585+ guard let data = json.data(using: encoding) else {
1586+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1587+ }
1588+ try self.init(data: data)
1589+ }
1590+
1591+ init(fromURL url: URL) throws {
1592+ try self.init(data: try Data(contentsOf: url))
1593+ }
1594+
1595+ func with(
1596+ batidaceae: JSONNull?? = nil,
1597+ brechites: JSONNull?? = nil,
1598+ codespairer: JSONNull?? = nil,
1599+ emery: JSONNull?? = nil,
1600+ enervative: JSONNull?? = nil,
1601+ excriminate: JSONNull?? = nil,
1602+ goshenite: JSONNull?? = nil,
1603+ grime: JSONNull?? = nil,
1604+ gritten: JSONNull?? = nil,
1605+ hectorly: JSONNull?? = nil,
1606+ intermediation: JSONNull?? = nil,
1607+ meeterly: JSONNull?? = nil,
1608+ narraganset: JSONNull?? = nil,
1609+ onymatic: JSONNull?? = nil,
1610+ paddlecock: JSONNull?? = nil,
1611+ thana: JSONNull?? = nil,
1612+ thornily: JSONNull?? = nil,
1613+ uckia: JSONNull?? = nil,
1614+ unmettle: JSONNull?? = nil,
1615+ vorticellid: JSONNull?? = nil
1616+ ) -> ChytridiaceaeClass {
1617+ return ChytridiaceaeClass(
1618+ batidaceae: batidaceae ?? self.batidaceae,
1619+ brechites: brechites ?? self.brechites,
1620+ codespairer: codespairer ?? self.codespairer,
1621+ emery: emery ?? self.emery,
1622+ enervative: enervative ?? self.enervative,
1623+ excriminate: excriminate ?? self.excriminate,
1624+ goshenite: goshenite ?? self.goshenite,
1625+ grime: grime ?? self.grime,
1626+ gritten: gritten ?? self.gritten,
1627+ hectorly: hectorly ?? self.hectorly,
1628+ intermediation: intermediation ?? self.intermediation,
1629+ meeterly: meeterly ?? self.meeterly,
1630+ narraganset: narraganset ?? self.narraganset,
1631+ onymatic: onymatic ?? self.onymatic,
1632+ paddlecock: paddlecock ?? self.paddlecock,
1633+ thana: thana ?? self.thana,
1634+ thornily: thornily ?? self.thornily,
1635+ uckia: uckia ?? self.uckia,
1636+ unmettle: unmettle ?? self.unmettle,
1637+ vorticellid: vorticellid ?? self.vorticellid
1638+ )
1639+ }
1640+
1641+ func jsonData() throws -> Data {
1642+ return try newJSONEncoder().encode(self)
1643+ }
1644+
1645+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1646+ return String(data: try self.jsonData(), encoding: encoding)
1647+ }
1648+}
1649+
1650+enum DiscordiaElement: Codable, Hashable {
1651+ case discordiaClass(DiscordiaClass)
1652+ case integerArray([Int])
1653+
1654+ init(from decoder: Decoder) throws {
1655+ let container = try decoder.singleValueContainer()
1656+ if let x = try? container.decode([Int].self) {
1657+ self = .integerArray(x)
1658+ return
1659+ }
1660+ if let x = try? container.decode(DiscordiaClass.self) {
1661+ self = .discordiaClass(x)
1662+ return
1663+ }
1664+ throw DecodingError.typeMismatch(DiscordiaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for DiscordiaElement"))
1665+ }
1666+
1667+ func encode(to encoder: Encoder) throws {
1668+ var container = encoder.singleValueContainer()
1669+ switch self {
1670+ case .discordiaClass(let x):
1671+ try container.encode(x)
1672+ case .integerArray(let x):
1673+ try container.encode(x)
1674+ }
1675+ }
1676+}
1677+
1678+//
1679+// Hashable or Equatable:
1680+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
1681+// for types that require the use of JSONAny, nor will the implementation of Hashable be
1682+// synthesized for types that have collections (such as arrays or dictionaries).
1683+
1684+// MARK: - DiscordiaClass
1685+struct DiscordiaClass: Codable, Hashable {
1686+ let altaic: Int?
1687+ let amoristic: Int?
1688+ let blennophthalmia: Int?
1689+ let catharticalness: Double?
1690+ let chirotherium: Int?
1691+ let disciplinability: Int?
1692+ let disdiapason: String?
1693+ let goofer: Int?
1694+ let homocerc: Bool?
1695+ let laryngograph: Int?
1696+ let leucitis: Int?
1697+ let lymphocyst: Int?
1698+ let microcosmology: Int?
1699+ let nauseation: Int?
1700+ let nonbookish: JSONNull?
1701+ let patarin: Int?
1702+ let preliberal: Int?
1703+ let prettifier: Int?
1704+ let rangework: Int?
1705+ let redient: Int?
1706+ let subfusiform: Int?
1707+ let suicidical: Int?
1708+ let swow: Int?
1709+ let wastrel: Int?
1710+ let wingle: Int?
1711+
1712+ enum CodingKeys: String, CodingKey {
1713+ case altaic = "Altaic"
1714+ case amoristic = "amoristic"
1715+ case blennophthalmia = "blennophthalmia"
1716+ case catharticalness = "catharticalness"
1717+ case chirotherium = "Chirotherium"
1718+ case disciplinability = "disciplinability"
1719+ case disdiapason = "disdiapason"
1720+ case goofer = "goofer"
1721+ case homocerc = "homocerc"
1722+ case laryngograph = "laryngograph"
1723+ case leucitis = "leucitis"
1724+ case lymphocyst = "lymphocyst"
1725+ case microcosmology = "microcosmology"
1726+ case nauseation = "nauseation"
1727+ case nonbookish = "nonbookish"
1728+ case patarin = "Patarin"
1729+ case preliberal = "preliberal"
1730+ case prettifier = "prettifier"
1731+ case rangework = "rangework"
1732+ case redient = "redient"
1733+ case subfusiform = "subfusiform"
1734+ case suicidical = "suicidical"
1735+ case swow = "swow"
1736+ case wastrel = "wastrel"
1737+ case wingle = "wingle"
1738+ }
1739+}
1740+
1741+// MARK: DiscordiaClass convenience initializers and mutators
1742+
1743+extension DiscordiaClass {
1744+ init(data: Data) throws {
1745+ self = try newJSONDecoder().decode(DiscordiaClass.self, from: data)
1746+ }
1747+
1748+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1749+ guard let data = json.data(using: encoding) else {
1750+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1751+ }
1752+ try self.init(data: data)
1753+ }
1754+
1755+ init(fromURL url: URL) throws {
1756+ try self.init(data: try Data(contentsOf: url))
1757+ }
1758+
1759+ func with(
1760+ altaic: Int?? = nil,
1761+ amoristic: Int?? = nil,
1762+ blennophthalmia: Int?? = nil,
1763+ catharticalness: Double?? = nil,
1764+ chirotherium: Int?? = nil,
1765+ disciplinability: Int?? = nil,
1766+ disdiapason: String?? = nil,
1767+ goofer: Int?? = nil,
1768+ homocerc: Bool?? = nil,
1769+ laryngograph: Int?? = nil,
1770+ leucitis: Int?? = nil,
1771+ lymphocyst: Int?? = nil,
1772+ microcosmology: Int?? = nil,
1773+ nauseation: Int?? = nil,
1774+ nonbookish: JSONNull?? = nil,
1775+ patarin: Int?? = nil,
1776+ preliberal: Int?? = nil,
1777+ prettifier: Int?? = nil,
1778+ rangework: Int?? = nil,
1779+ redient: Int?? = nil,
1780+ subfusiform: Int?? = nil,
1781+ suicidical: Int?? = nil,
1782+ swow: Int?? = nil,
1783+ wastrel: Int?? = nil,
1784+ wingle: Int?? = nil
1785+ ) -> DiscordiaClass {
1786+ return DiscordiaClass(
1787+ altaic: altaic ?? self.altaic,
1788+ amoristic: amoristic ?? self.amoristic,
1789+ blennophthalmia: blennophthalmia ?? self.blennophthalmia,
1790+ catharticalness: catharticalness ?? self.catharticalness,
1791+ chirotherium: chirotherium ?? self.chirotherium,
1792+ disciplinability: disciplinability ?? self.disciplinability,
1793+ disdiapason: disdiapason ?? self.disdiapason,
1794+ goofer: goofer ?? self.goofer,
1795+ homocerc: homocerc ?? self.homocerc,
1796+ laryngograph: laryngograph ?? self.laryngograph,
1797+ leucitis: leucitis ?? self.leucitis,
1798+ lymphocyst: lymphocyst ?? self.lymphocyst,
1799+ microcosmology: microcosmology ?? self.microcosmology,
1800+ nauseation: nauseation ?? self.nauseation,
1801+ nonbookish: nonbookish ?? self.nonbookish,
1802+ patarin: patarin ?? self.patarin,
1803+ preliberal: preliberal ?? self.preliberal,
1804+ prettifier: prettifier ?? self.prettifier,
1805+ rangework: rangework ?? self.rangework,
1806+ redient: redient ?? self.redient,
1807+ subfusiform: subfusiform ?? self.subfusiform,
1808+ suicidical: suicidical ?? self.suicidical,
1809+ swow: swow ?? self.swow,
1810+ wastrel: wastrel ?? self.wastrel,
1811+ wingle: wingle ?? self.wingle
1812+ )
1813+ }
1814+
1815+ func jsonData() throws -> Data {
1816+ return try newJSONEncoder().encode(self)
1817+ }
1818+
1819+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1820+ return String(data: try self.jsonData(), encoding: encoding)
1821+ }
1822+}
1823+
1824+enum Endomyce: Codable, Hashable {
1825+ case integer(Int)
1826+ case string(String)
1827+
1828+ init(from decoder: Decoder) throws {
1829+ let container = try decoder.singleValueContainer()
1830+ if let x = try? container.decode(Int.self) {
1831+ self = .integer(x)
1832+ return
1833+ }
1834+ if let x = try? container.decode(String.self) {
1835+ self = .string(x)
1836+ return
1837+ }
1838+ throw DecodingError.typeMismatch(Endomyce.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Endomyce"))
1839+ }
1840+
1841+ func encode(to encoder: Encoder) throws {
1842+ var container = encoder.singleValueContainer()
1843+ switch self {
1844+ case .integer(let x):
1845+ try container.encode(x)
1846+ case .string(let x):
1847+ try container.encode(x)
1848+ }
1849+ }
1850+}
1851+
1852+enum Epinephelidae: Codable, Hashable {
1853+ case bool(Bool)
1854+ case integer(Int)
1855+ case string(String)
1856+
1857+ init(from decoder: Decoder) throws {
1858+ let container = try decoder.singleValueContainer()
1859+ if let x = try? container.decode(Bool.self) {
1860+ self = .bool(x)
1861+ return
1862+ }
1863+ if let x = try? container.decode(Int.self) {
1864+ self = .integer(x)
1865+ return
1866+ }
1867+ if let x = try? container.decode(String.self) {
1868+ self = .string(x)
1869+ return
1870+ }
1871+ throw DecodingError.typeMismatch(Epinephelidae.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Epinephelidae"))
1872+ }
1873+
1874+ func encode(to encoder: Encoder) throws {
1875+ var container = encoder.singleValueContainer()
1876+ switch self {
1877+ case .bool(let x):
1878+ try container.encode(x)
1879+ case .integer(let x):
1880+ try container.encode(x)
1881+ case .string(let x):
1882+ try container.encode(x)
1883+ }
1884+ }
1885+}
1886+
1887+enum Eupatorium: Codable, Hashable {
1888+ case integerMap([String: Int])
1889+ case nullArray([JSONNull?])
1890+
1891+ init(from decoder: Decoder) throws {
1892+ let container = try decoder.singleValueContainer()
1893+ if let x = try? container.decode([JSONNull?].self) {
1894+ self = .nullArray(x)
1895+ return
1896+ }
1897+ if let x = try? container.decode([String: Int].self) {
1898+ self = .integerMap(x)
1899+ return
1900+ }
1901+ throw DecodingError.typeMismatch(Eupatorium.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Eupatorium"))
1902+ }
1903+
1904+ func encode(to encoder: Encoder) throws {
1905+ var container = encoder.singleValueContainer()
1906+ switch self {
1907+ case .integerMap(let x):
1908+ try container.encode(x)
1909+ case .nullArray(let x):
1910+ try container.encode(x)
1911+ }
1912+ }
1913+}
1914+
1915+enum GryphosaurusElement: Codable, Hashable {
1916+ case gryphosaurusClass(GryphosaurusClass)
1917+ case integerArray([Int])
1918+ case string(String)
1919+
1920+ init(from decoder: Decoder) throws {
1921+ let container = try decoder.singleValueContainer()
1922+ if let x = try? container.decode([Int].self) {
1923+ self = .integerArray(x)
1924+ return
1925+ }
1926+ if let x = try? container.decode(String.self) {
1927+ self = .string(x)
1928+ return
1929+ }
1930+ if let x = try? container.decode(GryphosaurusClass.self) {
1931+ self = .gryphosaurusClass(x)
1932+ return
1933+ }
1934+ throw DecodingError.typeMismatch(GryphosaurusElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for GryphosaurusElement"))
1935+ }
1936+
1937+ func encode(to encoder: Encoder) throws {
1938+ var container = encoder.singleValueContainer()
1939+ switch self {
1940+ case .gryphosaurusClass(let x):
1941+ try container.encode(x)
1942+ case .integerArray(let x):
1943+ try container.encode(x)
1944+ case .string(let x):
1945+ try container.encode(x)
1946+ }
1947+ }
1948+}
1949+
1950+//
1951+// Hashable or Equatable:
1952+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
1953+// for types that require the use of JSONAny, nor will the implementation of Hashable be
1954+// synthesized for types that have collections (such as arrays or dictionaries).
1955+
1956+// MARK: - GryphosaurusClass
1957+struct GryphosaurusClass: Codable, Hashable {
1958+ let amissibility: JSONNull?
1959+ let burushaski: JSONNull?
1960+ let citronin: JSONNull?
1961+ let coplaintiff: JSONNull?
1962+ let disquisitionary: JSONNull?
1963+ let enoplan: JSONNull?
1964+ let faintness: JSONNull?
1965+ let hebetomy: JSONNull?
1966+ let islandry: JSONNull?
1967+ let lameduck: JSONNull?
1968+ let overbattle: JSONNull?
1969+ let overinterested: JSONNull?
1970+ let phrenologic: JSONNull?
1971+ let rainband: JSONNull?
1972+ let shiningly: JSONNull?
1973+ let stamineous: JSONNull?
1974+ let subscapularis: JSONNull?
1975+ let tahami: JSONNull?
1976+ let undaubed: JSONNull?
1977+ let underntime: JSONNull?
1978+
1979+ enum CodingKeys: String, CodingKey {
1980+ case amissibility = "amissibility"
1981+ case burushaski = "Burushaski"
1982+ case citronin = "citronin"
1983+ case coplaintiff = "coplaintiff"
1984+ case disquisitionary = "disquisitionary"
1985+ case enoplan = "enoplan"
1986+ case faintness = "faintness"
1987+ case hebetomy = "hebetomy"
1988+ case islandry = "islandry"
1989+ case lameduck = "lameduck"
1990+ case overbattle = "overbattle"
1991+ case overinterested = "overinterested"
1992+ case phrenologic = "phrenologic"
1993+ case rainband = "rainband"
1994+ case shiningly = "shiningly"
1995+ case stamineous = "stamineous"
1996+ case subscapularis = "subscapularis"
1997+ case tahami = "Tahami"
1998+ case undaubed = "undaubed"
1999+ case underntime = "underntime"
2000+ }
2001+}
2002+
2003+// MARK: GryphosaurusClass convenience initializers and mutators
2004+
2005+extension GryphosaurusClass {
2006+ init(data: Data) throws {
2007+ self = try newJSONDecoder().decode(GryphosaurusClass.self, from: data)
2008+ }
2009+
2010+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2011+ guard let data = json.data(using: encoding) else {
2012+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2013+ }
2014+ try self.init(data: data)
2015+ }
2016+
2017+ init(fromURL url: URL) throws {
2018+ try self.init(data: try Data(contentsOf: url))
2019+ }
2020+
2021+ func with(
2022+ amissibility: JSONNull?? = nil,
2023+ burushaski: JSONNull?? = nil,
2024+ citronin: JSONNull?? = nil,
2025+ coplaintiff: JSONNull?? = nil,
2026+ disquisitionary: JSONNull?? = nil,
2027+ enoplan: JSONNull?? = nil,
2028+ faintness: JSONNull?? = nil,
2029+ hebetomy: JSONNull?? = nil,
2030+ islandry: JSONNull?? = nil,
2031+ lameduck: JSONNull?? = nil,
2032+ overbattle: JSONNull?? = nil,
2033+ overinterested: JSONNull?? = nil,
2034+ phrenologic: JSONNull?? = nil,
2035+ rainband: JSONNull?? = nil,
2036+ shiningly: JSONNull?? = nil,
2037+ stamineous: JSONNull?? = nil,
2038+ subscapularis: JSONNull?? = nil,
2039+ tahami: JSONNull?? = nil,
2040+ undaubed: JSONNull?? = nil,
2041+ underntime: JSONNull?? = nil
2042+ ) -> GryphosaurusClass {
2043+ return GryphosaurusClass(
2044+ amissibility: amissibility ?? self.amissibility,
2045+ burushaski: burushaski ?? self.burushaski,
2046+ citronin: citronin ?? self.citronin,
2047+ coplaintiff: coplaintiff ?? self.coplaintiff,
2048+ disquisitionary: disquisitionary ?? self.disquisitionary,
2049+ enoplan: enoplan ?? self.enoplan,
2050+ faintness: faintness ?? self.faintness,
2051+ hebetomy: hebetomy ?? self.hebetomy,
2052+ islandry: islandry ?? self.islandry,
2053+ lameduck: lameduck ?? self.lameduck,
2054+ overbattle: overbattle ?? self.overbattle,
2055+ overinterested: overinterested ?? self.overinterested,
2056+ phrenologic: phrenologic ?? self.phrenologic,
2057+ rainband: rainband ?? self.rainband,
2058+ shiningly: shiningly ?? self.shiningly,
2059+ stamineous: stamineous ?? self.stamineous,
2060+ subscapularis: subscapularis ?? self.subscapularis,
2061+ tahami: tahami ?? self.tahami,
2062+ undaubed: undaubed ?? self.undaubed,
2063+ underntime: underntime ?? self.underntime
2064+ )
2065+ }
2066+
2067+ func jsonData() throws -> Data {
2068+ return try newJSONEncoder().encode(self)
2069+ }
2070+
2071+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2072+ return String(data: try self.jsonData(), encoding: encoding)
2073+ }
2074+}
2075+
2076+enum Koryak: Codable, Hashable {
2077+ case string(String)
2078+ case unionMap([String: Int?])
2079+
2080+ init(from decoder: Decoder) throws {
2081+ let container = try decoder.singleValueContainer()
2082+ if let x = try? container.decode([String: Int?].self) {
2083+ self = .unionMap(x)
2084+ return
2085+ }
2086+ if let x = try? container.decode(String.self) {
2087+ self = .string(x)
2088+ return
2089+ }
2090+ throw DecodingError.typeMismatch(Koryak.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Koryak"))
2091+ }
2092+
2093+ func encode(to encoder: Encoder) throws {
2094+ var container = encoder.singleValueContainer()
2095+ switch self {
2096+ case .string(let x):
2097+ try container.encode(x)
2098+ case .unionMap(let x):
2099+ try container.encode(x)
2100+ }
2101+ }
2102+}
2103+
2104+enum LaviniaElement: Codable, Hashable {
2105+ case laviniaClass(LaviniaClass)
2106+ case string(String)
2107+
2108+ init(from decoder: Decoder) throws {
2109+ let container = try decoder.singleValueContainer()
2110+ if let x = try? container.decode(String.self) {
2111+ self = .string(x)
2112+ return
2113+ }
2114+ if let x = try? container.decode(LaviniaClass.self) {
2115+ self = .laviniaClass(x)
2116+ return
2117+ }
2118+ throw DecodingError.typeMismatch(LaviniaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for LaviniaElement"))
2119+ }
2120+
2121+ func encode(to encoder: Encoder) throws {
2122+ var container = encoder.singleValueContainer()
2123+ switch self {
2124+ case .laviniaClass(let x):
2125+ try container.encode(x)
2126+ case .string(let x):
2127+ try container.encode(x)
2128+ }
2129+ }
2130+}
2131+
2132+//
2133+// Hashable or Equatable:
2134+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
2135+// for types that require the use of JSONAny, nor will the implementation of Hashable be
2136+// synthesized for types that have collections (such as arrays or dictionaries).
2137+
2138+// MARK: - LaviniaClass
2139+struct LaviniaClass: Codable, Hashable {
2140+ let agitable: Int?
2141+ let asininity: Int?
2142+ let benefiter: Int?
2143+ let bronzelike: Int?
2144+ let catharticalness: Double?
2145+ let chirotherium: Int?
2146+ let cholesteatomatous: Int?
2147+ let deprivement: Int?
2148+ let disdiapason: String?
2149+ let flippantness: Int?
2150+ let fogproof: Int?
2151+ let homocerc: Bool?
2152+ let merrymeeting: Int?
2153+ let nonbookish: JSONNull?
2154+ let overcareful: Int?
2155+ let panaris: Int?
2156+ let preacceptance: Int?
2157+ let quinoxaline: Int?
2158+ let sig: Int?
2159+ let superconfusion: Int?
2160+ let tacana: Int?
2161+ let tillotter: Int?
2162+ let tranquillize: Int?
2163+ let unquestionable: Int?
2164+ let uproute: Int?
2165+
2166+ enum CodingKeys: String, CodingKey {
2167+ case agitable = "agitable"
2168+ case asininity = "asininity"
2169+ case benefiter = "benefiter"
2170+ case bronzelike = "bronzelike"
2171+ case catharticalness = "catharticalness"
2172+ case chirotherium = "Chirotherium"
2173+ case cholesteatomatous = "cholesteatomatous"
2174+ case deprivement = "deprivement"
2175+ case disdiapason = "disdiapason"
2176+ case flippantness = "flippantness"
2177+ case fogproof = "fogproof"
2178+ case homocerc = "homocerc"
2179+ case merrymeeting = "merrymeeting"
2180+ case nonbookish = "nonbookish"
2181+ case overcareful = "overcareful"
2182+ case panaris = "panaris"
2183+ case preacceptance = "preacceptance"
2184+ case quinoxaline = "quinoxaline"
2185+ case sig = "sig"
2186+ case superconfusion = "superconfusion"
2187+ case tacana = "Tacana"
2188+ case tillotter = "tillotter"
2189+ case tranquillize = "tranquillize"
2190+ case unquestionable = "unquestionable"
2191+ case uproute = "uproute"
2192+ }
2193+}
2194+
2195+// MARK: LaviniaClass convenience initializers and mutators
2196+
2197+extension LaviniaClass {
2198+ init(data: Data) throws {
2199+ self = try newJSONDecoder().decode(LaviniaClass.self, from: data)
2200+ }
2201+
2202+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2203+ guard let data = json.data(using: encoding) else {
2204+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2205+ }
2206+ try self.init(data: data)
2207+ }
2208+
2209+ init(fromURL url: URL) throws {
2210+ try self.init(data: try Data(contentsOf: url))
2211+ }
2212+
2213+ func with(
2214+ agitable: Int?? = nil,
2215+ asininity: Int?? = nil,
2216+ benefiter: Int?? = nil,
2217+ bronzelike: Int?? = nil,
2218+ catharticalness: Double?? = nil,
2219+ chirotherium: Int?? = nil,
2220+ cholesteatomatous: Int?? = nil,
2221+ deprivement: Int?? = nil,
2222+ disdiapason: String?? = nil,
2223+ flippantness: Int?? = nil,
2224+ fogproof: Int?? = nil,
2225+ homocerc: Bool?? = nil,
2226+ merrymeeting: Int?? = nil,
2227+ nonbookish: JSONNull?? = nil,
2228+ overcareful: Int?? = nil,
2229+ panaris: Int?? = nil,
2230+ preacceptance: Int?? = nil,
2231+ quinoxaline: Int?? = nil,
2232+ sig: Int?? = nil,
2233+ superconfusion: Int?? = nil,
2234+ tacana: Int?? = nil,
2235+ tillotter: Int?? = nil,
2236+ tranquillize: Int?? = nil,
2237+ unquestionable: Int?? = nil,
2238+ uproute: Int?? = nil
2239+ ) -> LaviniaClass {
2240+ return LaviniaClass(
2241+ agitable: agitable ?? self.agitable,
2242+ asininity: asininity ?? self.asininity,
2243+ benefiter: benefiter ?? self.benefiter,
2244+ bronzelike: bronzelike ?? self.bronzelike,
2245+ catharticalness: catharticalness ?? self.catharticalness,
2246+ chirotherium: chirotherium ?? self.chirotherium,
2247+ cholesteatomatous: cholesteatomatous ?? self.cholesteatomatous,
2248+ deprivement: deprivement ?? self.deprivement,
2249+ disdiapason: disdiapason ?? self.disdiapason,
2250+ flippantness: flippantness ?? self.flippantness,
2251+ fogproof: fogproof ?? self.fogproof,
2252+ homocerc: homocerc ?? self.homocerc,
2253+ merrymeeting: merrymeeting ?? self.merrymeeting,
2254+ nonbookish: nonbookish ?? self.nonbookish,
2255+ overcareful: overcareful ?? self.overcareful,
2256+ panaris: panaris ?? self.panaris,
2257+ preacceptance: preacceptance ?? self.preacceptance,
2258+ quinoxaline: quinoxaline ?? self.quinoxaline,
2259+ sig: sig ?? self.sig,
2260+ superconfusion: superconfusion ?? self.superconfusion,
2261+ tacana: tacana ?? self.tacana,
2262+ tillotter: tillotter ?? self.tillotter,
2263+ tranquillize: tranquillize ?? self.tranquillize,
2264+ unquestionable: unquestionable ?? self.unquestionable,
2265+ uproute: uproute ?? self.uproute
2266+ )
2267+ }
2268+
2269+ func jsonData() throws -> Data {
2270+ return try newJSONEncoder().encode(self)
2271+ }
2272+
2273+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2274+ return String(data: try self.jsonData(), encoding: encoding)
2275+ }
2276+}
2277+
2278+enum OskarElement: Codable, Hashable {
2279+ case integerArray([Int])
2280+ case oskarClass(OskarClass)
2281+
2282+ init(from decoder: Decoder) throws {
2283+ let container = try decoder.singleValueContainer()
2284+ if let x = try? container.decode([Int].self) {
2285+ self = .integerArray(x)
2286+ return
2287+ }
2288+ if let x = try? container.decode(OskarClass.self) {
2289+ self = .oskarClass(x)
2290+ return
2291+ }
2292+ throw DecodingError.typeMismatch(OskarElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for OskarElement"))
2293+ }
2294+
2295+ func encode(to encoder: Encoder) throws {
2296+ var container = encoder.singleValueContainer()
2297+ switch self {
2298+ case .integerArray(let x):
2299+ try container.encode(x)
2300+ case .oskarClass(let x):
2301+ try container.encode(x)
2302+ }
2303+ }
2304+}
2305+
2306+//
2307+// Hashable or Equatable:
2308+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
2309+// for types that require the use of JSONAny, nor will the implementation of Hashable be
2310+// synthesized for types that have collections (such as arrays or dictionaries).
2311+
2312+// MARK: - OskarClass
2313+struct OskarClass: Codable, Hashable {
2314+ let acrobates: JSONNull?
2315+ let beanshooter: JSONNull?
2316+ let bearhound: JSONNull?
2317+ let cayuga: JSONNull?
2318+ let guarneri: JSONNull?
2319+ let hypochondriacism: JSONNull?
2320+ let indication: JSONNull?
2321+ let jaculative: JSONNull?
2322+ let nagana: JSONNull?
2323+ let netherlandish: JSONNull?
2324+ let noctivagous: JSONNull?
2325+ let nonphysiological: JSONNull?
2326+ let praxis: JSONNull?
2327+ let provision: JSONNull?
2328+ let subterhuman: JSONNull?
2329+ let sunlit: JSONNull?
2330+ let syncraniate: JSONNull?
2331+ let teachment: JSONNull?
2332+ let unmutinous: JSONNull?
2333+ let unstoppable: JSONNull?
2334+
2335+ enum CodingKeys: String, CodingKey {
2336+ case acrobates = "Acrobates"
2337+ case beanshooter = "beanshooter"
2338+ case bearhound = "bearhound"
2339+ case cayuga = "Cayuga"
2340+ case guarneri = "guarneri"
2341+ case hypochondriacism = "hypochondriacism"
2342+ case indication = "indication"
2343+ case jaculative = "jaculative"
2344+ case nagana = "nagana"
2345+ case netherlandish = "Netherlandish"
2346+ case noctivagous = "noctivagous"
2347+ case nonphysiological = "nonphysiological"
2348+ case praxis = "praxis"
2349+ case provision = "provision"
2350+ case subterhuman = "subterhuman"
2351+ case sunlit = "sunlit"
2352+ case syncraniate = "syncraniate"
2353+ case teachment = "teachment"
2354+ case unmutinous = "unmutinous"
2355+ case unstoppable = "unstoppable"
2356+ }
2357+}
2358+
2359+// MARK: OskarClass convenience initializers and mutators
2360+
2361+extension OskarClass {
2362+ init(data: Data) throws {
2363+ self = try newJSONDecoder().decode(OskarClass.self, from: data)
2364+ }
2365+
2366+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2367+ guard let data = json.data(using: encoding) else {
2368+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2369+ }
2370+ try self.init(data: data)
2371+ }
2372+
2373+ init(fromURL url: URL) throws {
2374+ try self.init(data: try Data(contentsOf: url))
2375+ }
2376+
2377+ func with(
2378+ acrobates: JSONNull?? = nil,
2379+ beanshooter: JSONNull?? = nil,
2380+ bearhound: JSONNull?? = nil,
2381+ cayuga: JSONNull?? = nil,
2382+ guarneri: JSONNull?? = nil,
2383+ hypochondriacism: JSONNull?? = nil,
2384+ indication: JSONNull?? = nil,
2385+ jaculative: JSONNull?? = nil,
2386+ nagana: JSONNull?? = nil,
2387+ netherlandish: JSONNull?? = nil,
2388+ noctivagous: JSONNull?? = nil,
2389+ nonphysiological: JSONNull?? = nil,
2390+ praxis: JSONNull?? = nil,
2391+ provision: JSONNull?? = nil,
2392+ subterhuman: JSONNull?? = nil,
2393+ sunlit: JSONNull?? = nil,
2394+ syncraniate: JSONNull?? = nil,
2395+ teachment: JSONNull?? = nil,
2396+ unmutinous: JSONNull?? = nil,
2397+ unstoppable: JSONNull?? = nil
2398+ ) -> OskarClass {
2399+ return OskarClass(
2400+ acrobates: acrobates ?? self.acrobates,
2401+ beanshooter: beanshooter ?? self.beanshooter,
2402+ bearhound: bearhound ?? self.bearhound,
2403+ cayuga: cayuga ?? self.cayuga,
2404+ guarneri: guarneri ?? self.guarneri,
2405+ hypochondriacism: hypochondriacism ?? self.hypochondriacism,
2406+ indication: indication ?? self.indication,
2407+ jaculative: jaculative ?? self.jaculative,
2408+ nagana: nagana ?? self.nagana,
2409+ netherlandish: netherlandish ?? self.netherlandish,
2410+ noctivagous: noctivagous ?? self.noctivagous,
2411+ nonphysiological: nonphysiological ?? self.nonphysiological,
2412+ praxis: praxis ?? self.praxis,
2413+ provision: provision ?? self.provision,
2414+ subterhuman: subterhuman ?? self.subterhuman,
2415+ sunlit: sunlit ?? self.sunlit,
2416+ syncraniate: syncraniate ?? self.syncraniate,
2417+ teachment: teachment ?? self.teachment,
2418+ unmutinous: unmutinous ?? self.unmutinous,
2419+ unstoppable: unstoppable ?? self.unstoppable
2420+ )
2421+ }
2422+
2423+ func jsonData() throws -> Data {
2424+ return try newJSONEncoder().encode(self)
2425+ }
2426+
2427+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2428+ return String(data: try self.jsonData(), encoding: encoding)
2429+ }
2430+}
2431+
2432+enum RebeccaElement: Codable, Hashable {
2433+ case integer(Int)
2434+ case rebecca(Rebecca)
2435+ case string(String)
2436+
2437+ init(from decoder: Decoder) throws {
2438+ let container = try decoder.singleValueContainer()
2439+ if let x = try? container.decode(Int.self) {
2440+ self = .integer(x)
2441+ return
2442+ }
2443+ if let x = try? container.decode(String.self) {
2444+ self = .string(x)
2445+ return
2446+ }
2447+ if let x = try? container.decode(Rebecca.self) {
2448+ self = .rebecca(x)
2449+ return
2450+ }
2451+ throw DecodingError.typeMismatch(RebeccaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for RebeccaElement"))
2452+ }
2453+
2454+ func encode(to encoder: Encoder) throws {
2455+ var container = encoder.singleValueContainer()
2456+ switch self {
2457+ case .integer(let x):
2458+ try container.encode(x)
2459+ case .rebecca(let x):
2460+ try container.encode(x)
2461+ case .string(let x):
2462+ try container.encode(x)
2463+ }
2464+ }
2465+}
2466+
2467+enum Rhomboganoidei: Codable, Hashable {
2468+ case integerArray([Int])
2469+ case rebecca(Rebecca)
2470+ case string(String)
2471+
2472+ init(from decoder: Decoder) throws {
2473+ let container = try decoder.singleValueContainer()
2474+ if let x = try? container.decode([Int].self) {
2475+ self = .integerArray(x)
2476+ return
2477+ }
2478+ if let x = try? container.decode(String.self) {
2479+ self = .string(x)
2480+ return
2481+ }
2482+ if let x = try? container.decode(Rebecca.self) {
2483+ self = .rebecca(x)
2484+ return
2485+ }
2486+ throw DecodingError.typeMismatch(Rhomboganoidei.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Rhomboganoidei"))
2487+ }
2488+
2489+ func encode(to encoder: Encoder) throws {
2490+ var container = encoder.singleValueContainer()
2491+ switch self {
2492+ case .integerArray(let x):
2493+ try container.encode(x)
2494+ case .rebecca(let x):
2495+ try container.encode(x)
2496+ case .string(let x):
2497+ try container.encode(x)
2498+ }
2499+ }
2500+}
2501+
2502+enum Ruellia: Codable, Hashable {
2503+ case bool(Bool)
2504+ case rebecca(Rebecca)
2505+ case string(String)
2506+
2507+ init(from decoder: Decoder) throws {
2508+ let container = try decoder.singleValueContainer()
2509+ if let x = try? container.decode(Bool.self) {
2510+ self = .bool(x)
2511+ return
2512+ }
2513+ if let x = try? container.decode(String.self) {
2514+ self = .string(x)
2515+ return
2516+ }
2517+ if let x = try? container.decode(Rebecca.self) {
2518+ self = .rebecca(x)
2519+ return
2520+ }
2521+ throw DecodingError.typeMismatch(Ruellia.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Ruellia"))
2522+ }
2523+
2524+ func encode(to encoder: Encoder) throws {
2525+ var container = encoder.singleValueContainer()
2526+ switch self {
2527+ case .bool(let x):
2528+ try container.encode(x)
2529+ case .rebecca(let x):
2530+ try container.encode(x)
2531+ case .string(let x):
2532+ try container.encode(x)
2533+ }
2534+ }
2535+}
2536+
2537+enum School: Codable, Hashable {
2538+ case integer(Int)
2539+ case integerMap([String: Int])
2540+ case null
2541+
2542+ init(from decoder: Decoder) throws {
2543+ let container = try decoder.singleValueContainer()
2544+ if let x = try? container.decode(Int.self) {
2545+ self = .integer(x)
2546+ return
2547+ }
2548+ if let x = try? container.decode([String: Int].self) {
2549+ self = .integerMap(x)
2550+ return
2551+ }
2552+ if container.decodeNil() {
2553+ self = .null
2554+ return
2555+ }
2556+ throw DecodingError.typeMismatch(School.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for School"))
2557+ }
2558+
2559+ func encode(to encoder: Encoder) throws {
2560+ var container = encoder.singleValueContainer()
2561+ switch self {
2562+ case .integer(let x):
2563+ try container.encode(x)
2564+ case .integerMap(let x):
2565+ try container.encode(x)
2566+ case .null:
2567+ try container.encodeNil()
2568+ }
2569+ }
2570+}
2571+
2572+enum Shakespearolater: Codable, Hashable {
2573+ case double(Double)
2574+ case integerArray([Int])
2575+ case string(String)
2576+
2577+ init(from decoder: Decoder) throws {
2578+ let container = try decoder.singleValueContainer()
2579+ if let x = try? container.decode([Int].self) {
2580+ self = .integerArray(x)
2581+ return
2582+ }
2583+ if let x = try? container.decode(Double.self) {
2584+ self = .double(x)
2585+ return
2586+ }
2587+ if let x = try? container.decode(String.self) {
2588+ self = .string(x)
2589+ return
2590+ }
2591+ throw DecodingError.typeMismatch(Shakespearolater.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Shakespearolater"))
2592+ }
2593+
2594+ func encode(to encoder: Encoder) throws {
2595+ var container = encoder.singleValueContainer()
2596+ switch self {
2597+ case .double(let x):
2598+ try container.encode(x)
2599+ case .integerArray(let x):
2600+ try container.encode(x)
2601+ case .string(let x):
2602+ try container.encode(x)
2603+ }
2604+ }
2605+}
2606+
2607+// MARK: - Helper functions for creating encoders and decoders
2608+
2609+func newJSONDecoder() -> JSONDecoder {
2610+ let decoder = JSONDecoder()
2611+ decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in
2612+ let container = try decoder.singleValueContainer()
2613+ let dateStr = try container.decode(String.self)
2614+
2615+ let formatter = DateFormatter()
2616+ formatter.calendar = Calendar(identifier: .iso8601)
2617+ formatter.locale = Locale(identifier: "en_US_POSIX")
2618+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
2619+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX"
2620+ if let date = formatter.date(from: dateStr) {
2621+ return date
2622+ }
2623+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX"
2624+ if let date = formatter.date(from: dateStr) {
2625+ return date
2626+ }
2627+ throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date"))
2628+ })
2629+ return decoder
2630+}
2631+
2632+func newJSONEncoder() -> JSONEncoder {
2633+ let encoder = JSONEncoder()
2634+ let formatter = DateFormatter()
2635+ formatter.calendar = Calendar(identifier: .iso8601)
2636+ formatter.locale = Locale(identifier: "en_US_POSIX")
2637+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
2638+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSXXXXX"
2639+ encoder.dateEncodingStrategy = .formatted(formatter)
2640+ return encoder
2641+}
2642+
2643+// MARK: - Encode/decode helpers
2644+
2645+class JSONNull: Codable, Hashable {
2646+
2647+ public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool {
2648+ return true
2649+ }
2650+
2651+ public func hash(into hasher: inout Hasher) {
2652+ hasher.combine(0)
2653+ }
2654+
2655+ public init() {}
2656+
2657+ public required init(from decoder: Decoder) throws {
2658+ let container = try decoder.singleValueContainer()
2659+ if !container.decodeNil() {
2660+ throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull"))
2661+ }
2662+ }
2663+
2664+ public func encode(to encoder: Encoder) throws {
2665+ var container = encoder.singleValueContainer()
2666+ try container.encodeNil()
2667+ }
2668+}
Atypescriptprefer-const-values-true--6b26e4d1265c / TopLevel.ts+812 −0
@@ -0,0 +1,812 @@
1+// To parse this data:
2+//
3+// import { Convert, TopLevel } from "./TopLevel";
4+//
5+// const topLevel = Convert.toTopLevel(json);
6+//
7+// These functions will throw an error if the JSON doesn't
8+// match the expected interface, even if the JSON is valid.
9+
10+export interface TopLevel {
11+ Abranchiata: Abranchiata[];
12+ Andriana: (null | string)[];
13+ Ansarie: AnsarieElement[];
14+ Chytridiaceae: ChytridiaceaeElement[];
15+ Discordia: DiscordiaElement[];
16+ Endomyces: Endomyce[];
17+ Epinephelidae: Epinephelidae[];
18+ Eupatorium: Eupatorium[];
19+ Gryphosaurus: GryphosaurusElement[];
20+ Koryak: Koryak[];
21+ Lavinia: LaviniaElement[];
22+ Oskar: OskarElement[];
23+ Rebecca: RebeccaElement[];
24+ Rhomboganoidei: Rhomboganoidei[];
25+ Rigsmal: boolean;
26+ Ruellia: Ruellia[];
27+ School: School[];
28+ Shakespearolater: Shakespearolater[];
29+ Svan: number[];
30+ Wayao: { [key: string]: number };
31+ academe: Academe[];
32+ acquirable: Acquirable[];
33+ aerometry: Aerometry[];
34+ alexin: Alexin[];
35+ alleviate: AlleviateElement[];
36+ amaas: Amaa[];
37+ ambassage: Ambassage[];
38+ amphithyron: (Amphithyron | null)[];
39+ ankee: AnkeeElement[];
40+ annihilator: ({ [key: string]: number | null } | null)[];
41+ annulose: null;
42+ aphasia: Aphasia[];
43+ asprawl: Asprawl[];
44+ attractive: (boolean | null)[];
45+ barksome: { [key: string]: number };
46+ bedesman: Bedesman[];
47+ belard: Belard[];
48+ bocking: Bocking[];
49+ brawlingly: Brawlingly[];
50+ brookie: Brookie[];
51+ bumboatman: Bumboatman[];
52+ bystreet: null[];
53+ calaverite: Calaverite[];
54+ catallactic: Catallactic[];
55+ cemental: Cemental[];
56+}
57+
58+export type Abranchiata = number[] | number | null;
59+
60+export type AnsarieElement = number[] | AnsarieClass | null;
61+
62+export interface AnsarieClass {
63+ Alida: null;
64+ Ictonyx: null;
65+ Ramist: null;
66+ accension: null;
67+ asteria: null;
68+ beriberic: null;
69+ edgebone: null;
70+ gastrodialysis: null;
71+ geographic: null;
72+ metrocele: null;
73+ misgraft: null;
74+ monteith: null;
75+ notcher: null;
76+ prorestriction: null;
77+ throatlet: null;
78+ unfair: null;
79+ unsynonymous: null;
80+ water: null;
81+ zestfully: null;
82+ zincic: null;
83+}
84+
85+export type ChytridiaceaeElement = boolean | ChytridiaceaeClass | null;
86+
87+export interface ChytridiaceaeClass {
88+ Batidaceae: null;
89+ Brechites: null;
90+ Emery: null;
91+ Narraganset: null;
92+ codespairer: null;
93+ enervative: null;
94+ excriminate: null;
95+ goshenite: null;
96+ grime: null;
97+ gritten: null;
98+ hectorly: null;
99+ intermediation: null;
100+ meeterly: null;
101+ onymatic: null;
102+ paddlecock: null;
103+ thana: null;
104+ thornily: null;
105+ uckia: null;
106+ unmettle: null;
107+ vorticellid: null;
108+}
109+
110+export type DiscordiaElement = number[] | DiscordiaClass;
111+
112+export interface DiscordiaClass {
113+ Altaic?: number;
114+ Chirotherium?: number;
115+ Patarin?: number;
116+ amoristic?: number;
117+ blennophthalmia?: number;
118+ catharticalness?: number;
119+ disciplinability?: number;
120+ disdiapason?: string;
121+ goofer?: number;
122+ homocerc?: boolean;
123+ laryngograph?: number;
124+ leucitis?: number;
125+ lymphocyst?: number;
126+ microcosmology?: number;
127+ nauseation?: number;
128+ nonbookish?: null;
129+ preliberal?: number;
130+ prettifier?: number;
131+ rangework?: number;
132+ redient?: number;
133+ subfusiform?: number;
134+ suicidical?: number;
135+ swow?: number;
136+ wastrel?: number;
137+ wingle?: number;
138+}
139+
140+export type Endomyce = number | string;
141+
142+export type Epinephelidae = boolean | number | string;
143+
144+export type Eupatorium = null[] | { [key: string]: number };
145+
146+export type GryphosaurusElement = number[] | GryphosaurusClass | string;
147+
148+export interface GryphosaurusClass {
149+ Burushaski: null;
150+ Tahami: null;
151+ amissibility: null;
152+ citronin: null;
153+ coplaintiff: null;
154+ disquisitionary: null;
155+ enoplan: null;
156+ faintness: null;
157+ hebetomy: null;
158+ islandry: null;
159+ lameduck: null;
160+ overbattle: null;
161+ overinterested: null;
162+ phrenologic: null;
163+ rainband: null;
164+ shiningly: null;
165+ stamineous: null;
166+ subscapularis: null;
167+ undaubed: null;
168+ underntime: null;
169+}
170+
171+export type Koryak = { [key: string]: number | null } | string;
172+
173+export type LaviniaElement = LaviniaClass | string;
174+
175+export interface LaviniaClass {
176+ Chirotherium?: number;
177+ Tacana?: number;
178+ agitable?: number;
179+ asininity?: number;
180+ benefiter?: number;
181+ bronzelike?: number;
182+ catharticalness?: number;
183+ cholesteatomatous?: number;
184+ deprivement?: number;
185+ disdiapason?: string;
186+ flippantness?: number;
187+ fogproof?: number;
188+ homocerc?: boolean;
189+ merrymeeting?: number;
190+ nonbookish?: null;
191+ overcareful?: number;
192+ panaris?: number;
193+ preacceptance?: number;
194+ quinoxaline?: number;
195+ sig?: number;
196+ superconfusion?: number;
197+ tillotter?: number;
198+ tranquillize?: number;
199+ unquestionable?: number;
200+ uproute?: number;
201+}
202+
203+export type OskarElement = number[] | OskarClass;
204+
205+export interface OskarClass {
206+ Acrobates: null;
207+ Cayuga: null;
208+ Netherlandish: null;
209+ beanshooter: null;
210+ bearhound: null;
211+ guarneri: null;
212+ hypochondriacism: null;
213+ indication: null;
214+ jaculative: null;
215+ nagana: null;
216+ noctivagous: null;
217+ nonphysiological: null;
218+ praxis: null;
219+ provision: null;
220+ subterhuman: null;
221+ sunlit: null;
222+ syncraniate: null;
223+ teachment: null;
224+ unmutinous: null;
225+ unstoppable: null;
226+}
227+
228+export type RebeccaElement = Rebecca | number | string;
229+
230+export interface Rebecca {
231+ Chirotherium: number;
232+ catharticalness: number;
233+ disdiapason: string;
234+ homocerc: boolean;
235+ nonbookish: null;
236+}
237+
238+export type Rhomboganoidei = number[] | Rebecca | string;
239+
240+export type Ruellia = boolean | Rebecca | string;
241+
242+export type School = number | { [key: string]: number } | null;
243+
244+export type Shakespearolater = number[] | number | string;
245+
246+export type Academe = number[] | number | { [key: string]: number };
247+
248+export type Acquirable = (number | null)[] | { [key: string]: number };
249+
250+export type Aerometry = boolean | number;
251+
252+export type Alexin = number[] | boolean;
253+
254+export type AlleviateElement = (number | null)[] | AlleviateClass;
255+
256+export interface AlleviateClass {
257+ Hulsean: null;
258+ apriori: null;
259+ beggarer: null;
260+ brokenheartedly: null;
261+ debilitation: null;
262+ frike: null;
263+ gastrolith: null;
264+ orthocentric: null;
265+ petaly: null;
266+ probudgeting: null;
267+ reacquire: null;
268+ scow: null;
269+ shutoff: null;
270+ subcontiguous: null;
271+ suffumigate: null;
272+ transformable: null;
273+ uncoroneted: null;
274+ unparking: null;
275+ unvarnishedness: null;
276+ wherewithal: null;
277+}
278+
279+export type Amaa = boolean | Rebecca | number;
280+
281+export type Ambassage = null[] | string;
282+
283+export interface Amphithyron {
284+ Chirotherium?: number;
285+ Juniperus?: number;
286+ Nazirite?: number;
287+ Those?: number;
288+ akroasis?: number;
289+ antiphonical?: number;
290+ basebred?: number;
291+ catharticalness?: number;
292+ conductometric?: number;
293+ disdiapason?: string;
294+ ensilation?: number;
295+ eyebolt?: number;
296+ fistulated?: number;
297+ heteropod?: number;
298+ homocerc?: boolean;
299+ labyrinthically?: number;
300+ martyrization?: number;
301+ mispolicy?: number;
302+ multipara?: number;
303+ nonbookish?: null;
304+ possessorial?: number;
305+ shamed?: number;
306+ shelfworn?: number;
307+ stagnum?: number;
308+ undecimal?: number;
309+}
310+
311+export type AnkeeElement = number[] | AnkeeClass | number;
312+
313+export interface AnkeeClass {
314+ Anomoean: null;
315+ Naja: null;
316+ barleyhood: null;
317+ befriender: null;
318+ brutishness: null;
319+ cephalalgy: null;
320+ cirurgian: null;
321+ conventionally: null;
322+ jackshay: null;
323+ milammeter: null;
324+ ombrological: null;
325+ phonasthenia: null;
326+ retrievableness: null;
327+ snakily: null;
328+ swot: null;
329+ tartlet: null;
330+ thiofuran: null;
331+ tracheophone: null;
332+ tuglike: null;
333+ unscratchingly: null;
334+}
335+
336+export type Aphasia = number[] | number;
337+
338+export type Asprawl = number | string;
339+
340+export type Bedesman = boolean | number | string;
341+
342+export type Belard = number[] | Rebecca | number;
343+
344+export type Bocking = number[] | boolean | { [key: string]: number };
345+
346+export type Brawlingly = null[] | { [key: string]: number | null };
347+
348+export type Brookie = number[] | Rebecca;
349+
350+export type Bumboatman = null[] | null | string;
351+
352+export type Calaverite = number[] | string;
353+
354+export type Catallactic = null[] | boolean | { [key: string]: number };
355+
356+export type Cemental = number[] | number | { [key: string]: number };
357+
358+// Converts JSON strings to/from your types
359+// and asserts the results of JSON.parse at runtime
360+export class Convert {
361+ public static toTopLevel(json: string): TopLevel {
362+ return cast(JSON.parse(json), r("TopLevel"));
363+ }
364+
365+ public static topLevelToJson(value: TopLevel): string {
366+ return JSON.stringify(uncast(value, r("TopLevel")), null, 2);
367+ }
368+}
369+
370+function invalidValue(typ: any, val: any, key: any, parent: any = ''): never {
371+ const prettyTyp = prettyTypeName(typ);
372+ const parentText = parent ? ` on ${parent}` : '';
373+ const keyText = key ? ` for key "${key}"` : '';
374+ throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`);
375+}
376+
377+function prettyTypeName(typ: any): string {
378+ if (Array.isArray(typ)) {
379+ if (typ.length === 2 && typ[0] === undefined) {
380+ return `an optional ${prettyTypeName(typ[1])}`;
381+ } else {
382+ return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`;
383+ }
384+ } else if (typeof typ === "object" && typ.literal !== undefined) {
385+ return typ.literal;
386+ } else {
387+ return typeof typ;
388+ }
389+}
390+
391+function jsonToJSProps(typ: any): any {
392+ if (typ.jsonToJS === undefined) {
393+ const map: any = {};
394+ typ.props.forEach((p: any) => map[p.json] = { key: p.js, typ: p.typ });
395+ typ.jsonToJS = map;
396+ }
397+ return typ.jsonToJS;
398+}
399+
400+function jsToJSONProps(typ: any): any {
401+ if (typ.jsToJSON === undefined) {
402+ const map: any = {};
403+ typ.props.forEach((p: any) => map[p.js] = { key: p.json, typ: p.typ });
404+ typ.jsToJSON = map;
405+ }
406+ return typ.jsToJSON;
407+}
408+
409+function transform(val: any, typ: any, getProps: any, key: any = '', parent: any = ''): any {
410+ function transformPrimitive(typ: string, val: any): any {
411+ if (typeof typ === typeof val) return val;
412+ return invalidValue(typ, val, key, parent);
413+ }
414+
415+ function transformUnion(typs: any[], val: any): any {
416+ // val must validate against one typ in typs
417+ const l = typs.length;
418+ for (let i = 0; i < l; i++) {
419+ const typ = typs[i];
420+ try {
421+ return transform(val, typ, getProps);
422+ } catch (_) {}
423+ }
424+ return invalidValue(typs, val, key, parent);
425+ }
426+
427+ function transformEnum(cases: string[], val: any): any {
428+ if (cases.indexOf(val) !== -1) return val;
429+ return invalidValue(cases.map(a => { return l(a); }), val, key, parent);
430+ }
431+
432+ function transformArray(typ: any, val: any): any {
433+ // val must be an array with no invalid elements
434+ if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent);
435+
436+ return val.map(el => transform(el, typ, getProps));
437+ }
438+
439+ function transformDate(val: any): any {
440+ if (val === null) {
441+ return null;
442+ }
443+ const d = new Date(val);
444+ if (isNaN(d.valueOf())) {
445+ return invalidValue(l("Date"), val, key, parent);
446+ }
447+ return d;
448+ }
449+
450+ function transformObject(props: { [k: string]: any }, additional: any, val: any): any {
451+ if (val === null || typeof val !== "object" || Array.isArray(val)) {
452+ return invalidValue(l(ref || "object"), val, key, parent);
453+ }
454+ const result: any = {};
455+ Object.getOwnPropertyNames(props).forEach(key => {
456+ const prop = props[key];
457+ const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined;
458+ result[prop.key] = transform(v, prop.typ, getProps, key, ref);
459+ });
460+ Object.getOwnPropertyNames(val).forEach(key => {
461+ if (!Object.prototype.hasOwnProperty.call(props, key)) {
462+ result[key] = transform(val[key], additional, getProps, key, ref);
463+ }
464+ });
465+ return result;
466+ }
467+
468+ if (typ === "any") return val;
469+ if (typ === null) {
470+ if (val === null) return val;
471+ return invalidValue(typ, val, key, parent);
472+ }
473+ if (typ === false) return invalidValue(typ, val, key, parent);
474+ let ref: any = undefined;
475+ while (typeof typ === "object" && typ.ref !== undefined) {
476+ ref = typ.ref;
477+ typ = typeMap[typ.ref];
478+ }
479+ if (Array.isArray(typ)) return transformEnum(typ, val);
480+ if (typeof typ === "object") {
481+ return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent)
482+ : 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)
483+ : 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)
484+ : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent)
485+ : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val)
486+ : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val)
487+ : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val)
488+ : invalidValue(typ, val, key, parent);
489+ }
490+ // Numbers can be parsed by Date but shouldn't be.
491+ if (typ === Date && typeof val !== "number") return transformDate(val);
492+ return transformPrimitive(typ, val);
493+}
494+
495+function cast<T>(val: any, typ: any): T {
496+ return transform(val, typ, jsonToJSProps);
497+}
498+
499+function uncast<T>(val: T, typ: any): any {
500+ return transform(val, typ, jsToJSONProps);
501+}
502+
503+function l(typ: any) {
504+ return { literal: typ };
505+}
506+
507+function a(typ: any) {
508+ return { arrayItems: typ };
509+}
510+
511+function i(typ: any) {
512+ return { integer: typ };
513+}
514+
515+function p(pattern: any) {
516+ return { pattern };
517+}
518+
519+function s(typ: any, min: any, max: any) {
520+ return { string: typ, min, max };
521+}
522+
523+function n(typ: any, min: any, max: any) {
524+ return { number: typ, min, max };
525+}
526+
527+function u(...typs: any[]) {
528+ return { unionMembers: typs };
529+}
530+
531+function o(props: any[], additional: any) {
532+ return { props, additional };
533+}
534+
535+function m(additional: any) {
536+ const props: any[] = [];
537+ return { props, additional };
538+}
539+
540+function r(name: string) {
541+ return { ref: name };
542+}
543+
544+const typeMap: any = {
545+ "TopLevel": o([
546+ { json: "Abranchiata", js: "Abranchiata", typ: a(u(a(i(0)), i(0), null)) },
547+ { json: "Andriana", js: "Andriana", typ: a(u(null, "")) },
548+ { json: "Ansarie", js: "Ansarie", typ: a(u(a(i(0)), r("AnsarieClass"), null)) },
549+ { json: "Chytridiaceae", js: "Chytridiaceae", typ: a(u(true, r("ChytridiaceaeClass"), null)) },
550+ { json: "Discordia", js: "Discordia", typ: a(u(a(i(0)), r("DiscordiaClass"))) },
551+ { json: "Endomyces", js: "Endomyces", typ: a(u(i(0), "")) },
552+ { json: "Epinephelidae", js: "Epinephelidae", typ: a(u(true, i(0), "")) },
553+ { json: "Eupatorium", js: "Eupatorium", typ: a(u(a(null), m(i(0)))) },
554+ { json: "Gryphosaurus", js: "Gryphosaurus", typ: a(u(a(i(0)), r("GryphosaurusClass"), "")) },
555+ { json: "Koryak", js: "Koryak", typ: a(u(m(u(i(0), null)), "")) },
556+ { json: "Lavinia", js: "Lavinia", typ: a(u(r("LaviniaClass"), "")) },
557+ { json: "Oskar", js: "Oskar", typ: a(u(a(i(0)), r("OskarClass"))) },
558+ { json: "Rebecca", js: "Rebecca", typ: a(u(r("Rebecca"), i(0), "")) },
559+ { json: "Rhomboganoidei", js: "Rhomboganoidei", typ: a(u(a(i(0)), r("Rebecca"), "")) },
560+ { json: "Rigsmal", js: "Rigsmal", typ: true },
561+ { json: "Ruellia", js: "Ruellia", typ: a(u(true, r("Rebecca"), "")) },
562+ { json: "School", js: "School", typ: a(u(i(0), m(i(0)), null)) },
563+ { json: "Shakespearolater", js: "Shakespearolater", typ: a(u(a(i(0)), 3.14, "")) },
564+ { json: "Svan", js: "Svan", typ: a(3.14) },
565+ { json: "Wayao", js: "Wayao", typ: m(3.14) },
566+ { json: "academe", js: "academe", typ: a(u(a(i(0)), i(0), m(i(0)))) },
567+ { json: "acquirable", js: "acquirable", typ: a(u(a(u(i(0), null)), m(i(0)))) },
568+ { json: "aerometry", js: "aerometry", typ: a(u(true, 3.14)) },
569+ { json: "alexin", js: "alexin", typ: a(u(a(i(0)), true)) },
570+ { json: "alleviate", js: "alleviate", typ: a(u(a(u(i(0), null)), r("AlleviateClass"))) },
571+ { json: "amaas", js: "amaas", typ: a(u(true, r("Rebecca"), i(0))) },
572+ { json: "ambassage", js: "ambassage", typ: a(u(a(null), "")) },
573+ { json: "amphithyron", js: "amphithyron", typ: a(u(r("Amphithyron"), null)) },
574+ { json: "ankee", js: "ankee", typ: a(u(a(i(0)), r("AnkeeClass"), i(0))) },
575+ { json: "annihilator", js: "annihilator", typ: a(u(m(u(i(0), null)), null)) },
576+ { json: "annulose", js: "annulose", typ: null },
577+ { json: "aphasia", js: "aphasia", typ: a(u(a(i(0)), i(0))) },
578+ { json: "asprawl", js: "asprawl", typ: a(u(3.14, "")) },
579+ { json: "attractive", js: "attractive", typ: a(u(true, null)) },
580+ { json: "barksome", js: "barksome", typ: m(i(0)) },
581+ { json: "bedesman", js: "bedesman", typ: a(u(true, 3.14, "")) },
582+ { json: "belard", js: "belard", typ: a(u(a(i(0)), r("Rebecca"), 3.14)) },
583+ { json: "bocking", js: "bocking", typ: a(u(a(i(0)), true, m(i(0)))) },
584+ { json: "brawlingly", js: "brawlingly", typ: a(u(a(null), m(u(i(0), null)))) },
585+ { json: "brookie", js: "brookie", typ: a(u(a(i(0)), r("Rebecca"))) },
586+ { json: "bumboatman", js: "bumboatman", typ: a(u(a(null), null, "")) },
587+ { json: "bystreet", js: "bystreet", typ: a(null) },
588+ { json: "calaverite", js: "calaverite", typ: a(u(a(i(0)), "")) },
589+ { json: "catallactic", js: "catallactic", typ: a(u(a(null), true, m(i(0)))) },
590+ { json: "cemental", js: "cemental", typ: a(u(a(i(0)), 3.14, m(i(0)))) },
591+ ], false),
592+ "AnsarieClass": o([
593+ { json: "Alida", js: "Alida", typ: null },
594+ { json: "Ictonyx", js: "Ictonyx", typ: null },
595+ { json: "Ramist", js: "Ramist", typ: null },
596+ { json: "accension", js: "accension", typ: null },
597+ { json: "asteria", js: "asteria", typ: null },
598+ { json: "beriberic", js: "beriberic", typ: null },
599+ { json: "edgebone", js: "edgebone", typ: null },
600+ { json: "gastrodialysis", js: "gastrodialysis", typ: null },
601+ { json: "geographic", js: "geographic", typ: null },
602+ { json: "metrocele", js: "metrocele", typ: null },
603+ { json: "misgraft", js: "misgraft", typ: null },
604+ { json: "monteith", js: "monteith", typ: null },
605+ { json: "notcher", js: "notcher", typ: null },
606+ { json: "prorestriction", js: "prorestriction", typ: null },
607+ { json: "throatlet", js: "throatlet", typ: null },
608+ { json: "unfair", js: "unfair", typ: null },
609+ { json: "unsynonymous", js: "unsynonymous", typ: null },
610+ { json: "water", js: "water", typ: null },
611+ { json: "zestfully", js: "zestfully", typ: null },
612+ { json: "zincic", js: "zincic", typ: null },
613+ ], false),
614+ "ChytridiaceaeClass": o([
615+ { json: "Batidaceae", js: "Batidaceae", typ: null },
616+ { json: "Brechites", js: "Brechites", typ: null },
617+ { json: "Emery", js: "Emery", typ: null },
618+ { json: "Narraganset", js: "Narraganset", typ: null },
619+ { json: "codespairer", js: "codespairer", typ: null },
620+ { json: "enervative", js: "enervative", typ: null },
621+ { json: "excriminate", js: "excriminate", typ: null },
622+ { json: "goshenite", js: "goshenite", typ: null },
623+ { json: "grime", js: "grime", typ: null },
624+ { json: "gritten", js: "gritten", typ: null },
625+ { json: "hectorly", js: "hectorly", typ: null },
626+ { json: "intermediation", js: "intermediation", typ: null },
627+ { json: "meeterly", js: "meeterly", typ: null },
628+ { json: "onymatic", js: "onymatic", typ: null },
629+ { json: "paddlecock", js: "paddlecock", typ: null },
630+ { json: "thana", js: "thana", typ: null },
631+ { json: "thornily", js: "thornily", typ: null },
632+ { json: "uckia", js: "uckia", typ: null },
633+ { json: "unmettle", js: "unmettle", typ: null },
634+ { json: "vorticellid", js: "vorticellid", typ: null },
635+ ], false),
636+ "DiscordiaClass": o([
637+ { json: "Altaic", js: "Altaic", typ: u(undefined, i(0)) },
638+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
639+ { json: "Patarin", js: "Patarin", typ: u(undefined, i(0)) },
640+ { json: "amoristic", js: "amoristic", typ: u(undefined, i(0)) },
641+ { json: "blennophthalmia", js: "blennophthalmia", typ: u(undefined, i(0)) },
642+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
643+ { json: "disciplinability", js: "disciplinability", typ: u(undefined, i(0)) },
644+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
645+ { json: "goofer", js: "goofer", typ: u(undefined, i(0)) },
646+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
647+ { json: "laryngograph", js: "laryngograph", typ: u(undefined, i(0)) },
648+ { json: "leucitis", js: "leucitis", typ: u(undefined, i(0)) },
649+ { json: "lymphocyst", js: "lymphocyst", typ: u(undefined, i(0)) },
650+ { json: "microcosmology", js: "microcosmology", typ: u(undefined, i(0)) },
651+ { json: "nauseation", js: "nauseation", typ: u(undefined, i(0)) },
652+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
653+ { json: "preliberal", js: "preliberal", typ: u(undefined, i(0)) },
654+ { json: "prettifier", js: "prettifier", typ: u(undefined, i(0)) },
655+ { json: "rangework", js: "rangework", typ: u(undefined, i(0)) },
656+ { json: "redient", js: "redient", typ: u(undefined, i(0)) },
657+ { json: "subfusiform", js: "subfusiform", typ: u(undefined, i(0)) },
658+ { json: "suicidical", js: "suicidical", typ: u(undefined, i(0)) },
659+ { json: "swow", js: "swow", typ: u(undefined, i(0)) },
660+ { json: "wastrel", js: "wastrel", typ: u(undefined, i(0)) },
661+ { json: "wingle", js: "wingle", typ: u(undefined, i(0)) },
662+ ], false),
663+ "GryphosaurusClass": o([
664+ { json: "Burushaski", js: "Burushaski", typ: null },
665+ { json: "Tahami", js: "Tahami", typ: null },
666+ { json: "amissibility", js: "amissibility", typ: null },
667+ { json: "citronin", js: "citronin", typ: null },
668+ { json: "coplaintiff", js: "coplaintiff", typ: null },
669+ { json: "disquisitionary", js: "disquisitionary", typ: null },
670+ { json: "enoplan", js: "enoplan", typ: null },
671+ { json: "faintness", js: "faintness", typ: null },
672+ { json: "hebetomy", js: "hebetomy", typ: null },
673+ { json: "islandry", js: "islandry", typ: null },
674+ { json: "lameduck", js: "lameduck", typ: null },
675+ { json: "overbattle", js: "overbattle", typ: null },
676+ { json: "overinterested", js: "overinterested", typ: null },
677+ { json: "phrenologic", js: "phrenologic", typ: null },
678+ { json: "rainband", js: "rainband", typ: null },
679+ { json: "shiningly", js: "shiningly", typ: null },
680+ { json: "stamineous", js: "stamineous", typ: null },
681+ { json: "subscapularis", js: "subscapularis", typ: null },
682+ { json: "undaubed", js: "undaubed", typ: null },
683+ { json: "underntime", js: "underntime", typ: null },
684+ ], false),
685+ "LaviniaClass": o([
686+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
687+ { json: "Tacana", js: "Tacana", typ: u(undefined, i(0)) },
688+ { json: "agitable", js: "agitable", typ: u(undefined, i(0)) },
689+ { json: "asininity", js: "asininity", typ: u(undefined, i(0)) },
690+ { json: "benefiter", js: "benefiter", typ: u(undefined, i(0)) },
691+ { json: "bronzelike", js: "bronzelike", typ: u(undefined, i(0)) },
692+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
693+ { json: "cholesteatomatous", js: "cholesteatomatous", typ: u(undefined, i(0)) },
694+ { json: "deprivement", js: "deprivement", typ: u(undefined, i(0)) },
695+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
696+ { json: "flippantness", js: "flippantness", typ: u(undefined, i(0)) },
697+ { json: "fogproof", js: "fogproof", typ: u(undefined, i(0)) },
698+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
699+ { json: "merrymeeting", js: "merrymeeting", typ: u(undefined, i(0)) },
700+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
701+ { json: "overcareful", js: "overcareful", typ: u(undefined, i(0)) },
702+ { json: "panaris", js: "panaris", typ: u(undefined, i(0)) },
703+ { json: "preacceptance", js: "preacceptance", typ: u(undefined, i(0)) },
704+ { json: "quinoxaline", js: "quinoxaline", typ: u(undefined, i(0)) },
705+ { json: "sig", js: "sig", typ: u(undefined, i(0)) },
706+ { json: "superconfusion", js: "superconfusion", typ: u(undefined, i(0)) },
707+ { json: "tillotter", js: "tillotter", typ: u(undefined, i(0)) },
708+ { json: "tranquillize", js: "tranquillize", typ: u(undefined, i(0)) },
709+ { json: "unquestionable", js: "unquestionable", typ: u(undefined, i(0)) },
710+ { json: "uproute", js: "uproute", typ: u(undefined, i(0)) },
711+ ], false),
712+ "OskarClass": o([
713+ { json: "Acrobates", js: "Acrobates", typ: null },
714+ { json: "Cayuga", js: "Cayuga", typ: null },
715+ { json: "Netherlandish", js: "Netherlandish", typ: null },
716+ { json: "beanshooter", js: "beanshooter", typ: null },
717+ { json: "bearhound", js: "bearhound", typ: null },
718+ { json: "guarneri", js: "guarneri", typ: null },
719+ { json: "hypochondriacism", js: "hypochondriacism", typ: null },
720+ { json: "indication", js: "indication", typ: null },
721+ { json: "jaculative", js: "jaculative", typ: null },
722+ { json: "nagana", js: "nagana", typ: null },
723+ { json: "noctivagous", js: "noctivagous", typ: null },
724+ { json: "nonphysiological", js: "nonphysiological", typ: null },
725+ { json: "praxis", js: "praxis", typ: null },
726+ { json: "provision", js: "provision", typ: null },
727+ { json: "subterhuman", js: "subterhuman", typ: null },
728+ { json: "sunlit", js: "sunlit", typ: null },
729+ { json: "syncraniate", js: "syncraniate", typ: null },
730+ { json: "teachment", js: "teachment", typ: null },
731+ { json: "unmutinous", js: "unmutinous", typ: null },
732+ { json: "unstoppable", js: "unstoppable", typ: null },
733+ ], false),
734+ "Rebecca": o([
735+ { json: "Chirotherium", js: "Chirotherium", typ: i(0) },
736+ { json: "catharticalness", js: "catharticalness", typ: 3.14 },
737+ { json: "disdiapason", js: "disdiapason", typ: "" },
738+ { json: "homocerc", js: "homocerc", typ: true },
739+ { json: "nonbookish", js: "nonbookish", typ: null },
740+ ], false),
741+ "AlleviateClass": o([
742+ { json: "Hulsean", js: "Hulsean", typ: null },
743+ { json: "apriori", js: "apriori", typ: null },
744+ { json: "beggarer", js: "beggarer", typ: null },
745+ { json: "brokenheartedly", js: "brokenheartedly", typ: null },
746+ { json: "debilitation", js: "debilitation", typ: null },
747+ { json: "frike", js: "frike", typ: null },
748+ { json: "gastrolith", js: "gastrolith", typ: null },
749+ { json: "orthocentric", js: "orthocentric", typ: null },
750+ { json: "petaly", js: "petaly", typ: null },
751+ { json: "probudgeting", js: "probudgeting", typ: null },
752+ { json: "reacquire", js: "reacquire", typ: null },
753+ { json: "scow", js: "scow", typ: null },
754+ { json: "shutoff", js: "shutoff", typ: null },
755+ { json: "subcontiguous", js: "subcontiguous", typ: null },
756+ { json: "suffumigate", js: "suffumigate", typ: null },
757+ { json: "transformable", js: "transformable", typ: null },
758+ { json: "uncoroneted", js: "uncoroneted", typ: null },
759+ { json: "unparking", js: "unparking", typ: null },
760+ { json: "unvarnishedness", js: "unvarnishedness", typ: null },
761+ { json: "wherewithal", js: "wherewithal", typ: null },
762+ ], false),
763+ "Amphithyron": o([
764+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
765+ { json: "Juniperus", js: "Juniperus", typ: u(undefined, i(0)) },
766+ { json: "Nazirite", js: "Nazirite", typ: u(undefined, i(0)) },
767+ { json: "Those", js: "Those", typ: u(undefined, i(0)) },
768+ { json: "akroasis", js: "akroasis", typ: u(undefined, i(0)) },
769+ { json: "antiphonical", js: "antiphonical", typ: u(undefined, i(0)) },
770+ { json: "basebred", js: "basebred", typ: u(undefined, i(0)) },
771+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
772+ { json: "conductometric", js: "conductometric", typ: u(undefined, i(0)) },
773+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
774+ { json: "ensilation", js: "ensilation", typ: u(undefined, i(0)) },
775+ { json: "eyebolt", js: "eyebolt", typ: u(undefined, i(0)) },
776+ { json: "fistulated", js: "fistulated", typ: u(undefined, i(0)) },
777+ { json: "heteropod", js: "heteropod", typ: u(undefined, i(0)) },
778+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
779+ { json: "labyrinthically", js: "labyrinthically", typ: u(undefined, i(0)) },
780+ { json: "martyrization", js: "martyrization", typ: u(undefined, i(0)) },
781+ { json: "mispolicy", js: "mispolicy", typ: u(undefined, i(0)) },
782+ { json: "multipara", js: "multipara", typ: u(undefined, i(0)) },
783+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
784+ { json: "possessorial", js: "possessorial", typ: u(undefined, i(0)) },
785+ { json: "shamed", js: "shamed", typ: u(undefined, i(0)) },
786+ { json: "shelfworn", js: "shelfworn", typ: u(undefined, i(0)) },
787+ { json: "stagnum", js: "stagnum", typ: u(undefined, i(0)) },
788+ { json: "undecimal", js: "undecimal", typ: u(undefined, i(0)) },
789+ ], false),
790+ "AnkeeClass": o([
791+ { json: "Anomoean", js: "Anomoean", typ: null },
792+ { json: "Naja", js: "Naja", typ: null },
793+ { json: "barleyhood", js: "barleyhood", typ: null },
794+ { json: "befriender", js: "befriender", typ: null },
795+ { json: "brutishness", js: "brutishness", typ: null },
796+ { json: "cephalalgy", js: "cephalalgy", typ: null },
797+ { json: "cirurgian", js: "cirurgian", typ: null },
798+ { json: "conventionally", js: "conventionally", typ: null },
799+ { json: "jackshay", js: "jackshay", typ: null },
800+ { json: "milammeter", js: "milammeter", typ: null },
801+ { json: "ombrological", js: "ombrological", typ: null },
802+ { json: "phonasthenia", js: "phonasthenia", typ: null },
803+ { json: "retrievableness", js: "retrievableness", typ: null },
804+ { json: "snakily", js: "snakily", typ: null },
805+ { json: "swot", js: "swot", typ: null },
806+ { json: "tartlet", js: "tartlet", typ: null },
807+ { json: "thiofuran", js: "thiofuran", typ: null },
808+ { json: "tracheophone", js: "tracheophone", typ: null },
809+ { json: "tuglike", js: "tuglike", typ: null },
810+ { json: "unscratchingly", js: "unscratchingly", typ: null },
811+ ], false),
812+};
Atypescriptprefer-types-true--df33e18681f9 / TopLevel.ts+812 −0
@@ -0,0 +1,812 @@
1+// To parse this data:
2+//
3+// import { Convert, TopLevel } from "./TopLevel";
4+//
5+// const topLevel = Convert.toTopLevel(json);
6+//
7+// These functions will throw an error if the JSON doesn't
8+// match the expected interface, even if the JSON is valid.
9+
10+export type TopLevel = {
11+ Abranchiata: Abranchiata[];
12+ Andriana: (null | string)[];
13+ Ansarie: AnsarieElement[];
14+ Chytridiaceae: ChytridiaceaeElement[];
15+ Discordia: DiscordiaElement[];
16+ Endomyces: Endomyce[];
17+ Epinephelidae: Epinephelidae[];
18+ Eupatorium: Eupatorium[];
19+ Gryphosaurus: GryphosaurusElement[];
20+ Koryak: Koryak[];
21+ Lavinia: LaviniaElement[];
22+ Oskar: OskarElement[];
23+ Rebecca: RebeccaElement[];
24+ Rhomboganoidei: Rhomboganoidei[];
25+ Rigsmal: boolean;
26+ Ruellia: Ruellia[];
27+ School: School[];
28+ Shakespearolater: Shakespearolater[];
29+ Svan: number[];
30+ Wayao: { [key: string]: number };
31+ academe: Academe[];
32+ acquirable: Acquirable[];
33+ aerometry: Aerometry[];
34+ alexin: Alexin[];
35+ alleviate: AlleviateElement[];
36+ amaas: Amaa[];
37+ ambassage: Ambassage[];
38+ amphithyron: (Amphithyron | null)[];
39+ ankee: AnkeeElement[];
40+ annihilator: ({ [key: string]: number | null } | null)[];
41+ annulose: null;
42+ aphasia: Aphasia[];
43+ asprawl: Asprawl[];
44+ attractive: (boolean | null)[];
45+ barksome: { [key: string]: number };
46+ bedesman: Bedesman[];
47+ belard: Belard[];
48+ bocking: Bocking[];
49+ brawlingly: Brawlingly[];
50+ brookie: Brookie[];
51+ bumboatman: Bumboatman[];
52+ bystreet: null[];
53+ calaverite: Calaverite[];
54+ catallactic: Catallactic[];
55+ cemental: Cemental[];
56+}
57+
58+export type Abranchiata = number[] | number | null;
59+
60+export type AnsarieElement = number[] | AnsarieClass | null;
61+
62+export type AnsarieClass = {
63+ Alida: null;
64+ Ictonyx: null;
65+ Ramist: null;
66+ accension: null;
67+ asteria: null;
68+ beriberic: null;
69+ edgebone: null;
70+ gastrodialysis: null;
71+ geographic: null;
72+ metrocele: null;
73+ misgraft: null;
74+ monteith: null;
75+ notcher: null;
76+ prorestriction: null;
77+ throatlet: null;
78+ unfair: null;
79+ unsynonymous: null;
80+ water: null;
81+ zestfully: null;
82+ zincic: null;
83+}
84+
85+export type ChytridiaceaeElement = boolean | ChytridiaceaeClass | null;
86+
87+export type ChytridiaceaeClass = {
88+ Batidaceae: null;
89+ Brechites: null;
90+ Emery: null;
91+ Narraganset: null;
92+ codespairer: null;
93+ enervative: null;
94+ excriminate: null;
95+ goshenite: null;
96+ grime: null;
97+ gritten: null;
98+ hectorly: null;
99+ intermediation: null;
100+ meeterly: null;
101+ onymatic: null;
102+ paddlecock: null;
103+ thana: null;
104+ thornily: null;
105+ uckia: null;
106+ unmettle: null;
107+ vorticellid: null;
108+}
109+
110+export type DiscordiaElement = number[] | DiscordiaClass;
111+
112+export type DiscordiaClass = {
113+ Altaic?: number;
114+ Chirotherium?: number;
115+ Patarin?: number;
116+ amoristic?: number;
117+ blennophthalmia?: number;
118+ catharticalness?: number;
119+ disciplinability?: number;
120+ disdiapason?: string;
121+ goofer?: number;
122+ homocerc?: boolean;
123+ laryngograph?: number;
124+ leucitis?: number;
125+ lymphocyst?: number;
126+ microcosmology?: number;
127+ nauseation?: number;
128+ nonbookish?: null;
129+ preliberal?: number;
130+ prettifier?: number;
131+ rangework?: number;
132+ redient?: number;
133+ subfusiform?: number;
134+ suicidical?: number;
135+ swow?: number;
136+ wastrel?: number;
137+ wingle?: number;
138+}
139+
140+export type Endomyce = number | string;
141+
142+export type Epinephelidae = boolean | number | string;
143+
144+export type Eupatorium = null[] | { [key: string]: number };
145+
146+export type GryphosaurusElement = number[] | GryphosaurusClass | string;
147+
148+export type GryphosaurusClass = {
149+ Burushaski: null;
150+ Tahami: null;
151+ amissibility: null;
152+ citronin: null;
153+ coplaintiff: null;
154+ disquisitionary: null;
155+ enoplan: null;
156+ faintness: null;
157+ hebetomy: null;
158+ islandry: null;
159+ lameduck: null;
160+ overbattle: null;
161+ overinterested: null;
162+ phrenologic: null;
163+ rainband: null;
164+ shiningly: null;
165+ stamineous: null;
166+ subscapularis: null;
167+ undaubed: null;
168+ underntime: null;
169+}
170+
171+export type Koryak = { [key: string]: number | null } | string;
172+
173+export type LaviniaElement = LaviniaClass | string;
174+
175+export type LaviniaClass = {
176+ Chirotherium?: number;
177+ Tacana?: number;
178+ agitable?: number;
179+ asininity?: number;
180+ benefiter?: number;
181+ bronzelike?: number;
182+ catharticalness?: number;
183+ cholesteatomatous?: number;
184+ deprivement?: number;
185+ disdiapason?: string;
186+ flippantness?: number;
187+ fogproof?: number;
188+ homocerc?: boolean;
189+ merrymeeting?: number;
190+ nonbookish?: null;
191+ overcareful?: number;
192+ panaris?: number;
193+ preacceptance?: number;
194+ quinoxaline?: number;
195+ sig?: number;
196+ superconfusion?: number;
197+ tillotter?: number;
198+ tranquillize?: number;
199+ unquestionable?: number;
200+ uproute?: number;
201+}
202+
203+export type OskarElement = number[] | OskarClass;
204+
205+export type OskarClass = {
206+ Acrobates: null;
207+ Cayuga: null;
208+ Netherlandish: null;
209+ beanshooter: null;
210+ bearhound: null;
211+ guarneri: null;
212+ hypochondriacism: null;
213+ indication: null;
214+ jaculative: null;
215+ nagana: null;
216+ noctivagous: null;
217+ nonphysiological: null;
218+ praxis: null;
219+ provision: null;
220+ subterhuman: null;
221+ sunlit: null;
222+ syncraniate: null;
223+ teachment: null;
224+ unmutinous: null;
225+ unstoppable: null;
226+}
227+
228+export type RebeccaElement = Rebecca | number | string;
229+
230+export type Rebecca = {
231+ Chirotherium: number;
232+ catharticalness: number;
233+ disdiapason: string;
234+ homocerc: boolean;
235+ nonbookish: null;
236+}
237+
238+export type Rhomboganoidei = number[] | Rebecca | string;
239+
240+export type Ruellia = boolean | Rebecca | string;
241+
242+export type School = number | { [key: string]: number } | null;
243+
244+export type Shakespearolater = number[] | number | string;
245+
246+export type Academe = number[] | number | { [key: string]: number };
247+
248+export type Acquirable = (number | null)[] | { [key: string]: number };
249+
250+export type Aerometry = boolean | number;
251+
252+export type Alexin = number[] | boolean;
253+
254+export type AlleviateElement = (number | null)[] | AlleviateClass;
255+
256+export type AlleviateClass = {
257+ Hulsean: null;
258+ apriori: null;
259+ beggarer: null;
260+ brokenheartedly: null;
261+ debilitation: null;
262+ frike: null;
263+ gastrolith: null;
264+ orthocentric: null;
265+ petaly: null;
266+ probudgeting: null;
267+ reacquire: null;
268+ scow: null;
269+ shutoff: null;
270+ subcontiguous: null;
271+ suffumigate: null;
272+ transformable: null;
273+ uncoroneted: null;
274+ unparking: null;
275+ unvarnishedness: null;
276+ wherewithal: null;
277+}
278+
279+export type Amaa = boolean | Rebecca | number;
280+
281+export type Ambassage = null[] | string;
282+
283+export type Amphithyron = {
284+ Chirotherium?: number;
285+ Juniperus?: number;
286+ Nazirite?: number;
287+ Those?: number;
288+ akroasis?: number;
289+ antiphonical?: number;
290+ basebred?: number;
291+ catharticalness?: number;
292+ conductometric?: number;
293+ disdiapason?: string;
294+ ensilation?: number;
295+ eyebolt?: number;
296+ fistulated?: number;
297+ heteropod?: number;
298+ homocerc?: boolean;
299+ labyrinthically?: number;
300+ martyrization?: number;
301+ mispolicy?: number;
302+ multipara?: number;
303+ nonbookish?: null;
304+ possessorial?: number;
305+ shamed?: number;
306+ shelfworn?: number;
307+ stagnum?: number;
308+ undecimal?: number;
309+}
310+
311+export type AnkeeElement = number[] | AnkeeClass | number;
312+
313+export type AnkeeClass = {
314+ Anomoean: null;
315+ Naja: null;
316+ barleyhood: null;
317+ befriender: null;
318+ brutishness: null;
319+ cephalalgy: null;
320+ cirurgian: null;
321+ conventionally: null;
322+ jackshay: null;
323+ milammeter: null;
324+ ombrological: null;
325+ phonasthenia: null;
326+ retrievableness: null;
327+ snakily: null;
328+ swot: null;
329+ tartlet: null;
330+ thiofuran: null;
331+ tracheophone: null;
332+ tuglike: null;
333+ unscratchingly: null;
334+}
335+
336+export type Aphasia = number[] | number;
337+
338+export type Asprawl = number | string;
339+
340+export type Bedesman = boolean | number | string;
341+
342+export type Belard = number[] | Rebecca | number;
343+
344+export type Bocking = number[] | boolean | { [key: string]: number };
345+
346+export type Brawlingly = null[] | { [key: string]: number | null };
347+
348+export type Brookie = number[] | Rebecca;
349+
350+export type Bumboatman = null[] | null | string;
351+
352+export type Calaverite = number[] | string;
353+
354+export type Catallactic = null[] | boolean | { [key: string]: number };
355+
356+export type Cemental = number[] | number | { [key: string]: number };
357+
358+// Converts JSON strings to/from your types
359+// and asserts the results of JSON.parse at runtime
360+export class Convert {
361+ public static toTopLevel(json: string): TopLevel {
362+ return cast(JSON.parse(json), r("TopLevel"));
363+ }
364+
365+ public static topLevelToJson(value: TopLevel): string {
366+ return JSON.stringify(uncast(value, r("TopLevel")), null, 2);
367+ }
368+}
369+
370+function invalidValue(typ: any, val: any, key: any, parent: any = ''): never {
371+ const prettyTyp = prettyTypeName(typ);
372+ const parentText = parent ? ` on ${parent}` : '';
373+ const keyText = key ? ` for key "${key}"` : '';
374+ throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`);
375+}
376+
377+function prettyTypeName(typ: any): string {
378+ if (Array.isArray(typ)) {
379+ if (typ.length === 2 && typ[0] === undefined) {
380+ return `an optional ${prettyTypeName(typ[1])}`;
381+ } else {
382+ return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`;
383+ }
384+ } else if (typeof typ === "object" && typ.literal !== undefined) {
385+ return typ.literal;
386+ } else {
387+ return typeof typ;
388+ }
389+}
390+
391+function jsonToJSProps(typ: any): any {
392+ if (typ.jsonToJS === undefined) {
393+ const map: any = {};
394+ typ.props.forEach((p: any) => map[p.json] = { key: p.js, typ: p.typ });
395+ typ.jsonToJS = map;
396+ }
397+ return typ.jsonToJS;
398+}
399+
400+function jsToJSONProps(typ: any): any {
401+ if (typ.jsToJSON === undefined) {
402+ const map: any = {};
403+ typ.props.forEach((p: any) => map[p.js] = { key: p.json, typ: p.typ });
404+ typ.jsToJSON = map;
405+ }
406+ return typ.jsToJSON;
407+}
408+
409+function transform(val: any, typ: any, getProps: any, key: any = '', parent: any = ''): any {
410+ function transformPrimitive(typ: string, val: any): any {
411+ if (typeof typ === typeof val) return val;
412+ return invalidValue(typ, val, key, parent);
413+ }
414+
415+ function transformUnion(typs: any[], val: any): any {
416+ // val must validate against one typ in typs
417+ const l = typs.length;
418+ for (let i = 0; i < l; i++) {
419+ const typ = typs[i];
420+ try {
421+ return transform(val, typ, getProps);
422+ } catch (_) {}
423+ }
424+ return invalidValue(typs, val, key, parent);
425+ }
426+
427+ function transformEnum(cases: string[], val: any): any {
428+ if (cases.indexOf(val) !== -1) return val;
429+ return invalidValue(cases.map(a => { return l(a); }), val, key, parent);
430+ }
431+
432+ function transformArray(typ: any, val: any): any {
433+ // val must be an array with no invalid elements
434+ if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent);
435+
436+ return val.map(el => transform(el, typ, getProps));
437+ }
438+
439+ function transformDate(val: any): any {
440+ if (val === null) {
441+ return null;
442+ }
443+ const d = new Date(val);
444+ if (isNaN(d.valueOf())) {
445+ return invalidValue(l("Date"), val, key, parent);
446+ }
447+ return d;
448+ }
449+
450+ function transformObject(props: { [k: string]: any }, additional: any, val: any): any {
451+ if (val === null || typeof val !== "object" || Array.isArray(val)) {
452+ return invalidValue(l(ref || "object"), val, key, parent);
453+ }
454+ const result: any = {};
455+ Object.getOwnPropertyNames(props).forEach(key => {
456+ const prop = props[key];
457+ const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined;
458+ result[prop.key] = transform(v, prop.typ, getProps, key, ref);
459+ });
460+ Object.getOwnPropertyNames(val).forEach(key => {
461+ if (!Object.prototype.hasOwnProperty.call(props, key)) {
462+ result[key] = transform(val[key], additional, getProps, key, ref);
463+ }
464+ });
465+ return result;
466+ }
467+
468+ if (typ === "any") return val;
469+ if (typ === null) {
470+ if (val === null) return val;
471+ return invalidValue(typ, val, key, parent);
472+ }
473+ if (typ === false) return invalidValue(typ, val, key, parent);
474+ let ref: any = undefined;
475+ while (typeof typ === "object" && typ.ref !== undefined) {
476+ ref = typ.ref;
477+ typ = typeMap[typ.ref];
478+ }
479+ if (Array.isArray(typ)) return transformEnum(typ, val);
480+ if (typeof typ === "object") {
481+ return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent)
482+ : 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)
483+ : 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)
484+ : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent)
485+ : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val)
486+ : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val)
487+ : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val)
488+ : invalidValue(typ, val, key, parent);
489+ }
490+ // Numbers can be parsed by Date but shouldn't be.
491+ if (typ === Date && typeof val !== "number") return transformDate(val);
492+ return transformPrimitive(typ, val);
493+}
494+
495+function cast<T>(val: any, typ: any): T {
496+ return transform(val, typ, jsonToJSProps);
497+}
498+
499+function uncast<T>(val: T, typ: any): any {
500+ return transform(val, typ, jsToJSONProps);
501+}
502+
503+function l(typ: any) {
504+ return { literal: typ };
505+}
506+
507+function a(typ: any) {
508+ return { arrayItems: typ };
509+}
510+
511+function i(typ: any) {
512+ return { integer: typ };
513+}
514+
515+function p(pattern: any) {
516+ return { pattern };
517+}
518+
519+function s(typ: any, min: any, max: any) {
520+ return { string: typ, min, max };
521+}
522+
523+function n(typ: any, min: any, max: any) {
524+ return { number: typ, min, max };
525+}
526+
527+function u(...typs: any[]) {
528+ return { unionMembers: typs };
529+}
530+
531+function o(props: any[], additional: any) {
532+ return { props, additional };
533+}
534+
535+function m(additional: any) {
536+ const props: any[] = [];
537+ return { props, additional };
538+}
539+
540+function r(name: string) {
541+ return { ref: name };
542+}
543+
544+const typeMap: any = {
545+ "TopLevel": o([
546+ { json: "Abranchiata", js: "Abranchiata", typ: a(u(a(i(0)), i(0), null)) },
547+ { json: "Andriana", js: "Andriana", typ: a(u(null, "")) },
548+ { json: "Ansarie", js: "Ansarie", typ: a(u(a(i(0)), r("AnsarieClass"), null)) },
549+ { json: "Chytridiaceae", js: "Chytridiaceae", typ: a(u(true, r("ChytridiaceaeClass"), null)) },
550+ { json: "Discordia", js: "Discordia", typ: a(u(a(i(0)), r("DiscordiaClass"))) },
551+ { json: "Endomyces", js: "Endomyces", typ: a(u(i(0), "")) },
552+ { json: "Epinephelidae", js: "Epinephelidae", typ: a(u(true, i(0), "")) },
553+ { json: "Eupatorium", js: "Eupatorium", typ: a(u(a(null), m(i(0)))) },
554+ { json: "Gryphosaurus", js: "Gryphosaurus", typ: a(u(a(i(0)), r("GryphosaurusClass"), "")) },
555+ { json: "Koryak", js: "Koryak", typ: a(u(m(u(i(0), null)), "")) },
556+ { json: "Lavinia", js: "Lavinia", typ: a(u(r("LaviniaClass"), "")) },
557+ { json: "Oskar", js: "Oskar", typ: a(u(a(i(0)), r("OskarClass"))) },
558+ { json: "Rebecca", js: "Rebecca", typ: a(u(r("Rebecca"), i(0), "")) },
559+ { json: "Rhomboganoidei", js: "Rhomboganoidei", typ: a(u(a(i(0)), r("Rebecca"), "")) },
560+ { json: "Rigsmal", js: "Rigsmal", typ: true },
561+ { json: "Ruellia", js: "Ruellia", typ: a(u(true, r("Rebecca"), "")) },
562+ { json: "School", js: "School", typ: a(u(i(0), m(i(0)), null)) },
563+ { json: "Shakespearolater", js: "Shakespearolater", typ: a(u(a(i(0)), 3.14, "")) },
564+ { json: "Svan", js: "Svan", typ: a(3.14) },
565+ { json: "Wayao", js: "Wayao", typ: m(3.14) },
566+ { json: "academe", js: "academe", typ: a(u(a(i(0)), i(0), m(i(0)))) },
567+ { json: "acquirable", js: "acquirable", typ: a(u(a(u(i(0), null)), m(i(0)))) },
568+ { json: "aerometry", js: "aerometry", typ: a(u(true, 3.14)) },
569+ { json: "alexin", js: "alexin", typ: a(u(a(i(0)), true)) },
570+ { json: "alleviate", js: "alleviate", typ: a(u(a(u(i(0), null)), r("AlleviateClass"))) },
571+ { json: "amaas", js: "amaas", typ: a(u(true, r("Rebecca"), i(0))) },
572+ { json: "ambassage", js: "ambassage", typ: a(u(a(null), "")) },
573+ { json: "amphithyron", js: "amphithyron", typ: a(u(r("Amphithyron"), null)) },
574+ { json: "ankee", js: "ankee", typ: a(u(a(i(0)), r("AnkeeClass"), i(0))) },
575+ { json: "annihilator", js: "annihilator", typ: a(u(m(u(i(0), null)), null)) },
576+ { json: "annulose", js: "annulose", typ: null },
577+ { json: "aphasia", js: "aphasia", typ: a(u(a(i(0)), i(0))) },
578+ { json: "asprawl", js: "asprawl", typ: a(u(3.14, "")) },
579+ { json: "attractive", js: "attractive", typ: a(u(true, null)) },
580+ { json: "barksome", js: "barksome", typ: m(i(0)) },
581+ { json: "bedesman", js: "bedesman", typ: a(u(true, 3.14, "")) },
582+ { json: "belard", js: "belard", typ: a(u(a(i(0)), r("Rebecca"), 3.14)) },
583+ { json: "bocking", js: "bocking", typ: a(u(a(i(0)), true, m(i(0)))) },
584+ { json: "brawlingly", js: "brawlingly", typ: a(u(a(null), m(u(i(0), null)))) },
585+ { json: "brookie", js: "brookie", typ: a(u(a(i(0)), r("Rebecca"))) },
586+ { json: "bumboatman", js: "bumboatman", typ: a(u(a(null), null, "")) },
587+ { json: "bystreet", js: "bystreet", typ: a(null) },
588+ { json: "calaverite", js: "calaverite", typ: a(u(a(i(0)), "")) },
589+ { json: "catallactic", js: "catallactic", typ: a(u(a(null), true, m(i(0)))) },
590+ { json: "cemental", js: "cemental", typ: a(u(a(i(0)), 3.14, m(i(0)))) },
591+ ], false),
592+ "AnsarieClass": o([
593+ { json: "Alida", js: "Alida", typ: null },
594+ { json: "Ictonyx", js: "Ictonyx", typ: null },
595+ { json: "Ramist", js: "Ramist", typ: null },
596+ { json: "accension", js: "accension", typ: null },
597+ { json: "asteria", js: "asteria", typ: null },
598+ { json: "beriberic", js: "beriberic", typ: null },
599+ { json: "edgebone", js: "edgebone", typ: null },
600+ { json: "gastrodialysis", js: "gastrodialysis", typ: null },
601+ { json: "geographic", js: "geographic", typ: null },
602+ { json: "metrocele", js: "metrocele", typ: null },
603+ { json: "misgraft", js: "misgraft", typ: null },
604+ { json: "monteith", js: "monteith", typ: null },
605+ { json: "notcher", js: "notcher", typ: null },
606+ { json: "prorestriction", js: "prorestriction", typ: null },
607+ { json: "throatlet", js: "throatlet", typ: null },
608+ { json: "unfair", js: "unfair", typ: null },
609+ { json: "unsynonymous", js: "unsynonymous", typ: null },
610+ { json: "water", js: "water", typ: null },
611+ { json: "zestfully", js: "zestfully", typ: null },
612+ { json: "zincic", js: "zincic", typ: null },
613+ ], false),
614+ "ChytridiaceaeClass": o([
615+ { json: "Batidaceae", js: "Batidaceae", typ: null },
616+ { json: "Brechites", js: "Brechites", typ: null },
617+ { json: "Emery", js: "Emery", typ: null },
618+ { json: "Narraganset", js: "Narraganset", typ: null },
619+ { json: "codespairer", js: "codespairer", typ: null },
620+ { json: "enervative", js: "enervative", typ: null },
621+ { json: "excriminate", js: "excriminate", typ: null },
622+ { json: "goshenite", js: "goshenite", typ: null },
623+ { json: "grime", js: "grime", typ: null },
624+ { json: "gritten", js: "gritten", typ: null },
625+ { json: "hectorly", js: "hectorly", typ: null },
626+ { json: "intermediation", js: "intermediation", typ: null },
627+ { json: "meeterly", js: "meeterly", typ: null },
628+ { json: "onymatic", js: "onymatic", typ: null },
629+ { json: "paddlecock", js: "paddlecock", typ: null },
630+ { json: "thana", js: "thana", typ: null },
631+ { json: "thornily", js: "thornily", typ: null },
632+ { json: "uckia", js: "uckia", typ: null },
633+ { json: "unmettle", js: "unmettle", typ: null },
634+ { json: "vorticellid", js: "vorticellid", typ: null },
635+ ], false),
636+ "DiscordiaClass": o([
637+ { json: "Altaic", js: "Altaic", typ: u(undefined, i(0)) },
638+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
639+ { json: "Patarin", js: "Patarin", typ: u(undefined, i(0)) },
640+ { json: "amoristic", js: "amoristic", typ: u(undefined, i(0)) },
641+ { json: "blennophthalmia", js: "blennophthalmia", typ: u(undefined, i(0)) },
642+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
643+ { json: "disciplinability", js: "disciplinability", typ: u(undefined, i(0)) },
644+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
645+ { json: "goofer", js: "goofer", typ: u(undefined, i(0)) },
646+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
647+ { json: "laryngograph", js: "laryngograph", typ: u(undefined, i(0)) },
648+ { json: "leucitis", js: "leucitis", typ: u(undefined, i(0)) },
649+ { json: "lymphocyst", js: "lymphocyst", typ: u(undefined, i(0)) },
650+ { json: "microcosmology", js: "microcosmology", typ: u(undefined, i(0)) },
651+ { json: "nauseation", js: "nauseation", typ: u(undefined, i(0)) },
652+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
653+ { json: "preliberal", js: "preliberal", typ: u(undefined, i(0)) },
654+ { json: "prettifier", js: "prettifier", typ: u(undefined, i(0)) },
655+ { json: "rangework", js: "rangework", typ: u(undefined, i(0)) },
656+ { json: "redient", js: "redient", typ: u(undefined, i(0)) },
657+ { json: "subfusiform", js: "subfusiform", typ: u(undefined, i(0)) },
658+ { json: "suicidical", js: "suicidical", typ: u(undefined, i(0)) },
659+ { json: "swow", js: "swow", typ: u(undefined, i(0)) },
660+ { json: "wastrel", js: "wastrel", typ: u(undefined, i(0)) },
661+ { json: "wingle", js: "wingle", typ: u(undefined, i(0)) },
662+ ], false),
663+ "GryphosaurusClass": o([
664+ { json: "Burushaski", js: "Burushaski", typ: null },
665+ { json: "Tahami", js: "Tahami", typ: null },
666+ { json: "amissibility", js: "amissibility", typ: null },
667+ { json: "citronin", js: "citronin", typ: null },
668+ { json: "coplaintiff", js: "coplaintiff", typ: null },
669+ { json: "disquisitionary", js: "disquisitionary", typ: null },
670+ { json: "enoplan", js: "enoplan", typ: null },
671+ { json: "faintness", js: "faintness", typ: null },
672+ { json: "hebetomy", js: "hebetomy", typ: null },
673+ { json: "islandry", js: "islandry", typ: null },
674+ { json: "lameduck", js: "lameduck", typ: null },
675+ { json: "overbattle", js: "overbattle", typ: null },
676+ { json: "overinterested", js: "overinterested", typ: null },
677+ { json: "phrenologic", js: "phrenologic", typ: null },
678+ { json: "rainband", js: "rainband", typ: null },
679+ { json: "shiningly", js: "shiningly", typ: null },
680+ { json: "stamineous", js: "stamineous", typ: null },
681+ { json: "subscapularis", js: "subscapularis", typ: null },
682+ { json: "undaubed", js: "undaubed", typ: null },
683+ { json: "underntime", js: "underntime", typ: null },
684+ ], false),
685+ "LaviniaClass": o([
686+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
687+ { json: "Tacana", js: "Tacana", typ: u(undefined, i(0)) },
688+ { json: "agitable", js: "agitable", typ: u(undefined, i(0)) },
689+ { json: "asininity", js: "asininity", typ: u(undefined, i(0)) },
690+ { json: "benefiter", js: "benefiter", typ: u(undefined, i(0)) },
691+ { json: "bronzelike", js: "bronzelike", typ: u(undefined, i(0)) },
692+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
693+ { json: "cholesteatomatous", js: "cholesteatomatous", typ: u(undefined, i(0)) },
694+ { json: "deprivement", js: "deprivement", typ: u(undefined, i(0)) },
695+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
696+ { json: "flippantness", js: "flippantness", typ: u(undefined, i(0)) },
697+ { json: "fogproof", js: "fogproof", typ: u(undefined, i(0)) },
698+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
699+ { json: "merrymeeting", js: "merrymeeting", typ: u(undefined, i(0)) },
700+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
701+ { json: "overcareful", js: "overcareful", typ: u(undefined, i(0)) },
702+ { json: "panaris", js: "panaris", typ: u(undefined, i(0)) },
703+ { json: "preacceptance", js: "preacceptance", typ: u(undefined, i(0)) },
704+ { json: "quinoxaline", js: "quinoxaline", typ: u(undefined, i(0)) },
705+ { json: "sig", js: "sig", typ: u(undefined, i(0)) },
706+ { json: "superconfusion", js: "superconfusion", typ: u(undefined, i(0)) },
707+ { json: "tillotter", js: "tillotter", typ: u(undefined, i(0)) },
708+ { json: "tranquillize", js: "tranquillize", typ: u(undefined, i(0)) },
709+ { json: "unquestionable", js: "unquestionable", typ: u(undefined, i(0)) },
710+ { json: "uproute", js: "uproute", typ: u(undefined, i(0)) },
711+ ], false),
712+ "OskarClass": o([
713+ { json: "Acrobates", js: "Acrobates", typ: null },
714+ { json: "Cayuga", js: "Cayuga", typ: null },
715+ { json: "Netherlandish", js: "Netherlandish", typ: null },
716+ { json: "beanshooter", js: "beanshooter", typ: null },
717+ { json: "bearhound", js: "bearhound", typ: null },
718+ { json: "guarneri", js: "guarneri", typ: null },
719+ { json: "hypochondriacism", js: "hypochondriacism", typ: null },
720+ { json: "indication", js: "indication", typ: null },
721+ { json: "jaculative", js: "jaculative", typ: null },
722+ { json: "nagana", js: "nagana", typ: null },
723+ { json: "noctivagous", js: "noctivagous", typ: null },
724+ { json: "nonphysiological", js: "nonphysiological", typ: null },
725+ { json: "praxis", js: "praxis", typ: null },
726+ { json: "provision", js: "provision", typ: null },
727+ { json: "subterhuman", js: "subterhuman", typ: null },
728+ { json: "sunlit", js: "sunlit", typ: null },
729+ { json: "syncraniate", js: "syncraniate", typ: null },
730+ { json: "teachment", js: "teachment", typ: null },
731+ { json: "unmutinous", js: "unmutinous", typ: null },
732+ { json: "unstoppable", js: "unstoppable", typ: null },
733+ ], false),
734+ "Rebecca": o([
735+ { json: "Chirotherium", js: "Chirotherium", typ: i(0) },
736+ { json: "catharticalness", js: "catharticalness", typ: 3.14 },
737+ { json: "disdiapason", js: "disdiapason", typ: "" },
738+ { json: "homocerc", js: "homocerc", typ: true },
739+ { json: "nonbookish", js: "nonbookish", typ: null },
740+ ], false),
741+ "AlleviateClass": o([
742+ { json: "Hulsean", js: "Hulsean", typ: null },
743+ { json: "apriori", js: "apriori", typ: null },
744+ { json: "beggarer", js: "beggarer", typ: null },
745+ { json: "brokenheartedly", js: "brokenheartedly", typ: null },
746+ { json: "debilitation", js: "debilitation", typ: null },
747+ { json: "frike", js: "frike", typ: null },
748+ { json: "gastrolith", js: "gastrolith", typ: null },
749+ { json: "orthocentric", js: "orthocentric", typ: null },
750+ { json: "petaly", js: "petaly", typ: null },
751+ { json: "probudgeting", js: "probudgeting", typ: null },
752+ { json: "reacquire", js: "reacquire", typ: null },
753+ { json: "scow", js: "scow", typ: null },
754+ { json: "shutoff", js: "shutoff", typ: null },
755+ { json: "subcontiguous", js: "subcontiguous", typ: null },
756+ { json: "suffumigate", js: "suffumigate", typ: null },
757+ { json: "transformable", js: "transformable", typ: null },
758+ { json: "uncoroneted", js: "uncoroneted", typ: null },
759+ { json: "unparking", js: "unparking", typ: null },
760+ { json: "unvarnishedness", js: "unvarnishedness", typ: null },
761+ { json: "wherewithal", js: "wherewithal", typ: null },
762+ ], false),
763+ "Amphithyron": o([
764+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
765+ { json: "Juniperus", js: "Juniperus", typ: u(undefined, i(0)) },
766+ { json: "Nazirite", js: "Nazirite", typ: u(undefined, i(0)) },
767+ { json: "Those", js: "Those", typ: u(undefined, i(0)) },
768+ { json: "akroasis", js: "akroasis", typ: u(undefined, i(0)) },
769+ { json: "antiphonical", js: "antiphonical", typ: u(undefined, i(0)) },
770+ { json: "basebred", js: "basebred", typ: u(undefined, i(0)) },
771+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
772+ { json: "conductometric", js: "conductometric", typ: u(undefined, i(0)) },
773+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
774+ { json: "ensilation", js: "ensilation", typ: u(undefined, i(0)) },
775+ { json: "eyebolt", js: "eyebolt", typ: u(undefined, i(0)) },
776+ { json: "fistulated", js: "fistulated", typ: u(undefined, i(0)) },
777+ { json: "heteropod", js: "heteropod", typ: u(undefined, i(0)) },
778+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
779+ { json: "labyrinthically", js: "labyrinthically", typ: u(undefined, i(0)) },
780+ { json: "martyrization", js: "martyrization", typ: u(undefined, i(0)) },
781+ { json: "mispolicy", js: "mispolicy", typ: u(undefined, i(0)) },
782+ { json: "multipara", js: "multipara", typ: u(undefined, i(0)) },
783+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
784+ { json: "possessorial", js: "possessorial", typ: u(undefined, i(0)) },
785+ { json: "shamed", js: "shamed", typ: u(undefined, i(0)) },
786+ { json: "shelfworn", js: "shelfworn", typ: u(undefined, i(0)) },
787+ { json: "stagnum", js: "stagnum", typ: u(undefined, i(0)) },
788+ { json: "undecimal", js: "undecimal", typ: u(undefined, i(0)) },
789+ ], false),
790+ "AnkeeClass": o([
791+ { json: "Anomoean", js: "Anomoean", typ: null },
792+ { json: "Naja", js: "Naja", typ: null },
793+ { json: "barleyhood", js: "barleyhood", typ: null },
794+ { json: "befriender", js: "befriender", typ: null },
795+ { json: "brutishness", js: "brutishness", typ: null },
796+ { json: "cephalalgy", js: "cephalalgy", typ: null },
797+ { json: "cirurgian", js: "cirurgian", typ: null },
798+ { json: "conventionally", js: "conventionally", typ: null },
799+ { json: "jackshay", js: "jackshay", typ: null },
800+ { json: "milammeter", js: "milammeter", typ: null },
801+ { json: "ombrological", js: "ombrological", typ: null },
802+ { json: "phonasthenia", js: "phonasthenia", typ: null },
803+ { json: "retrievableness", js: "retrievableness", typ: null },
804+ { json: "snakily", js: "snakily", typ: null },
805+ { json: "swot", js: "swot", typ: null },
806+ { json: "tartlet", js: "tartlet", typ: null },
807+ { json: "thiofuran", js: "thiofuran", typ: null },
808+ { json: "tracheophone", js: "tracheophone", typ: null },
809+ { json: "tuglike", js: "tuglike", typ: null },
810+ { json: "unscratchingly", js: "unscratchingly", typ: null },
811+ ], false),
812+};
Test case

test/inputs/json/priority/combinations3.json

5 generated files · +10,330 −0
Adartfrom-map-true--d222f65b3fee / TopLevel.dart+1,537 −0
@@ -0,0 +1,1537 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromMap(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toMap());
10+
11+class TopLevel {
12+ final List<dynamic> juror;
13+ final List<dynamic> kongoni;
14+ final List<dynamic> ladronism;
15+ final List<dynamic> landlubberly;
16+ final List<dynamic> listener;
17+ final List<dynamic> lupus;
18+ final List<Maslin> maslin;
19+ final List<dynamic> monazite;
20+ final List<dynamic> monoliteral;
21+ final List<dynamic> monotheistically;
22+ final List<dynamic> montage;
23+ final List<dynamic> moralness;
24+ final List<MonaziteClass?> mowra;
25+ final List<dynamic> mulishly;
26+ final List<dynamic> myoscope;
27+ final List<List<int?>?> nach;
28+ final List<dynamic> neuromastic;
29+ final List<Noncontributing> noncontributing;
30+ final List<dynamic> nonnervous;
31+ final List<dynamic> nonvaluation;
32+ final List<dynamic> occupationalist;
33+ final List<dynamic> outrival;
34+ final List<dynamic> paleographically;
35+ final List<dynamic> pamphletwise;
36+ final List<dynamic> pediatrics;
37+ final List<bool> perceptive;
38+ final List<dynamic> piaculum;
39+ final List<dynamic> piccadilly;
40+ final List<dynamic> piffler;
41+ final List<dynamic> pithful;
42+ final List<dynamic> placuntitis;
43+ final List<dynamic> plectopterous;
44+ final List<Pneumocele?> pneumocele;
45+ final List<dynamic> poliorcetic;
46+ final List<dynamic> poormaster;
47+ final List<dynamic> potwhisky;
48+ final List<dynamic> practicalizer;
49+ final List<dynamic> prefreshman;
50+ final List<dynamic> prehensility;
51+ final List<dynamic> prevoidance;
52+ final List<Map<String, int?>> probant;
53+ final List<dynamic> protext;
54+
55+ TopLevel({
56+ required this.juror,
57+ required this.kongoni,
58+ required this.ladronism,
59+ required this.landlubberly,
60+ required this.listener,
61+ required this.lupus,
62+ required this.maslin,
63+ required this.monazite,
64+ required this.monoliteral,
65+ required this.monotheistically,
66+ required this.montage,
67+ required this.moralness,
68+ required this.mowra,
69+ required this.mulishly,
70+ required this.myoscope,
71+ required this.nach,
72+ required this.neuromastic,
73+ required this.noncontributing,
74+ required this.nonnervous,
75+ required this.nonvaluation,
76+ required this.occupationalist,
77+ required this.outrival,
78+ required this.paleographically,
79+ required this.pamphletwise,
80+ required this.pediatrics,
81+ required this.perceptive,
82+ required this.piaculum,
83+ required this.piccadilly,
84+ required this.piffler,
85+ required this.pithful,
86+ required this.placuntitis,
87+ required this.plectopterous,
88+ required this.pneumocele,
89+ required this.poliorcetic,
90+ required this.poormaster,
91+ required this.potwhisky,
92+ required this.practicalizer,
93+ required this.prefreshman,
94+ required this.prehensility,
95+ required this.prevoidance,
96+ required this.probant,
97+ required this.protext,
98+ });
99+
100+ factory TopLevel.fromMap(Map<String, dynamic> json) => TopLevel(
101+ juror: List<dynamic>.from(json["juror"].map((x) => x)),
102+ kongoni: List<dynamic>.from(json["kongoni"].map((x) => x)),
103+ ladronism: List<dynamic>.from(json["ladronism"].map((x) => x)),
104+ landlubberly: List<dynamic>.from(json["landlubberly"].map((x) => x)),
105+ listener: List<dynamic>.from(json["listener"].map((x) => x)),
106+ lupus: List<dynamic>.from(json["lupus"].map((x) => x)),
107+ maslin: List<Maslin>.from(json["maslin"].map((x) => Maslin.fromMap(x))),
108+ monazite: List<dynamic>.from(json["monazite"].map((x) => x)),
109+ monoliteral: List<dynamic>.from(json["monoliteral"].map((x) => x)),
110+ monotheistically: List<dynamic>.from(json["monotheistically"].map((x) => x)),
111+ montage: List<dynamic>.from(json["montage"].map((x) => x)),
112+ moralness: List<dynamic>.from(json["moralness"].map((x) => x)),
113+ mowra: List<MonaziteClass?>.from(json["mowra"].map((x) => x == null ? null : MonaziteClass.fromMap(x))),
114+ mulishly: List<dynamic>.from(json["mulishly"].map((x) => x)),
115+ myoscope: List<dynamic>.from(json["myoscope"].map((x) => x)),
116+ nach: List<List<int?>?>.from(json["nach"].map((x) => x == null ? null : List<int?>.from(x!.map((x) => x)))),
117+ neuromastic: List<dynamic>.from(json["neuromastic"].map((x) => x)),
118+ noncontributing: List<Noncontributing>.from(json["noncontributing"].map((x) => Noncontributing.fromMap(x))),
119+ nonnervous: List<dynamic>.from(json["nonnervous"].map((x) => x)),
120+ nonvaluation: List<dynamic>.from(json["nonvaluation"].map((x) => x)),
121+ occupationalist: List<dynamic>.from(json["occupationalist"].map((x) => x)),
122+ outrival: List<dynamic>.from(json["outrival"].map((x) => x)),
123+ paleographically: List<dynamic>.from(json["paleographically"].map((x) => x)),
124+ pamphletwise: List<dynamic>.from(json["pamphletwise"].map((x) => x)),
125+ pediatrics: List<dynamic>.from(json["pediatrics"].map((x) => x)),
126+ perceptive: List<bool>.from(json["perceptive"].map((x) => x)),
127+ piaculum: List<dynamic>.from(json["piaculum"].map((x) => x)),
128+ piccadilly: List<dynamic>.from(json["piccadilly"].map((x) => x)),
129+ piffler: List<dynamic>.from(json["piffler"].map((x) => x)),
130+ pithful: List<dynamic>.from(json["pithful"].map((x) => x)),
131+ placuntitis: List<dynamic>.from(json["placuntitis"].map((x) => x)),
132+ plectopterous: List<dynamic>.from(json["plectopterous"].map((x) => x)),
133+ pneumocele: List<Pneumocele?>.from(json["pneumocele"].map((x) => x == null ? null : Pneumocele.fromMap(x))),
134+ poliorcetic: List<dynamic>.from(json["poliorcetic"].map((x) => x)),
135+ poormaster: List<dynamic>.from(json["poormaster"].map((x) => x)),
136+ potwhisky: List<dynamic>.from(json["potwhisky"].map((x) => x)),
137+ practicalizer: List<dynamic>.from(json["practicalizer"].map((x) => x)),
138+ prefreshman: List<dynamic>.from(json["prefreshman"].map((x) => x)),
139+ prehensility: List<dynamic>.from(json["prehensility"].map((x) => x)),
140+ prevoidance: List<dynamic>.from(json["prevoidance"].map((x) => x)),
141+ probant: List<Map<String, int?>>.from(json["probant"].map((x) => Map.from(x).map((k, v) => MapEntry<String, int?>(k, v)))),
142+ protext: List<dynamic>.from(json["protext"].map((x) => x)),
143+ );
144+
145+ Map<String, dynamic> toMap() => {
146+ "juror": List<dynamic>.from(juror.map((x) => x)),
147+ "kongoni": List<dynamic>.from(kongoni.map((x) => x)),
148+ "ladronism": List<dynamic>.from(ladronism.map((x) => x)),
149+ "landlubberly": List<dynamic>.from(landlubberly.map((x) => x)),
150+ "listener": List<dynamic>.from(listener.map((x) => x)),
151+ "lupus": List<dynamic>.from(lupus.map((x) => x)),
152+ "maslin": List<dynamic>.from(maslin.map((x) => x.toMap())),
153+ "monazite": List<dynamic>.from(monazite.map((x) => x)),
154+ "monoliteral": List<dynamic>.from(monoliteral.map((x) => x)),
155+ "monotheistically": List<dynamic>.from(monotheistically.map((x) => x)),
156+ "montage": List<dynamic>.from(montage.map((x) => x)),
157+ "moralness": List<dynamic>.from(moralness.map((x) => x)),
158+ "mowra": List<dynamic>.from(mowra.map((x) => x?.toMap())),
159+ "mulishly": List<dynamic>.from(mulishly.map((x) => x)),
160+ "myoscope": List<dynamic>.from(myoscope.map((x) => x)),
161+ "nach": List<dynamic>.from(nach.map((x) => x == null ? null : List<dynamic>.from(x!.map((x) => x)))),
162+ "neuromastic": List<dynamic>.from(neuromastic.map((x) => x)),
163+ "noncontributing": List<dynamic>.from(noncontributing.map((x) => x.toMap())),
164+ "nonnervous": List<dynamic>.from(nonnervous.map((x) => x)),
165+ "nonvaluation": List<dynamic>.from(nonvaluation.map((x) => x)),
166+ "occupationalist": List<dynamic>.from(occupationalist.map((x) => x)),
167+ "outrival": List<dynamic>.from(outrival.map((x) => x)),
168+ "paleographically": List<dynamic>.from(paleographically.map((x) => x)),
169+ "pamphletwise": List<dynamic>.from(pamphletwise.map((x) => x)),
170+ "pediatrics": List<dynamic>.from(pediatrics.map((x) => x)),
171+ "perceptive": List<dynamic>.from(perceptive.map((x) => x)),
172+ "piaculum": List<dynamic>.from(piaculum.map((x) => x)),
173+ "piccadilly": List<dynamic>.from(piccadilly.map((x) => x)),
174+ "piffler": List<dynamic>.from(piffler.map((x) => x)),
175+ "pithful": List<dynamic>.from(pithful.map((x) => x)),
176+ "placuntitis": List<dynamic>.from(placuntitis.map((x) => x)),
177+ "plectopterous": List<dynamic>.from(plectopterous.map((x) => x)),
178+ "pneumocele": List<dynamic>.from(pneumocele.map((x) => x?.toMap())),
179+ "poliorcetic": List<dynamic>.from(poliorcetic.map((x) => x)),
180+ "poormaster": List<dynamic>.from(poormaster.map((x) => x)),
181+ "potwhisky": List<dynamic>.from(potwhisky.map((x) => x)),
182+ "practicalizer": List<dynamic>.from(practicalizer.map((x) => x)),
183+ "prefreshman": List<dynamic>.from(prefreshman.map((x) => x)),
184+ "prehensility": List<dynamic>.from(prehensility.map((x) => x)),
185+ "prevoidance": List<dynamic>.from(prevoidance.map((x) => x)),
186+ "probant": List<dynamic>.from(probant.map((x) => Map.from(x).map((k, v) => MapEntry<String, dynamic>(k, v)))),
187+ "protext": List<dynamic>.from(protext.map((x) => x)),
188+ };
189+}
190+
191+class JurorClass {
192+ final dynamic adipsy;
193+ final dynamic auxiliator;
194+ final dynamic benda;
195+ final dynamic benjamin;
196+ final dynamic brandling;
197+ final dynamic epicurishly;
198+ final dynamic eremochaetous;
199+ final dynamic marten;
200+ final dynamic monocline;
201+ final dynamic olea;
202+ final dynamic palgat;
203+ final dynamic pennyworth;
204+ final dynamic pioury;
205+ final dynamic pragmatistic;
206+ final dynamic stylelessness;
207+ final dynamic systematical;
208+ final dynamic thready;
209+ final dynamic uncontemporary;
210+ final dynamic uncouched;
211+ final dynamic uninhabitedness;
212+
213+ JurorClass({
214+ required this.adipsy,
215+ required this.auxiliator,
216+ required this.benda,
217+ required this.benjamin,
218+ required this.brandling,
219+ required this.epicurishly,
220+ required this.eremochaetous,
221+ required this.marten,
222+ required this.monocline,
223+ required this.olea,
224+ required this.palgat,
225+ required this.pennyworth,
226+ required this.pioury,
227+ required this.pragmatistic,
228+ required this.stylelessness,
229+ required this.systematical,
230+ required this.thready,
231+ required this.uncontemporary,
232+ required this.uncouched,
233+ required this.uninhabitedness,
234+ });
235+
236+ factory JurorClass.fromMap(Map<String, dynamic> json) => JurorClass(
237+ adipsy: (json.containsKey("adipsy") ? json["adipsy"] : throw FormatException('Missing required property')),
238+ auxiliator: (json.containsKey("auxiliator") ? json["auxiliator"] : throw FormatException('Missing required property')),
239+ benda: (json.containsKey("benda") ? json["benda"] : throw FormatException('Missing required property')),
240+ benjamin: (json.containsKey("benjamin") ? json["benjamin"] : throw FormatException('Missing required property')),
241+ brandling: (json.containsKey("brandling") ? json["brandling"] : throw FormatException('Missing required property')),
242+ epicurishly: (json.containsKey("epicurishly") ? json["epicurishly"] : throw FormatException('Missing required property')),
243+ eremochaetous: (json.containsKey("eremochaetous") ? json["eremochaetous"] : throw FormatException('Missing required property')),
244+ marten: (json.containsKey("marten") ? json["marten"] : throw FormatException('Missing required property')),
245+ monocline: (json.containsKey("monocline") ? json["monocline"] : throw FormatException('Missing required property')),
246+ olea: (json.containsKey("Olea") ? json["Olea"] : throw FormatException('Missing required property')),
247+ palgat: (json.containsKey("palgat") ? json["palgat"] : throw FormatException('Missing required property')),
248+ pennyworth: (json.containsKey("pennyworth") ? json["pennyworth"] : throw FormatException('Missing required property')),
249+ pioury: (json.containsKey("pioury") ? json["pioury"] : throw FormatException('Missing required property')),
250+ pragmatistic: (json.containsKey("pragmatistic") ? json["pragmatistic"] : throw FormatException('Missing required property')),
251+ stylelessness: (json.containsKey("stylelessness") ? json["stylelessness"] : throw FormatException('Missing required property')),
252+ systematical: (json.containsKey("systematical") ? json["systematical"] : throw FormatException('Missing required property')),
253+ thready: (json.containsKey("thready") ? json["thready"] : throw FormatException('Missing required property')),
254+ uncontemporary: (json.containsKey("uncontemporary") ? json["uncontemporary"] : throw FormatException('Missing required property')),
255+ uncouched: (json.containsKey("uncouched") ? json["uncouched"] : throw FormatException('Missing required property')),
256+ uninhabitedness: (json.containsKey("uninhabitedness") ? json["uninhabitedness"] : throw FormatException('Missing required property')),
257+ );
258+
259+ Map<String, dynamic> toMap() => {
260+ "adipsy": adipsy,
261+ "auxiliator": auxiliator,
262+ "benda": benda,
263+ "benjamin": benjamin,
264+ "brandling": brandling,
265+ "epicurishly": epicurishly,
266+ "eremochaetous": eremochaetous,
267+ "marten": marten,
268+ "monocline": monocline,
269+ "Olea": olea,
270+ "palgat": palgat,
271+ "pennyworth": pennyworth,
272+ "pioury": pioury,
273+ "pragmatistic": pragmatistic,
274+ "stylelessness": stylelessness,
275+ "systematical": systematical,
276+ "thready": thready,
277+ "uncontemporary": uncontemporary,
278+ "uncouched": uncouched,
279+ "uninhabitedness": uninhabitedness,
280+ };
281+}
282+
283+class LadronismClass {
284+ final dynamic acclaimer;
285+ final dynamic achree;
286+ final dynamic base;
287+ final dynamic conundrumize;
288+ final dynamic degerminator;
289+ final dynamic describable;
290+ final dynamic exasperatedly;
291+ final dynamic heroine;
292+ final dynamic indazin;
293+ final dynamic luteous;
294+ final dynamic papular;
295+ final dynamic pritch;
296+ final dynamic prodenia;
297+ final dynamic seege;
298+ final dynamic shopgirl;
299+ final dynamic tragedietta;
300+ final dynamic unsparse;
301+ final dynamic uplook;
302+ final dynamic vermiformis;
303+ final dynamic whafabout;
304+
305+ LadronismClass({
306+ required this.acclaimer,
307+ required this.achree,
308+ required this.base,
309+ required this.conundrumize,
310+ required this.degerminator,
311+ required this.describable,
312+ required this.exasperatedly,
313+ required this.heroine,
314+ required this.indazin,
315+ required this.luteous,
316+ required this.papular,
317+ required this.pritch,
318+ required this.prodenia,
319+ required this.seege,
320+ required this.shopgirl,
321+ required this.tragedietta,
322+ required this.unsparse,
323+ required this.uplook,
324+ required this.vermiformis,
325+ required this.whafabout,
326+ });
327+
328+ factory LadronismClass.fromMap(Map<String, dynamic> json) => LadronismClass(
329+ acclaimer: (json.containsKey("acclaimer") ? json["acclaimer"] : throw FormatException('Missing required property')),
330+ achree: (json.containsKey("achree") ? json["achree"] : throw FormatException('Missing required property')),
331+ base: (json.containsKey("base") ? json["base"] : throw FormatException('Missing required property')),
332+ conundrumize: (json.containsKey("conundrumize") ? json["conundrumize"] : throw FormatException('Missing required property')),
333+ degerminator: (json.containsKey("degerminator") ? json["degerminator"] : throw FormatException('Missing required property')),
334+ describable: (json.containsKey("describable") ? json["describable"] : throw FormatException('Missing required property')),
335+ exasperatedly: (json.containsKey("exasperatedly") ? json["exasperatedly"] : throw FormatException('Missing required property')),
336+ heroine: (json.containsKey("heroine") ? json["heroine"] : throw FormatException('Missing required property')),
337+ indazin: (json.containsKey("indazin") ? json["indazin"] : throw FormatException('Missing required property')),
338+ luteous: (json.containsKey("luteous") ? json["luteous"] : throw FormatException('Missing required property')),
339+ papular: (json.containsKey("papular") ? json["papular"] : throw FormatException('Missing required property')),
340+ pritch: (json.containsKey("pritch") ? json["pritch"] : throw FormatException('Missing required property')),
341+ prodenia: (json.containsKey("Prodenia") ? json["Prodenia"] : throw FormatException('Missing required property')),
342+ seege: (json.containsKey("seege") ? json["seege"] : throw FormatException('Missing required property')),
343+ shopgirl: (json.containsKey("shopgirl") ? json["shopgirl"] : throw FormatException('Missing required property')),
344+ tragedietta: (json.containsKey("tragedietta") ? json["tragedietta"] : throw FormatException('Missing required property')),
345+ unsparse: (json.containsKey("unsparse") ? json["unsparse"] : throw FormatException('Missing required property')),
346+ uplook: (json.containsKey("uplook") ? json["uplook"] : throw FormatException('Missing required property')),
347+ vermiformis: (json.containsKey("vermiformis") ? json["vermiformis"] : throw FormatException('Missing required property')),
348+ whafabout: (json.containsKey("whafabout") ? json["whafabout"] : throw FormatException('Missing required property')),
349+ );
350+
351+ Map<String, dynamic> toMap() => {
352+ "acclaimer": acclaimer,
353+ "achree": achree,
354+ "base": base,
355+ "conundrumize": conundrumize,
356+ "degerminator": degerminator,
357+ "describable": describable,
358+ "exasperatedly": exasperatedly,
359+ "heroine": heroine,
360+ "indazin": indazin,
361+ "luteous": luteous,
362+ "papular": papular,
363+ "pritch": pritch,
364+ "Prodenia": prodenia,
365+ "seege": seege,
366+ "shopgirl": shopgirl,
367+ "tragedietta": tragedietta,
368+ "unsparse": unsparse,
369+ "uplook": uplook,
370+ "vermiformis": vermiformis,
371+ "whafabout": whafabout,
372+ };
373+}
374+
375+class LandlubberlyClass {
376+ final dynamic acropoleis;
377+ final dynamic aminate;
378+ final dynamic amyraldism;
379+ final dynamic bipenniform;
380+ final dynamic bugre;
381+ final dynamic calycule;
382+ final dynamic caoutchouc;
383+ final dynamic disprover;
384+ final dynamic fitroot;
385+ final dynamic fulgently;
386+ final dynamic kickup;
387+ final dynamic laevoversion;
388+ final dynamic moter;
389+ final dynamic objectivity;
390+ final dynamic posterity;
391+ final dynamic postnuptial;
392+ final dynamic precedentary;
393+ final dynamic saddling;
394+ final dynamic subcurrent;
395+ final dynamic unrecriminative;
396+
397+ LandlubberlyClass({
398+ required this.acropoleis,
399+ required this.aminate,
400+ required this.amyraldism,
401+ required this.bipenniform,
402+ required this.bugre,
403+ required this.calycule,
404+ required this.caoutchouc,
405+ required this.disprover,
406+ required this.fitroot,
407+ required this.fulgently,
408+ required this.kickup,
409+ required this.laevoversion,
410+ required this.moter,
411+ required this.objectivity,
412+ required this.posterity,
413+ required this.postnuptial,
414+ required this.precedentary,
415+ required this.saddling,
416+ required this.subcurrent,
417+ required this.unrecriminative,
418+ });
419+
420+ factory LandlubberlyClass.fromMap(Map<String, dynamic> json) => LandlubberlyClass(
421+ acropoleis: (json.containsKey("acropoleis") ? json["acropoleis"] : throw FormatException('Missing required property')),
422+ aminate: (json.containsKey("aminate") ? json["aminate"] : throw FormatException('Missing required property')),
423+ amyraldism: (json.containsKey("Amyraldism") ? json["Amyraldism"] : throw FormatException('Missing required property')),
424+ bipenniform: (json.containsKey("bipenniform") ? json["bipenniform"] : throw FormatException('Missing required property')),
425+ bugre: (json.containsKey("bugre") ? json["bugre"] : throw FormatException('Missing required property')),
426+ calycule: (json.containsKey("calycule") ? json["calycule"] : throw FormatException('Missing required property')),
427+ caoutchouc: (json.containsKey("caoutchouc") ? json["caoutchouc"] : throw FormatException('Missing required property')),
428+ disprover: (json.containsKey("disprover") ? json["disprover"] : throw FormatException('Missing required property')),
429+ fitroot: (json.containsKey("fitroot") ? json["fitroot"] : throw FormatException('Missing required property')),
430+ fulgently: (json.containsKey("fulgently") ? json["fulgently"] : throw FormatException('Missing required property')),
431+ kickup: (json.containsKey("kickup") ? json["kickup"] : throw FormatException('Missing required property')),
432+ laevoversion: (json.containsKey("laevoversion") ? json["laevoversion"] : throw FormatException('Missing required property')),
433+ moter: (json.containsKey("moter") ? json["moter"] : throw FormatException('Missing required property')),
434+ objectivity: (json.containsKey("objectivity") ? json["objectivity"] : throw FormatException('Missing required property')),
435+ posterity: (json.containsKey("posterity") ? json["posterity"] : throw FormatException('Missing required property')),
436+ postnuptial: (json.containsKey("postnuptial") ? json["postnuptial"] : throw FormatException('Missing required property')),
437+ precedentary: (json.containsKey("precedentary") ? json["precedentary"] : throw FormatException('Missing required property')),
438+ saddling: (json.containsKey("saddling") ? json["saddling"] : throw FormatException('Missing required property')),
439+ subcurrent: (json.containsKey("subcurrent") ? json["subcurrent"] : throw FormatException('Missing required property')),
440+ unrecriminative: (json.containsKey("unrecriminative") ? json["unrecriminative"] : throw FormatException('Missing required property')),
441+ );
442+
443+ Map<String, dynamic> toMap() => {
444+ "acropoleis": acropoleis,
445+ "aminate": aminate,
446+ "Amyraldism": amyraldism,
447+ "bipenniform": bipenniform,
448+ "bugre": bugre,
449+ "calycule": calycule,
450+ "caoutchouc": caoutchouc,
451+ "disprover": disprover,
452+ "fitroot": fitroot,
453+ "fulgently": fulgently,
454+ "kickup": kickup,
455+ "laevoversion": laevoversion,
456+ "moter": moter,
457+ "objectivity": objectivity,
458+ "posterity": posterity,
459+ "postnuptial": postnuptial,
460+ "precedentary": precedentary,
461+ "saddling": saddling,
462+ "subcurrent": subcurrent,
463+ "unrecriminative": unrecriminative,
464+ };
465+}
466+
467+class LupusClass {
468+ final double? catharticalness;
469+ final int? chirotherium;
470+ final int? chlorioninae;
471+ final int? corvinae;
472+ final int? crassina;
473+ final String? disdiapason;
474+ final int? exiguity;
475+ final int? farcist;
476+ final int? holographical;
477+ final bool? homocerc;
478+ final int? ichthyophagan;
479+ final int? implacable;
480+ final dynamic nonbookish;
481+ final int? outshiner;
482+ final int? overweather;
483+ final int? protonegroid;
484+ final int? shallowish;
485+ final int? snoke;
486+ final int? snout;
487+ final int? surveillance;
488+ final int? threshingtime;
489+ final int? thysanocarpus;
490+ final int? unsignificantly;
491+ final int? unsnap;
492+ final int? vendible;
493+
494+ LupusClass({
495+ this.catharticalness,
496+ this.chirotherium,
497+ this.chlorioninae,
498+ this.corvinae,
499+ this.crassina,
500+ this.disdiapason,
501+ this.exiguity,
502+ this.farcist,
503+ this.holographical,
504+ this.homocerc,
505+ this.ichthyophagan,
506+ this.implacable,
507+ this.nonbookish,
508+ this.outshiner,
509+ this.overweather,
510+ this.protonegroid,
511+ this.shallowish,
512+ this.snoke,
513+ this.snout,
514+ this.surveillance,
515+ this.threshingtime,
516+ this.thysanocarpus,
517+ this.unsignificantly,
518+ this.unsnap,
519+ this.vendible,
520+ });
521+
522+ factory LupusClass.fromMap(Map<String, dynamic> json) => LupusClass(
523+ catharticalness: json["catharticalness"]?.toDouble(),
524+ chirotherium: json["Chirotherium"],
525+ chlorioninae: json["Chlorioninae"],
526+ corvinae: json["Corvinae"],
527+ crassina: json["Crassina"],
528+ disdiapason: json["disdiapason"],
529+ exiguity: json["exiguity"],
530+ farcist: json["farcist"],
531+ holographical: json["holographical"],
532+ homocerc: json["homocerc"],
533+ ichthyophagan: json["ichthyophagan"],
534+ implacable: json["implacable"],
535+ nonbookish: json["nonbookish"],
536+ outshiner: json["outshiner"],
537+ overweather: json["overweather"],
538+ protonegroid: json["protonegroid"],
539+ shallowish: json["shallowish"],
540+ snoke: json["snoke"],
541+ snout: json["snout"],
542+ surveillance: json["surveillance"],
543+ threshingtime: json["threshingtime"],
544+ thysanocarpus: json["Thysanocarpus"],
545+ unsignificantly: json["unsignificantly"],
546+ unsnap: json["unsnap"],
547+ vendible: json["vendible"],
548+ );
549+
550+ Map<String, dynamic> toMap() => {
551+ "catharticalness": catharticalness,
552+ "Chirotherium": chirotherium,
553+ "Chlorioninae": chlorioninae,
554+ "Corvinae": corvinae,
555+ "Crassina": crassina,
556+ "disdiapason": disdiapason,
557+ "exiguity": exiguity,
558+ "farcist": farcist,
559+ "holographical": holographical,
560+ "homocerc": homocerc,
561+ "ichthyophagan": ichthyophagan,
562+ "implacable": implacable,
563+ "nonbookish": nonbookish,
564+ "outshiner": outshiner,
565+ "overweather": overweather,
566+ "protonegroid": protonegroid,
567+ "shallowish": shallowish,
568+ "snoke": snoke,
569+ "snout": snout,
570+ "surveillance": surveillance,
571+ "threshingtime": threshingtime,
572+ "Thysanocarpus": thysanocarpus,
573+ "unsignificantly": unsignificantly,
574+ "unsnap": unsnap,
575+ "vendible": vendible,
576+ };
577+}
578+
579+class Maslin {
580+ final int? alicant;
581+ final dynamic antiatonement;
582+ final int? anticorrosive;
583+ final dynamic aphidozer;
584+ final dynamic bakuninist;
585+ final int? be;
586+ final double? catharticalness;
587+ final int? chirotherium;
588+ final int? chub;
589+ final int? cuprosilicon;
590+ final int? curtailedly;
591+ final int? dellenite;
592+ final int? dimitry;
593+ final String? disdiapason;
594+ final dynamic edifying;
595+ final int? ethmoiditis;
596+ final dynamic gastralgy;
597+ final int? goatherd;
598+ final int? hammerdress;
599+ final dynamic hangfire;
600+ final bool? homocerc;
601+ final int? lacunosity;
602+ final dynamic longiloquence;
603+ final int? mameliere;
604+ final dynamic motherless;
605+ final dynamic nonbookish;
606+ final dynamic noncorrodible;
607+ final dynamic nonsensicality;
608+ final int? oafishly;
609+ final dynamic pfund;
610+ final dynamic preadvisory;
611+ final dynamic retroflexed;
612+ final int? saccharulmic;
613+ final int? scowlful;
614+ final dynamic secluded;
615+ final dynamic slackage;
616+ final int? sphaeridial;
617+ final dynamic spondulics;
618+ final int? subsecive;
619+ final dynamic swellmobsman;
620+ final int? trachyglossate;
621+ final dynamic trialogue;
622+ final int? unassuaged;
623+ final dynamic ungross;
624+ final dynamic unjudiciously;
625+
626+ Maslin({
627+ this.alicant,
628+ this.antiatonement,
629+ this.anticorrosive,
630+ this.aphidozer,
631+ this.bakuninist,
632+ this.be,
633+ this.catharticalness,
634+ this.chirotherium,
635+ this.chub,
636+ this.cuprosilicon,
637+ this.curtailedly,
638+ this.dellenite,
639+ this.dimitry,
640+ this.disdiapason,
641+ this.edifying,
642+ this.ethmoiditis,
643+ this.gastralgy,
644+ this.goatherd,
645+ this.hammerdress,
646+ this.hangfire,
647+ this.homocerc,
648+ this.lacunosity,
649+ this.longiloquence,
650+ this.mameliere,
651+ this.motherless,
652+ this.nonbookish,
653+ this.noncorrodible,
654+ this.nonsensicality,
655+ this.oafishly,
656+ this.pfund,
657+ this.preadvisory,
658+ this.retroflexed,
659+ this.saccharulmic,
660+ this.scowlful,
661+ this.secluded,
662+ this.slackage,
663+ this.sphaeridial,
664+ this.spondulics,
665+ this.subsecive,
666+ this.swellmobsman,
667+ this.trachyglossate,
668+ this.trialogue,
669+ this.unassuaged,
670+ this.ungross,
671+ this.unjudiciously,
672+ });
673+
674+ factory Maslin.fromMap(Map<String, dynamic> json) => Maslin(
675+ alicant: json["Alicant"],
676+ antiatonement: json["antiatonement"],
677+ anticorrosive: json["anticorrosive"],
678+ aphidozer: json["aphidozer"],
679+ bakuninist: json["Bakuninist"],
680+ be: json["be"],
681+ catharticalness: json["catharticalness"]?.toDouble(),
682+ chirotherium: json["Chirotherium"],
683+ chub: json["chub"],
684+ cuprosilicon: json["cuprosilicon"],
685+ curtailedly: json["curtailedly"],
686+ dellenite: json["dellenite"],
687+ dimitry: json["Dimitry"],
688+ disdiapason: json["disdiapason"],
689+ edifying: json["edifying"],
690+ ethmoiditis: json["ethmoiditis"],
691+ gastralgy: json["gastralgy"],
692+ goatherd: json["goatherd"],
693+ hammerdress: json["hammerdress"],
694+ hangfire: json["hangfire"],
695+ homocerc: json["homocerc"],
696+ lacunosity: json["lacunosity"],
697+ longiloquence: json["longiloquence"],
698+ mameliere: json["mameliere"],
699+ motherless: json["motherless"],
700+ nonbookish: json["nonbookish"],
701+ noncorrodible: json["noncorrodible"],
702+ nonsensicality: json["nonsensicality"],
703+ oafishly: json["oafishly"],
704+ pfund: json["pfund"],
705+ preadvisory: json["preadvisory"],
706+ retroflexed: json["retroflexed"],
707+ saccharulmic: json["saccharulmic"],
708+ scowlful: json["scowlful"],
709+ secluded: json["secluded"],
710+ slackage: json["slackage"],
711+ sphaeridial: json["sphaeridial"],
712+ spondulics: json["spondulics"],
713+ subsecive: json["subsecive"],
714+ swellmobsman: json["swellmobsman"],
715+ trachyglossate: json["trachyglossate"],
716+ trialogue: json["trialogue"],
717+ unassuaged: json["unassuaged"],
718+ ungross: json["ungross"],
719+ unjudiciously: json["unjudiciously"],
720+ );
721+
722+ Map<String, dynamic> toMap() => {
723+ "Alicant": alicant,
724+ "antiatonement": antiatonement,
725+ "anticorrosive": anticorrosive,
726+ "aphidozer": aphidozer,
727+ "Bakuninist": bakuninist,
728+ "be": be,
729+ "catharticalness": catharticalness,
730+ "Chirotherium": chirotherium,
731+ "chub": chub,
732+ "cuprosilicon": cuprosilicon,
733+ "curtailedly": curtailedly,
734+ "dellenite": dellenite,
735+ "Dimitry": dimitry,
736+ "disdiapason": disdiapason,
737+ "edifying": edifying,
738+ "ethmoiditis": ethmoiditis,
739+ "gastralgy": gastralgy,
740+ "goatherd": goatherd,
741+ "hammerdress": hammerdress,
742+ "hangfire": hangfire,
743+ "homocerc": homocerc,
744+ "lacunosity": lacunosity,
745+ "longiloquence": longiloquence,
746+ "mameliere": mameliere,
747+ "motherless": motherless,
748+ "nonbookish": nonbookish,
749+ "noncorrodible": noncorrodible,
750+ "nonsensicality": nonsensicality,
751+ "oafishly": oafishly,
752+ "pfund": pfund,
753+ "preadvisory": preadvisory,
754+ "retroflexed": retroflexed,
755+ "saccharulmic": saccharulmic,
756+ "scowlful": scowlful,
757+ "secluded": secluded,
758+ "slackage": slackage,
759+ "sphaeridial": sphaeridial,
760+ "spondulics": spondulics,
761+ "subsecive": subsecive,
762+ "swellmobsman": swellmobsman,
763+ "trachyglossate": trachyglossate,
764+ "trialogue": trialogue,
765+ "unassuaged": unassuaged,
766+ "ungross": ungross,
767+ "unjudiciously": unjudiciously,
768+ };
769+}
770+
771+class MonaziteClass {
772+ final double catharticalness;
773+ final int chirotherium;
774+ final String disdiapason;
775+ final bool homocerc;
776+ final dynamic nonbookish;
777+
778+ MonaziteClass({
779+ required this.catharticalness,
780+ required this.chirotherium,
781+ required this.disdiapason,
782+ required this.homocerc,
783+ required this.nonbookish,
784+ });
785+
786+ factory MonaziteClass.fromMap(Map<String, dynamic> json) => MonaziteClass(
787+ catharticalness: json["catharticalness"]?.toDouble(),
788+ chirotherium: json["Chirotherium"],
789+ disdiapason: json["disdiapason"],
790+ homocerc: json["homocerc"],
791+ nonbookish: (json.containsKey("nonbookish") ? json["nonbookish"] : throw FormatException('Missing required property')),
792+ );
793+
794+ Map<String, dynamic> toMap() => {
795+ "catharticalness": catharticalness,
796+ "Chirotherium": chirotherium,
797+ "disdiapason": disdiapason,
798+ "homocerc": homocerc,
799+ "nonbookish": nonbookish,
800+ };
801+}
802+
803+class MonotheisticallyClass {
804+ final dynamic blaspheme;
805+ final double? catharticalness;
806+ final dynamic celiosalpingectomy;
807+ final int? chirotherium;
808+ final dynamic consummativeness;
809+ final String? disdiapason;
810+ final dynamic egestive;
811+ final dynamic enchylema;
812+ final dynamic gasconade;
813+ final dynamic holidayer;
814+ final bool? homocerc;
815+ final dynamic intuitionalism;
816+ final dynamic lophiostomate;
817+ final dynamic nonbookish;
818+ final dynamic nonvolition;
819+ final dynamic palatableness;
820+ final dynamic pimpery;
821+ final dynamic previolation;
822+ final dynamic reconveyance;
823+ final dynamic registership;
824+ final dynamic rhyacolite;
825+ final dynamic smithereens;
826+ final dynamic superedification;
827+ final dynamic trust;
828+ final dynamic whitestone;
829+
830+ MonotheisticallyClass({
831+ this.blaspheme,
832+ this.catharticalness,
833+ this.celiosalpingectomy,
834+ this.chirotherium,
835+ this.consummativeness,
836+ this.disdiapason,
837+ this.egestive,
838+ this.enchylema,
839+ this.gasconade,
840+ this.holidayer,
841+ this.homocerc,
842+ this.intuitionalism,
843+ this.lophiostomate,
844+ this.nonbookish,
845+ this.nonvolition,
846+ this.palatableness,
847+ this.pimpery,
848+ this.previolation,
849+ this.reconveyance,
850+ this.registership,
851+ this.rhyacolite,
852+ this.smithereens,
853+ this.superedification,
854+ this.trust,
855+ this.whitestone,
856+ });
857+
858+ factory MonotheisticallyClass.fromMap(Map<String, dynamic> json) => MonotheisticallyClass(
859+ blaspheme: json["blaspheme"],
860+ catharticalness: json["catharticalness"]?.toDouble(),
861+ celiosalpingectomy: json["celiosalpingectomy"],
862+ chirotherium: json["Chirotherium"],
863+ consummativeness: json["consummativeness"],
864+ disdiapason: json["disdiapason"],
865+ egestive: json["egestive"],
866+ enchylema: json["enchylema"],
867+ gasconade: json["gasconade"],
868+ holidayer: json["holidayer"],
869+ homocerc: json["homocerc"],
870+ intuitionalism: json["intuitionalism"],
871+ lophiostomate: json["lophiostomate"],
872+ nonbookish: json["nonbookish"],
873+ nonvolition: json["nonvolition"],
874+ palatableness: json["palatableness"],
875+ pimpery: json["pimpery"],
876+ previolation: json["previolation"],
877+ reconveyance: json["reconveyance"],
878+ registership: json["registership"],
879+ rhyacolite: json["rhyacolite"],
880+ smithereens: json["smithereens"],
881+ superedification: json["superedification"],
882+ trust: json["trust"],
883+ whitestone: json["whitestone"],
884+ );
885+
886+ Map<String, dynamic> toMap() => {
887+ "blaspheme": blaspheme,
888+ "catharticalness": catharticalness,
889+ "celiosalpingectomy": celiosalpingectomy,
890+ "Chirotherium": chirotherium,
891+ "consummativeness": consummativeness,
892+ "disdiapason": disdiapason,
893+ "egestive": egestive,
894+ "enchylema": enchylema,
895+ "gasconade": gasconade,
896+ "holidayer": holidayer,
897+ "homocerc": homocerc,
898+ "intuitionalism": intuitionalism,
899+ "lophiostomate": lophiostomate,
900+ "nonbookish": nonbookish,
901+ "nonvolition": nonvolition,
902+ "palatableness": palatableness,
903+ "pimpery": pimpery,
904+ "previolation": previolation,
905+ "reconveyance": reconveyance,
906+ "registership": registership,
907+ "rhyacolite": rhyacolite,
908+ "smithereens": smithereens,
909+ "superedification": superedification,
910+ "trust": trust,
911+ "whitestone": whitestone,
912+ };
913+}
914+
915+class Noncontributing {
916+ final String estevin;
917+ final double jolterhead;
918+ final int sauternes;
919+ final bool sparsely;
920+ final dynamic unrequested;
921+
922+ Noncontributing({
923+ required this.estevin,
924+ required this.jolterhead,
925+ required this.sauternes,
926+ required this.sparsely,
927+ required this.unrequested,
928+ });
929+
930+ factory Noncontributing.fromMap(Map<String, dynamic> json) => Noncontributing(
931+ estevin: json["estevin"],
932+ jolterhead: json["jolterhead"]?.toDouble(),
933+ sauternes: json["sauternes"],
934+ sparsely: json["sparsely"],
935+ unrequested: (json.containsKey("unrequested") ? json["unrequested"] : throw FormatException('Missing required property')),
936+ );
937+
938+ Map<String, dynamic> toMap() => {
939+ "estevin": estevin,
940+ "jolterhead": jolterhead,
941+ "sauternes": sauternes,
942+ "sparsely": sparsely,
943+ "unrequested": unrequested,
944+ };
945+}
946+
947+class OccupationalistClass {
948+ final dynamic beholdable;
949+ final dynamic brotuliform;
950+ final dynamic chimakum;
951+ final dynamic doodler;
952+ final dynamic emulsin;
953+ final dynamic fin;
954+ final dynamic flourishing;
955+ final dynamic flueless;
956+ final dynamic furtively;
957+ final dynamic gritter;
958+ final dynamic interwish;
959+ final dynamic monoxylic;
960+ final dynamic myristic;
961+ final dynamic nightwear;
962+ final dynamic peruser;
963+ final dynamic theoastrological;
964+ final dynamic thumby;
965+ final dynamic tingitid;
966+ final dynamic trailless;
967+ final dynamic unpocketed;
968+
969+ OccupationalistClass({
970+ required this.beholdable,
971+ required this.brotuliform,
972+ required this.chimakum,
973+ required this.doodler,
974+ required this.emulsin,
975+ required this.fin,
976+ required this.flourishing,
977+ required this.flueless,
978+ required this.furtively,
979+ required this.gritter,
980+ required this.interwish,
981+ required this.monoxylic,
982+ required this.myristic,
983+ required this.nightwear,
984+ required this.peruser,
985+ required this.theoastrological,
986+ required this.thumby,
987+ required this.tingitid,
988+ required this.trailless,
989+ required this.unpocketed,
990+ });
991+
992+ factory OccupationalistClass.fromMap(Map<String, dynamic> json) => OccupationalistClass(
993+ beholdable: (json.containsKey("beholdable") ? json["beholdable"] : throw FormatException('Missing required property')),
994+ brotuliform: (json.containsKey("brotuliform") ? json["brotuliform"] : throw FormatException('Missing required property')),
995+ chimakum: (json.containsKey("Chimakum") ? json["Chimakum"] : throw FormatException('Missing required property')),
996+ doodler: (json.containsKey("doodler") ? json["doodler"] : throw FormatException('Missing required property')),
997+ emulsin: (json.containsKey("emulsin") ? json["emulsin"] : throw FormatException('Missing required property')),
998+ fin: (json.containsKey("Fin") ? json["Fin"] : throw FormatException('Missing required property')),
999+ flourishing: (json.containsKey("flourishing") ? json["flourishing"] : throw FormatException('Missing required property')),
1000+ flueless: (json.containsKey("flueless") ? json["flueless"] : throw FormatException('Missing required property')),
1001+ furtively: (json.containsKey("furtively") ? json["furtively"] : throw FormatException('Missing required property')),
1002+ gritter: (json.containsKey("gritter") ? json["gritter"] : throw FormatException('Missing required property')),
1003+ interwish: (json.containsKey("interwish") ? json["interwish"] : throw FormatException('Missing required property')),
1004+ monoxylic: (json.containsKey("monoxylic") ? json["monoxylic"] : throw FormatException('Missing required property')),
1005+ myristic: (json.containsKey("myristic") ? json["myristic"] : throw FormatException('Missing required property')),
1006+ nightwear: (json.containsKey("nightwear") ? json["nightwear"] : throw FormatException('Missing required property')),
1007+ peruser: (json.containsKey("peruser") ? json["peruser"] : throw FormatException('Missing required property')),
1008+ theoastrological: (json.containsKey("theoastrological") ? json["theoastrological"] : throw FormatException('Missing required property')),
1009+ thumby: (json.containsKey("thumby") ? json["thumby"] : throw FormatException('Missing required property')),
1010+ tingitid: (json.containsKey("tingitid") ? json["tingitid"] : throw FormatException('Missing required property')),
1011+ trailless: (json.containsKey("trailless") ? json["trailless"] : throw FormatException('Missing required property')),
1012+ unpocketed: (json.containsKey("unpocketed") ? json["unpocketed"] : throw FormatException('Missing required property')),
1013+ );
1014+
1015+ Map<String, dynamic> toMap() => {
1016+ "beholdable": beholdable,
1017+ "brotuliform": brotuliform,
1018+ "Chimakum": chimakum,
1019+ "doodler": doodler,
1020+ "emulsin": emulsin,
1021+ "Fin": fin,
1022+ "flourishing": flourishing,
1023+ "flueless": flueless,
1024+ "furtively": furtively,
1025+ "gritter": gritter,
1026+ "interwish": interwish,
1027+ "monoxylic": monoxylic,
1028+ "myristic": myristic,
1029+ "nightwear": nightwear,
1030+ "peruser": peruser,
1031+ "theoastrological": theoastrological,
1032+ "thumby": thumby,
1033+ "tingitid": tingitid,
1034+ "trailless": trailless,
1035+ "unpocketed": unpocketed,
1036+ };
1037+}
1038+
1039+class OutrivalClass {
1040+ final dynamic adroitly;
1041+ final dynamic bridehood;
1042+ final dynamic castoroides;
1043+ final dynamic czechoslovak;
1044+ final dynamic diagenesis;
1045+ final dynamic dihexahedron;
1046+ final dynamic dopester;
1047+ final dynamic eumerism;
1048+ final dynamic flyness;
1049+ final dynamic fouler;
1050+ final dynamic laudanosine;
1051+ final dynamic lingulidae;
1052+ final dynamic minutary;
1053+ final dynamic mitra;
1054+ final dynamic opisthorchiasis;
1055+ final dynamic pensively;
1056+ final dynamic pubigerous;
1057+ final dynamic rebellious;
1058+ final dynamic recodify;
1059+ final dynamic unpaced;
1060+
1061+ OutrivalClass({
1062+ required this.adroitly,
1063+ required this.bridehood,
1064+ required this.castoroides,
1065+ required this.czechoslovak,
1066+ required this.diagenesis,
1067+ required this.dihexahedron,
1068+ required this.dopester,
1069+ required this.eumerism,
1070+ required this.flyness,
1071+ required this.fouler,
1072+ required this.laudanosine,
1073+ required this.lingulidae,
1074+ required this.minutary,
1075+ required this.mitra,
1076+ required this.opisthorchiasis,
1077+ required this.pensively,
1078+ required this.pubigerous,
1079+ required this.rebellious,
1080+ required this.recodify,
1081+ required this.unpaced,
1082+ });
1083+
1084+ factory OutrivalClass.fromMap(Map<String, dynamic> json) => OutrivalClass(
1085+ adroitly: (json.containsKey("adroitly") ? json["adroitly"] : throw FormatException('Missing required property')),
1086+ bridehood: (json.containsKey("bridehood") ? json["bridehood"] : throw FormatException('Missing required property')),
1087+ castoroides: (json.containsKey("Castoroides") ? json["Castoroides"] : throw FormatException('Missing required property')),
1088+ czechoslovak: (json.containsKey("Czechoslovak") ? json["Czechoslovak"] : throw FormatException('Missing required property')),
1089+ diagenesis: (json.containsKey("diagenesis") ? json["diagenesis"] : throw FormatException('Missing required property')),
1090+ dihexahedron: (json.containsKey("dihexahedron") ? json["dihexahedron"] : throw FormatException('Missing required property')),
1091+ dopester: (json.containsKey("dopester") ? json["dopester"] : throw FormatException('Missing required property')),
1092+ eumerism: (json.containsKey("eumerism") ? json["eumerism"] : throw FormatException('Missing required property')),
1093+ flyness: (json.containsKey("flyness") ? json["flyness"] : throw FormatException('Missing required property')),
1094+ fouler: (json.containsKey("fouler") ? json["fouler"] : throw FormatException('Missing required property')),
1095+ laudanosine: (json.containsKey("laudanosine") ? json["laudanosine"] : throw FormatException('Missing required property')),
1096+ lingulidae: (json.containsKey("Lingulidae") ? json["Lingulidae"] : throw FormatException('Missing required property')),
1097+ minutary: (json.containsKey("minutary") ? json["minutary"] : throw FormatException('Missing required property')),
1098+ mitra: (json.containsKey("mitra") ? json["mitra"] : throw FormatException('Missing required property')),
1099+ opisthorchiasis: (json.containsKey("opisthorchiasis") ? json["opisthorchiasis"] : throw FormatException('Missing required property')),
1100+ pensively: (json.containsKey("pensively") ? json["pensively"] : throw FormatException('Missing required property')),
1101+ pubigerous: (json.containsKey("pubigerous") ? json["pubigerous"] : throw FormatException('Missing required property')),
1102+ rebellious: (json.containsKey("rebellious") ? json["rebellious"] : throw FormatException('Missing required property')),
1103+ recodify: (json.containsKey("recodify") ? json["recodify"] : throw FormatException('Missing required property')),
1104+ unpaced: (json.containsKey("unpaced") ? json["unpaced"] : throw FormatException('Missing required property')),
1105+ );
1106+
1107+ Map<String, dynamic> toMap() => {
1108+ "adroitly": adroitly,
1109+ "bridehood": bridehood,
1110+ "Castoroides": castoroides,
1111+ "Czechoslovak": czechoslovak,
1112+ "diagenesis": diagenesis,
1113+ "dihexahedron": dihexahedron,
1114+ "dopester": dopester,
1115+ "eumerism": eumerism,
1116+ "flyness": flyness,
1117+ "fouler": fouler,
1118+ "laudanosine": laudanosine,
1119+ "Lingulidae": lingulidae,
1120+ "minutary": minutary,
1121+ "mitra": mitra,
1122+ "opisthorchiasis": opisthorchiasis,
1123+ "pensively": pensively,
1124+ "pubigerous": pubigerous,
1125+ "rebellious": rebellious,
1126+ "recodify": recodify,
1127+ "unpaced": unpaced,
1128+ };
1129+}
1130+
1131+class PiaculumClass {
1132+ final int? alada;
1133+ final int? amphistomous;
1134+ final int? boysenberry;
1135+ final double? catharticalness;
1136+ final int? chirotherium;
1137+ final int? decardinalize;
1138+ final int? discouragement;
1139+ final String? disdiapason;
1140+ final int? doitrified;
1141+ final int? hexaspermous;
1142+ final bool? homocerc;
1143+ final int? insinking;
1144+ final int? loathfulness;
1145+ final int? miasmatical;
1146+ final int? neurofibril;
1147+ final dynamic nonbookish;
1148+ final int? phonendoscope;
1149+ final int? pilferment;
1150+ final int? predismissory;
1151+ final int? preinscription;
1152+ final int? quotative;
1153+ final int? sienna;
1154+ final int? thorax;
1155+ final int? yachting;
1156+ final int? zipper;
1157+
1158+ PiaculumClass({
1159+ this.alada,
1160+ this.amphistomous,
1161+ this.boysenberry,
1162+ this.catharticalness,
1163+ this.chirotherium,
1164+ this.decardinalize,
1165+ this.discouragement,
1166+ this.disdiapason,
1167+ this.doitrified,
1168+ this.hexaspermous,
1169+ this.homocerc,
1170+ this.insinking,
1171+ this.loathfulness,
1172+ this.miasmatical,
1173+ this.neurofibril,
1174+ this.nonbookish,
1175+ this.phonendoscope,
1176+ this.pilferment,
1177+ this.predismissory,
1178+ this.preinscription,
1179+ this.quotative,
1180+ this.sienna,
1181+ this.thorax,
1182+ this.yachting,
1183+ this.zipper,
1184+ });
1185+
1186+ factory PiaculumClass.fromMap(Map<String, dynamic> json) => PiaculumClass(
1187+ alada: json["alada"],
1188+ amphistomous: json["amphistomous"],
1189+ boysenberry: json["boysenberry"],
1190+ catharticalness: json["catharticalness"]?.toDouble(),
1191+ chirotherium: json["Chirotherium"],
1192+ decardinalize: json["decardinalize"],
1193+ discouragement: json["discouragement"],
1194+ disdiapason: json["disdiapason"],
1195+ doitrified: json["doitrified"],
1196+ hexaspermous: json["hexaspermous"],
1197+ homocerc: json["homocerc"],
1198+ insinking: json["insinking"],
1199+ loathfulness: json["loathfulness"],
1200+ miasmatical: json["miasmatical"],
1201+ neurofibril: json["neurofibril"],
1202+ nonbookish: json["nonbookish"],
1203+ phonendoscope: json["phonendoscope"],
1204+ pilferment: json["pilferment"],
1205+ predismissory: json["predismissory"],
1206+ preinscription: json["preinscription"],
1207+ quotative: json["quotative"],
1208+ sienna: json["sienna"],
1209+ thorax: json["thorax"],
1210+ yachting: json["yachting"],
1211+ zipper: json["Zipper"],
1212+ );
1213+
1214+ Map<String, dynamic> toMap() => {
1215+ "alada": alada,
1216+ "amphistomous": amphistomous,
1217+ "boysenberry": boysenberry,
1218+ "catharticalness": catharticalness,
1219+ "Chirotherium": chirotherium,
1220+ "decardinalize": decardinalize,
1221+ "discouragement": discouragement,
1222+ "disdiapason": disdiapason,
1223+ "doitrified": doitrified,
1224+ "hexaspermous": hexaspermous,
1225+ "homocerc": homocerc,
1226+ "insinking": insinking,
1227+ "loathfulness": loathfulness,
1228+ "miasmatical": miasmatical,
1229+ "neurofibril": neurofibril,
1230+ "nonbookish": nonbookish,
1231+ "phonendoscope": phonendoscope,
1232+ "pilferment": pilferment,
1233+ "predismissory": predismissory,
1234+ "preinscription": preinscription,
1235+ "quotative": quotative,
1236+ "sienna": sienna,
1237+ "thorax": thorax,
1238+ "yachting": yachting,
1239+ "Zipper": zipper,
1240+ };
1241+}
1242+
1243+class Pneumocele {
1244+ final dynamic carbonarism;
1245+ final double? catharticalness;
1246+ final int? chirotherium;
1247+ final dynamic cineolic;
1248+ final dynamic cobbly;
1249+ final dynamic conchyliferous;
1250+ final dynamic congregation;
1251+ final String? disdiapason;
1252+ final dynamic enterotomy;
1253+ final dynamic entophytal;
1254+ final dynamic fewtrils;
1255+ final dynamic herem;
1256+ final bool? homocerc;
1257+ final dynamic koniga;
1258+ final dynamic meticulosity;
1259+ final dynamic micky;
1260+ final dynamic mismarriage;
1261+ final dynamic neurotrophic;
1262+ final dynamic nonbookish;
1263+ final dynamic persuasively;
1264+ final dynamic replaceable;
1265+ final dynamic silex;
1266+ final dynamic taillight;
1267+ final dynamic unjealous;
1268+ final dynamic visitorial;
1269+
1270+ Pneumocele({
1271+ this.carbonarism,
1272+ this.catharticalness,
1273+ this.chirotherium,
1274+ this.cineolic,
1275+ this.cobbly,
1276+ this.conchyliferous,
1277+ this.congregation,
1278+ this.disdiapason,
1279+ this.enterotomy,
1280+ this.entophytal,
1281+ this.fewtrils,
1282+ this.herem,
1283+ this.homocerc,
1284+ this.koniga,
1285+ this.meticulosity,
1286+ this.micky,
1287+ this.mismarriage,
1288+ this.neurotrophic,
1289+ this.nonbookish,
1290+ this.persuasively,
1291+ this.replaceable,
1292+ this.silex,
1293+ this.taillight,
1294+ this.unjealous,
1295+ this.visitorial,
1296+ });
1297+
1298+ factory Pneumocele.fromMap(Map<String, dynamic> json) => Pneumocele(
1299+ carbonarism: json["Carbonarism"],
1300+ catharticalness: json["catharticalness"]?.toDouble(),
1301+ chirotherium: json["Chirotherium"],
1302+ cineolic: json["cineolic"],
1303+ cobbly: json["cobbly"],
1304+ conchyliferous: json["conchyliferous"],
1305+ congregation: json["congregation"],
1306+ disdiapason: json["disdiapason"],
1307+ enterotomy: json["enterotomy"],
1308+ entophytal: json["entophytal"],
1309+ fewtrils: json["fewtrils"],
1310+ herem: json["herem"],
1311+ homocerc: json["homocerc"],
1312+ koniga: json["Koniga"],
1313+ meticulosity: json["meticulosity"],
1314+ micky: json["Micky"],
1315+ mismarriage: json["mismarriage"],
1316+ neurotrophic: json["neurotrophic"],
1317+ nonbookish: json["nonbookish"],
1318+ persuasively: json["persuasively"],
1319+ replaceable: json["replaceable"],
1320+ silex: json["silex"],
1321+ taillight: json["taillight"],
1322+ unjealous: json["unjealous"],
1323+ visitorial: json["visitorial"],
1324+ );
1325+
1326+ Map<String, dynamic> toMap() => {
1327+ "Carbonarism": carbonarism,
1328+ "catharticalness": catharticalness,
1329+ "Chirotherium": chirotherium,
1330+ "cineolic": cineolic,
1331+ "cobbly": cobbly,
1332+ "conchyliferous": conchyliferous,
1333+ "congregation": congregation,
1334+ "disdiapason": disdiapason,
1335+ "enterotomy": enterotomy,
1336+ "entophytal": entophytal,
1337+ "fewtrils": fewtrils,
1338+ "herem": herem,
1339+ "homocerc": homocerc,
1340+ "Koniga": koniga,
1341+ "meticulosity": meticulosity,
1342+ "Micky": micky,
1343+ "mismarriage": mismarriage,
1344+ "neurotrophic": neurotrophic,
1345+ "nonbookish": nonbookish,
1346+ "persuasively": persuasively,
1347+ "replaceable": replaceable,
1348+ "silex": silex,
1349+ "taillight": taillight,
1350+ "unjealous": unjealous,
1351+ "visitorial": visitorial,
1352+ };
1353+}
1354+
1355+class PotwhiskyClass {
1356+ final dynamic arciform;
1357+ final dynamic cresolin;
1358+ final dynamic disheartener;
1359+ final dynamic disproportionable;
1360+ final dynamic euchorda;
1361+ final dynamic ferryway;
1362+ final dynamic filamentiferous;
1363+ final dynamic flemish;
1364+ final dynamic forgainst;
1365+ final dynamic grainering;
1366+ final dynamic irrevoluble;
1367+ final dynamic kindredship;
1368+ final dynamic pinguitudinous;
1369+ final dynamic simpletonic;
1370+ final dynamic singsong;
1371+ final dynamic submergement;
1372+ final dynamic supraoesophagal;
1373+ final dynamic thrashel;
1374+ final dynamic tyremesis;
1375+ final dynamic yoruba;
1376+
1377+ PotwhiskyClass({
1378+ required this.arciform,
1379+ required this.cresolin,
1380+ required this.disheartener,
1381+ required this.disproportionable,
1382+ required this.euchorda,
1383+ required this.ferryway,
1384+ required this.filamentiferous,
1385+ required this.flemish,
1386+ required this.forgainst,
1387+ required this.grainering,
1388+ required this.irrevoluble,
1389+ required this.kindredship,
1390+ required this.pinguitudinous,
1391+ required this.simpletonic,
1392+ required this.singsong,
1393+ required this.submergement,
1394+ required this.supraoesophagal,
1395+ required this.thrashel,
1396+ required this.tyremesis,
1397+ required this.yoruba,
1398+ });
1399+
1400+ factory PotwhiskyClass.fromMap(Map<String, dynamic> json) => PotwhiskyClass(
1401+ arciform: (json.containsKey("arciform") ? json["arciform"] : throw FormatException('Missing required property')),
1402+ cresolin: (json.containsKey("cresolin") ? json["cresolin"] : throw FormatException('Missing required property')),
1403+ disheartener: (json.containsKey("disheartener") ? json["disheartener"] : throw FormatException('Missing required property')),
1404+ disproportionable: (json.containsKey("disproportionable") ? json["disproportionable"] : throw FormatException('Missing required property')),
1405+ euchorda: (json.containsKey("Euchorda") ? json["Euchorda"] : throw FormatException('Missing required property')),
1406+ ferryway: (json.containsKey("ferryway") ? json["ferryway"] : throw FormatException('Missing required property')),
1407+ filamentiferous: (json.containsKey("filamentiferous") ? json["filamentiferous"] : throw FormatException('Missing required property')),
1408+ flemish: (json.containsKey("flemish") ? json["flemish"] : throw FormatException('Missing required property')),
1409+ forgainst: (json.containsKey("forgainst") ? json["forgainst"] : throw FormatException('Missing required property')),
1410+ grainering: (json.containsKey("grainering") ? json["grainering"] : throw FormatException('Missing required property')),
1411+ irrevoluble: (json.containsKey("irrevoluble") ? json["irrevoluble"] : throw FormatException('Missing required property')),
1412+ kindredship: (json.containsKey("kindredship") ? json["kindredship"] : throw FormatException('Missing required property')),
1413+ pinguitudinous: (json.containsKey("pinguitudinous") ? json["pinguitudinous"] : throw FormatException('Missing required property')),
1414+ simpletonic: (json.containsKey("simpletonic") ? json["simpletonic"] : throw FormatException('Missing required property')),
1415+ singsong: (json.containsKey("singsong") ? json["singsong"] : throw FormatException('Missing required property')),
1416+ submergement: (json.containsKey("submergement") ? json["submergement"] : throw FormatException('Missing required property')),
1417+ supraoesophagal: (json.containsKey("supraoesophagal") ? json["supraoesophagal"] : throw FormatException('Missing required property')),
1418+ thrashel: (json.containsKey("thrashel") ? json["thrashel"] : throw FormatException('Missing required property')),
1419+ tyremesis: (json.containsKey("tyremesis") ? json["tyremesis"] : throw FormatException('Missing required property')),
1420+ yoruba: (json.containsKey("Yoruba") ? json["Yoruba"] : throw FormatException('Missing required property')),
1421+ );
1422+
1423+ Map<String, dynamic> toMap() => {
1424+ "arciform": arciform,
1425+ "cresolin": cresolin,
1426+ "disheartener": disheartener,
1427+ "disproportionable": disproportionable,
1428+ "Euchorda": euchorda,
1429+ "ferryway": ferryway,
1430+ "filamentiferous": filamentiferous,
1431+ "flemish": flemish,
1432+ "forgainst": forgainst,
1433+ "grainering": grainering,
1434+ "irrevoluble": irrevoluble,
1435+ "kindredship": kindredship,
1436+ "pinguitudinous": pinguitudinous,
1437+ "simpletonic": simpletonic,
1438+ "singsong": singsong,
1439+ "submergement": submergement,
1440+ "supraoesophagal": supraoesophagal,
1441+ "thrashel": thrashel,
1442+ "tyremesis": tyremesis,
1443+ "Yoruba": yoruba,
1444+ };
1445+}
1446+
1447+class PrefreshmanClass {
1448+ final dynamic azorubine;
1449+ final dynamic choroiditis;
1450+ final dynamic coagulatory;
1451+ final dynamic cyclorama;
1452+ final dynamic dolphus;
1453+ final dynamic duckhearted;
1454+ final dynamic ficus;
1455+ final dynamic gemaric;
1456+ final dynamic jugation;
1457+ final dynamic myoliposis;
1458+ final dynamic nonnomination;
1459+ final dynamic palay;
1460+ final dynamic pentactinal;
1461+ final dynamic phaet;
1462+ final dynamic piquant;
1463+ final dynamic registration;
1464+ final dynamic remancipation;
1465+ final dynamic scutatiform;
1466+ final dynamic theodolite;
1467+ final dynamic underward;
1468+
1469+ PrefreshmanClass({
1470+ required this.azorubine,
1471+ required this.choroiditis,
1472+ required this.coagulatory,
1473+ required this.cyclorama,
1474+ required this.dolphus,
1475+ required this.duckhearted,
1476+ required this.ficus,
1477+ required this.gemaric,
1478+ required this.jugation,
1479+ required this.myoliposis,
1480+ required this.nonnomination,
1481+ required this.palay,
1482+ required this.pentactinal,
1483+ required this.phaet,
1484+ required this.piquant,
1485+ required this.registration,
1486+ required this.remancipation,
1487+ required this.scutatiform,
1488+ required this.theodolite,
1489+ required this.underward,
1490+ });
1491+
1492+ factory PrefreshmanClass.fromMap(Map<String, dynamic> json) => PrefreshmanClass(
1493+ azorubine: (json.containsKey("azorubine") ? json["azorubine"] : throw FormatException('Missing required property')),
1494+ choroiditis: (json.containsKey("choroiditis") ? json["choroiditis"] : throw FormatException('Missing required property')),
1495+ coagulatory: (json.containsKey("coagulatory") ? json["coagulatory"] : throw FormatException('Missing required property')),
1496+ cyclorama: (json.containsKey("cyclorama") ? json["cyclorama"] : throw FormatException('Missing required property')),
1497+ dolphus: (json.containsKey("Dolphus") ? json["Dolphus"] : throw FormatException('Missing required property')),
1498+ duckhearted: (json.containsKey("duckhearted") ? json["duckhearted"] : throw FormatException('Missing required property')),
1499+ ficus: (json.containsKey("Ficus") ? json["Ficus"] : throw FormatException('Missing required property')),
1500+ gemaric: (json.containsKey("Gemaric") ? json["Gemaric"] : throw FormatException('Missing required property')),
1501+ jugation: (json.containsKey("jugation") ? json["jugation"] : throw FormatException('Missing required property')),
1502+ myoliposis: (json.containsKey("myoliposis") ? json["myoliposis"] : throw FormatException('Missing required property')),
1503+ nonnomination: (json.containsKey("nonnomination") ? json["nonnomination"] : throw FormatException('Missing required property')),
1504+ palay: (json.containsKey("palay") ? json["palay"] : throw FormatException('Missing required property')),
1505+ pentactinal: (json.containsKey("pentactinal") ? json["pentactinal"] : throw FormatException('Missing required property')),
1506+ phaet: (json.containsKey("Phaet") ? json["Phaet"] : throw FormatException('Missing required property')),
1507+ piquant: (json.containsKey("piquant") ? json["piquant"] : throw FormatException('Missing required property')),
1508+ registration: (json.containsKey("registration") ? json["registration"] : throw FormatException('Missing required property')),
1509+ remancipation: (json.containsKey("remancipation") ? json["remancipation"] : throw FormatException('Missing required property')),
1510+ scutatiform: (json.containsKey("scutatiform") ? json["scutatiform"] : throw FormatException('Missing required property')),
1511+ theodolite: (json.containsKey("theodolite") ? json["theodolite"] : throw FormatException('Missing required property')),
1512+ underward: (json.containsKey("underward") ? json["underward"] : throw FormatException('Missing required property')),
1513+ );
1514+
1515+ Map<String, dynamic> toMap() => {
1516+ "azorubine": azorubine,
1517+ "choroiditis": choroiditis,
1518+ "coagulatory": coagulatory,
1519+ "cyclorama": cyclorama,
1520+ "Dolphus": dolphus,
1521+ "duckhearted": duckhearted,
1522+ "Ficus": ficus,
1523+ "Gemaric": gemaric,
1524+ "jugation": jugation,
1525+ "myoliposis": myoliposis,
1526+ "nonnomination": nonnomination,
1527+ "palay": palay,
1528+ "pentactinal": pentactinal,
1529+ "Phaet": phaet,
1530+ "piquant": piquant,
1531+ "registration": registration,
1532+ "remancipation": remancipation,
1533+ "scutatiform": scutatiform,
1534+ "theodolite": theodolite,
1535+ "underward": underward,
1536+ };
1537+}
Aswiftfinal-classes-true__struct-or-class-class--d3c62ec7414d / quicktype.swift+3,534 −0
@@ -0,0 +1,3534 @@
1+// This file was generated from JSON Schema using quicktype, do not modify it directly.
2+// To parse the JSON, add this file to your project and do:
3+//
4+// let topLevel = try TopLevel(json)
5+
6+import Foundation
7+
8+// MARK: - TopLevel
9+final class TopLevel: Codable {
10+ let juror: [JurorElement]
11+ let kongoni: [Kongoni]
12+ let ladronism: [LadronismElement]
13+ let landlubberly: [LandlubberlyElement]
14+ let listener: [Listener]
15+ let lupus: [LupusElement]
16+ let maslin: [Maslin]
17+ let monazite: [MonaziteElement]
18+ let monoliteral: [Monoliteral]
19+ let monotheistically: [MonotheisticallyElement]
20+ let montage: [Montage]
21+ let moralness: [Moralness]
22+ let mowra: [MonaziteClass?]
23+ let mulishly: [Mulishly]
24+ let myoscope: [Myoscope]
25+ let nach: [[Int?]?]
26+ let neuromastic: [Neuromastic]
27+ let noncontributing: [Noncontributing]
28+ let nonnervous: [Nonnervous]
29+ let nonvaluation: [Nonvaluation]
30+ let occupationalist: [OccupationalistElement]
31+ let outrival: [OutrivalElement]
32+ let paleographically: [Paleographically]
33+ let pamphletwise: [Pamphletwise]
34+ let pediatrics: [Pediatric]
35+ let perceptive: [Bool]
36+ let piaculum: [PiaculumElement]
37+ let piccadilly: [Piccadilly]
38+ let piffler: [Piffler]
39+ let pithful: [Pithful]
40+ let placuntitis: [Placuntiti]
41+ let plectopterous: [Plectopterous]
42+ let pneumocele: [Pneumocele?]
43+ let poliorcetic: [Poliorcetic]
44+ let poormaster: [Poormaster]
45+ let potwhisky: [PotwhiskyElement]
46+ let practicalizer: [Practicalizer]
47+ let prefreshman: [PrefreshmanElement]
48+ let prehensility: [Prehensility]
49+ let prevoidance: [Prevoidance]
50+ let probant: [[String: Int?]]
51+ let protext: [Protext]
52+
53+ enum CodingKeys: String, CodingKey {
54+ case juror = "juror"
55+ case kongoni = "kongoni"
56+ case ladronism = "ladronism"
57+ case landlubberly = "landlubberly"
58+ case listener = "listener"
59+ case lupus = "lupus"
60+ case maslin = "maslin"
61+ case monazite = "monazite"
62+ case monoliteral = "monoliteral"
63+ case monotheistically = "monotheistically"
64+ case montage = "montage"
65+ case moralness = "moralness"
66+ case mowra = "mowra"
67+ case mulishly = "mulishly"
68+ case myoscope = "myoscope"
69+ case nach = "nach"
70+ case neuromastic = "neuromastic"
71+ case noncontributing = "noncontributing"
72+ case nonnervous = "nonnervous"
73+ case nonvaluation = "nonvaluation"
74+ case occupationalist = "occupationalist"
75+ case outrival = "outrival"
76+ case paleographically = "paleographically"
77+ case pamphletwise = "pamphletwise"
78+ case pediatrics = "pediatrics"
79+ case perceptive = "perceptive"
80+ case piaculum = "piaculum"
81+ case piccadilly = "piccadilly"
82+ case piffler = "piffler"
83+ case pithful = "pithful"
84+ case placuntitis = "placuntitis"
85+ case plectopterous = "plectopterous"
86+ case pneumocele = "pneumocele"
87+ case poliorcetic = "poliorcetic"
88+ case poormaster = "poormaster"
89+ case potwhisky = "potwhisky"
90+ case practicalizer = "practicalizer"
91+ case prefreshman = "prefreshman"
92+ case prehensility = "prehensility"
93+ case prevoidance = "prevoidance"
94+ case probant = "probant"
95+ case protext = "protext"
96+ }
97+
98+ 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]) {
99+ self.juror = juror
100+ self.kongoni = kongoni
101+ self.ladronism = ladronism
102+ self.landlubberly = landlubberly
103+ self.listener = listener
104+ self.lupus = lupus
105+ self.maslin = maslin
106+ self.monazite = monazite
107+ self.monoliteral = monoliteral
108+ self.monotheistically = monotheistically
109+ self.montage = montage
110+ self.moralness = moralness
111+ self.mowra = mowra
112+ self.mulishly = mulishly
113+ self.myoscope = myoscope
114+ self.nach = nach
115+ self.neuromastic = neuromastic
116+ self.noncontributing = noncontributing
117+ self.nonnervous = nonnervous
118+ self.nonvaluation = nonvaluation
119+ self.occupationalist = occupationalist
120+ self.outrival = outrival
121+ self.paleographically = paleographically
122+ self.pamphletwise = pamphletwise
123+ self.pediatrics = pediatrics
124+ self.perceptive = perceptive
125+ self.piaculum = piaculum
126+ self.piccadilly = piccadilly
127+ self.piffler = piffler
128+ self.pithful = pithful
129+ self.placuntitis = placuntitis
130+ self.plectopterous = plectopterous
131+ self.pneumocele = pneumocele
132+ self.poliorcetic = poliorcetic
133+ self.poormaster = poormaster
134+ self.potwhisky = potwhisky
135+ self.practicalizer = practicalizer
136+ self.prefreshman = prefreshman
137+ self.prehensility = prehensility
138+ self.prevoidance = prevoidance
139+ self.probant = probant
140+ self.protext = protext
141+ }
142+}
143+
144+// MARK: TopLevel convenience initializers and mutators
145+
146+extension TopLevel {
147+ convenience init(data: Data) throws {
148+ let me = try newJSONDecoder().decode(TopLevel.self, from: data)
149+ 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)
150+ }
151+
152+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
153+ guard let data = json.data(using: encoding) else {
154+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
155+ }
156+ try self.init(data: data)
157+ }
158+
159+ convenience init(fromURL url: URL) throws {
160+ try self.init(data: try Data(contentsOf: url))
161+ }
162+
163+ func with(
164+ juror: [JurorElement]? = nil,
165+ kongoni: [Kongoni]? = nil,
166+ ladronism: [LadronismElement]? = nil,
167+ landlubberly: [LandlubberlyElement]? = nil,
168+ listener: [Listener]? = nil,
169+ lupus: [LupusElement]? = nil,
170+ maslin: [Maslin]? = nil,
171+ monazite: [MonaziteElement]? = nil,
172+ monoliteral: [Monoliteral]? = nil,
173+ monotheistically: [MonotheisticallyElement]? = nil,
174+ montage: [Montage]? = nil,
175+ moralness: [Moralness]? = nil,
176+ mowra: [MonaziteClass?]? = nil,
177+ mulishly: [Mulishly]? = nil,
178+ myoscope: [Myoscope]? = nil,
179+ nach: [[Int?]?]? = nil,
180+ neuromastic: [Neuromastic]? = nil,
181+ noncontributing: [Noncontributing]? = nil,
182+ nonnervous: [Nonnervous]? = nil,
183+ nonvaluation: [Nonvaluation]? = nil,
184+ occupationalist: [OccupationalistElement]? = nil,
185+ outrival: [OutrivalElement]? = nil,
186+ paleographically: [Paleographically]? = nil,
187+ pamphletwise: [Pamphletwise]? = nil,
188+ pediatrics: [Pediatric]? = nil,
189+ perceptive: [Bool]? = nil,
190+ piaculum: [PiaculumElement]? = nil,
191+ piccadilly: [Piccadilly]? = nil,
192+ piffler: [Piffler]? = nil,
193+ pithful: [Pithful]? = nil,
194+ placuntitis: [Placuntiti]? = nil,
195+ plectopterous: [Plectopterous]? = nil,
196+ pneumocele: [Pneumocele?]? = nil,
197+ poliorcetic: [Poliorcetic]? = nil,
198+ poormaster: [Poormaster]? = nil,
199+ potwhisky: [PotwhiskyElement]? = nil,
200+ practicalizer: [Practicalizer]? = nil,
201+ prefreshman: [PrefreshmanElement]? = nil,
202+ prehensility: [Prehensility]? = nil,
203+ prevoidance: [Prevoidance]? = nil,
204+ probant: [[String: Int?]]? = nil,
205+ protext: [Protext]? = nil
206+ ) -> TopLevel {
207+ return TopLevel(
208+ juror: juror ?? self.juror,
209+ kongoni: kongoni ?? self.kongoni,
210+ ladronism: ladronism ?? self.ladronism,
211+ landlubberly: landlubberly ?? self.landlubberly,
212+ listener: listener ?? self.listener,
213+ lupus: lupus ?? self.lupus,
214+ maslin: maslin ?? self.maslin,
215+ monazite: monazite ?? self.monazite,
216+ monoliteral: monoliteral ?? self.monoliteral,
217+ monotheistically: monotheistically ?? self.monotheistically,
218+ montage: montage ?? self.montage,
219+ moralness: moralness ?? self.moralness,
220+ mowra: mowra ?? self.mowra,
221+ mulishly: mulishly ?? self.mulishly,
222+ myoscope: myoscope ?? self.myoscope,
223+ nach: nach ?? self.nach,
224+ neuromastic: neuromastic ?? self.neuromastic,
225+ noncontributing: noncontributing ?? self.noncontributing,
226+ nonnervous: nonnervous ?? self.nonnervous,
227+ nonvaluation: nonvaluation ?? self.nonvaluation,
228+ occupationalist: occupationalist ?? self.occupationalist,
229+ outrival: outrival ?? self.outrival,
230+ paleographically: paleographically ?? self.paleographically,
231+ pamphletwise: pamphletwise ?? self.pamphletwise,
232+ pediatrics: pediatrics ?? self.pediatrics,
233+ perceptive: perceptive ?? self.perceptive,
234+ piaculum: piaculum ?? self.piaculum,
235+ piccadilly: piccadilly ?? self.piccadilly,
236+ piffler: piffler ?? self.piffler,
237+ pithful: pithful ?? self.pithful,
238+ placuntitis: placuntitis ?? self.placuntitis,
239+ plectopterous: plectopterous ?? self.plectopterous,
240+ pneumocele: pneumocele ?? self.pneumocele,
241+ poliorcetic: poliorcetic ?? self.poliorcetic,
242+ poormaster: poormaster ?? self.poormaster,
243+ potwhisky: potwhisky ?? self.potwhisky,
244+ practicalizer: practicalizer ?? self.practicalizer,
245+ prefreshman: prefreshman ?? self.prefreshman,
246+ prehensility: prehensility ?? self.prehensility,
247+ prevoidance: prevoidance ?? self.prevoidance,
248+ probant: probant ?? self.probant,
249+ protext: protext ?? self.protext
250+ )
251+ }
252+
253+ func jsonData() throws -> Data {
254+ return try newJSONEncoder().encode(self)
255+ }
256+
257+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
258+ return String(data: try self.jsonData(), encoding: encoding)
259+ }
260+}
261+
262+enum JurorElement: Codable {
263+ case bool(Bool)
264+ case jurorClass(JurorClass)
265+
266+ init(from decoder: Decoder) throws {
267+ let container = try decoder.singleValueContainer()
268+ if let x = try? container.decode(Bool.self) {
269+ self = .bool(x)
270+ return
271+ }
272+ if let x = try? container.decode(JurorClass.self) {
273+ self = .jurorClass(x)
274+ return
275+ }
276+ throw DecodingError.typeMismatch(JurorElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JurorElement"))
277+ }
278+
279+ func encode(to encoder: Encoder) throws {
280+ var container = encoder.singleValueContainer()
281+ switch self {
282+ case .bool(let x):
283+ try container.encode(x)
284+ case .jurorClass(let x):
285+ try container.encode(x)
286+ }
287+ }
288+}
289+
290+// MARK: - JurorClass
291+final class JurorClass: Codable {
292+ let adipsy: JSONNull?
293+ let auxiliator: JSONNull?
294+ let benda: JSONNull?
295+ let benjamin: JSONNull?
296+ let brandling: JSONNull?
297+ let epicurishly: JSONNull?
298+ let eremochaetous: JSONNull?
299+ let marten: JSONNull?
300+ let monocline: JSONNull?
301+ let olea: JSONNull?
302+ let palgat: JSONNull?
303+ let pennyworth: JSONNull?
304+ let pioury: JSONNull?
305+ let pragmatistic: JSONNull?
306+ let stylelessness: JSONNull?
307+ let systematical: JSONNull?
308+ let thready: JSONNull?
309+ let uncontemporary: JSONNull?
310+ let uncouched: JSONNull?
311+ let uninhabitedness: JSONNull?
312+
313+ enum CodingKeys: String, CodingKey {
314+ case adipsy = "adipsy"
315+ case auxiliator = "auxiliator"
316+ case benda = "benda"
317+ case benjamin = "benjamin"
318+ case brandling = "brandling"
319+ case epicurishly = "epicurishly"
320+ case eremochaetous = "eremochaetous"
321+ case marten = "marten"
322+ case monocline = "monocline"
323+ case olea = "Olea"
324+ case palgat = "palgat"
325+ case pennyworth = "pennyworth"
326+ case pioury = "pioury"
327+ case pragmatistic = "pragmatistic"
328+ case stylelessness = "stylelessness"
329+ case systematical = "systematical"
330+ case thready = "thready"
331+ case uncontemporary = "uncontemporary"
332+ case uncouched = "uncouched"
333+ case uninhabitedness = "uninhabitedness"
334+ }
335+
336+ 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?) {
337+ self.adipsy = adipsy
338+ self.auxiliator = auxiliator
339+ self.benda = benda
340+ self.benjamin = benjamin
341+ self.brandling = brandling
342+ self.epicurishly = epicurishly
343+ self.eremochaetous = eremochaetous
344+ self.marten = marten
345+ self.monocline = monocline
346+ self.olea = olea
347+ self.palgat = palgat
348+ self.pennyworth = pennyworth
349+ self.pioury = pioury
350+ self.pragmatistic = pragmatistic
351+ self.stylelessness = stylelessness
352+ self.systematical = systematical
353+ self.thready = thready
354+ self.uncontemporary = uncontemporary
355+ self.uncouched = uncouched
356+ self.uninhabitedness = uninhabitedness
357+ }
358+}
359+
360+// MARK: JurorClass convenience initializers and mutators
361+
362+extension JurorClass {
363+ convenience init(data: Data) throws {
364+ let me = try newJSONDecoder().decode(JurorClass.self, from: data)
365+ 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)
366+ }
367+
368+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
369+ guard let data = json.data(using: encoding) else {
370+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
371+ }
372+ try self.init(data: data)
373+ }
374+
375+ convenience init(fromURL url: URL) throws {
376+ try self.init(data: try Data(contentsOf: url))
377+ }
378+
379+ func with(
380+ adipsy: JSONNull?? = nil,
381+ auxiliator: JSONNull?? = nil,
382+ benda: JSONNull?? = nil,
383+ benjamin: JSONNull?? = nil,
384+ brandling: JSONNull?? = nil,
385+ epicurishly: JSONNull?? = nil,
386+ eremochaetous: JSONNull?? = nil,
387+ marten: JSONNull?? = nil,
388+ monocline: JSONNull?? = nil,
389+ olea: JSONNull?? = nil,
390+ palgat: JSONNull?? = nil,
391+ pennyworth: JSONNull?? = nil,
392+ pioury: JSONNull?? = nil,
393+ pragmatistic: JSONNull?? = nil,
394+ stylelessness: JSONNull?? = nil,
395+ systematical: JSONNull?? = nil,
396+ thready: JSONNull?? = nil,
397+ uncontemporary: JSONNull?? = nil,
398+ uncouched: JSONNull?? = nil,
399+ uninhabitedness: JSONNull?? = nil
400+ ) -> JurorClass {
401+ return JurorClass(
402+ adipsy: adipsy ?? self.adipsy,
403+ auxiliator: auxiliator ?? self.auxiliator,
404+ benda: benda ?? self.benda,
405+ benjamin: benjamin ?? self.benjamin,
406+ brandling: brandling ?? self.brandling,
407+ epicurishly: epicurishly ?? self.epicurishly,
408+ eremochaetous: eremochaetous ?? self.eremochaetous,
409+ marten: marten ?? self.marten,
410+ monocline: monocline ?? self.monocline,
411+ olea: olea ?? self.olea,
412+ palgat: palgat ?? self.palgat,
413+ pennyworth: pennyworth ?? self.pennyworth,
414+ pioury: pioury ?? self.pioury,
415+ pragmatistic: pragmatistic ?? self.pragmatistic,
416+ stylelessness: stylelessness ?? self.stylelessness,
417+ systematical: systematical ?? self.systematical,
418+ thready: thready ?? self.thready,
419+ uncontemporary: uncontemporary ?? self.uncontemporary,
420+ uncouched: uncouched ?? self.uncouched,
421+ uninhabitedness: uninhabitedness ?? self.uninhabitedness
422+ )
423+ }
424+
425+ func jsonData() throws -> Data {
426+ return try newJSONEncoder().encode(self)
427+ }
428+
429+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
430+ return String(data: try self.jsonData(), encoding: encoding)
431+ }
432+}
433+
434+enum Kongoni: Codable {
435+ case integerArray([Int])
436+ case integerMap([String: Int])
437+
438+ init(from decoder: Decoder) throws {
439+ let container = try decoder.singleValueContainer()
440+ if let x = try? container.decode([Int].self) {
441+ self = .integerArray(x)
442+ return
443+ }
444+ if let x = try? container.decode([String: Int].self) {
445+ self = .integerMap(x)
446+ return
447+ }
448+ throw DecodingError.typeMismatch(Kongoni.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Kongoni"))
449+ }
450+
451+ func encode(to encoder: Encoder) throws {
452+ var container = encoder.singleValueContainer()
453+ switch self {
454+ case .integerArray(let x):
455+ try container.encode(x)
456+ case .integerMap(let x):
457+ try container.encode(x)
458+ }
459+ }
460+}
461+
462+enum LadronismElement: Codable {
463+ case double(Double)
464+ case ladronismClass(LadronismClass)
465+ case string(String)
466+
467+ init(from decoder: Decoder) throws {
468+ let container = try decoder.singleValueContainer()
469+ if let x = try? container.decode(Double.self) {
470+ self = .double(x)
471+ return
472+ }
473+ if let x = try? container.decode(String.self) {
474+ self = .string(x)
475+ return
476+ }
477+ if let x = try? container.decode(LadronismClass.self) {
478+ self = .ladronismClass(x)
479+ return
480+ }
481+ throw DecodingError.typeMismatch(LadronismElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for LadronismElement"))
482+ }
483+
484+ func encode(to encoder: Encoder) throws {
485+ var container = encoder.singleValueContainer()
486+ switch self {
487+ case .double(let x):
488+ try container.encode(x)
489+ case .ladronismClass(let x):
490+ try container.encode(x)
491+ case .string(let x):
492+ try container.encode(x)
493+ }
494+ }
495+}
496+
497+// MARK: - LadronismClass
498+final class LadronismClass: Codable {
499+ let acclaimer: JSONNull?
500+ let achree: JSONNull?
501+ let base: JSONNull?
502+ let conundrumize: JSONNull?
503+ let degerminator: JSONNull?
504+ let describable: JSONNull?
505+ let exasperatedly: JSONNull?
506+ let heroine: JSONNull?
507+ let indazin: JSONNull?
508+ let luteous: JSONNull?
509+ let papular: JSONNull?
510+ let pritch: JSONNull?
511+ let prodenia: JSONNull?
512+ let seege: JSONNull?
513+ let shopgirl: JSONNull?
514+ let tragedietta: JSONNull?
515+ let unsparse: JSONNull?
516+ let uplook: JSONNull?
517+ let vermiformis: JSONNull?
518+ let whafabout: JSONNull?
519+
520+ enum CodingKeys: String, CodingKey {
521+ case acclaimer = "acclaimer"
522+ case achree = "achree"
523+ case base = "base"
524+ case conundrumize = "conundrumize"
525+ case degerminator = "degerminator"
526+ case describable = "describable"
527+ case exasperatedly = "exasperatedly"
528+ case heroine = "heroine"
529+ case indazin = "indazin"
530+ case luteous = "luteous"
531+ case papular = "papular"
532+ case pritch = "pritch"
533+ case prodenia = "Prodenia"
534+ case seege = "seege"
535+ case shopgirl = "shopgirl"
536+ case tragedietta = "tragedietta"
537+ case unsparse = "unsparse"
538+ case uplook = "uplook"
539+ case vermiformis = "vermiformis"
540+ case whafabout = "whafabout"
541+ }
542+
543+ 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?) {
544+ self.acclaimer = acclaimer
545+ self.achree = achree
546+ self.base = base
547+ self.conundrumize = conundrumize
548+ self.degerminator = degerminator
549+ self.describable = describable
550+ self.exasperatedly = exasperatedly
551+ self.heroine = heroine
552+ self.indazin = indazin
553+ self.luteous = luteous
554+ self.papular = papular
555+ self.pritch = pritch
556+ self.prodenia = prodenia
557+ self.seege = seege
558+ self.shopgirl = shopgirl
559+ self.tragedietta = tragedietta
560+ self.unsparse = unsparse
561+ self.uplook = uplook
562+ self.vermiformis = vermiformis
563+ self.whafabout = whafabout
564+ }
565+}
566+
567+// MARK: LadronismClass convenience initializers and mutators
568+
569+extension LadronismClass {
570+ convenience init(data: Data) throws {
571+ let me = try newJSONDecoder().decode(LadronismClass.self, from: data)
572+ 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)
573+ }
574+
575+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
576+ guard let data = json.data(using: encoding) else {
577+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
578+ }
579+ try self.init(data: data)
580+ }
581+
582+ convenience init(fromURL url: URL) throws {
583+ try self.init(data: try Data(contentsOf: url))
584+ }
585+
586+ func with(
587+ acclaimer: JSONNull?? = nil,
588+ achree: JSONNull?? = nil,
589+ base: JSONNull?? = nil,
590+ conundrumize: JSONNull?? = nil,
591+ degerminator: JSONNull?? = nil,
592+ describable: JSONNull?? = nil,
593+ exasperatedly: JSONNull?? = nil,
594+ heroine: JSONNull?? = nil,
595+ indazin: JSONNull?? = nil,
596+ luteous: JSONNull?? = nil,
597+ papular: JSONNull?? = nil,
598+ pritch: JSONNull?? = nil,
599+ prodenia: JSONNull?? = nil,
600+ seege: JSONNull?? = nil,
601+ shopgirl: JSONNull?? = nil,
602+ tragedietta: JSONNull?? = nil,
603+ unsparse: JSONNull?? = nil,
604+ uplook: JSONNull?? = nil,
605+ vermiformis: JSONNull?? = nil,
606+ whafabout: JSONNull?? = nil
607+ ) -> LadronismClass {
608+ return LadronismClass(
609+ acclaimer: acclaimer ?? self.acclaimer,
610+ achree: achree ?? self.achree,
611+ base: base ?? self.base,
612+ conundrumize: conundrumize ?? self.conundrumize,
613+ degerminator: degerminator ?? self.degerminator,
614+ describable: describable ?? self.describable,
615+ exasperatedly: exasperatedly ?? self.exasperatedly,
616+ heroine: heroine ?? self.heroine,
617+ indazin: indazin ?? self.indazin,
618+ luteous: luteous ?? self.luteous,
619+ papular: papular ?? self.papular,
620+ pritch: pritch ?? self.pritch,
621+ prodenia: prodenia ?? self.prodenia,
622+ seege: seege ?? self.seege,
623+ shopgirl: shopgirl ?? self.shopgirl,
624+ tragedietta: tragedietta ?? self.tragedietta,
625+ unsparse: unsparse ?? self.unsparse,
626+ uplook: uplook ?? self.uplook,
627+ vermiformis: vermiformis ?? self.vermiformis,
628+ whafabout: whafabout ?? self.whafabout
629+ )
630+ }
631+
632+ func jsonData() throws -> Data {
633+ return try newJSONEncoder().encode(self)
634+ }
635+
636+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
637+ return String(data: try self.jsonData(), encoding: encoding)
638+ }
639+}
640+
641+enum LandlubberlyElement: Codable {
642+ case bool(Bool)
643+ case integer(Int)
644+ case landlubberlyClass(LandlubberlyClass)
645+
646+ init(from decoder: Decoder) throws {
647+ let container = try decoder.singleValueContainer()
648+ if let x = try? container.decode(Bool.self) {
649+ self = .bool(x)
650+ return
651+ }
652+ if let x = try? container.decode(Int.self) {
653+ self = .integer(x)
654+ return
655+ }
656+ if let x = try? container.decode(LandlubberlyClass.self) {
657+ self = .landlubberlyClass(x)
658+ return
659+ }
660+ throw DecodingError.typeMismatch(LandlubberlyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for LandlubberlyElement"))
661+ }
662+
663+ func encode(to encoder: Encoder) throws {
664+ var container = encoder.singleValueContainer()
665+ switch self {
666+ case .bool(let x):
667+ try container.encode(x)
668+ case .integer(let x):
669+ try container.encode(x)
670+ case .landlubberlyClass(let x):
671+ try container.encode(x)
672+ }
673+ }
674+}
675+
676+// MARK: - LandlubberlyClass
677+final class LandlubberlyClass: Codable {
678+ let acropoleis: JSONNull?
679+ let aminate: JSONNull?
680+ let amyraldism: JSONNull?
681+ let bipenniform: JSONNull?
682+ let bugre: JSONNull?
683+ let calycule: JSONNull?
684+ let caoutchouc: JSONNull?
685+ let disprover: JSONNull?
686+ let fitroot: JSONNull?
687+ let fulgently: JSONNull?
688+ let kickup: JSONNull?
689+ let laevoversion: JSONNull?
690+ let moter: JSONNull?
691+ let objectivity: JSONNull?
692+ let posterity: JSONNull?
693+ let postnuptial: JSONNull?
694+ let precedentary: JSONNull?
695+ let saddling: JSONNull?
696+ let subcurrent: JSONNull?
697+ let unrecriminative: JSONNull?
698+
699+ enum CodingKeys: String, CodingKey {
700+ case acropoleis = "acropoleis"
701+ case aminate = "aminate"
702+ case amyraldism = "Amyraldism"
703+ case bipenniform = "bipenniform"
704+ case bugre = "bugre"
705+ case calycule = "calycule"
706+ case caoutchouc = "caoutchouc"
707+ case disprover = "disprover"
708+ case fitroot = "fitroot"
709+ case fulgently = "fulgently"
710+ case kickup = "kickup"
711+ case laevoversion = "laevoversion"
712+ case moter = "moter"
713+ case objectivity = "objectivity"
714+ case posterity = "posterity"
715+ case postnuptial = "postnuptial"
716+ case precedentary = "precedentary"
717+ case saddling = "saddling"
718+ case subcurrent = "subcurrent"
719+ case unrecriminative = "unrecriminative"
720+ }
721+
722+ 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?) {
723+ self.acropoleis = acropoleis
724+ self.aminate = aminate
725+ self.amyraldism = amyraldism
726+ self.bipenniform = bipenniform
727+ self.bugre = bugre
728+ self.calycule = calycule
729+ self.caoutchouc = caoutchouc
730+ self.disprover = disprover
731+ self.fitroot = fitroot
732+ self.fulgently = fulgently
733+ self.kickup = kickup
734+ self.laevoversion = laevoversion
735+ self.moter = moter
736+ self.objectivity = objectivity
737+ self.posterity = posterity
738+ self.postnuptial = postnuptial
739+ self.precedentary = precedentary
740+ self.saddling = saddling
741+ self.subcurrent = subcurrent
742+ self.unrecriminative = unrecriminative
743+ }
744+}
745+
746+// MARK: LandlubberlyClass convenience initializers and mutators
747+
748+extension LandlubberlyClass {
749+ convenience init(data: Data) throws {
750+ let me = try newJSONDecoder().decode(LandlubberlyClass.self, from: data)
751+ 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)
752+ }
753+
754+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
755+ guard let data = json.data(using: encoding) else {
756+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
757+ }
758+ try self.init(data: data)
759+ }
760+
761+ convenience init(fromURL url: URL) throws {
762+ try self.init(data: try Data(contentsOf: url))
763+ }
764+
765+ func with(
766+ acropoleis: JSONNull?? = nil,
767+ aminate: JSONNull?? = nil,
768+ amyraldism: JSONNull?? = nil,
769+ bipenniform: JSONNull?? = nil,
770+ bugre: JSONNull?? = nil,
771+ calycule: JSONNull?? = nil,
772+ caoutchouc: JSONNull?? = nil,
773+ disprover: JSONNull?? = nil,
774+ fitroot: JSONNull?? = nil,
775+ fulgently: JSONNull?? = nil,
776+ kickup: JSONNull?? = nil,
777+ laevoversion: JSONNull?? = nil,
778+ moter: JSONNull?? = nil,
779+ objectivity: JSONNull?? = nil,
780+ posterity: JSONNull?? = nil,
781+ postnuptial: JSONNull?? = nil,
782+ precedentary: JSONNull?? = nil,
783+ saddling: JSONNull?? = nil,
784+ subcurrent: JSONNull?? = nil,
785+ unrecriminative: JSONNull?? = nil
786+ ) -> LandlubberlyClass {
787+ return LandlubberlyClass(
788+ acropoleis: acropoleis ?? self.acropoleis,
789+ aminate: aminate ?? self.aminate,
790+ amyraldism: amyraldism ?? self.amyraldism,
791+ bipenniform: bipenniform ?? self.bipenniform,
792+ bugre: bugre ?? self.bugre,
793+ calycule: calycule ?? self.calycule,
794+ caoutchouc: caoutchouc ?? self.caoutchouc,
795+ disprover: disprover ?? self.disprover,
796+ fitroot: fitroot ?? self.fitroot,
797+ fulgently: fulgently ?? self.fulgently,
798+ kickup: kickup ?? self.kickup,
799+ laevoversion: laevoversion ?? self.laevoversion,
800+ moter: moter ?? self.moter,
801+ objectivity: objectivity ?? self.objectivity,
802+ posterity: posterity ?? self.posterity,
803+ postnuptial: postnuptial ?? self.postnuptial,
804+ precedentary: precedentary ?? self.precedentary,
805+ saddling: saddling ?? self.saddling,
806+ subcurrent: subcurrent ?? self.subcurrent,
807+ unrecriminative: unrecriminative ?? self.unrecriminative
808+ )
809+ }
810+
811+ func jsonData() throws -> Data {
812+ return try newJSONEncoder().encode(self)
813+ }
814+
815+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
816+ return String(data: try self.jsonData(), encoding: encoding)
817+ }
818+}
819+
820+enum Listener: Codable {
821+ case integer(Int)
822+ case nullArray([JSONNull?])
823+
824+ init(from decoder: Decoder) throws {
825+ let container = try decoder.singleValueContainer()
826+ if let x = try? container.decode(Int.self) {
827+ self = .integer(x)
828+ return
829+ }
830+ if let x = try? container.decode([JSONNull?].self) {
831+ self = .nullArray(x)
832+ return
833+ }
834+ throw DecodingError.typeMismatch(Listener.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Listener"))
835+ }
836+
837+ func encode(to encoder: Encoder) throws {
838+ var container = encoder.singleValueContainer()
839+ switch self {
840+ case .integer(let x):
841+ try container.encode(x)
842+ case .nullArray(let x):
843+ try container.encode(x)
844+ }
845+ }
846+}
847+
848+enum LupusElement: Codable {
849+ case integer(Int)
850+ case lupusClass(LupusClass)
851+
852+ init(from decoder: Decoder) throws {
853+ let container = try decoder.singleValueContainer()
854+ if let x = try? container.decode(Int.self) {
855+ self = .integer(x)
856+ return
857+ }
858+ if let x = try? container.decode(LupusClass.self) {
859+ self = .lupusClass(x)
860+ return
861+ }
862+ throw DecodingError.typeMismatch(LupusElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for LupusElement"))
863+ }
864+
865+ func encode(to encoder: Encoder) throws {
866+ var container = encoder.singleValueContainer()
867+ switch self {
868+ case .integer(let x):
869+ try container.encode(x)
870+ case .lupusClass(let x):
871+ try container.encode(x)
872+ }
873+ }
874+}
875+
876+// MARK: - LupusClass
877+final class LupusClass: Codable {
878+ let catharticalness: Double?
879+ let chirotherium: Int?
880+ let chlorioninae: Int?
881+ let corvinae: Int?
882+ let crassina: Int?
883+ let disdiapason: String?
884+ let exiguity: Int?
885+ let farcist: Int?
886+ let holographical: Int?
887+ let homocerc: Bool?
888+ let ichthyophagan: Int?
889+ let implacable: Int?
890+ let nonbookish: JSONNull?
891+ let outshiner: Int?
892+ let overweather: Int?
893+ let protonegroid: Int?
894+ let shallowish: Int?
895+ let snoke: Int?
896+ let snout: Int?
897+ let surveillance: Int?
898+ let threshingtime: Int?
899+ let thysanocarpus: Int?
900+ let unsignificantly: Int?
901+ let unsnap: Int?
902+ let vendible: Int?
903+
904+ enum CodingKeys: String, CodingKey {
905+ case catharticalness = "catharticalness"
906+ case chirotherium = "Chirotherium"
907+ case chlorioninae = "Chlorioninae"
908+ case corvinae = "Corvinae"
909+ case crassina = "Crassina"
910+ case disdiapason = "disdiapason"
911+ case exiguity = "exiguity"
912+ case farcist = "farcist"
913+ case holographical = "holographical"
914+ case homocerc = "homocerc"
915+ case ichthyophagan = "ichthyophagan"
916+ case implacable = "implacable"
917+ case nonbookish = "nonbookish"
918+ case outshiner = "outshiner"
919+ case overweather = "overweather"
920+ case protonegroid = "protonegroid"
921+ case shallowish = "shallowish"
922+ case snoke = "snoke"
923+ case snout = "snout"
924+ case surveillance = "surveillance"
925+ case threshingtime = "threshingtime"
926+ case thysanocarpus = "Thysanocarpus"
927+ case unsignificantly = "unsignificantly"
928+ case unsnap = "unsnap"
929+ case vendible = "vendible"
930+ }
931+
932+ 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?) {
933+ self.catharticalness = catharticalness
934+ self.chirotherium = chirotherium
935+ self.chlorioninae = chlorioninae
936+ self.corvinae = corvinae
937+ self.crassina = crassina
938+ self.disdiapason = disdiapason
939+ self.exiguity = exiguity
940+ self.farcist = farcist
941+ self.holographical = holographical
942+ self.homocerc = homocerc
943+ self.ichthyophagan = ichthyophagan
944+ self.implacable = implacable
945+ self.nonbookish = nonbookish
946+ self.outshiner = outshiner
947+ self.overweather = overweather
948+ self.protonegroid = protonegroid
949+ self.shallowish = shallowish
950+ self.snoke = snoke
951+ self.snout = snout
952+ self.surveillance = surveillance
953+ self.threshingtime = threshingtime
954+ self.thysanocarpus = thysanocarpus
955+ self.unsignificantly = unsignificantly
956+ self.unsnap = unsnap
957+ self.vendible = vendible
958+ }
959+}
960+
961+// MARK: LupusClass convenience initializers and mutators
962+
963+extension LupusClass {
964+ convenience init(data: Data) throws {
965+ let me = try newJSONDecoder().decode(LupusClass.self, from: data)
966+ 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)
967+ }
968+
969+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
970+ guard let data = json.data(using: encoding) else {
971+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
972+ }
973+ try self.init(data: data)
974+ }
975+
976+ convenience init(fromURL url: URL) throws {
977+ try self.init(data: try Data(contentsOf: url))
978+ }
979+
980+ func with(
981+ catharticalness: Double?? = nil,
982+ chirotherium: Int?? = nil,
983+ chlorioninae: Int?? = nil,
984+ corvinae: Int?? = nil,
985+ crassina: Int?? = nil,
986+ disdiapason: String?? = nil,
987+ exiguity: Int?? = nil,
988+ farcist: Int?? = nil,
989+ holographical: Int?? = nil,
990+ homocerc: Bool?? = nil,
991+ ichthyophagan: Int?? = nil,
992+ implacable: Int?? = nil,
993+ nonbookish: JSONNull?? = nil,
994+ outshiner: Int?? = nil,
995+ overweather: Int?? = nil,
996+ protonegroid: Int?? = nil,
997+ shallowish: Int?? = nil,
998+ snoke: Int?? = nil,
999+ snout: Int?? = nil,
1000+ surveillance: Int?? = nil,
1001+ threshingtime: Int?? = nil,
1002+ thysanocarpus: Int?? = nil,
1003+ unsignificantly: Int?? = nil,
1004+ unsnap: Int?? = nil,
1005+ vendible: Int?? = nil
1006+ ) -> LupusClass {
1007+ return LupusClass(
1008+ catharticalness: catharticalness ?? self.catharticalness,
1009+ chirotherium: chirotherium ?? self.chirotherium,
1010+ chlorioninae: chlorioninae ?? self.chlorioninae,
1011+ corvinae: corvinae ?? self.corvinae,
1012+ crassina: crassina ?? self.crassina,
1013+ disdiapason: disdiapason ?? self.disdiapason,
1014+ exiguity: exiguity ?? self.exiguity,
1015+ farcist: farcist ?? self.farcist,
1016+ holographical: holographical ?? self.holographical,
1017+ homocerc: homocerc ?? self.homocerc,
1018+ ichthyophagan: ichthyophagan ?? self.ichthyophagan,
1019+ implacable: implacable ?? self.implacable,
1020+ nonbookish: nonbookish ?? self.nonbookish,
1021+ outshiner: outshiner ?? self.outshiner,
1022+ overweather: overweather ?? self.overweather,
1023+ protonegroid: protonegroid ?? self.protonegroid,
1024+ shallowish: shallowish ?? self.shallowish,
1025+ snoke: snoke ?? self.snoke,
1026+ snout: snout ?? self.snout,
1027+ surveillance: surveillance ?? self.surveillance,
1028+ threshingtime: threshingtime ?? self.threshingtime,
1029+ thysanocarpus: thysanocarpus ?? self.thysanocarpus,
1030+ unsignificantly: unsignificantly ?? self.unsignificantly,
1031+ unsnap: unsnap ?? self.unsnap,
1032+ vendible: vendible ?? self.vendible
1033+ )
1034+ }
1035+
1036+ func jsonData() throws -> Data {
1037+ return try newJSONEncoder().encode(self)
1038+ }
1039+
1040+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1041+ return String(data: try self.jsonData(), encoding: encoding)
1042+ }
1043+}
1044+
1045+// MARK: - Maslin
1046+final class Maslin: Codable {
1047+ let alicant: Int?
1048+ let antiatonement: JSONNull?
1049+ let anticorrosive: Int?
1050+ let aphidozer: JSONNull?
1051+ let bakuninist: JSONNull?
1052+ let be: Int?
1053+ let catharticalness: Double?
1054+ let chirotherium: Int?
1055+ let chub: Int?
1056+ let cuprosilicon: Int?
1057+ let curtailedly: Int?
1058+ let dellenite: Int?
1059+ let dimitry: Int?
1060+ let disdiapason: String?
1061+ let edifying: JSONNull?
1062+ let ethmoiditis: Int?
1063+ let gastralgy: JSONNull?
1064+ let goatherd: Int?
1065+ let hammerdress: Int?
1066+ let hangfire: JSONNull?
1067+ let homocerc: Bool?
1068+ let lacunosity: Int?
1069+ let longiloquence: JSONNull?
1070+ let mameliere: Int?
1071+ let motherless: JSONNull?
1072+ let nonbookish: JSONNull?
1073+ let noncorrodible: JSONNull?
1074+ let nonsensicality: JSONNull?
1075+ let oafishly: Int?
1076+ let pfund: JSONNull?
1077+ let preadvisory: JSONNull?
1078+ let retroflexed: JSONNull?
1079+ let saccharulmic: Int?
1080+ let scowlful: Int?
1081+ let secluded: JSONNull?
1082+ let slackage: JSONNull?
1083+ let sphaeridial: Int?
1084+ let spondulics: JSONNull?
1085+ let subsecive: Int?
1086+ let swellmobsman: JSONNull?
1087+ let trachyglossate: Int?
1088+ let trialogue: JSONNull?
1089+ let unassuaged: Int?
1090+ let ungross: JSONNull?
1091+ let unjudiciously: JSONNull?
1092+
1093+ enum CodingKeys: String, CodingKey {
1094+ case alicant = "Alicant"
1095+ case antiatonement = "antiatonement"
1096+ case anticorrosive = "anticorrosive"
1097+ case aphidozer = "aphidozer"
1098+ case bakuninist = "Bakuninist"
1099+ case be = "be"
1100+ case catharticalness = "catharticalness"
1101+ case chirotherium = "Chirotherium"
1102+ case chub = "chub"
1103+ case cuprosilicon = "cuprosilicon"
1104+ case curtailedly = "curtailedly"
1105+ case dellenite = "dellenite"
1106+ case dimitry = "Dimitry"
1107+ case disdiapason = "disdiapason"
1108+ case edifying = "edifying"
1109+ case ethmoiditis = "ethmoiditis"
1110+ case gastralgy = "gastralgy"
1111+ case goatherd = "goatherd"
1112+ case hammerdress = "hammerdress"
1113+ case hangfire = "hangfire"
1114+ case homocerc = "homocerc"
1115+ case lacunosity = "lacunosity"
1116+ case longiloquence = "longiloquence"
1117+ case mameliere = "mameliere"
1118+ case motherless = "motherless"
1119+ case nonbookish = "nonbookish"
1120+ case noncorrodible = "noncorrodible"
1121+ case nonsensicality = "nonsensicality"
1122+ case oafishly = "oafishly"
1123+ case pfund = "pfund"
1124+ case preadvisory = "preadvisory"
1125+ case retroflexed = "retroflexed"
1126+ case saccharulmic = "saccharulmic"
1127+ case scowlful = "scowlful"
1128+ case secluded = "secluded"
1129+ case slackage = "slackage"
1130+ case sphaeridial = "sphaeridial"
1131+ case spondulics = "spondulics"
1132+ case subsecive = "subsecive"
1133+ case swellmobsman = "swellmobsman"
1134+ case trachyglossate = "trachyglossate"
1135+ case trialogue = "trialogue"
1136+ case unassuaged = "unassuaged"
1137+ case ungross = "ungross"
1138+ case unjudiciously = "unjudiciously"
1139+ }
1140+
1141+ 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?) {
1142+ self.alicant = alicant
1143+ self.antiatonement = antiatonement
1144+ self.anticorrosive = anticorrosive
1145+ self.aphidozer = aphidozer
1146+ self.bakuninist = bakuninist
1147+ self.be = be
1148+ self.catharticalness = catharticalness
1149+ self.chirotherium = chirotherium
1150+ self.chub = chub
1151+ self.cuprosilicon = cuprosilicon
1152+ self.curtailedly = curtailedly
1153+ self.dellenite = dellenite
1154+ self.dimitry = dimitry
1155+ self.disdiapason = disdiapason
1156+ self.edifying = edifying
1157+ self.ethmoiditis = ethmoiditis
1158+ self.gastralgy = gastralgy
1159+ self.goatherd = goatherd
1160+ self.hammerdress = hammerdress
1161+ self.hangfire = hangfire
1162+ self.homocerc = homocerc
1163+ self.lacunosity = lacunosity
1164+ self.longiloquence = longiloquence
1165+ self.mameliere = mameliere
1166+ self.motherless = motherless
1167+ self.nonbookish = nonbookish
1168+ self.noncorrodible = noncorrodible
1169+ self.nonsensicality = nonsensicality
1170+ self.oafishly = oafishly
1171+ self.pfund = pfund
1172+ self.preadvisory = preadvisory
1173+ self.retroflexed = retroflexed
1174+ self.saccharulmic = saccharulmic
1175+ self.scowlful = scowlful
1176+ self.secluded = secluded
1177+ self.slackage = slackage
1178+ self.sphaeridial = sphaeridial
1179+ self.spondulics = spondulics
1180+ self.subsecive = subsecive
1181+ self.swellmobsman = swellmobsman
1182+ self.trachyglossate = trachyglossate
1183+ self.trialogue = trialogue
1184+ self.unassuaged = unassuaged
1185+ self.ungross = ungross
1186+ self.unjudiciously = unjudiciously
1187+ }
1188+}
1189+
1190+// MARK: Maslin convenience initializers and mutators
1191+
1192+extension Maslin {
1193+ convenience init(data: Data) throws {
1194+ let me = try newJSONDecoder().decode(Maslin.self, from: data)
1195+ 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)
1196+ }
1197+
1198+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1199+ guard let data = json.data(using: encoding) else {
1200+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1201+ }
1202+ try self.init(data: data)
1203+ }
1204+
1205+ convenience init(fromURL url: URL) throws {
1206+ try self.init(data: try Data(contentsOf: url))
1207+ }
1208+
1209+ func with(
1210+ alicant: Int?? = nil,
1211+ antiatonement: JSONNull?? = nil,
1212+ anticorrosive: Int?? = nil,
1213+ aphidozer: JSONNull?? = nil,
1214+ bakuninist: JSONNull?? = nil,
1215+ be: Int?? = nil,
1216+ catharticalness: Double?? = nil,
1217+ chirotherium: Int?? = nil,
1218+ chub: Int?? = nil,
1219+ cuprosilicon: Int?? = nil,
1220+ curtailedly: Int?? = nil,
1221+ dellenite: Int?? = nil,
1222+ dimitry: Int?? = nil,
1223+ disdiapason: String?? = nil,
1224+ edifying: JSONNull?? = nil,
1225+ ethmoiditis: Int?? = nil,
1226+ gastralgy: JSONNull?? = nil,
1227+ goatherd: Int?? = nil,
1228+ hammerdress: Int?? = nil,
1229+ hangfire: JSONNull?? = nil,
1230+ homocerc: Bool?? = nil,
1231+ lacunosity: Int?? = nil,
1232+ longiloquence: JSONNull?? = nil,
1233+ mameliere: Int?? = nil,
1234+ motherless: JSONNull?? = nil,
1235+ nonbookish: JSONNull?? = nil,
1236+ noncorrodible: JSONNull?? = nil,
1237+ nonsensicality: JSONNull?? = nil,
1238+ oafishly: Int?? = nil,
1239+ pfund: JSONNull?? = nil,
1240+ preadvisory: JSONNull?? = nil,
1241+ retroflexed: JSONNull?? = nil,
1242+ saccharulmic: Int?? = nil,
1243+ scowlful: Int?? = nil,
1244+ secluded: JSONNull?? = nil,
1245+ slackage: JSONNull?? = nil,
1246+ sphaeridial: Int?? = nil,
1247+ spondulics: JSONNull?? = nil,
1248+ subsecive: Int?? = nil,
1249+ swellmobsman: JSONNull?? = nil,
1250+ trachyglossate: Int?? = nil,
1251+ trialogue: JSONNull?? = nil,
1252+ unassuaged: Int?? = nil,
1253+ ungross: JSONNull?? = nil,
1254+ unjudiciously: JSONNull?? = nil
1255+ ) -> Maslin {
1256+ return Maslin(
1257+ alicant: alicant ?? self.alicant,
1258+ antiatonement: antiatonement ?? self.antiatonement,
1259+ anticorrosive: anticorrosive ?? self.anticorrosive,
1260+ aphidozer: aphidozer ?? self.aphidozer,
1261+ bakuninist: bakuninist ?? self.bakuninist,
1262+ be: be ?? self.be,
1263+ catharticalness: catharticalness ?? self.catharticalness,
1264+ chirotherium: chirotherium ?? self.chirotherium,
1265+ chub: chub ?? self.chub,
1266+ cuprosilicon: cuprosilicon ?? self.cuprosilicon,
1267+ curtailedly: curtailedly ?? self.curtailedly,
1268+ dellenite: dellenite ?? self.dellenite,
1269+ dimitry: dimitry ?? self.dimitry,
1270+ disdiapason: disdiapason ?? self.disdiapason,
1271+ edifying: edifying ?? self.edifying,
1272+ ethmoiditis: ethmoiditis ?? self.ethmoiditis,
1273+ gastralgy: gastralgy ?? self.gastralgy,
1274+ goatherd: goatherd ?? self.goatherd,
1275+ hammerdress: hammerdress ?? self.hammerdress,
1276+ hangfire: hangfire ?? self.hangfire,
1277+ homocerc: homocerc ?? self.homocerc,
1278+ lacunosity: lacunosity ?? self.lacunosity,
1279+ longiloquence: longiloquence ?? self.longiloquence,
1280+ mameliere: mameliere ?? self.mameliere,
1281+ motherless: motherless ?? self.motherless,
1282+ nonbookish: nonbookish ?? self.nonbookish,
1283+ noncorrodible: noncorrodible ?? self.noncorrodible,
1284+ nonsensicality: nonsensicality ?? self.nonsensicality,
1285+ oafishly: oafishly ?? self.oafishly,
1286+ pfund: pfund ?? self.pfund,
1287+ preadvisory: preadvisory ?? self.preadvisory,
1288+ retroflexed: retroflexed ?? self.retroflexed,
1289+ saccharulmic: saccharulmic ?? self.saccharulmic,
1290+ scowlful: scowlful ?? self.scowlful,
1291+ secluded: secluded ?? self.secluded,
1292+ slackage: slackage ?? self.slackage,
1293+ sphaeridial: sphaeridial ?? self.sphaeridial,
1294+ spondulics: spondulics ?? self.spondulics,
1295+ subsecive: subsecive ?? self.subsecive,
1296+ swellmobsman: swellmobsman ?? self.swellmobsman,
1297+ trachyglossate: trachyglossate ?? self.trachyglossate,
1298+ trialogue: trialogue ?? self.trialogue,
1299+ unassuaged: unassuaged ?? self.unassuaged,
1300+ ungross: ungross ?? self.ungross,
1301+ unjudiciously: unjudiciously ?? self.unjudiciously
1302+ )
1303+ }
1304+
1305+ func jsonData() throws -> Data {
1306+ return try newJSONEncoder().encode(self)
1307+ }
1308+
1309+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1310+ return String(data: try self.jsonData(), encoding: encoding)
1311+ }
1312+}
1313+
1314+enum MonaziteElement: Codable {
1315+ case double(Double)
1316+ case monaziteClass(MonaziteClass)
1317+
1318+ init(from decoder: Decoder) throws {
1319+ let container = try decoder.singleValueContainer()
1320+ if let x = try? container.decode(Double.self) {
1321+ self = .double(x)
1322+ return
1323+ }
1324+ if let x = try? container.decode(MonaziteClass.self) {
1325+ self = .monaziteClass(x)
1326+ return
1327+ }
1328+ throw DecodingError.typeMismatch(MonaziteElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for MonaziteElement"))
1329+ }
1330+
1331+ func encode(to encoder: Encoder) throws {
1332+ var container = encoder.singleValueContainer()
1333+ switch self {
1334+ case .double(let x):
1335+ try container.encode(x)
1336+ case .monaziteClass(let x):
1337+ try container.encode(x)
1338+ }
1339+ }
1340+}
1341+
1342+// MARK: - MonaziteClass
1343+final class MonaziteClass: Codable {
1344+ let catharticalness: Double
1345+ let chirotherium: Int
1346+ let disdiapason: String
1347+ let homocerc: Bool
1348+ let nonbookish: JSONNull?
1349+
1350+ enum CodingKeys: String, CodingKey {
1351+ case catharticalness = "catharticalness"
1352+ case chirotherium = "Chirotherium"
1353+ case disdiapason = "disdiapason"
1354+ case homocerc = "homocerc"
1355+ case nonbookish = "nonbookish"
1356+ }
1357+
1358+ init(catharticalness: Double, chirotherium: Int, disdiapason: String, homocerc: Bool, nonbookish: JSONNull?) {
1359+ self.catharticalness = catharticalness
1360+ self.chirotherium = chirotherium
1361+ self.disdiapason = disdiapason
1362+ self.homocerc = homocerc
1363+ self.nonbookish = nonbookish
1364+ }
1365+}
1366+
1367+// MARK: MonaziteClass convenience initializers and mutators
1368+
1369+extension MonaziteClass {
1370+ convenience init(data: Data) throws {
1371+ let me = try newJSONDecoder().decode(MonaziteClass.self, from: data)
1372+ self.init(catharticalness: me.catharticalness, chirotherium: me.chirotherium, disdiapason: me.disdiapason, homocerc: me.homocerc, nonbookish: me.nonbookish)
1373+ }
1374+
1375+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1376+ guard let data = json.data(using: encoding) else {
1377+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1378+ }
1379+ try self.init(data: data)
1380+ }
1381+
1382+ convenience init(fromURL url: URL) throws {
1383+ try self.init(data: try Data(contentsOf: url))
1384+ }
1385+
1386+ func with(
1387+ catharticalness: Double? = nil,
1388+ chirotherium: Int? = nil,
1389+ disdiapason: String? = nil,
1390+ homocerc: Bool? = nil,
1391+ nonbookish: JSONNull?? = nil
1392+ ) -> MonaziteClass {
1393+ return MonaziteClass(
1394+ catharticalness: catharticalness ?? self.catharticalness,
1395+ chirotherium: chirotherium ?? self.chirotherium,
1396+ disdiapason: disdiapason ?? self.disdiapason,
1397+ homocerc: homocerc ?? self.homocerc,
1398+ nonbookish: nonbookish ?? self.nonbookish
1399+ )
1400+ }
1401+
1402+ func jsonData() throws -> Data {
1403+ return try newJSONEncoder().encode(self)
1404+ }
1405+
1406+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1407+ return String(data: try self.jsonData(), encoding: encoding)
1408+ }
1409+}
1410+
1411+enum Monoliteral: Codable {
1412+ case bool(Bool)
1413+ case nullArray([JSONNull?])
1414+
1415+ init(from decoder: Decoder) throws {
1416+ let container = try decoder.singleValueContainer()
1417+ if let x = try? container.decode(Bool.self) {
1418+ self = .bool(x)
1419+ return
1420+ }
1421+ if let x = try? container.decode([JSONNull?].self) {
1422+ self = .nullArray(x)
1423+ return
1424+ }
1425+ throw DecodingError.typeMismatch(Monoliteral.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Monoliteral"))
1426+ }
1427+
1428+ func encode(to encoder: Encoder) throws {
1429+ var container = encoder.singleValueContainer()
1430+ switch self {
1431+ case .bool(let x):
1432+ try container.encode(x)
1433+ case .nullArray(let x):
1434+ try container.encode(x)
1435+ }
1436+ }
1437+}
1438+
1439+enum MonotheisticallyElement: Codable {
1440+ case monotheisticallyClass(MonotheisticallyClass)
1441+ case nullArray([JSONNull?])
1442+
1443+ init(from decoder: Decoder) throws {
1444+ let container = try decoder.singleValueContainer()
1445+ if let x = try? container.decode([JSONNull?].self) {
1446+ self = .nullArray(x)
1447+ return
1448+ }
1449+ if let x = try? container.decode(MonotheisticallyClass.self) {
1450+ self = .monotheisticallyClass(x)
1451+ return
1452+ }
1453+ throw DecodingError.typeMismatch(MonotheisticallyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for MonotheisticallyElement"))
1454+ }
1455+
1456+ func encode(to encoder: Encoder) throws {
1457+ var container = encoder.singleValueContainer()
1458+ switch self {
1459+ case .monotheisticallyClass(let x):
1460+ try container.encode(x)
1461+ case .nullArray(let x):
1462+ try container.encode(x)
1463+ }
1464+ }
1465+}
1466+
1467+// MARK: - MonotheisticallyClass
1468+final class MonotheisticallyClass: Codable {
1469+ let blaspheme: JSONNull?
1470+ let catharticalness: Double?
1471+ let celiosalpingectomy: JSONNull?
1472+ let chirotherium: Int?
1473+ let consummativeness: JSONNull?
1474+ let disdiapason: String?
1475+ let egestive: JSONNull?
1476+ let enchylema: JSONNull?
1477+ let gasconade: JSONNull?
1478+ let holidayer: JSONNull?
1479+ let homocerc: Bool?
1480+ let intuitionalism: JSONNull?
1481+ let lophiostomate: JSONNull?
1482+ let nonbookish: JSONNull?
1483+ let nonvolition: JSONNull?
1484+ let palatableness: JSONNull?
1485+ let pimpery: JSONNull?
1486+ let previolation: JSONNull?
1487+ let reconveyance: JSONNull?
1488+ let registership: JSONNull?
1489+ let rhyacolite: JSONNull?
1490+ let smithereens: JSONNull?
1491+ let superedification: JSONNull?
1492+ let trust: JSONNull?
1493+ let whitestone: JSONNull?
1494+
1495+ enum CodingKeys: String, CodingKey {
1496+ case blaspheme = "blaspheme"
1497+ case catharticalness = "catharticalness"
1498+ case celiosalpingectomy = "celiosalpingectomy"
1499+ case chirotherium = "Chirotherium"
1500+ case consummativeness = "consummativeness"
1501+ case disdiapason = "disdiapason"
1502+ case egestive = "egestive"
1503+ case enchylema = "enchylema"
1504+ case gasconade = "gasconade"
1505+ case holidayer = "holidayer"
1506+ case homocerc = "homocerc"
1507+ case intuitionalism = "intuitionalism"
1508+ case lophiostomate = "lophiostomate"
1509+ case nonbookish = "nonbookish"
1510+ case nonvolition = "nonvolition"
1511+ case palatableness = "palatableness"
1512+ case pimpery = "pimpery"
1513+ case previolation = "previolation"
1514+ case reconveyance = "reconveyance"
1515+ case registership = "registership"
1516+ case rhyacolite = "rhyacolite"
1517+ case smithereens = "smithereens"
1518+ case superedification = "superedification"
1519+ case trust = "trust"
1520+ case whitestone = "whitestone"
1521+ }
1522+
1523+ 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?) {
1524+ self.blaspheme = blaspheme
1525+ self.catharticalness = catharticalness
1526+ self.celiosalpingectomy = celiosalpingectomy
1527+ self.chirotherium = chirotherium
1528+ self.consummativeness = consummativeness
1529+ self.disdiapason = disdiapason
1530+ self.egestive = egestive
1531+ self.enchylema = enchylema
1532+ self.gasconade = gasconade
1533+ self.holidayer = holidayer
1534+ self.homocerc = homocerc
1535+ self.intuitionalism = intuitionalism
1536+ self.lophiostomate = lophiostomate
1537+ self.nonbookish = nonbookish
1538+ self.nonvolition = nonvolition
1539+ self.palatableness = palatableness
1540+ self.pimpery = pimpery
1541+ self.previolation = previolation
1542+ self.reconveyance = reconveyance
1543+ self.registership = registership
1544+ self.rhyacolite = rhyacolite
1545+ self.smithereens = smithereens
1546+ self.superedification = superedification
1547+ self.trust = trust
1548+ self.whitestone = whitestone
1549+ }
1550+}
1551+
1552+// MARK: MonotheisticallyClass convenience initializers and mutators
1553+
1554+extension MonotheisticallyClass {
1555+ convenience init(data: Data) throws {
1556+ let me = try newJSONDecoder().decode(MonotheisticallyClass.self, from: data)
1557+ 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)
1558+ }
1559+
1560+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1561+ guard let data = json.data(using: encoding) else {
1562+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1563+ }
1564+ try self.init(data: data)
1565+ }
1566+
1567+ convenience init(fromURL url: URL) throws {
1568+ try self.init(data: try Data(contentsOf: url))
1569+ }
1570+
1571+ func with(
1572+ blaspheme: JSONNull?? = nil,
1573+ catharticalness: Double?? = nil,
1574+ celiosalpingectomy: JSONNull?? = nil,
1575+ chirotherium: Int?? = nil,
1576+ consummativeness: JSONNull?? = nil,
1577+ disdiapason: String?? = nil,
1578+ egestive: JSONNull?? = nil,
1579+ enchylema: JSONNull?? = nil,
1580+ gasconade: JSONNull?? = nil,
1581+ holidayer: JSONNull?? = nil,
1582+ homocerc: Bool?? = nil,
1583+ intuitionalism: JSONNull?? = nil,
1584+ lophiostomate: JSONNull?? = nil,
1585+ nonbookish: JSONNull?? = nil,
1586+ nonvolition: JSONNull?? = nil,
1587+ palatableness: JSONNull?? = nil,
1588+ pimpery: JSONNull?? = nil,
1589+ previolation: JSONNull?? = nil,
1590+ reconveyance: JSONNull?? = nil,
1591+ registership: JSONNull?? = nil,
1592+ rhyacolite: JSONNull?? = nil,
1593+ smithereens: JSONNull?? = nil,
1594+ superedification: JSONNull?? = nil,
1595+ trust: JSONNull?? = nil,
1596+ whitestone: JSONNull?? = nil
1597+ ) -> MonotheisticallyClass {
1598+ return MonotheisticallyClass(
1599+ blaspheme: blaspheme ?? self.blaspheme,
1600+ catharticalness: catharticalness ?? self.catharticalness,
1601+ celiosalpingectomy: celiosalpingectomy ?? self.celiosalpingectomy,
1602+ chirotherium: chirotherium ?? self.chirotherium,
1603+ consummativeness: consummativeness ?? self.consummativeness,
1604+ disdiapason: disdiapason ?? self.disdiapason,
1605+ egestive: egestive ?? self.egestive,
1606+ enchylema: enchylema ?? self.enchylema,
1607+ gasconade: gasconade ?? self.gasconade,
1608+ holidayer: holidayer ?? self.holidayer,
1609+ homocerc: homocerc ?? self.homocerc,
1610+ intuitionalism: intuitionalism ?? self.intuitionalism,
1611+ lophiostomate: lophiostomate ?? self.lophiostomate,
1612+ nonbookish: nonbookish ?? self.nonbookish,
1613+ nonvolition: nonvolition ?? self.nonvolition,
1614+ palatableness: palatableness ?? self.palatableness,
1615+ pimpery: pimpery ?? self.pimpery,
1616+ previolation: previolation ?? self.previolation,
1617+ reconveyance: reconveyance ?? self.reconveyance,
1618+ registership: registership ?? self.registership,
1619+ rhyacolite: rhyacolite ?? self.rhyacolite,
1620+ smithereens: smithereens ?? self.smithereens,
1621+ superedification: superedification ?? self.superedification,
1622+ trust: trust ?? self.trust,
1623+ whitestone: whitestone ?? self.whitestone
1624+ )
1625+ }
1626+
1627+ func jsonData() throws -> Data {
1628+ return try newJSONEncoder().encode(self)
1629+ }
1630+
1631+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1632+ return String(data: try self.jsonData(), encoding: encoding)
1633+ }
1634+}
1635+
1636+enum Montage: Codable {
1637+ case double(Double)
1638+ case nullArray([JSONNull?])
1639+ case string(String)
1640+
1641+ init(from decoder: Decoder) throws {
1642+ let container = try decoder.singleValueContainer()
1643+ if let x = try? container.decode([JSONNull?].self) {
1644+ self = .nullArray(x)
1645+ return
1646+ }
1647+ if let x = try? container.decode(Double.self) {
1648+ self = .double(x)
1649+ return
1650+ }
1651+ if let x = try? container.decode(String.self) {
1652+ self = .string(x)
1653+ return
1654+ }
1655+ throw DecodingError.typeMismatch(Montage.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Montage"))
1656+ }
1657+
1658+ func encode(to encoder: Encoder) throws {
1659+ var container = encoder.singleValueContainer()
1660+ switch self {
1661+ case .double(let x):
1662+ try container.encode(x)
1663+ case .nullArray(let x):
1664+ try container.encode(x)
1665+ case .string(let x):
1666+ try container.encode(x)
1667+ }
1668+ }
1669+}
1670+
1671+enum Moralness: Codable {
1672+ case double(Double)
1673+ case nullArray([JSONNull?])
1674+ case null
1675+
1676+ init(from decoder: Decoder) throws {
1677+ let container = try decoder.singleValueContainer()
1678+ if let x = try? container.decode([JSONNull?].self) {
1679+ self = .nullArray(x)
1680+ return
1681+ }
1682+ if let x = try? container.decode(Double.self) {
1683+ self = .double(x)
1684+ return
1685+ }
1686+ if container.decodeNil() {
1687+ self = .null
1688+ return
1689+ }
1690+ throw DecodingError.typeMismatch(Moralness.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Moralness"))
1691+ }
1692+
1693+ func encode(to encoder: Encoder) throws {
1694+ var container = encoder.singleValueContainer()
1695+ switch self {
1696+ case .double(let x):
1697+ try container.encode(x)
1698+ case .nullArray(let x):
1699+ try container.encode(x)
1700+ case .null:
1701+ try container.encodeNil()
1702+ }
1703+ }
1704+}
1705+
1706+enum Mulishly: Codable {
1707+ case double(Double)
1708+ case integerArray([Int])
1709+ case null
1710+
1711+ init(from decoder: Decoder) throws {
1712+ let container = try decoder.singleValueContainer()
1713+ if let x = try? container.decode([Int].self) {
1714+ self = .integerArray(x)
1715+ return
1716+ }
1717+ if let x = try? container.decode(Double.self) {
1718+ self = .double(x)
1719+ return
1720+ }
1721+ if container.decodeNil() {
1722+ self = .null
1723+ return
1724+ }
1725+ throw DecodingError.typeMismatch(Mulishly.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Mulishly"))
1726+ }
1727+
1728+ func encode(to encoder: Encoder) throws {
1729+ var container = encoder.singleValueContainer()
1730+ switch self {
1731+ case .double(let x):
1732+ try container.encode(x)
1733+ case .integerArray(let x):
1734+ try container.encode(x)
1735+ case .null:
1736+ try container.encodeNil()
1737+ }
1738+ }
1739+}
1740+
1741+enum Myoscope: Codable {
1742+ case bool(Bool)
1743+ case integer(Int)
1744+ case nullArray([JSONNull?])
1745+
1746+ init(from decoder: Decoder) throws {
1747+ let container = try decoder.singleValueContainer()
1748+ if let x = try? container.decode(Bool.self) {
1749+ self = .bool(x)
1750+ return
1751+ }
1752+ if let x = try? container.decode(Int.self) {
1753+ self = .integer(x)
1754+ return
1755+ }
1756+ if let x = try? container.decode([JSONNull?].self) {
1757+ self = .nullArray(x)
1758+ return
1759+ }
1760+ throw DecodingError.typeMismatch(Myoscope.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Myoscope"))
1761+ }
1762+
1763+ func encode(to encoder: Encoder) throws {
1764+ var container = encoder.singleValueContainer()
1765+ switch self {
1766+ case .bool(let x):
1767+ try container.encode(x)
1768+ case .integer(let x):
1769+ try container.encode(x)
1770+ case .nullArray(let x):
1771+ try container.encode(x)
1772+ }
1773+ }
1774+}
1775+
1776+enum Neuromastic: Codable {
1777+ case double(Double)
1778+ case nullArray([JSONNull?])
1779+
1780+ init(from decoder: Decoder) throws {
1781+ let container = try decoder.singleValueContainer()
1782+ if let x = try? container.decode([JSONNull?].self) {
1783+ self = .nullArray(x)
1784+ return
1785+ }
1786+ if let x = try? container.decode(Double.self) {
1787+ self = .double(x)
1788+ return
1789+ }
1790+ throw DecodingError.typeMismatch(Neuromastic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Neuromastic"))
1791+ }
1792+
1793+ func encode(to encoder: Encoder) throws {
1794+ var container = encoder.singleValueContainer()
1795+ switch self {
1796+ case .double(let x):
1797+ try container.encode(x)
1798+ case .nullArray(let x):
1799+ try container.encode(x)
1800+ }
1801+ }
1802+}
1803+
1804+// MARK: - Noncontributing
1805+final class Noncontributing: Codable {
1806+ let estevin: String
1807+ let jolterhead: Double
1808+ let sauternes: Int
1809+ let sparsely: Bool
1810+ let unrequested: JSONNull?
1811+
1812+ enum CodingKeys: String, CodingKey {
1813+ case estevin = "estevin"
1814+ case jolterhead = "jolterhead"
1815+ case sauternes = "sauternes"
1816+ case sparsely = "sparsely"
1817+ case unrequested = "unrequested"
1818+ }
1819+
1820+ init(estevin: String, jolterhead: Double, sauternes: Int, sparsely: Bool, unrequested: JSONNull?) {
1821+ self.estevin = estevin
1822+ self.jolterhead = jolterhead
1823+ self.sauternes = sauternes
1824+ self.sparsely = sparsely
1825+ self.unrequested = unrequested
1826+ }
1827+}
1828+
1829+// MARK: Noncontributing convenience initializers and mutators
1830+
1831+extension Noncontributing {
1832+ convenience init(data: Data) throws {
1833+ let me = try newJSONDecoder().decode(Noncontributing.self, from: data)
1834+ self.init(estevin: me.estevin, jolterhead: me.jolterhead, sauternes: me.sauternes, sparsely: me.sparsely, unrequested: me.unrequested)
1835+ }
1836+
1837+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1838+ guard let data = json.data(using: encoding) else {
1839+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1840+ }
1841+ try self.init(data: data)
1842+ }
1843+
1844+ convenience init(fromURL url: URL) throws {
1845+ try self.init(data: try Data(contentsOf: url))
1846+ }
1847+
1848+ func with(
1849+ estevin: String? = nil,
1850+ jolterhead: Double? = nil,
1851+ sauternes: Int? = nil,
1852+ sparsely: Bool? = nil,
1853+ unrequested: JSONNull?? = nil
1854+ ) -> Noncontributing {
1855+ return Noncontributing(
1856+ estevin: estevin ?? self.estevin,
1857+ jolterhead: jolterhead ?? self.jolterhead,
1858+ sauternes: sauternes ?? self.sauternes,
1859+ sparsely: sparsely ?? self.sparsely,
1860+ unrequested: unrequested ?? self.unrequested
1861+ )
1862+ }
1863+
1864+ func jsonData() throws -> Data {
1865+ return try newJSONEncoder().encode(self)
1866+ }
1867+
1868+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1869+ return String(data: try self.jsonData(), encoding: encoding)
1870+ }
1871+}
1872+
1873+enum Nonnervous: Codable {
1874+ case bool(Bool)
1875+ case integer(Int)
1876+
1877+ init(from decoder: Decoder) throws {
1878+ let container = try decoder.singleValueContainer()
1879+ if let x = try? container.decode(Bool.self) {
1880+ self = .bool(x)
1881+ return
1882+ }
1883+ if let x = try? container.decode(Int.self) {
1884+ self = .integer(x)
1885+ return
1886+ }
1887+ throw DecodingError.typeMismatch(Nonnervous.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Nonnervous"))
1888+ }
1889+
1890+ func encode(to encoder: Encoder) throws {
1891+ var container = encoder.singleValueContainer()
1892+ switch self {
1893+ case .bool(let x):
1894+ try container.encode(x)
1895+ case .integer(let x):
1896+ try container.encode(x)
1897+ }
1898+ }
1899+}
1900+
1901+enum Nonvaluation: Codable {
1902+ case bool(Bool)
1903+ case double(Double)
1904+ case nullArray([JSONNull?])
1905+
1906+ init(from decoder: Decoder) throws {
1907+ let container = try decoder.singleValueContainer()
1908+ if let x = try? container.decode(Bool.self) {
1909+ self = .bool(x)
1910+ return
1911+ }
1912+ if let x = try? container.decode([JSONNull?].self) {
1913+ self = .nullArray(x)
1914+ return
1915+ }
1916+ if let x = try? container.decode(Double.self) {
1917+ self = .double(x)
1918+ return
1919+ }
1920+ throw DecodingError.typeMismatch(Nonvaluation.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Nonvaluation"))
1921+ }
1922+
1923+ func encode(to encoder: Encoder) throws {
1924+ var container = encoder.singleValueContainer()
1925+ switch self {
1926+ case .bool(let x):
1927+ try container.encode(x)
1928+ case .double(let x):
1929+ try container.encode(x)
1930+ case .nullArray(let x):
1931+ try container.encode(x)
1932+ }
1933+ }
1934+}
1935+
1936+enum OccupationalistElement: Codable {
1937+ case nullArray([JSONNull?])
1938+ case occupationalistClass(OccupationalistClass)
1939+ case null
1940+
1941+ init(from decoder: Decoder) throws {
1942+ let container = try decoder.singleValueContainer()
1943+ if let x = try? container.decode([JSONNull?].self) {
1944+ self = .nullArray(x)
1945+ return
1946+ }
1947+ if let x = try? container.decode(OccupationalistClass.self) {
1948+ self = .occupationalistClass(x)
1949+ return
1950+ }
1951+ if container.decodeNil() {
1952+ self = .null
1953+ return
1954+ }
1955+ throw DecodingError.typeMismatch(OccupationalistElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for OccupationalistElement"))
1956+ }
1957+
1958+ func encode(to encoder: Encoder) throws {
1959+ var container = encoder.singleValueContainer()
1960+ switch self {
1961+ case .nullArray(let x):
1962+ try container.encode(x)
1963+ case .occupationalistClass(let x):
1964+ try container.encode(x)
1965+ case .null:
1966+ try container.encodeNil()
1967+ }
1968+ }
1969+}
1970+
1971+// MARK: - OccupationalistClass
1972+final class OccupationalistClass: Codable {
1973+ let beholdable: JSONNull?
1974+ let brotuliform: JSONNull?
1975+ let chimakum: JSONNull?
1976+ let doodler: JSONNull?
1977+ let emulsin: JSONNull?
1978+ let fin: JSONNull?
1979+ let flourishing: JSONNull?
1980+ let flueless: JSONNull?
1981+ let furtively: JSONNull?
1982+ let gritter: JSONNull?
1983+ let interwish: JSONNull?
1984+ let monoxylic: JSONNull?
1985+ let myristic: JSONNull?
1986+ let nightwear: JSONNull?
1987+ let peruser: JSONNull?
1988+ let theoastrological: JSONNull?
1989+ let thumby: JSONNull?
1990+ let tingitid: JSONNull?
1991+ let trailless: JSONNull?
1992+ let unpocketed: JSONNull?
1993+
1994+ enum CodingKeys: String, CodingKey {
1995+ case beholdable = "beholdable"
1996+ case brotuliform = "brotuliform"
1997+ case chimakum = "Chimakum"
1998+ case doodler = "doodler"
1999+ case emulsin = "emulsin"
2000+ case fin = "Fin"
2001+ case flourishing = "flourishing"
2002+ case flueless = "flueless"
2003+ case furtively = "furtively"
2004+ case gritter = "gritter"
2005+ case interwish = "interwish"
2006+ case monoxylic = "monoxylic"
2007+ case myristic = "myristic"
2008+ case nightwear = "nightwear"
2009+ case peruser = "peruser"
2010+ case theoastrological = "theoastrological"
2011+ case thumby = "thumby"
2012+ case tingitid = "tingitid"
2013+ case trailless = "trailless"
2014+ case unpocketed = "unpocketed"
2015+ }
2016+
2017+ 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?) {
2018+ self.beholdable = beholdable
2019+ self.brotuliform = brotuliform
2020+ self.chimakum = chimakum
2021+ self.doodler = doodler
2022+ self.emulsin = emulsin
2023+ self.fin = fin
2024+ self.flourishing = flourishing
2025+ self.flueless = flueless
2026+ self.furtively = furtively
2027+ self.gritter = gritter
2028+ self.interwish = interwish
2029+ self.monoxylic = monoxylic
2030+ self.myristic = myristic
2031+ self.nightwear = nightwear
2032+ self.peruser = peruser
2033+ self.theoastrological = theoastrological
2034+ self.thumby = thumby
2035+ self.tingitid = tingitid
2036+ self.trailless = trailless
2037+ self.unpocketed = unpocketed
2038+ }
2039+}
2040+
2041+// MARK: OccupationalistClass convenience initializers and mutators
2042+
2043+extension OccupationalistClass {
2044+ convenience init(data: Data) throws {
2045+ let me = try newJSONDecoder().decode(OccupationalistClass.self, from: data)
2046+ 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)
2047+ }
2048+
2049+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2050+ guard let data = json.data(using: encoding) else {
2051+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2052+ }
2053+ try self.init(data: data)
2054+ }
2055+
2056+ convenience init(fromURL url: URL) throws {
2057+ try self.init(data: try Data(contentsOf: url))
2058+ }
2059+
2060+ func with(
2061+ beholdable: JSONNull?? = nil,
2062+ brotuliform: JSONNull?? = nil,
2063+ chimakum: JSONNull?? = nil,
2064+ doodler: JSONNull?? = nil,
2065+ emulsin: JSONNull?? = nil,
2066+ fin: JSONNull?? = nil,
2067+ flourishing: JSONNull?? = nil,
2068+ flueless: JSONNull?? = nil,
2069+ furtively: JSONNull?? = nil,
2070+ gritter: JSONNull?? = nil,
2071+ interwish: JSONNull?? = nil,
2072+ monoxylic: JSONNull?? = nil,
2073+ myristic: JSONNull?? = nil,
2074+ nightwear: JSONNull?? = nil,
2075+ peruser: JSONNull?? = nil,
2076+ theoastrological: JSONNull?? = nil,
2077+ thumby: JSONNull?? = nil,
2078+ tingitid: JSONNull?? = nil,
2079+ trailless: JSONNull?? = nil,
2080+ unpocketed: JSONNull?? = nil
2081+ ) -> OccupationalistClass {
2082+ return OccupationalistClass(
2083+ beholdable: beholdable ?? self.beholdable,
2084+ brotuliform: brotuliform ?? self.brotuliform,
2085+ chimakum: chimakum ?? self.chimakum,
2086+ doodler: doodler ?? self.doodler,
2087+ emulsin: emulsin ?? self.emulsin,
2088+ fin: fin ?? self.fin,
2089+ flourishing: flourishing ?? self.flourishing,
2090+ flueless: flueless ?? self.flueless,
2091+ furtively: furtively ?? self.furtively,
2092+ gritter: gritter ?? self.gritter,
2093+ interwish: interwish ?? self.interwish,
2094+ monoxylic: monoxylic ?? self.monoxylic,
2095+ myristic: myristic ?? self.myristic,
2096+ nightwear: nightwear ?? self.nightwear,
2097+ peruser: peruser ?? self.peruser,
2098+ theoastrological: theoastrological ?? self.theoastrological,
2099+ thumby: thumby ?? self.thumby,
2100+ tingitid: tingitid ?? self.tingitid,
2101+ trailless: trailless ?? self.trailless,
2102+ unpocketed: unpocketed ?? self.unpocketed
2103+ )
2104+ }
2105+
2106+ func jsonData() throws -> Data {
2107+ return try newJSONEncoder().encode(self)
2108+ }
2109+
2110+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2111+ return String(data: try self.jsonData(), encoding: encoding)
2112+ }
2113+}
2114+
2115+enum OutrivalElement: Codable {
2116+ case double(Double)
2117+ case outrivalClass(OutrivalClass)
2118+ case null
2119+
2120+ init(from decoder: Decoder) throws {
2121+ let container = try decoder.singleValueContainer()
2122+ if let x = try? container.decode(Double.self) {
2123+ self = .double(x)
2124+ return
2125+ }
2126+ if let x = try? container.decode(OutrivalClass.self) {
2127+ self = .outrivalClass(x)
2128+ return
2129+ }
2130+ if container.decodeNil() {
2131+ self = .null
2132+ return
2133+ }
2134+ throw DecodingError.typeMismatch(OutrivalElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for OutrivalElement"))
2135+ }
2136+
2137+ func encode(to encoder: Encoder) throws {
2138+ var container = encoder.singleValueContainer()
2139+ switch self {
2140+ case .double(let x):
2141+ try container.encode(x)
2142+ case .outrivalClass(let x):
2143+ try container.encode(x)
2144+ case .null:
2145+ try container.encodeNil()
2146+ }
2147+ }
2148+}
2149+
2150+// MARK: - OutrivalClass
2151+final class OutrivalClass: Codable {
2152+ let adroitly: JSONNull?
2153+ let bridehood: JSONNull?
2154+ let castoroides: JSONNull?
2155+ let czechoslovak: JSONNull?
2156+ let diagenesis: JSONNull?
2157+ let dihexahedron: JSONNull?
2158+ let dopester: JSONNull?
2159+ let eumerism: JSONNull?
2160+ let flyness: JSONNull?
2161+ let fouler: JSONNull?
2162+ let laudanosine: JSONNull?
2163+ let lingulidae: JSONNull?
2164+ let minutary: JSONNull?
2165+ let mitra: JSONNull?
2166+ let opisthorchiasis: JSONNull?
2167+ let pensively: JSONNull?
2168+ let pubigerous: JSONNull?
2169+ let rebellious: JSONNull?
2170+ let recodify: JSONNull?
2171+ let unpaced: JSONNull?
2172+
2173+ enum CodingKeys: String, CodingKey {
2174+ case adroitly = "adroitly"
2175+ case bridehood = "bridehood"
2176+ case castoroides = "Castoroides"
2177+ case czechoslovak = "Czechoslovak"
2178+ case diagenesis = "diagenesis"
2179+ case dihexahedron = "dihexahedron"
2180+ case dopester = "dopester"
2181+ case eumerism = "eumerism"
2182+ case flyness = "flyness"
2183+ case fouler = "fouler"
2184+ case laudanosine = "laudanosine"
2185+ case lingulidae = "Lingulidae"
2186+ case minutary = "minutary"
2187+ case mitra = "mitra"
2188+ case opisthorchiasis = "opisthorchiasis"
2189+ case pensively = "pensively"
2190+ case pubigerous = "pubigerous"
2191+ case rebellious = "rebellious"
2192+ case recodify = "recodify"
2193+ case unpaced = "unpaced"
2194+ }
2195+
2196+ 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?) {
2197+ self.adroitly = adroitly
2198+ self.bridehood = bridehood
2199+ self.castoroides = castoroides
2200+ self.czechoslovak = czechoslovak
2201+ self.diagenesis = diagenesis
2202+ self.dihexahedron = dihexahedron
2203+ self.dopester = dopester
2204+ self.eumerism = eumerism
2205+ self.flyness = flyness
2206+ self.fouler = fouler
2207+ self.laudanosine = laudanosine
2208+ self.lingulidae = lingulidae
2209+ self.minutary = minutary
2210+ self.mitra = mitra
2211+ self.opisthorchiasis = opisthorchiasis
2212+ self.pensively = pensively
2213+ self.pubigerous = pubigerous
2214+ self.rebellious = rebellious
2215+ self.recodify = recodify
2216+ self.unpaced = unpaced
2217+ }
2218+}
2219+
2220+// MARK: OutrivalClass convenience initializers and mutators
2221+
2222+extension OutrivalClass {
2223+ convenience init(data: Data) throws {
2224+ let me = try newJSONDecoder().decode(OutrivalClass.self, from: data)
2225+ 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)
2226+ }
2227+
2228+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2229+ guard let data = json.data(using: encoding) else {
2230+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2231+ }
2232+ try self.init(data: data)
2233+ }
2234+
2235+ convenience init(fromURL url: URL) throws {
2236+ try self.init(data: try Data(contentsOf: url))
2237+ }
2238+
2239+ func with(
2240+ adroitly: JSONNull?? = nil,
2241+ bridehood: JSONNull?? = nil,
2242+ castoroides: JSONNull?? = nil,
2243+ czechoslovak: JSONNull?? = nil,
2244+ diagenesis: JSONNull?? = nil,
2245+ dihexahedron: JSONNull?? = nil,
2246+ dopester: JSONNull?? = nil,
2247+ eumerism: JSONNull?? = nil,
2248+ flyness: JSONNull?? = nil,
2249+ fouler: JSONNull?? = nil,
2250+ laudanosine: JSONNull?? = nil,
2251+ lingulidae: JSONNull?? = nil,
2252+ minutary: JSONNull?? = nil,
2253+ mitra: JSONNull?? = nil,
2254+ opisthorchiasis: JSONNull?? = nil,
2255+ pensively: JSONNull?? = nil,
2256+ pubigerous: JSONNull?? = nil,
2257+ rebellious: JSONNull?? = nil,
2258+ recodify: JSONNull?? = nil,
2259+ unpaced: JSONNull?? = nil
2260+ ) -> OutrivalClass {
2261+ return OutrivalClass(
2262+ adroitly: adroitly ?? self.adroitly,
2263+ bridehood: bridehood ?? self.bridehood,
2264+ castoroides: castoroides ?? self.castoroides,
2265+ czechoslovak: czechoslovak ?? self.czechoslovak,
2266+ diagenesis: diagenesis ?? self.diagenesis,
2267+ dihexahedron: dihexahedron ?? self.dihexahedron,
2268+ dopester: dopester ?? self.dopester,
2269+ eumerism: eumerism ?? self.eumerism,
2270+ flyness: flyness ?? self.flyness,
2271+ fouler: fouler ?? self.fouler,
2272+ laudanosine: laudanosine ?? self.laudanosine,
2273+ lingulidae: lingulidae ?? self.lingulidae,
2274+ minutary: minutary ?? self.minutary,
2275+ mitra: mitra ?? self.mitra,
2276+ opisthorchiasis: opisthorchiasis ?? self.opisthorchiasis,
2277+ pensively: pensively ?? self.pensively,
2278+ pubigerous: pubigerous ?? self.pubigerous,
2279+ rebellious: rebellious ?? self.rebellious,
2280+ recodify: recodify ?? self.recodify,
2281+ unpaced: unpaced ?? self.unpaced
2282+ )
2283+ }
2284+
2285+ func jsonData() throws -> Data {
2286+ return try newJSONEncoder().encode(self)
2287+ }
2288+
2289+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2290+ return String(data: try self.jsonData(), encoding: encoding)
2291+ }
2292+}
2293+
2294+enum Paleographically: Codable {
2295+ case double(Double)
2296+ case unionMap([String: Int?])
2297+
2298+ init(from decoder: Decoder) throws {
2299+ let container = try decoder.singleValueContainer()
2300+ if let x = try? container.decode(Double.self) {
2301+ self = .double(x)
2302+ return
2303+ }
2304+ if let x = try? container.decode([String: Int?].self) {
2305+ self = .unionMap(x)
2306+ return
2307+ }
2308+ throw DecodingError.typeMismatch(Paleographically.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Paleographically"))
2309+ }
2310+
2311+ func encode(to encoder: Encoder) throws {
2312+ var container = encoder.singleValueContainer()
2313+ switch self {
2314+ case .double(let x):
2315+ try container.encode(x)
2316+ case .unionMap(let x):
2317+ try container.encode(x)
2318+ }
2319+ }
2320+}
2321+
2322+enum Pamphletwise: Codable {
2323+ case integer(Int)
2324+ case integerMap([String: Int])
2325+ case string(String)
2326+
2327+ init(from decoder: Decoder) throws {
2328+ let container = try decoder.singleValueContainer()
2329+ if let x = try? container.decode(Int.self) {
2330+ self = .integer(x)
2331+ return
2332+ }
2333+ if let x = try? container.decode([String: Int].self) {
2334+ self = .integerMap(x)
2335+ return
2336+ }
2337+ if let x = try? container.decode(String.self) {
2338+ self = .string(x)
2339+ return
2340+ }
2341+ throw DecodingError.typeMismatch(Pamphletwise.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Pamphletwise"))
2342+ }
2343+
2344+ func encode(to encoder: Encoder) throws {
2345+ var container = encoder.singleValueContainer()
2346+ switch self {
2347+ case .integer(let x):
2348+ try container.encode(x)
2349+ case .integerMap(let x):
2350+ try container.encode(x)
2351+ case .string(let x):
2352+ try container.encode(x)
2353+ }
2354+ }
2355+}
2356+
2357+enum Pediatric: Codable {
2358+ case bool(Bool)
2359+ case double(Double)
2360+ case null
2361+
2362+ init(from decoder: Decoder) throws {
2363+ let container = try decoder.singleValueContainer()
2364+ if let x = try? container.decode(Bool.self) {
2365+ self = .bool(x)
2366+ return
2367+ }
2368+ if let x = try? container.decode(Double.self) {
2369+ self = .double(x)
2370+ return
2371+ }
2372+ if container.decodeNil() {
2373+ self = .null
2374+ return
2375+ }
2376+ throw DecodingError.typeMismatch(Pediatric.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Pediatric"))
2377+ }
2378+
2379+ func encode(to encoder: Encoder) throws {
2380+ var container = encoder.singleValueContainer()
2381+ switch self {
2382+ case .bool(let x):
2383+ try container.encode(x)
2384+ case .double(let x):
2385+ try container.encode(x)
2386+ case .null:
2387+ try container.encodeNil()
2388+ }
2389+ }
2390+}
2391+
2392+enum PiaculumElement: Codable {
2393+ case double(Double)
2394+ case piaculumClass(PiaculumClass)
2395+
2396+ init(from decoder: Decoder) throws {
2397+ let container = try decoder.singleValueContainer()
2398+ if let x = try? container.decode(Double.self) {
2399+ self = .double(x)
2400+ return
2401+ }
2402+ if let x = try? container.decode(PiaculumClass.self) {
2403+ self = .piaculumClass(x)
2404+ return
2405+ }
2406+ throw DecodingError.typeMismatch(PiaculumElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PiaculumElement"))
2407+ }
2408+
2409+ func encode(to encoder: Encoder) throws {
2410+ var container = encoder.singleValueContainer()
2411+ switch self {
2412+ case .double(let x):
2413+ try container.encode(x)
2414+ case .piaculumClass(let x):
2415+ try container.encode(x)
2416+ }
2417+ }
2418+}
2419+
2420+// MARK: - PiaculumClass
2421+final class PiaculumClass: Codable {
2422+ let alada: Int?
2423+ let amphistomous: Int?
2424+ let boysenberry: Int?
2425+ let catharticalness: Double?
2426+ let chirotherium: Int?
2427+ let decardinalize: Int?
2428+ let discouragement: Int?
2429+ let disdiapason: String?
2430+ let doitrified: Int?
2431+ let hexaspermous: Int?
2432+ let homocerc: Bool?
2433+ let insinking: Int?
2434+ let loathfulness: Int?
2435+ let miasmatical: Int?
2436+ let neurofibril: Int?
2437+ let nonbookish: JSONNull?
2438+ let phonendoscope: Int?
2439+ let pilferment: Int?
2440+ let predismissory: Int?
2441+ let preinscription: Int?
2442+ let quotative: Int?
2443+ let sienna: Int?
2444+ let thorax: Int?
2445+ let yachting: Int?
2446+ let zipper: Int?
2447+
2448+ enum CodingKeys: String, CodingKey {
2449+ case alada = "alada"
2450+ case amphistomous = "amphistomous"
2451+ case boysenberry = "boysenberry"
2452+ case catharticalness = "catharticalness"
2453+ case chirotherium = "Chirotherium"
2454+ case decardinalize = "decardinalize"
2455+ case discouragement = "discouragement"
2456+ case disdiapason = "disdiapason"
2457+ case doitrified = "doitrified"
2458+ case hexaspermous = "hexaspermous"
2459+ case homocerc = "homocerc"
2460+ case insinking = "insinking"
2461+ case loathfulness = "loathfulness"
2462+ case miasmatical = "miasmatical"
2463+ case neurofibril = "neurofibril"
2464+ case nonbookish = "nonbookish"
2465+ case phonendoscope = "phonendoscope"
2466+ case pilferment = "pilferment"
2467+ case predismissory = "predismissory"
2468+ case preinscription = "preinscription"
2469+ case quotative = "quotative"
2470+ case sienna = "sienna"
2471+ case thorax = "thorax"
2472+ case yachting = "yachting"
2473+ case zipper = "Zipper"
2474+ }
2475+
2476+ 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?) {
2477+ self.alada = alada
2478+ self.amphistomous = amphistomous
2479+ self.boysenberry = boysenberry
2480+ self.catharticalness = catharticalness
2481+ self.chirotherium = chirotherium
2482+ self.decardinalize = decardinalize
2483+ self.discouragement = discouragement
2484+ self.disdiapason = disdiapason
2485+ self.doitrified = doitrified
2486+ self.hexaspermous = hexaspermous
2487+ self.homocerc = homocerc
2488+ self.insinking = insinking
2489+ self.loathfulness = loathfulness
2490+ self.miasmatical = miasmatical
2491+ self.neurofibril = neurofibril
2492+ self.nonbookish = nonbookish
2493+ self.phonendoscope = phonendoscope
2494+ self.pilferment = pilferment
2495+ self.predismissory = predismissory
2496+ self.preinscription = preinscription
2497+ self.quotative = quotative
2498+ self.sienna = sienna
2499+ self.thorax = thorax
2500+ self.yachting = yachting
2501+ self.zipper = zipper
2502+ }
2503+}
2504+
2505+// MARK: PiaculumClass convenience initializers and mutators
2506+
2507+extension PiaculumClass {
2508+ convenience init(data: Data) throws {
2509+ let me = try newJSONDecoder().decode(PiaculumClass.self, from: data)
2510+ 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)
2511+ }
2512+
2513+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2514+ guard let data = json.data(using: encoding) else {
2515+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2516+ }
2517+ try self.init(data: data)
2518+ }
2519+
2520+ convenience init(fromURL url: URL) throws {
2521+ try self.init(data: try Data(contentsOf: url))
2522+ }
2523+
2524+ func with(
2525+ alada: Int?? = nil,
2526+ amphistomous: Int?? = nil,
2527+ boysenberry: Int?? = nil,
2528+ catharticalness: Double?? = nil,
2529+ chirotherium: Int?? = nil,
2530+ decardinalize: Int?? = nil,
2531+ discouragement: Int?? = nil,
2532+ disdiapason: String?? = nil,
2533+ doitrified: Int?? = nil,
2534+ hexaspermous: Int?? = nil,
2535+ homocerc: Bool?? = nil,
2536+ insinking: Int?? = nil,
2537+ loathfulness: Int?? = nil,
2538+ miasmatical: Int?? = nil,
2539+ neurofibril: Int?? = nil,
2540+ nonbookish: JSONNull?? = nil,
2541+ phonendoscope: Int?? = nil,
2542+ pilferment: Int?? = nil,
2543+ predismissory: Int?? = nil,
2544+ preinscription: Int?? = nil,
2545+ quotative: Int?? = nil,
2546+ sienna: Int?? = nil,
2547+ thorax: Int?? = nil,
2548+ yachting: Int?? = nil,
2549+ zipper: Int?? = nil
2550+ ) -> PiaculumClass {
2551+ return PiaculumClass(
2552+ alada: alada ?? self.alada,
2553+ amphistomous: amphistomous ?? self.amphistomous,
2554+ boysenberry: boysenberry ?? self.boysenberry,
2555+ catharticalness: catharticalness ?? self.catharticalness,
2556+ chirotherium: chirotherium ?? self.chirotherium,
2557+ decardinalize: decardinalize ?? self.decardinalize,
2558+ discouragement: discouragement ?? self.discouragement,
2559+ disdiapason: disdiapason ?? self.disdiapason,
2560+ doitrified: doitrified ?? self.doitrified,
2561+ hexaspermous: hexaspermous ?? self.hexaspermous,
2562+ homocerc: homocerc ?? self.homocerc,
2563+ insinking: insinking ?? self.insinking,
2564+ loathfulness: loathfulness ?? self.loathfulness,
2565+ miasmatical: miasmatical ?? self.miasmatical,
2566+ neurofibril: neurofibril ?? self.neurofibril,
2567+ nonbookish: nonbookish ?? self.nonbookish,
2568+ phonendoscope: phonendoscope ?? self.phonendoscope,
2569+ pilferment: pilferment ?? self.pilferment,
2570+ predismissory: predismissory ?? self.predismissory,
2571+ preinscription: preinscription ?? self.preinscription,
2572+ quotative: quotative ?? self.quotative,
2573+ sienna: sienna ?? self.sienna,
2574+ thorax: thorax ?? self.thorax,
2575+ yachting: yachting ?? self.yachting,
2576+ zipper: zipper ?? self.zipper
2577+ )
2578+ }
2579+
2580+ func jsonData() throws -> Data {
2581+ return try newJSONEncoder().encode(self)
2582+ }
2583+
2584+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2585+ return String(data: try self.jsonData(), encoding: encoding)
2586+ }
2587+}
2588+
2589+enum Piccadilly: Codable {
2590+ case double(Double)
2591+ case string(String)
2592+ case null
2593+
2594+ init(from decoder: Decoder) throws {
2595+ let container = try decoder.singleValueContainer()
2596+ if let x = try? container.decode(Double.self) {
2597+ self = .double(x)
2598+ return
2599+ }
2600+ if let x = try? container.decode(String.self) {
2601+ self = .string(x)
2602+ return
2603+ }
2604+ if container.decodeNil() {
2605+ self = .null
2606+ return
2607+ }
2608+ throw DecodingError.typeMismatch(Piccadilly.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Piccadilly"))
2609+ }
2610+
2611+ func encode(to encoder: Encoder) throws {
2612+ var container = encoder.singleValueContainer()
2613+ switch self {
2614+ case .double(let x):
2615+ try container.encode(x)
2616+ case .string(let x):
2617+ try container.encode(x)
2618+ case .null:
2619+ try container.encodeNil()
2620+ }
2621+ }
2622+}
2623+
2624+enum Piffler: Codable {
2625+ case monaziteClass(MonaziteClass)
2626+ case nullArray([JSONNull?])
2627+
2628+ init(from decoder: Decoder) throws {
2629+ let container = try decoder.singleValueContainer()
2630+ if let x = try? container.decode([JSONNull?].self) {
2631+ self = .nullArray(x)
2632+ return
2633+ }
2634+ if let x = try? container.decode(MonaziteClass.self) {
2635+ self = .monaziteClass(x)
2636+ return
2637+ }
2638+ throw DecodingError.typeMismatch(Piffler.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Piffler"))
2639+ }
2640+
2641+ func encode(to encoder: Encoder) throws {
2642+ var container = encoder.singleValueContainer()
2643+ switch self {
2644+ case .monaziteClass(let x):
2645+ try container.encode(x)
2646+ case .nullArray(let x):
2647+ try container.encode(x)
2648+ }
2649+ }
2650+}
2651+
2652+enum Pithful: Codable {
2653+ case bool(Bool)
2654+ case integer(Int)
2655+ case null
2656+
2657+ init(from decoder: Decoder) throws {
2658+ let container = try decoder.singleValueContainer()
2659+ if let x = try? container.decode(Bool.self) {
2660+ self = .bool(x)
2661+ return
2662+ }
2663+ if let x = try? container.decode(Int.self) {
2664+ self = .integer(x)
2665+ return
2666+ }
2667+ if container.decodeNil() {
2668+ self = .null
2669+ return
2670+ }
2671+ throw DecodingError.typeMismatch(Pithful.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Pithful"))
2672+ }
2673+
2674+ func encode(to encoder: Encoder) throws {
2675+ var container = encoder.singleValueContainer()
2676+ switch self {
2677+ case .bool(let x):
2678+ try container.encode(x)
2679+ case .integer(let x):
2680+ try container.encode(x)
2681+ case .null:
2682+ try container.encodeNil()
2683+ }
2684+ }
2685+}
2686+
2687+enum Placuntiti: Codable {
2688+ case integer(Int)
2689+ case integerMap([String: Int])
2690+
2691+ init(from decoder: Decoder) throws {
2692+ let container = try decoder.singleValueContainer()
2693+ if let x = try? container.decode(Int.self) {
2694+ self = .integer(x)
2695+ return
2696+ }
2697+ if let x = try? container.decode([String: Int].self) {
2698+ self = .integerMap(x)
2699+ return
2700+ }
2701+ throw DecodingError.typeMismatch(Placuntiti.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Placuntiti"))
2702+ }
2703+
2704+ func encode(to encoder: Encoder) throws {
2705+ var container = encoder.singleValueContainer()
2706+ switch self {
2707+ case .integer(let x):
2708+ try container.encode(x)
2709+ case .integerMap(let x):
2710+ try container.encode(x)
2711+ }
2712+ }
2713+}
2714+
2715+enum Plectopterous: Codable {
2716+ case double(Double)
2717+ case integerMap([String: Int])
2718+
2719+ init(from decoder: Decoder) throws {
2720+ let container = try decoder.singleValueContainer()
2721+ if let x = try? container.decode(Double.self) {
2722+ self = .double(x)
2723+ return
2724+ }
2725+ if let x = try? container.decode([String: Int].self) {
2726+ self = .integerMap(x)
2727+ return
2728+ }
2729+ throw DecodingError.typeMismatch(Plectopterous.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Plectopterous"))
2730+ }
2731+
2732+ func encode(to encoder: Encoder) throws {
2733+ var container = encoder.singleValueContainer()
2734+ switch self {
2735+ case .double(let x):
2736+ try container.encode(x)
2737+ case .integerMap(let x):
2738+ try container.encode(x)
2739+ }
2740+ }
2741+}
2742+
2743+// MARK: - Pneumocele
2744+final class Pneumocele: Codable {
2745+ let carbonarism: JSONNull?
2746+ let catharticalness: Double?
2747+ let chirotherium: Int?
2748+ let cineolic: JSONNull?
2749+ let cobbly: JSONNull?
2750+ let conchyliferous: JSONNull?
2751+ let congregation: JSONNull?
2752+ let disdiapason: String?
2753+ let enterotomy: JSONNull?
2754+ let entophytal: JSONNull?
2755+ let fewtrils: JSONNull?
2756+ let herem: JSONNull?
2757+ let homocerc: Bool?
2758+ let koniga: JSONNull?
2759+ let meticulosity: JSONNull?
2760+ let micky: JSONNull?
2761+ let mismarriage: JSONNull?
2762+ let neurotrophic: JSONNull?
2763+ let nonbookish: JSONNull?
2764+ let persuasively: JSONNull?
2765+ let replaceable: JSONNull?
2766+ let silex: JSONNull?
2767+ let taillight: JSONNull?
2768+ let unjealous: JSONNull?
2769+ let visitorial: JSONNull?
2770+
2771+ enum CodingKeys: String, CodingKey {
2772+ case carbonarism = "Carbonarism"
2773+ case catharticalness = "catharticalness"
2774+ case chirotherium = "Chirotherium"
2775+ case cineolic = "cineolic"
2776+ case cobbly = "cobbly"
2777+ case conchyliferous = "conchyliferous"
2778+ case congregation = "congregation"
2779+ case disdiapason = "disdiapason"
2780+ case enterotomy = "enterotomy"
2781+ case entophytal = "entophytal"
2782+ case fewtrils = "fewtrils"
2783+ case herem = "herem"
2784+ case homocerc = "homocerc"
2785+ case koniga = "Koniga"
2786+ case meticulosity = "meticulosity"
2787+ case micky = "Micky"
2788+ case mismarriage = "mismarriage"
2789+ case neurotrophic = "neurotrophic"
2790+ case nonbookish = "nonbookish"
2791+ case persuasively = "persuasively"
2792+ case replaceable = "replaceable"
2793+ case silex = "silex"
2794+ case taillight = "taillight"
2795+ case unjealous = "unjealous"
2796+ case visitorial = "visitorial"
2797+ }
2798+
2799+ 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?) {
2800+ self.carbonarism = carbonarism
2801+ self.catharticalness = catharticalness
2802+ self.chirotherium = chirotherium
2803+ self.cineolic = cineolic
2804+ self.cobbly = cobbly
2805+ self.conchyliferous = conchyliferous
2806+ self.congregation = congregation
2807+ self.disdiapason = disdiapason
2808+ self.enterotomy = enterotomy
2809+ self.entophytal = entophytal
2810+ self.fewtrils = fewtrils
2811+ self.herem = herem
2812+ self.homocerc = homocerc
2813+ self.koniga = koniga
2814+ self.meticulosity = meticulosity
2815+ self.micky = micky
2816+ self.mismarriage = mismarriage
2817+ self.neurotrophic = neurotrophic
2818+ self.nonbookish = nonbookish
2819+ self.persuasively = persuasively
2820+ self.replaceable = replaceable
2821+ self.silex = silex
2822+ self.taillight = taillight
2823+ self.unjealous = unjealous
2824+ self.visitorial = visitorial
2825+ }
2826+}
2827+
2828+// MARK: Pneumocele convenience initializers and mutators
2829+
2830+extension Pneumocele {
2831+ convenience init(data: Data) throws {
2832+ let me = try newJSONDecoder().decode(Pneumocele.self, from: data)
2833+ 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)
2834+ }
2835+
2836+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2837+ guard let data = json.data(using: encoding) else {
2838+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2839+ }
2840+ try self.init(data: data)
2841+ }
2842+
2843+ convenience init(fromURL url: URL) throws {
2844+ try self.init(data: try Data(contentsOf: url))
2845+ }
2846+
2847+ func with(
2848+ carbonarism: JSONNull?? = nil,
2849+ catharticalness: Double?? = nil,
2850+ chirotherium: Int?? = nil,
2851+ cineolic: JSONNull?? = nil,
2852+ cobbly: JSONNull?? = nil,
2853+ conchyliferous: JSONNull?? = nil,
2854+ congregation: JSONNull?? = nil,
2855+ disdiapason: String?? = nil,
2856+ enterotomy: JSONNull?? = nil,
2857+ entophytal: JSONNull?? = nil,
2858+ fewtrils: JSONNull?? = nil,
2859+ herem: JSONNull?? = nil,
2860+ homocerc: Bool?? = nil,
2861+ koniga: JSONNull?? = nil,
2862+ meticulosity: JSONNull?? = nil,
2863+ micky: JSONNull?? = nil,
2864+ mismarriage: JSONNull?? = nil,
2865+ neurotrophic: JSONNull?? = nil,
2866+ nonbookish: JSONNull?? = nil,
2867+ persuasively: JSONNull?? = nil,
2868+ replaceable: JSONNull?? = nil,
2869+ silex: JSONNull?? = nil,
2870+ taillight: JSONNull?? = nil,
2871+ unjealous: JSONNull?? = nil,
2872+ visitorial: JSONNull?? = nil
2873+ ) -> Pneumocele {
2874+ return Pneumocele(
2875+ carbonarism: carbonarism ?? self.carbonarism,
2876+ catharticalness: catharticalness ?? self.catharticalness,
2877+ chirotherium: chirotherium ?? self.chirotherium,
2878+ cineolic: cineolic ?? self.cineolic,
2879+ cobbly: cobbly ?? self.cobbly,
2880+ conchyliferous: conchyliferous ?? self.conchyliferous,
2881+ congregation: congregation ?? self.congregation,
2882+ disdiapason: disdiapason ?? self.disdiapason,
2883+ enterotomy: enterotomy ?? self.enterotomy,
2884+ entophytal: entophytal ?? self.entophytal,
2885+ fewtrils: fewtrils ?? self.fewtrils,
2886+ herem: herem ?? self.herem,
2887+ homocerc: homocerc ?? self.homocerc,
2888+ koniga: koniga ?? self.koniga,
2889+ meticulosity: meticulosity ?? self.meticulosity,
2890+ micky: micky ?? self.micky,
2891+ mismarriage: mismarriage ?? self.mismarriage,
2892+ neurotrophic: neurotrophic ?? self.neurotrophic,
2893+ nonbookish: nonbookish ?? self.nonbookish,
2894+ persuasively: persuasively ?? self.persuasively,
2895+ replaceable: replaceable ?? self.replaceable,
2896+ silex: silex ?? self.silex,
2897+ taillight: taillight ?? self.taillight,
2898+ unjealous: unjealous ?? self.unjealous,
2899+ visitorial: visitorial ?? self.visitorial
2900+ )
2901+ }
2902+
2903+ func jsonData() throws -> Data {
2904+ return try newJSONEncoder().encode(self)
2905+ }
2906+
2907+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2908+ return String(data: try self.jsonData(), encoding: encoding)
2909+ }
2910+}
2911+
2912+enum Poliorcetic: Codable {
2913+ case bool(Bool)
2914+ case monaziteClass(MonaziteClass)
2915+
2916+ init(from decoder: Decoder) throws {
2917+ let container = try decoder.singleValueContainer()
2918+ if let x = try? container.decode(Bool.self) {
2919+ self = .bool(x)
2920+ return
2921+ }
2922+ if let x = try? container.decode(MonaziteClass.self) {
2923+ self = .monaziteClass(x)
2924+ return
2925+ }
2926+ throw DecodingError.typeMismatch(Poliorcetic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Poliorcetic"))
2927+ }
2928+
2929+ func encode(to encoder: Encoder) throws {
2930+ var container = encoder.singleValueContainer()
2931+ switch self {
2932+ case .bool(let x):
2933+ try container.encode(x)
2934+ case .monaziteClass(let x):
2935+ try container.encode(x)
2936+ }
2937+ }
2938+}
2939+
2940+enum Poormaster: Codable {
2941+ case integerArray([Int])
2942+ case integerMap([String: Int])
2943+ case null
2944+
2945+ init(from decoder: Decoder) throws {
2946+ let container = try decoder.singleValueContainer()
2947+ if let x = try? container.decode([Int].self) {
2948+ self = .integerArray(x)
2949+ return
2950+ }
2951+ if let x = try? container.decode([String: Int].self) {
2952+ self = .integerMap(x)
2953+ return
2954+ }
2955+ if container.decodeNil() {
2956+ self = .null
2957+ return
2958+ }
2959+ throw DecodingError.typeMismatch(Poormaster.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Poormaster"))
2960+ }
2961+
2962+ func encode(to encoder: Encoder) throws {
2963+ var container = encoder.singleValueContainer()
2964+ switch self {
2965+ case .integerArray(let x):
2966+ try container.encode(x)
2967+ case .integerMap(let x):
2968+ try container.encode(x)
2969+ case .null:
2970+ try container.encodeNil()
2971+ }
2972+ }
2973+}
2974+
2975+enum PotwhiskyElement: Codable {
2976+ case integer(Int)
2977+ case potwhiskyClass(PotwhiskyClass)
2978+ case null
2979+
2980+ init(from decoder: Decoder) throws {
2981+ let container = try decoder.singleValueContainer()
2982+ if let x = try? container.decode(Int.self) {
2983+ self = .integer(x)
2984+ return
2985+ }
2986+ if let x = try? container.decode(PotwhiskyClass.self) {
2987+ self = .potwhiskyClass(x)
2988+ return
2989+ }
2990+ if container.decodeNil() {
2991+ self = .null
2992+ return
2993+ }
2994+ throw DecodingError.typeMismatch(PotwhiskyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PotwhiskyElement"))
2995+ }
2996+
2997+ func encode(to encoder: Encoder) throws {
2998+ var container = encoder.singleValueContainer()
2999+ switch self {
3000+ case .integer(let x):
3001+ try container.encode(x)
3002+ case .potwhiskyClass(let x):
3003+ try container.encode(x)
3004+ case .null:
3005+ try container.encodeNil()
3006+ }
3007+ }
3008+}
3009+
3010+// MARK: - PotwhiskyClass
3011+final class PotwhiskyClass: Codable {
3012+ let arciform: JSONNull?
3013+ let cresolin: JSONNull?
3014+ let disheartener: JSONNull?
3015+ let disproportionable: JSONNull?
3016+ let euchorda: JSONNull?
3017+ let ferryway: JSONNull?
3018+ let filamentiferous: JSONNull?
3019+ let flemish: JSONNull?
3020+ let forgainst: JSONNull?
3021+ let grainering: JSONNull?
3022+ let irrevoluble: JSONNull?
3023+ let kindredship: JSONNull?
3024+ let pinguitudinous: JSONNull?
3025+ let simpletonic: JSONNull?
3026+ let singsong: JSONNull?
3027+ let submergement: JSONNull?
3028+ let supraoesophagal: JSONNull?
3029+ let thrashel: JSONNull?
3030+ let tyremesis: JSONNull?
3031+ let yoruba: JSONNull?
3032+
3033+ enum CodingKeys: String, CodingKey {
3034+ case arciform = "arciform"
3035+ case cresolin = "cresolin"
3036+ case disheartener = "disheartener"
3037+ case disproportionable = "disproportionable"
3038+ case euchorda = "Euchorda"
3039+ case ferryway = "ferryway"
3040+ case filamentiferous = "filamentiferous"
3041+ case flemish = "flemish"
3042+ case forgainst = "forgainst"
3043+ case grainering = "grainering"
3044+ case irrevoluble = "irrevoluble"
3045+ case kindredship = "kindredship"
3046+ case pinguitudinous = "pinguitudinous"
3047+ case simpletonic = "simpletonic"
3048+ case singsong = "singsong"
3049+ case submergement = "submergement"
3050+ case supraoesophagal = "supraoesophagal"
3051+ case thrashel = "thrashel"
3052+ case tyremesis = "tyremesis"
3053+ case yoruba = "Yoruba"
3054+ }
3055+
3056+ 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?) {
3057+ self.arciform = arciform
3058+ self.cresolin = cresolin
3059+ self.disheartener = disheartener
3060+ self.disproportionable = disproportionable
3061+ self.euchorda = euchorda
3062+ self.ferryway = ferryway
3063+ self.filamentiferous = filamentiferous
3064+ self.flemish = flemish
3065+ self.forgainst = forgainst
3066+ self.grainering = grainering
3067+ self.irrevoluble = irrevoluble
3068+ self.kindredship = kindredship
3069+ self.pinguitudinous = pinguitudinous
3070+ self.simpletonic = simpletonic
3071+ self.singsong = singsong
3072+ self.submergement = submergement
3073+ self.supraoesophagal = supraoesophagal
3074+ self.thrashel = thrashel
3075+ self.tyremesis = tyremesis
3076+ self.yoruba = yoruba
3077+ }
3078+}
3079+
3080+// MARK: PotwhiskyClass convenience initializers and mutators
3081+
3082+extension PotwhiskyClass {
3083+ convenience init(data: Data) throws {
3084+ let me = try newJSONDecoder().decode(PotwhiskyClass.self, from: data)
3085+ 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)
3086+ }
3087+
3088+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
3089+ guard let data = json.data(using: encoding) else {
3090+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
3091+ }
3092+ try self.init(data: data)
3093+ }
3094+
3095+ convenience init(fromURL url: URL) throws {
3096+ try self.init(data: try Data(contentsOf: url))
3097+ }
3098+
3099+ func with(
3100+ arciform: JSONNull?? = nil,
3101+ cresolin: JSONNull?? = nil,
3102+ disheartener: JSONNull?? = nil,
3103+ disproportionable: JSONNull?? = nil,
3104+ euchorda: JSONNull?? = nil,
3105+ ferryway: JSONNull?? = nil,
3106+ filamentiferous: JSONNull?? = nil,
3107+ flemish: JSONNull?? = nil,
3108+ forgainst: JSONNull?? = nil,
3109+ grainering: JSONNull?? = nil,
3110+ irrevoluble: JSONNull?? = nil,
3111+ kindredship: JSONNull?? = nil,
3112+ pinguitudinous: JSONNull?? = nil,
3113+ simpletonic: JSONNull?? = nil,
3114+ singsong: JSONNull?? = nil,
3115+ submergement: JSONNull?? = nil,
3116+ supraoesophagal: JSONNull?? = nil,
3117+ thrashel: JSONNull?? = nil,
3118+ tyremesis: JSONNull?? = nil,
3119+ yoruba: JSONNull?? = nil
3120+ ) -> PotwhiskyClass {
3121+ return PotwhiskyClass(
3122+ arciform: arciform ?? self.arciform,
3123+ cresolin: cresolin ?? self.cresolin,
3124+ disheartener: disheartener ?? self.disheartener,
3125+ disproportionable: disproportionable ?? self.disproportionable,
3126+ euchorda: euchorda ?? self.euchorda,
3127+ ferryway: ferryway ?? self.ferryway,
3128+ filamentiferous: filamentiferous ?? self.filamentiferous,
3129+ flemish: flemish ?? self.flemish,
3130+ forgainst: forgainst ?? self.forgainst,
3131+ grainering: grainering ?? self.grainering,
3132+ irrevoluble: irrevoluble ?? self.irrevoluble,
3133+ kindredship: kindredship ?? self.kindredship,
3134+ pinguitudinous: pinguitudinous ?? self.pinguitudinous,
3135+ simpletonic: simpletonic ?? self.simpletonic,
3136+ singsong: singsong ?? self.singsong,
3137+ submergement: submergement ?? self.submergement,
3138+ supraoesophagal: supraoesophagal ?? self.supraoesophagal,
3139+ thrashel: thrashel ?? self.thrashel,
3140+ tyremesis: tyremesis ?? self.tyremesis,
3141+ yoruba: yoruba ?? self.yoruba
3142+ )
3143+ }
3144+
3145+ func jsonData() throws -> Data {
3146+ return try newJSONEncoder().encode(self)
3147+ }
3148+
3149+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
3150+ return String(data: try self.jsonData(), encoding: encoding)
3151+ }
3152+}
3153+
3154+enum Practicalizer: Codable {
3155+ case monaziteClass(MonaziteClass)
3156+ case nullArray([JSONNull?])
3157+ case string(String)
3158+
3159+ init(from decoder: Decoder) throws {
3160+ let container = try decoder.singleValueContainer()
3161+ if let x = try? container.decode([JSONNull?].self) {
3162+ self = .nullArray(x)
3163+ return
3164+ }
3165+ if let x = try? container.decode(String.self) {
3166+ self = .string(x)
3167+ return
3168+ }
3169+ if let x = try? container.decode(MonaziteClass.self) {
3170+ self = .monaziteClass(x)
3171+ return
3172+ }
3173+ throw DecodingError.typeMismatch(Practicalizer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Practicalizer"))
3174+ }
3175+
3176+ func encode(to encoder: Encoder) throws {
3177+ var container = encoder.singleValueContainer()
3178+ switch self {
3179+ case .monaziteClass(let x):
3180+ try container.encode(x)
3181+ case .nullArray(let x):
3182+ try container.encode(x)
3183+ case .string(let x):
3184+ try container.encode(x)
3185+ }
3186+ }
3187+}
3188+
3189+enum PrefreshmanElement: Codable {
3190+ case nullArray([JSONNull?])
3191+ case prefreshmanClass(PrefreshmanClass)
3192+ case string(String)
3193+
3194+ init(from decoder: Decoder) throws {
3195+ let container = try decoder.singleValueContainer()
3196+ if let x = try? container.decode([JSONNull?].self) {
3197+ self = .nullArray(x)
3198+ return
3199+ }
3200+ if let x = try? container.decode(String.self) {
3201+ self = .string(x)
3202+ return
3203+ }
3204+ if let x = try? container.decode(PrefreshmanClass.self) {
3205+ self = .prefreshmanClass(x)
3206+ return
3207+ }
3208+ throw DecodingError.typeMismatch(PrefreshmanElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PrefreshmanElement"))
3209+ }
3210+
3211+ func encode(to encoder: Encoder) throws {
3212+ var container = encoder.singleValueContainer()
3213+ switch self {
3214+ case .nullArray(let x):
3215+ try container.encode(x)
3216+ case .prefreshmanClass(let x):
3217+ try container.encode(x)
3218+ case .string(let x):
3219+ try container.encode(x)
3220+ }
3221+ }
3222+}
3223+
3224+// MARK: - PrefreshmanClass
3225+final class PrefreshmanClass: Codable {
3226+ let azorubine: JSONNull?
3227+ let choroiditis: JSONNull?
3228+ let coagulatory: JSONNull?
3229+ let cyclorama: JSONNull?
3230+ let dolphus: JSONNull?
3231+ let duckhearted: JSONNull?
3232+ let ficus: JSONNull?
3233+ let gemaric: JSONNull?
3234+ let jugation: JSONNull?
3235+ let myoliposis: JSONNull?
3236+ let nonnomination: JSONNull?
3237+ let palay: JSONNull?
3238+ let pentactinal: JSONNull?
3239+ let phaet: JSONNull?
3240+ let piquant: JSONNull?
3241+ let registration: JSONNull?
3242+ let remancipation: JSONNull?
3243+ let scutatiform: JSONNull?
3244+ let theodolite: JSONNull?
3245+ let underward: JSONNull?
3246+
3247+ enum CodingKeys: String, CodingKey {
3248+ case azorubine = "azorubine"
3249+ case choroiditis = "choroiditis"
3250+ case coagulatory = "coagulatory"
3251+ case cyclorama = "cyclorama"
3252+ case dolphus = "Dolphus"
3253+ case duckhearted = "duckhearted"
3254+ case ficus = "Ficus"
3255+ case gemaric = "Gemaric"
3256+ case jugation = "jugation"
3257+ case myoliposis = "myoliposis"
3258+ case nonnomination = "nonnomination"
3259+ case palay = "palay"
3260+ case pentactinal = "pentactinal"
3261+ case phaet = "Phaet"
3262+ case piquant = "piquant"
3263+ case registration = "registration"
3264+ case remancipation = "remancipation"
3265+ case scutatiform = "scutatiform"
3266+ case theodolite = "theodolite"
3267+ case underward = "underward"
3268+ }
3269+
3270+ 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?) {
3271+ self.azorubine = azorubine
3272+ self.choroiditis = choroiditis
3273+ self.coagulatory = coagulatory
3274+ self.cyclorama = cyclorama
3275+ self.dolphus = dolphus
3276+ self.duckhearted = duckhearted
3277+ self.ficus = ficus
3278+ self.gemaric = gemaric
3279+ self.jugation = jugation
3280+ self.myoliposis = myoliposis
3281+ self.nonnomination = nonnomination
3282+ self.palay = palay
3283+ self.pentactinal = pentactinal
3284+ self.phaet = phaet
3285+ self.piquant = piquant
3286+ self.registration = registration
3287+ self.remancipation = remancipation
3288+ self.scutatiform = scutatiform
3289+ self.theodolite = theodolite
3290+ self.underward = underward
3291+ }
3292+}
3293+
3294+// MARK: PrefreshmanClass convenience initializers and mutators
3295+
3296+extension PrefreshmanClass {
3297+ convenience init(data: Data) throws {
3298+ let me = try newJSONDecoder().decode(PrefreshmanClass.self, from: data)
3299+ 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)
3300+ }
3301+
3302+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
3303+ guard let data = json.data(using: encoding) else {
3304+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
3305+ }
3306+ try self.init(data: data)
3307+ }
3308+
3309+ convenience init(fromURL url: URL) throws {
3310+ try self.init(data: try Data(contentsOf: url))
3311+ }
3312+
3313+ func with(
3314+ azorubine: JSONNull?? = nil,
3315+ choroiditis: JSONNull?? = nil,
3316+ coagulatory: JSONNull?? = nil,
3317+ cyclorama: JSONNull?? = nil,
3318+ dolphus: JSONNull?? = nil,
3319+ duckhearted: JSONNull?? = nil,
3320+ ficus: JSONNull?? = nil,
3321+ gemaric: JSONNull?? = nil,
3322+ jugation: JSONNull?? = nil,
3323+ myoliposis: JSONNull?? = nil,
3324+ nonnomination: JSONNull?? = nil,
3325+ palay: JSONNull?? = nil,
3326+ pentactinal: JSONNull?? = nil,
3327+ phaet: JSONNull?? = nil,
3328+ piquant: JSONNull?? = nil,
3329+ registration: JSONNull?? = nil,
3330+ remancipation: JSONNull?? = nil,
3331+ scutatiform: JSONNull?? = nil,
3332+ theodolite: JSONNull?? = nil,
3333+ underward: JSONNull?? = nil
3334+ ) -> PrefreshmanClass {
3335+ return PrefreshmanClass(
3336+ azorubine: azorubine ?? self.azorubine,
3337+ choroiditis: choroiditis ?? self.choroiditis,
3338+ coagulatory: coagulatory ?? self.coagulatory,
3339+ cyclorama: cyclorama ?? self.cyclorama,
3340+ dolphus: dolphus ?? self.dolphus,
3341+ duckhearted: duckhearted ?? self.duckhearted,
3342+ ficus: ficus ?? self.ficus,
3343+ gemaric: gemaric ?? self.gemaric,
3344+ jugation: jugation ?? self.jugation,
3345+ myoliposis: myoliposis ?? self.myoliposis,
3346+ nonnomination: nonnomination ?? self.nonnomination,
3347+ palay: palay ?? self.palay,
3348+ pentactinal: pentactinal ?? self.pentactinal,
3349+ phaet: phaet ?? self.phaet,
3350+ piquant: piquant ?? self.piquant,
3351+ registration: registration ?? self.registration,
3352+ remancipation: remancipation ?? self.remancipation,
3353+ scutatiform: scutatiform ?? self.scutatiform,
3354+ theodolite: theodolite ?? self.theodolite,
3355+ underward: underward ?? self.underward
3356+ )
3357+ }
3358+
3359+ func jsonData() throws -> Data {
3360+ return try newJSONEncoder().encode(self)
3361+ }
3362+
3363+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
3364+ return String(data: try self.jsonData(), encoding: encoding)
3365+ }
3366+}
3367+
3368+enum Prehensility: Codable {
3369+ case bool(Bool)
3370+ case monaziteClass(MonaziteClass)
3371+ case nullArray([JSONNull?])
3372+
3373+ init(from decoder: Decoder) throws {
3374+ let container = try decoder.singleValueContainer()
3375+ if let x = try? container.decode(Bool.self) {
3376+ self = .bool(x)
3377+ return
3378+ }
3379+ if let x = try? container.decode([JSONNull?].self) {
3380+ self = .nullArray(x)
3381+ return
3382+ }
3383+ if let x = try? container.decode(MonaziteClass.self) {
3384+ self = .monaziteClass(x)
3385+ return
3386+ }
3387+ throw DecodingError.typeMismatch(Prehensility.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Prehensility"))
3388+ }
3389+
3390+ func encode(to encoder: Encoder) throws {
3391+ var container = encoder.singleValueContainer()
3392+ switch self {
3393+ case .bool(let x):
3394+ try container.encode(x)
3395+ case .monaziteClass(let x):
3396+ try container.encode(x)
3397+ case .nullArray(let x):
3398+ try container.encode(x)
3399+ }
3400+ }
3401+}
3402+
3403+enum Prevoidance: Codable {
3404+ case integer(Int)
3405+ case integerArray([Int])
3406+ case monaziteClass(MonaziteClass)
3407+
3408+ init(from decoder: Decoder) throws {
3409+ let container = try decoder.singleValueContainer()
3410+ if let x = try? container.decode(Int.self) {
3411+ self = .integer(x)
3412+ return
3413+ }
3414+ if let x = try? container.decode([Int].self) {
3415+ self = .integerArray(x)
3416+ return
3417+ }
3418+ if let x = try? container.decode(MonaziteClass.self) {
3419+ self = .monaziteClass(x)
3420+ return
3421+ }
3422+ throw DecodingError.typeMismatch(Prevoidance.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Prevoidance"))
3423+ }
3424+
3425+ func encode(to encoder: Encoder) throws {
3426+ var container = encoder.singleValueContainer()
3427+ switch self {
3428+ case .integer(let x):
3429+ try container.encode(x)
3430+ case .integerArray(let x):
3431+ try container.encode(x)
3432+ case .monaziteClass(let x):
3433+ try container.encode(x)
3434+ }
3435+ }
3436+}
3437+
3438+enum Protext: Codable {
3439+ case bool(Bool)
3440+ case integerArray([Int])
3441+ case monaziteClass(MonaziteClass)
3442+
3443+ init(from decoder: Decoder) throws {
3444+ let container = try decoder.singleValueContainer()
3445+ if let x = try? container.decode(Bool.self) {
3446+ self = .bool(x)
3447+ return
3448+ }
3449+ if let x = try? container.decode([Int].self) {
3450+ self = .integerArray(x)
3451+ return
3452+ }
3453+ if let x = try? container.decode(MonaziteClass.self) {
3454+ self = .monaziteClass(x)
3455+ return
3456+ }
3457+ throw DecodingError.typeMismatch(Protext.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Protext"))
3458+ }
3459+
3460+ func encode(to encoder: Encoder) throws {
3461+ var container = encoder.singleValueContainer()
3462+ switch self {
3463+ case .bool(let x):
3464+ try container.encode(x)
3465+ case .integerArray(let x):
3466+ try container.encode(x)
3467+ case .monaziteClass(let x):
3468+ try container.encode(x)
3469+ }
3470+ }
3471+}
3472+
3473+// MARK: - Helper functions for creating encoders and decoders
3474+
3475+func newJSONDecoder() -> JSONDecoder {
3476+ let decoder = JSONDecoder()
3477+ decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in
3478+ let container = try decoder.singleValueContainer()
3479+ let dateStr = try container.decode(String.self)
3480+
3481+ let formatter = DateFormatter()
3482+ formatter.calendar = Calendar(identifier: .iso8601)
3483+ formatter.locale = Locale(identifier: "en_US_POSIX")
3484+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
3485+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX"
3486+ if let date = formatter.date(from: dateStr) {
3487+ return date
3488+ }
3489+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX"
3490+ if let date = formatter.date(from: dateStr) {
3491+ return date
3492+ }
3493+ throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date"))
3494+ })
3495+ return decoder
3496+}
3497+
3498+func newJSONEncoder() -> JSONEncoder {
3499+ let encoder = JSONEncoder()
3500+ let formatter = DateFormatter()
3501+ formatter.calendar = Calendar(identifier: .iso8601)
3502+ formatter.locale = Locale(identifier: "en_US_POSIX")
3503+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
3504+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSXXXXX"
3505+ encoder.dateEncodingStrategy = .formatted(formatter)
3506+ return encoder
3507+}
3508+
3509+// MARK: - Encode/decode helpers
3510+
3511+final class JSONNull: Codable, Hashable {
3512+
3513+ public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool {
3514+ return true
3515+ }
3516+
3517+ public func hash(into hasher: inout Hasher) {
3518+ hasher.combine(0)
3519+ }
3520+
3521+ public init() {}
3522+
3523+ public required init(from decoder: Decoder) throws {
3524+ let container = try decoder.singleValueContainer()
3525+ if !container.decodeNil() {
3526+ throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull"))
3527+ }
3528+ }
3529+
3530+ public func encode(to encoder: Encoder) throws {
3531+ var container = encoder.singleValueContainer()
3532+ try container.encodeNil()
3533+ }
3534+}
Aswiftprotocol-hashable--739b516c7897 / quicktype.swift+3,227 −0
@@ -0,0 +1,3227 @@
1+// This file was generated from JSON Schema using quicktype, do not modify it directly.
2+// To parse the JSON, add this file to your project and do:
3+//
4+// let topLevel = try TopLevel(json)
5+
6+//
7+// Hashable or Equatable:
8+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
9+// for types that require the use of JSONAny, nor will the implementation of Hashable be
10+// synthesized for types that have collections (such as arrays or dictionaries).
11+
12+import Foundation
13+
14+// MARK: - TopLevel
15+struct TopLevel: Codable, Hashable {
16+ let juror: [JurorElement]
17+ let kongoni: [Kongoni]
18+ let ladronism: [LadronismElement]
19+ let landlubberly: [LandlubberlyElement]
20+ let listener: [Listener]
21+ let lupus: [LupusElement]
22+ let maslin: [Maslin]
23+ let monazite: [MonaziteElement]
24+ let monoliteral: [Monoliteral]
25+ let monotheistically: [MonotheisticallyElement]
26+ let montage: [Montage]
27+ let moralness: [Moralness]
28+ let mowra: [MonaziteClass?]
29+ let mulishly: [Mulishly]
30+ let myoscope: [Myoscope]
31+ let nach: [[Int?]?]
32+ let neuromastic: [Neuromastic]
33+ let noncontributing: [Noncontributing]
34+ let nonnervous: [Nonnervous]
35+ let nonvaluation: [Nonvaluation]
36+ let occupationalist: [OccupationalistElement]
37+ let outrival: [OutrivalElement]
38+ let paleographically: [Paleographically]
39+ let pamphletwise: [Pamphletwise]
40+ let pediatrics: [Pediatric]
41+ let perceptive: [Bool]
42+ let piaculum: [PiaculumElement]
43+ let piccadilly: [Piccadilly]
44+ let piffler: [Piffler]
45+ let pithful: [Pithful]
46+ let placuntitis: [Placuntiti]
47+ let plectopterous: [Plectopterous]
48+ let pneumocele: [Pneumocele?]
49+ let poliorcetic: [Poliorcetic]
50+ let poormaster: [Poormaster]
51+ let potwhisky: [PotwhiskyElement]
52+ let practicalizer: [Practicalizer]
53+ let prefreshman: [PrefreshmanElement]
54+ let prehensility: [Prehensility]
55+ let prevoidance: [Prevoidance]
56+ let probant: [[String: Int?]]
57+ let protext: [Protext]
58+
59+ enum CodingKeys: String, CodingKey {
60+ case juror = "juror"
61+ case kongoni = "kongoni"
62+ case ladronism = "ladronism"
63+ case landlubberly = "landlubberly"
64+ case listener = "listener"
65+ case lupus = "lupus"
66+ case maslin = "maslin"
67+ case monazite = "monazite"
68+ case monoliteral = "monoliteral"
69+ case monotheistically = "monotheistically"
70+ case montage = "montage"
71+ case moralness = "moralness"
72+ case mowra = "mowra"
73+ case mulishly = "mulishly"
74+ case myoscope = "myoscope"
75+ case nach = "nach"
76+ case neuromastic = "neuromastic"
77+ case noncontributing = "noncontributing"
78+ case nonnervous = "nonnervous"
79+ case nonvaluation = "nonvaluation"
80+ case occupationalist = "occupationalist"
81+ case outrival = "outrival"
82+ case paleographically = "paleographically"
83+ case pamphletwise = "pamphletwise"
84+ case pediatrics = "pediatrics"
85+ case perceptive = "perceptive"
86+ case piaculum = "piaculum"
87+ case piccadilly = "piccadilly"
88+ case piffler = "piffler"
89+ case pithful = "pithful"
90+ case placuntitis = "placuntitis"
91+ case plectopterous = "plectopterous"
92+ case pneumocele = "pneumocele"
93+ case poliorcetic = "poliorcetic"
94+ case poormaster = "poormaster"
95+ case potwhisky = "potwhisky"
96+ case practicalizer = "practicalizer"
97+ case prefreshman = "prefreshman"
98+ case prehensility = "prehensility"
99+ case prevoidance = "prevoidance"
100+ case probant = "probant"
101+ case protext = "protext"
102+ }
103+}
104+
105+// MARK: TopLevel convenience initializers and mutators
106+
107+extension TopLevel {
108+ init(data: Data) throws {
109+ self = try newJSONDecoder().decode(TopLevel.self, from: data)
110+ }
111+
112+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
113+ guard let data = json.data(using: encoding) else {
114+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
115+ }
116+ try self.init(data: data)
117+ }
118+
119+ init(fromURL url: URL) throws {
120+ try self.init(data: try Data(contentsOf: url))
121+ }
122+
123+ func with(
124+ juror: [JurorElement]? = nil,
125+ kongoni: [Kongoni]? = nil,
126+ ladronism: [LadronismElement]? = nil,
127+ landlubberly: [LandlubberlyElement]? = nil,
128+ listener: [Listener]? = nil,
129+ lupus: [LupusElement]? = nil,
130+ maslin: [Maslin]? = nil,
131+ monazite: [MonaziteElement]? = nil,
132+ monoliteral: [Monoliteral]? = nil,
133+ monotheistically: [MonotheisticallyElement]? = nil,
134+ montage: [Montage]? = nil,
135+ moralness: [Moralness]? = nil,
136+ mowra: [MonaziteClass?]? = nil,
137+ mulishly: [Mulishly]? = nil,
138+ myoscope: [Myoscope]? = nil,
139+ nach: [[Int?]?]? = nil,
140+ neuromastic: [Neuromastic]? = nil,
141+ noncontributing: [Noncontributing]? = nil,
142+ nonnervous: [Nonnervous]? = nil,
143+ nonvaluation: [Nonvaluation]? = nil,
144+ occupationalist: [OccupationalistElement]? = nil,
145+ outrival: [OutrivalElement]? = nil,
146+ paleographically: [Paleographically]? = nil,
147+ pamphletwise: [Pamphletwise]? = nil,
148+ pediatrics: [Pediatric]? = nil,
149+ perceptive: [Bool]? = nil,
150+ piaculum: [PiaculumElement]? = nil,
151+ piccadilly: [Piccadilly]? = nil,
152+ piffler: [Piffler]? = nil,
153+ pithful: [Pithful]? = nil,
154+ placuntitis: [Placuntiti]? = nil,
155+ plectopterous: [Plectopterous]? = nil,
156+ pneumocele: [Pneumocele?]? = nil,
157+ poliorcetic: [Poliorcetic]? = nil,
158+ poormaster: [Poormaster]? = nil,
159+ potwhisky: [PotwhiskyElement]? = nil,
160+ practicalizer: [Practicalizer]? = nil,
161+ prefreshman: [PrefreshmanElement]? = nil,
162+ prehensility: [Prehensility]? = nil,
163+ prevoidance: [Prevoidance]? = nil,
164+ probant: [[String: Int?]]? = nil,
165+ protext: [Protext]? = nil
166+ ) -> TopLevel {
167+ return TopLevel(
168+ juror: juror ?? self.juror,
169+ kongoni: kongoni ?? self.kongoni,
170+ ladronism: ladronism ?? self.ladronism,
171+ landlubberly: landlubberly ?? self.landlubberly,
172+ listener: listener ?? self.listener,
173+ lupus: lupus ?? self.lupus,
174+ maslin: maslin ?? self.maslin,
175+ monazite: monazite ?? self.monazite,
176+ monoliteral: monoliteral ?? self.monoliteral,
177+ monotheistically: monotheistically ?? self.monotheistically,
178+ montage: montage ?? self.montage,
179+ moralness: moralness ?? self.moralness,
180+ mowra: mowra ?? self.mowra,
181+ mulishly: mulishly ?? self.mulishly,
182+ myoscope: myoscope ?? self.myoscope,
183+ nach: nach ?? self.nach,
184+ neuromastic: neuromastic ?? self.neuromastic,
185+ noncontributing: noncontributing ?? self.noncontributing,
186+ nonnervous: nonnervous ?? self.nonnervous,
187+ nonvaluation: nonvaluation ?? self.nonvaluation,
188+ occupationalist: occupationalist ?? self.occupationalist,
189+ outrival: outrival ?? self.outrival,
190+ paleographically: paleographically ?? self.paleographically,
191+ pamphletwise: pamphletwise ?? self.pamphletwise,
192+ pediatrics: pediatrics ?? self.pediatrics,
193+ perceptive: perceptive ?? self.perceptive,
194+ piaculum: piaculum ?? self.piaculum,
195+ piccadilly: piccadilly ?? self.piccadilly,
196+ piffler: piffler ?? self.piffler,
197+ pithful: pithful ?? self.pithful,
198+ placuntitis: placuntitis ?? self.placuntitis,
199+ plectopterous: plectopterous ?? self.plectopterous,
200+ pneumocele: pneumocele ?? self.pneumocele,
201+ poliorcetic: poliorcetic ?? self.poliorcetic,
202+ poormaster: poormaster ?? self.poormaster,
203+ potwhisky: potwhisky ?? self.potwhisky,
204+ practicalizer: practicalizer ?? self.practicalizer,
205+ prefreshman: prefreshman ?? self.prefreshman,
206+ prehensility: prehensility ?? self.prehensility,
207+ prevoidance: prevoidance ?? self.prevoidance,
208+ probant: probant ?? self.probant,
209+ protext: protext ?? self.protext
210+ )
211+ }
212+
213+ func jsonData() throws -> Data {
214+ return try newJSONEncoder().encode(self)
215+ }
216+
217+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
218+ return String(data: try self.jsonData(), encoding: encoding)
219+ }
220+}
221+
222+enum JurorElement: Codable, Hashable {
223+ case bool(Bool)
224+ case jurorClass(JurorClass)
225+
226+ init(from decoder: Decoder) throws {
227+ let container = try decoder.singleValueContainer()
228+ if let x = try? container.decode(Bool.self) {
229+ self = .bool(x)
230+ return
231+ }
232+ if let x = try? container.decode(JurorClass.self) {
233+ self = .jurorClass(x)
234+ return
235+ }
236+ throw DecodingError.typeMismatch(JurorElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JurorElement"))
237+ }
238+
239+ func encode(to encoder: Encoder) throws {
240+ var container = encoder.singleValueContainer()
241+ switch self {
242+ case .bool(let x):
243+ try container.encode(x)
244+ case .jurorClass(let x):
245+ try container.encode(x)
246+ }
247+ }
248+}
249+
250+//
251+// Hashable or Equatable:
252+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
253+// for types that require the use of JSONAny, nor will the implementation of Hashable be
254+// synthesized for types that have collections (such as arrays or dictionaries).
255+
256+// MARK: - JurorClass
257+struct JurorClass: Codable, Hashable {
258+ let adipsy: JSONNull?
259+ let auxiliator: JSONNull?
260+ let benda: JSONNull?
261+ let benjamin: JSONNull?
262+ let brandling: JSONNull?
263+ let epicurishly: JSONNull?
264+ let eremochaetous: JSONNull?
265+ let marten: JSONNull?
266+ let monocline: JSONNull?
267+ let olea: JSONNull?
268+ let palgat: JSONNull?
269+ let pennyworth: JSONNull?
270+ let pioury: JSONNull?
271+ let pragmatistic: JSONNull?
272+ let stylelessness: JSONNull?
273+ let systematical: JSONNull?
274+ let thready: JSONNull?
275+ let uncontemporary: JSONNull?
276+ let uncouched: JSONNull?
277+ let uninhabitedness: JSONNull?
278+
279+ enum CodingKeys: String, CodingKey {
280+ case adipsy = "adipsy"
281+ case auxiliator = "auxiliator"
282+ case benda = "benda"
283+ case benjamin = "benjamin"
284+ case brandling = "brandling"
285+ case epicurishly = "epicurishly"
286+ case eremochaetous = "eremochaetous"
287+ case marten = "marten"
288+ case monocline = "monocline"
289+ case olea = "Olea"
290+ case palgat = "palgat"
291+ case pennyworth = "pennyworth"
292+ case pioury = "pioury"
293+ case pragmatistic = "pragmatistic"
294+ case stylelessness = "stylelessness"
295+ case systematical = "systematical"
296+ case thready = "thready"
297+ case uncontemporary = "uncontemporary"
298+ case uncouched = "uncouched"
299+ case uninhabitedness = "uninhabitedness"
300+ }
301+}
302+
303+// MARK: JurorClass convenience initializers and mutators
304+
305+extension JurorClass {
306+ init(data: Data) throws {
307+ self = try newJSONDecoder().decode(JurorClass.self, from: data)
308+ }
309+
310+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
311+ guard let data = json.data(using: encoding) else {
312+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
313+ }
314+ try self.init(data: data)
315+ }
316+
317+ init(fromURL url: URL) throws {
318+ try self.init(data: try Data(contentsOf: url))
319+ }
320+
321+ func with(
322+ adipsy: JSONNull?? = nil,
323+ auxiliator: JSONNull?? = nil,
324+ benda: JSONNull?? = nil,
325+ benjamin: JSONNull?? = nil,
326+ brandling: JSONNull?? = nil,
327+ epicurishly: JSONNull?? = nil,
328+ eremochaetous: JSONNull?? = nil,
329+ marten: JSONNull?? = nil,
330+ monocline: JSONNull?? = nil,
331+ olea: JSONNull?? = nil,
332+ palgat: JSONNull?? = nil,
333+ pennyworth: JSONNull?? = nil,
334+ pioury: JSONNull?? = nil,
335+ pragmatistic: JSONNull?? = nil,
336+ stylelessness: JSONNull?? = nil,
337+ systematical: JSONNull?? = nil,
338+ thready: JSONNull?? = nil,
339+ uncontemporary: JSONNull?? = nil,
340+ uncouched: JSONNull?? = nil,
341+ uninhabitedness: JSONNull?? = nil
342+ ) -> JurorClass {
343+ return JurorClass(
344+ adipsy: adipsy ?? self.adipsy,
345+ auxiliator: auxiliator ?? self.auxiliator,
346+ benda: benda ?? self.benda,
347+ benjamin: benjamin ?? self.benjamin,
348+ brandling: brandling ?? self.brandling,
349+ epicurishly: epicurishly ?? self.epicurishly,
350+ eremochaetous: eremochaetous ?? self.eremochaetous,
351+ marten: marten ?? self.marten,
352+ monocline: monocline ?? self.monocline,
353+ olea: olea ?? self.olea,
354+ palgat: palgat ?? self.palgat,
355+ pennyworth: pennyworth ?? self.pennyworth,
356+ pioury: pioury ?? self.pioury,
357+ pragmatistic: pragmatistic ?? self.pragmatistic,
358+ stylelessness: stylelessness ?? self.stylelessness,
359+ systematical: systematical ?? self.systematical,
360+ thready: thready ?? self.thready,
361+ uncontemporary: uncontemporary ?? self.uncontemporary,
362+ uncouched: uncouched ?? self.uncouched,
363+ uninhabitedness: uninhabitedness ?? self.uninhabitedness
364+ )
365+ }
366+
367+ func jsonData() throws -> Data {
368+ return try newJSONEncoder().encode(self)
369+ }
370+
371+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
372+ return String(data: try self.jsonData(), encoding: encoding)
373+ }
374+}
375+
376+enum Kongoni: Codable, Hashable {
377+ case integerArray([Int])
378+ case integerMap([String: Int])
379+
380+ init(from decoder: Decoder) throws {
381+ let container = try decoder.singleValueContainer()
382+ if let x = try? container.decode([Int].self) {
383+ self = .integerArray(x)
384+ return
385+ }
386+ if let x = try? container.decode([String: Int].self) {
387+ self = .integerMap(x)
388+ return
389+ }
390+ throw DecodingError.typeMismatch(Kongoni.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Kongoni"))
391+ }
392+
393+ func encode(to encoder: Encoder) throws {
394+ var container = encoder.singleValueContainer()
395+ switch self {
396+ case .integerArray(let x):
397+ try container.encode(x)
398+ case .integerMap(let x):
399+ try container.encode(x)
400+ }
401+ }
402+}
403+
404+enum LadronismElement: Codable, Hashable {
405+ case double(Double)
406+ case ladronismClass(LadronismClass)
407+ case string(String)
408+
409+ init(from decoder: Decoder) throws {
410+ let container = try decoder.singleValueContainer()
411+ if let x = try? container.decode(Double.self) {
412+ self = .double(x)
413+ return
414+ }
415+ if let x = try? container.decode(String.self) {
416+ self = .string(x)
417+ return
418+ }
419+ if let x = try? container.decode(LadronismClass.self) {
420+ self = .ladronismClass(x)
421+ return
422+ }
423+ throw DecodingError.typeMismatch(LadronismElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for LadronismElement"))
424+ }
425+
426+ func encode(to encoder: Encoder) throws {
427+ var container = encoder.singleValueContainer()
428+ switch self {
429+ case .double(let x):
430+ try container.encode(x)
431+ case .ladronismClass(let x):
432+ try container.encode(x)
433+ case .string(let x):
434+ try container.encode(x)
435+ }
436+ }
437+}
438+
439+//
440+// Hashable or Equatable:
441+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
442+// for types that require the use of JSONAny, nor will the implementation of Hashable be
443+// synthesized for types that have collections (such as arrays or dictionaries).
444+
445+// MARK: - LadronismClass
446+struct LadronismClass: Codable, Hashable {
447+ let acclaimer: JSONNull?
448+ let achree: JSONNull?
449+ let base: JSONNull?
450+ let conundrumize: JSONNull?
451+ let degerminator: JSONNull?
452+ let describable: JSONNull?
453+ let exasperatedly: JSONNull?
454+ let heroine: JSONNull?
455+ let indazin: JSONNull?
456+ let luteous: JSONNull?
457+ let papular: JSONNull?
458+ let pritch: JSONNull?
459+ let prodenia: JSONNull?
460+ let seege: JSONNull?
461+ let shopgirl: JSONNull?
462+ let tragedietta: JSONNull?
463+ let unsparse: JSONNull?
464+ let uplook: JSONNull?
465+ let vermiformis: JSONNull?
466+ let whafabout: JSONNull?
467+
468+ enum CodingKeys: String, CodingKey {
469+ case acclaimer = "acclaimer"
470+ case achree = "achree"
471+ case base = "base"
472+ case conundrumize = "conundrumize"
473+ case degerminator = "degerminator"
474+ case describable = "describable"
475+ case exasperatedly = "exasperatedly"
476+ case heroine = "heroine"
477+ case indazin = "indazin"
478+ case luteous = "luteous"
479+ case papular = "papular"
480+ case pritch = "pritch"
481+ case prodenia = "Prodenia"
482+ case seege = "seege"
483+ case shopgirl = "shopgirl"
484+ case tragedietta = "tragedietta"
485+ case unsparse = "unsparse"
486+ case uplook = "uplook"
487+ case vermiformis = "vermiformis"
488+ case whafabout = "whafabout"
489+ }
490+}
491+
492+// MARK: LadronismClass convenience initializers and mutators
493+
494+extension LadronismClass {
495+ init(data: Data) throws {
496+ self = try newJSONDecoder().decode(LadronismClass.self, from: data)
497+ }
498+
499+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
500+ guard let data = json.data(using: encoding) else {
501+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
502+ }
503+ try self.init(data: data)
504+ }
505+
506+ init(fromURL url: URL) throws {
507+ try self.init(data: try Data(contentsOf: url))
508+ }
509+
510+ func with(
511+ acclaimer: JSONNull?? = nil,
512+ achree: JSONNull?? = nil,
513+ base: JSONNull?? = nil,
514+ conundrumize: JSONNull?? = nil,
515+ degerminator: JSONNull?? = nil,
516+ describable: JSONNull?? = nil,
517+ exasperatedly: JSONNull?? = nil,
518+ heroine: JSONNull?? = nil,
519+ indazin: JSONNull?? = nil,
520+ luteous: JSONNull?? = nil,
521+ papular: JSONNull?? = nil,
522+ pritch: JSONNull?? = nil,
523+ prodenia: JSONNull?? = nil,
524+ seege: JSONNull?? = nil,
525+ shopgirl: JSONNull?? = nil,
526+ tragedietta: JSONNull?? = nil,
527+ unsparse: JSONNull?? = nil,
528+ uplook: JSONNull?? = nil,
529+ vermiformis: JSONNull?? = nil,
530+ whafabout: JSONNull?? = nil
531+ ) -> LadronismClass {
532+ return LadronismClass(
533+ acclaimer: acclaimer ?? self.acclaimer,
534+ achree: achree ?? self.achree,
535+ base: base ?? self.base,
536+ conundrumize: conundrumize ?? self.conundrumize,
537+ degerminator: degerminator ?? self.degerminator,
538+ describable: describable ?? self.describable,
539+ exasperatedly: exasperatedly ?? self.exasperatedly,
540+ heroine: heroine ?? self.heroine,
541+ indazin: indazin ?? self.indazin,
542+ luteous: luteous ?? self.luteous,
543+ papular: papular ?? self.papular,
544+ pritch: pritch ?? self.pritch,
545+ prodenia: prodenia ?? self.prodenia,
546+ seege: seege ?? self.seege,
547+ shopgirl: shopgirl ?? self.shopgirl,
548+ tragedietta: tragedietta ?? self.tragedietta,
549+ unsparse: unsparse ?? self.unsparse,
550+ uplook: uplook ?? self.uplook,
551+ vermiformis: vermiformis ?? self.vermiformis,
552+ whafabout: whafabout ?? self.whafabout
553+ )
554+ }
555+
556+ func jsonData() throws -> Data {
557+ return try newJSONEncoder().encode(self)
558+ }
559+
560+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
561+ return String(data: try self.jsonData(), encoding: encoding)
562+ }
563+}
564+
565+enum LandlubberlyElement: Codable, Hashable {
566+ case bool(Bool)
567+ case integer(Int)
568+ case landlubberlyClass(LandlubberlyClass)
569+
570+ init(from decoder: Decoder) throws {
571+ let container = try decoder.singleValueContainer()
572+ if let x = try? container.decode(Bool.self) {
573+ self = .bool(x)
574+ return
575+ }
576+ if let x = try? container.decode(Int.self) {
577+ self = .integer(x)
578+ return
579+ }
580+ if let x = try? container.decode(LandlubberlyClass.self) {
581+ self = .landlubberlyClass(x)
582+ return
583+ }
584+ throw DecodingError.typeMismatch(LandlubberlyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for LandlubberlyElement"))
585+ }
586+
587+ func encode(to encoder: Encoder) throws {
588+ var container = encoder.singleValueContainer()
589+ switch self {
590+ case .bool(let x):
591+ try container.encode(x)
592+ case .integer(let x):
593+ try container.encode(x)
594+ case .landlubberlyClass(let x):
595+ try container.encode(x)
596+ }
597+ }
598+}
599+
600+//
601+// Hashable or Equatable:
602+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
603+// for types that require the use of JSONAny, nor will the implementation of Hashable be
604+// synthesized for types that have collections (such as arrays or dictionaries).
605+
606+// MARK: - LandlubberlyClass
607+struct LandlubberlyClass: Codable, Hashable {
608+ let acropoleis: JSONNull?
609+ let aminate: JSONNull?
610+ let amyraldism: JSONNull?
611+ let bipenniform: JSONNull?
612+ let bugre: JSONNull?
613+ let calycule: JSONNull?
614+ let caoutchouc: JSONNull?
615+ let disprover: JSONNull?
616+ let fitroot: JSONNull?
617+ let fulgently: JSONNull?
618+ let kickup: JSONNull?
619+ let laevoversion: JSONNull?
620+ let moter: JSONNull?
621+ let objectivity: JSONNull?
622+ let posterity: JSONNull?
623+ let postnuptial: JSONNull?
624+ let precedentary: JSONNull?
625+ let saddling: JSONNull?
626+ let subcurrent: JSONNull?
627+ let unrecriminative: JSONNull?
628+
629+ enum CodingKeys: String, CodingKey {
630+ case acropoleis = "acropoleis"
631+ case aminate = "aminate"
632+ case amyraldism = "Amyraldism"
633+ case bipenniform = "bipenniform"
634+ case bugre = "bugre"
635+ case calycule = "calycule"
636+ case caoutchouc = "caoutchouc"
637+ case disprover = "disprover"
638+ case fitroot = "fitroot"
639+ case fulgently = "fulgently"
640+ case kickup = "kickup"
641+ case laevoversion = "laevoversion"
642+ case moter = "moter"
643+ case objectivity = "objectivity"
644+ case posterity = "posterity"
645+ case postnuptial = "postnuptial"
646+ case precedentary = "precedentary"
647+ case saddling = "saddling"
648+ case subcurrent = "subcurrent"
649+ case unrecriminative = "unrecriminative"
650+ }
651+}
652+
653+// MARK: LandlubberlyClass convenience initializers and mutators
654+
655+extension LandlubberlyClass {
656+ init(data: Data) throws {
657+ self = try newJSONDecoder().decode(LandlubberlyClass.self, from: data)
658+ }
659+
660+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
661+ guard let data = json.data(using: encoding) else {
662+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
663+ }
664+ try self.init(data: data)
665+ }
666+
667+ init(fromURL url: URL) throws {
668+ try self.init(data: try Data(contentsOf: url))
669+ }
670+
671+ func with(
672+ acropoleis: JSONNull?? = nil,
673+ aminate: JSONNull?? = nil,
674+ amyraldism: JSONNull?? = nil,
675+ bipenniform: JSONNull?? = nil,
676+ bugre: JSONNull?? = nil,
677+ calycule: JSONNull?? = nil,
678+ caoutchouc: JSONNull?? = nil,
679+ disprover: JSONNull?? = nil,
680+ fitroot: JSONNull?? = nil,
681+ fulgently: JSONNull?? = nil,
682+ kickup: JSONNull?? = nil,
683+ laevoversion: JSONNull?? = nil,
684+ moter: JSONNull?? = nil,
685+ objectivity: JSONNull?? = nil,
686+ posterity: JSONNull?? = nil,
687+ postnuptial: JSONNull?? = nil,
688+ precedentary: JSONNull?? = nil,
689+ saddling: JSONNull?? = nil,
690+ subcurrent: JSONNull?? = nil,
691+ unrecriminative: JSONNull?? = nil
692+ ) -> LandlubberlyClass {
693+ return LandlubberlyClass(
694+ acropoleis: acropoleis ?? self.acropoleis,
695+ aminate: aminate ?? self.aminate,
696+ amyraldism: amyraldism ?? self.amyraldism,
697+ bipenniform: bipenniform ?? self.bipenniform,
698+ bugre: bugre ?? self.bugre,
699+ calycule: calycule ?? self.calycule,
700+ caoutchouc: caoutchouc ?? self.caoutchouc,
701+ disprover: disprover ?? self.disprover,
702+ fitroot: fitroot ?? self.fitroot,
703+ fulgently: fulgently ?? self.fulgently,
704+ kickup: kickup ?? self.kickup,
705+ laevoversion: laevoversion ?? self.laevoversion,
706+ moter: moter ?? self.moter,
707+ objectivity: objectivity ?? self.objectivity,
708+ posterity: posterity ?? self.posterity,
709+ postnuptial: postnuptial ?? self.postnuptial,
710+ precedentary: precedentary ?? self.precedentary,
711+ saddling: saddling ?? self.saddling,
712+ subcurrent: subcurrent ?? self.subcurrent,
713+ unrecriminative: unrecriminative ?? self.unrecriminative
714+ )
715+ }
716+
717+ func jsonData() throws -> Data {
718+ return try newJSONEncoder().encode(self)
719+ }
720+
721+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
722+ return String(data: try self.jsonData(), encoding: encoding)
723+ }
724+}
725+
726+enum Listener: Codable, Hashable {
727+ case integer(Int)
728+ case nullArray([JSONNull?])
729+
730+ init(from decoder: Decoder) throws {
731+ let container = try decoder.singleValueContainer()
732+ if let x = try? container.decode(Int.self) {
733+ self = .integer(x)
734+ return
735+ }
736+ if let x = try? container.decode([JSONNull?].self) {
737+ self = .nullArray(x)
738+ return
739+ }
740+ throw DecodingError.typeMismatch(Listener.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Listener"))
741+ }
742+
743+ func encode(to encoder: Encoder) throws {
744+ var container = encoder.singleValueContainer()
745+ switch self {
746+ case .integer(let x):
747+ try container.encode(x)
748+ case .nullArray(let x):
749+ try container.encode(x)
750+ }
751+ }
752+}
753+
754+enum LupusElement: Codable, Hashable {
755+ case integer(Int)
756+ case lupusClass(LupusClass)
757+
758+ init(from decoder: Decoder) throws {
759+ let container = try decoder.singleValueContainer()
760+ if let x = try? container.decode(Int.self) {
761+ self = .integer(x)
762+ return
763+ }
764+ if let x = try? container.decode(LupusClass.self) {
765+ self = .lupusClass(x)
766+ return
767+ }
768+ throw DecodingError.typeMismatch(LupusElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for LupusElement"))
769+ }
770+
771+ func encode(to encoder: Encoder) throws {
772+ var container = encoder.singleValueContainer()
773+ switch self {
774+ case .integer(let x):
775+ try container.encode(x)
776+ case .lupusClass(let x):
777+ try container.encode(x)
778+ }
779+ }
780+}
781+
782+//
783+// Hashable or Equatable:
784+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
785+// for types that require the use of JSONAny, nor will the implementation of Hashable be
786+// synthesized for types that have collections (such as arrays or dictionaries).
787+
788+// MARK: - LupusClass
789+struct LupusClass: Codable, Hashable {
790+ let catharticalness: Double?
791+ let chirotherium: Int?
792+ let chlorioninae: Int?
793+ let corvinae: Int?
794+ let crassina: Int?
795+ let disdiapason: String?
796+ let exiguity: Int?
797+ let farcist: Int?
798+ let holographical: Int?
799+ let homocerc: Bool?
800+ let ichthyophagan: Int?
801+ let implacable: Int?
802+ let nonbookish: JSONNull?
803+ let outshiner: Int?
804+ let overweather: Int?
805+ let protonegroid: Int?
806+ let shallowish: Int?
807+ let snoke: Int?
808+ let snout: Int?
809+ let surveillance: Int?
810+ let threshingtime: Int?
811+ let thysanocarpus: Int?
812+ let unsignificantly: Int?
813+ let unsnap: Int?
814+ let vendible: Int?
815+
816+ enum CodingKeys: String, CodingKey {
817+ case catharticalness = "catharticalness"
818+ case chirotherium = "Chirotherium"
819+ case chlorioninae = "Chlorioninae"
820+ case corvinae = "Corvinae"
821+ case crassina = "Crassina"
822+ case disdiapason = "disdiapason"
823+ case exiguity = "exiguity"
824+ case farcist = "farcist"
825+ case holographical = "holographical"
826+ case homocerc = "homocerc"
827+ case ichthyophagan = "ichthyophagan"
828+ case implacable = "implacable"
829+ case nonbookish = "nonbookish"
830+ case outshiner = "outshiner"
831+ case overweather = "overweather"
832+ case protonegroid = "protonegroid"
833+ case shallowish = "shallowish"
834+ case snoke = "snoke"
835+ case snout = "snout"
836+ case surveillance = "surveillance"
837+ case threshingtime = "threshingtime"
838+ case thysanocarpus = "Thysanocarpus"
839+ case unsignificantly = "unsignificantly"
840+ case unsnap = "unsnap"
841+ case vendible = "vendible"
842+ }
843+}
844+
845+// MARK: LupusClass convenience initializers and mutators
846+
847+extension LupusClass {
848+ init(data: Data) throws {
849+ self = try newJSONDecoder().decode(LupusClass.self, from: data)
850+ }
851+
852+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
853+ guard let data = json.data(using: encoding) else {
854+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
855+ }
856+ try self.init(data: data)
857+ }
858+
859+ init(fromURL url: URL) throws {
860+ try self.init(data: try Data(contentsOf: url))
861+ }
862+
863+ func with(
864+ catharticalness: Double?? = nil,
865+ chirotherium: Int?? = nil,
866+ chlorioninae: Int?? = nil,
867+ corvinae: Int?? = nil,
868+ crassina: Int?? = nil,
869+ disdiapason: String?? = nil,
870+ exiguity: Int?? = nil,
871+ farcist: Int?? = nil,
872+ holographical: Int?? = nil,
873+ homocerc: Bool?? = nil,
874+ ichthyophagan: Int?? = nil,
875+ implacable: Int?? = nil,
876+ nonbookish: JSONNull?? = nil,
877+ outshiner: Int?? = nil,
878+ overweather: Int?? = nil,
879+ protonegroid: Int?? = nil,
880+ shallowish: Int?? = nil,
881+ snoke: Int?? = nil,
882+ snout: Int?? = nil,
883+ surveillance: Int?? = nil,
884+ threshingtime: Int?? = nil,
885+ thysanocarpus: Int?? = nil,
886+ unsignificantly: Int?? = nil,
887+ unsnap: Int?? = nil,
888+ vendible: Int?? = nil
889+ ) -> LupusClass {
890+ return LupusClass(
891+ catharticalness: catharticalness ?? self.catharticalness,
892+ chirotherium: chirotherium ?? self.chirotherium,
893+ chlorioninae: chlorioninae ?? self.chlorioninae,
894+ corvinae: corvinae ?? self.corvinae,
895+ crassina: crassina ?? self.crassina,
896+ disdiapason: disdiapason ?? self.disdiapason,
897+ exiguity: exiguity ?? self.exiguity,
898+ farcist: farcist ?? self.farcist,
899+ holographical: holographical ?? self.holographical,
900+ homocerc: homocerc ?? self.homocerc,
901+ ichthyophagan: ichthyophagan ?? self.ichthyophagan,
902+ implacable: implacable ?? self.implacable,
903+ nonbookish: nonbookish ?? self.nonbookish,
904+ outshiner: outshiner ?? self.outshiner,
905+ overweather: overweather ?? self.overweather,
906+ protonegroid: protonegroid ?? self.protonegroid,
907+ shallowish: shallowish ?? self.shallowish,
908+ snoke: snoke ?? self.snoke,
909+ snout: snout ?? self.snout,
910+ surveillance: surveillance ?? self.surveillance,
911+ threshingtime: threshingtime ?? self.threshingtime,
912+ thysanocarpus: thysanocarpus ?? self.thysanocarpus,
913+ unsignificantly: unsignificantly ?? self.unsignificantly,
914+ unsnap: unsnap ?? self.unsnap,
915+ vendible: vendible ?? self.vendible
916+ )
917+ }
918+
919+ func jsonData() throws -> Data {
920+ return try newJSONEncoder().encode(self)
921+ }
922+
923+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
924+ return String(data: try self.jsonData(), encoding: encoding)
925+ }
926+}
927+
928+//
929+// Hashable or Equatable:
930+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
931+// for types that require the use of JSONAny, nor will the implementation of Hashable be
932+// synthesized for types that have collections (such as arrays or dictionaries).
933+
934+// MARK: - Maslin
935+struct Maslin: Codable, Hashable {
936+ let alicant: Int?
937+ let antiatonement: JSONNull?
938+ let anticorrosive: Int?
939+ let aphidozer: JSONNull?
940+ let bakuninist: JSONNull?
941+ let be: Int?
942+ let catharticalness: Double?
943+ let chirotherium: Int?
944+ let chub: Int?
945+ let cuprosilicon: Int?
946+ let curtailedly: Int?
947+ let dellenite: Int?
948+ let dimitry: Int?
949+ let disdiapason: String?
950+ let edifying: JSONNull?
951+ let ethmoiditis: Int?
952+ let gastralgy: JSONNull?
953+ let goatherd: Int?
954+ let hammerdress: Int?
955+ let hangfire: JSONNull?
956+ let homocerc: Bool?
957+ let lacunosity: Int?
958+ let longiloquence: JSONNull?
959+ let mameliere: Int?
960+ let motherless: JSONNull?
961+ let nonbookish: JSONNull?
962+ let noncorrodible: JSONNull?
963+ let nonsensicality: JSONNull?
964+ let oafishly: Int?
965+ let pfund: JSONNull?
966+ let preadvisory: JSONNull?
967+ let retroflexed: JSONNull?
968+ let saccharulmic: Int?
969+ let scowlful: Int?
970+ let secluded: JSONNull?
971+ let slackage: JSONNull?
972+ let sphaeridial: Int?
973+ let spondulics: JSONNull?
974+ let subsecive: Int?
975+ let swellmobsman: JSONNull?
976+ let trachyglossate: Int?
977+ let trialogue: JSONNull?
978+ let unassuaged: Int?
979+ let ungross: JSONNull?
980+ let unjudiciously: JSONNull?
981+
982+ enum CodingKeys: String, CodingKey {
983+ case alicant = "Alicant"
984+ case antiatonement = "antiatonement"
985+ case anticorrosive = "anticorrosive"
986+ case aphidozer = "aphidozer"
987+ case bakuninist = "Bakuninist"
988+ case be = "be"
989+ case catharticalness = "catharticalness"
990+ case chirotherium = "Chirotherium"
991+ case chub = "chub"
992+ case cuprosilicon = "cuprosilicon"
993+ case curtailedly = "curtailedly"
994+ case dellenite = "dellenite"
995+ case dimitry = "Dimitry"
996+ case disdiapason = "disdiapason"
997+ case edifying = "edifying"
998+ case ethmoiditis = "ethmoiditis"
999+ case gastralgy = "gastralgy"
1000+ case goatherd = "goatherd"
1001+ case hammerdress = "hammerdress"
1002+ case hangfire = "hangfire"
1003+ case homocerc = "homocerc"
1004+ case lacunosity = "lacunosity"
1005+ case longiloquence = "longiloquence"
1006+ case mameliere = "mameliere"
1007+ case motherless = "motherless"
1008+ case nonbookish = "nonbookish"
1009+ case noncorrodible = "noncorrodible"
1010+ case nonsensicality = "nonsensicality"
1011+ case oafishly = "oafishly"
1012+ case pfund = "pfund"
1013+ case preadvisory = "preadvisory"
1014+ case retroflexed = "retroflexed"
1015+ case saccharulmic = "saccharulmic"
1016+ case scowlful = "scowlful"
1017+ case secluded = "secluded"
1018+ case slackage = "slackage"
1019+ case sphaeridial = "sphaeridial"
1020+ case spondulics = "spondulics"
1021+ case subsecive = "subsecive"
1022+ case swellmobsman = "swellmobsman"
1023+ case trachyglossate = "trachyglossate"
1024+ case trialogue = "trialogue"
1025+ case unassuaged = "unassuaged"
1026+ case ungross = "ungross"
1027+ case unjudiciously = "unjudiciously"
1028+ }
1029+}
1030+
1031+// MARK: Maslin convenience initializers and mutators
1032+
1033+extension Maslin {
1034+ init(data: Data) throws {
1035+ self = try newJSONDecoder().decode(Maslin.self, from: data)
1036+ }
1037+
1038+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1039+ guard let data = json.data(using: encoding) else {
1040+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1041+ }
1042+ try self.init(data: data)
1043+ }
1044+
1045+ init(fromURL url: URL) throws {
1046+ try self.init(data: try Data(contentsOf: url))
1047+ }
1048+
1049+ func with(
1050+ alicant: Int?? = nil,
1051+ antiatonement: JSONNull?? = nil,
1052+ anticorrosive: Int?? = nil,
1053+ aphidozer: JSONNull?? = nil,
1054+ bakuninist: JSONNull?? = nil,
1055+ be: Int?? = nil,
1056+ catharticalness: Double?? = nil,
1057+ chirotherium: Int?? = nil,
1058+ chub: Int?? = nil,
1059+ cuprosilicon: Int?? = nil,
1060+ curtailedly: Int?? = nil,
1061+ dellenite: Int?? = nil,
1062+ dimitry: Int?? = nil,
1063+ disdiapason: String?? = nil,
1064+ edifying: JSONNull?? = nil,
1065+ ethmoiditis: Int?? = nil,
1066+ gastralgy: JSONNull?? = nil,
1067+ goatherd: Int?? = nil,
1068+ hammerdress: Int?? = nil,
1069+ hangfire: JSONNull?? = nil,
1070+ homocerc: Bool?? = nil,
1071+ lacunosity: Int?? = nil,
1072+ longiloquence: JSONNull?? = nil,
1073+ mameliere: Int?? = nil,
1074+ motherless: JSONNull?? = nil,
1075+ nonbookish: JSONNull?? = nil,
1076+ noncorrodible: JSONNull?? = nil,
1077+ nonsensicality: JSONNull?? = nil,
1078+ oafishly: Int?? = nil,
1079+ pfund: JSONNull?? = nil,
1080+ preadvisory: JSONNull?? = nil,
1081+ retroflexed: JSONNull?? = nil,
1082+ saccharulmic: Int?? = nil,
1083+ scowlful: Int?? = nil,
1084+ secluded: JSONNull?? = nil,
1085+ slackage: JSONNull?? = nil,
1086+ sphaeridial: Int?? = nil,
1087+ spondulics: JSONNull?? = nil,
1088+ subsecive: Int?? = nil,
1089+ swellmobsman: JSONNull?? = nil,
1090+ trachyglossate: Int?? = nil,
1091+ trialogue: JSONNull?? = nil,
1092+ unassuaged: Int?? = nil,
1093+ ungross: JSONNull?? = nil,
1094+ unjudiciously: JSONNull?? = nil
1095+ ) -> Maslin {
1096+ return Maslin(
1097+ alicant: alicant ?? self.alicant,
1098+ antiatonement: antiatonement ?? self.antiatonement,
1099+ anticorrosive: anticorrosive ?? self.anticorrosive,
1100+ aphidozer: aphidozer ?? self.aphidozer,
1101+ bakuninist: bakuninist ?? self.bakuninist,
1102+ be: be ?? self.be,
1103+ catharticalness: catharticalness ?? self.catharticalness,
1104+ chirotherium: chirotherium ?? self.chirotherium,
1105+ chub: chub ?? self.chub,
1106+ cuprosilicon: cuprosilicon ?? self.cuprosilicon,
1107+ curtailedly: curtailedly ?? self.curtailedly,
1108+ dellenite: dellenite ?? self.dellenite,
1109+ dimitry: dimitry ?? self.dimitry,
1110+ disdiapason: disdiapason ?? self.disdiapason,
1111+ edifying: edifying ?? self.edifying,
1112+ ethmoiditis: ethmoiditis ?? self.ethmoiditis,
1113+ gastralgy: gastralgy ?? self.gastralgy,
1114+ goatherd: goatherd ?? self.goatherd,
1115+ hammerdress: hammerdress ?? self.hammerdress,
1116+ hangfire: hangfire ?? self.hangfire,
1117+ homocerc: homocerc ?? self.homocerc,
1118+ lacunosity: lacunosity ?? self.lacunosity,
1119+ longiloquence: longiloquence ?? self.longiloquence,
1120+ mameliere: mameliere ?? self.mameliere,
1121+ motherless: motherless ?? self.motherless,
1122+ nonbookish: nonbookish ?? self.nonbookish,
1123+ noncorrodible: noncorrodible ?? self.noncorrodible,
1124+ nonsensicality: nonsensicality ?? self.nonsensicality,
1125+ oafishly: oafishly ?? self.oafishly,
1126+ pfund: pfund ?? self.pfund,
1127+ preadvisory: preadvisory ?? self.preadvisory,
1128+ retroflexed: retroflexed ?? self.retroflexed,
1129+ saccharulmic: saccharulmic ?? self.saccharulmic,
1130+ scowlful: scowlful ?? self.scowlful,
1131+ secluded: secluded ?? self.secluded,
1132+ slackage: slackage ?? self.slackage,
1133+ sphaeridial: sphaeridial ?? self.sphaeridial,
1134+ spondulics: spondulics ?? self.spondulics,
1135+ subsecive: subsecive ?? self.subsecive,
1136+ swellmobsman: swellmobsman ?? self.swellmobsman,
1137+ trachyglossate: trachyglossate ?? self.trachyglossate,
1138+ trialogue: trialogue ?? self.trialogue,
1139+ unassuaged: unassuaged ?? self.unassuaged,
1140+ ungross: ungross ?? self.ungross,
1141+ unjudiciously: unjudiciously ?? self.unjudiciously
1142+ )
1143+ }
1144+
1145+ func jsonData() throws -> Data {
1146+ return try newJSONEncoder().encode(self)
1147+ }
1148+
1149+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1150+ return String(data: try self.jsonData(), encoding: encoding)
1151+ }
1152+}
1153+
1154+enum MonaziteElement: Codable, Hashable {
1155+ case double(Double)
1156+ case monaziteClass(MonaziteClass)
1157+
1158+ init(from decoder: Decoder) throws {
1159+ let container = try decoder.singleValueContainer()
1160+ if let x = try? container.decode(Double.self) {
1161+ self = .double(x)
1162+ return
1163+ }
1164+ if let x = try? container.decode(MonaziteClass.self) {
1165+ self = .monaziteClass(x)
1166+ return
1167+ }
1168+ throw DecodingError.typeMismatch(MonaziteElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for MonaziteElement"))
1169+ }
1170+
1171+ func encode(to encoder: Encoder) throws {
1172+ var container = encoder.singleValueContainer()
1173+ switch self {
1174+ case .double(let x):
1175+ try container.encode(x)
1176+ case .monaziteClass(let x):
1177+ try container.encode(x)
1178+ }
1179+ }
1180+}
1181+
1182+//
1183+// Hashable or Equatable:
1184+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
1185+// for types that require the use of JSONAny, nor will the implementation of Hashable be
1186+// synthesized for types that have collections (such as arrays or dictionaries).
1187+
1188+// MARK: - MonaziteClass
1189+struct MonaziteClass: Codable, Hashable {
1190+ let catharticalness: Double
1191+ let chirotherium: Int
1192+ let disdiapason: String
1193+ let homocerc: Bool
1194+ let nonbookish: JSONNull?
1195+
1196+ enum CodingKeys: String, CodingKey {
1197+ case catharticalness = "catharticalness"
1198+ case chirotherium = "Chirotherium"
1199+ case disdiapason = "disdiapason"
1200+ case homocerc = "homocerc"
1201+ case nonbookish = "nonbookish"
1202+ }
1203+}
1204+
1205+// MARK: MonaziteClass convenience initializers and mutators
1206+
1207+extension MonaziteClass {
1208+ init(data: Data) throws {
1209+ self = try newJSONDecoder().decode(MonaziteClass.self, from: data)
1210+ }
1211+
1212+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1213+ guard let data = json.data(using: encoding) else {
1214+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1215+ }
1216+ try self.init(data: data)
1217+ }
1218+
1219+ init(fromURL url: URL) throws {
1220+ try self.init(data: try Data(contentsOf: url))
1221+ }
1222+
1223+ func with(
1224+ catharticalness: Double? = nil,
1225+ chirotherium: Int? = nil,
1226+ disdiapason: String? = nil,
1227+ homocerc: Bool? = nil,
1228+ nonbookish: JSONNull?? = nil
1229+ ) -> MonaziteClass {
1230+ return MonaziteClass(
1231+ catharticalness: catharticalness ?? self.catharticalness,
1232+ chirotherium: chirotherium ?? self.chirotherium,
1233+ disdiapason: disdiapason ?? self.disdiapason,
1234+ homocerc: homocerc ?? self.homocerc,
1235+ nonbookish: nonbookish ?? self.nonbookish
1236+ )
1237+ }
1238+
1239+ func jsonData() throws -> Data {
1240+ return try newJSONEncoder().encode(self)
1241+ }
1242+
1243+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1244+ return String(data: try self.jsonData(), encoding: encoding)
1245+ }
1246+}
1247+
1248+enum Monoliteral: Codable, Hashable {
1249+ case bool(Bool)
1250+ case nullArray([JSONNull?])
1251+
1252+ init(from decoder: Decoder) throws {
1253+ let container = try decoder.singleValueContainer()
1254+ if let x = try? container.decode(Bool.self) {
1255+ self = .bool(x)
1256+ return
1257+ }
1258+ if let x = try? container.decode([JSONNull?].self) {
1259+ self = .nullArray(x)
1260+ return
1261+ }
1262+ throw DecodingError.typeMismatch(Monoliteral.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Monoliteral"))
1263+ }
1264+
1265+ func encode(to encoder: Encoder) throws {
1266+ var container = encoder.singleValueContainer()
1267+ switch self {
1268+ case .bool(let x):
1269+ try container.encode(x)
1270+ case .nullArray(let x):
1271+ try container.encode(x)
1272+ }
1273+ }
1274+}
1275+
1276+enum MonotheisticallyElement: Codable, Hashable {
1277+ case monotheisticallyClass(MonotheisticallyClass)
1278+ case nullArray([JSONNull?])
1279+
1280+ init(from decoder: Decoder) throws {
1281+ let container = try decoder.singleValueContainer()
1282+ if let x = try? container.decode([JSONNull?].self) {
1283+ self = .nullArray(x)
1284+ return
1285+ }
1286+ if let x = try? container.decode(MonotheisticallyClass.self) {
1287+ self = .monotheisticallyClass(x)
1288+ return
1289+ }
1290+ throw DecodingError.typeMismatch(MonotheisticallyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for MonotheisticallyElement"))
1291+ }
1292+
1293+ func encode(to encoder: Encoder) throws {
1294+ var container = encoder.singleValueContainer()
1295+ switch self {
1296+ case .monotheisticallyClass(let x):
1297+ try container.encode(x)
1298+ case .nullArray(let x):
1299+ try container.encode(x)
1300+ }
1301+ }
1302+}
1303+
1304+//
1305+// Hashable or Equatable:
1306+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
1307+// for types that require the use of JSONAny, nor will the implementation of Hashable be
1308+// synthesized for types that have collections (such as arrays or dictionaries).
1309+
1310+// MARK: - MonotheisticallyClass
1311+struct MonotheisticallyClass: Codable, Hashable {
1312+ let blaspheme: JSONNull?
1313+ let catharticalness: Double?
1314+ let celiosalpingectomy: JSONNull?
1315+ let chirotherium: Int?
1316+ let consummativeness: JSONNull?
1317+ let disdiapason: String?
1318+ let egestive: JSONNull?
1319+ let enchylema: JSONNull?
1320+ let gasconade: JSONNull?
1321+ let holidayer: JSONNull?
1322+ let homocerc: Bool?
1323+ let intuitionalism: JSONNull?
1324+ let lophiostomate: JSONNull?
1325+ let nonbookish: JSONNull?
1326+ let nonvolition: JSONNull?
1327+ let palatableness: JSONNull?
1328+ let pimpery: JSONNull?
1329+ let previolation: JSONNull?
1330+ let reconveyance: JSONNull?
1331+ let registership: JSONNull?
1332+ let rhyacolite: JSONNull?
1333+ let smithereens: JSONNull?
1334+ let superedification: JSONNull?
1335+ let trust: JSONNull?
1336+ let whitestone: JSONNull?
1337+
1338+ enum CodingKeys: String, CodingKey {
1339+ case blaspheme = "blaspheme"
1340+ case catharticalness = "catharticalness"
1341+ case celiosalpingectomy = "celiosalpingectomy"
1342+ case chirotherium = "Chirotherium"
1343+ case consummativeness = "consummativeness"
1344+ case disdiapason = "disdiapason"
1345+ case egestive = "egestive"
1346+ case enchylema = "enchylema"
1347+ case gasconade = "gasconade"
1348+ case holidayer = "holidayer"
1349+ case homocerc = "homocerc"
1350+ case intuitionalism = "intuitionalism"
1351+ case lophiostomate = "lophiostomate"
1352+ case nonbookish = "nonbookish"
1353+ case nonvolition = "nonvolition"
1354+ case palatableness = "palatableness"
1355+ case pimpery = "pimpery"
1356+ case previolation = "previolation"
1357+ case reconveyance = "reconveyance"
1358+ case registership = "registership"
1359+ case rhyacolite = "rhyacolite"
1360+ case smithereens = "smithereens"
1361+ case superedification = "superedification"
1362+ case trust = "trust"
1363+ case whitestone = "whitestone"
1364+ }
1365+}
1366+
1367+// MARK: MonotheisticallyClass convenience initializers and mutators
1368+
1369+extension MonotheisticallyClass {
1370+ init(data: Data) throws {
1371+ self = try newJSONDecoder().decode(MonotheisticallyClass.self, from: data)
1372+ }
1373+
1374+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1375+ guard let data = json.data(using: encoding) else {
1376+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1377+ }
1378+ try self.init(data: data)
1379+ }
1380+
1381+ init(fromURL url: URL) throws {
1382+ try self.init(data: try Data(contentsOf: url))
1383+ }
1384+
1385+ func with(
1386+ blaspheme: JSONNull?? = nil,
1387+ catharticalness: Double?? = nil,
1388+ celiosalpingectomy: JSONNull?? = nil,
1389+ chirotherium: Int?? = nil,
1390+ consummativeness: JSONNull?? = nil,
1391+ disdiapason: String?? = nil,
1392+ egestive: JSONNull?? = nil,
1393+ enchylema: JSONNull?? = nil,
1394+ gasconade: JSONNull?? = nil,
1395+ holidayer: JSONNull?? = nil,
1396+ homocerc: Bool?? = nil,
1397+ intuitionalism: JSONNull?? = nil,
1398+ lophiostomate: JSONNull?? = nil,
1399+ nonbookish: JSONNull?? = nil,
1400+ nonvolition: JSONNull?? = nil,
1401+ palatableness: JSONNull?? = nil,
1402+ pimpery: JSONNull?? = nil,
1403+ previolation: JSONNull?? = nil,
1404+ reconveyance: JSONNull?? = nil,
1405+ registership: JSONNull?? = nil,
1406+ rhyacolite: JSONNull?? = nil,
1407+ smithereens: JSONNull?? = nil,
1408+ superedification: JSONNull?? = nil,
1409+ trust: JSONNull?? = nil,
1410+ whitestone: JSONNull?? = nil
1411+ ) -> MonotheisticallyClass {
1412+ return MonotheisticallyClass(
1413+ blaspheme: blaspheme ?? self.blaspheme,
1414+ catharticalness: catharticalness ?? self.catharticalness,
1415+ celiosalpingectomy: celiosalpingectomy ?? self.celiosalpingectomy,
1416+ chirotherium: chirotherium ?? self.chirotherium,
1417+ consummativeness: consummativeness ?? self.consummativeness,
1418+ disdiapason: disdiapason ?? self.disdiapason,
1419+ egestive: egestive ?? self.egestive,
1420+ enchylema: enchylema ?? self.enchylema,
1421+ gasconade: gasconade ?? self.gasconade,
1422+ holidayer: holidayer ?? self.holidayer,
1423+ homocerc: homocerc ?? self.homocerc,
1424+ intuitionalism: intuitionalism ?? self.intuitionalism,
1425+ lophiostomate: lophiostomate ?? self.lophiostomate,
1426+ nonbookish: nonbookish ?? self.nonbookish,
1427+ nonvolition: nonvolition ?? self.nonvolition,
1428+ palatableness: palatableness ?? self.palatableness,
1429+ pimpery: pimpery ?? self.pimpery,
1430+ previolation: previolation ?? self.previolation,
1431+ reconveyance: reconveyance ?? self.reconveyance,
1432+ registership: registership ?? self.registership,
1433+ rhyacolite: rhyacolite ?? self.rhyacolite,
1434+ smithereens: smithereens ?? self.smithereens,
1435+ superedification: superedification ?? self.superedification,
1436+ trust: trust ?? self.trust,
1437+ whitestone: whitestone ?? self.whitestone
1438+ )
1439+ }
1440+
1441+ func jsonData() throws -> Data {
1442+ return try newJSONEncoder().encode(self)
1443+ }
1444+
1445+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1446+ return String(data: try self.jsonData(), encoding: encoding)
1447+ }
1448+}
1449+
1450+enum Montage: Codable, Hashable {
1451+ case double(Double)
1452+ case nullArray([JSONNull?])
1453+ case string(String)
1454+
1455+ init(from decoder: Decoder) throws {
1456+ let container = try decoder.singleValueContainer()
1457+ if let x = try? container.decode([JSONNull?].self) {
1458+ self = .nullArray(x)
1459+ return
1460+ }
1461+ if let x = try? container.decode(Double.self) {
1462+ self = .double(x)
1463+ return
1464+ }
1465+ if let x = try? container.decode(String.self) {
1466+ self = .string(x)
1467+ return
1468+ }
1469+ throw DecodingError.typeMismatch(Montage.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Montage"))
1470+ }
1471+
1472+ func encode(to encoder: Encoder) throws {
1473+ var container = encoder.singleValueContainer()
1474+ switch self {
1475+ case .double(let x):
1476+ try container.encode(x)
1477+ case .nullArray(let x):
1478+ try container.encode(x)
1479+ case .string(let x):
1480+ try container.encode(x)
1481+ }
1482+ }
1483+}
1484+
1485+enum Moralness: Codable, Hashable {
1486+ case double(Double)
1487+ case nullArray([JSONNull?])
1488+ case null
1489+
1490+ init(from decoder: Decoder) throws {
1491+ let container = try decoder.singleValueContainer()
1492+ if let x = try? container.decode([JSONNull?].self) {
1493+ self = .nullArray(x)
1494+ return
1495+ }
1496+ if let x = try? container.decode(Double.self) {
1497+ self = .double(x)
1498+ return
1499+ }
1500+ if container.decodeNil() {
1501+ self = .null
1502+ return
1503+ }
1504+ throw DecodingError.typeMismatch(Moralness.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Moralness"))
1505+ }
1506+
1507+ func encode(to encoder: Encoder) throws {
1508+ var container = encoder.singleValueContainer()
1509+ switch self {
1510+ case .double(let x):
1511+ try container.encode(x)
1512+ case .nullArray(let x):
1513+ try container.encode(x)
1514+ case .null:
1515+ try container.encodeNil()
1516+ }
1517+ }
1518+}
1519+
1520+enum Mulishly: Codable, Hashable {
1521+ case double(Double)
1522+ case integerArray([Int])
1523+ case null
1524+
1525+ init(from decoder: Decoder) throws {
1526+ let container = try decoder.singleValueContainer()
1527+ if let x = try? container.decode([Int].self) {
1528+ self = .integerArray(x)
1529+ return
1530+ }
1531+ if let x = try? container.decode(Double.self) {
1532+ self = .double(x)
1533+ return
1534+ }
1535+ if container.decodeNil() {
1536+ self = .null
1537+ return
1538+ }
1539+ throw DecodingError.typeMismatch(Mulishly.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Mulishly"))
1540+ }
1541+
1542+ func encode(to encoder: Encoder) throws {
1543+ var container = encoder.singleValueContainer()
1544+ switch self {
1545+ case .double(let x):
1546+ try container.encode(x)
1547+ case .integerArray(let x):
1548+ try container.encode(x)
1549+ case .null:
1550+ try container.encodeNil()
1551+ }
1552+ }
1553+}
1554+
1555+enum Myoscope: Codable, Hashable {
1556+ case bool(Bool)
1557+ case integer(Int)
1558+ case nullArray([JSONNull?])
1559+
1560+ init(from decoder: Decoder) throws {
1561+ let container = try decoder.singleValueContainer()
1562+ if let x = try? container.decode(Bool.self) {
1563+ self = .bool(x)
1564+ return
1565+ }
1566+ if let x = try? container.decode(Int.self) {
1567+ self = .integer(x)
1568+ return
1569+ }
1570+ if let x = try? container.decode([JSONNull?].self) {
1571+ self = .nullArray(x)
1572+ return
1573+ }
1574+ throw DecodingError.typeMismatch(Myoscope.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Myoscope"))
1575+ }
1576+
1577+ func encode(to encoder: Encoder) throws {
1578+ var container = encoder.singleValueContainer()
1579+ switch self {
1580+ case .bool(let x):
1581+ try container.encode(x)
1582+ case .integer(let x):
1583+ try container.encode(x)
1584+ case .nullArray(let x):
1585+ try container.encode(x)
1586+ }
1587+ }
1588+}
1589+
1590+enum Neuromastic: Codable, Hashable {
1591+ case double(Double)
1592+ case nullArray([JSONNull?])
1593+
1594+ init(from decoder: Decoder) throws {
1595+ let container = try decoder.singleValueContainer()
1596+ if let x = try? container.decode([JSONNull?].self) {
1597+ self = .nullArray(x)
1598+ return
1599+ }
1600+ if let x = try? container.decode(Double.self) {
1601+ self = .double(x)
1602+ return
1603+ }
1604+ throw DecodingError.typeMismatch(Neuromastic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Neuromastic"))
1605+ }
1606+
1607+ func encode(to encoder: Encoder) throws {
1608+ var container = encoder.singleValueContainer()
1609+ switch self {
1610+ case .double(let x):
1611+ try container.encode(x)
1612+ case .nullArray(let x):
1613+ try container.encode(x)
1614+ }
1615+ }
1616+}
1617+
1618+//
1619+// Hashable or Equatable:
1620+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
1621+// for types that require the use of JSONAny, nor will the implementation of Hashable be
1622+// synthesized for types that have collections (such as arrays or dictionaries).
1623+
1624+// MARK: - Noncontributing
1625+struct Noncontributing: Codable, Hashable {
1626+ let estevin: String
1627+ let jolterhead: Double
1628+ let sauternes: Int
1629+ let sparsely: Bool
1630+ let unrequested: JSONNull?
1631+
1632+ enum CodingKeys: String, CodingKey {
1633+ case estevin = "estevin"
1634+ case jolterhead = "jolterhead"
1635+ case sauternes = "sauternes"
1636+ case sparsely = "sparsely"
1637+ case unrequested = "unrequested"
1638+ }
1639+}
1640+
1641+// MARK: Noncontributing convenience initializers and mutators
1642+
1643+extension Noncontributing {
1644+ init(data: Data) throws {
1645+ self = try newJSONDecoder().decode(Noncontributing.self, from: data)
1646+ }
1647+
1648+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1649+ guard let data = json.data(using: encoding) else {
1650+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1651+ }
1652+ try self.init(data: data)
1653+ }
1654+
1655+ init(fromURL url: URL) throws {
1656+ try self.init(data: try Data(contentsOf: url))
1657+ }
1658+
1659+ func with(
1660+ estevin: String? = nil,
1661+ jolterhead: Double? = nil,
1662+ sauternes: Int? = nil,
1663+ sparsely: Bool? = nil,
1664+ unrequested: JSONNull?? = nil
1665+ ) -> Noncontributing {
1666+ return Noncontributing(
1667+ estevin: estevin ?? self.estevin,
1668+ jolterhead: jolterhead ?? self.jolterhead,
1669+ sauternes: sauternes ?? self.sauternes,
1670+ sparsely: sparsely ?? self.sparsely,
1671+ unrequested: unrequested ?? self.unrequested
1672+ )
1673+ }
1674+
1675+ func jsonData() throws -> Data {
1676+ return try newJSONEncoder().encode(self)
1677+ }
1678+
1679+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1680+ return String(data: try self.jsonData(), encoding: encoding)
1681+ }
1682+}
1683+
1684+enum Nonnervous: Codable, Hashable {
1685+ case bool(Bool)
1686+ case integer(Int)
1687+
1688+ init(from decoder: Decoder) throws {
1689+ let container = try decoder.singleValueContainer()
1690+ if let x = try? container.decode(Bool.self) {
1691+ self = .bool(x)
1692+ return
1693+ }
1694+ if let x = try? container.decode(Int.self) {
1695+ self = .integer(x)
1696+ return
1697+ }
1698+ throw DecodingError.typeMismatch(Nonnervous.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Nonnervous"))
1699+ }
1700+
1701+ func encode(to encoder: Encoder) throws {
1702+ var container = encoder.singleValueContainer()
1703+ switch self {
1704+ case .bool(let x):
1705+ try container.encode(x)
1706+ case .integer(let x):
1707+ try container.encode(x)
1708+ }
1709+ }
1710+}
1711+
1712+enum Nonvaluation: Codable, Hashable {
1713+ case bool(Bool)
1714+ case double(Double)
1715+ case nullArray([JSONNull?])
1716+
1717+ init(from decoder: Decoder) throws {
1718+ let container = try decoder.singleValueContainer()
1719+ if let x = try? container.decode(Bool.self) {
1720+ self = .bool(x)
1721+ return
1722+ }
1723+ if let x = try? container.decode([JSONNull?].self) {
1724+ self = .nullArray(x)
1725+ return
1726+ }
1727+ if let x = try? container.decode(Double.self) {
1728+ self = .double(x)
1729+ return
1730+ }
1731+ throw DecodingError.typeMismatch(Nonvaluation.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Nonvaluation"))
1732+ }
1733+
1734+ func encode(to encoder: Encoder) throws {
1735+ var container = encoder.singleValueContainer()
1736+ switch self {
1737+ case .bool(let x):
1738+ try container.encode(x)
1739+ case .double(let x):
1740+ try container.encode(x)
1741+ case .nullArray(let x):
1742+ try container.encode(x)
1743+ }
1744+ }
1745+}
1746+
1747+enum OccupationalistElement: Codable, Hashable {
1748+ case nullArray([JSONNull?])
1749+ case occupationalistClass(OccupationalistClass)
1750+ case null
1751+
1752+ init(from decoder: Decoder) throws {
1753+ let container = try decoder.singleValueContainer()
1754+ if let x = try? container.decode([JSONNull?].self) {
1755+ self = .nullArray(x)
1756+ return
1757+ }
1758+ if let x = try? container.decode(OccupationalistClass.self) {
1759+ self = .occupationalistClass(x)
1760+ return
1761+ }
1762+ if container.decodeNil() {
1763+ self = .null
1764+ return
1765+ }
1766+ throw DecodingError.typeMismatch(OccupationalistElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for OccupationalistElement"))
1767+ }
1768+
1769+ func encode(to encoder: Encoder) throws {
1770+ var container = encoder.singleValueContainer()
1771+ switch self {
1772+ case .nullArray(let x):
1773+ try container.encode(x)
1774+ case .occupationalistClass(let x):
1775+ try container.encode(x)
1776+ case .null:
1777+ try container.encodeNil()
1778+ }
1779+ }
1780+}
1781+
1782+//
1783+// Hashable or Equatable:
1784+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
1785+// for types that require the use of JSONAny, nor will the implementation of Hashable be
1786+// synthesized for types that have collections (such as arrays or dictionaries).
1787+
1788+// MARK: - OccupationalistClass
1789+struct OccupationalistClass: Codable, Hashable {
1790+ let beholdable: JSONNull?
1791+ let brotuliform: JSONNull?
1792+ let chimakum: JSONNull?
1793+ let doodler: JSONNull?
1794+ let emulsin: JSONNull?
1795+ let fin: JSONNull?
1796+ let flourishing: JSONNull?
1797+ let flueless: JSONNull?
1798+ let furtively: JSONNull?
1799+ let gritter: JSONNull?
1800+ let interwish: JSONNull?
1801+ let monoxylic: JSONNull?
1802+ let myristic: JSONNull?
1803+ let nightwear: JSONNull?
1804+ let peruser: JSONNull?
1805+ let theoastrological: JSONNull?
1806+ let thumby: JSONNull?
1807+ let tingitid: JSONNull?
1808+ let trailless: JSONNull?
1809+ let unpocketed: JSONNull?
1810+
1811+ enum CodingKeys: String, CodingKey {
1812+ case beholdable = "beholdable"
1813+ case brotuliform = "brotuliform"
1814+ case chimakum = "Chimakum"
1815+ case doodler = "doodler"
1816+ case emulsin = "emulsin"
1817+ case fin = "Fin"
1818+ case flourishing = "flourishing"
1819+ case flueless = "flueless"
1820+ case furtively = "furtively"
1821+ case gritter = "gritter"
1822+ case interwish = "interwish"
1823+ case monoxylic = "monoxylic"
1824+ case myristic = "myristic"
1825+ case nightwear = "nightwear"
1826+ case peruser = "peruser"
1827+ case theoastrological = "theoastrological"
1828+ case thumby = "thumby"
1829+ case tingitid = "tingitid"
1830+ case trailless = "trailless"
1831+ case unpocketed = "unpocketed"
1832+ }
1833+}
1834+
1835+// MARK: OccupationalistClass convenience initializers and mutators
1836+
1837+extension OccupationalistClass {
1838+ init(data: Data) throws {
1839+ self = try newJSONDecoder().decode(OccupationalistClass.self, from: data)
1840+ }
1841+
1842+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1843+ guard let data = json.data(using: encoding) else {
1844+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1845+ }
1846+ try self.init(data: data)
1847+ }
1848+
1849+ init(fromURL url: URL) throws {
1850+ try self.init(data: try Data(contentsOf: url))
1851+ }
1852+
1853+ func with(
1854+ beholdable: JSONNull?? = nil,
1855+ brotuliform: JSONNull?? = nil,
1856+ chimakum: JSONNull?? = nil,
1857+ doodler: JSONNull?? = nil,
1858+ emulsin: JSONNull?? = nil,
1859+ fin: JSONNull?? = nil,
1860+ flourishing: JSONNull?? = nil,
1861+ flueless: JSONNull?? = nil,
1862+ furtively: JSONNull?? = nil,
1863+ gritter: JSONNull?? = nil,
1864+ interwish: JSONNull?? = nil,
1865+ monoxylic: JSONNull?? = nil,
1866+ myristic: JSONNull?? = nil,
1867+ nightwear: JSONNull?? = nil,
1868+ peruser: JSONNull?? = nil,
1869+ theoastrological: JSONNull?? = nil,
1870+ thumby: JSONNull?? = nil,
1871+ tingitid: JSONNull?? = nil,
1872+ trailless: JSONNull?? = nil,
1873+ unpocketed: JSONNull?? = nil
1874+ ) -> OccupationalistClass {
1875+ return OccupationalistClass(
1876+ beholdable: beholdable ?? self.beholdable,
1877+ brotuliform: brotuliform ?? self.brotuliform,
1878+ chimakum: chimakum ?? self.chimakum,
1879+ doodler: doodler ?? self.doodler,
1880+ emulsin: emulsin ?? self.emulsin,
1881+ fin: fin ?? self.fin,
1882+ flourishing: flourishing ?? self.flourishing,
1883+ flueless: flueless ?? self.flueless,
1884+ furtively: furtively ?? self.furtively,
1885+ gritter: gritter ?? self.gritter,
1886+ interwish: interwish ?? self.interwish,
1887+ monoxylic: monoxylic ?? self.monoxylic,
1888+ myristic: myristic ?? self.myristic,
1889+ nightwear: nightwear ?? self.nightwear,
1890+ peruser: peruser ?? self.peruser,
1891+ theoastrological: theoastrological ?? self.theoastrological,
1892+ thumby: thumby ?? self.thumby,
1893+ tingitid: tingitid ?? self.tingitid,
1894+ trailless: trailless ?? self.trailless,
1895+ unpocketed: unpocketed ?? self.unpocketed
1896+ )
1897+ }
1898+
1899+ func jsonData() throws -> Data {
1900+ return try newJSONEncoder().encode(self)
1901+ }
1902+
1903+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1904+ return String(data: try self.jsonData(), encoding: encoding)
1905+ }
1906+}
1907+
1908+enum OutrivalElement: Codable, Hashable {
1909+ case double(Double)
1910+ case outrivalClass(OutrivalClass)
1911+ case null
1912+
1913+ init(from decoder: Decoder) throws {
1914+ let container = try decoder.singleValueContainer()
1915+ if let x = try? container.decode(Double.self) {
1916+ self = .double(x)
1917+ return
1918+ }
1919+ if let x = try? container.decode(OutrivalClass.self) {
1920+ self = .outrivalClass(x)
1921+ return
1922+ }
1923+ if container.decodeNil() {
1924+ self = .null
1925+ return
1926+ }
1927+ throw DecodingError.typeMismatch(OutrivalElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for OutrivalElement"))
1928+ }
1929+
1930+ func encode(to encoder: Encoder) throws {
1931+ var container = encoder.singleValueContainer()
1932+ switch self {
1933+ case .double(let x):
1934+ try container.encode(x)
1935+ case .outrivalClass(let x):
1936+ try container.encode(x)
1937+ case .null:
1938+ try container.encodeNil()
1939+ }
1940+ }
1941+}
1942+
1943+//
1944+// Hashable or Equatable:
1945+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
1946+// for types that require the use of JSONAny, nor will the implementation of Hashable be
1947+// synthesized for types that have collections (such as arrays or dictionaries).
1948+
1949+// MARK: - OutrivalClass
1950+struct OutrivalClass: Codable, Hashable {
1951+ let adroitly: JSONNull?
1952+ let bridehood: JSONNull?
1953+ let castoroides: JSONNull?
1954+ let czechoslovak: JSONNull?
1955+ let diagenesis: JSONNull?
1956+ let dihexahedron: JSONNull?
1957+ let dopester: JSONNull?
1958+ let eumerism: JSONNull?
1959+ let flyness: JSONNull?
1960+ let fouler: JSONNull?
1961+ let laudanosine: JSONNull?
1962+ let lingulidae: JSONNull?
1963+ let minutary: JSONNull?
1964+ let mitra: JSONNull?
1965+ let opisthorchiasis: JSONNull?
1966+ let pensively: JSONNull?
1967+ let pubigerous: JSONNull?
1968+ let rebellious: JSONNull?
1969+ let recodify: JSONNull?
1970+ let unpaced: JSONNull?
1971+
1972+ enum CodingKeys: String, CodingKey {
1973+ case adroitly = "adroitly"
1974+ case bridehood = "bridehood"
1975+ case castoroides = "Castoroides"
1976+ case czechoslovak = "Czechoslovak"
1977+ case diagenesis = "diagenesis"
1978+ case dihexahedron = "dihexahedron"
1979+ case dopester = "dopester"
1980+ case eumerism = "eumerism"
1981+ case flyness = "flyness"
1982+ case fouler = "fouler"
1983+ case laudanosine = "laudanosine"
1984+ case lingulidae = "Lingulidae"
1985+ case minutary = "minutary"
1986+ case mitra = "mitra"
1987+ case opisthorchiasis = "opisthorchiasis"
1988+ case pensively = "pensively"
1989+ case pubigerous = "pubigerous"
1990+ case rebellious = "rebellious"
1991+ case recodify = "recodify"
1992+ case unpaced = "unpaced"
1993+ }
1994+}
1995+
1996+// MARK: OutrivalClass convenience initializers and mutators
1997+
1998+extension OutrivalClass {
1999+ init(data: Data) throws {
2000+ self = try newJSONDecoder().decode(OutrivalClass.self, from: data)
2001+ }
2002+
2003+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2004+ guard let data = json.data(using: encoding) else {
2005+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2006+ }
2007+ try self.init(data: data)
2008+ }
2009+
2010+ init(fromURL url: URL) throws {
2011+ try self.init(data: try Data(contentsOf: url))
2012+ }
2013+
2014+ func with(
2015+ adroitly: JSONNull?? = nil,
2016+ bridehood: JSONNull?? = nil,
2017+ castoroides: JSONNull?? = nil,
2018+ czechoslovak: JSONNull?? = nil,
2019+ diagenesis: JSONNull?? = nil,
2020+ dihexahedron: JSONNull?? = nil,
2021+ dopester: JSONNull?? = nil,
2022+ eumerism: JSONNull?? = nil,
2023+ flyness: JSONNull?? = nil,
2024+ fouler: JSONNull?? = nil,
2025+ laudanosine: JSONNull?? = nil,
2026+ lingulidae: JSONNull?? = nil,
2027+ minutary: JSONNull?? = nil,
2028+ mitra: JSONNull?? = nil,
2029+ opisthorchiasis: JSONNull?? = nil,
2030+ pensively: JSONNull?? = nil,
2031+ pubigerous: JSONNull?? = nil,
2032+ rebellious: JSONNull?? = nil,
2033+ recodify: JSONNull?? = nil,
2034+ unpaced: JSONNull?? = nil
2035+ ) -> OutrivalClass {
2036+ return OutrivalClass(
2037+ adroitly: adroitly ?? self.adroitly,
2038+ bridehood: bridehood ?? self.bridehood,
2039+ castoroides: castoroides ?? self.castoroides,
2040+ czechoslovak: czechoslovak ?? self.czechoslovak,
2041+ diagenesis: diagenesis ?? self.diagenesis,
2042+ dihexahedron: dihexahedron ?? self.dihexahedron,
2043+ dopester: dopester ?? self.dopester,
2044+ eumerism: eumerism ?? self.eumerism,
2045+ flyness: flyness ?? self.flyness,
2046+ fouler: fouler ?? self.fouler,
2047+ laudanosine: laudanosine ?? self.laudanosine,
2048+ lingulidae: lingulidae ?? self.lingulidae,
2049+ minutary: minutary ?? self.minutary,
2050+ mitra: mitra ?? self.mitra,
2051+ opisthorchiasis: opisthorchiasis ?? self.opisthorchiasis,
2052+ pensively: pensively ?? self.pensively,
2053+ pubigerous: pubigerous ?? self.pubigerous,
2054+ rebellious: rebellious ?? self.rebellious,
2055+ recodify: recodify ?? self.recodify,
2056+ unpaced: unpaced ?? self.unpaced
2057+ )
2058+ }
2059+
2060+ func jsonData() throws -> Data {
2061+ return try newJSONEncoder().encode(self)
2062+ }
2063+
2064+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2065+ return String(data: try self.jsonData(), encoding: encoding)
2066+ }
2067+}
2068+
2069+enum Paleographically: Codable, Hashable {
2070+ case double(Double)
2071+ case unionMap([String: Int?])
2072+
2073+ init(from decoder: Decoder) throws {
2074+ let container = try decoder.singleValueContainer()
2075+ if let x = try? container.decode(Double.self) {
2076+ self = .double(x)
2077+ return
2078+ }
2079+ if let x = try? container.decode([String: Int?].self) {
2080+ self = .unionMap(x)
2081+ return
2082+ }
2083+ throw DecodingError.typeMismatch(Paleographically.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Paleographically"))
2084+ }
2085+
2086+ func encode(to encoder: Encoder) throws {
2087+ var container = encoder.singleValueContainer()
2088+ switch self {
2089+ case .double(let x):
2090+ try container.encode(x)
2091+ case .unionMap(let x):
2092+ try container.encode(x)
2093+ }
2094+ }
2095+}
2096+
2097+enum Pamphletwise: Codable, Hashable {
2098+ case integer(Int)
2099+ case integerMap([String: Int])
2100+ case string(String)
2101+
2102+ init(from decoder: Decoder) throws {
2103+ let container = try decoder.singleValueContainer()
2104+ if let x = try? container.decode(Int.self) {
2105+ self = .integer(x)
2106+ return
2107+ }
2108+ if let x = try? container.decode([String: Int].self) {
2109+ self = .integerMap(x)
2110+ return
2111+ }
2112+ if let x = try? container.decode(String.self) {
2113+ self = .string(x)
2114+ return
2115+ }
2116+ throw DecodingError.typeMismatch(Pamphletwise.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Pamphletwise"))
2117+ }
2118+
2119+ func encode(to encoder: Encoder) throws {
2120+ var container = encoder.singleValueContainer()
2121+ switch self {
2122+ case .integer(let x):
2123+ try container.encode(x)
2124+ case .integerMap(let x):
2125+ try container.encode(x)
2126+ case .string(let x):
2127+ try container.encode(x)
2128+ }
2129+ }
2130+}
2131+
2132+enum Pediatric: Codable, Hashable {
2133+ case bool(Bool)
2134+ case double(Double)
2135+ case null
2136+
2137+ init(from decoder: Decoder) throws {
2138+ let container = try decoder.singleValueContainer()
2139+ if let x = try? container.decode(Bool.self) {
2140+ self = .bool(x)
2141+ return
2142+ }
2143+ if let x = try? container.decode(Double.self) {
2144+ self = .double(x)
2145+ return
2146+ }
2147+ if container.decodeNil() {
2148+ self = .null
2149+ return
2150+ }
2151+ throw DecodingError.typeMismatch(Pediatric.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Pediatric"))
2152+ }
2153+
2154+ func encode(to encoder: Encoder) throws {
2155+ var container = encoder.singleValueContainer()
2156+ switch self {
2157+ case .bool(let x):
2158+ try container.encode(x)
2159+ case .double(let x):
2160+ try container.encode(x)
2161+ case .null:
2162+ try container.encodeNil()
2163+ }
2164+ }
2165+}
2166+
2167+enum PiaculumElement: Codable, Hashable {
2168+ case double(Double)
2169+ case piaculumClass(PiaculumClass)
2170+
2171+ init(from decoder: Decoder) throws {
2172+ let container = try decoder.singleValueContainer()
2173+ if let x = try? container.decode(Double.self) {
2174+ self = .double(x)
2175+ return
2176+ }
2177+ if let x = try? container.decode(PiaculumClass.self) {
2178+ self = .piaculumClass(x)
2179+ return
2180+ }
2181+ throw DecodingError.typeMismatch(PiaculumElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PiaculumElement"))
2182+ }
2183+
2184+ func encode(to encoder: Encoder) throws {
2185+ var container = encoder.singleValueContainer()
2186+ switch self {
2187+ case .double(let x):
2188+ try container.encode(x)
2189+ case .piaculumClass(let x):
2190+ try container.encode(x)
2191+ }
2192+ }
2193+}
2194+
2195+//
2196+// Hashable or Equatable:
2197+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
2198+// for types that require the use of JSONAny, nor will the implementation of Hashable be
2199+// synthesized for types that have collections (such as arrays or dictionaries).
2200+
2201+// MARK: - PiaculumClass
2202+struct PiaculumClass: Codable, Hashable {
2203+ let alada: Int?
2204+ let amphistomous: Int?
2205+ let boysenberry: Int?
2206+ let catharticalness: Double?
2207+ let chirotherium: Int?
2208+ let decardinalize: Int?
2209+ let discouragement: Int?
2210+ let disdiapason: String?
2211+ let doitrified: Int?
2212+ let hexaspermous: Int?
2213+ let homocerc: Bool?
2214+ let insinking: Int?
2215+ let loathfulness: Int?
2216+ let miasmatical: Int?
2217+ let neurofibril: Int?
2218+ let nonbookish: JSONNull?
2219+ let phonendoscope: Int?
2220+ let pilferment: Int?
2221+ let predismissory: Int?
2222+ let preinscription: Int?
2223+ let quotative: Int?
2224+ let sienna: Int?
2225+ let thorax: Int?
2226+ let yachting: Int?
2227+ let zipper: Int?
2228+
2229+ enum CodingKeys: String, CodingKey {
2230+ case alada = "alada"
2231+ case amphistomous = "amphistomous"
2232+ case boysenberry = "boysenberry"
2233+ case catharticalness = "catharticalness"
2234+ case chirotherium = "Chirotherium"
2235+ case decardinalize = "decardinalize"
2236+ case discouragement = "discouragement"
2237+ case disdiapason = "disdiapason"
2238+ case doitrified = "doitrified"
2239+ case hexaspermous = "hexaspermous"
2240+ case homocerc = "homocerc"
2241+ case insinking = "insinking"
2242+ case loathfulness = "loathfulness"
2243+ case miasmatical = "miasmatical"
2244+ case neurofibril = "neurofibril"
2245+ case nonbookish = "nonbookish"
2246+ case phonendoscope = "phonendoscope"
2247+ case pilferment = "pilferment"
2248+ case predismissory = "predismissory"
2249+ case preinscription = "preinscription"
2250+ case quotative = "quotative"
2251+ case sienna = "sienna"
2252+ case thorax = "thorax"
2253+ case yachting = "yachting"
2254+ case zipper = "Zipper"
2255+ }
2256+}
2257+
2258+// MARK: PiaculumClass convenience initializers and mutators
2259+
2260+extension PiaculumClass {
2261+ init(data: Data) throws {
2262+ self = try newJSONDecoder().decode(PiaculumClass.self, from: data)
2263+ }
2264+
2265+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2266+ guard let data = json.data(using: encoding) else {
2267+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2268+ }
2269+ try self.init(data: data)
2270+ }
2271+
2272+ init(fromURL url: URL) throws {
2273+ try self.init(data: try Data(contentsOf: url))
2274+ }
2275+
2276+ func with(
2277+ alada: Int?? = nil,
2278+ amphistomous: Int?? = nil,
2279+ boysenberry: Int?? = nil,
2280+ catharticalness: Double?? = nil,
2281+ chirotherium: Int?? = nil,
2282+ decardinalize: Int?? = nil,
2283+ discouragement: Int?? = nil,
2284+ disdiapason: String?? = nil,
2285+ doitrified: Int?? = nil,
2286+ hexaspermous: Int?? = nil,
2287+ homocerc: Bool?? = nil,
2288+ insinking: Int?? = nil,
2289+ loathfulness: Int?? = nil,
2290+ miasmatical: Int?? = nil,
2291+ neurofibril: Int?? = nil,
2292+ nonbookish: JSONNull?? = nil,
2293+ phonendoscope: Int?? = nil,
2294+ pilferment: Int?? = nil,
2295+ predismissory: Int?? = nil,
2296+ preinscription: Int?? = nil,
2297+ quotative: Int?? = nil,
2298+ sienna: Int?? = nil,
2299+ thorax: Int?? = nil,
2300+ yachting: Int?? = nil,
2301+ zipper: Int?? = nil
2302+ ) -> PiaculumClass {
2303+ return PiaculumClass(
2304+ alada: alada ?? self.alada,
2305+ amphistomous: amphistomous ?? self.amphistomous,
2306+ boysenberry: boysenberry ?? self.boysenberry,
2307+ catharticalness: catharticalness ?? self.catharticalness,
2308+ chirotherium: chirotherium ?? self.chirotherium,
2309+ decardinalize: decardinalize ?? self.decardinalize,
2310+ discouragement: discouragement ?? self.discouragement,
2311+ disdiapason: disdiapason ?? self.disdiapason,
2312+ doitrified: doitrified ?? self.doitrified,
2313+ hexaspermous: hexaspermous ?? self.hexaspermous,
2314+ homocerc: homocerc ?? self.homocerc,
2315+ insinking: insinking ?? self.insinking,
2316+ loathfulness: loathfulness ?? self.loathfulness,
2317+ miasmatical: miasmatical ?? self.miasmatical,
2318+ neurofibril: neurofibril ?? self.neurofibril,
2319+ nonbookish: nonbookish ?? self.nonbookish,
2320+ phonendoscope: phonendoscope ?? self.phonendoscope,
2321+ pilferment: pilferment ?? self.pilferment,
2322+ predismissory: predismissory ?? self.predismissory,
2323+ preinscription: preinscription ?? self.preinscription,
2324+ quotative: quotative ?? self.quotative,
2325+ sienna: sienna ?? self.sienna,
2326+ thorax: thorax ?? self.thorax,
2327+ yachting: yachting ?? self.yachting,
2328+ zipper: zipper ?? self.zipper
2329+ )
2330+ }
2331+
2332+ func jsonData() throws -> Data {
2333+ return try newJSONEncoder().encode(self)
2334+ }
2335+
2336+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2337+ return String(data: try self.jsonData(), encoding: encoding)
2338+ }
2339+}
2340+
2341+enum Piccadilly: Codable, Hashable {
2342+ case double(Double)
2343+ case string(String)
2344+ case null
2345+
2346+ init(from decoder: Decoder) throws {
2347+ let container = try decoder.singleValueContainer()
2348+ if let x = try? container.decode(Double.self) {
2349+ self = .double(x)
2350+ return
2351+ }
2352+ if let x = try? container.decode(String.self) {
2353+ self = .string(x)
2354+ return
2355+ }
2356+ if container.decodeNil() {
2357+ self = .null
2358+ return
2359+ }
2360+ throw DecodingError.typeMismatch(Piccadilly.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Piccadilly"))
2361+ }
2362+
2363+ func encode(to encoder: Encoder) throws {
2364+ var container = encoder.singleValueContainer()
2365+ switch self {
2366+ case .double(let x):
2367+ try container.encode(x)
2368+ case .string(let x):
2369+ try container.encode(x)
2370+ case .null:
2371+ try container.encodeNil()
2372+ }
2373+ }
2374+}
2375+
2376+enum Piffler: Codable, Hashable {
2377+ case monaziteClass(MonaziteClass)
2378+ case nullArray([JSONNull?])
2379+
2380+ init(from decoder: Decoder) throws {
2381+ let container = try decoder.singleValueContainer()
2382+ if let x = try? container.decode([JSONNull?].self) {
2383+ self = .nullArray(x)
2384+ return
2385+ }
2386+ if let x = try? container.decode(MonaziteClass.self) {
2387+ self = .monaziteClass(x)
2388+ return
2389+ }
2390+ throw DecodingError.typeMismatch(Piffler.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Piffler"))
2391+ }
2392+
2393+ func encode(to encoder: Encoder) throws {
2394+ var container = encoder.singleValueContainer()
2395+ switch self {
2396+ case .monaziteClass(let x):
2397+ try container.encode(x)
2398+ case .nullArray(let x):
2399+ try container.encode(x)
2400+ }
2401+ }
2402+}
2403+
2404+enum Pithful: Codable, Hashable {
2405+ case bool(Bool)
2406+ case integer(Int)
2407+ case null
2408+
2409+ init(from decoder: Decoder) throws {
2410+ let container = try decoder.singleValueContainer()
2411+ if let x = try? container.decode(Bool.self) {
2412+ self = .bool(x)
2413+ return
2414+ }
2415+ if let x = try? container.decode(Int.self) {
2416+ self = .integer(x)
2417+ return
2418+ }
2419+ if container.decodeNil() {
2420+ self = .null
2421+ return
2422+ }
2423+ throw DecodingError.typeMismatch(Pithful.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Pithful"))
2424+ }
2425+
2426+ func encode(to encoder: Encoder) throws {
2427+ var container = encoder.singleValueContainer()
2428+ switch self {
2429+ case .bool(let x):
2430+ try container.encode(x)
2431+ case .integer(let x):
2432+ try container.encode(x)
2433+ case .null:
2434+ try container.encodeNil()
2435+ }
2436+ }
2437+}
2438+
2439+enum Placuntiti: Codable, Hashable {
2440+ case integer(Int)
2441+ case integerMap([String: Int])
2442+
2443+ init(from decoder: Decoder) throws {
2444+ let container = try decoder.singleValueContainer()
2445+ if let x = try? container.decode(Int.self) {
2446+ self = .integer(x)
2447+ return
2448+ }
2449+ if let x = try? container.decode([String: Int].self) {
2450+ self = .integerMap(x)
2451+ return
2452+ }
2453+ throw DecodingError.typeMismatch(Placuntiti.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Placuntiti"))
2454+ }
2455+
2456+ func encode(to encoder: Encoder) throws {
2457+ var container = encoder.singleValueContainer()
2458+ switch self {
2459+ case .integer(let x):
2460+ try container.encode(x)
2461+ case .integerMap(let x):
2462+ try container.encode(x)
2463+ }
2464+ }
2465+}
2466+
2467+enum Plectopterous: Codable, Hashable {
2468+ case double(Double)
2469+ case integerMap([String: Int])
2470+
2471+ init(from decoder: Decoder) throws {
2472+ let container = try decoder.singleValueContainer()
2473+ if let x = try? container.decode(Double.self) {
2474+ self = .double(x)
2475+ return
2476+ }
2477+ if let x = try? container.decode([String: Int].self) {
2478+ self = .integerMap(x)
2479+ return
2480+ }
2481+ throw DecodingError.typeMismatch(Plectopterous.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Plectopterous"))
2482+ }
2483+
2484+ func encode(to encoder: Encoder) throws {
2485+ var container = encoder.singleValueContainer()
2486+ switch self {
2487+ case .double(let x):
2488+ try container.encode(x)
2489+ case .integerMap(let x):
2490+ try container.encode(x)
2491+ }
2492+ }
2493+}
2494+
2495+//
2496+// Hashable or Equatable:
2497+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
2498+// for types that require the use of JSONAny, nor will the implementation of Hashable be
2499+// synthesized for types that have collections (such as arrays or dictionaries).
2500+
2501+// MARK: - Pneumocele
2502+struct Pneumocele: Codable, Hashable {
2503+ let carbonarism: JSONNull?
2504+ let catharticalness: Double?
2505+ let chirotherium: Int?
2506+ let cineolic: JSONNull?
2507+ let cobbly: JSONNull?
2508+ let conchyliferous: JSONNull?
2509+ let congregation: JSONNull?
2510+ let disdiapason: String?
2511+ let enterotomy: JSONNull?
2512+ let entophytal: JSONNull?
2513+ let fewtrils: JSONNull?
2514+ let herem: JSONNull?
2515+ let homocerc: Bool?
2516+ let koniga: JSONNull?
2517+ let meticulosity: JSONNull?
2518+ let micky: JSONNull?
2519+ let mismarriage: JSONNull?
2520+ let neurotrophic: JSONNull?
2521+ let nonbookish: JSONNull?
2522+ let persuasively: JSONNull?
2523+ let replaceable: JSONNull?
2524+ let silex: JSONNull?
2525+ let taillight: JSONNull?
2526+ let unjealous: JSONNull?
2527+ let visitorial: JSONNull?
2528+
2529+ enum CodingKeys: String, CodingKey {
2530+ case carbonarism = "Carbonarism"
2531+ case catharticalness = "catharticalness"
2532+ case chirotherium = "Chirotherium"
2533+ case cineolic = "cineolic"
2534+ case cobbly = "cobbly"
2535+ case conchyliferous = "conchyliferous"
2536+ case congregation = "congregation"
2537+ case disdiapason = "disdiapason"
2538+ case enterotomy = "enterotomy"
2539+ case entophytal = "entophytal"
2540+ case fewtrils = "fewtrils"
2541+ case herem = "herem"
2542+ case homocerc = "homocerc"
2543+ case koniga = "Koniga"
2544+ case meticulosity = "meticulosity"
2545+ case micky = "Micky"
2546+ case mismarriage = "mismarriage"
2547+ case neurotrophic = "neurotrophic"
2548+ case nonbookish = "nonbookish"
2549+ case persuasively = "persuasively"
2550+ case replaceable = "replaceable"
2551+ case silex = "silex"
2552+ case taillight = "taillight"
2553+ case unjealous = "unjealous"
2554+ case visitorial = "visitorial"
2555+ }
2556+}
2557+
2558+// MARK: Pneumocele convenience initializers and mutators
2559+
2560+extension Pneumocele {
2561+ init(data: Data) throws {
2562+ self = try newJSONDecoder().decode(Pneumocele.self, from: data)
2563+ }
2564+
2565+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2566+ guard let data = json.data(using: encoding) else {
2567+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2568+ }
2569+ try self.init(data: data)
2570+ }
2571+
2572+ init(fromURL url: URL) throws {
2573+ try self.init(data: try Data(contentsOf: url))
2574+ }
2575+
2576+ func with(
2577+ carbonarism: JSONNull?? = nil,
2578+ catharticalness: Double?? = nil,
2579+ chirotherium: Int?? = nil,
2580+ cineolic: JSONNull?? = nil,
2581+ cobbly: JSONNull?? = nil,
2582+ conchyliferous: JSONNull?? = nil,
2583+ congregation: JSONNull?? = nil,
2584+ disdiapason: String?? = nil,
2585+ enterotomy: JSONNull?? = nil,
2586+ entophytal: JSONNull?? = nil,
2587+ fewtrils: JSONNull?? = nil,
2588+ herem: JSONNull?? = nil,
2589+ homocerc: Bool?? = nil,
2590+ koniga: JSONNull?? = nil,
2591+ meticulosity: JSONNull?? = nil,
2592+ micky: JSONNull?? = nil,
2593+ mismarriage: JSONNull?? = nil,
2594+ neurotrophic: JSONNull?? = nil,
2595+ nonbookish: JSONNull?? = nil,
2596+ persuasively: JSONNull?? = nil,
2597+ replaceable: JSONNull?? = nil,
2598+ silex: JSONNull?? = nil,
2599+ taillight: JSONNull?? = nil,
2600+ unjealous: JSONNull?? = nil,
2601+ visitorial: JSONNull?? = nil
2602+ ) -> Pneumocele {
2603+ return Pneumocele(
2604+ carbonarism: carbonarism ?? self.carbonarism,
2605+ catharticalness: catharticalness ?? self.catharticalness,
2606+ chirotherium: chirotherium ?? self.chirotherium,
2607+ cineolic: cineolic ?? self.cineolic,
2608+ cobbly: cobbly ?? self.cobbly,
2609+ conchyliferous: conchyliferous ?? self.conchyliferous,
2610+ congregation: congregation ?? self.congregation,
2611+ disdiapason: disdiapason ?? self.disdiapason,
2612+ enterotomy: enterotomy ?? self.enterotomy,
2613+ entophytal: entophytal ?? self.entophytal,
2614+ fewtrils: fewtrils ?? self.fewtrils,
2615+ herem: herem ?? self.herem,
2616+ homocerc: homocerc ?? self.homocerc,
2617+ koniga: koniga ?? self.koniga,
2618+ meticulosity: meticulosity ?? self.meticulosity,
2619+ micky: micky ?? self.micky,
2620+ mismarriage: mismarriage ?? self.mismarriage,
2621+ neurotrophic: neurotrophic ?? self.neurotrophic,
2622+ nonbookish: nonbookish ?? self.nonbookish,
2623+ persuasively: persuasively ?? self.persuasively,
2624+ replaceable: replaceable ?? self.replaceable,
2625+ silex: silex ?? self.silex,
2626+ taillight: taillight ?? self.taillight,
2627+ unjealous: unjealous ?? self.unjealous,
2628+ visitorial: visitorial ?? self.visitorial
2629+ )
2630+ }
2631+
2632+ func jsonData() throws -> Data {
2633+ return try newJSONEncoder().encode(self)
2634+ }
2635+
2636+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2637+ return String(data: try self.jsonData(), encoding: encoding)
2638+ }
2639+}
2640+
2641+enum Poliorcetic: Codable, Hashable {
2642+ case bool(Bool)
2643+ case monaziteClass(MonaziteClass)
2644+
2645+ init(from decoder: Decoder) throws {
2646+ let container = try decoder.singleValueContainer()
2647+ if let x = try? container.decode(Bool.self) {
2648+ self = .bool(x)
2649+ return
2650+ }
2651+ if let x = try? container.decode(MonaziteClass.self) {
2652+ self = .monaziteClass(x)
2653+ return
2654+ }
2655+ throw DecodingError.typeMismatch(Poliorcetic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Poliorcetic"))
2656+ }
2657+
2658+ func encode(to encoder: Encoder) throws {
2659+ var container = encoder.singleValueContainer()
2660+ switch self {
2661+ case .bool(let x):
2662+ try container.encode(x)
2663+ case .monaziteClass(let x):
2664+ try container.encode(x)
2665+ }
2666+ }
2667+}
2668+
2669+enum Poormaster: Codable, Hashable {
2670+ case integerArray([Int])
2671+ case integerMap([String: Int])
2672+ case null
2673+
2674+ init(from decoder: Decoder) throws {
2675+ let container = try decoder.singleValueContainer()
2676+ if let x = try? container.decode([Int].self) {
2677+ self = .integerArray(x)
2678+ return
2679+ }
2680+ if let x = try? container.decode([String: Int].self) {
2681+ self = .integerMap(x)
2682+ return
2683+ }
2684+ if container.decodeNil() {
2685+ self = .null
2686+ return
2687+ }
2688+ throw DecodingError.typeMismatch(Poormaster.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Poormaster"))
2689+ }
2690+
2691+ func encode(to encoder: Encoder) throws {
2692+ var container = encoder.singleValueContainer()
2693+ switch self {
2694+ case .integerArray(let x):
2695+ try container.encode(x)
2696+ case .integerMap(let x):
2697+ try container.encode(x)
2698+ case .null:
2699+ try container.encodeNil()
2700+ }
2701+ }
2702+}
2703+
2704+enum PotwhiskyElement: Codable, Hashable {
2705+ case integer(Int)
2706+ case potwhiskyClass(PotwhiskyClass)
2707+ case null
2708+
2709+ init(from decoder: Decoder) throws {
2710+ let container = try decoder.singleValueContainer()
2711+ if let x = try? container.decode(Int.self) {
2712+ self = .integer(x)
2713+ return
2714+ }
2715+ if let x = try? container.decode(PotwhiskyClass.self) {
2716+ self = .potwhiskyClass(x)
2717+ return
2718+ }
2719+ if container.decodeNil() {
2720+ self = .null
2721+ return
2722+ }
2723+ throw DecodingError.typeMismatch(PotwhiskyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PotwhiskyElement"))
2724+ }
2725+
2726+ func encode(to encoder: Encoder) throws {
2727+ var container = encoder.singleValueContainer()
2728+ switch self {
2729+ case .integer(let x):
2730+ try container.encode(x)
2731+ case .potwhiskyClass(let x):
2732+ try container.encode(x)
2733+ case .null:
2734+ try container.encodeNil()
2735+ }
2736+ }
2737+}
2738+
2739+//
2740+// Hashable or Equatable:
2741+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
2742+// for types that require the use of JSONAny, nor will the implementation of Hashable be
2743+// synthesized for types that have collections (such as arrays or dictionaries).
2744+
2745+// MARK: - PotwhiskyClass
2746+struct PotwhiskyClass: Codable, Hashable {
2747+ let arciform: JSONNull?
2748+ let cresolin: JSONNull?
2749+ let disheartener: JSONNull?
2750+ let disproportionable: JSONNull?
2751+ let euchorda: JSONNull?
2752+ let ferryway: JSONNull?
2753+ let filamentiferous: JSONNull?
2754+ let flemish: JSONNull?
2755+ let forgainst: JSONNull?
2756+ let grainering: JSONNull?
2757+ let irrevoluble: JSONNull?
2758+ let kindredship: JSONNull?
2759+ let pinguitudinous: JSONNull?
2760+ let simpletonic: JSONNull?
2761+ let singsong: JSONNull?
2762+ let submergement: JSONNull?
2763+ let supraoesophagal: JSONNull?
2764+ let thrashel: JSONNull?
2765+ let tyremesis: JSONNull?
2766+ let yoruba: JSONNull?
2767+
2768+ enum CodingKeys: String, CodingKey {
2769+ case arciform = "arciform"
2770+ case cresolin = "cresolin"
2771+ case disheartener = "disheartener"
2772+ case disproportionable = "disproportionable"
2773+ case euchorda = "Euchorda"
2774+ case ferryway = "ferryway"
2775+ case filamentiferous = "filamentiferous"
2776+ case flemish = "flemish"
2777+ case forgainst = "forgainst"
2778+ case grainering = "grainering"
2779+ case irrevoluble = "irrevoluble"
2780+ case kindredship = "kindredship"
2781+ case pinguitudinous = "pinguitudinous"
2782+ case simpletonic = "simpletonic"
2783+ case singsong = "singsong"
2784+ case submergement = "submergement"
2785+ case supraoesophagal = "supraoesophagal"
2786+ case thrashel = "thrashel"
2787+ case tyremesis = "tyremesis"
2788+ case yoruba = "Yoruba"
2789+ }
2790+}
2791+
2792+// MARK: PotwhiskyClass convenience initializers and mutators
2793+
2794+extension PotwhiskyClass {
2795+ init(data: Data) throws {
2796+ self = try newJSONDecoder().decode(PotwhiskyClass.self, from: data)
2797+ }
2798+
2799+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2800+ guard let data = json.data(using: encoding) else {
2801+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2802+ }
2803+ try self.init(data: data)
2804+ }
2805+
2806+ init(fromURL url: URL) throws {
2807+ try self.init(data: try Data(contentsOf: url))
2808+ }
2809+
2810+ func with(
2811+ arciform: JSONNull?? = nil,
2812+ cresolin: JSONNull?? = nil,
2813+ disheartener: JSONNull?? = nil,
2814+ disproportionable: JSONNull?? = nil,
2815+ euchorda: JSONNull?? = nil,
2816+ ferryway: JSONNull?? = nil,
2817+ filamentiferous: JSONNull?? = nil,
2818+ flemish: JSONNull?? = nil,
2819+ forgainst: JSONNull?? = nil,
2820+ grainering: JSONNull?? = nil,
2821+ irrevoluble: JSONNull?? = nil,
2822+ kindredship: JSONNull?? = nil,
2823+ pinguitudinous: JSONNull?? = nil,
2824+ simpletonic: JSONNull?? = nil,
2825+ singsong: JSONNull?? = nil,
2826+ submergement: JSONNull?? = nil,
2827+ supraoesophagal: JSONNull?? = nil,
2828+ thrashel: JSONNull?? = nil,
2829+ tyremesis: JSONNull?? = nil,
2830+ yoruba: JSONNull?? = nil
2831+ ) -> PotwhiskyClass {
2832+ return PotwhiskyClass(
2833+ arciform: arciform ?? self.arciform,
2834+ cresolin: cresolin ?? self.cresolin,
2835+ disheartener: disheartener ?? self.disheartener,
2836+ disproportionable: disproportionable ?? self.disproportionable,
2837+ euchorda: euchorda ?? self.euchorda,
2838+ ferryway: ferryway ?? self.ferryway,
2839+ filamentiferous: filamentiferous ?? self.filamentiferous,
2840+ flemish: flemish ?? self.flemish,
2841+ forgainst: forgainst ?? self.forgainst,
2842+ grainering: grainering ?? self.grainering,
2843+ irrevoluble: irrevoluble ?? self.irrevoluble,
2844+ kindredship: kindredship ?? self.kindredship,
2845+ pinguitudinous: pinguitudinous ?? self.pinguitudinous,
2846+ simpletonic: simpletonic ?? self.simpletonic,
2847+ singsong: singsong ?? self.singsong,
2848+ submergement: submergement ?? self.submergement,
2849+ supraoesophagal: supraoesophagal ?? self.supraoesophagal,
2850+ thrashel: thrashel ?? self.thrashel,
2851+ tyremesis: tyremesis ?? self.tyremesis,
2852+ yoruba: yoruba ?? self.yoruba
2853+ )
2854+ }
2855+
2856+ func jsonData() throws -> Data {
2857+ return try newJSONEncoder().encode(self)
2858+ }
2859+
2860+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2861+ return String(data: try self.jsonData(), encoding: encoding)
2862+ }
2863+}
2864+
2865+enum Practicalizer: Codable, Hashable {
2866+ case monaziteClass(MonaziteClass)
2867+ case nullArray([JSONNull?])
2868+ case string(String)
2869+
2870+ init(from decoder: Decoder) throws {
2871+ let container = try decoder.singleValueContainer()
2872+ if let x = try? container.decode([JSONNull?].self) {
2873+ self = .nullArray(x)
2874+ return
2875+ }
2876+ if let x = try? container.decode(String.self) {
2877+ self = .string(x)
2878+ return
2879+ }
2880+ if let x = try? container.decode(MonaziteClass.self) {
2881+ self = .monaziteClass(x)
2882+ return
2883+ }
2884+ throw DecodingError.typeMismatch(Practicalizer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Practicalizer"))
2885+ }
2886+
2887+ func encode(to encoder: Encoder) throws {
2888+ var container = encoder.singleValueContainer()
2889+ switch self {
2890+ case .monaziteClass(let x):
2891+ try container.encode(x)
2892+ case .nullArray(let x):
2893+ try container.encode(x)
2894+ case .string(let x):
2895+ try container.encode(x)
2896+ }
2897+ }
2898+}
2899+
2900+enum PrefreshmanElement: Codable, Hashable {
2901+ case nullArray([JSONNull?])
2902+ case prefreshmanClass(PrefreshmanClass)
2903+ case string(String)
2904+
2905+ init(from decoder: Decoder) throws {
2906+ let container = try decoder.singleValueContainer()
2907+ if let x = try? container.decode([JSONNull?].self) {
2908+ self = .nullArray(x)
2909+ return
2910+ }
2911+ if let x = try? container.decode(String.self) {
2912+ self = .string(x)
2913+ return
2914+ }
2915+ if let x = try? container.decode(PrefreshmanClass.self) {
2916+ self = .prefreshmanClass(x)
2917+ return
2918+ }
2919+ throw DecodingError.typeMismatch(PrefreshmanElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PrefreshmanElement"))
2920+ }
2921+
2922+ func encode(to encoder: Encoder) throws {
2923+ var container = encoder.singleValueContainer()
2924+ switch self {
2925+ case .nullArray(let x):
2926+ try container.encode(x)
2927+ case .prefreshmanClass(let x):
2928+ try container.encode(x)
2929+ case .string(let x):
2930+ try container.encode(x)
2931+ }
2932+ }
2933+}
2934+
2935+//
2936+// Hashable or Equatable:
2937+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
2938+// for types that require the use of JSONAny, nor will the implementation of Hashable be
2939+// synthesized for types that have collections (such as arrays or dictionaries).
2940+
2941+// MARK: - PrefreshmanClass
2942+struct PrefreshmanClass: Codable, Hashable {
2943+ let azorubine: JSONNull?
2944+ let choroiditis: JSONNull?
2945+ let coagulatory: JSONNull?
2946+ let cyclorama: JSONNull?
2947+ let dolphus: JSONNull?
2948+ let duckhearted: JSONNull?
2949+ let ficus: JSONNull?
2950+ let gemaric: JSONNull?
2951+ let jugation: JSONNull?
2952+ let myoliposis: JSONNull?
2953+ let nonnomination: JSONNull?
2954+ let palay: JSONNull?
2955+ let pentactinal: JSONNull?
2956+ let phaet: JSONNull?
2957+ let piquant: JSONNull?
2958+ let registration: JSONNull?
2959+ let remancipation: JSONNull?
2960+ let scutatiform: JSONNull?
2961+ let theodolite: JSONNull?
2962+ let underward: JSONNull?
2963+
2964+ enum CodingKeys: String, CodingKey {
2965+ case azorubine = "azorubine"
2966+ case choroiditis = "choroiditis"
2967+ case coagulatory = "coagulatory"
2968+ case cyclorama = "cyclorama"
2969+ case dolphus = "Dolphus"
2970+ case duckhearted = "duckhearted"
2971+ case ficus = "Ficus"
2972+ case gemaric = "Gemaric"
2973+ case jugation = "jugation"
2974+ case myoliposis = "myoliposis"
2975+ case nonnomination = "nonnomination"
2976+ case palay = "palay"
2977+ case pentactinal = "pentactinal"
2978+ case phaet = "Phaet"
2979+ case piquant = "piquant"
2980+ case registration = "registration"
2981+ case remancipation = "remancipation"
2982+ case scutatiform = "scutatiform"
2983+ case theodolite = "theodolite"
2984+ case underward = "underward"
2985+ }
2986+}
2987+
2988+// MARK: PrefreshmanClass convenience initializers and mutators
2989+
2990+extension PrefreshmanClass {
2991+ init(data: Data) throws {
2992+ self = try newJSONDecoder().decode(PrefreshmanClass.self, from: data)
2993+ }
2994+
2995+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2996+ guard let data = json.data(using: encoding) else {
2997+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2998+ }
2999+ try self.init(data: data)
3000+ }
3001+
3002+ init(fromURL url: URL) throws {
3003+ try self.init(data: try Data(contentsOf: url))
3004+ }
3005+
3006+ func with(
3007+ azorubine: JSONNull?? = nil,
3008+ choroiditis: JSONNull?? = nil,
3009+ coagulatory: JSONNull?? = nil,
3010+ cyclorama: JSONNull?? = nil,
3011+ dolphus: JSONNull?? = nil,
3012+ duckhearted: JSONNull?? = nil,
3013+ ficus: JSONNull?? = nil,
3014+ gemaric: JSONNull?? = nil,
3015+ jugation: JSONNull?? = nil,
3016+ myoliposis: JSONNull?? = nil,
3017+ nonnomination: JSONNull?? = nil,
3018+ palay: JSONNull?? = nil,
3019+ pentactinal: JSONNull?? = nil,
3020+ phaet: JSONNull?? = nil,
3021+ piquant: JSONNull?? = nil,
3022+ registration: JSONNull?? = nil,
3023+ remancipation: JSONNull?? = nil,
3024+ scutatiform: JSONNull?? = nil,
3025+ theodolite: JSONNull?? = nil,
3026+ underward: JSONNull?? = nil
3027+ ) -> PrefreshmanClass {
3028+ return PrefreshmanClass(
3029+ azorubine: azorubine ?? self.azorubine,
3030+ choroiditis: choroiditis ?? self.choroiditis,
3031+ coagulatory: coagulatory ?? self.coagulatory,
3032+ cyclorama: cyclorama ?? self.cyclorama,
3033+ dolphus: dolphus ?? self.dolphus,
3034+ duckhearted: duckhearted ?? self.duckhearted,
3035+ ficus: ficus ?? self.ficus,
3036+ gemaric: gemaric ?? self.gemaric,
3037+ jugation: jugation ?? self.jugation,
3038+ myoliposis: myoliposis ?? self.myoliposis,
3039+ nonnomination: nonnomination ?? self.nonnomination,
3040+ palay: palay ?? self.palay,
3041+ pentactinal: pentactinal ?? self.pentactinal,
3042+ phaet: phaet ?? self.phaet,
3043+ piquant: piquant ?? self.piquant,
3044+ registration: registration ?? self.registration,
3045+ remancipation: remancipation ?? self.remancipation,
3046+ scutatiform: scutatiform ?? self.scutatiform,
3047+ theodolite: theodolite ?? self.theodolite,
3048+ underward: underward ?? self.underward
3049+ )
3050+ }
3051+
3052+ func jsonData() throws -> Data {
3053+ return try newJSONEncoder().encode(self)
3054+ }
3055+
3056+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
3057+ return String(data: try self.jsonData(), encoding: encoding)
3058+ }
3059+}
3060+
3061+enum Prehensility: Codable, Hashable {
3062+ case bool(Bool)
3063+ case monaziteClass(MonaziteClass)
3064+ case nullArray([JSONNull?])
3065+
3066+ init(from decoder: Decoder) throws {
3067+ let container = try decoder.singleValueContainer()
3068+ if let x = try? container.decode(Bool.self) {
3069+ self = .bool(x)
3070+ return
3071+ }
3072+ if let x = try? container.decode([JSONNull?].self) {
3073+ self = .nullArray(x)
3074+ return
3075+ }
3076+ if let x = try? container.decode(MonaziteClass.self) {
3077+ self = .monaziteClass(x)
3078+ return
3079+ }
3080+ throw DecodingError.typeMismatch(Prehensility.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Prehensility"))
3081+ }
3082+
3083+ func encode(to encoder: Encoder) throws {
3084+ var container = encoder.singleValueContainer()
3085+ switch self {
3086+ case .bool(let x):
3087+ try container.encode(x)
3088+ case .monaziteClass(let x):
3089+ try container.encode(x)
3090+ case .nullArray(let x):
3091+ try container.encode(x)
3092+ }
3093+ }
3094+}
3095+
3096+enum Prevoidance: Codable, Hashable {
3097+ case integer(Int)
3098+ case integerArray([Int])
3099+ case monaziteClass(MonaziteClass)
3100+
3101+ init(from decoder: Decoder) throws {
3102+ let container = try decoder.singleValueContainer()
3103+ if let x = try? container.decode(Int.self) {
3104+ self = .integer(x)
3105+ return
3106+ }
3107+ if let x = try? container.decode([Int].self) {
3108+ self = .integerArray(x)
3109+ return
3110+ }
3111+ if let x = try? container.decode(MonaziteClass.self) {
3112+ self = .monaziteClass(x)
3113+ return
3114+ }
3115+ throw DecodingError.typeMismatch(Prevoidance.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Prevoidance"))
3116+ }
3117+
3118+ func encode(to encoder: Encoder) throws {
3119+ var container = encoder.singleValueContainer()
3120+ switch self {
3121+ case .integer(let x):
3122+ try container.encode(x)
3123+ case .integerArray(let x):
3124+ try container.encode(x)
3125+ case .monaziteClass(let x):
3126+ try container.encode(x)
3127+ }
3128+ }
3129+}
3130+
3131+enum Protext: Codable, Hashable {
3132+ case bool(Bool)
3133+ case integerArray([Int])
3134+ case monaziteClass(MonaziteClass)
3135+
3136+ init(from decoder: Decoder) throws {
3137+ let container = try decoder.singleValueContainer()
3138+ if let x = try? container.decode(Bool.self) {
3139+ self = .bool(x)
3140+ return
3141+ }
3142+ if let x = try? container.decode([Int].self) {
3143+ self = .integerArray(x)
3144+ return
3145+ }
3146+ if let x = try? container.decode(MonaziteClass.self) {
3147+ self = .monaziteClass(x)
3148+ return
3149+ }
3150+ throw DecodingError.typeMismatch(Protext.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Protext"))
3151+ }
3152+
3153+ func encode(to encoder: Encoder) throws {
3154+ var container = encoder.singleValueContainer()
3155+ switch self {
3156+ case .bool(let x):
3157+ try container.encode(x)
3158+ case .integerArray(let x):
3159+ try container.encode(x)
3160+ case .monaziteClass(let x):
3161+ try container.encode(x)
3162+ }
3163+ }
3164+}
3165+
3166+// MARK: - Helper functions for creating encoders and decoders
3167+
3168+func newJSONDecoder() -> JSONDecoder {
3169+ let decoder = JSONDecoder()
3170+ decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in
3171+ let container = try decoder.singleValueContainer()
3172+ let dateStr = try container.decode(String.self)
3173+
3174+ let formatter = DateFormatter()
3175+ formatter.calendar = Calendar(identifier: .iso8601)
3176+ formatter.locale = Locale(identifier: "en_US_POSIX")
3177+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
3178+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX"
3179+ if let date = formatter.date(from: dateStr) {
3180+ return date
3181+ }
3182+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX"
3183+ if let date = formatter.date(from: dateStr) {
3184+ return date
3185+ }
3186+ throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date"))
3187+ })
3188+ return decoder
3189+}
3190+
3191+func newJSONEncoder() -> JSONEncoder {
3192+ let encoder = JSONEncoder()
3193+ let formatter = DateFormatter()
3194+ formatter.calendar = Calendar(identifier: .iso8601)
3195+ formatter.locale = Locale(identifier: "en_US_POSIX")
3196+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
3197+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSXXXXX"
3198+ encoder.dateEncodingStrategy = .formatted(formatter)
3199+ return encoder
3200+}
3201+
3202+// MARK: - Encode/decode helpers
3203+
3204+class JSONNull: Codable, Hashable {
3205+
3206+ public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool {
3207+ return true
3208+ }
3209+
3210+ public func hash(into hasher: inout Hasher) {
3211+ hasher.combine(0)
3212+ }
3213+
3214+ public init() {}
3215+
3216+ public required init(from decoder: Decoder) throws {
3217+ let container = try decoder.singleValueContainer()
3218+ if !container.decodeNil() {
3219+ throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull"))
3220+ }
3221+ }
3222+
3223+ public func encode(to encoder: Encoder) throws {
3224+ var container = encoder.singleValueContainer()
3225+ try container.encodeNil()
3226+ }
3227+}
Atypescriptprefer-const-values-true--6b26e4d1265c / TopLevel.ts+1,016 −0
@@ -0,0 +1,1016 @@
1+// To parse this data:
2+//
3+// import { Convert, TopLevel } from "./TopLevel";
4+//
5+// const topLevel = Convert.toTopLevel(json);
6+//
7+// These functions will throw an error if the JSON doesn't
8+// match the expected interface, even if the JSON is valid.
9+
10+export interface TopLevel {
11+ juror: JurorElement[];
12+ kongoni: Kongoni[];
13+ ladronism: LadronismElement[];
14+ landlubberly: LandlubberlyElement[];
15+ listener: Listener[];
16+ lupus: LupusElement[];
17+ maslin: Maslin[];
18+ monazite: MonaziteElement[];
19+ monoliteral: Monoliteral[];
20+ monotheistically: MonotheisticallyElement[];
21+ montage: Montage[];
22+ moralness: Moralness[];
23+ mowra: (MonaziteClass | null)[];
24+ mulishly: Mulishly[];
25+ myoscope: Myoscope[];
26+ nach: ((number | null)[] | null)[];
27+ neuromastic: Neuromastic[];
28+ noncontributing: Noncontributing[];
29+ nonnervous: Nonnervous[];
30+ nonvaluation: Nonvaluation[];
31+ occupationalist: OccupationalistElement[];
32+ outrival: OutrivalElement[];
33+ paleographically: Paleographically[];
34+ pamphletwise: Pamphletwise[];
35+ pediatrics: Pediatric[];
36+ perceptive: boolean[];
37+ piaculum: PiaculumElement[];
38+ piccadilly: Piccadilly[];
39+ piffler: Piffler[];
40+ pithful: Pithful[];
41+ placuntitis: Placuntiti[];
42+ plectopterous: Plectopterous[];
43+ pneumocele: (Pneumocele | null)[];
44+ poliorcetic: Poliorcetic[];
45+ poormaster: Poormaster[];
46+ potwhisky: PotwhiskyElement[];
47+ practicalizer: Practicalizer[];
48+ prefreshman: PrefreshmanElement[];
49+ prehensility: Prehensility[];
50+ prevoidance: Prevoidance[];
51+ probant: { [key: string]: number | null }[];
52+ protext: Protext[];
53+}
54+
55+export type JurorElement = boolean | JurorClass;
56+
57+export interface JurorClass {
58+ Olea: null;
59+ adipsy: null;
60+ auxiliator: null;
61+ benda: null;
62+ benjamin: null;
63+ brandling: null;
64+ epicurishly: null;
65+ eremochaetous: null;
66+ marten: null;
67+ monocline: null;
68+ palgat: null;
69+ pennyworth: null;
70+ pioury: null;
71+ pragmatistic: null;
72+ stylelessness: null;
73+ systematical: null;
74+ thready: null;
75+ uncontemporary: null;
76+ uncouched: null;
77+ uninhabitedness: null;
78+}
79+
80+export type Kongoni = number[] | { [key: string]: number };
81+
82+export type LadronismElement = LadronismClass | number | string;
83+
84+export interface LadronismClass {
85+ Prodenia: null;
86+ acclaimer: null;
87+ achree: null;
88+ base: null;
89+ conundrumize: null;
90+ degerminator: null;
91+ describable: null;
92+ exasperatedly: null;
93+ heroine: null;
94+ indazin: null;
95+ luteous: null;
96+ papular: null;
97+ pritch: null;
98+ seege: null;
99+ shopgirl: null;
100+ tragedietta: null;
101+ unsparse: null;
102+ uplook: null;
103+ vermiformis: null;
104+ whafabout: null;
105+}
106+
107+export type LandlubberlyElement = boolean | LandlubberlyClass | number;
108+
109+export interface LandlubberlyClass {
110+ Amyraldism: null;
111+ acropoleis: null;
112+ aminate: null;
113+ bipenniform: null;
114+ bugre: null;
115+ calycule: null;
116+ caoutchouc: null;
117+ disprover: null;
118+ fitroot: null;
119+ fulgently: null;
120+ kickup: null;
121+ laevoversion: null;
122+ moter: null;
123+ objectivity: null;
124+ posterity: null;
125+ postnuptial: null;
126+ precedentary: null;
127+ saddling: null;
128+ subcurrent: null;
129+ unrecriminative: null;
130+}
131+
132+export type Listener = null[] | number;
133+
134+export type LupusElement = LupusClass | number;
135+
136+export interface LupusClass {
137+ Chirotherium?: number;
138+ Chlorioninae?: number;
139+ Corvinae?: number;
140+ Crassina?: number;
141+ Thysanocarpus?: number;
142+ catharticalness?: number;
143+ disdiapason?: string;
144+ exiguity?: number;
145+ farcist?: number;
146+ holographical?: number;
147+ homocerc?: boolean;
148+ ichthyophagan?: number;
149+ implacable?: number;
150+ nonbookish?: null;
151+ outshiner?: number;
152+ overweather?: number;
153+ protonegroid?: number;
154+ shallowish?: number;
155+ snoke?: number;
156+ snout?: number;
157+ surveillance?: number;
158+ threshingtime?: number;
159+ unsignificantly?: number;
160+ unsnap?: number;
161+ vendible?: number;
162+}
163+
164+export interface Maslin {
165+ Alicant?: number;
166+ Bakuninist?: null;
167+ Chirotherium?: number;
168+ Dimitry?: number;
169+ antiatonement?: null;
170+ anticorrosive?: number;
171+ aphidozer?: null;
172+ be?: number;
173+ catharticalness?: number;
174+ chub?: number;
175+ cuprosilicon?: number;
176+ curtailedly?: number;
177+ dellenite?: number;
178+ disdiapason?: string;
179+ edifying?: null;
180+ ethmoiditis?: number;
181+ gastralgy?: null;
182+ goatherd?: number;
183+ hammerdress?: number;
184+ hangfire?: null;
185+ homocerc?: boolean;
186+ lacunosity?: number;
187+ longiloquence?: null;
188+ mameliere?: number;
189+ motherless?: null;
190+ nonbookish?: null;
191+ noncorrodible?: null;
192+ nonsensicality?: null;
193+ oafishly?: number;
194+ pfund?: null;
195+ preadvisory?: null;
196+ retroflexed?: null;
197+ saccharulmic?: number;
198+ scowlful?: number;
199+ secluded?: null;
200+ slackage?: null;
201+ sphaeridial?: number;
202+ spondulics?: null;
203+ subsecive?: number;
204+ swellmobsman?: null;
205+ trachyglossate?: number;
206+ trialogue?: null;
207+ unassuaged?: number;
208+ ungross?: null;
209+ unjudiciously?: null;
210+}
211+
212+export type MonaziteElement = MonaziteClass | number;
213+
214+export interface MonaziteClass {
215+ Chirotherium: number;
216+ catharticalness: number;
217+ disdiapason: string;
218+ homocerc: boolean;
219+ nonbookish: null;
220+}
221+
222+export type Monoliteral = null[] | boolean;
223+
224+export type MonotheisticallyElement = null[] | MonotheisticallyClass;
225+
226+export interface MonotheisticallyClass {
227+ Chirotherium?: number;
228+ blaspheme?: null;
229+ catharticalness?: number;
230+ celiosalpingectomy?: null;
231+ consummativeness?: null;
232+ disdiapason?: string;
233+ egestive?: null;
234+ enchylema?: null;
235+ gasconade?: null;
236+ holidayer?: null;
237+ homocerc?: boolean;
238+ intuitionalism?: null;
239+ lophiostomate?: null;
240+ nonbookish?: null;
241+ nonvolition?: null;
242+ palatableness?: null;
243+ pimpery?: null;
244+ previolation?: null;
245+ reconveyance?: null;
246+ registership?: null;
247+ rhyacolite?: null;
248+ smithereens?: null;
249+ superedification?: null;
250+ trust?: null;
251+ whitestone?: null;
252+}
253+
254+export type Montage = null[] | number | string;
255+
256+export type Moralness = null[] | number | null;
257+
258+export type Mulishly = number[] | number | null;
259+
260+export type Myoscope = null[] | boolean | number;
261+
262+export type Neuromastic = null[] | number;
263+
264+export interface Noncontributing {
265+ estevin: string;
266+ jolterhead: number;
267+ sauternes: number;
268+ sparsely: boolean;
269+ unrequested: null;
270+}
271+
272+export type Nonnervous = boolean | number;
273+
274+export type Nonvaluation = null[] | boolean | number;
275+
276+export type OccupationalistElement = null[] | OccupationalistClass | null;
277+
278+export interface OccupationalistClass {
279+ Chimakum: null;
280+ Fin: null;
281+ beholdable: null;
282+ brotuliform: null;
283+ doodler: null;
284+ emulsin: null;
285+ flourishing: null;
286+ flueless: null;
287+ furtively: null;
288+ gritter: null;
289+ interwish: null;
290+ monoxylic: null;
291+ myristic: null;
292+ nightwear: null;
293+ peruser: null;
294+ theoastrological: null;
295+ thumby: null;
296+ tingitid: null;
297+ trailless: null;
298+ unpocketed: null;
299+}
300+
301+export type OutrivalElement = OutrivalClass | number | null;
302+
303+export interface OutrivalClass {
304+ Castoroides: null;
305+ Czechoslovak: null;
306+ Lingulidae: null;
307+ adroitly: null;
308+ bridehood: null;
309+ diagenesis: null;
310+ dihexahedron: null;
311+ dopester: null;
312+ eumerism: null;
313+ flyness: null;
314+ fouler: null;
315+ laudanosine: null;
316+ minutary: null;
317+ mitra: null;
318+ opisthorchiasis: null;
319+ pensively: null;
320+ pubigerous: null;
321+ rebellious: null;
322+ recodify: null;
323+ unpaced: null;
324+}
325+
326+export type Paleographically = number | { [key: string]: number | null };
327+
328+export type Pamphletwise = number | { [key: string]: number } | string;
329+
330+export type Pediatric = boolean | number | null;
331+
332+export type PiaculumElement = PiaculumClass | number;
333+
334+export interface PiaculumClass {
335+ Chirotherium?: number;
336+ Zipper?: number;
337+ alada?: number;
338+ amphistomous?: number;
339+ boysenberry?: number;
340+ catharticalness?: number;
341+ decardinalize?: number;
342+ discouragement?: number;
343+ disdiapason?: string;
344+ doitrified?: number;
345+ hexaspermous?: number;
346+ homocerc?: boolean;
347+ insinking?: number;
348+ loathfulness?: number;
349+ miasmatical?: number;
350+ neurofibril?: number;
351+ nonbookish?: null;
352+ phonendoscope?: number;
353+ pilferment?: number;
354+ predismissory?: number;
355+ preinscription?: number;
356+ quotative?: number;
357+ sienna?: number;
358+ thorax?: number;
359+ yachting?: number;
360+}
361+
362+export type Piccadilly = number | null | string;
363+
364+export type Piffler = null[] | MonaziteClass;
365+
366+export type Pithful = boolean | number | null;
367+
368+export type Placuntiti = number | { [key: string]: number };
369+
370+export type Plectopterous = number | { [key: string]: number };
371+
372+export interface Pneumocele {
373+ Carbonarism?: null;
374+ Chirotherium?: number;
375+ Koniga?: null;
376+ Micky?: null;
377+ catharticalness?: number;
378+ cineolic?: null;
379+ cobbly?: null;
380+ conchyliferous?: null;
381+ congregation?: null;
382+ disdiapason?: string;
383+ enterotomy?: null;
384+ entophytal?: null;
385+ fewtrils?: null;
386+ herem?: null;
387+ homocerc?: boolean;
388+ meticulosity?: null;
389+ mismarriage?: null;
390+ neurotrophic?: null;
391+ nonbookish?: null;
392+ persuasively?: null;
393+ replaceable?: null;
394+ silex?: null;
395+ taillight?: null;
396+ unjealous?: null;
397+ visitorial?: null;
398+}
399+
400+export type Poliorcetic = boolean | MonaziteClass;
401+
402+export type Poormaster = number[] | { [key: string]: number } | null;
403+
404+export type PotwhiskyElement = PotwhiskyClass | number | null;
405+
406+export interface PotwhiskyClass {
407+ Euchorda: null;
408+ Yoruba: null;
409+ arciform: null;
410+ cresolin: null;
411+ disheartener: null;
412+ disproportionable: null;
413+ ferryway: null;
414+ filamentiferous: null;
415+ flemish: null;
416+ forgainst: null;
417+ grainering: null;
418+ irrevoluble: null;
419+ kindredship: null;
420+ pinguitudinous: null;
421+ simpletonic: null;
422+ singsong: null;
423+ submergement: null;
424+ supraoesophagal: null;
425+ thrashel: null;
426+ tyremesis: null;
427+}
428+
429+export type Practicalizer = null[] | MonaziteClass | string;
430+
431+export type PrefreshmanElement = null[] | PrefreshmanClass | string;
432+
433+export interface PrefreshmanClass {
434+ Dolphus: null;
435+ Ficus: null;
436+ Gemaric: null;
437+ Phaet: null;
438+ azorubine: null;
439+ choroiditis: null;
440+ coagulatory: null;
441+ cyclorama: null;
442+ duckhearted: null;
443+ jugation: null;
444+ myoliposis: null;
445+ nonnomination: null;
446+ palay: null;
447+ pentactinal: null;
448+ piquant: null;
449+ registration: null;
450+ remancipation: null;
451+ scutatiform: null;
452+ theodolite: null;
453+ underward: null;
454+}
455+
456+export type Prehensility = null[] | boolean | MonaziteClass;
457+
458+export type Prevoidance = number[] | MonaziteClass | number;
459+
460+export type Protext = number[] | boolean | MonaziteClass;
461+
462+// Converts JSON strings to/from your types
463+// and asserts the results of JSON.parse at runtime
464+export class Convert {
465+ public static toTopLevel(json: string): TopLevel {
466+ return cast(JSON.parse(json), r("TopLevel"));
467+ }
468+
469+ public static topLevelToJson(value: TopLevel): string {
470+ return JSON.stringify(uncast(value, r("TopLevel")), null, 2);
471+ }
472+}
473+
474+function invalidValue(typ: any, val: any, key: any, parent: any = ''): never {
475+ const prettyTyp = prettyTypeName(typ);
476+ const parentText = parent ? ` on ${parent}` : '';
477+ const keyText = key ? ` for key "${key}"` : '';
478+ throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`);
479+}
480+
481+function prettyTypeName(typ: any): string {
482+ if (Array.isArray(typ)) {
483+ if (typ.length === 2 && typ[0] === undefined) {
484+ return `an optional ${prettyTypeName(typ[1])}`;
485+ } else {
486+ return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`;
487+ }
488+ } else if (typeof typ === "object" && typ.literal !== undefined) {
489+ return typ.literal;
490+ } else {
491+ return typeof typ;
492+ }
493+}
494+
495+function jsonToJSProps(typ: any): any {
496+ if (typ.jsonToJS === undefined) {
497+ const map: any = {};
498+ typ.props.forEach((p: any) => map[p.json] = { key: p.js, typ: p.typ });
499+ typ.jsonToJS = map;
500+ }
501+ return typ.jsonToJS;
502+}
503+
504+function jsToJSONProps(typ: any): any {
505+ if (typ.jsToJSON === undefined) {
506+ const map: any = {};
507+ typ.props.forEach((p: any) => map[p.js] = { key: p.json, typ: p.typ });
508+ typ.jsToJSON = map;
509+ }
510+ return typ.jsToJSON;
511+}
512+
513+function transform(val: any, typ: any, getProps: any, key: any = '', parent: any = ''): any {
514+ function transformPrimitive(typ: string, val: any): any {
515+ if (typeof typ === typeof val) return val;
516+ return invalidValue(typ, val, key, parent);
517+ }
518+
519+ function transformUnion(typs: any[], val: any): any {
520+ // val must validate against one typ in typs
521+ const l = typs.length;
522+ for (let i = 0; i < l; i++) {
523+ const typ = typs[i];
524+ try {
525+ return transform(val, typ, getProps);
526+ } catch (_) {}
527+ }
528+ return invalidValue(typs, val, key, parent);
529+ }
530+
531+ function transformEnum(cases: string[], val: any): any {
532+ if (cases.indexOf(val) !== -1) return val;
533+ return invalidValue(cases.map(a => { return l(a); }), val, key, parent);
534+ }
535+
536+ function transformArray(typ: any, val: any): any {
537+ // val must be an array with no invalid elements
538+ if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent);
539+
540+ return val.map(el => transform(el, typ, getProps));
541+ }
542+
543+ function transformDate(val: any): any {
544+ if (val === null) {
545+ return null;
546+ }
547+ const d = new Date(val);
548+ if (isNaN(d.valueOf())) {
549+ return invalidValue(l("Date"), val, key, parent);
550+ }
551+ return d;
552+ }
553+
554+ function transformObject(props: { [k: string]: any }, additional: any, val: any): any {
555+ if (val === null || typeof val !== "object" || Array.isArray(val)) {
556+ return invalidValue(l(ref || "object"), val, key, parent);
557+ }
558+ const result: any = {};
559+ Object.getOwnPropertyNames(props).forEach(key => {
560+ const prop = props[key];
561+ const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined;
562+ result[prop.key] = transform(v, prop.typ, getProps, key, ref);
563+ });
564+ Object.getOwnPropertyNames(val).forEach(key => {
565+ if (!Object.prototype.hasOwnProperty.call(props, key)) {
566+ result[key] = transform(val[key], additional, getProps, key, ref);
567+ }
568+ });
569+ return result;
570+ }
571+
572+ if (typ === "any") return val;
573+ if (typ === null) {
574+ if (val === null) return val;
575+ return invalidValue(typ, val, key, parent);
576+ }
577+ if (typ === false) return invalidValue(typ, val, key, parent);
578+ let ref: any = undefined;
579+ while (typeof typ === "object" && typ.ref !== undefined) {
580+ ref = typ.ref;
581+ typ = typeMap[typ.ref];
582+ }
583+ if (Array.isArray(typ)) return transformEnum(typ, val);
584+ if (typeof typ === "object") {
585+ return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent)
586+ : 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)
587+ : 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)
588+ : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent)
589+ : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val)
590+ : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val)
591+ : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val)
592+ : invalidValue(typ, val, key, parent);
593+ }
594+ // Numbers can be parsed by Date but shouldn't be.
595+ if (typ === Date && typeof val !== "number") return transformDate(val);
596+ return transformPrimitive(typ, val);
597+}
598+
599+function cast<T>(val: any, typ: any): T {
600+ return transform(val, typ, jsonToJSProps);
601+}
602+
603+function uncast<T>(val: T, typ: any): any {
604+ return transform(val, typ, jsToJSONProps);
605+}
606+
607+function l(typ: any) {
608+ return { literal: typ };
609+}
610+
611+function a(typ: any) {
612+ return { arrayItems: typ };
613+}
614+
615+function i(typ: any) {
616+ return { integer: typ };
617+}
618+
619+function p(pattern: any) {
620+ return { pattern };
621+}
622+
623+function s(typ: any, min: any, max: any) {
624+ return { string: typ, min, max };
625+}
626+
627+function n(typ: any, min: any, max: any) {
628+ return { number: typ, min, max };
629+}
630+
631+function u(...typs: any[]) {
632+ return { unionMembers: typs };
633+}
634+
635+function o(props: any[], additional: any) {
636+ return { props, additional };
637+}
638+
639+function m(additional: any) {
640+ const props: any[] = [];
641+ return { props, additional };
642+}
643+
644+function r(name: string) {
645+ return { ref: name };
646+}
647+
648+const typeMap: any = {
649+ "TopLevel": o([
650+ { json: "juror", js: "juror", typ: a(u(true, r("JurorClass"))) },
651+ { json: "kongoni", js: "kongoni", typ: a(u(a(i(0)), m(i(0)))) },
652+ { json: "ladronism", js: "ladronism", typ: a(u(r("LadronismClass"), 3.14, "")) },
653+ { json: "landlubberly", js: "landlubberly", typ: a(u(true, r("LandlubberlyClass"), i(0))) },
654+ { json: "listener", js: "listener", typ: a(u(a(null), i(0))) },
655+ { json: "lupus", js: "lupus", typ: a(u(r("LupusClass"), i(0))) },
656+ { json: "maslin", js: "maslin", typ: a(r("Maslin")) },
657+ { json: "monazite", js: "monazite", typ: a(u(r("MonaziteClass"), 3.14)) },
658+ { json: "monoliteral", js: "monoliteral", typ: a(u(a(null), true)) },
659+ { json: "monotheistically", js: "monotheistically", typ: a(u(a(null), r("MonotheisticallyClass"))) },
660+ { json: "montage", js: "montage", typ: a(u(a(null), 3.14, "")) },
661+ { json: "moralness", js: "moralness", typ: a(u(a(null), 3.14, null)) },
662+ { json: "mowra", js: "mowra", typ: a(u(r("MonaziteClass"), null)) },
663+ { json: "mulishly", js: "mulishly", typ: a(u(a(i(0)), 3.14, null)) },
664+ { json: "myoscope", js: "myoscope", typ: a(u(a(null), true, i(0))) },
665+ { json: "nach", js: "nach", typ: a(u(a(u(i(0), null)), null)) },
666+ { json: "neuromastic", js: "neuromastic", typ: a(u(a(null), 3.14)) },
667+ { json: "noncontributing", js: "noncontributing", typ: a(r("Noncontributing")) },
668+ { json: "nonnervous", js: "nonnervous", typ: a(u(true, i(0))) },
669+ { json: "nonvaluation", js: "nonvaluation", typ: a(u(a(null), true, 3.14)) },
670+ { json: "occupationalist", js: "occupationalist", typ: a(u(a(null), r("OccupationalistClass"), null)) },
671+ { json: "outrival", js: "outrival", typ: a(u(r("OutrivalClass"), 3.14, null)) },
672+ { json: "paleographically", js: "paleographically", typ: a(u(3.14, m(u(i(0), null)))) },
673+ { json: "pamphletwise", js: "pamphletwise", typ: a(u(i(0), m(i(0)), "")) },
674+ { json: "pediatrics", js: "pediatrics", typ: a(u(true, 3.14, null)) },
675+ { json: "perceptive", js: "perceptive", typ: a(true) },
676+ { json: "piaculum", js: "piaculum", typ: a(u(r("PiaculumClass"), 3.14)) },
677+ { json: "piccadilly", js: "piccadilly", typ: a(u(3.14, null, "")) },
678+ { json: "piffler", js: "piffler", typ: a(u(a(null), r("MonaziteClass"))) },
679+ { json: "pithful", js: "pithful", typ: a(u(true, i(0), null)) },
680+ { json: "placuntitis", js: "placuntitis", typ: a(u(i(0), m(i(0)))) },
681+ { json: "plectopterous", js: "plectopterous", typ: a(u(3.14, m(i(0)))) },
682+ { json: "pneumocele", js: "pneumocele", typ: a(u(r("Pneumocele"), null)) },
683+ { json: "poliorcetic", js: "poliorcetic", typ: a(u(true, r("MonaziteClass"))) },
684+ { json: "poormaster", js: "poormaster", typ: a(u(a(i(0)), m(i(0)), null)) },
685+ { json: "potwhisky", js: "potwhisky", typ: a(u(r("PotwhiskyClass"), i(0), null)) },
686+ { json: "practicalizer", js: "practicalizer", typ: a(u(a(null), r("MonaziteClass"), "")) },
687+ { json: "prefreshman", js: "prefreshman", typ: a(u(a(null), r("PrefreshmanClass"), "")) },
688+ { json: "prehensility", js: "prehensility", typ: a(u(a(null), true, r("MonaziteClass"))) },
689+ { json: "prevoidance", js: "prevoidance", typ: a(u(a(i(0)), r("MonaziteClass"), i(0))) },
690+ { json: "probant", js: "probant", typ: a(m(u(i(0), null))) },
691+ { json: "protext", js: "protext", typ: a(u(a(i(0)), true, r("MonaziteClass"))) },
692+ ], false),
693+ "JurorClass": o([
694+ { json: "Olea", js: "Olea", typ: null },
695+ { json: "adipsy", js: "adipsy", typ: null },
696+ { json: "auxiliator", js: "auxiliator", typ: null },
697+ { json: "benda", js: "benda", typ: null },
698+ { json: "benjamin", js: "benjamin", typ: null },
699+ { json: "brandling", js: "brandling", typ: null },
700+ { json: "epicurishly", js: "epicurishly", typ: null },
701+ { json: "eremochaetous", js: "eremochaetous", typ: null },
702+ { json: "marten", js: "marten", typ: null },
703+ { json: "monocline", js: "monocline", typ: null },
704+ { json: "palgat", js: "palgat", typ: null },
705+ { json: "pennyworth", js: "pennyworth", typ: null },
706+ { json: "pioury", js: "pioury", typ: null },
707+ { json: "pragmatistic", js: "pragmatistic", typ: null },
708+ { json: "stylelessness", js: "stylelessness", typ: null },
709+ { json: "systematical", js: "systematical", typ: null },
710+ { json: "thready", js: "thready", typ: null },
711+ { json: "uncontemporary", js: "uncontemporary", typ: null },
712+ { json: "uncouched", js: "uncouched", typ: null },
713+ { json: "uninhabitedness", js: "uninhabitedness", typ: null },
714+ ], false),
715+ "LadronismClass": o([
716+ { json: "Prodenia", js: "Prodenia", typ: null },
717+ { json: "acclaimer", js: "acclaimer", typ: null },
718+ { json: "achree", js: "achree", typ: null },
719+ { json: "base", js: "base", typ: null },
720+ { json: "conundrumize", js: "conundrumize", typ: null },
721+ { json: "degerminator", js: "degerminator", typ: null },
722+ { json: "describable", js: "describable", typ: null },
723+ { json: "exasperatedly", js: "exasperatedly", typ: null },
724+ { json: "heroine", js: "heroine", typ: null },
725+ { json: "indazin", js: "indazin", typ: null },
726+ { json: "luteous", js: "luteous", typ: null },
727+ { json: "papular", js: "papular", typ: null },
728+ { json: "pritch", js: "pritch", typ: null },
729+ { json: "seege", js: "seege", typ: null },
730+ { json: "shopgirl", js: "shopgirl", typ: null },
731+ { json: "tragedietta", js: "tragedietta", typ: null },
732+ { json: "unsparse", js: "unsparse", typ: null },
733+ { json: "uplook", js: "uplook", typ: null },
734+ { json: "vermiformis", js: "vermiformis", typ: null },
735+ { json: "whafabout", js: "whafabout", typ: null },
736+ ], false),
737+ "LandlubberlyClass": o([
738+ { json: "Amyraldism", js: "Amyraldism", typ: null },
739+ { json: "acropoleis", js: "acropoleis", typ: null },
740+ { json: "aminate", js: "aminate", typ: null },
741+ { json: "bipenniform", js: "bipenniform", typ: null },
742+ { json: "bugre", js: "bugre", typ: null },
743+ { json: "calycule", js: "calycule", typ: null },
744+ { json: "caoutchouc", js: "caoutchouc", typ: null },
745+ { json: "disprover", js: "disprover", typ: null },
746+ { json: "fitroot", js: "fitroot", typ: null },
747+ { json: "fulgently", js: "fulgently", typ: null },
748+ { json: "kickup", js: "kickup", typ: null },
749+ { json: "laevoversion", js: "laevoversion", typ: null },
750+ { json: "moter", js: "moter", typ: null },
751+ { json: "objectivity", js: "objectivity", typ: null },
752+ { json: "posterity", js: "posterity", typ: null },
753+ { json: "postnuptial", js: "postnuptial", typ: null },
754+ { json: "precedentary", js: "precedentary", typ: null },
755+ { json: "saddling", js: "saddling", typ: null },
756+ { json: "subcurrent", js: "subcurrent", typ: null },
757+ { json: "unrecriminative", js: "unrecriminative", typ: null },
758+ ], false),
759+ "LupusClass": o([
760+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
761+ { json: "Chlorioninae", js: "Chlorioninae", typ: u(undefined, i(0)) },
762+ { json: "Corvinae", js: "Corvinae", typ: u(undefined, i(0)) },
763+ { json: "Crassina", js: "Crassina", typ: u(undefined, i(0)) },
764+ { json: "Thysanocarpus", js: "Thysanocarpus", typ: u(undefined, i(0)) },
765+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
766+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
767+ { json: "exiguity", js: "exiguity", typ: u(undefined, i(0)) },
768+ { json: "farcist", js: "farcist", typ: u(undefined, i(0)) },
769+ { json: "holographical", js: "holographical", typ: u(undefined, i(0)) },
770+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
771+ { json: "ichthyophagan", js: "ichthyophagan", typ: u(undefined, i(0)) },
772+ { json: "implacable", js: "implacable", typ: u(undefined, i(0)) },
773+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
774+ { json: "outshiner", js: "outshiner", typ: u(undefined, i(0)) },
775+ { json: "overweather", js: "overweather", typ: u(undefined, i(0)) },
776+ { json: "protonegroid", js: "protonegroid", typ: u(undefined, i(0)) },
777+ { json: "shallowish", js: "shallowish", typ: u(undefined, i(0)) },
778+ { json: "snoke", js: "snoke", typ: u(undefined, i(0)) },
779+ { json: "snout", js: "snout", typ: u(undefined, i(0)) },
780+ { json: "surveillance", js: "surveillance", typ: u(undefined, i(0)) },
781+ { json: "threshingtime", js: "threshingtime", typ: u(undefined, i(0)) },
782+ { json: "unsignificantly", js: "unsignificantly", typ: u(undefined, i(0)) },
783+ { json: "unsnap", js: "unsnap", typ: u(undefined, i(0)) },
784+ { json: "vendible", js: "vendible", typ: u(undefined, i(0)) },
785+ ], false),
786+ "Maslin": o([
787+ { json: "Alicant", js: "Alicant", typ: u(undefined, i(0)) },
788+ { json: "Bakuninist", js: "Bakuninist", typ: u(undefined, null) },
789+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
790+ { json: "Dimitry", js: "Dimitry", typ: u(undefined, i(0)) },
791+ { json: "antiatonement", js: "antiatonement", typ: u(undefined, null) },
792+ { json: "anticorrosive", js: "anticorrosive", typ: u(undefined, i(0)) },
793+ { json: "aphidozer", js: "aphidozer", typ: u(undefined, null) },
794+ { json: "be", js: "be", typ: u(undefined, i(0)) },
795+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
796+ { json: "chub", js: "chub", typ: u(undefined, i(0)) },
797+ { json: "cuprosilicon", js: "cuprosilicon", typ: u(undefined, i(0)) },
798+ { json: "curtailedly", js: "curtailedly", typ: u(undefined, i(0)) },
799+ { json: "dellenite", js: "dellenite", typ: u(undefined, i(0)) },
800+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
801+ { json: "edifying", js: "edifying", typ: u(undefined, null) },
802+ { json: "ethmoiditis", js: "ethmoiditis", typ: u(undefined, i(0)) },
803+ { json: "gastralgy", js: "gastralgy", typ: u(undefined, null) },
804+ { json: "goatherd", js: "goatherd", typ: u(undefined, i(0)) },
805+ { json: "hammerdress", js: "hammerdress", typ: u(undefined, i(0)) },
806+ { json: "hangfire", js: "hangfire", typ: u(undefined, null) },
807+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
808+ { json: "lacunosity", js: "lacunosity", typ: u(undefined, i(0)) },
809+ { json: "longiloquence", js: "longiloquence", typ: u(undefined, null) },
810+ { json: "mameliere", js: "mameliere", typ: u(undefined, i(0)) },
811+ { json: "motherless", js: "motherless", typ: u(undefined, null) },
812+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
813+ { json: "noncorrodible", js: "noncorrodible", typ: u(undefined, null) },
814+ { json: "nonsensicality", js: "nonsensicality", typ: u(undefined, null) },
815+ { json: "oafishly", js: "oafishly", typ: u(undefined, i(0)) },
816+ { json: "pfund", js: "pfund", typ: u(undefined, null) },
817+ { json: "preadvisory", js: "preadvisory", typ: u(undefined, null) },
818+ { json: "retroflexed", js: "retroflexed", typ: u(undefined, null) },
819+ { json: "saccharulmic", js: "saccharulmic", typ: u(undefined, i(0)) },
820+ { json: "scowlful", js: "scowlful", typ: u(undefined, i(0)) },
821+ { json: "secluded", js: "secluded", typ: u(undefined, null) },
822+ { json: "slackage", js: "slackage", typ: u(undefined, null) },
823+ { json: "sphaeridial", js: "sphaeridial", typ: u(undefined, i(0)) },
824+ { json: "spondulics", js: "spondulics", typ: u(undefined, null) },
825+ { json: "subsecive", js: "subsecive", typ: u(undefined, i(0)) },
826+ { json: "swellmobsman", js: "swellmobsman", typ: u(undefined, null) },
827+ { json: "trachyglossate", js: "trachyglossate", typ: u(undefined, i(0)) },
828+ { json: "trialogue", js: "trialogue", typ: u(undefined, null) },
829+ { json: "unassuaged", js: "unassuaged", typ: u(undefined, i(0)) },
830+ { json: "ungross", js: "ungross", typ: u(undefined, null) },
831+ { json: "unjudiciously", js: "unjudiciously", typ: u(undefined, null) },
832+ ], false),
833+ "MonaziteClass": o([
834+ { json: "Chirotherium", js: "Chirotherium", typ: i(0) },
835+ { json: "catharticalness", js: "catharticalness", typ: 3.14 },
836+ { json: "disdiapason", js: "disdiapason", typ: "" },
837+ { json: "homocerc", js: "homocerc", typ: true },
838+ { json: "nonbookish", js: "nonbookish", typ: null },
839+ ], false),
840+ "MonotheisticallyClass": o([
841+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
842+ { json: "blaspheme", js: "blaspheme", typ: u(undefined, null) },
843+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
844+ { json: "celiosalpingectomy", js: "celiosalpingectomy", typ: u(undefined, null) },
845+ { json: "consummativeness", js: "consummativeness", typ: u(undefined, null) },
846+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
847+ { json: "egestive", js: "egestive", typ: u(undefined, null) },
848+ { json: "enchylema", js: "enchylema", typ: u(undefined, null) },
849+ { json: "gasconade", js: "gasconade", typ: u(undefined, null) },
850+ { json: "holidayer", js: "holidayer", typ: u(undefined, null) },
851+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
852+ { json: "intuitionalism", js: "intuitionalism", typ: u(undefined, null) },
853+ { json: "lophiostomate", js: "lophiostomate", typ: u(undefined, null) },
854+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
855+ { json: "nonvolition", js: "nonvolition", typ: u(undefined, null) },
856+ { json: "palatableness", js: "palatableness", typ: u(undefined, null) },
857+ { json: "pimpery", js: "pimpery", typ: u(undefined, null) },
858+ { json: "previolation", js: "previolation", typ: u(undefined, null) },
859+ { json: "reconveyance", js: "reconveyance", typ: u(undefined, null) },
860+ { json: "registership", js: "registership", typ: u(undefined, null) },
861+ { json: "rhyacolite", js: "rhyacolite", typ: u(undefined, null) },
862+ { json: "smithereens", js: "smithereens", typ: u(undefined, null) },
863+ { json: "superedification", js: "superedification", typ: u(undefined, null) },
864+ { json: "trust", js: "trust", typ: u(undefined, null) },
865+ { json: "whitestone", js: "whitestone", typ: u(undefined, null) },
866+ ], false),
867+ "Noncontributing": o([
868+ { json: "estevin", js: "estevin", typ: "" },
869+ { json: "jolterhead", js: "jolterhead", typ: 3.14 },
870+ { json: "sauternes", js: "sauternes", typ: i(0) },
871+ { json: "sparsely", js: "sparsely", typ: true },
872+ { json: "unrequested", js: "unrequested", typ: null },
873+ ], false),
874+ "OccupationalistClass": o([
875+ { json: "Chimakum", js: "Chimakum", typ: null },
876+ { json: "Fin", js: "Fin", typ: null },
877+ { json: "beholdable", js: "beholdable", typ: null },
878+ { json: "brotuliform", js: "brotuliform", typ: null },
879+ { json: "doodler", js: "doodler", typ: null },
880+ { json: "emulsin", js: "emulsin", typ: null },
881+ { json: "flourishing", js: "flourishing", typ: null },
882+ { json: "flueless", js: "flueless", typ: null },
883+ { json: "furtively", js: "furtively", typ: null },
884+ { json: "gritter", js: "gritter", typ: null },
885+ { json: "interwish", js: "interwish", typ: null },
886+ { json: "monoxylic", js: "monoxylic", typ: null },
887+ { json: "myristic", js: "myristic", typ: null },
888+ { json: "nightwear", js: "nightwear", typ: null },
889+ { json: "peruser", js: "peruser", typ: null },
890+ { json: "theoastrological", js: "theoastrological", typ: null },
891+ { json: "thumby", js: "thumby", typ: null },
892+ { json: "tingitid", js: "tingitid", typ: null },
893+ { json: "trailless", js: "trailless", typ: null },
894+ { json: "unpocketed", js: "unpocketed", typ: null },
895+ ], false),
896+ "OutrivalClass": o([
897+ { json: "Castoroides", js: "Castoroides", typ: null },
898+ { json: "Czechoslovak", js: "Czechoslovak", typ: null },
899+ { json: "Lingulidae", js: "Lingulidae", typ: null },
900+ { json: "adroitly", js: "adroitly", typ: null },
901+ { json: "bridehood", js: "bridehood", typ: null },
902+ { json: "diagenesis", js: "diagenesis", typ: null },
903+ { json: "dihexahedron", js: "dihexahedron", typ: null },
904+ { json: "dopester", js: "dopester", typ: null },
905+ { json: "eumerism", js: "eumerism", typ: null },
906+ { json: "flyness", js: "flyness", typ: null },
907+ { json: "fouler", js: "fouler", typ: null },
908+ { json: "laudanosine", js: "laudanosine", typ: null },
909+ { json: "minutary", js: "minutary", typ: null },
910+ { json: "mitra", js: "mitra", typ: null },
911+ { json: "opisthorchiasis", js: "opisthorchiasis", typ: null },
912+ { json: "pensively", js: "pensively", typ: null },
913+ { json: "pubigerous", js: "pubigerous", typ: null },
914+ { json: "rebellious", js: "rebellious", typ: null },
915+ { json: "recodify", js: "recodify", typ: null },
916+ { json: "unpaced", js: "unpaced", typ: null },
917+ ], false),
918+ "PiaculumClass": o([
919+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
920+ { json: "Zipper", js: "Zipper", typ: u(undefined, i(0)) },
921+ { json: "alada", js: "alada", typ: u(undefined, i(0)) },
922+ { json: "amphistomous", js: "amphistomous", typ: u(undefined, i(0)) },
923+ { json: "boysenberry", js: "boysenberry", typ: u(undefined, i(0)) },
924+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
925+ { json: "decardinalize", js: "decardinalize", typ: u(undefined, i(0)) },
926+ { json: "discouragement", js: "discouragement", typ: u(undefined, i(0)) },
927+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
928+ { json: "doitrified", js: "doitrified", typ: u(undefined, i(0)) },
929+ { json: "hexaspermous", js: "hexaspermous", typ: u(undefined, i(0)) },
930+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
931+ { json: "insinking", js: "insinking", typ: u(undefined, i(0)) },
932+ { json: "loathfulness", js: "loathfulness", typ: u(undefined, i(0)) },
933+ { json: "miasmatical", js: "miasmatical", typ: u(undefined, i(0)) },
934+ { json: "neurofibril", js: "neurofibril", typ: u(undefined, i(0)) },
935+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
936+ { json: "phonendoscope", js: "phonendoscope", typ: u(undefined, i(0)) },
937+ { json: "pilferment", js: "pilferment", typ: u(undefined, i(0)) },
938+ { json: "predismissory", js: "predismissory", typ: u(undefined, i(0)) },
939+ { json: "preinscription", js: "preinscription", typ: u(undefined, i(0)) },
940+ { json: "quotative", js: "quotative", typ: u(undefined, i(0)) },
941+ { json: "sienna", js: "sienna", typ: u(undefined, i(0)) },
942+ { json: "thorax", js: "thorax", typ: u(undefined, i(0)) },
943+ { json: "yachting", js: "yachting", typ: u(undefined, i(0)) },
944+ ], false),
945+ "Pneumocele": o([
946+ { json: "Carbonarism", js: "Carbonarism", typ: u(undefined, null) },
947+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
948+ { json: "Koniga", js: "Koniga", typ: u(undefined, null) },
949+ { json: "Micky", js: "Micky", typ: u(undefined, null) },
950+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
951+ { json: "cineolic", js: "cineolic", typ: u(undefined, null) },
952+ { json: "cobbly", js: "cobbly", typ: u(undefined, null) },
953+ { json: "conchyliferous", js: "conchyliferous", typ: u(undefined, null) },
954+ { json: "congregation", js: "congregation", typ: u(undefined, null) },
955+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
956+ { json: "enterotomy", js: "enterotomy", typ: u(undefined, null) },
957+ { json: "entophytal", js: "entophytal", typ: u(undefined, null) },
958+ { json: "fewtrils", js: "fewtrils", typ: u(undefined, null) },
959+ { json: "herem", js: "herem", typ: u(undefined, null) },
960+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
961+ { json: "meticulosity", js: "meticulosity", typ: u(undefined, null) },
962+ { json: "mismarriage", js: "mismarriage", typ: u(undefined, null) },
963+ { json: "neurotrophic", js: "neurotrophic", typ: u(undefined, null) },
964+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
965+ { json: "persuasively", js: "persuasively", typ: u(undefined, null) },
966+ { json: "replaceable", js: "replaceable", typ: u(undefined, null) },
967+ { json: "silex", js: "silex", typ: u(undefined, null) },
968+ { json: "taillight", js: "taillight", typ: u(undefined, null) },
969+ { json: "unjealous", js: "unjealous", typ: u(undefined, null) },
970+ { json: "visitorial", js: "visitorial", typ: u(undefined, null) },
971+ ], false),
972+ "PotwhiskyClass": o([
973+ { json: "Euchorda", js: "Euchorda", typ: null },
974+ { json: "Yoruba", js: "Yoruba", typ: null },
975+ { json: "arciform", js: "arciform", typ: null },
976+ { json: "cresolin", js: "cresolin", typ: null },
977+ { json: "disheartener", js: "disheartener", typ: null },
978+ { json: "disproportionable", js: "disproportionable", typ: null },
979+ { json: "ferryway", js: "ferryway", typ: null },
980+ { json: "filamentiferous", js: "filamentiferous", typ: null },
981+ { json: "flemish", js: "flemish", typ: null },
982+ { json: "forgainst", js: "forgainst", typ: null },
983+ { json: "grainering", js: "grainering", typ: null },
984+ { json: "irrevoluble", js: "irrevoluble", typ: null },
985+ { json: "kindredship", js: "kindredship", typ: null },
986+ { json: "pinguitudinous", js: "pinguitudinous", typ: null },
987+ { json: "simpletonic", js: "simpletonic", typ: null },
988+ { json: "singsong", js: "singsong", typ: null },
989+ { json: "submergement", js: "submergement", typ: null },
990+ { json: "supraoesophagal", js: "supraoesophagal", typ: null },
991+ { json: "thrashel", js: "thrashel", typ: null },
992+ { json: "tyremesis", js: "tyremesis", typ: null },
993+ ], false),
994+ "PrefreshmanClass": o([
995+ { json: "Dolphus", js: "Dolphus", typ: null },
996+ { json: "Ficus", js: "Ficus", typ: null },
997+ { json: "Gemaric", js: "Gemaric", typ: null },
998+ { json: "Phaet", js: "Phaet", typ: null },
999+ { json: "azorubine", js: "azorubine", typ: null },
1000+ { json: "choroiditis", js: "choroiditis", typ: null },
1001+ { json: "coagulatory", js: "coagulatory", typ: null },
1002+ { json: "cyclorama", js: "cyclorama", typ: null },
1003+ { json: "duckhearted", js: "duckhearted", typ: null },
1004+ { json: "jugation", js: "jugation", typ: null },
1005+ { json: "myoliposis", js: "myoliposis", typ: null },
1006+ { json: "nonnomination", js: "nonnomination", typ: null },
1007+ { json: "palay", js: "palay", typ: null },
1008+ { json: "pentactinal", js: "pentactinal", typ: null },
1009+ { json: "piquant", js: "piquant", typ: null },
1010+ { json: "registration", js: "registration", typ: null },
1011+ { json: "remancipation", js: "remancipation", typ: null },
1012+ { json: "scutatiform", js: "scutatiform", typ: null },
1013+ { json: "theodolite", js: "theodolite", typ: null },
1014+ { json: "underward", js: "underward", typ: null },
1015+ ], false),
1016+};
Atypescriptprefer-types-true--df33e18681f9 / TopLevel.ts+1,016 −0
@@ -0,0 +1,1016 @@
1+// To parse this data:
2+//
3+// import { Convert, TopLevel } from "./TopLevel";
4+//
5+// const topLevel = Convert.toTopLevel(json);
6+//
7+// These functions will throw an error if the JSON doesn't
8+// match the expected interface, even if the JSON is valid.
9+
10+export type TopLevel = {
11+ juror: JurorElement[];
12+ kongoni: Kongoni[];
13+ ladronism: LadronismElement[];
14+ landlubberly: LandlubberlyElement[];
15+ listener: Listener[];
16+ lupus: LupusElement[];
17+ maslin: Maslin[];
18+ monazite: MonaziteElement[];
19+ monoliteral: Monoliteral[];
20+ monotheistically: MonotheisticallyElement[];
21+ montage: Montage[];
22+ moralness: Moralness[];
23+ mowra: (MonaziteClass | null)[];
24+ mulishly: Mulishly[];
25+ myoscope: Myoscope[];
26+ nach: ((number | null)[] | null)[];
27+ neuromastic: Neuromastic[];
28+ noncontributing: Noncontributing[];
29+ nonnervous: Nonnervous[];
30+ nonvaluation: Nonvaluation[];
31+ occupationalist: OccupationalistElement[];
32+ outrival: OutrivalElement[];
33+ paleographically: Paleographically[];
34+ pamphletwise: Pamphletwise[];
35+ pediatrics: Pediatric[];
36+ perceptive: boolean[];
37+ piaculum: PiaculumElement[];
38+ piccadilly: Piccadilly[];
39+ piffler: Piffler[];
40+ pithful: Pithful[];
41+ placuntitis: Placuntiti[];
42+ plectopterous: Plectopterous[];
43+ pneumocele: (Pneumocele | null)[];
44+ poliorcetic: Poliorcetic[];
45+ poormaster: Poormaster[];
46+ potwhisky: PotwhiskyElement[];
47+ practicalizer: Practicalizer[];
48+ prefreshman: PrefreshmanElement[];
49+ prehensility: Prehensility[];
50+ prevoidance: Prevoidance[];
51+ probant: { [key: string]: number | null }[];
52+ protext: Protext[];
53+}
54+
55+export type JurorElement = boolean | JurorClass;
56+
57+export type JurorClass = {
58+ Olea: null;
59+ adipsy: null;
60+ auxiliator: null;
61+ benda: null;
62+ benjamin: null;
63+ brandling: null;
64+ epicurishly: null;
65+ eremochaetous: null;
66+ marten: null;
67+ monocline: null;
68+ palgat: null;
69+ pennyworth: null;
70+ pioury: null;
71+ pragmatistic: null;
72+ stylelessness: null;
73+ systematical: null;
74+ thready: null;
75+ uncontemporary: null;
76+ uncouched: null;
77+ uninhabitedness: null;
78+}
79+
80+export type Kongoni = number[] | { [key: string]: number };
81+
82+export type LadronismElement = LadronismClass | number | string;
83+
84+export type LadronismClass = {
85+ Prodenia: null;
86+ acclaimer: null;
87+ achree: null;
88+ base: null;
89+ conundrumize: null;
90+ degerminator: null;
91+ describable: null;
92+ exasperatedly: null;
93+ heroine: null;
94+ indazin: null;
95+ luteous: null;
96+ papular: null;
97+ pritch: null;
98+ seege: null;
99+ shopgirl: null;
100+ tragedietta: null;
101+ unsparse: null;
102+ uplook: null;
103+ vermiformis: null;
104+ whafabout: null;
105+}
106+
107+export type LandlubberlyElement = boolean | LandlubberlyClass | number;
108+
109+export type LandlubberlyClass = {
110+ Amyraldism: null;
111+ acropoleis: null;
112+ aminate: null;
113+ bipenniform: null;
114+ bugre: null;
115+ calycule: null;
116+ caoutchouc: null;
117+ disprover: null;
118+ fitroot: null;
119+ fulgently: null;
120+ kickup: null;
121+ laevoversion: null;
122+ moter: null;
123+ objectivity: null;
124+ posterity: null;
125+ postnuptial: null;
126+ precedentary: null;
127+ saddling: null;
128+ subcurrent: null;
129+ unrecriminative: null;
130+}
131+
132+export type Listener = null[] | number;
133+
134+export type LupusElement = LupusClass | number;
135+
136+export type LupusClass = {
137+ Chirotherium?: number;
138+ Chlorioninae?: number;
139+ Corvinae?: number;
140+ Crassina?: number;
141+ Thysanocarpus?: number;
142+ catharticalness?: number;
143+ disdiapason?: string;
144+ exiguity?: number;
145+ farcist?: number;
146+ holographical?: number;
147+ homocerc?: boolean;
148+ ichthyophagan?: number;
149+ implacable?: number;
150+ nonbookish?: null;
151+ outshiner?: number;
152+ overweather?: number;
153+ protonegroid?: number;
154+ shallowish?: number;
155+ snoke?: number;
156+ snout?: number;
157+ surveillance?: number;
158+ threshingtime?: number;
159+ unsignificantly?: number;
160+ unsnap?: number;
161+ vendible?: number;
162+}
163+
164+export type Maslin = {
165+ Alicant?: number;
166+ Bakuninist?: null;
167+ Chirotherium?: number;
168+ Dimitry?: number;
169+ antiatonement?: null;
170+ anticorrosive?: number;
171+ aphidozer?: null;
172+ be?: number;
173+ catharticalness?: number;
174+ chub?: number;
175+ cuprosilicon?: number;
176+ curtailedly?: number;
177+ dellenite?: number;
178+ disdiapason?: string;
179+ edifying?: null;
180+ ethmoiditis?: number;
181+ gastralgy?: null;
182+ goatherd?: number;
183+ hammerdress?: number;
184+ hangfire?: null;
185+ homocerc?: boolean;
186+ lacunosity?: number;
187+ longiloquence?: null;
188+ mameliere?: number;
189+ motherless?: null;
190+ nonbookish?: null;
191+ noncorrodible?: null;
192+ nonsensicality?: null;
193+ oafishly?: number;
194+ pfund?: null;
195+ preadvisory?: null;
196+ retroflexed?: null;
197+ saccharulmic?: number;
198+ scowlful?: number;
199+ secluded?: null;
200+ slackage?: null;
201+ sphaeridial?: number;
202+ spondulics?: null;
203+ subsecive?: number;
204+ swellmobsman?: null;
205+ trachyglossate?: number;
206+ trialogue?: null;
207+ unassuaged?: number;
208+ ungross?: null;
209+ unjudiciously?: null;
210+}
211+
212+export type MonaziteElement = MonaziteClass | number;
213+
214+export type MonaziteClass = {
215+ Chirotherium: number;
216+ catharticalness: number;
217+ disdiapason: string;
218+ homocerc: boolean;
219+ nonbookish: null;
220+}
221+
222+export type Monoliteral = null[] | boolean;
223+
224+export type MonotheisticallyElement = null[] | MonotheisticallyClass;
225+
226+export type MonotheisticallyClass = {
227+ Chirotherium?: number;
228+ blaspheme?: null;
229+ catharticalness?: number;
230+ celiosalpingectomy?: null;
231+ consummativeness?: null;
232+ disdiapason?: string;
233+ egestive?: null;
234+ enchylema?: null;
235+ gasconade?: null;
236+ holidayer?: null;
237+ homocerc?: boolean;
238+ intuitionalism?: null;
239+ lophiostomate?: null;
240+ nonbookish?: null;
241+ nonvolition?: null;
242+ palatableness?: null;
243+ pimpery?: null;
244+ previolation?: null;
245+ reconveyance?: null;
246+ registership?: null;
247+ rhyacolite?: null;
248+ smithereens?: null;
249+ superedification?: null;
250+ trust?: null;
251+ whitestone?: null;
252+}
253+
254+export type Montage = null[] | number | string;
255+
256+export type Moralness = null[] | number | null;
257+
258+export type Mulishly = number[] | number | null;
259+
260+export type Myoscope = null[] | boolean | number;
261+
262+export type Neuromastic = null[] | number;
263+
264+export type Noncontributing = {
265+ estevin: string;
266+ jolterhead: number;
267+ sauternes: number;
268+ sparsely: boolean;
269+ unrequested: null;
270+}
271+
272+export type Nonnervous = boolean | number;
273+
274+export type Nonvaluation = null[] | boolean | number;
275+
276+export type OccupationalistElement = null[] | OccupationalistClass | null;
277+
278+export type OccupationalistClass = {
279+ Chimakum: null;
280+ Fin: null;
281+ beholdable: null;
282+ brotuliform: null;
283+ doodler: null;
284+ emulsin: null;
285+ flourishing: null;
286+ flueless: null;
287+ furtively: null;
288+ gritter: null;
289+ interwish: null;
290+ monoxylic: null;
291+ myristic: null;
292+ nightwear: null;
293+ peruser: null;
294+ theoastrological: null;
295+ thumby: null;
296+ tingitid: null;
297+ trailless: null;
298+ unpocketed: null;
299+}
300+
301+export type OutrivalElement = OutrivalClass | number | null;
302+
303+export type OutrivalClass = {
304+ Castoroides: null;
305+ Czechoslovak: null;
306+ Lingulidae: null;
307+ adroitly: null;
308+ bridehood: null;
309+ diagenesis: null;
310+ dihexahedron: null;
311+ dopester: null;
312+ eumerism: null;
313+ flyness: null;
314+ fouler: null;
315+ laudanosine: null;
316+ minutary: null;
317+ mitra: null;
318+ opisthorchiasis: null;
319+ pensively: null;
320+ pubigerous: null;
321+ rebellious: null;
322+ recodify: null;
323+ unpaced: null;
324+}
325+
326+export type Paleographically = number | { [key: string]: number | null };
327+
328+export type Pamphletwise = number | { [key: string]: number } | string;
329+
330+export type Pediatric = boolean | number | null;
331+
332+export type PiaculumElement = PiaculumClass | number;
333+
334+export type PiaculumClass = {
335+ Chirotherium?: number;
336+ Zipper?: number;
337+ alada?: number;
338+ amphistomous?: number;
339+ boysenberry?: number;
340+ catharticalness?: number;
341+ decardinalize?: number;
342+ discouragement?: number;
343+ disdiapason?: string;
344+ doitrified?: number;
345+ hexaspermous?: number;
346+ homocerc?: boolean;
347+ insinking?: number;
348+ loathfulness?: number;
349+ miasmatical?: number;
350+ neurofibril?: number;
351+ nonbookish?: null;
352+ phonendoscope?: number;
353+ pilferment?: number;
354+ predismissory?: number;
355+ preinscription?: number;
356+ quotative?: number;
357+ sienna?: number;
358+ thorax?: number;
359+ yachting?: number;
360+}
361+
362+export type Piccadilly = number | null | string;
363+
364+export type Piffler = null[] | MonaziteClass;
365+
366+export type Pithful = boolean | number | null;
367+
368+export type Placuntiti = number | { [key: string]: number };
369+
370+export type Plectopterous = number | { [key: string]: number };
371+
372+export type Pneumocele = {
373+ Carbonarism?: null;
374+ Chirotherium?: number;
375+ Koniga?: null;
376+ Micky?: null;
377+ catharticalness?: number;
378+ cineolic?: null;
379+ cobbly?: null;
380+ conchyliferous?: null;
381+ congregation?: null;
382+ disdiapason?: string;
383+ enterotomy?: null;
384+ entophytal?: null;
385+ fewtrils?: null;
386+ herem?: null;
387+ homocerc?: boolean;
388+ meticulosity?: null;
389+ mismarriage?: null;
390+ neurotrophic?: null;
391+ nonbookish?: null;
392+ persuasively?: null;
393+ replaceable?: null;
394+ silex?: null;
395+ taillight?: null;
396+ unjealous?: null;
397+ visitorial?: null;
398+}
399+
400+export type Poliorcetic = boolean | MonaziteClass;
401+
402+export type Poormaster = number[] | { [key: string]: number } | null;
403+
404+export type PotwhiskyElement = PotwhiskyClass | number | null;
405+
406+export type PotwhiskyClass = {
407+ Euchorda: null;
408+ Yoruba: null;
409+ arciform: null;
410+ cresolin: null;
411+ disheartener: null;
412+ disproportionable: null;
413+ ferryway: null;
414+ filamentiferous: null;
415+ flemish: null;
416+ forgainst: null;
417+ grainering: null;
418+ irrevoluble: null;
419+ kindredship: null;
420+ pinguitudinous: null;
421+ simpletonic: null;
422+ singsong: null;
423+ submergement: null;
424+ supraoesophagal: null;
425+ thrashel: null;
426+ tyremesis: null;
427+}
428+
429+export type Practicalizer = null[] | MonaziteClass | string;
430+
431+export type PrefreshmanElement = null[] | PrefreshmanClass | string;
432+
433+export type PrefreshmanClass = {
434+ Dolphus: null;
435+ Ficus: null;
436+ Gemaric: null;
437+ Phaet: null;
438+ azorubine: null;
439+ choroiditis: null;
440+ coagulatory: null;
441+ cyclorama: null;
442+ duckhearted: null;
443+ jugation: null;
444+ myoliposis: null;
445+ nonnomination: null;
446+ palay: null;
447+ pentactinal: null;
448+ piquant: null;
449+ registration: null;
450+ remancipation: null;
451+ scutatiform: null;
452+ theodolite: null;
453+ underward: null;
454+}
455+
456+export type Prehensility = null[] | boolean | MonaziteClass;
457+
458+export type Prevoidance = number[] | MonaziteClass | number;
459+
460+export type Protext = number[] | boolean | MonaziteClass;
461+
462+// Converts JSON strings to/from your types
463+// and asserts the results of JSON.parse at runtime
464+export class Convert {
465+ public static toTopLevel(json: string): TopLevel {
466+ return cast(JSON.parse(json), r("TopLevel"));
467+ }
468+
469+ public static topLevelToJson(value: TopLevel): string {
470+ return JSON.stringify(uncast(value, r("TopLevel")), null, 2);
471+ }
472+}
473+
474+function invalidValue(typ: any, val: any, key: any, parent: any = ''): never {
475+ const prettyTyp = prettyTypeName(typ);
476+ const parentText = parent ? ` on ${parent}` : '';
477+ const keyText = key ? ` for key "${key}"` : '';
478+ throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`);
479+}
480+
481+function prettyTypeName(typ: any): string {
482+ if (Array.isArray(typ)) {
483+ if (typ.length === 2 && typ[0] === undefined) {
484+ return `an optional ${prettyTypeName(typ[1])}`;
485+ } else {
486+ return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`;
487+ }
488+ } else if (typeof typ === "object" && typ.literal !== undefined) {
489+ return typ.literal;
490+ } else {
491+ return typeof typ;
492+ }
493+}
494+
495+function jsonToJSProps(typ: any): any {
496+ if (typ.jsonToJS === undefined) {
497+ const map: any = {};
498+ typ.props.forEach((p: any) => map[p.json] = { key: p.js, typ: p.typ });
499+ typ.jsonToJS = map;
500+ }
501+ return typ.jsonToJS;
502+}
503+
504+function jsToJSONProps(typ: any): any {
505+ if (typ.jsToJSON === undefined) {
506+ const map: any = {};
507+ typ.props.forEach((p: any) => map[p.js] = { key: p.json, typ: p.typ });
508+ typ.jsToJSON = map;
509+ }
510+ return typ.jsToJSON;
511+}
512+
513+function transform(val: any, typ: any, getProps: any, key: any = '', parent: any = ''): any {
514+ function transformPrimitive(typ: string, val: any): any {
515+ if (typeof typ === typeof val) return val;
516+ return invalidValue(typ, val, key, parent);
517+ }
518+
519+ function transformUnion(typs: any[], val: any): any {
520+ // val must validate against one typ in typs
521+ const l = typs.length;
522+ for (let i = 0; i < l; i++) {
523+ const typ = typs[i];
524+ try {
525+ return transform(val, typ, getProps);
526+ } catch (_) {}
527+ }
528+ return invalidValue(typs, val, key, parent);
529+ }
530+
531+ function transformEnum(cases: string[], val: any): any {
532+ if (cases.indexOf(val) !== -1) return val;
533+ return invalidValue(cases.map(a => { return l(a); }), val, key, parent);
534+ }
535+
536+ function transformArray(typ: any, val: any): any {
537+ // val must be an array with no invalid elements
538+ if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent);
539+
540+ return val.map(el => transform(el, typ, getProps));
541+ }
542+
543+ function transformDate(val: any): any {
544+ if (val === null) {
545+ return null;
546+ }
547+ const d = new Date(val);
548+ if (isNaN(d.valueOf())) {
549+ return invalidValue(l("Date"), val, key, parent);
550+ }
551+ return d;
552+ }
553+
554+ function transformObject(props: { [k: string]: any }, additional: any, val: any): any {
555+ if (val === null || typeof val !== "object" || Array.isArray(val)) {
556+ return invalidValue(l(ref || "object"), val, key, parent);
557+ }
558+ const result: any = {};
559+ Object.getOwnPropertyNames(props).forEach(key => {
560+ const prop = props[key];
561+ const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined;
562+ result[prop.key] = transform(v, prop.typ, getProps, key, ref);
563+ });
564+ Object.getOwnPropertyNames(val).forEach(key => {
565+ if (!Object.prototype.hasOwnProperty.call(props, key)) {
566+ result[key] = transform(val[key], additional, getProps, key, ref);
567+ }
568+ });
569+ return result;
570+ }
571+
572+ if (typ === "any") return val;
573+ if (typ === null) {
574+ if (val === null) return val;
575+ return invalidValue(typ, val, key, parent);
576+ }
577+ if (typ === false) return invalidValue(typ, val, key, parent);
578+ let ref: any = undefined;
579+ while (typeof typ === "object" && typ.ref !== undefined) {
580+ ref = typ.ref;
581+ typ = typeMap[typ.ref];
582+ }
583+ if (Array.isArray(typ)) return transformEnum(typ, val);
584+ if (typeof typ === "object") {
585+ return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent)
586+ : 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)
587+ : 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)
588+ : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent)
589+ : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val)
590+ : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val)
591+ : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val)
592+ : invalidValue(typ, val, key, parent);
593+ }
594+ // Numbers can be parsed by Date but shouldn't be.
595+ if (typ === Date && typeof val !== "number") return transformDate(val);
596+ return transformPrimitive(typ, val);
597+}
598+
599+function cast<T>(val: any, typ: any): T {
600+ return transform(val, typ, jsonToJSProps);
601+}
602+
603+function uncast<T>(val: T, typ: any): any {
604+ return transform(val, typ, jsToJSONProps);
605+}
606+
607+function l(typ: any) {
608+ return { literal: typ };
609+}
610+
611+function a(typ: any) {
612+ return { arrayItems: typ };
613+}
614+
615+function i(typ: any) {
616+ return { integer: typ };
617+}
618+
619+function p(pattern: any) {
620+ return { pattern };
621+}
622+
623+function s(typ: any, min: any, max: any) {
624+ return { string: typ, min, max };
625+}
626+
627+function n(typ: any, min: any, max: any) {
628+ return { number: typ, min, max };
629+}
630+
631+function u(...typs: any[]) {
632+ return { unionMembers: typs };
633+}
634+
635+function o(props: any[], additional: any) {
636+ return { props, additional };
637+}
638+
639+function m(additional: any) {
640+ const props: any[] = [];
641+ return { props, additional };
642+}
643+
644+function r(name: string) {
645+ return { ref: name };
646+}
647+
648+const typeMap: any = {
649+ "TopLevel": o([
650+ { json: "juror", js: "juror", typ: a(u(true, r("JurorClass"))) },
651+ { json: "kongoni", js: "kongoni", typ: a(u(a(i(0)), m(i(0)))) },
652+ { json: "ladronism", js: "ladronism", typ: a(u(r("LadronismClass"), 3.14, "")) },
653+ { json: "landlubberly", js: "landlubberly", typ: a(u(true, r("LandlubberlyClass"), i(0))) },
654+ { json: "listener", js: "listener", typ: a(u(a(null), i(0))) },
655+ { json: "lupus", js: "lupus", typ: a(u(r("LupusClass"), i(0))) },
656+ { json: "maslin", js: "maslin", typ: a(r("Maslin")) },
657+ { json: "monazite", js: "monazite", typ: a(u(r("MonaziteClass"), 3.14)) },
658+ { json: "monoliteral", js: "monoliteral", typ: a(u(a(null), true)) },
659+ { json: "monotheistically", js: "monotheistically", typ: a(u(a(null), r("MonotheisticallyClass"))) },
660+ { json: "montage", js: "montage", typ: a(u(a(null), 3.14, "")) },
661+ { json: "moralness", js: "moralness", typ: a(u(a(null), 3.14, null)) },
662+ { json: "mowra", js: "mowra", typ: a(u(r("MonaziteClass"), null)) },
663+ { json: "mulishly", js: "mulishly", typ: a(u(a(i(0)), 3.14, null)) },
664+ { json: "myoscope", js: "myoscope", typ: a(u(a(null), true, i(0))) },
665+ { json: "nach", js: "nach", typ: a(u(a(u(i(0), null)), null)) },
666+ { json: "neuromastic", js: "neuromastic", typ: a(u(a(null), 3.14)) },
667+ { json: "noncontributing", js: "noncontributing", typ: a(r("Noncontributing")) },
668+ { json: "nonnervous", js: "nonnervous", typ: a(u(true, i(0))) },
669+ { json: "nonvaluation", js: "nonvaluation", typ: a(u(a(null), true, 3.14)) },
670+ { json: "occupationalist", js: "occupationalist", typ: a(u(a(null), r("OccupationalistClass"), null)) },
671+ { json: "outrival", js: "outrival", typ: a(u(r("OutrivalClass"), 3.14, null)) },
672+ { json: "paleographically", js: "paleographically", typ: a(u(3.14, m(u(i(0), null)))) },
673+ { json: "pamphletwise", js: "pamphletwise", typ: a(u(i(0), m(i(0)), "")) },
674+ { json: "pediatrics", js: "pediatrics", typ: a(u(true, 3.14, null)) },
675+ { json: "perceptive", js: "perceptive", typ: a(true) },
676+ { json: "piaculum", js: "piaculum", typ: a(u(r("PiaculumClass"), 3.14)) },
677+ { json: "piccadilly", js: "piccadilly", typ: a(u(3.14, null, "")) },
678+ { json: "piffler", js: "piffler", typ: a(u(a(null), r("MonaziteClass"))) },
679+ { json: "pithful", js: "pithful", typ: a(u(true, i(0), null)) },
680+ { json: "placuntitis", js: "placuntitis", typ: a(u(i(0), m(i(0)))) },
681+ { json: "plectopterous", js: "plectopterous", typ: a(u(3.14, m(i(0)))) },
682+ { json: "pneumocele", js: "pneumocele", typ: a(u(r("Pneumocele"), null)) },
683+ { json: "poliorcetic", js: "poliorcetic", typ: a(u(true, r("MonaziteClass"))) },
684+ { json: "poormaster", js: "poormaster", typ: a(u(a(i(0)), m(i(0)), null)) },
685+ { json: "potwhisky", js: "potwhisky", typ: a(u(r("PotwhiskyClass"), i(0), null)) },
686+ { json: "practicalizer", js: "practicalizer", typ: a(u(a(null), r("MonaziteClass"), "")) },
687+ { json: "prefreshman", js: "prefreshman", typ: a(u(a(null), r("PrefreshmanClass"), "")) },
688+ { json: "prehensility", js: "prehensility", typ: a(u(a(null), true, r("MonaziteClass"))) },
689+ { json: "prevoidance", js: "prevoidance", typ: a(u(a(i(0)), r("MonaziteClass"), i(0))) },
690+ { json: "probant", js: "probant", typ: a(m(u(i(0), null))) },
691+ { json: "protext", js: "protext", typ: a(u(a(i(0)), true, r("MonaziteClass"))) },
692+ ], false),
693+ "JurorClass": o([
694+ { json: "Olea", js: "Olea", typ: null },
695+ { json: "adipsy", js: "adipsy", typ: null },
696+ { json: "auxiliator", js: "auxiliator", typ: null },
697+ { json: "benda", js: "benda", typ: null },
698+ { json: "benjamin", js: "benjamin", typ: null },
699+ { json: "brandling", js: "brandling", typ: null },
700+ { json: "epicurishly", js: "epicurishly", typ: null },
701+ { json: "eremochaetous", js: "eremochaetous", typ: null },
702+ { json: "marten", js: "marten", typ: null },
703+ { json: "monocline", js: "monocline", typ: null },
704+ { json: "palgat", js: "palgat", typ: null },
705+ { json: "pennyworth", js: "pennyworth", typ: null },
706+ { json: "pioury", js: "pioury", typ: null },
707+ { json: "pragmatistic", js: "pragmatistic", typ: null },
708+ { json: "stylelessness", js: "stylelessness", typ: null },
709+ { json: "systematical", js: "systematical", typ: null },
710+ { json: "thready", js: "thready", typ: null },
711+ { json: "uncontemporary", js: "uncontemporary", typ: null },
712+ { json: "uncouched", js: "uncouched", typ: null },
713+ { json: "uninhabitedness", js: "uninhabitedness", typ: null },
714+ ], false),
715+ "LadronismClass": o([
716+ { json: "Prodenia", js: "Prodenia", typ: null },
717+ { json: "acclaimer", js: "acclaimer", typ: null },
718+ { json: "achree", js: "achree", typ: null },
719+ { json: "base", js: "base", typ: null },
720+ { json: "conundrumize", js: "conundrumize", typ: null },
721+ { json: "degerminator", js: "degerminator", typ: null },
722+ { json: "describable", js: "describable", typ: null },
723+ { json: "exasperatedly", js: "exasperatedly", typ: null },
724+ { json: "heroine", js: "heroine", typ: null },
725+ { json: "indazin", js: "indazin", typ: null },
726+ { json: "luteous", js: "luteous", typ: null },
727+ { json: "papular", js: "papular", typ: null },
728+ { json: "pritch", js: "pritch", typ: null },
729+ { json: "seege", js: "seege", typ: null },
730+ { json: "shopgirl", js: "shopgirl", typ: null },
731+ { json: "tragedietta", js: "tragedietta", typ: null },
732+ { json: "unsparse", js: "unsparse", typ: null },
733+ { json: "uplook", js: "uplook", typ: null },
734+ { json: "vermiformis", js: "vermiformis", typ: null },
735+ { json: "whafabout", js: "whafabout", typ: null },
736+ ], false),
737+ "LandlubberlyClass": o([
738+ { json: "Amyraldism", js: "Amyraldism", typ: null },
739+ { json: "acropoleis", js: "acropoleis", typ: null },
740+ { json: "aminate", js: "aminate", typ: null },
741+ { json: "bipenniform", js: "bipenniform", typ: null },
742+ { json: "bugre", js: "bugre", typ: null },
743+ { json: "calycule", js: "calycule", typ: null },
744+ { json: "caoutchouc", js: "caoutchouc", typ: null },
745+ { json: "disprover", js: "disprover", typ: null },
746+ { json: "fitroot", js: "fitroot", typ: null },
747+ { json: "fulgently", js: "fulgently", typ: null },
748+ { json: "kickup", js: "kickup", typ: null },
749+ { json: "laevoversion", js: "laevoversion", typ: null },
750+ { json: "moter", js: "moter", typ: null },
751+ { json: "objectivity", js: "objectivity", typ: null },
752+ { json: "posterity", js: "posterity", typ: null },
753+ { json: "postnuptial", js: "postnuptial", typ: null },
754+ { json: "precedentary", js: "precedentary", typ: null },
755+ { json: "saddling", js: "saddling", typ: null },
756+ { json: "subcurrent", js: "subcurrent", typ: null },
757+ { json: "unrecriminative", js: "unrecriminative", typ: null },
758+ ], false),
759+ "LupusClass": o([
760+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
761+ { json: "Chlorioninae", js: "Chlorioninae", typ: u(undefined, i(0)) },
762+ { json: "Corvinae", js: "Corvinae", typ: u(undefined, i(0)) },
763+ { json: "Crassina", js: "Crassina", typ: u(undefined, i(0)) },
764+ { json: "Thysanocarpus", js: "Thysanocarpus", typ: u(undefined, i(0)) },
765+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
766+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
767+ { json: "exiguity", js: "exiguity", typ: u(undefined, i(0)) },
768+ { json: "farcist", js: "farcist", typ: u(undefined, i(0)) },
769+ { json: "holographical", js: "holographical", typ: u(undefined, i(0)) },
770+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
771+ { json: "ichthyophagan", js: "ichthyophagan", typ: u(undefined, i(0)) },
772+ { json: "implacable", js: "implacable", typ: u(undefined, i(0)) },
773+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
774+ { json: "outshiner", js: "outshiner", typ: u(undefined, i(0)) },
775+ { json: "overweather", js: "overweather", typ: u(undefined, i(0)) },
776+ { json: "protonegroid", js: "protonegroid", typ: u(undefined, i(0)) },
777+ { json: "shallowish", js: "shallowish", typ: u(undefined, i(0)) },
778+ { json: "snoke", js: "snoke", typ: u(undefined, i(0)) },
779+ { json: "snout", js: "snout", typ: u(undefined, i(0)) },
780+ { json: "surveillance", js: "surveillance", typ: u(undefined, i(0)) },
781+ { json: "threshingtime", js: "threshingtime", typ: u(undefined, i(0)) },
782+ { json: "unsignificantly", js: "unsignificantly", typ: u(undefined, i(0)) },
783+ { json: "unsnap", js: "unsnap", typ: u(undefined, i(0)) },
784+ { json: "vendible", js: "vendible", typ: u(undefined, i(0)) },
785+ ], false),
786+ "Maslin": o([
787+ { json: "Alicant", js: "Alicant", typ: u(undefined, i(0)) },
788+ { json: "Bakuninist", js: "Bakuninist", typ: u(undefined, null) },
789+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
790+ { json: "Dimitry", js: "Dimitry", typ: u(undefined, i(0)) },
791+ { json: "antiatonement", js: "antiatonement", typ: u(undefined, null) },
792+ { json: "anticorrosive", js: "anticorrosive", typ: u(undefined, i(0)) },
793+ { json: "aphidozer", js: "aphidozer", typ: u(undefined, null) },
794+ { json: "be", js: "be", typ: u(undefined, i(0)) },
795+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
796+ { json: "chub", js: "chub", typ: u(undefined, i(0)) },
797+ { json: "cuprosilicon", js: "cuprosilicon", typ: u(undefined, i(0)) },
798+ { json: "curtailedly", js: "curtailedly", typ: u(undefined, i(0)) },
799+ { json: "dellenite", js: "dellenite", typ: u(undefined, i(0)) },
800+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
801+ { json: "edifying", js: "edifying", typ: u(undefined, null) },
802+ { json: "ethmoiditis", js: "ethmoiditis", typ: u(undefined, i(0)) },
803+ { json: "gastralgy", js: "gastralgy", typ: u(undefined, null) },
804+ { json: "goatherd", js: "goatherd", typ: u(undefined, i(0)) },
805+ { json: "hammerdress", js: "hammerdress", typ: u(undefined, i(0)) },
806+ { json: "hangfire", js: "hangfire", typ: u(undefined, null) },
807+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
808+ { json: "lacunosity", js: "lacunosity", typ: u(undefined, i(0)) },
809+ { json: "longiloquence", js: "longiloquence", typ: u(undefined, null) },
810+ { json: "mameliere", js: "mameliere", typ: u(undefined, i(0)) },
811+ { json: "motherless", js: "motherless", typ: u(undefined, null) },
812+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
813+ { json: "noncorrodible", js: "noncorrodible", typ: u(undefined, null) },
814+ { json: "nonsensicality", js: "nonsensicality", typ: u(undefined, null) },
815+ { json: "oafishly", js: "oafishly", typ: u(undefined, i(0)) },
816+ { json: "pfund", js: "pfund", typ: u(undefined, null) },
817+ { json: "preadvisory", js: "preadvisory", typ: u(undefined, null) },
818+ { json: "retroflexed", js: "retroflexed", typ: u(undefined, null) },
819+ { json: "saccharulmic", js: "saccharulmic", typ: u(undefined, i(0)) },
820+ { json: "scowlful", js: "scowlful", typ: u(undefined, i(0)) },
821+ { json: "secluded", js: "secluded", typ: u(undefined, null) },
822+ { json: "slackage", js: "slackage", typ: u(undefined, null) },
823+ { json: "sphaeridial", js: "sphaeridial", typ: u(undefined, i(0)) },
824+ { json: "spondulics", js: "spondulics", typ: u(undefined, null) },
825+ { json: "subsecive", js: "subsecive", typ: u(undefined, i(0)) },
826+ { json: "swellmobsman", js: "swellmobsman", typ: u(undefined, null) },
827+ { json: "trachyglossate", js: "trachyglossate", typ: u(undefined, i(0)) },
828+ { json: "trialogue", js: "trialogue", typ: u(undefined, null) },
829+ { json: "unassuaged", js: "unassuaged", typ: u(undefined, i(0)) },
830+ { json: "ungross", js: "ungross", typ: u(undefined, null) },
831+ { json: "unjudiciously", js: "unjudiciously", typ: u(undefined, null) },
832+ ], false),
833+ "MonaziteClass": o([
834+ { json: "Chirotherium", js: "Chirotherium", typ: i(0) },
835+ { json: "catharticalness", js: "catharticalness", typ: 3.14 },
836+ { json: "disdiapason", js: "disdiapason", typ: "" },
837+ { json: "homocerc", js: "homocerc", typ: true },
838+ { json: "nonbookish", js: "nonbookish", typ: null },
839+ ], false),
840+ "MonotheisticallyClass": o([
841+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
842+ { json: "blaspheme", js: "blaspheme", typ: u(undefined, null) },
843+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
844+ { json: "celiosalpingectomy", js: "celiosalpingectomy", typ: u(undefined, null) },
845+ { json: "consummativeness", js: "consummativeness", typ: u(undefined, null) },
846+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
847+ { json: "egestive", js: "egestive", typ: u(undefined, null) },
848+ { json: "enchylema", js: "enchylema", typ: u(undefined, null) },
849+ { json: "gasconade", js: "gasconade", typ: u(undefined, null) },
850+ { json: "holidayer", js: "holidayer", typ: u(undefined, null) },
851+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
852+ { json: "intuitionalism", js: "intuitionalism", typ: u(undefined, null) },
853+ { json: "lophiostomate", js: "lophiostomate", typ: u(undefined, null) },
854+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
855+ { json: "nonvolition", js: "nonvolition", typ: u(undefined, null) },
856+ { json: "palatableness", js: "palatableness", typ: u(undefined, null) },
857+ { json: "pimpery", js: "pimpery", typ: u(undefined, null) },
858+ { json: "previolation", js: "previolation", typ: u(undefined, null) },
859+ { json: "reconveyance", js: "reconveyance", typ: u(undefined, null) },
860+ { json: "registership", js: "registership", typ: u(undefined, null) },
861+ { json: "rhyacolite", js: "rhyacolite", typ: u(undefined, null) },
862+ { json: "smithereens", js: "smithereens", typ: u(undefined, null) },
863+ { json: "superedification", js: "superedification", typ: u(undefined, null) },
864+ { json: "trust", js: "trust", typ: u(undefined, null) },
865+ { json: "whitestone", js: "whitestone", typ: u(undefined, null) },
866+ ], false),
867+ "Noncontributing": o([
868+ { json: "estevin", js: "estevin", typ: "" },
869+ { json: "jolterhead", js: "jolterhead", typ: 3.14 },
870+ { json: "sauternes", js: "sauternes", typ: i(0) },
871+ { json: "sparsely", js: "sparsely", typ: true },
872+ { json: "unrequested", js: "unrequested", typ: null },
873+ ], false),
874+ "OccupationalistClass": o([
875+ { json: "Chimakum", js: "Chimakum", typ: null },
876+ { json: "Fin", js: "Fin", typ: null },
877+ { json: "beholdable", js: "beholdable", typ: null },
878+ { json: "brotuliform", js: "brotuliform", typ: null },
879+ { json: "doodler", js: "doodler", typ: null },
880+ { json: "emulsin", js: "emulsin", typ: null },
881+ { json: "flourishing", js: "flourishing", typ: null },
882+ { json: "flueless", js: "flueless", typ: null },
883+ { json: "furtively", js: "furtively", typ: null },
884+ { json: "gritter", js: "gritter", typ: null },
885+ { json: "interwish", js: "interwish", typ: null },
886+ { json: "monoxylic", js: "monoxylic", typ: null },
887+ { json: "myristic", js: "myristic", typ: null },
888+ { json: "nightwear", js: "nightwear", typ: null },
889+ { json: "peruser", js: "peruser", typ: null },
890+ { json: "theoastrological", js: "theoastrological", typ: null },
891+ { json: "thumby", js: "thumby", typ: null },
892+ { json: "tingitid", js: "tingitid", typ: null },
893+ { json: "trailless", js: "trailless", typ: null },
894+ { json: "unpocketed", js: "unpocketed", typ: null },
895+ ], false),
896+ "OutrivalClass": o([
897+ { json: "Castoroides", js: "Castoroides", typ: null },
898+ { json: "Czechoslovak", js: "Czechoslovak", typ: null },
899+ { json: "Lingulidae", js: "Lingulidae", typ: null },
900+ { json: "adroitly", js: "adroitly", typ: null },
901+ { json: "bridehood", js: "bridehood", typ: null },
902+ { json: "diagenesis", js: "diagenesis", typ: null },
903+ { json: "dihexahedron", js: "dihexahedron", typ: null },
904+ { json: "dopester", js: "dopester", typ: null },
905+ { json: "eumerism", js: "eumerism", typ: null },
906+ { json: "flyness", js: "flyness", typ: null },
907+ { json: "fouler", js: "fouler", typ: null },
908+ { json: "laudanosine", js: "laudanosine", typ: null },
909+ { json: "minutary", js: "minutary", typ: null },
910+ { json: "mitra", js: "mitra", typ: null },
911+ { json: "opisthorchiasis", js: "opisthorchiasis", typ: null },
912+ { json: "pensively", js: "pensively", typ: null },
913+ { json: "pubigerous", js: "pubigerous", typ: null },
914+ { json: "rebellious", js: "rebellious", typ: null },
915+ { json: "recodify", js: "recodify", typ: null },
916+ { json: "unpaced", js: "unpaced", typ: null },
917+ ], false),
918+ "PiaculumClass": o([
919+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
920+ { json: "Zipper", js: "Zipper", typ: u(undefined, i(0)) },
921+ { json: "alada", js: "alada", typ: u(undefined, i(0)) },
922+ { json: "amphistomous", js: "amphistomous", typ: u(undefined, i(0)) },
923+ { json: "boysenberry", js: "boysenberry", typ: u(undefined, i(0)) },
924+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
925+ { json: "decardinalize", js: "decardinalize", typ: u(undefined, i(0)) },
926+ { json: "discouragement", js: "discouragement", typ: u(undefined, i(0)) },
927+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
928+ { json: "doitrified", js: "doitrified", typ: u(undefined, i(0)) },
929+ { json: "hexaspermous", js: "hexaspermous", typ: u(undefined, i(0)) },
930+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
931+ { json: "insinking", js: "insinking", typ: u(undefined, i(0)) },
932+ { json: "loathfulness", js: "loathfulness", typ: u(undefined, i(0)) },
933+ { json: "miasmatical", js: "miasmatical", typ: u(undefined, i(0)) },
934+ { json: "neurofibril", js: "neurofibril", typ: u(undefined, i(0)) },
935+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
936+ { json: "phonendoscope", js: "phonendoscope", typ: u(undefined, i(0)) },
937+ { json: "pilferment", js: "pilferment", typ: u(undefined, i(0)) },
938+ { json: "predismissory", js: "predismissory", typ: u(undefined, i(0)) },
939+ { json: "preinscription", js: "preinscription", typ: u(undefined, i(0)) },
940+ { json: "quotative", js: "quotative", typ: u(undefined, i(0)) },
941+ { json: "sienna", js: "sienna", typ: u(undefined, i(0)) },
942+ { json: "thorax", js: "thorax", typ: u(undefined, i(0)) },
943+ { json: "yachting", js: "yachting", typ: u(undefined, i(0)) },
944+ ], false),
945+ "Pneumocele": o([
946+ { json: "Carbonarism", js: "Carbonarism", typ: u(undefined, null) },
947+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
948+ { json: "Koniga", js: "Koniga", typ: u(undefined, null) },
949+ { json: "Micky", js: "Micky", typ: u(undefined, null) },
950+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
951+ { json: "cineolic", js: "cineolic", typ: u(undefined, null) },
952+ { json: "cobbly", js: "cobbly", typ: u(undefined, null) },
953+ { json: "conchyliferous", js: "conchyliferous", typ: u(undefined, null) },
954+ { json: "congregation", js: "congregation", typ: u(undefined, null) },
955+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
956+ { json: "enterotomy", js: "enterotomy", typ: u(undefined, null) },
957+ { json: "entophytal", js: "entophytal", typ: u(undefined, null) },
958+ { json: "fewtrils", js: "fewtrils", typ: u(undefined, null) },
959+ { json: "herem", js: "herem", typ: u(undefined, null) },
960+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
961+ { json: "meticulosity", js: "meticulosity", typ: u(undefined, null) },
962+ { json: "mismarriage", js: "mismarriage", typ: u(undefined, null) },
963+ { json: "neurotrophic", js: "neurotrophic", typ: u(undefined, null) },
964+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
965+ { json: "persuasively", js: "persuasively", typ: u(undefined, null) },
966+ { json: "replaceable", js: "replaceable", typ: u(undefined, null) },
967+ { json: "silex", js: "silex", typ: u(undefined, null) },
968+ { json: "taillight", js: "taillight", typ: u(undefined, null) },
969+ { json: "unjealous", js: "unjealous", typ: u(undefined, null) },
970+ { json: "visitorial", js: "visitorial", typ: u(undefined, null) },
971+ ], false),
972+ "PotwhiskyClass": o([
973+ { json: "Euchorda", js: "Euchorda", typ: null },
974+ { json: "Yoruba", js: "Yoruba", typ: null },
975+ { json: "arciform", js: "arciform", typ: null },
976+ { json: "cresolin", js: "cresolin", typ: null },
977+ { json: "disheartener", js: "disheartener", typ: null },
978+ { json: "disproportionable", js: "disproportionable", typ: null },
979+ { json: "ferryway", js: "ferryway", typ: null },
980+ { json: "filamentiferous", js: "filamentiferous", typ: null },
981+ { json: "flemish", js: "flemish", typ: null },
982+ { json: "forgainst", js: "forgainst", typ: null },
983+ { json: "grainering", js: "grainering", typ: null },
984+ { json: "irrevoluble", js: "irrevoluble", typ: null },
985+ { json: "kindredship", js: "kindredship", typ: null },
986+ { json: "pinguitudinous", js: "pinguitudinous", typ: null },
987+ { json: "simpletonic", js: "simpletonic", typ: null },
988+ { json: "singsong", js: "singsong", typ: null },
989+ { json: "submergement", js: "submergement", typ: null },
990+ { json: "supraoesophagal", js: "supraoesophagal", typ: null },
991+ { json: "thrashel", js: "thrashel", typ: null },
992+ { json: "tyremesis", js: "tyremesis", typ: null },
993+ ], false),
994+ "PrefreshmanClass": o([
995+ { json: "Dolphus", js: "Dolphus", typ: null },
996+ { json: "Ficus", js: "Ficus", typ: null },
997+ { json: "Gemaric", js: "Gemaric", typ: null },
998+ { json: "Phaet", js: "Phaet", typ: null },
999+ { json: "azorubine", js: "azorubine", typ: null },
1000+ { json: "choroiditis", js: "choroiditis", typ: null },
1001+ { json: "coagulatory", js: "coagulatory", typ: null },
1002+ { json: "cyclorama", js: "cyclorama", typ: null },
1003+ { json: "duckhearted", js: "duckhearted", typ: null },
1004+ { json: "jugation", js: "jugation", typ: null },
1005+ { json: "myoliposis", js: "myoliposis", typ: null },
1006+ { json: "nonnomination", js: "nonnomination", typ: null },
1007+ { json: "palay", js: "palay", typ: null },
1008+ { json: "pentactinal", js: "pentactinal", typ: null },
1009+ { json: "piquant", js: "piquant", typ: null },
1010+ { json: "registration", js: "registration", typ: null },
1011+ { json: "remancipation", js: "remancipation", typ: null },
1012+ { json: "scutatiform", js: "scutatiform", typ: null },
1013+ { json: "theodolite", js: "theodolite", typ: null },
1014+ { json: "underward", js: "underward", typ: null },
1015+ ], false),
1016+};
Test case

test/inputs/json/priority/combinations4.json

5 generated files · +11,880 −0
Adartfrom-map-true--d222f65b3fee / TopLevel.dart+1,761 −0
@@ -0,0 +1,1761 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromMap(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toMap());
10+
11+class TopLevel {
12+ final List<dynamic> protrusive;
13+ final List<dynamic> pulpitism;
14+ final List<dynamic> pyodermia;
15+ final List<dynamic> quebrachine;
16+ final List<dynamic> querier;
17+ final List<dynamic> rebarbative;
18+ final List<Reimagine> reimagine;
19+ final Ressaut ressaut;
20+ final List<dynamic> retrocervical;
21+ final List<dynamic> revert;
22+ final List<dynamic> rewrite;
23+ final List<dynamic> saccoderm;
24+ final List<dynamic> santir;
25+ final List<dynamic> saprophilous;
26+ final List<dynamic> saxten;
27+ final List<Scatty?> scatty;
28+ final List<dynamic> scoffer;
29+ final List<dynamic> scrampum;
30+ final double semantic;
31+ final List<dynamic> serpentinic;
32+ final List<dynamic> shadowable;
33+ final List<dynamic> sistering;
34+ final List<Staghunting> staghunting;
35+ final List<dynamic> stagmometer;
36+ final List<dynamic> stimulability;
37+ final List<dynamic> strangleable;
38+ final List<dynamic> strenuosity;
39+ final List<dynamic> tabaxir;
40+ final List<dynamic> talpiform;
41+ final List<dynamic> thwack;
42+ final List<double?> to;
43+ final List<dynamic> tortricine;
44+ final List<dynamic> truantcy;
45+ final List<String> turgesce;
46+ final List<dynamic> unbeginning;
47+ final List<double> underdunged;
48+ final List<dynamic> undesirability;
49+ final List<dynamic> unerasing;
50+ final List<dynamic> unguentarium;
51+ final List<dynamic> unimpeachably;
52+ final List<dynamic> unmortgaged;
53+ final List<dynamic> unobstructed;
54+ final List<dynamic> unreceptivity;
55+ final List<dynamic> unsatisfactoriness;
56+ final List<int> unsecurity;
57+ final List<dynamic> unstressed;
58+ final List<dynamic> untasked;
59+ final List<dynamic> unvarying;
60+ final List<dynamic> vehemently;
61+ final Map<String, bool> warriorship;
62+ final List<dynamic> whitepot;
63+ final List<dynamic> wrothy;
64+
65+ TopLevel({
66+ required this.protrusive,
67+ required this.pulpitism,
68+ required this.pyodermia,
69+ required this.quebrachine,
70+ required this.querier,
71+ required this.rebarbative,
72+ required this.reimagine,
73+ required this.ressaut,
74+ required this.retrocervical,
75+ required this.revert,
76+ required this.rewrite,
77+ required this.saccoderm,
78+ required this.santir,
79+ required this.saprophilous,
80+ required this.saxten,
81+ required this.scatty,
82+ required this.scoffer,
83+ required this.scrampum,
84+ required this.semantic,
85+ required this.serpentinic,
86+ required this.shadowable,
87+ required this.sistering,
88+ required this.staghunting,
89+ required this.stagmometer,
90+ required this.stimulability,
91+ required this.strangleable,
92+ required this.strenuosity,
93+ required this.tabaxir,
94+ required this.talpiform,
95+ required this.thwack,
96+ required this.to,
97+ required this.tortricine,
98+ required this.truantcy,
99+ required this.turgesce,
100+ required this.unbeginning,
101+ required this.underdunged,
102+ required this.undesirability,
103+ required this.unerasing,
104+ required this.unguentarium,
105+ required this.unimpeachably,
106+ required this.unmortgaged,
107+ required this.unobstructed,
108+ required this.unreceptivity,
109+ required this.unsatisfactoriness,
110+ required this.unsecurity,
111+ required this.unstressed,
112+ required this.untasked,
113+ required this.unvarying,
114+ required this.vehemently,
115+ required this.warriorship,
116+ required this.whitepot,
117+ required this.wrothy,
118+ });
119+
120+ factory TopLevel.fromMap(Map<String, dynamic> json) => TopLevel(
121+ protrusive: List<dynamic>.from(json["protrusive"].map((x) => x)),
122+ pulpitism: List<dynamic>.from(json["pulpitism"].map((x) => x)),
123+ pyodermia: List<dynamic>.from(json["pyodermia"].map((x) => x)),
124+ quebrachine: List<dynamic>.from(json["quebrachine"].map((x) => x)),
125+ querier: List<dynamic>.from(json["querier"].map((x) => x)),
126+ rebarbative: List<dynamic>.from(json["rebarbative"].map((x) => x)),
127+ reimagine: List<Reimagine>.from(json["reimagine"].map((x) => Reimagine.fromMap(x))),
128+ ressaut: Ressaut.fromMap(json["ressaut"]),
129+ retrocervical: List<dynamic>.from(json["retrocervical"].map((x) => x)),
130+ revert: List<dynamic>.from(json["revert"].map((x) => x)),
131+ rewrite: List<dynamic>.from(json["rewrite"].map((x) => x)),
132+ saccoderm: List<dynamic>.from(json["saccoderm"].map((x) => x)),
133+ santir: List<dynamic>.from(json["santir"].map((x) => x)),
134+ saprophilous: List<dynamic>.from(json["saprophilous"].map((x) => x)),
135+ saxten: List<dynamic>.from(json["saxten"].map((x) => x)),
136+ scatty: List<Scatty?>.from(json["scatty"].map((x) => x == null ? null : Scatty.fromMap(x))),
137+ scoffer: List<dynamic>.from(json["scoffer"].map((x) => x)),
138+ scrampum: List<dynamic>.from(json["scrampum"].map((x) => x)),
139+ semantic: json["semantic"]?.toDouble(),
140+ serpentinic: List<dynamic>.from(json["serpentinic"].map((x) => x)),
141+ shadowable: List<dynamic>.from(json["shadowable"].map((x) => x)),
142+ sistering: List<dynamic>.from(json["sistering"].map((x) => x)),
143+ staghunting: List<Staghunting>.from(json["staghunting"].map((x) => Staghunting.fromMap(x))),
144+ stagmometer: List<dynamic>.from(json["stagmometer"].map((x) => x)),
145+ stimulability: List<dynamic>.from(json["stimulability"].map((x) => x)),
146+ strangleable: List<dynamic>.from(json["strangleable"].map((x) => x)),
147+ strenuosity: List<dynamic>.from(json["strenuosity"].map((x) => x)),
148+ tabaxir: List<dynamic>.from(json["tabaxir"].map((x) => x)),
149+ talpiform: List<dynamic>.from(json["talpiform"].map((x) => x)),
150+ thwack: List<dynamic>.from(json["thwack"].map((x) => x)),
151+ to: List<double?>.from(json["to"].map((x) => x?.toDouble())),
152+ tortricine: List<dynamic>.from(json["tortricine"].map((x) => x)),
153+ truantcy: List<dynamic>.from(json["truantcy"].map((x) => x)),
154+ turgesce: List<String>.from(json["turgesce"].map((x) => x)),
155+ unbeginning: List<dynamic>.from(json["unbeginning"].map((x) => x)),
156+ underdunged: List<double>.from(json["underdunged"].map((x) => x?.toDouble())),
157+ undesirability: List<dynamic>.from(json["undesirability"].map((x) => x)),
158+ unerasing: List<dynamic>.from(json["unerasing"].map((x) => x)),
159+ unguentarium: List<dynamic>.from(json["unguentarium"].map((x) => x)),
160+ unimpeachably: List<dynamic>.from(json["unimpeachably"].map((x) => x)),
161+ unmortgaged: List<dynamic>.from(json["unmortgaged"].map((x) => x)),
162+ unobstructed: List<dynamic>.from(json["unobstructed"].map((x) => x)),
163+ unreceptivity: List<dynamic>.from(json["unreceptivity"].map((x) => x)),
164+ unsatisfactoriness: List<dynamic>.from(json["unsatisfactoriness"].map((x) => x)),
165+ unsecurity: List<int>.from(json["unsecurity"].map((x) => x)),
166+ unstressed: List<dynamic>.from(json["unstressed"].map((x) => x)),
167+ untasked: List<dynamic>.from(json["untasked"].map((x) => x)),
168+ unvarying: List<dynamic>.from(json["unvarying"].map((x) => x)),
169+ vehemently: List<dynamic>.from(json["vehemently"].map((x) => x)),
170+ warriorship: Map.from(json["warriorship"]).map((k, v) => MapEntry<String, bool>(k, v)),
171+ whitepot: List<dynamic>.from(json["whitepot"].map((x) => x)),
172+ wrothy: List<dynamic>.from(json["wrothy"].map((x) => x)),
173+ );
174+
175+ Map<String, dynamic> toMap() => {
176+ "protrusive": List<dynamic>.from(protrusive.map((x) => x)),
177+ "pulpitism": List<dynamic>.from(pulpitism.map((x) => x)),
178+ "pyodermia": List<dynamic>.from(pyodermia.map((x) => x)),
179+ "quebrachine": List<dynamic>.from(quebrachine.map((x) => x)),
180+ "querier": List<dynamic>.from(querier.map((x) => x)),
181+ "rebarbative": List<dynamic>.from(rebarbative.map((x) => x)),
182+ "reimagine": List<dynamic>.from(reimagine.map((x) => x.toMap())),
183+ "ressaut": ressaut.toMap(),
184+ "retrocervical": List<dynamic>.from(retrocervical.map((x) => x)),
185+ "revert": List<dynamic>.from(revert.map((x) => x)),
186+ "rewrite": List<dynamic>.from(rewrite.map((x) => x)),
187+ "saccoderm": List<dynamic>.from(saccoderm.map((x) => x)),
188+ "santir": List<dynamic>.from(santir.map((x) => x)),
189+ "saprophilous": List<dynamic>.from(saprophilous.map((x) => x)),
190+ "saxten": List<dynamic>.from(saxten.map((x) => x)),
191+ "scatty": List<dynamic>.from(scatty.map((x) => x?.toMap())),
192+ "scoffer": List<dynamic>.from(scoffer.map((x) => x)),
193+ "scrampum": List<dynamic>.from(scrampum.map((x) => x)),
194+ "semantic": semantic,
195+ "serpentinic": List<dynamic>.from(serpentinic.map((x) => x)),
196+ "shadowable": List<dynamic>.from(shadowable.map((x) => x)),
197+ "sistering": List<dynamic>.from(sistering.map((x) => x)),
198+ "staghunting": List<dynamic>.from(staghunting.map((x) => x.toMap())),
199+ "stagmometer": List<dynamic>.from(stagmometer.map((x) => x)),
200+ "stimulability": List<dynamic>.from(stimulability.map((x) => x)),
201+ "strangleable": List<dynamic>.from(strangleable.map((x) => x)),
202+ "strenuosity": List<dynamic>.from(strenuosity.map((x) => x)),
203+ "tabaxir": List<dynamic>.from(tabaxir.map((x) => x)),
204+ "talpiform": List<dynamic>.from(talpiform.map((x) => x)),
205+ "thwack": List<dynamic>.from(thwack.map((x) => x)),
206+ "to": List<dynamic>.from(to.map((x) => x)),
207+ "tortricine": List<dynamic>.from(tortricine.map((x) => x)),
208+ "truantcy": List<dynamic>.from(truantcy.map((x) => x)),
209+ "turgesce": List<dynamic>.from(turgesce.map((x) => x)),
210+ "unbeginning": List<dynamic>.from(unbeginning.map((x) => x)),
211+ "underdunged": List<dynamic>.from(underdunged.map((x) => x)),
212+ "undesirability": List<dynamic>.from(undesirability.map((x) => x)),
213+ "unerasing": List<dynamic>.from(unerasing.map((x) => x)),
214+ "unguentarium": List<dynamic>.from(unguentarium.map((x) => x)),
215+ "unimpeachably": List<dynamic>.from(unimpeachably.map((x) => x)),
216+ "unmortgaged": List<dynamic>.from(unmortgaged.map((x) => x)),
217+ "unobstructed": List<dynamic>.from(unobstructed.map((x) => x)),
218+ "unreceptivity": List<dynamic>.from(unreceptivity.map((x) => x)),
219+ "unsatisfactoriness": List<dynamic>.from(unsatisfactoriness.map((x) => x)),
220+ "unsecurity": List<dynamic>.from(unsecurity.map((x) => x)),
221+ "unstressed": List<dynamic>.from(unstressed.map((x) => x)),
222+ "untasked": List<dynamic>.from(untasked.map((x) => x)),
223+ "unvarying": List<dynamic>.from(unvarying.map((x) => x)),
224+ "vehemently": List<dynamic>.from(vehemently.map((x) => x)),
225+ "warriorship": Map.from(warriorship).map((k, v) => MapEntry<String, dynamic>(k, v)),
226+ "whitepot": List<dynamic>.from(whitepot.map((x) => x)),
227+ "wrothy": List<dynamic>.from(wrothy.map((x) => x)),
228+ };
229+}
230+
231+class PulpitismClass {
232+ final dynamic abnet;
233+ final dynamic buckhorn;
234+ final dynamic calciform;
235+ final dynamic chelophore;
236+ final dynamic cogitation;
237+ final dynamic decreeable;
238+ final dynamic despicable;
239+ final dynamic isodiazo;
240+ final dynamic jadedly;
241+ final dynamic leptochlorite;
242+ final dynamic nursling;
243+ final dynamic palamedean;
244+ final dynamic photoheliograph;
245+ final dynamic pipewood;
246+ final dynamic roberd;
247+ final dynamic statable;
248+ final dynamic superassume;
249+ final dynamic syllabe;
250+ final dynamic toughhead;
251+ final dynamic underburn;
252+
253+ PulpitismClass({
254+ required this.abnet,
255+ required this.buckhorn,
256+ required this.calciform,
257+ required this.chelophore,
258+ required this.cogitation,
259+ required this.decreeable,
260+ required this.despicable,
261+ required this.isodiazo,
262+ required this.jadedly,
263+ required this.leptochlorite,
264+ required this.nursling,
265+ required this.palamedean,
266+ required this.photoheliograph,
267+ required this.pipewood,
268+ required this.roberd,
269+ required this.statable,
270+ required this.superassume,
271+ required this.syllabe,
272+ required this.toughhead,
273+ required this.underburn,
274+ });
275+
276+ factory PulpitismClass.fromMap(Map<String, dynamic> json) => PulpitismClass(
277+ abnet: (json.containsKey("abnet") ? json["abnet"] : throw FormatException('Missing required property')),
278+ buckhorn: (json.containsKey("buckhorn") ? json["buckhorn"] : throw FormatException('Missing required property')),
279+ calciform: (json.containsKey("calciform") ? json["calciform"] : throw FormatException('Missing required property')),
280+ chelophore: (json.containsKey("chelophore") ? json["chelophore"] : throw FormatException('Missing required property')),
281+ cogitation: (json.containsKey("cogitation") ? json["cogitation"] : throw FormatException('Missing required property')),
282+ decreeable: (json.containsKey("decreeable") ? json["decreeable"] : throw FormatException('Missing required property')),
283+ despicable: (json.containsKey("despicable") ? json["despicable"] : throw FormatException('Missing required property')),
284+ isodiazo: (json.containsKey("isodiazo") ? json["isodiazo"] : throw FormatException('Missing required property')),
285+ jadedly: (json.containsKey("jadedly") ? json["jadedly"] : throw FormatException('Missing required property')),
286+ leptochlorite: (json.containsKey("leptochlorite") ? json["leptochlorite"] : throw FormatException('Missing required property')),
287+ nursling: (json.containsKey("nursling") ? json["nursling"] : throw FormatException('Missing required property')),
288+ palamedean: (json.containsKey("palamedean") ? json["palamedean"] : throw FormatException('Missing required property')),
289+ photoheliograph: (json.containsKey("photoheliograph") ? json["photoheliograph"] : throw FormatException('Missing required property')),
290+ pipewood: (json.containsKey("pipewood") ? json["pipewood"] : throw FormatException('Missing required property')),
291+ roberd: (json.containsKey("roberd") ? json["roberd"] : throw FormatException('Missing required property')),
292+ statable: (json.containsKey("statable") ? json["statable"] : throw FormatException('Missing required property')),
293+ superassume: (json.containsKey("superassume") ? json["superassume"] : throw FormatException('Missing required property')),
294+ syllabe: (json.containsKey("syllabe") ? json["syllabe"] : throw FormatException('Missing required property')),
295+ toughhead: (json.containsKey("toughhead") ? json["toughhead"] : throw FormatException('Missing required property')),
296+ underburn: (json.containsKey("underburn") ? json["underburn"] : throw FormatException('Missing required property')),
297+ );
298+
299+ Map<String, dynamic> toMap() => {
300+ "abnet": abnet,
301+ "buckhorn": buckhorn,
302+ "calciform": calciform,
303+ "chelophore": chelophore,
304+ "cogitation": cogitation,
305+ "decreeable": decreeable,
306+ "despicable": despicable,
307+ "isodiazo": isodiazo,
308+ "jadedly": jadedly,
309+ "leptochlorite": leptochlorite,
310+ "nursling": nursling,
311+ "palamedean": palamedean,
312+ "photoheliograph": photoheliograph,
313+ "pipewood": pipewood,
314+ "roberd": roberd,
315+ "statable": statable,
316+ "superassume": superassume,
317+ "syllabe": syllabe,
318+ "toughhead": toughhead,
319+ "underburn": underburn,
320+ };
321+}
322+
323+class PyodermiaClass {
324+ final dynamic aphoristically;
325+ final dynamic apophyllous;
326+ final dynamic cognize;
327+ final dynamic dermonosology;
328+ final dynamic gyppo;
329+ final dynamic ither;
330+ final dynamic juglandaceous;
331+ final dynamic litho;
332+ final dynamic macropterous;
333+ final dynamic photographer;
334+ final dynamic romancing;
335+ final dynamic rumness;
336+ final dynamic somniloquist;
337+ final dynamic stressfully;
338+ final dynamic tactically;
339+ final dynamic tracheophony;
340+ final dynamic unappositely;
341+ final dynamic unclothedly;
342+ final dynamic unimplied;
343+ final dynamic unsyncopated;
344+
345+ PyodermiaClass({
346+ required this.aphoristically,
347+ required this.apophyllous,
348+ required this.cognize,
349+ required this.dermonosology,
350+ required this.gyppo,
351+ required this.ither,
352+ required this.juglandaceous,
353+ required this.litho,
354+ required this.macropterous,
355+ required this.photographer,
356+ required this.romancing,
357+ required this.rumness,
358+ required this.somniloquist,
359+ required this.stressfully,
360+ required this.tactically,
361+ required this.tracheophony,
362+ required this.unappositely,
363+ required this.unclothedly,
364+ required this.unimplied,
365+ required this.unsyncopated,
366+ });
367+
368+ factory PyodermiaClass.fromMap(Map<String, dynamic> json) => PyodermiaClass(
369+ aphoristically: (json.containsKey("aphoristically") ? json["aphoristically"] : throw FormatException('Missing required property')),
370+ apophyllous: (json.containsKey("apophyllous") ? json["apophyllous"] : throw FormatException('Missing required property')),
371+ cognize: (json.containsKey("cognize") ? json["cognize"] : throw FormatException('Missing required property')),
372+ dermonosology: (json.containsKey("dermonosology") ? json["dermonosology"] : throw FormatException('Missing required property')),
373+ gyppo: (json.containsKey("Gyppo") ? json["Gyppo"] : throw FormatException('Missing required property')),
374+ ither: (json.containsKey("ither") ? json["ither"] : throw FormatException('Missing required property')),
375+ juglandaceous: (json.containsKey("juglandaceous") ? json["juglandaceous"] : throw FormatException('Missing required property')),
376+ litho: (json.containsKey("litho") ? json["litho"] : throw FormatException('Missing required property')),
377+ macropterous: (json.containsKey("macropterous") ? json["macropterous"] : throw FormatException('Missing required property')),
378+ photographer: (json.containsKey("photographer") ? json["photographer"] : throw FormatException('Missing required property')),
379+ romancing: (json.containsKey("romancing") ? json["romancing"] : throw FormatException('Missing required property')),
380+ rumness: (json.containsKey("rumness") ? json["rumness"] : throw FormatException('Missing required property')),
381+ somniloquist: (json.containsKey("somniloquist") ? json["somniloquist"] : throw FormatException('Missing required property')),
382+ stressfully: (json.containsKey("stressfully") ? json["stressfully"] : throw FormatException('Missing required property')),
383+ tactically: (json.containsKey("tactically") ? json["tactically"] : throw FormatException('Missing required property')),
384+ tracheophony: (json.containsKey("tracheophony") ? json["tracheophony"] : throw FormatException('Missing required property')),
385+ unappositely: (json.containsKey("unappositely") ? json["unappositely"] : throw FormatException('Missing required property')),
386+ unclothedly: (json.containsKey("unclothedly") ? json["unclothedly"] : throw FormatException('Missing required property')),
387+ unimplied: (json.containsKey("unimplied") ? json["unimplied"] : throw FormatException('Missing required property')),
388+ unsyncopated: (json.containsKey("unsyncopated") ? json["unsyncopated"] : throw FormatException('Missing required property')),
389+ );
390+
391+ Map<String, dynamic> toMap() => {
392+ "aphoristically": aphoristically,
393+ "apophyllous": apophyllous,
394+ "cognize": cognize,
395+ "dermonosology": dermonosology,
396+ "Gyppo": gyppo,
397+ "ither": ither,
398+ "juglandaceous": juglandaceous,
399+ "litho": litho,
400+ "macropterous": macropterous,
401+ "photographer": photographer,
402+ "romancing": romancing,
403+ "rumness": rumness,
404+ "somniloquist": somniloquist,
405+ "stressfully": stressfully,
406+ "tactically": tactically,
407+ "tracheophony": tracheophony,
408+ "unappositely": unappositely,
409+ "unclothedly": unclothedly,
410+ "unimplied": unimplied,
411+ "unsyncopated": unsyncopated,
412+ };
413+}
414+
415+class QuebrachineClass {
416+ final double catharticalness;
417+ final int chirotherium;
418+ final String disdiapason;
419+ final bool homocerc;
420+ final dynamic nonbookish;
421+
422+ QuebrachineClass({
423+ required this.catharticalness,
424+ required this.chirotherium,
425+ required this.disdiapason,
426+ required this.homocerc,
427+ required this.nonbookish,
428+ });
429+
430+ factory QuebrachineClass.fromMap(Map<String, dynamic> json) => QuebrachineClass(
431+ catharticalness: json["catharticalness"]?.toDouble(),
432+ chirotherium: json["Chirotherium"],
433+ disdiapason: json["disdiapason"],
434+ homocerc: json["homocerc"],
435+ nonbookish: (json.containsKey("nonbookish") ? json["nonbookish"] : throw FormatException('Missing required property')),
436+ );
437+
438+ Map<String, dynamic> toMap() => {
439+ "catharticalness": catharticalness,
440+ "Chirotherium": chirotherium,
441+ "disdiapason": disdiapason,
442+ "homocerc": homocerc,
443+ "nonbookish": nonbookish,
444+ };
445+}
446+
447+class Reimagine {
448+ final dynamic adducible;
449+ final dynamic anabolin;
450+ final dynamic brainy;
451+ final double? catharticalness;
452+ final int? chirotherium;
453+ final dynamic chrysamine;
454+ final String? disdiapason;
455+ final dynamic fluxweed;
456+ final dynamic glaucine;
457+ final dynamic grobianism;
458+ final dynamic hermo;
459+ final dynamic hieroglyphist;
460+ final bool? homocerc;
461+ final dynamic icteroid;
462+ final dynamic immortal;
463+ final dynamic impetulant;
464+ final dynamic irrigate;
465+ final dynamic myxedema;
466+ final dynamic nonbookish;
467+ final dynamic onyx;
468+ final dynamic repasser;
469+ final dynamic septomarginal;
470+ final dynamic subdie;
471+ final dynamic tibiometatarsal;
472+ final dynamic waltzlike;
473+
474+ Reimagine({
475+ this.adducible,
476+ this.anabolin,
477+ this.brainy,
478+ this.catharticalness,
479+ this.chirotherium,
480+ this.chrysamine,
481+ this.disdiapason,
482+ this.fluxweed,
483+ this.glaucine,
484+ this.grobianism,
485+ this.hermo,
486+ this.hieroglyphist,
487+ this.homocerc,
488+ this.icteroid,
489+ this.immortal,
490+ this.impetulant,
491+ this.irrigate,
492+ this.myxedema,
493+ this.nonbookish,
494+ this.onyx,
495+ this.repasser,
496+ this.septomarginal,
497+ this.subdie,
498+ this.tibiometatarsal,
499+ this.waltzlike,
500+ });
501+
502+ factory Reimagine.fromMap(Map<String, dynamic> json) => Reimagine(
503+ adducible: json["adducible"],
504+ anabolin: json["anabolin"],
505+ brainy: json["brainy"],
506+ catharticalness: json["catharticalness"]?.toDouble(),
507+ chirotherium: json["Chirotherium"],
508+ chrysamine: json["chrysamine"],
509+ disdiapason: json["disdiapason"],
510+ fluxweed: json["fluxweed"],
511+ glaucine: json["glaucine"],
512+ grobianism: json["grobianism"],
513+ hermo: json["Hermo"],
514+ hieroglyphist: json["hieroglyphist"],
515+ homocerc: json["homocerc"],
516+ icteroid: json["icteroid"],
517+ immortal: json["immortal"],
518+ impetulant: json["impetulant"],
519+ irrigate: json["irrigate"],
520+ myxedema: json["myxedema"],
521+ nonbookish: json["nonbookish"],
522+ onyx: json["onyx"],
523+ repasser: json["repasser"],
524+ septomarginal: json["septomarginal"],
525+ subdie: json["subdie"],
526+ tibiometatarsal: json["tibiometatarsal"],
527+ waltzlike: json["waltzlike"],
528+ );
529+
530+ Map<String, dynamic> toMap() => {
531+ "adducible": adducible,
532+ "anabolin": anabolin,
533+ "brainy": brainy,
534+ "catharticalness": catharticalness,
535+ "Chirotherium": chirotherium,
536+ "chrysamine": chrysamine,
537+ "disdiapason": disdiapason,
538+ "fluxweed": fluxweed,
539+ "glaucine": glaucine,
540+ "grobianism": grobianism,
541+ "Hermo": hermo,
542+ "hieroglyphist": hieroglyphist,
543+ "homocerc": homocerc,
544+ "icteroid": icteroid,
545+ "immortal": immortal,
546+ "impetulant": impetulant,
547+ "irrigate": irrigate,
548+ "myxedema": myxedema,
549+ "nonbookish": nonbookish,
550+ "onyx": onyx,
551+ "repasser": repasser,
552+ "septomarginal": septomarginal,
553+ "subdie": subdie,
554+ "tibiometatarsal": tibiometatarsal,
555+ "waltzlike": waltzlike,
556+ };
557+}
558+
559+class Ressaut {
560+ final String apperceptive;
561+ final String cuttoo;
562+ final String douser;
563+ final String drinkproof;
564+ final String forementioned;
565+ final String freesia;
566+ final String genevieve;
567+ final String hyperdiabolical;
568+ final String hypocone;
569+ final String irreverentially;
570+ final String jumart;
571+ final String mimosaceae;
572+ final String mollicrush;
573+ final String nedder;
574+ final String retinasphalt;
575+ final String sough;
576+ final String steading;
577+ final String theopaschitism;
578+ final String undurableness;
579+ final String unmingleable;
580+
581+ Ressaut({
582+ required this.apperceptive,
583+ required this.cuttoo,
584+ required this.douser,
585+ required this.drinkproof,
586+ required this.forementioned,
587+ required this.freesia,
588+ required this.genevieve,
589+ required this.hyperdiabolical,
590+ required this.hypocone,
591+ required this.irreverentially,
592+ required this.jumart,
593+ required this.mimosaceae,
594+ required this.mollicrush,
595+ required this.nedder,
596+ required this.retinasphalt,
597+ required this.sough,
598+ required this.steading,
599+ required this.theopaschitism,
600+ required this.undurableness,
601+ required this.unmingleable,
602+ });
603+
604+ factory Ressaut.fromMap(Map<String, dynamic> json) => Ressaut(
605+ apperceptive: json["apperceptive"],
606+ cuttoo: json["cuttoo"],
607+ douser: json["douser"],
608+ drinkproof: json["drinkproof"],
609+ forementioned: json["forementioned"],
610+ freesia: json["Freesia"],
611+ genevieve: json["Genevieve"],
612+ hyperdiabolical: json["hyperdiabolical"],
613+ hypocone: json["hypocone"],
614+ irreverentially: json["irreverentially"],
615+ jumart: json["jumart"],
616+ mimosaceae: json["Mimosaceae"],
617+ mollicrush: json["mollicrush"],
618+ nedder: json["nedder"],
619+ retinasphalt: json["retinasphalt"],
620+ sough: json["sough"],
621+ steading: json["steading"],
622+ theopaschitism: json["Theopaschitism"],
623+ undurableness: json["undurableness"],
624+ unmingleable: json["unmingleable"],
625+ );
626+
627+ Map<String, dynamic> toMap() => {
628+ "apperceptive": apperceptive,
629+ "cuttoo": cuttoo,
630+ "douser": douser,
631+ "drinkproof": drinkproof,
632+ "forementioned": forementioned,
633+ "Freesia": freesia,
634+ "Genevieve": genevieve,
635+ "hyperdiabolical": hyperdiabolical,
636+ "hypocone": hypocone,
637+ "irreverentially": irreverentially,
638+ "jumart": jumart,
639+ "Mimosaceae": mimosaceae,
640+ "mollicrush": mollicrush,
641+ "nedder": nedder,
642+ "retinasphalt": retinasphalt,
643+ "sough": sough,
644+ "steading": steading,
645+ "Theopaschitism": theopaschitism,
646+ "undurableness": undurableness,
647+ "unmingleable": unmingleable,
648+ };
649+}
650+
651+class RewriteClass {
652+ final dynamic accountancy;
653+ final dynamic cacotrophic;
654+ final dynamic contest;
655+ final dynamic couthily;
656+ final dynamic falculate;
657+ final dynamic foreseize;
658+ final dynamic hyades;
659+ final dynamic lemnad;
660+ final dynamic monotheistically;
661+ final dynamic nonflying;
662+ final dynamic ptenoglossa;
663+ final dynamic repatch;
664+ final dynamic rodman;
665+ final dynamic strung;
666+ final dynamic titmal;
667+ final dynamic twalpennyworth;
668+ final dynamic unblamable;
669+ final dynamic vertical;
670+ final dynamic whiggification;
671+ final dynamic yardman;
672+
673+ RewriteClass({
674+ required this.accountancy,
675+ required this.cacotrophic,
676+ required this.contest,
677+ required this.couthily,
678+ required this.falculate,
679+ required this.foreseize,
680+ required this.hyades,
681+ required this.lemnad,
682+ required this.monotheistically,
683+ required this.nonflying,
684+ required this.ptenoglossa,
685+ required this.repatch,
686+ required this.rodman,
687+ required this.strung,
688+ required this.titmal,
689+ required this.twalpennyworth,
690+ required this.unblamable,
691+ required this.vertical,
692+ required this.whiggification,
693+ required this.yardman,
694+ });
695+
696+ factory RewriteClass.fromMap(Map<String, dynamic> json) => RewriteClass(
697+ accountancy: (json.containsKey("accountancy") ? json["accountancy"] : throw FormatException('Missing required property')),
698+ cacotrophic: (json.containsKey("cacotrophic") ? json["cacotrophic"] : throw FormatException('Missing required property')),
699+ contest: (json.containsKey("contest") ? json["contest"] : throw FormatException('Missing required property')),
700+ couthily: (json.containsKey("couthily") ? json["couthily"] : throw FormatException('Missing required property')),
701+ falculate: (json.containsKey("falculate") ? json["falculate"] : throw FormatException('Missing required property')),
702+ foreseize: (json.containsKey("foreseize") ? json["foreseize"] : throw FormatException('Missing required property')),
703+ hyades: (json.containsKey("Hyades") ? json["Hyades"] : throw FormatException('Missing required property')),
704+ lemnad: (json.containsKey("lemnad") ? json["lemnad"] : throw FormatException('Missing required property')),
705+ monotheistically: (json.containsKey("monotheistically") ? json["monotheistically"] : throw FormatException('Missing required property')),
706+ nonflying: (json.containsKey("nonflying") ? json["nonflying"] : throw FormatException('Missing required property')),
707+ ptenoglossa: (json.containsKey("Ptenoglossa") ? json["Ptenoglossa"] : throw FormatException('Missing required property')),
708+ repatch: (json.containsKey("repatch") ? json["repatch"] : throw FormatException('Missing required property')),
709+ rodman: (json.containsKey("rodman") ? json["rodman"] : throw FormatException('Missing required property')),
710+ strung: (json.containsKey("strung") ? json["strung"] : throw FormatException('Missing required property')),
711+ titmal: (json.containsKey("titmal") ? json["titmal"] : throw FormatException('Missing required property')),
712+ twalpennyworth: (json.containsKey("twalpennyworth") ? json["twalpennyworth"] : throw FormatException('Missing required property')),
713+ unblamable: (json.containsKey("unblamable") ? json["unblamable"] : throw FormatException('Missing required property')),
714+ vertical: (json.containsKey("vertical") ? json["vertical"] : throw FormatException('Missing required property')),
715+ whiggification: (json.containsKey("Whiggification") ? json["Whiggification"] : throw FormatException('Missing required property')),
716+ yardman: (json.containsKey("yardman") ? json["yardman"] : throw FormatException('Missing required property')),
717+ );
718+
719+ Map<String, dynamic> toMap() => {
720+ "accountancy": accountancy,
721+ "cacotrophic": cacotrophic,
722+ "contest": contest,
723+ "couthily": couthily,
724+ "falculate": falculate,
725+ "foreseize": foreseize,
726+ "Hyades": hyades,
727+ "lemnad": lemnad,
728+ "monotheistically": monotheistically,
729+ "nonflying": nonflying,
730+ "Ptenoglossa": ptenoglossa,
731+ "repatch": repatch,
732+ "rodman": rodman,
733+ "strung": strung,
734+ "titmal": titmal,
735+ "twalpennyworth": twalpennyworth,
736+ "unblamable": unblamable,
737+ "vertical": vertical,
738+ "Whiggification": whiggification,
739+ "yardman": yardman,
740+ };
741+}
742+
743+class SantirClass {
744+ final dynamic admiredly;
745+ final dynamic demicaponier;
746+ final dynamic epitympanic;
747+ final dynamic investitor;
748+ final dynamic lupiform;
749+ final dynamic monoflagellate;
750+ final dynamic paleoethnic;
751+ final dynamic prediscountable;
752+ final dynamic rhetoricals;
753+ final dynamic roomth;
754+ final dynamic saccharose;
755+ final dynamic septonasal;
756+ final dynamic serpenticide;
757+ final dynamic setarious;
758+ final dynamic spaework;
759+ final dynamic stylite;
760+ final dynamic suessiones;
761+ final dynamic timelily;
762+ final dynamic unprofaned;
763+ final dynamic vorticular;
764+
765+ SantirClass({
766+ required this.admiredly,
767+ required this.demicaponier,
768+ required this.epitympanic,
769+ required this.investitor,
770+ required this.lupiform,
771+ required this.monoflagellate,
772+ required this.paleoethnic,
773+ required this.prediscountable,
774+ required this.rhetoricals,
775+ required this.roomth,
776+ required this.saccharose,
777+ required this.septonasal,
778+ required this.serpenticide,
779+ required this.setarious,
780+ required this.spaework,
781+ required this.stylite,
782+ required this.suessiones,
783+ required this.timelily,
784+ required this.unprofaned,
785+ required this.vorticular,
786+ });
787+
788+ factory SantirClass.fromMap(Map<String, dynamic> json) => SantirClass(
789+ admiredly: (json.containsKey("admiredly") ? json["admiredly"] : throw FormatException('Missing required property')),
790+ demicaponier: (json.containsKey("demicaponier") ? json["demicaponier"] : throw FormatException('Missing required property')),
791+ epitympanic: (json.containsKey("epitympanic") ? json["epitympanic"] : throw FormatException('Missing required property')),
792+ investitor: (json.containsKey("investitor") ? json["investitor"] : throw FormatException('Missing required property')),
793+ lupiform: (json.containsKey("lupiform") ? json["lupiform"] : throw FormatException('Missing required property')),
794+ monoflagellate: (json.containsKey("monoflagellate") ? json["monoflagellate"] : throw FormatException('Missing required property')),
795+ paleoethnic: (json.containsKey("paleoethnic") ? json["paleoethnic"] : throw FormatException('Missing required property')),
796+ prediscountable: (json.containsKey("prediscountable") ? json["prediscountable"] : throw FormatException('Missing required property')),
797+ rhetoricals: (json.containsKey("rhetoricals") ? json["rhetoricals"] : throw FormatException('Missing required property')),
798+ roomth: (json.containsKey("roomth") ? json["roomth"] : throw FormatException('Missing required property')),
799+ saccharose: (json.containsKey("saccharose") ? json["saccharose"] : throw FormatException('Missing required property')),
800+ septonasal: (json.containsKey("septonasal") ? json["septonasal"] : throw FormatException('Missing required property')),
801+ serpenticide: (json.containsKey("serpenticide") ? json["serpenticide"] : throw FormatException('Missing required property')),
802+ setarious: (json.containsKey("setarious") ? json["setarious"] : throw FormatException('Missing required property')),
803+ spaework: (json.containsKey("spaework") ? json["spaework"] : throw FormatException('Missing required property')),
804+ stylite: (json.containsKey("stylite") ? json["stylite"] : throw FormatException('Missing required property')),
805+ suessiones: (json.containsKey("Suessiones") ? json["Suessiones"] : throw FormatException('Missing required property')),
806+ timelily: (json.containsKey("timelily") ? json["timelily"] : throw FormatException('Missing required property')),
807+ unprofaned: (json.containsKey("unprofaned") ? json["unprofaned"] : throw FormatException('Missing required property')),
808+ vorticular: (json.containsKey("vorticular") ? json["vorticular"] : throw FormatException('Missing required property')),
809+ );
810+
811+ Map<String, dynamic> toMap() => {
812+ "admiredly": admiredly,
813+ "demicaponier": demicaponier,
814+ "epitympanic": epitympanic,
815+ "investitor": investitor,
816+ "lupiform": lupiform,
817+ "monoflagellate": monoflagellate,
818+ "paleoethnic": paleoethnic,
819+ "prediscountable": prediscountable,
820+ "rhetoricals": rhetoricals,
821+ "roomth": roomth,
822+ "saccharose": saccharose,
823+ "septonasal": septonasal,
824+ "serpenticide": serpenticide,
825+ "setarious": setarious,
826+ "spaework": spaework,
827+ "stylite": stylite,
828+ "Suessiones": suessiones,
829+ "timelily": timelily,
830+ "unprofaned": unprofaned,
831+ "vorticular": vorticular,
832+ };
833+}
834+
835+class SaxtenClass {
836+ final dynamic algarrobilla;
837+ final dynamic bowgrace;
838+ final double? catharticalness;
839+ final dynamic centaurid;
840+ final int? chirotherium;
841+ final String? disdiapason;
842+ final dynamic flix;
843+ final dynamic germanely;
844+ final bool? homocerc;
845+ final dynamic inhume;
846+ final dynamic lepidote;
847+ final dynamic megalochirous;
848+ final dynamic ninepenny;
849+ final dynamic nonbookish;
850+ final dynamic nondeist;
851+ final dynamic nymphaeaceous;
852+ final dynamic parietofrontal;
853+ final dynamic sancyite;
854+ final dynamic subjectivist;
855+ final dynamic tibiad;
856+ final dynamic transonic;
857+ final dynamic tripetalous;
858+ final dynamic trunchman;
859+ final dynamic urger;
860+ final dynamic withdrawnness;
861+
862+ SaxtenClass({
863+ this.algarrobilla,
864+ this.bowgrace,
865+ this.catharticalness,
866+ this.centaurid,
867+ this.chirotherium,
868+ this.disdiapason,
869+ this.flix,
870+ this.germanely,
871+ this.homocerc,
872+ this.inhume,
873+ this.lepidote,
874+ this.megalochirous,
875+ this.ninepenny,
876+ this.nonbookish,
877+ this.nondeist,
878+ this.nymphaeaceous,
879+ this.parietofrontal,
880+ this.sancyite,
881+ this.subjectivist,
882+ this.tibiad,
883+ this.transonic,
884+ this.tripetalous,
885+ this.trunchman,
886+ this.urger,
887+ this.withdrawnness,
888+ });
889+
890+ factory SaxtenClass.fromMap(Map<String, dynamic> json) => SaxtenClass(
891+ algarrobilla: json["algarrobilla"],
892+ bowgrace: json["bowgrace"],
893+ catharticalness: json["catharticalness"]?.toDouble(),
894+ centaurid: json["Centaurid"],
895+ chirotherium: json["Chirotherium"],
896+ disdiapason: json["disdiapason"],
897+ flix: json["flix"],
898+ germanely: json["germanely"],
899+ homocerc: json["homocerc"],
900+ inhume: json["inhume"],
901+ lepidote: json["lepidote"],
902+ megalochirous: json["megalochirous"],
903+ ninepenny: json["ninepenny"],
904+ nonbookish: json["nonbookish"],
905+ nondeist: json["nondeist"],
906+ nymphaeaceous: json["nymphaeaceous"],
907+ parietofrontal: json["parietofrontal"],
908+ sancyite: json["sancyite"],
909+ subjectivist: json["subjectivist"],
910+ tibiad: json["tibiad"],
911+ transonic: json["transonic"],
912+ tripetalous: json["tripetalous"],
913+ trunchman: json["trunchman"],
914+ urger: json["urger"],
915+ withdrawnness: json["withdrawnness"],
916+ );
917+
918+ Map<String, dynamic> toMap() => {
919+ "algarrobilla": algarrobilla,
920+ "bowgrace": bowgrace,
921+ "catharticalness": catharticalness,
922+ "Centaurid": centaurid,
923+ "Chirotherium": chirotherium,
924+ "disdiapason": disdiapason,
925+ "flix": flix,
926+ "germanely": germanely,
927+ "homocerc": homocerc,
928+ "inhume": inhume,
929+ "lepidote": lepidote,
930+ "megalochirous": megalochirous,
931+ "ninepenny": ninepenny,
932+ "nonbookish": nonbookish,
933+ "nondeist": nondeist,
934+ "nymphaeaceous": nymphaeaceous,
935+ "parietofrontal": parietofrontal,
936+ "sancyite": sancyite,
937+ "subjectivist": subjectivist,
938+ "tibiad": tibiad,
939+ "transonic": transonic,
940+ "tripetalous": tripetalous,
941+ "trunchman": trunchman,
942+ "urger": urger,
943+ "withdrawnness": withdrawnness,
944+ };
945+}
946+
947+class Scatty {
948+ final dynamic aeriferous;
949+ final dynamic antical;
950+ final dynamic antighostism;
951+ final dynamic arcanum;
952+ final dynamic autotrophy;
953+ final dynamic baronial;
954+ final dynamic caffeine;
955+ final dynamic gorgoniacean;
956+ final dynamic heroical;
957+ final dynamic hydropical;
958+ final dynamic mechanology;
959+ final dynamic musicopoetic;
960+ final dynamic officiality;
961+ final dynamic oftentimes;
962+ final dynamic ophthalmotonometer;
963+ final dynamic reflectively;
964+ final dynamic springer;
965+ final dynamic tabasco;
966+ final dynamic teleianthous;
967+ final dynamic uncombated;
968+
969+ Scatty({
970+ required this.aeriferous,
971+ required this.antical,
972+ required this.antighostism,
973+ required this.arcanum,
974+ required this.autotrophy,
975+ required this.baronial,
976+ required this.caffeine,
977+ required this.gorgoniacean,
978+ required this.heroical,
979+ required this.hydropical,
980+ required this.mechanology,
981+ required this.musicopoetic,
982+ required this.officiality,
983+ required this.oftentimes,
984+ required this.ophthalmotonometer,
985+ required this.reflectively,
986+ required this.springer,
987+ required this.tabasco,
988+ required this.teleianthous,
989+ required this.uncombated,
990+ });
991+
992+ factory Scatty.fromMap(Map<String, dynamic> json) => Scatty(
993+ aeriferous: (json.containsKey("aeriferous") ? json["aeriferous"] : throw FormatException('Missing required property')),
994+ antical: (json.containsKey("antical") ? json["antical"] : throw FormatException('Missing required property')),
995+ antighostism: (json.containsKey("antighostism") ? json["antighostism"] : throw FormatException('Missing required property')),
996+ arcanum: (json.containsKey("arcanum") ? json["arcanum"] : throw FormatException('Missing required property')),
997+ autotrophy: (json.containsKey("autotrophy") ? json["autotrophy"] : throw FormatException('Missing required property')),
998+ baronial: (json.containsKey("baronial") ? json["baronial"] : throw FormatException('Missing required property')),
999+ caffeine: (json.containsKey("caffeine") ? json["caffeine"] : throw FormatException('Missing required property')),
1000+ gorgoniacean: (json.containsKey("gorgoniacean") ? json["gorgoniacean"] : throw FormatException('Missing required property')),
1001+ heroical: (json.containsKey("heroical") ? json["heroical"] : throw FormatException('Missing required property')),
1002+ hydropical: (json.containsKey("hydropical") ? json["hydropical"] : throw FormatException('Missing required property')),
1003+ mechanology: (json.containsKey("mechanology") ? json["mechanology"] : throw FormatException('Missing required property')),
1004+ musicopoetic: (json.containsKey("musicopoetic") ? json["musicopoetic"] : throw FormatException('Missing required property')),
1005+ officiality: (json.containsKey("officiality") ? json["officiality"] : throw FormatException('Missing required property')),
1006+ oftentimes: (json.containsKey("oftentimes") ? json["oftentimes"] : throw FormatException('Missing required property')),
1007+ ophthalmotonometer: (json.containsKey("ophthalmotonometer") ? json["ophthalmotonometer"] : throw FormatException('Missing required property')),
1008+ reflectively: (json.containsKey("reflectively") ? json["reflectively"] : throw FormatException('Missing required property')),
1009+ springer: (json.containsKey("springer") ? json["springer"] : throw FormatException('Missing required property')),
1010+ tabasco: (json.containsKey("Tabasco") ? json["Tabasco"] : throw FormatException('Missing required property')),
1011+ teleianthous: (json.containsKey("teleianthous") ? json["teleianthous"] : throw FormatException('Missing required property')),
1012+ uncombated: (json.containsKey("uncombated") ? json["uncombated"] : throw FormatException('Missing required property')),
1013+ );
1014+
1015+ Map<String, dynamic> toMap() => {
1016+ "aeriferous": aeriferous,
1017+ "antical": antical,
1018+ "antighostism": antighostism,
1019+ "arcanum": arcanum,
1020+ "autotrophy": autotrophy,
1021+ "baronial": baronial,
1022+ "caffeine": caffeine,
1023+ "gorgoniacean": gorgoniacean,
1024+ "heroical": heroical,
1025+ "hydropical": hydropical,
1026+ "mechanology": mechanology,
1027+ "musicopoetic": musicopoetic,
1028+ "officiality": officiality,
1029+ "oftentimes": oftentimes,
1030+ "ophthalmotonometer": ophthalmotonometer,
1031+ "reflectively": reflectively,
1032+ "springer": springer,
1033+ "Tabasco": tabasco,
1034+ "teleianthous": teleianthous,
1035+ "uncombated": uncombated,
1036+ };
1037+}
1038+
1039+class SisteringClass {
1040+ final dynamic amphicarpic;
1041+ final dynamic chianti;
1042+ final dynamic frigorific;
1043+ final dynamic haplomi;
1044+ final dynamic hyperkinesis;
1045+ final dynamic laudable;
1046+ final dynamic madwoman;
1047+ final dynamic maimedly;
1048+ final dynamic micropterygidae;
1049+ final dynamic microrhabdus;
1050+ final dynamic nondense;
1051+ final dynamic phlebemphraxis;
1052+ final dynamic redsear;
1053+ final dynamic schismatical;
1054+ final dynamic tartryl;
1055+ final dynamic unabhorred;
1056+ final dynamic undeliberateness;
1057+ final dynamic unmixable;
1058+ final dynamic untruckling;
1059+ final dynamic vineal;
1060+
1061+ SisteringClass({
1062+ required this.amphicarpic,
1063+ required this.chianti,
1064+ required this.frigorific,
1065+ required this.haplomi,
1066+ required this.hyperkinesis,
1067+ required this.laudable,
1068+ required this.madwoman,
1069+ required this.maimedly,
1070+ required this.micropterygidae,
1071+ required this.microrhabdus,
1072+ required this.nondense,
1073+ required this.phlebemphraxis,
1074+ required this.redsear,
1075+ required this.schismatical,
1076+ required this.tartryl,
1077+ required this.unabhorred,
1078+ required this.undeliberateness,
1079+ required this.unmixable,
1080+ required this.untruckling,
1081+ required this.vineal,
1082+ });
1083+
1084+ factory SisteringClass.fromMap(Map<String, dynamic> json) => SisteringClass(
1085+ amphicarpic: (json.containsKey("amphicarpic") ? json["amphicarpic"] : throw FormatException('Missing required property')),
1086+ chianti: (json.containsKey("Chianti") ? json["Chianti"] : throw FormatException('Missing required property')),
1087+ frigorific: (json.containsKey("frigorific") ? json["frigorific"] : throw FormatException('Missing required property')),
1088+ haplomi: (json.containsKey("Haplomi") ? json["Haplomi"] : throw FormatException('Missing required property')),
1089+ hyperkinesis: (json.containsKey("hyperkinesis") ? json["hyperkinesis"] : throw FormatException('Missing required property')),
1090+ laudable: (json.containsKey("laudable") ? json["laudable"] : throw FormatException('Missing required property')),
1091+ madwoman: (json.containsKey("madwoman") ? json["madwoman"] : throw FormatException('Missing required property')),
1092+ maimedly: (json.containsKey("maimedly") ? json["maimedly"] : throw FormatException('Missing required property')),
1093+ micropterygidae: (json.containsKey("Micropterygidae") ? json["Micropterygidae"] : throw FormatException('Missing required property')),
1094+ microrhabdus: (json.containsKey("microrhabdus") ? json["microrhabdus"] : throw FormatException('Missing required property')),
1095+ nondense: (json.containsKey("nondense") ? json["nondense"] : throw FormatException('Missing required property')),
1096+ phlebemphraxis: (json.containsKey("phlebemphraxis") ? json["phlebemphraxis"] : throw FormatException('Missing required property')),
1097+ redsear: (json.containsKey("redsear") ? json["redsear"] : throw FormatException('Missing required property')),
1098+ schismatical: (json.containsKey("schismatical") ? json["schismatical"] : throw FormatException('Missing required property')),
1099+ tartryl: (json.containsKey("tartryl") ? json["tartryl"] : throw FormatException('Missing required property')),
1100+ unabhorred: (json.containsKey("unabhorred") ? json["unabhorred"] : throw FormatException('Missing required property')),
1101+ undeliberateness: (json.containsKey("undeliberateness") ? json["undeliberateness"] : throw FormatException('Missing required property')),
1102+ unmixable: (json.containsKey("unmixable") ? json["unmixable"] : throw FormatException('Missing required property')),
1103+ untruckling: (json.containsKey("untruckling") ? json["untruckling"] : throw FormatException('Missing required property')),
1104+ vineal: (json.containsKey("vineal") ? json["vineal"] : throw FormatException('Missing required property')),
1105+ );
1106+
1107+ Map<String, dynamic> toMap() => {
1108+ "amphicarpic": amphicarpic,
1109+ "Chianti": chianti,
1110+ "frigorific": frigorific,
1111+ "Haplomi": haplomi,
1112+ "hyperkinesis": hyperkinesis,
1113+ "laudable": laudable,
1114+ "madwoman": madwoman,
1115+ "maimedly": maimedly,
1116+ "Micropterygidae": micropterygidae,
1117+ "microrhabdus": microrhabdus,
1118+ "nondense": nondense,
1119+ "phlebemphraxis": phlebemphraxis,
1120+ "redsear": redsear,
1121+ "schismatical": schismatical,
1122+ "tartryl": tartryl,
1123+ "unabhorred": unabhorred,
1124+ "undeliberateness": undeliberateness,
1125+ "unmixable": unmixable,
1126+ "untruckling": untruckling,
1127+ "vineal": vineal,
1128+ };
1129+}
1130+
1131+class Staghunting {
1132+ final int? calorimetric;
1133+ final int? canid;
1134+ final double? catharticalness;
1135+ final int? chirotherium;
1136+ final String? disdiapason;
1137+ final int? ditriglyphic;
1138+ final int? floriferousness;
1139+ final int? gamelike;
1140+ final int? grig;
1141+ final bool? homocerc;
1142+ final int? interloan;
1143+ final int? lithotomy;
1144+ final int? loric;
1145+ final int? membranocoriaceous;
1146+ final int? membranogenic;
1147+ final dynamic nonbookish;
1148+ final int? overtrump;
1149+ final int? scotino;
1150+ final int? seasonable;
1151+ final int? sephen;
1152+ final int? stigmarioid;
1153+ final int? tired;
1154+ final int? trifid;
1155+ final int? undefeatedly;
1156+ final int? ungirlish;
1157+
1158+ Staghunting({
1159+ this.calorimetric,
1160+ this.canid,
1161+ this.catharticalness,
1162+ this.chirotherium,
1163+ this.disdiapason,
1164+ this.ditriglyphic,
1165+ this.floriferousness,
1166+ this.gamelike,
1167+ this.grig,
1168+ this.homocerc,
1169+ this.interloan,
1170+ this.lithotomy,
1171+ this.loric,
1172+ this.membranocoriaceous,
1173+ this.membranogenic,
1174+ this.nonbookish,
1175+ this.overtrump,
1176+ this.scotino,
1177+ this.seasonable,
1178+ this.sephen,
1179+ this.stigmarioid,
1180+ this.tired,
1181+ this.trifid,
1182+ this.undefeatedly,
1183+ this.ungirlish,
1184+ });
1185+
1186+ factory Staghunting.fromMap(Map<String, dynamic> json) => Staghunting(
1187+ calorimetric: json["calorimetric"],
1188+ canid: json["canid"],
1189+ catharticalness: json["catharticalness"]?.toDouble(),
1190+ chirotherium: json["Chirotherium"],
1191+ disdiapason: json["disdiapason"],
1192+ ditriglyphic: json["ditriglyphic"],
1193+ floriferousness: json["floriferousness"],
1194+ gamelike: json["gamelike"],
1195+ grig: json["grig"],
1196+ homocerc: json["homocerc"],
1197+ interloan: json["interloan"],
1198+ lithotomy: json["lithotomy"],
1199+ loric: json["loric"],
1200+ membranocoriaceous: json["membranocoriaceous"],
1201+ membranogenic: json["membranogenic"],
1202+ nonbookish: json["nonbookish"],
1203+ overtrump: json["overtrump"],
1204+ scotino: json["scotino"],
1205+ seasonable: json["seasonable"],
1206+ sephen: json["sephen"],
1207+ stigmarioid: json["stigmarioid"],
1208+ tired: json["tired"],
1209+ trifid: json["trifid"],
1210+ undefeatedly: json["undefeatedly"],
1211+ ungirlish: json["ungirlish"],
1212+ );
1213+
1214+ Map<String, dynamic> toMap() => {
1215+ "calorimetric": calorimetric,
1216+ "canid": canid,
1217+ "catharticalness": catharticalness,
1218+ "Chirotherium": chirotherium,
1219+ "disdiapason": disdiapason,
1220+ "ditriglyphic": ditriglyphic,
1221+ "floriferousness": floriferousness,
1222+ "gamelike": gamelike,
1223+ "grig": grig,
1224+ "homocerc": homocerc,
1225+ "interloan": interloan,
1226+ "lithotomy": lithotomy,
1227+ "loric": loric,
1228+ "membranocoriaceous": membranocoriaceous,
1229+ "membranogenic": membranogenic,
1230+ "nonbookish": nonbookish,
1231+ "overtrump": overtrump,
1232+ "scotino": scotino,
1233+ "seasonable": seasonable,
1234+ "sephen": sephen,
1235+ "stigmarioid": stigmarioid,
1236+ "tired": tired,
1237+ "trifid": trifid,
1238+ "undefeatedly": undefeatedly,
1239+ "ungirlish": ungirlish,
1240+ };
1241+}
1242+
1243+class StrenuosityClass {
1244+ final int? bliss;
1245+ final int? buccate;
1246+ final int? bulletproof;
1247+ final double? catharticalness;
1248+ final int? chirotherium;
1249+ final int? crumblingness;
1250+ final String? disdiapason;
1251+ final int? engagedly;
1252+ final int? fightable;
1253+ final int? hoariness;
1254+ final bool? homocerc;
1255+ final int? hypopodium;
1256+ final int? luxurist;
1257+ final int? mechanician;
1258+ final dynamic nonbookish;
1259+ final int? onopordon;
1260+ final int? podgily;
1261+ final int? reformableness;
1262+ final int? scatterbrains;
1263+ final int? seminuria;
1264+ final int? sodomite;
1265+ final int? tramp;
1266+ final int? undueness;
1267+ final int? worthily;
1268+ final int? yankeeist;
1269+
1270+ StrenuosityClass({
1271+ this.bliss,
1272+ this.buccate,
1273+ this.bulletproof,
1274+ this.catharticalness,
1275+ this.chirotherium,
1276+ this.crumblingness,
1277+ this.disdiapason,
1278+ this.engagedly,
1279+ this.fightable,
1280+ this.hoariness,
1281+ this.homocerc,
1282+ this.hypopodium,
1283+ this.luxurist,
1284+ this.mechanician,
1285+ this.nonbookish,
1286+ this.onopordon,
1287+ this.podgily,
1288+ this.reformableness,
1289+ this.scatterbrains,
1290+ this.seminuria,
1291+ this.sodomite,
1292+ this.tramp,
1293+ this.undueness,
1294+ this.worthily,
1295+ this.yankeeist,
1296+ });
1297+
1298+ factory StrenuosityClass.fromMap(Map<String, dynamic> json) => StrenuosityClass(
1299+ bliss: json["bliss"],
1300+ buccate: json["buccate"],
1301+ bulletproof: json["bulletproof"],
1302+ catharticalness: json["catharticalness"]?.toDouble(),
1303+ chirotherium: json["Chirotherium"],
1304+ crumblingness: json["crumblingness"],
1305+ disdiapason: json["disdiapason"],
1306+ engagedly: json["engagedly"],
1307+ fightable: json["fightable"],
1308+ hoariness: json["hoariness"],
1309+ homocerc: json["homocerc"],
1310+ hypopodium: json["hypopodium"],
1311+ luxurist: json["luxurist"],
1312+ mechanician: json["mechanician"],
1313+ nonbookish: json["nonbookish"],
1314+ onopordon: json["Onopordon"],
1315+ podgily: json["podgily"],
1316+ reformableness: json["reformableness"],
1317+ scatterbrains: json["scatterbrains"],
1318+ seminuria: json["seminuria"],
1319+ sodomite: json["Sodomite"],
1320+ tramp: json["tramp"],
1321+ undueness: json["undueness"],
1322+ worthily: json["worthily"],
1323+ yankeeist: json["Yankeeist"],
1324+ );
1325+
1326+ Map<String, dynamic> toMap() => {
1327+ "bliss": bliss,
1328+ "buccate": buccate,
1329+ "bulletproof": bulletproof,
1330+ "catharticalness": catharticalness,
1331+ "Chirotherium": chirotherium,
1332+ "crumblingness": crumblingness,
1333+ "disdiapason": disdiapason,
1334+ "engagedly": engagedly,
1335+ "fightable": fightable,
1336+ "hoariness": hoariness,
1337+ "homocerc": homocerc,
1338+ "hypopodium": hypopodium,
1339+ "luxurist": luxurist,
1340+ "mechanician": mechanician,
1341+ "nonbookish": nonbookish,
1342+ "Onopordon": onopordon,
1343+ "podgily": podgily,
1344+ "reformableness": reformableness,
1345+ "scatterbrains": scatterbrains,
1346+ "seminuria": seminuria,
1347+ "Sodomite": sodomite,
1348+ "tramp": tramp,
1349+ "undueness": undueness,
1350+ "worthily": worthily,
1351+ "Yankeeist": yankeeist,
1352+ };
1353+}
1354+
1355+class TruantcyClass {
1356+ final dynamic alfiona;
1357+ final dynamic ascaridiasis;
1358+ final dynamic bungey;
1359+ final double? catharticalness;
1360+ final dynamic ceroxyle;
1361+ final int? chirotherium;
1362+ final dynamic chorology;
1363+ final String? disdiapason;
1364+ final dynamic enmarble;
1365+ final dynamic epeira;
1366+ final dynamic eurylaimi;
1367+ final dynamic germination;
1368+ final dynamic hallelujah;
1369+ final bool? homocerc;
1370+ final dynamic lev;
1371+ final dynamic mouthing;
1372+ final dynamic nonbookish;
1373+ final dynamic philliloo;
1374+ final dynamic planetal;
1375+ final dynamic poney;
1376+ final dynamic punctualist;
1377+ final dynamic returnlessly;
1378+ final dynamic skelder;
1379+ final dynamic windwaywardly;
1380+ final dynamic yuman;
1381+
1382+ TruantcyClass({
1383+ this.alfiona,
1384+ this.ascaridiasis,
1385+ this.bungey,
1386+ this.catharticalness,
1387+ this.ceroxyle,
1388+ this.chirotherium,
1389+ this.chorology,
1390+ this.disdiapason,
1391+ this.enmarble,
1392+ this.epeira,
1393+ this.eurylaimi,
1394+ this.germination,
1395+ this.hallelujah,
1396+ this.homocerc,
1397+ this.lev,
1398+ this.mouthing,
1399+ this.nonbookish,
1400+ this.philliloo,
1401+ this.planetal,
1402+ this.poney,
1403+ this.punctualist,
1404+ this.returnlessly,
1405+ this.skelder,
1406+ this.windwaywardly,
1407+ this.yuman,
1408+ });
1409+
1410+ factory TruantcyClass.fromMap(Map<String, dynamic> json) => TruantcyClass(
1411+ alfiona: json["alfiona"],
1412+ ascaridiasis: json["ascaridiasis"],
1413+ bungey: json["bungey"],
1414+ catharticalness: json["catharticalness"]?.toDouble(),
1415+ ceroxyle: json["ceroxyle"],
1416+ chirotherium: json["Chirotherium"],
1417+ chorology: json["chorology"],
1418+ disdiapason: json["disdiapason"],
1419+ enmarble: json["enmarble"],
1420+ epeira: json["Epeira"],
1421+ eurylaimi: json["Eurylaimi"],
1422+ germination: json["germination"],
1423+ hallelujah: json["hallelujah"],
1424+ homocerc: json["homocerc"],
1425+ lev: json["lev"],
1426+ mouthing: json["mouthing"],
1427+ nonbookish: json["nonbookish"],
1428+ philliloo: json["philliloo"],
1429+ planetal: json["planetal"],
1430+ poney: json["poney"],
1431+ punctualist: json["punctualist"],
1432+ returnlessly: json["returnlessly"],
1433+ skelder: json["skelder"],
1434+ windwaywardly: json["windwaywardly"],
1435+ yuman: json["Yuman"],
1436+ );
1437+
1438+ Map<String, dynamic> toMap() => {
1439+ "alfiona": alfiona,
1440+ "ascaridiasis": ascaridiasis,
1441+ "bungey": bungey,
1442+ "catharticalness": catharticalness,
1443+ "ceroxyle": ceroxyle,
1444+ "Chirotherium": chirotherium,
1445+ "chorology": chorology,
1446+ "disdiapason": disdiapason,
1447+ "enmarble": enmarble,
1448+ "Epeira": epeira,
1449+ "Eurylaimi": eurylaimi,
1450+ "germination": germination,
1451+ "hallelujah": hallelujah,
1452+ "homocerc": homocerc,
1453+ "lev": lev,
1454+ "mouthing": mouthing,
1455+ "nonbookish": nonbookish,
1456+ "philliloo": philliloo,
1457+ "planetal": planetal,
1458+ "poney": poney,
1459+ "punctualist": punctualist,
1460+ "returnlessly": returnlessly,
1461+ "skelder": skelder,
1462+ "windwaywardly": windwaywardly,
1463+ "Yuman": yuman,
1464+ };
1465+}
1466+
1467+class UnimpeachablyClass {
1468+ final int? acerin;
1469+ final int? bobadil;
1470+ final double? catharticalness;
1471+ final int? chirotherium;
1472+ final int? chlorophylligenous;
1473+ final int? conversational;
1474+ final int? demiowl;
1475+ final String? disdiapason;
1476+ final int? ectorhinal;
1477+ final int? gamblesomeness;
1478+ final bool? homocerc;
1479+ final int? irrorate;
1480+ final int? kindergartening;
1481+ final int? lateritic;
1482+ final int? mespil;
1483+ final int? misconfiguration;
1484+ final dynamic nonbookish;
1485+ final int? planometry;
1486+ final int? quiina;
1487+ final int? robert;
1488+ final int? rot;
1489+ final int? subcinctorium;
1490+ final int? tussocker;
1491+ final int? ultraproud;
1492+ final int? unsuggestedness;
1493+
1494+ UnimpeachablyClass({
1495+ this.acerin,
1496+ this.bobadil,
1497+ this.catharticalness,
1498+ this.chirotherium,
1499+ this.chlorophylligenous,
1500+ this.conversational,
1501+ this.demiowl,
1502+ this.disdiapason,
1503+ this.ectorhinal,
1504+ this.gamblesomeness,
1505+ this.homocerc,
1506+ this.irrorate,
1507+ this.kindergartening,
1508+ this.lateritic,
1509+ this.mespil,
1510+ this.misconfiguration,
1511+ this.nonbookish,
1512+ this.planometry,
1513+ this.quiina,
1514+ this.robert,
1515+ this.rot,
1516+ this.subcinctorium,
1517+ this.tussocker,
1518+ this.ultraproud,
1519+ this.unsuggestedness,
1520+ });
1521+
1522+ factory UnimpeachablyClass.fromMap(Map<String, dynamic> json) => UnimpeachablyClass(
1523+ acerin: json["acerin"],
1524+ bobadil: json["Bobadil"],
1525+ catharticalness: json["catharticalness"]?.toDouble(),
1526+ chirotherium: json["Chirotherium"],
1527+ chlorophylligenous: json["chlorophylligenous"],
1528+ conversational: json["conversational"],
1529+ demiowl: json["demiowl"],
1530+ disdiapason: json["disdiapason"],
1531+ ectorhinal: json["ectorhinal"],
1532+ gamblesomeness: json["gamblesomeness"],
1533+ homocerc: json["homocerc"],
1534+ irrorate: json["irrorate"],
1535+ kindergartening: json["kindergartening"],
1536+ lateritic: json["lateritic"],
1537+ mespil: json["mespil"],
1538+ misconfiguration: json["misconfiguration"],
1539+ nonbookish: json["nonbookish"],
1540+ planometry: json["planometry"],
1541+ quiina: json["Quiina"],
1542+ robert: json["Robert"],
1543+ rot: json["rot"],
1544+ subcinctorium: json["subcinctorium"],
1545+ tussocker: json["tussocker"],
1546+ ultraproud: json["ultraproud"],
1547+ unsuggestedness: json["unsuggestedness"],
1548+ );
1549+
1550+ Map<String, dynamic> toMap() => {
1551+ "acerin": acerin,
1552+ "Bobadil": bobadil,
1553+ "catharticalness": catharticalness,
1554+ "Chirotherium": chirotherium,
1555+ "chlorophylligenous": chlorophylligenous,
1556+ "conversational": conversational,
1557+ "demiowl": demiowl,
1558+ "disdiapason": disdiapason,
1559+ "ectorhinal": ectorhinal,
1560+ "gamblesomeness": gamblesomeness,
1561+ "homocerc": homocerc,
1562+ "irrorate": irrorate,
1563+ "kindergartening": kindergartening,
1564+ "lateritic": lateritic,
1565+ "mespil": mespil,
1566+ "misconfiguration": misconfiguration,
1567+ "nonbookish": nonbookish,
1568+ "planometry": planometry,
1569+ "Quiina": quiina,
1570+ "Robert": robert,
1571+ "rot": rot,
1572+ "subcinctorium": subcinctorium,
1573+ "tussocker": tussocker,
1574+ "ultraproud": ultraproud,
1575+ "unsuggestedness": unsuggestedness,
1576+ };
1577+}
1578+
1579+class UnstressedClass {
1580+ final dynamic alain;
1581+ final dynamic amphirhina;
1582+ final dynamic antimachinery;
1583+ final dynamic coldish;
1584+ final dynamic crantara;
1585+ final dynamic distinguishing;
1586+ final dynamic elytroposis;
1587+ final dynamic gentianwort;
1588+ final dynamic heliosis;
1589+ final dynamic instrumental;
1590+ final dynamic introinflection;
1591+ final dynamic kala;
1592+ final dynamic lincolnian;
1593+ final dynamic metad;
1594+ final dynamic sarcophilus;
1595+ final dynamic swingingly;
1596+ final dynamic unconformity;
1597+ final dynamic undecreed;
1598+ final dynamic venerable;
1599+ final dynamic vowellessness;
1600+
1601+ UnstressedClass({
1602+ required this.alain,
1603+ required this.amphirhina,
1604+ required this.antimachinery,
1605+ required this.coldish,
1606+ required this.crantara,
1607+ required this.distinguishing,
1608+ required this.elytroposis,
1609+ required this.gentianwort,
1610+ required this.heliosis,
1611+ required this.instrumental,
1612+ required this.introinflection,
1613+ required this.kala,
1614+ required this.lincolnian,
1615+ required this.metad,
1616+ required this.sarcophilus,
1617+ required this.swingingly,
1618+ required this.unconformity,
1619+ required this.undecreed,
1620+ required this.venerable,
1621+ required this.vowellessness,
1622+ });
1623+
1624+ factory UnstressedClass.fromMap(Map<String, dynamic> json) => UnstressedClass(
1625+ alain: (json.containsKey("Alain") ? json["Alain"] : throw FormatException('Missing required property')),
1626+ amphirhina: (json.containsKey("Amphirhina") ? json["Amphirhina"] : throw FormatException('Missing required property')),
1627+ antimachinery: (json.containsKey("antimachinery") ? json["antimachinery"] : throw FormatException('Missing required property')),
1628+ coldish: (json.containsKey("coldish") ? json["coldish"] : throw FormatException('Missing required property')),
1629+ crantara: (json.containsKey("crantara") ? json["crantara"] : throw FormatException('Missing required property')),
1630+ distinguishing: (json.containsKey("distinguishing") ? json["distinguishing"] : throw FormatException('Missing required property')),
1631+ elytroposis: (json.containsKey("elytroposis") ? json["elytroposis"] : throw FormatException('Missing required property')),
1632+ gentianwort: (json.containsKey("gentianwort") ? json["gentianwort"] : throw FormatException('Missing required property')),
1633+ heliosis: (json.containsKey("heliosis") ? json["heliosis"] : throw FormatException('Missing required property')),
1634+ instrumental: (json.containsKey("instrumental") ? json["instrumental"] : throw FormatException('Missing required property')),
1635+ introinflection: (json.containsKey("introinflection") ? json["introinflection"] : throw FormatException('Missing required property')),
1636+ kala: (json.containsKey("kala") ? json["kala"] : throw FormatException('Missing required property')),
1637+ lincolnian: (json.containsKey("Lincolnian") ? json["Lincolnian"] : throw FormatException('Missing required property')),
1638+ metad: (json.containsKey("metad") ? json["metad"] : throw FormatException('Missing required property')),
1639+ sarcophilus: (json.containsKey("Sarcophilus") ? json["Sarcophilus"] : throw FormatException('Missing required property')),
1640+ swingingly: (json.containsKey("swingingly") ? json["swingingly"] : throw FormatException('Missing required property')),
1641+ unconformity: (json.containsKey("unconformity") ? json["unconformity"] : throw FormatException('Missing required property')),
1642+ undecreed: (json.containsKey("undecreed") ? json["undecreed"] : throw FormatException('Missing required property')),
1643+ venerable: (json.containsKey("venerable") ? json["venerable"] : throw FormatException('Missing required property')),
1644+ vowellessness: (json.containsKey("vowellessness") ? json["vowellessness"] : throw FormatException('Missing required property')),
1645+ );
1646+
1647+ Map<String, dynamic> toMap() => {
1648+ "Alain": alain,
1649+ "Amphirhina": amphirhina,
1650+ "antimachinery": antimachinery,
1651+ "coldish": coldish,
1652+ "crantara": crantara,
1653+ "distinguishing": distinguishing,
1654+ "elytroposis": elytroposis,
1655+ "gentianwort": gentianwort,
1656+ "heliosis": heliosis,
1657+ "instrumental": instrumental,
1658+ "introinflection": introinflection,
1659+ "kala": kala,
1660+ "Lincolnian": lincolnian,
1661+ "metad": metad,
1662+ "Sarcophilus": sarcophilus,
1663+ "swingingly": swingingly,
1664+ "unconformity": unconformity,
1665+ "undecreed": undecreed,
1666+ "venerable": venerable,
1667+ "vowellessness": vowellessness,
1668+ };
1669+}
1670+
1671+class WrothyClass {
1672+ final dynamic aeschynanthus;
1673+ final dynamic aquiferous;
1674+ final dynamic cheapener;
1675+ final dynamic enumeration;
1676+ final dynamic ephesine;
1677+ final dynamic escadrille;
1678+ final dynamic estrous;
1679+ final dynamic interestedly;
1680+ final dynamic katakinetomer;
1681+ final dynamic mortification;
1682+ final dynamic morula;
1683+ final dynamic orthosymmetrical;
1684+ final dynamic overbark;
1685+ final dynamic politist;
1686+ final dynamic qualified;
1687+ final dynamic sphenomalar;
1688+ final dynamic throatful;
1689+ final dynamic transhumance;
1690+ final dynamic triandrian;
1691+ final dynamic unbooked;
1692+
1693+ WrothyClass({
1694+ required this.aeschynanthus,
1695+ required this.aquiferous,
1696+ required this.cheapener,
1697+ required this.enumeration,
1698+ required this.ephesine,
1699+ required this.escadrille,
1700+ required this.estrous,
1701+ required this.interestedly,
1702+ required this.katakinetomer,
1703+ required this.mortification,
1704+ required this.morula,
1705+ required this.orthosymmetrical,
1706+ required this.overbark,
1707+ required this.politist,
1708+ required this.qualified,
1709+ required this.sphenomalar,
1710+ required this.throatful,
1711+ required this.transhumance,
1712+ required this.triandrian,
1713+ required this.unbooked,
1714+ });
1715+
1716+ factory WrothyClass.fromMap(Map<String, dynamic> json) => WrothyClass(
1717+ aeschynanthus: (json.containsKey("Aeschynanthus") ? json["Aeschynanthus"] : throw FormatException('Missing required property')),
1718+ aquiferous: (json.containsKey("aquiferous") ? json["aquiferous"] : throw FormatException('Missing required property')),
1719+ cheapener: (json.containsKey("cheapener") ? json["cheapener"] : throw FormatException('Missing required property')),
1720+ enumeration: (json.containsKey("enumeration") ? json["enumeration"] : throw FormatException('Missing required property')),
1721+ ephesine: (json.containsKey("Ephesine") ? json["Ephesine"] : throw FormatException('Missing required property')),
1722+ escadrille: (json.containsKey("escadrille") ? json["escadrille"] : throw FormatException('Missing required property')),
1723+ estrous: (json.containsKey("estrous") ? json["estrous"] : throw FormatException('Missing required property')),
1724+ interestedly: (json.containsKey("interestedly") ? json["interestedly"] : throw FormatException('Missing required property')),
1725+ katakinetomer: (json.containsKey("katakinetomer") ? json["katakinetomer"] : throw FormatException('Missing required property')),
1726+ mortification: (json.containsKey("mortification") ? json["mortification"] : throw FormatException('Missing required property')),
1727+ morula: (json.containsKey("morula") ? json["morula"] : throw FormatException('Missing required property')),
1728+ orthosymmetrical: (json.containsKey("orthosymmetrical") ? json["orthosymmetrical"] : throw FormatException('Missing required property')),
1729+ overbark: (json.containsKey("overbark") ? json["overbark"] : throw FormatException('Missing required property')),
1730+ politist: (json.containsKey("politist") ? json["politist"] : throw FormatException('Missing required property')),
1731+ qualified: (json.containsKey("qualified") ? json["qualified"] : throw FormatException('Missing required property')),
1732+ sphenomalar: (json.containsKey("sphenomalar") ? json["sphenomalar"] : throw FormatException('Missing required property')),
1733+ throatful: (json.containsKey("throatful") ? json["throatful"] : throw FormatException('Missing required property')),
1734+ transhumance: (json.containsKey("transhumance") ? json["transhumance"] : throw FormatException('Missing required property')),
1735+ triandrian: (json.containsKey("triandrian") ? json["triandrian"] : throw FormatException('Missing required property')),
1736+ unbooked: (json.containsKey("unbooked") ? json["unbooked"] : throw FormatException('Missing required property')),
1737+ );
1738+
1739+ Map<String, dynamic> toMap() => {
1740+ "Aeschynanthus": aeschynanthus,
1741+ "aquiferous": aquiferous,
1742+ "cheapener": cheapener,
1743+ "enumeration": enumeration,
1744+ "Ephesine": ephesine,
1745+ "escadrille": escadrille,
1746+ "estrous": estrous,
1747+ "interestedly": interestedly,
1748+ "katakinetomer": katakinetomer,
1749+ "mortification": mortification,
1750+ "morula": morula,
1751+ "orthosymmetrical": orthosymmetrical,
1752+ "overbark": overbark,
1753+ "politist": politist,
1754+ "qualified": qualified,
1755+ "sphenomalar": sphenomalar,
1756+ "throatful": throatful,
1757+ "transhumance": transhumance,
1758+ "triandrian": triandrian,
1759+ "unbooked": unbooked,
1760+ };
1761+}
Aswiftfinal-classes-true__struct-or-class-class--d3c62ec7414d / quicktype.swift+4,096 −0
@@ -0,0 +1,4096 @@
1+// This file was generated from JSON Schema using quicktype, do not modify it directly.
2+// To parse the JSON, add this file to your project and do:
3+//
4+// let topLevel = try TopLevel(json)
5+
6+import Foundation
7+
8+// MARK: - TopLevel
9+final class TopLevel: Codable {
10+ let protrusive: [Protrusive]
11+ let pulpitism: [PulpitismElement]
12+ let pyodermia: [PyodermiaElement]
13+ let quebrachine: [QuebrachineElement]
14+ let querier: [Querier]
15+ let rebarbative: [Rebarbative]
16+ let reimagine: [Reimagine]
17+ let ressaut: Ressaut
18+ let retrocervical: [Retrocervical]
19+ let revert: [Revert]
20+ let rewrite: [RewriteElement]
21+ let saccoderm: [Saccoderm]
22+ let santir: [SantirElement]
23+ let saprophilous: [Saprophilous]
24+ let saxten: [SaxtenElement]
25+ let scatty: [Scatty?]
26+ let scoffer: [Scoffer]
27+ let scrampum: [Scrampum]
28+ let semantic: Double
29+ let serpentinic: [Serpentinic]
30+ let shadowable: [Shadowable]
31+ let sistering: [SisteringElement]
32+ let staghunting: [Staghunting]
33+ let stagmometer: [Stagmometer]
34+ let stimulability: [Stimulability]
35+ let strangleable: [Strangleable]
36+ let strenuosity: [StrenuosityElement]
37+ let tabaxir: [Tabaxir]
38+ let talpiform: [Talpiform]
39+ let thwack: [Thwack]
40+ let to: [Double?]
41+ let tortricine: [Tortricine]
42+ let truantcy: [TruantcyElement]
43+ let turgesce: [String]
44+ let unbeginning: [Unbeginning]
45+ let underdunged: [Double]
46+ let undesirability: [Undesirability]
47+ let unerasing: [Unerasing]
48+ let unguentarium: [Unguentarium]
49+ let unimpeachably: [UnimpeachablyElement]
50+ let unmortgaged: [Unmortgaged]
51+ let unobstructed: [Unobstructed]
52+ let unreceptivity: [Unreceptivity]
53+ let unsatisfactoriness: [Unsatisfactoriness]
54+ let unsecurity: [Int]
55+ let unstressed: [UnstressedElement]
56+ let untasked: [Untasked]
57+ let unvarying: [Unvarying]
58+ let vehemently: [Vehemently]
59+ let warriorship: [String: Bool]
60+ let whitepot: [Whitepot]
61+ let wrothy: [WrothyElement]
62+
63+ enum CodingKeys: String, CodingKey {
64+ case protrusive = "protrusive"
65+ case pulpitism = "pulpitism"
66+ case pyodermia = "pyodermia"
67+ case quebrachine = "quebrachine"
68+ case querier = "querier"
69+ case rebarbative = "rebarbative"
70+ case reimagine = "reimagine"
71+ case ressaut = "ressaut"
72+ case retrocervical = "retrocervical"
73+ case revert = "revert"
74+ case rewrite = "rewrite"
75+ case saccoderm = "saccoderm"
76+ case santir = "santir"
77+ case saprophilous = "saprophilous"
78+ case saxten = "saxten"
79+ case scatty = "scatty"
80+ case scoffer = "scoffer"
81+ case scrampum = "scrampum"
82+ case semantic = "semantic"
83+ case serpentinic = "serpentinic"
84+ case shadowable = "shadowable"
85+ case sistering = "sistering"
86+ case staghunting = "staghunting"
87+ case stagmometer = "stagmometer"
88+ case stimulability = "stimulability"
89+ case strangleable = "strangleable"
90+ case strenuosity = "strenuosity"
91+ case tabaxir = "tabaxir"
92+ case talpiform = "talpiform"
93+ case thwack = "thwack"
94+ case to = "to"
95+ case tortricine = "tortricine"
96+ case truantcy = "truantcy"
97+ case turgesce = "turgesce"
98+ case unbeginning = "unbeginning"
99+ case underdunged = "underdunged"
100+ case undesirability = "undesirability"
101+ case unerasing = "unerasing"
102+ case unguentarium = "unguentarium"
103+ case unimpeachably = "unimpeachably"
104+ case unmortgaged = "unmortgaged"
105+ case unobstructed = "unobstructed"
106+ case unreceptivity = "unreceptivity"
107+ case unsatisfactoriness = "unsatisfactoriness"
108+ case unsecurity = "unsecurity"
109+ case unstressed = "unstressed"
110+ case untasked = "untasked"
111+ case unvarying = "unvarying"
112+ case vehemently = "vehemently"
113+ case warriorship = "warriorship"
114+ case whitepot = "whitepot"
115+ case wrothy = "wrothy"
116+ }
117+
118+ 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]) {
119+ self.protrusive = protrusive
120+ self.pulpitism = pulpitism
121+ self.pyodermia = pyodermia
122+ self.quebrachine = quebrachine
123+ self.querier = querier
124+ self.rebarbative = rebarbative
125+ self.reimagine = reimagine
126+ self.ressaut = ressaut
127+ self.retrocervical = retrocervical
128+ self.revert = revert
129+ self.rewrite = rewrite
130+ self.saccoderm = saccoderm
131+ self.santir = santir
132+ self.saprophilous = saprophilous
133+ self.saxten = saxten
134+ self.scatty = scatty
135+ self.scoffer = scoffer
136+ self.scrampum = scrampum
137+ self.semantic = semantic
138+ self.serpentinic = serpentinic
139+ self.shadowable = shadowable
140+ self.sistering = sistering
141+ self.staghunting = staghunting
142+ self.stagmometer = stagmometer
143+ self.stimulability = stimulability
144+ self.strangleable = strangleable
145+ self.strenuosity = strenuosity
146+ self.tabaxir = tabaxir
147+ self.talpiform = talpiform
148+ self.thwack = thwack
149+ self.to = to
150+ self.tortricine = tortricine
151+ self.truantcy = truantcy
152+ self.turgesce = turgesce
153+ self.unbeginning = unbeginning
154+ self.underdunged = underdunged
155+ self.undesirability = undesirability
156+ self.unerasing = unerasing
157+ self.unguentarium = unguentarium
158+ self.unimpeachably = unimpeachably
159+ self.unmortgaged = unmortgaged
160+ self.unobstructed = unobstructed
161+ self.unreceptivity = unreceptivity
162+ self.unsatisfactoriness = unsatisfactoriness
163+ self.unsecurity = unsecurity
164+ self.unstressed = unstressed
165+ self.untasked = untasked
166+ self.unvarying = unvarying
167+ self.vehemently = vehemently
168+ self.warriorship = warriorship
169+ self.whitepot = whitepot
170+ self.wrothy = wrothy
171+ }
172+}
173+
174+// MARK: TopLevel convenience initializers and mutators
175+
176+extension TopLevel {
177+ convenience init(data: Data) throws {
178+ let me = try newJSONDecoder().decode(TopLevel.self, from: data)
179+ 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)
180+ }
181+
182+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
183+ guard let data = json.data(using: encoding) else {
184+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
185+ }
186+ try self.init(data: data)
187+ }
188+
189+ convenience init(fromURL url: URL) throws {
190+ try self.init(data: try Data(contentsOf: url))
191+ }
192+
193+ func with(
194+ protrusive: [Protrusive]? = nil,
195+ pulpitism: [PulpitismElement]? = nil,
196+ pyodermia: [PyodermiaElement]? = nil,
197+ quebrachine: [QuebrachineElement]? = nil,
198+ querier: [Querier]? = nil,
199+ rebarbative: [Rebarbative]? = nil,
200+ reimagine: [Reimagine]? = nil,
201+ ressaut: Ressaut? = nil,
202+ retrocervical: [Retrocervical]? = nil,
203+ revert: [Revert]? = nil,
204+ rewrite: [RewriteElement]? = nil,
205+ saccoderm: [Saccoderm]? = nil,
206+ santir: [SantirElement]? = nil,
207+ saprophilous: [Saprophilous]? = nil,
208+ saxten: [SaxtenElement]? = nil,
209+ scatty: [Scatty?]? = nil,
210+ scoffer: [Scoffer]? = nil,
211+ scrampum: [Scrampum]? = nil,
212+ semantic: Double? = nil,
213+ serpentinic: [Serpentinic]? = nil,
214+ shadowable: [Shadowable]? = nil,
215+ sistering: [SisteringElement]? = nil,
216+ staghunting: [Staghunting]? = nil,
217+ stagmometer: [Stagmometer]? = nil,
218+ stimulability: [Stimulability]? = nil,
219+ strangleable: [Strangleable]? = nil,
220+ strenuosity: [StrenuosityElement]? = nil,
221+ tabaxir: [Tabaxir]? = nil,
222+ talpiform: [Talpiform]? = nil,
223+ thwack: [Thwack]? = nil,
224+ to: [Double?]? = nil,
225+ tortricine: [Tortricine]? = nil,
226+ truantcy: [TruantcyElement]? = nil,
227+ turgesce: [String]? = nil,
228+ unbeginning: [Unbeginning]? = nil,
229+ underdunged: [Double]? = nil,
230+ undesirability: [Undesirability]? = nil,
231+ unerasing: [Unerasing]? = nil,
232+ unguentarium: [Unguentarium]? = nil,
233+ unimpeachably: [UnimpeachablyElement]? = nil,
234+ unmortgaged: [Unmortgaged]? = nil,
235+ unobstructed: [Unobstructed]? = nil,
236+ unreceptivity: [Unreceptivity]? = nil,
237+ unsatisfactoriness: [Unsatisfactoriness]? = nil,
238+ unsecurity: [Int]? = nil,
239+ unstressed: [UnstressedElement]? = nil,
240+ untasked: [Untasked]? = nil,
241+ unvarying: [Unvarying]? = nil,
242+ vehemently: [Vehemently]? = nil,
243+ warriorship: [String: Bool]? = nil,
244+ whitepot: [Whitepot]? = nil,
245+ wrothy: [WrothyElement]? = nil
246+ ) -> TopLevel {
247+ return TopLevel(
248+ protrusive: protrusive ?? self.protrusive,
249+ pulpitism: pulpitism ?? self.pulpitism,
250+ pyodermia: pyodermia ?? self.pyodermia,
251+ quebrachine: quebrachine ?? self.quebrachine,
252+ querier: querier ?? self.querier,
253+ rebarbative: rebarbative ?? self.rebarbative,
254+ reimagine: reimagine ?? self.reimagine,
255+ ressaut: ressaut ?? self.ressaut,
256+ retrocervical: retrocervical ?? self.retrocervical,
257+ revert: revert ?? self.revert,
258+ rewrite: rewrite ?? self.rewrite,
259+ saccoderm: saccoderm ?? self.saccoderm,
260+ santir: santir ?? self.santir,
261+ saprophilous: saprophilous ?? self.saprophilous,
262+ saxten: saxten ?? self.saxten,
263+ scatty: scatty ?? self.scatty,
264+ scoffer: scoffer ?? self.scoffer,
265+ scrampum: scrampum ?? self.scrampum,
266+ semantic: semantic ?? self.semantic,
267+ serpentinic: serpentinic ?? self.serpentinic,
268+ shadowable: shadowable ?? self.shadowable,
269+ sistering: sistering ?? self.sistering,
270+ staghunting: staghunting ?? self.staghunting,
271+ stagmometer: stagmometer ?? self.stagmometer,
272+ stimulability: stimulability ?? self.stimulability,
273+ strangleable: strangleable ?? self.strangleable,
274+ strenuosity: strenuosity ?? self.strenuosity,
275+ tabaxir: tabaxir ?? self.tabaxir,
276+ talpiform: talpiform ?? self.talpiform,
277+ thwack: thwack ?? self.thwack,
278+ to: to ?? self.to,
279+ tortricine: tortricine ?? self.tortricine,
280+ truantcy: truantcy ?? self.truantcy,
281+ turgesce: turgesce ?? self.turgesce,
282+ unbeginning: unbeginning ?? self.unbeginning,
283+ underdunged: underdunged ?? self.underdunged,
284+ undesirability: undesirability ?? self.undesirability,
285+ unerasing: unerasing ?? self.unerasing,
286+ unguentarium: unguentarium ?? self.unguentarium,
287+ unimpeachably: unimpeachably ?? self.unimpeachably,
288+ unmortgaged: unmortgaged ?? self.unmortgaged,
289+ unobstructed: unobstructed ?? self.unobstructed,
290+ unreceptivity: unreceptivity ?? self.unreceptivity,
291+ unsatisfactoriness: unsatisfactoriness ?? self.unsatisfactoriness,
292+ unsecurity: unsecurity ?? self.unsecurity,
293+ unstressed: unstressed ?? self.unstressed,
294+ untasked: untasked ?? self.untasked,
295+ unvarying: unvarying ?? self.unvarying,
296+ vehemently: vehemently ?? self.vehemently,
297+ warriorship: warriorship ?? self.warriorship,
298+ whitepot: whitepot ?? self.whitepot,
299+ wrothy: wrothy ?? self.wrothy
300+ )
301+ }
302+
303+ func jsonData() throws -> Data {
304+ return try newJSONEncoder().encode(self)
305+ }
306+
307+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
308+ return String(data: try self.jsonData(), encoding: encoding)
309+ }
310+}
311+
312+enum Protrusive: Codable {
313+ case double(Double)
314+ case unionArray([Int?])
315+
316+ init(from decoder: Decoder) throws {
317+ let container = try decoder.singleValueContainer()
318+ if let x = try? container.decode([Int?].self) {
319+ self = .unionArray(x)
320+ return
321+ }
322+ if let x = try? container.decode(Double.self) {
323+ self = .double(x)
324+ return
325+ }
326+ throw DecodingError.typeMismatch(Protrusive.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Protrusive"))
327+ }
328+
329+ func encode(to encoder: Encoder) throws {
330+ var container = encoder.singleValueContainer()
331+ switch self {
332+ case .double(let x):
333+ try container.encode(x)
334+ case .unionArray(let x):
335+ try container.encode(x)
336+ }
337+ }
338+}
339+
340+enum PulpitismElement: Codable {
341+ case double(Double)
342+ case integerArray([Int])
343+ case pulpitismClass(PulpitismClass)
344+
345+ init(from decoder: Decoder) throws {
346+ let container = try decoder.singleValueContainer()
347+ if let x = try? container.decode([Int].self) {
348+ self = .integerArray(x)
349+ return
350+ }
351+ if let x = try? container.decode(Double.self) {
352+ self = .double(x)
353+ return
354+ }
355+ if let x = try? container.decode(PulpitismClass.self) {
356+ self = .pulpitismClass(x)
357+ return
358+ }
359+ throw DecodingError.typeMismatch(PulpitismElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PulpitismElement"))
360+ }
361+
362+ func encode(to encoder: Encoder) throws {
363+ var container = encoder.singleValueContainer()
364+ switch self {
365+ case .double(let x):
366+ try container.encode(x)
367+ case .integerArray(let x):
368+ try container.encode(x)
369+ case .pulpitismClass(let x):
370+ try container.encode(x)
371+ }
372+ }
373+}
374+
375+// MARK: - PulpitismClass
376+final class PulpitismClass: Codable {
377+ let abnet: JSONNull?
378+ let buckhorn: JSONNull?
379+ let calciform: JSONNull?
380+ let chelophore: JSONNull?
381+ let cogitation: JSONNull?
382+ let decreeable: JSONNull?
383+ let despicable: JSONNull?
384+ let isodiazo: JSONNull?
385+ let jadedly: JSONNull?
386+ let leptochlorite: JSONNull?
387+ let nursling: JSONNull?
388+ let palamedean: JSONNull?
389+ let photoheliograph: JSONNull?
390+ let pipewood: JSONNull?
391+ let roberd: JSONNull?
392+ let statable: JSONNull?
393+ let superassume: JSONNull?
394+ let syllabe: JSONNull?
395+ let toughhead: JSONNull?
396+ let underburn: JSONNull?
397+
398+ enum CodingKeys: String, CodingKey {
399+ case abnet = "abnet"
400+ case buckhorn = "buckhorn"
401+ case calciform = "calciform"
402+ case chelophore = "chelophore"
403+ case cogitation = "cogitation"
404+ case decreeable = "decreeable"
405+ case despicable = "despicable"
406+ case isodiazo = "isodiazo"
407+ case jadedly = "jadedly"
408+ case leptochlorite = "leptochlorite"
409+ case nursling = "nursling"
410+ case palamedean = "palamedean"
411+ case photoheliograph = "photoheliograph"
412+ case pipewood = "pipewood"
413+ case roberd = "roberd"
414+ case statable = "statable"
415+ case superassume = "superassume"
416+ case syllabe = "syllabe"
417+ case toughhead = "toughhead"
418+ case underburn = "underburn"
419+ }
420+
421+ 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?) {
422+ self.abnet = abnet
423+ self.buckhorn = buckhorn
424+ self.calciform = calciform
425+ self.chelophore = chelophore
426+ self.cogitation = cogitation
427+ self.decreeable = decreeable
428+ self.despicable = despicable
429+ self.isodiazo = isodiazo
430+ self.jadedly = jadedly
431+ self.leptochlorite = leptochlorite
432+ self.nursling = nursling
433+ self.palamedean = palamedean
434+ self.photoheliograph = photoheliograph
435+ self.pipewood = pipewood
436+ self.roberd = roberd
437+ self.statable = statable
438+ self.superassume = superassume
439+ self.syllabe = syllabe
440+ self.toughhead = toughhead
441+ self.underburn = underburn
442+ }
443+}
444+
445+// MARK: PulpitismClass convenience initializers and mutators
446+
447+extension PulpitismClass {
448+ convenience init(data: Data) throws {
449+ let me = try newJSONDecoder().decode(PulpitismClass.self, from: data)
450+ 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)
451+ }
452+
453+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
454+ guard let data = json.data(using: encoding) else {
455+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
456+ }
457+ try self.init(data: data)
458+ }
459+
460+ convenience init(fromURL url: URL) throws {
461+ try self.init(data: try Data(contentsOf: url))
462+ }
463+
464+ func with(
465+ abnet: JSONNull?? = nil,
466+ buckhorn: JSONNull?? = nil,
467+ calciform: JSONNull?? = nil,
468+ chelophore: JSONNull?? = nil,
469+ cogitation: JSONNull?? = nil,
470+ decreeable: JSONNull?? = nil,
471+ despicable: JSONNull?? = nil,
472+ isodiazo: JSONNull?? = nil,
473+ jadedly: JSONNull?? = nil,
474+ leptochlorite: JSONNull?? = nil,
475+ nursling: JSONNull?? = nil,
476+ palamedean: JSONNull?? = nil,
477+ photoheliograph: JSONNull?? = nil,
478+ pipewood: JSONNull?? = nil,
479+ roberd: JSONNull?? = nil,
480+ statable: JSONNull?? = nil,
481+ superassume: JSONNull?? = nil,
482+ syllabe: JSONNull?? = nil,
483+ toughhead: JSONNull?? = nil,
484+ underburn: JSONNull?? = nil
485+ ) -> PulpitismClass {
486+ return PulpitismClass(
487+ abnet: abnet ?? self.abnet,
488+ buckhorn: buckhorn ?? self.buckhorn,
489+ calciform: calciform ?? self.calciform,
490+ chelophore: chelophore ?? self.chelophore,
491+ cogitation: cogitation ?? self.cogitation,
492+ decreeable: decreeable ?? self.decreeable,
493+ despicable: despicable ?? self.despicable,
494+ isodiazo: isodiazo ?? self.isodiazo,
495+ jadedly: jadedly ?? self.jadedly,
496+ leptochlorite: leptochlorite ?? self.leptochlorite,
497+ nursling: nursling ?? self.nursling,
498+ palamedean: palamedean ?? self.palamedean,
499+ photoheliograph: photoheliograph ?? self.photoheliograph,
500+ pipewood: pipewood ?? self.pipewood,
501+ roberd: roberd ?? self.roberd,
502+ statable: statable ?? self.statable,
503+ superassume: superassume ?? self.superassume,
504+ syllabe: syllabe ?? self.syllabe,
505+ toughhead: toughhead ?? self.toughhead,
506+ underburn: underburn ?? self.underburn
507+ )
508+ }
509+
510+ func jsonData() throws -> Data {
511+ return try newJSONEncoder().encode(self)
512+ }
513+
514+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
515+ return String(data: try self.jsonData(), encoding: encoding)
516+ }
517+}
518+
519+enum PyodermiaElement: Codable {
520+ case integer(Int)
521+ case pyodermiaClass(PyodermiaClass)
522+
523+ init(from decoder: Decoder) throws {
524+ let container = try decoder.singleValueContainer()
525+ if let x = try? container.decode(Int.self) {
526+ self = .integer(x)
527+ return
528+ }
529+ if let x = try? container.decode(PyodermiaClass.self) {
530+ self = .pyodermiaClass(x)
531+ return
532+ }
533+ throw DecodingError.typeMismatch(PyodermiaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PyodermiaElement"))
534+ }
535+
536+ func encode(to encoder: Encoder) throws {
537+ var container = encoder.singleValueContainer()
538+ switch self {
539+ case .integer(let x):
540+ try container.encode(x)
541+ case .pyodermiaClass(let x):
542+ try container.encode(x)
543+ }
544+ }
545+}
546+
547+// MARK: - PyodermiaClass
548+final class PyodermiaClass: Codable {
549+ let aphoristically: JSONNull?
550+ let apophyllous: JSONNull?
551+ let cognize: JSONNull?
552+ let dermonosology: JSONNull?
553+ let gyppo: JSONNull?
554+ let ither: JSONNull?
555+ let juglandaceous: JSONNull?
556+ let litho: JSONNull?
557+ let macropterous: JSONNull?
558+ let photographer: JSONNull?
559+ let romancing: JSONNull?
560+ let rumness: JSONNull?
561+ let somniloquist: JSONNull?
562+ let stressfully: JSONNull?
563+ let tactically: JSONNull?
564+ let tracheophony: JSONNull?
565+ let unappositely: JSONNull?
566+ let unclothedly: JSONNull?
567+ let unimplied: JSONNull?
568+ let unsyncopated: JSONNull?
569+
570+ enum CodingKeys: String, CodingKey {
571+ case aphoristically = "aphoristically"
572+ case apophyllous = "apophyllous"
573+ case cognize = "cognize"
574+ case dermonosology = "dermonosology"
575+ case gyppo = "Gyppo"
576+ case ither = "ither"
577+ case juglandaceous = "juglandaceous"
578+ case litho = "litho"
579+ case macropterous = "macropterous"
580+ case photographer = "photographer"
581+ case romancing = "romancing"
582+ case rumness = "rumness"
583+ case somniloquist = "somniloquist"
584+ case stressfully = "stressfully"
585+ case tactically = "tactically"
586+ case tracheophony = "tracheophony"
587+ case unappositely = "unappositely"
588+ case unclothedly = "unclothedly"
589+ case unimplied = "unimplied"
590+ case unsyncopated = "unsyncopated"
591+ }
592+
593+ 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?) {
594+ self.aphoristically = aphoristically
595+ self.apophyllous = apophyllous
596+ self.cognize = cognize
597+ self.dermonosology = dermonosology
598+ self.gyppo = gyppo
599+ self.ither = ither
600+ self.juglandaceous = juglandaceous
601+ self.litho = litho
602+ self.macropterous = macropterous
603+ self.photographer = photographer
604+ self.romancing = romancing
605+ self.rumness = rumness
606+ self.somniloquist = somniloquist
607+ self.stressfully = stressfully
608+ self.tactically = tactically
609+ self.tracheophony = tracheophony
610+ self.unappositely = unappositely
611+ self.unclothedly = unclothedly
612+ self.unimplied = unimplied
613+ self.unsyncopated = unsyncopated
614+ }
615+}
616+
617+// MARK: PyodermiaClass convenience initializers and mutators
618+
619+extension PyodermiaClass {
620+ convenience init(data: Data) throws {
621+ let me = try newJSONDecoder().decode(PyodermiaClass.self, from: data)
622+ 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)
623+ }
624+
625+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
626+ guard let data = json.data(using: encoding) else {
627+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
628+ }
629+ try self.init(data: data)
630+ }
631+
632+ convenience init(fromURL url: URL) throws {
633+ try self.init(data: try Data(contentsOf: url))
634+ }
635+
636+ func with(
637+ aphoristically: JSONNull?? = nil,
638+ apophyllous: JSONNull?? = nil,
639+ cognize: JSONNull?? = nil,
640+ dermonosology: JSONNull?? = nil,
641+ gyppo: JSONNull?? = nil,
642+ ither: JSONNull?? = nil,
643+ juglandaceous: JSONNull?? = nil,
644+ litho: JSONNull?? = nil,
645+ macropterous: JSONNull?? = nil,
646+ photographer: JSONNull?? = nil,
647+ romancing: JSONNull?? = nil,
648+ rumness: JSONNull?? = nil,
649+ somniloquist: JSONNull?? = nil,
650+ stressfully: JSONNull?? = nil,
651+ tactically: JSONNull?? = nil,
652+ tracheophony: JSONNull?? = nil,
653+ unappositely: JSONNull?? = nil,
654+ unclothedly: JSONNull?? = nil,
655+ unimplied: JSONNull?? = nil,
656+ unsyncopated: JSONNull?? = nil
657+ ) -> PyodermiaClass {
658+ return PyodermiaClass(
659+ aphoristically: aphoristically ?? self.aphoristically,
660+ apophyllous: apophyllous ?? self.apophyllous,
661+ cognize: cognize ?? self.cognize,
662+ dermonosology: dermonosology ?? self.dermonosology,
663+ gyppo: gyppo ?? self.gyppo,
664+ ither: ither ?? self.ither,
665+ juglandaceous: juglandaceous ?? self.juglandaceous,
666+ litho: litho ?? self.litho,
667+ macropterous: macropterous ?? self.macropterous,
668+ photographer: photographer ?? self.photographer,
669+ romancing: romancing ?? self.romancing,
670+ rumness: rumness ?? self.rumness,
671+ somniloquist: somniloquist ?? self.somniloquist,
672+ stressfully: stressfully ?? self.stressfully,
673+ tactically: tactically ?? self.tactically,
674+ tracheophony: tracheophony ?? self.tracheophony,
675+ unappositely: unappositely ?? self.unappositely,
676+ unclothedly: unclothedly ?? self.unclothedly,
677+ unimplied: unimplied ?? self.unimplied,
678+ unsyncopated: unsyncopated ?? self.unsyncopated
679+ )
680+ }
681+
682+ func jsonData() throws -> Data {
683+ return try newJSONEncoder().encode(self)
684+ }
685+
686+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
687+ return String(data: try self.jsonData(), encoding: encoding)
688+ }
689+}
690+
691+enum QuebrachineElement: Codable {
692+ case bool(Bool)
693+ case quebrachineClass(QuebrachineClass)
694+ case null
695+
696+ init(from decoder: Decoder) throws {
697+ let container = try decoder.singleValueContainer()
698+ if let x = try? container.decode(Bool.self) {
699+ self = .bool(x)
700+ return
701+ }
702+ if let x = try? container.decode(QuebrachineClass.self) {
703+ self = .quebrachineClass(x)
704+ return
705+ }
706+ if container.decodeNil() {
707+ self = .null
708+ return
709+ }
710+ throw DecodingError.typeMismatch(QuebrachineElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for QuebrachineElement"))
711+ }
712+
713+ func encode(to encoder: Encoder) throws {
714+ var container = encoder.singleValueContainer()
715+ switch self {
716+ case .bool(let x):
717+ try container.encode(x)
718+ case .quebrachineClass(let x):
719+ try container.encode(x)
720+ case .null:
721+ try container.encodeNil()
722+ }
723+ }
724+}
725+
726+// MARK: - QuebrachineClass
727+final class QuebrachineClass: Codable {
728+ let catharticalness: Double
729+ let chirotherium: Int
730+ let disdiapason: String
731+ let homocerc: Bool
732+ let nonbookish: JSONNull?
733+
734+ enum CodingKeys: String, CodingKey {
735+ case catharticalness = "catharticalness"
736+ case chirotherium = "Chirotherium"
737+ case disdiapason = "disdiapason"
738+ case homocerc = "homocerc"
739+ case nonbookish = "nonbookish"
740+ }
741+
742+ init(catharticalness: Double, chirotherium: Int, disdiapason: String, homocerc: Bool, nonbookish: JSONNull?) {
743+ self.catharticalness = catharticalness
744+ self.chirotherium = chirotherium
745+ self.disdiapason = disdiapason
746+ self.homocerc = homocerc
747+ self.nonbookish = nonbookish
748+ }
749+}
750+
751+// MARK: QuebrachineClass convenience initializers and mutators
752+
753+extension QuebrachineClass {
754+ convenience init(data: Data) throws {
755+ let me = try newJSONDecoder().decode(QuebrachineClass.self, from: data)
756+ self.init(catharticalness: me.catharticalness, chirotherium: me.chirotherium, disdiapason: me.disdiapason, homocerc: me.homocerc, nonbookish: me.nonbookish)
757+ }
758+
759+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
760+ guard let data = json.data(using: encoding) else {
761+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
762+ }
763+ try self.init(data: data)
764+ }
765+
766+ convenience init(fromURL url: URL) throws {
767+ try self.init(data: try Data(contentsOf: url))
768+ }
769+
770+ func with(
771+ catharticalness: Double? = nil,
772+ chirotherium: Int? = nil,
773+ disdiapason: String? = nil,
774+ homocerc: Bool? = nil,
775+ nonbookish: JSONNull?? = nil
776+ ) -> QuebrachineClass {
777+ return QuebrachineClass(
778+ catharticalness: catharticalness ?? self.catharticalness,
779+ chirotherium: chirotherium ?? self.chirotherium,
780+ disdiapason: disdiapason ?? self.disdiapason,
781+ homocerc: homocerc ?? self.homocerc,
782+ nonbookish: nonbookish ?? self.nonbookish
783+ )
784+ }
785+
786+ func jsonData() throws -> Data {
787+ return try newJSONEncoder().encode(self)
788+ }
789+
790+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
791+ return String(data: try self.jsonData(), encoding: encoding)
792+ }
793+}
794+
795+enum Querier: Codable {
796+ case bool(Bool)
797+ case integerMap([String: Int])
798+
799+ init(from decoder: Decoder) throws {
800+ let container = try decoder.singleValueContainer()
801+ if let x = try? container.decode(Bool.self) {
802+ self = .bool(x)
803+ return
804+ }
805+ if let x = try? container.decode([String: Int].self) {
806+ self = .integerMap(x)
807+ return
808+ }
809+ throw DecodingError.typeMismatch(Querier.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Querier"))
810+ }
811+
812+ func encode(to encoder: Encoder) throws {
813+ var container = encoder.singleValueContainer()
814+ switch self {
815+ case .bool(let x):
816+ try container.encode(x)
817+ case .integerMap(let x):
818+ try container.encode(x)
819+ }
820+ }
821+}
822+
823+enum Rebarbative: Codable {
824+ case bool(Bool)
825+ case double(Double)
826+ case integerArray([Int])
827+
828+ init(from decoder: Decoder) throws {
829+ let container = try decoder.singleValueContainer()
830+ if let x = try? container.decode(Bool.self) {
831+ self = .bool(x)
832+ return
833+ }
834+ if let x = try? container.decode([Int].self) {
835+ self = .integerArray(x)
836+ return
837+ }
838+ if let x = try? container.decode(Double.self) {
839+ self = .double(x)
840+ return
841+ }
842+ throw DecodingError.typeMismatch(Rebarbative.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Rebarbative"))
843+ }
844+
845+ func encode(to encoder: Encoder) throws {
846+ var container = encoder.singleValueContainer()
847+ switch self {
848+ case .bool(let x):
849+ try container.encode(x)
850+ case .double(let x):
851+ try container.encode(x)
852+ case .integerArray(let x):
853+ try container.encode(x)
854+ }
855+ }
856+}
857+
858+// MARK: - Reimagine
859+final class Reimagine: Codable {
860+ let adducible: JSONNull?
861+ let anabolin: JSONNull?
862+ let brainy: JSONNull?
863+ let catharticalness: Double?
864+ let chirotherium: Int?
865+ let chrysamine: JSONNull?
866+ let disdiapason: String?
867+ let fluxweed: JSONNull?
868+ let glaucine: JSONNull?
869+ let grobianism: JSONNull?
870+ let hermo: JSONNull?
871+ let hieroglyphist: JSONNull?
872+ let homocerc: Bool?
873+ let icteroid: JSONNull?
874+ let immortal: JSONNull?
875+ let impetulant: JSONNull?
876+ let irrigate: JSONNull?
877+ let myxedema: JSONNull?
878+ let nonbookish: JSONNull?
879+ let onyx: JSONNull?
880+ let repasser: JSONNull?
881+ let septomarginal: JSONNull?
882+ let subdie: JSONNull?
883+ let tibiometatarsal: JSONNull?
884+ let waltzlike: JSONNull?
885+
886+ enum CodingKeys: String, CodingKey {
887+ case adducible = "adducible"
888+ case anabolin = "anabolin"
889+ case brainy = "brainy"
890+ case catharticalness = "catharticalness"
891+ case chirotherium = "Chirotherium"
892+ case chrysamine = "chrysamine"
893+ case disdiapason = "disdiapason"
894+ case fluxweed = "fluxweed"
895+ case glaucine = "glaucine"
896+ case grobianism = "grobianism"
897+ case hermo = "Hermo"
898+ case hieroglyphist = "hieroglyphist"
899+ case homocerc = "homocerc"
900+ case icteroid = "icteroid"
901+ case immortal = "immortal"
902+ case impetulant = "impetulant"
903+ case irrigate = "irrigate"
904+ case myxedema = "myxedema"
905+ case nonbookish = "nonbookish"
906+ case onyx = "onyx"
907+ case repasser = "repasser"
908+ case septomarginal = "septomarginal"
909+ case subdie = "subdie"
910+ case tibiometatarsal = "tibiometatarsal"
911+ case waltzlike = "waltzlike"
912+ }
913+
914+ 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?) {
915+ self.adducible = adducible
916+ self.anabolin = anabolin
917+ self.brainy = brainy
918+ self.catharticalness = catharticalness
919+ self.chirotherium = chirotherium
920+ self.chrysamine = chrysamine
921+ self.disdiapason = disdiapason
922+ self.fluxweed = fluxweed
923+ self.glaucine = glaucine
924+ self.grobianism = grobianism
925+ self.hermo = hermo
926+ self.hieroglyphist = hieroglyphist
927+ self.homocerc = homocerc
928+ self.icteroid = icteroid
929+ self.immortal = immortal
930+ self.impetulant = impetulant
931+ self.irrigate = irrigate
932+ self.myxedema = myxedema
933+ self.nonbookish = nonbookish
934+ self.onyx = onyx
935+ self.repasser = repasser
936+ self.septomarginal = septomarginal
937+ self.subdie = subdie
938+ self.tibiometatarsal = tibiometatarsal
939+ self.waltzlike = waltzlike
940+ }
941+}
942+
943+// MARK: Reimagine convenience initializers and mutators
944+
945+extension Reimagine {
946+ convenience init(data: Data) throws {
947+ let me = try newJSONDecoder().decode(Reimagine.self, from: data)
948+ 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)
949+ }
950+
951+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
952+ guard let data = json.data(using: encoding) else {
953+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
954+ }
955+ try self.init(data: data)
956+ }
957+
958+ convenience init(fromURL url: URL) throws {
959+ try self.init(data: try Data(contentsOf: url))
960+ }
961+
962+ func with(
963+ adducible: JSONNull?? = nil,
964+ anabolin: JSONNull?? = nil,
965+ brainy: JSONNull?? = nil,
966+ catharticalness: Double?? = nil,
967+ chirotherium: Int?? = nil,
968+ chrysamine: JSONNull?? = nil,
969+ disdiapason: String?? = nil,
970+ fluxweed: JSONNull?? = nil,
971+ glaucine: JSONNull?? = nil,
972+ grobianism: JSONNull?? = nil,
973+ hermo: JSONNull?? = nil,
974+ hieroglyphist: JSONNull?? = nil,
975+ homocerc: Bool?? = nil,
976+ icteroid: JSONNull?? = nil,
977+ immortal: JSONNull?? = nil,
978+ impetulant: JSONNull?? = nil,
979+ irrigate: JSONNull?? = nil,
980+ myxedema: JSONNull?? = nil,
981+ nonbookish: JSONNull?? = nil,
982+ onyx: JSONNull?? = nil,
983+ repasser: JSONNull?? = nil,
984+ septomarginal: JSONNull?? = nil,
985+ subdie: JSONNull?? = nil,
986+ tibiometatarsal: JSONNull?? = nil,
987+ waltzlike: JSONNull?? = nil
988+ ) -> Reimagine {
989+ return Reimagine(
990+ adducible: adducible ?? self.adducible,
991+ anabolin: anabolin ?? self.anabolin,
992+ brainy: brainy ?? self.brainy,
993+ catharticalness: catharticalness ?? self.catharticalness,
994+ chirotherium: chirotherium ?? self.chirotherium,
995+ chrysamine: chrysamine ?? self.chrysamine,
996+ disdiapason: disdiapason ?? self.disdiapason,
997+ fluxweed: fluxweed ?? self.fluxweed,
998+ glaucine: glaucine ?? self.glaucine,
999+ grobianism: grobianism ?? self.grobianism,
1000+ hermo: hermo ?? self.hermo,
1001+ hieroglyphist: hieroglyphist ?? self.hieroglyphist,
1002+ homocerc: homocerc ?? self.homocerc,
1003+ icteroid: icteroid ?? self.icteroid,
1004+ immortal: immortal ?? self.immortal,
1005+ impetulant: impetulant ?? self.impetulant,
1006+ irrigate: irrigate ?? self.irrigate,
1007+ myxedema: myxedema ?? self.myxedema,
1008+ nonbookish: nonbookish ?? self.nonbookish,
1009+ onyx: onyx ?? self.onyx,
1010+ repasser: repasser ?? self.repasser,
1011+ septomarginal: septomarginal ?? self.septomarginal,
1012+ subdie: subdie ?? self.subdie,
1013+ tibiometatarsal: tibiometatarsal ?? self.tibiometatarsal,
1014+ waltzlike: waltzlike ?? self.waltzlike
1015+ )
1016+ }
1017+
1018+ func jsonData() throws -> Data {
1019+ return try newJSONEncoder().encode(self)
1020+ }
1021+
1022+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1023+ return String(data: try self.jsonData(), encoding: encoding)
1024+ }
1025+}
1026+
1027+// MARK: - Ressaut
1028+final class Ressaut: Codable {
1029+ let apperceptive: String
1030+ let cuttoo: String
1031+ let douser: String
1032+ let drinkproof: String
1033+ let forementioned: String
1034+ let freesia: String
1035+ let genevieve: String
1036+ let hyperdiabolical: String
1037+ let hypocone: String
1038+ let irreverentially: String
1039+ let jumart: String
1040+ let mimosaceae: String
1041+ let mollicrush: String
1042+ let nedder: String
1043+ let retinasphalt: String
1044+ let sough: String
1045+ let steading: String
1046+ let theopaschitism: String
1047+ let undurableness: String
1048+ let unmingleable: String
1049+
1050+ enum CodingKeys: String, CodingKey {
1051+ case apperceptive = "apperceptive"
1052+ case cuttoo = "cuttoo"
1053+ case douser = "douser"
1054+ case drinkproof = "drinkproof"
1055+ case forementioned = "forementioned"
1056+ case freesia = "Freesia"
1057+ case genevieve = "Genevieve"
1058+ case hyperdiabolical = "hyperdiabolical"
1059+ case hypocone = "hypocone"
1060+ case irreverentially = "irreverentially"
1061+ case jumart = "jumart"
1062+ case mimosaceae = "Mimosaceae"
1063+ case mollicrush = "mollicrush"
1064+ case nedder = "nedder"
1065+ case retinasphalt = "retinasphalt"
1066+ case sough = "sough"
1067+ case steading = "steading"
1068+ case theopaschitism = "Theopaschitism"
1069+ case undurableness = "undurableness"
1070+ case unmingleable = "unmingleable"
1071+ }
1072+
1073+ 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) {
1074+ self.apperceptive = apperceptive
1075+ self.cuttoo = cuttoo
1076+ self.douser = douser
1077+ self.drinkproof = drinkproof
1078+ self.forementioned = forementioned
1079+ self.freesia = freesia
1080+ self.genevieve = genevieve
1081+ self.hyperdiabolical = hyperdiabolical
1082+ self.hypocone = hypocone
1083+ self.irreverentially = irreverentially
1084+ self.jumart = jumart
1085+ self.mimosaceae = mimosaceae
1086+ self.mollicrush = mollicrush
1087+ self.nedder = nedder
1088+ self.retinasphalt = retinasphalt
1089+ self.sough = sough
1090+ self.steading = steading
1091+ self.theopaschitism = theopaschitism
1092+ self.undurableness = undurableness
1093+ self.unmingleable = unmingleable
1094+ }
1095+}
1096+
1097+// MARK: Ressaut convenience initializers and mutators
1098+
1099+extension Ressaut {
1100+ convenience init(data: Data) throws {
1101+ let me = try newJSONDecoder().decode(Ressaut.self, from: data)
1102+ 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)
1103+ }
1104+
1105+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1106+ guard let data = json.data(using: encoding) else {
1107+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1108+ }
1109+ try self.init(data: data)
1110+ }
1111+
1112+ convenience init(fromURL url: URL) throws {
1113+ try self.init(data: try Data(contentsOf: url))
1114+ }
1115+
1116+ func with(
1117+ apperceptive: String? = nil,
1118+ cuttoo: String? = nil,
1119+ douser: String? = nil,
1120+ drinkproof: String? = nil,
1121+ forementioned: String? = nil,
1122+ freesia: String? = nil,
1123+ genevieve: String? = nil,
1124+ hyperdiabolical: String? = nil,
1125+ hypocone: String? = nil,
1126+ irreverentially: String? = nil,
1127+ jumart: String? = nil,
1128+ mimosaceae: String? = nil,
1129+ mollicrush: String? = nil,
1130+ nedder: String? = nil,
1131+ retinasphalt: String? = nil,
1132+ sough: String? = nil,
1133+ steading: String? = nil,
1134+ theopaschitism: String? = nil,
1135+ undurableness: String? = nil,
1136+ unmingleable: String? = nil
1137+ ) -> Ressaut {
1138+ return Ressaut(
1139+ apperceptive: apperceptive ?? self.apperceptive,
1140+ cuttoo: cuttoo ?? self.cuttoo,
1141+ douser: douser ?? self.douser,
1142+ drinkproof: drinkproof ?? self.drinkproof,
1143+ forementioned: forementioned ?? self.forementioned,
1144+ freesia: freesia ?? self.freesia,
1145+ genevieve: genevieve ?? self.genevieve,
1146+ hyperdiabolical: hyperdiabolical ?? self.hyperdiabolical,
1147+ hypocone: hypocone ?? self.hypocone,
1148+ irreverentially: irreverentially ?? self.irreverentially,
1149+ jumart: jumart ?? self.jumart,
1150+ mimosaceae: mimosaceae ?? self.mimosaceae,
1151+ mollicrush: mollicrush ?? self.mollicrush,
1152+ nedder: nedder ?? self.nedder,
1153+ retinasphalt: retinasphalt ?? self.retinasphalt,
1154+ sough: sough ?? self.sough,
1155+ steading: steading ?? self.steading,
1156+ theopaschitism: theopaschitism ?? self.theopaschitism,
1157+ undurableness: undurableness ?? self.undurableness,
1158+ unmingleable: unmingleable ?? self.unmingleable
1159+ )
1160+ }
1161+
1162+ func jsonData() throws -> Data {
1163+ return try newJSONEncoder().encode(self)
1164+ }
1165+
1166+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1167+ return String(data: try self.jsonData(), encoding: encoding)
1168+ }
1169+}
1170+
1171+enum Retrocervical: Codable {
1172+ case integer(Int)
1173+ case unionArray([Int?])
1174+
1175+ init(from decoder: Decoder) throws {
1176+ let container = try decoder.singleValueContainer()
1177+ if let x = try? container.decode(Int.self) {
1178+ self = .integer(x)
1179+ return
1180+ }
1181+ if let x = try? container.decode([Int?].self) {
1182+ self = .unionArray(x)
1183+ return
1184+ }
1185+ throw DecodingError.typeMismatch(Retrocervical.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Retrocervical"))
1186+ }
1187+
1188+ func encode(to encoder: Encoder) throws {
1189+ var container = encoder.singleValueContainer()
1190+ switch self {
1191+ case .integer(let x):
1192+ try container.encode(x)
1193+ case .unionArray(let x):
1194+ try container.encode(x)
1195+ }
1196+ }
1197+}
1198+
1199+enum Revert: Codable {
1200+ case bool(Bool)
1201+ case string(String)
1202+
1203+ init(from decoder: Decoder) throws {
1204+ let container = try decoder.singleValueContainer()
1205+ if let x = try? container.decode(Bool.self) {
1206+ self = .bool(x)
1207+ return
1208+ }
1209+ if let x = try? container.decode(String.self) {
1210+ self = .string(x)
1211+ return
1212+ }
1213+ throw DecodingError.typeMismatch(Revert.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Revert"))
1214+ }
1215+
1216+ func encode(to encoder: Encoder) throws {
1217+ var container = encoder.singleValueContainer()
1218+ switch self {
1219+ case .bool(let x):
1220+ try container.encode(x)
1221+ case .string(let x):
1222+ try container.encode(x)
1223+ }
1224+ }
1225+}
1226+
1227+enum RewriteElement: Codable {
1228+ case double(Double)
1229+ case nullArray([JSONNull?])
1230+ case rewriteClass(RewriteClass)
1231+
1232+ init(from decoder: Decoder) throws {
1233+ let container = try decoder.singleValueContainer()
1234+ if let x = try? container.decode([JSONNull?].self) {
1235+ self = .nullArray(x)
1236+ return
1237+ }
1238+ if let x = try? container.decode(Double.self) {
1239+ self = .double(x)
1240+ return
1241+ }
1242+ if let x = try? container.decode(RewriteClass.self) {
1243+ self = .rewriteClass(x)
1244+ return
1245+ }
1246+ throw DecodingError.typeMismatch(RewriteElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for RewriteElement"))
1247+ }
1248+
1249+ func encode(to encoder: Encoder) throws {
1250+ var container = encoder.singleValueContainer()
1251+ switch self {
1252+ case .double(let x):
1253+ try container.encode(x)
1254+ case .nullArray(let x):
1255+ try container.encode(x)
1256+ case .rewriteClass(let x):
1257+ try container.encode(x)
1258+ }
1259+ }
1260+}
1261+
1262+// MARK: - RewriteClass
1263+final class RewriteClass: Codable {
1264+ let accountancy: JSONNull?
1265+ let cacotrophic: JSONNull?
1266+ let contest: JSONNull?
1267+ let couthily: JSONNull?
1268+ let falculate: JSONNull?
1269+ let foreseize: JSONNull?
1270+ let hyades: JSONNull?
1271+ let lemnad: JSONNull?
1272+ let monotheistically: JSONNull?
1273+ let nonflying: JSONNull?
1274+ let ptenoglossa: JSONNull?
1275+ let repatch: JSONNull?
1276+ let rodman: JSONNull?
1277+ let strung: JSONNull?
1278+ let titmal: JSONNull?
1279+ let twalpennyworth: JSONNull?
1280+ let unblamable: JSONNull?
1281+ let vertical: JSONNull?
1282+ let whiggification: JSONNull?
1283+ let yardman: JSONNull?
1284+
1285+ enum CodingKeys: String, CodingKey {
1286+ case accountancy = "accountancy"
1287+ case cacotrophic = "cacotrophic"
1288+ case contest = "contest"
1289+ case couthily = "couthily"
1290+ case falculate = "falculate"
1291+ case foreseize = "foreseize"
1292+ case hyades = "Hyades"
1293+ case lemnad = "lemnad"
1294+ case monotheistically = "monotheistically"
1295+ case nonflying = "nonflying"
1296+ case ptenoglossa = "Ptenoglossa"
1297+ case repatch = "repatch"
1298+ case rodman = "rodman"
1299+ case strung = "strung"
1300+ case titmal = "titmal"
1301+ case twalpennyworth = "twalpennyworth"
1302+ case unblamable = "unblamable"
1303+ case vertical = "vertical"
1304+ case whiggification = "Whiggification"
1305+ case yardman = "yardman"
1306+ }
1307+
1308+ 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?) {
1309+ self.accountancy = accountancy
1310+ self.cacotrophic = cacotrophic
1311+ self.contest = contest
1312+ self.couthily = couthily
1313+ self.falculate = falculate
1314+ self.foreseize = foreseize
1315+ self.hyades = hyades
1316+ self.lemnad = lemnad
1317+ self.monotheistically = monotheistically
1318+ self.nonflying = nonflying
1319+ self.ptenoglossa = ptenoglossa
1320+ self.repatch = repatch
1321+ self.rodman = rodman
1322+ self.strung = strung
1323+ self.titmal = titmal
1324+ self.twalpennyworth = twalpennyworth
1325+ self.unblamable = unblamable
1326+ self.vertical = vertical
1327+ self.whiggification = whiggification
1328+ self.yardman = yardman
1329+ }
1330+}
1331+
1332+// MARK: RewriteClass convenience initializers and mutators
1333+
1334+extension RewriteClass {
1335+ convenience init(data: Data) throws {
1336+ let me = try newJSONDecoder().decode(RewriteClass.self, from: data)
1337+ 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)
1338+ }
1339+
1340+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1341+ guard let data = json.data(using: encoding) else {
1342+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1343+ }
1344+ try self.init(data: data)
1345+ }
1346+
1347+ convenience init(fromURL url: URL) throws {
1348+ try self.init(data: try Data(contentsOf: url))
1349+ }
1350+
1351+ func with(
1352+ accountancy: JSONNull?? = nil,
1353+ cacotrophic: JSONNull?? = nil,
1354+ contest: JSONNull?? = nil,
1355+ couthily: JSONNull?? = nil,
1356+ falculate: JSONNull?? = nil,
1357+ foreseize: JSONNull?? = nil,
1358+ hyades: JSONNull?? = nil,
1359+ lemnad: JSONNull?? = nil,
1360+ monotheistically: JSONNull?? = nil,
1361+ nonflying: JSONNull?? = nil,
1362+ ptenoglossa: JSONNull?? = nil,
1363+ repatch: JSONNull?? = nil,
1364+ rodman: JSONNull?? = nil,
1365+ strung: JSONNull?? = nil,
1366+ titmal: JSONNull?? = nil,
1367+ twalpennyworth: JSONNull?? = nil,
1368+ unblamable: JSONNull?? = nil,
1369+ vertical: JSONNull?? = nil,
1370+ whiggification: JSONNull?? = nil,
1371+ yardman: JSONNull?? = nil
1372+ ) -> RewriteClass {
1373+ return RewriteClass(
1374+ accountancy: accountancy ?? self.accountancy,
1375+ cacotrophic: cacotrophic ?? self.cacotrophic,
1376+ contest: contest ?? self.contest,
1377+ couthily: couthily ?? self.couthily,
1378+ falculate: falculate ?? self.falculate,
1379+ foreseize: foreseize ?? self.foreseize,
1380+ hyades: hyades ?? self.hyades,
1381+ lemnad: lemnad ?? self.lemnad,
1382+ monotheistically: monotheistically ?? self.monotheistically,
1383+ nonflying: nonflying ?? self.nonflying,
1384+ ptenoglossa: ptenoglossa ?? self.ptenoglossa,
1385+ repatch: repatch ?? self.repatch,
1386+ rodman: rodman ?? self.rodman,
1387+ strung: strung ?? self.strung,
1388+ titmal: titmal ?? self.titmal,
1389+ twalpennyworth: twalpennyworth ?? self.twalpennyworth,
1390+ unblamable: unblamable ?? self.unblamable,
1391+ vertical: vertical ?? self.vertical,
1392+ whiggification: whiggification ?? self.whiggification,
1393+ yardman: yardman ?? self.yardman
1394+ )
1395+ }
1396+
1397+ func jsonData() throws -> Data {
1398+ return try newJSONEncoder().encode(self)
1399+ }
1400+
1401+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1402+ return String(data: try self.jsonData(), encoding: encoding)
1403+ }
1404+}
1405+
1406+enum Saccoderm: Codable {
1407+ case integerArray([Int])
1408+ case string(String)
1409+ case null
1410+
1411+ init(from decoder: Decoder) throws {
1412+ let container = try decoder.singleValueContainer()
1413+ if let x = try? container.decode([Int].self) {
1414+ self = .integerArray(x)
1415+ return
1416+ }
1417+ if let x = try? container.decode(String.self) {
1418+ self = .string(x)
1419+ return
1420+ }
1421+ if container.decodeNil() {
1422+ self = .null
1423+ return
1424+ }
1425+ throw DecodingError.typeMismatch(Saccoderm.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Saccoderm"))
1426+ }
1427+
1428+ func encode(to encoder: Encoder) throws {
1429+ var container = encoder.singleValueContainer()
1430+ switch self {
1431+ case .integerArray(let x):
1432+ try container.encode(x)
1433+ case .string(let x):
1434+ try container.encode(x)
1435+ case .null:
1436+ try container.encodeNil()
1437+ }
1438+ }
1439+}
1440+
1441+enum SantirElement: Codable {
1442+ case double(Double)
1443+ case santirClass(SantirClass)
1444+
1445+ init(from decoder: Decoder) throws {
1446+ let container = try decoder.singleValueContainer()
1447+ if let x = try? container.decode(Double.self) {
1448+ self = .double(x)
1449+ return
1450+ }
1451+ if let x = try? container.decode(SantirClass.self) {
1452+ self = .santirClass(x)
1453+ return
1454+ }
1455+ throw DecodingError.typeMismatch(SantirElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for SantirElement"))
1456+ }
1457+
1458+ func encode(to encoder: Encoder) throws {
1459+ var container = encoder.singleValueContainer()
1460+ switch self {
1461+ case .double(let x):
1462+ try container.encode(x)
1463+ case .santirClass(let x):
1464+ try container.encode(x)
1465+ }
1466+ }
1467+}
1468+
1469+// MARK: - SantirClass
1470+final class SantirClass: Codable {
1471+ let admiredly: JSONNull?
1472+ let demicaponier: JSONNull?
1473+ let epitympanic: JSONNull?
1474+ let investitor: JSONNull?
1475+ let lupiform: JSONNull?
1476+ let monoflagellate: JSONNull?
1477+ let paleoethnic: JSONNull?
1478+ let prediscountable: JSONNull?
1479+ let rhetoricals: JSONNull?
1480+ let roomth: JSONNull?
1481+ let saccharose: JSONNull?
1482+ let septonasal: JSONNull?
1483+ let serpenticide: JSONNull?
1484+ let setarious: JSONNull?
1485+ let spaework: JSONNull?
1486+ let stylite: JSONNull?
1487+ let suessiones: JSONNull?
1488+ let timelily: JSONNull?
1489+ let unprofaned: JSONNull?
1490+ let vorticular: JSONNull?
1491+
1492+ enum CodingKeys: String, CodingKey {
1493+ case admiredly = "admiredly"
1494+ case demicaponier = "demicaponier"
1495+ case epitympanic = "epitympanic"
1496+ case investitor = "investitor"
1497+ case lupiform = "lupiform"
1498+ case monoflagellate = "monoflagellate"
1499+ case paleoethnic = "paleoethnic"
1500+ case prediscountable = "prediscountable"
1501+ case rhetoricals = "rhetoricals"
1502+ case roomth = "roomth"
1503+ case saccharose = "saccharose"
1504+ case septonasal = "septonasal"
1505+ case serpenticide = "serpenticide"
1506+ case setarious = "setarious"
1507+ case spaework = "spaework"
1508+ case stylite = "stylite"
1509+ case suessiones = "Suessiones"
1510+ case timelily = "timelily"
1511+ case unprofaned = "unprofaned"
1512+ case vorticular = "vorticular"
1513+ }
1514+
1515+ 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?) {
1516+ self.admiredly = admiredly
1517+ self.demicaponier = demicaponier
1518+ self.epitympanic = epitympanic
1519+ self.investitor = investitor
1520+ self.lupiform = lupiform
1521+ self.monoflagellate = monoflagellate
1522+ self.paleoethnic = paleoethnic
1523+ self.prediscountable = prediscountable
1524+ self.rhetoricals = rhetoricals
1525+ self.roomth = roomth
1526+ self.saccharose = saccharose
1527+ self.septonasal = septonasal
1528+ self.serpenticide = serpenticide
1529+ self.setarious = setarious
1530+ self.spaework = spaework
1531+ self.stylite = stylite
1532+ self.suessiones = suessiones
1533+ self.timelily = timelily
1534+ self.unprofaned = unprofaned
1535+ self.vorticular = vorticular
1536+ }
1537+}
1538+
1539+// MARK: SantirClass convenience initializers and mutators
1540+
1541+extension SantirClass {
1542+ convenience init(data: Data) throws {
1543+ let me = try newJSONDecoder().decode(SantirClass.self, from: data)
1544+ 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)
1545+ }
1546+
1547+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1548+ guard let data = json.data(using: encoding) else {
1549+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1550+ }
1551+ try self.init(data: data)
1552+ }
1553+
1554+ convenience init(fromURL url: URL) throws {
1555+ try self.init(data: try Data(contentsOf: url))
1556+ }
1557+
1558+ func with(
1559+ admiredly: JSONNull?? = nil,
1560+ demicaponier: JSONNull?? = nil,
1561+ epitympanic: JSONNull?? = nil,
1562+ investitor: JSONNull?? = nil,
1563+ lupiform: JSONNull?? = nil,
1564+ monoflagellate: JSONNull?? = nil,
1565+ paleoethnic: JSONNull?? = nil,
1566+ prediscountable: JSONNull?? = nil,
1567+ rhetoricals: JSONNull?? = nil,
1568+ roomth: JSONNull?? = nil,
1569+ saccharose: JSONNull?? = nil,
1570+ septonasal: JSONNull?? = nil,
1571+ serpenticide: JSONNull?? = nil,
1572+ setarious: JSONNull?? = nil,
1573+ spaework: JSONNull?? = nil,
1574+ stylite: JSONNull?? = nil,
1575+ suessiones: JSONNull?? = nil,
1576+ timelily: JSONNull?? = nil,
1577+ unprofaned: JSONNull?? = nil,
1578+ vorticular: JSONNull?? = nil
1579+ ) -> SantirClass {
1580+ return SantirClass(
1581+ admiredly: admiredly ?? self.admiredly,
1582+ demicaponier: demicaponier ?? self.demicaponier,
1583+ epitympanic: epitympanic ?? self.epitympanic,
1584+ investitor: investitor ?? self.investitor,
1585+ lupiform: lupiform ?? self.lupiform,
1586+ monoflagellate: monoflagellate ?? self.monoflagellate,
1587+ paleoethnic: paleoethnic ?? self.paleoethnic,
1588+ prediscountable: prediscountable ?? self.prediscountable,
1589+ rhetoricals: rhetoricals ?? self.rhetoricals,
1590+ roomth: roomth ?? self.roomth,
1591+ saccharose: saccharose ?? self.saccharose,
1592+ septonasal: septonasal ?? self.septonasal,
1593+ serpenticide: serpenticide ?? self.serpenticide,
1594+ setarious: setarious ?? self.setarious,
1595+ spaework: spaework ?? self.spaework,
1596+ stylite: stylite ?? self.stylite,
1597+ suessiones: suessiones ?? self.suessiones,
1598+ timelily: timelily ?? self.timelily,
1599+ unprofaned: unprofaned ?? self.unprofaned,
1600+ vorticular: vorticular ?? self.vorticular
1601+ )
1602+ }
1603+
1604+ func jsonData() throws -> Data {
1605+ return try newJSONEncoder().encode(self)
1606+ }
1607+
1608+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1609+ return String(data: try self.jsonData(), encoding: encoding)
1610+ }
1611+}
1612+
1613+enum Saprophilous: Codable {
1614+ case integerMap([String: Int])
1615+ case string(String)
1616+ case null
1617+
1618+ init(from decoder: Decoder) throws {
1619+ let container = try decoder.singleValueContainer()
1620+ if let x = try? container.decode([String: Int].self) {
1621+ self = .integerMap(x)
1622+ return
1623+ }
1624+ if let x = try? container.decode(String.self) {
1625+ self = .string(x)
1626+ return
1627+ }
1628+ if container.decodeNil() {
1629+ self = .null
1630+ return
1631+ }
1632+ throw DecodingError.typeMismatch(Saprophilous.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Saprophilous"))
1633+ }
1634+
1635+ func encode(to encoder: Encoder) throws {
1636+ var container = encoder.singleValueContainer()
1637+ switch self {
1638+ case .integerMap(let x):
1639+ try container.encode(x)
1640+ case .string(let x):
1641+ try container.encode(x)
1642+ case .null:
1643+ try container.encodeNil()
1644+ }
1645+ }
1646+}
1647+
1648+enum SaxtenElement: Codable {
1649+ case saxtenClass(SaxtenClass)
1650+ case string(String)
1651+
1652+ init(from decoder: Decoder) throws {
1653+ let container = try decoder.singleValueContainer()
1654+ if let x = try? container.decode(String.self) {
1655+ self = .string(x)
1656+ return
1657+ }
1658+ if let x = try? container.decode(SaxtenClass.self) {
1659+ self = .saxtenClass(x)
1660+ return
1661+ }
1662+ throw DecodingError.typeMismatch(SaxtenElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for SaxtenElement"))
1663+ }
1664+
1665+ func encode(to encoder: Encoder) throws {
1666+ var container = encoder.singleValueContainer()
1667+ switch self {
1668+ case .saxtenClass(let x):
1669+ try container.encode(x)
1670+ case .string(let x):
1671+ try container.encode(x)
1672+ }
1673+ }
1674+}
1675+
1676+// MARK: - SaxtenClass
1677+final class SaxtenClass: Codable {
1678+ let algarrobilla: JSONNull?
1679+ let bowgrace: JSONNull?
1680+ let catharticalness: Double?
1681+ let centaurid: JSONNull?
1682+ let chirotherium: Int?
1683+ let disdiapason: String?
1684+ let flix: JSONNull?
1685+ let germanely: JSONNull?
1686+ let homocerc: Bool?
1687+ let inhume: JSONNull?
1688+ let lepidote: JSONNull?
1689+ let megalochirous: JSONNull?
1690+ let ninepenny: JSONNull?
1691+ let nonbookish: JSONNull?
1692+ let nondeist: JSONNull?
1693+ let nymphaeaceous: JSONNull?
1694+ let parietofrontal: JSONNull?
1695+ let sancyite: JSONNull?
1696+ let subjectivist: JSONNull?
1697+ let tibiad: JSONNull?
1698+ let transonic: JSONNull?
1699+ let tripetalous: JSONNull?
1700+ let trunchman: JSONNull?
1701+ let urger: JSONNull?
1702+ let withdrawnness: JSONNull?
1703+
1704+ enum CodingKeys: String, CodingKey {
1705+ case algarrobilla = "algarrobilla"
1706+ case bowgrace = "bowgrace"
1707+ case catharticalness = "catharticalness"
1708+ case centaurid = "Centaurid"
1709+ case chirotherium = "Chirotherium"
1710+ case disdiapason = "disdiapason"
1711+ case flix = "flix"
1712+ case germanely = "germanely"
1713+ case homocerc = "homocerc"
1714+ case inhume = "inhume"
1715+ case lepidote = "lepidote"
1716+ case megalochirous = "megalochirous"
1717+ case ninepenny = "ninepenny"
1718+ case nonbookish = "nonbookish"
1719+ case nondeist = "nondeist"
1720+ case nymphaeaceous = "nymphaeaceous"
1721+ case parietofrontal = "parietofrontal"
1722+ case sancyite = "sancyite"
1723+ case subjectivist = "subjectivist"
1724+ case tibiad = "tibiad"
1725+ case transonic = "transonic"
1726+ case tripetalous = "tripetalous"
1727+ case trunchman = "trunchman"
1728+ case urger = "urger"
1729+ case withdrawnness = "withdrawnness"
1730+ }
1731+
1732+ 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?) {
1733+ self.algarrobilla = algarrobilla
1734+ self.bowgrace = bowgrace
1735+ self.catharticalness = catharticalness
1736+ self.centaurid = centaurid
1737+ self.chirotherium = chirotherium
1738+ self.disdiapason = disdiapason
1739+ self.flix = flix
1740+ self.germanely = germanely
1741+ self.homocerc = homocerc
1742+ self.inhume = inhume
1743+ self.lepidote = lepidote
1744+ self.megalochirous = megalochirous
1745+ self.ninepenny = ninepenny
1746+ self.nonbookish = nonbookish
1747+ self.nondeist = nondeist
1748+ self.nymphaeaceous = nymphaeaceous
1749+ self.parietofrontal = parietofrontal
1750+ self.sancyite = sancyite
1751+ self.subjectivist = subjectivist
1752+ self.tibiad = tibiad
1753+ self.transonic = transonic
1754+ self.tripetalous = tripetalous
1755+ self.trunchman = trunchman
1756+ self.urger = urger
1757+ self.withdrawnness = withdrawnness
1758+ }
1759+}
1760+
1761+// MARK: SaxtenClass convenience initializers and mutators
1762+
1763+extension SaxtenClass {
1764+ convenience init(data: Data) throws {
1765+ let me = try newJSONDecoder().decode(SaxtenClass.self, from: data)
1766+ 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)
1767+ }
1768+
1769+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1770+ guard let data = json.data(using: encoding) else {
1771+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1772+ }
1773+ try self.init(data: data)
1774+ }
1775+
1776+ convenience init(fromURL url: URL) throws {
1777+ try self.init(data: try Data(contentsOf: url))
1778+ }
1779+
1780+ func with(
1781+ algarrobilla: JSONNull?? = nil,
1782+ bowgrace: JSONNull?? = nil,
1783+ catharticalness: Double?? = nil,
1784+ centaurid: JSONNull?? = nil,
1785+ chirotherium: Int?? = nil,
1786+ disdiapason: String?? = nil,
1787+ flix: JSONNull?? = nil,
1788+ germanely: JSONNull?? = nil,
1789+ homocerc: Bool?? = nil,
1790+ inhume: JSONNull?? = nil,
1791+ lepidote: JSONNull?? = nil,
1792+ megalochirous: JSONNull?? = nil,
1793+ ninepenny: JSONNull?? = nil,
1794+ nonbookish: JSONNull?? = nil,
1795+ nondeist: JSONNull?? = nil,
1796+ nymphaeaceous: JSONNull?? = nil,
1797+ parietofrontal: JSONNull?? = nil,
1798+ sancyite: JSONNull?? = nil,
1799+ subjectivist: JSONNull?? = nil,
1800+ tibiad: JSONNull?? = nil,
1801+ transonic: JSONNull?? = nil,
1802+ tripetalous: JSONNull?? = nil,
1803+ trunchman: JSONNull?? = nil,
1804+ urger: JSONNull?? = nil,
1805+ withdrawnness: JSONNull?? = nil
1806+ ) -> SaxtenClass {
1807+ return SaxtenClass(
1808+ algarrobilla: algarrobilla ?? self.algarrobilla,
1809+ bowgrace: bowgrace ?? self.bowgrace,
1810+ catharticalness: catharticalness ?? self.catharticalness,
1811+ centaurid: centaurid ?? self.centaurid,
1812+ chirotherium: chirotherium ?? self.chirotherium,
1813+ disdiapason: disdiapason ?? self.disdiapason,
1814+ flix: flix ?? self.flix,
1815+ germanely: germanely ?? self.germanely,
1816+ homocerc: homocerc ?? self.homocerc,
1817+ inhume: inhume ?? self.inhume,
1818+ lepidote: lepidote ?? self.lepidote,
1819+ megalochirous: megalochirous ?? self.megalochirous,
1820+ ninepenny: ninepenny ?? self.ninepenny,
1821+ nonbookish: nonbookish ?? self.nonbookish,
1822+ nondeist: nondeist ?? self.nondeist,
1823+ nymphaeaceous: nymphaeaceous ?? self.nymphaeaceous,
1824+ parietofrontal: parietofrontal ?? self.parietofrontal,
1825+ sancyite: sancyite ?? self.sancyite,
1826+ subjectivist: subjectivist ?? self.subjectivist,
1827+ tibiad: tibiad ?? self.tibiad,
1828+ transonic: transonic ?? self.transonic,
1829+ tripetalous: tripetalous ?? self.tripetalous,
1830+ trunchman: trunchman ?? self.trunchman,
1831+ urger: urger ?? self.urger,
1832+ withdrawnness: withdrawnness ?? self.withdrawnness
1833+ )
1834+ }
1835+
1836+ func jsonData() throws -> Data {
1837+ return try newJSONEncoder().encode(self)
1838+ }
1839+
1840+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1841+ return String(data: try self.jsonData(), encoding: encoding)
1842+ }
1843+}
1844+
1845+// MARK: - Scatty
1846+final class Scatty: Codable {
1847+ let aeriferous: JSONNull?
1848+ let antical: JSONNull?
1849+ let antighostism: JSONNull?
1850+ let arcanum: JSONNull?
1851+ let autotrophy: JSONNull?
1852+ let baronial: JSONNull?
1853+ let caffeine: JSONNull?
1854+ let gorgoniacean: JSONNull?
1855+ let heroical: JSONNull?
1856+ let hydropical: JSONNull?
1857+ let mechanology: JSONNull?
1858+ let musicopoetic: JSONNull?
1859+ let officiality: JSONNull?
1860+ let oftentimes: JSONNull?
1861+ let ophthalmotonometer: JSONNull?
1862+ let reflectively: JSONNull?
1863+ let springer: JSONNull?
1864+ let tabasco: JSONNull?
1865+ let teleianthous: JSONNull?
1866+ let uncombated: JSONNull?
1867+
1868+ enum CodingKeys: String, CodingKey {
1869+ case aeriferous = "aeriferous"
1870+ case antical = "antical"
1871+ case antighostism = "antighostism"
1872+ case arcanum = "arcanum"
1873+ case autotrophy = "autotrophy"
1874+ case baronial = "baronial"
1875+ case caffeine = "caffeine"
1876+ case gorgoniacean = "gorgoniacean"
1877+ case heroical = "heroical"
1878+ case hydropical = "hydropical"
1879+ case mechanology = "mechanology"
1880+ case musicopoetic = "musicopoetic"
1881+ case officiality = "officiality"
1882+ case oftentimes = "oftentimes"
1883+ case ophthalmotonometer = "ophthalmotonometer"
1884+ case reflectively = "reflectively"
1885+ case springer = "springer"
1886+ case tabasco = "Tabasco"
1887+ case teleianthous = "teleianthous"
1888+ case uncombated = "uncombated"
1889+ }
1890+
1891+ 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?) {
1892+ self.aeriferous = aeriferous
1893+ self.antical = antical
1894+ self.antighostism = antighostism
1895+ self.arcanum = arcanum
1896+ self.autotrophy = autotrophy
1897+ self.baronial = baronial
1898+ self.caffeine = caffeine
1899+ self.gorgoniacean = gorgoniacean
1900+ self.heroical = heroical
1901+ self.hydropical = hydropical
1902+ self.mechanology = mechanology
1903+ self.musicopoetic = musicopoetic
1904+ self.officiality = officiality
1905+ self.oftentimes = oftentimes
1906+ self.ophthalmotonometer = ophthalmotonometer
1907+ self.reflectively = reflectively
1908+ self.springer = springer
1909+ self.tabasco = tabasco
1910+ self.teleianthous = teleianthous
1911+ self.uncombated = uncombated
1912+ }
1913+}
1914+
1915+// MARK: Scatty convenience initializers and mutators
1916+
1917+extension Scatty {
1918+ convenience init(data: Data) throws {
1919+ let me = try newJSONDecoder().decode(Scatty.self, from: data)
1920+ 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)
1921+ }
1922+
1923+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1924+ guard let data = json.data(using: encoding) else {
1925+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1926+ }
1927+ try self.init(data: data)
1928+ }
1929+
1930+ convenience init(fromURL url: URL) throws {
1931+ try self.init(data: try Data(contentsOf: url))
1932+ }
1933+
1934+ func with(
1935+ aeriferous: JSONNull?? = nil,
1936+ antical: JSONNull?? = nil,
1937+ antighostism: JSONNull?? = nil,
1938+ arcanum: JSONNull?? = nil,
1939+ autotrophy: JSONNull?? = nil,
1940+ baronial: JSONNull?? = nil,
1941+ caffeine: JSONNull?? = nil,
1942+ gorgoniacean: JSONNull?? = nil,
1943+ heroical: JSONNull?? = nil,
1944+ hydropical: JSONNull?? = nil,
1945+ mechanology: JSONNull?? = nil,
1946+ musicopoetic: JSONNull?? = nil,
1947+ officiality: JSONNull?? = nil,
1948+ oftentimes: JSONNull?? = nil,
1949+ ophthalmotonometer: JSONNull?? = nil,
1950+ reflectively: JSONNull?? = nil,
1951+ springer: JSONNull?? = nil,
1952+ tabasco: JSONNull?? = nil,
1953+ teleianthous: JSONNull?? = nil,
1954+ uncombated: JSONNull?? = nil
1955+ ) -> Scatty {
1956+ return Scatty(
1957+ aeriferous: aeriferous ?? self.aeriferous,
1958+ antical: antical ?? self.antical,
1959+ antighostism: antighostism ?? self.antighostism,
1960+ arcanum: arcanum ?? self.arcanum,
1961+ autotrophy: autotrophy ?? self.autotrophy,
1962+ baronial: baronial ?? self.baronial,
1963+ caffeine: caffeine ?? self.caffeine,
1964+ gorgoniacean: gorgoniacean ?? self.gorgoniacean,
1965+ heroical: heroical ?? self.heroical,
1966+ hydropical: hydropical ?? self.hydropical,
1967+ mechanology: mechanology ?? self.mechanology,
1968+ musicopoetic: musicopoetic ?? self.musicopoetic,
1969+ officiality: officiality ?? self.officiality,
1970+ oftentimes: oftentimes ?? self.oftentimes,
1971+ ophthalmotonometer: ophthalmotonometer ?? self.ophthalmotonometer,
1972+ reflectively: reflectively ?? self.reflectively,
1973+ springer: springer ?? self.springer,
1974+ tabasco: tabasco ?? self.tabasco,
1975+ teleianthous: teleianthous ?? self.teleianthous,
1976+ uncombated: uncombated ?? self.uncombated
1977+ )
1978+ }
1979+
1980+ func jsonData() throws -> Data {
1981+ return try newJSONEncoder().encode(self)
1982+ }
1983+
1984+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1985+ return String(data: try self.jsonData(), encoding: encoding)
1986+ }
1987+}
1988+
1989+enum Scoffer: Codable {
1990+ case integerMap([String: Int])
1991+ case nullArray([JSONNull?])
1992+ case null
1993+
1994+ init(from decoder: Decoder) throws {
1995+ let container = try decoder.singleValueContainer()
1996+ if let x = try? container.decode([JSONNull?].self) {
1997+ self = .nullArray(x)
1998+ return
1999+ }
2000+ if let x = try? container.decode([String: Int].self) {
2001+ self = .integerMap(x)
2002+ return
2003+ }
2004+ if container.decodeNil() {
2005+ self = .null
2006+ return
2007+ }
2008+ throw DecodingError.typeMismatch(Scoffer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Scoffer"))
2009+ }
2010+
2011+ func encode(to encoder: Encoder) throws {
2012+ var container = encoder.singleValueContainer()
2013+ switch self {
2014+ case .integerMap(let x):
2015+ try container.encode(x)
2016+ case .nullArray(let x):
2017+ try container.encode(x)
2018+ case .null:
2019+ try container.encodeNil()
2020+ }
2021+ }
2022+}
2023+
2024+enum Scrampum: Codable {
2025+ case bool(Bool)
2026+ case integerArray([Int])
2027+ case null
2028+
2029+ init(from decoder: Decoder) throws {
2030+ let container = try decoder.singleValueContainer()
2031+ if let x = try? container.decode(Bool.self) {
2032+ self = .bool(x)
2033+ return
2034+ }
2035+ if let x = try? container.decode([Int].self) {
2036+ self = .integerArray(x)
2037+ return
2038+ }
2039+ if container.decodeNil() {
2040+ self = .null
2041+ return
2042+ }
2043+ throw DecodingError.typeMismatch(Scrampum.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Scrampum"))
2044+ }
2045+
2046+ func encode(to encoder: Encoder) throws {
2047+ var container = encoder.singleValueContainer()
2048+ switch self {
2049+ case .bool(let x):
2050+ try container.encode(x)
2051+ case .integerArray(let x):
2052+ try container.encode(x)
2053+ case .null:
2054+ try container.encodeNil()
2055+ }
2056+ }
2057+}
2058+
2059+enum Serpentinic: Codable {
2060+ case double(Double)
2061+ case integerArray([Int])
2062+
2063+ init(from decoder: Decoder) throws {
2064+ let container = try decoder.singleValueContainer()
2065+ if let x = try? container.decode([Int].self) {
2066+ self = .integerArray(x)
2067+ return
2068+ }
2069+ if let x = try? container.decode(Double.self) {
2070+ self = .double(x)
2071+ return
2072+ }
2073+ throw DecodingError.typeMismatch(Serpentinic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Serpentinic"))
2074+ }
2075+
2076+ func encode(to encoder: Encoder) throws {
2077+ var container = encoder.singleValueContainer()
2078+ switch self {
2079+ case .double(let x):
2080+ try container.encode(x)
2081+ case .integerArray(let x):
2082+ try container.encode(x)
2083+ }
2084+ }
2085+}
2086+
2087+enum Shadowable: Codable {
2088+ case bool(Bool)
2089+ case unionArray([Int?])
2090+
2091+ init(from decoder: Decoder) throws {
2092+ let container = try decoder.singleValueContainer()
2093+ if let x = try? container.decode(Bool.self) {
2094+ self = .bool(x)
2095+ return
2096+ }
2097+ if let x = try? container.decode([Int?].self) {
2098+ self = .unionArray(x)
2099+ return
2100+ }
2101+ throw DecodingError.typeMismatch(Shadowable.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Shadowable"))
2102+ }
2103+
2104+ func encode(to encoder: Encoder) throws {
2105+ var container = encoder.singleValueContainer()
2106+ switch self {
2107+ case .bool(let x):
2108+ try container.encode(x)
2109+ case .unionArray(let x):
2110+ try container.encode(x)
2111+ }
2112+ }
2113+}
2114+
2115+enum SisteringElement: Codable {
2116+ case integer(Int)
2117+ case nullArray([JSONNull?])
2118+ case sisteringClass(SisteringClass)
2119+
2120+ init(from decoder: Decoder) throws {
2121+ let container = try decoder.singleValueContainer()
2122+ if let x = try? container.decode(Int.self) {
2123+ self = .integer(x)
2124+ return
2125+ }
2126+ if let x = try? container.decode([JSONNull?].self) {
2127+ self = .nullArray(x)
2128+ return
2129+ }
2130+ if let x = try? container.decode(SisteringClass.self) {
2131+ self = .sisteringClass(x)
2132+ return
2133+ }
2134+ throw DecodingError.typeMismatch(SisteringElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for SisteringElement"))
2135+ }
2136+
2137+ func encode(to encoder: Encoder) throws {
2138+ var container = encoder.singleValueContainer()
2139+ switch self {
2140+ case .integer(let x):
2141+ try container.encode(x)
2142+ case .nullArray(let x):
2143+ try container.encode(x)
2144+ case .sisteringClass(let x):
2145+ try container.encode(x)
2146+ }
2147+ }
2148+}
2149+
2150+// MARK: - SisteringClass
2151+final class SisteringClass: Codable {
2152+ let amphicarpic: JSONNull?
2153+ let chianti: JSONNull?
2154+ let frigorific: JSONNull?
2155+ let haplomi: JSONNull?
2156+ let hyperkinesis: JSONNull?
2157+ let laudable: JSONNull?
2158+ let madwoman: JSONNull?
2159+ let maimedly: JSONNull?
2160+ let micropterygidae: JSONNull?
2161+ let microrhabdus: JSONNull?
2162+ let nondense: JSONNull?
2163+ let phlebemphraxis: JSONNull?
2164+ let redsear: JSONNull?
2165+ let schismatical: JSONNull?
2166+ let tartryl: JSONNull?
2167+ let unabhorred: JSONNull?
2168+ let undeliberateness: JSONNull?
2169+ let unmixable: JSONNull?
2170+ let untruckling: JSONNull?
2171+ let vineal: JSONNull?
2172+
2173+ enum CodingKeys: String, CodingKey {
2174+ case amphicarpic = "amphicarpic"
2175+ case chianti = "Chianti"
2176+ case frigorific = "frigorific"
2177+ case haplomi = "Haplomi"
2178+ case hyperkinesis = "hyperkinesis"
2179+ case laudable = "laudable"
2180+ case madwoman = "madwoman"
2181+ case maimedly = "maimedly"
2182+ case micropterygidae = "Micropterygidae"
2183+ case microrhabdus = "microrhabdus"
2184+ case nondense = "nondense"
2185+ case phlebemphraxis = "phlebemphraxis"
2186+ case redsear = "redsear"
2187+ case schismatical = "schismatical"
2188+ case tartryl = "tartryl"
2189+ case unabhorred = "unabhorred"
2190+ case undeliberateness = "undeliberateness"
2191+ case unmixable = "unmixable"
2192+ case untruckling = "untruckling"
2193+ case vineal = "vineal"
2194+ }
2195+
2196+ 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?) {
2197+ self.amphicarpic = amphicarpic
2198+ self.chianti = chianti
2199+ self.frigorific = frigorific
2200+ self.haplomi = haplomi
2201+ self.hyperkinesis = hyperkinesis
2202+ self.laudable = laudable
2203+ self.madwoman = madwoman
2204+ self.maimedly = maimedly
2205+ self.micropterygidae = micropterygidae
2206+ self.microrhabdus = microrhabdus
2207+ self.nondense = nondense
2208+ self.phlebemphraxis = phlebemphraxis
2209+ self.redsear = redsear
2210+ self.schismatical = schismatical
2211+ self.tartryl = tartryl
2212+ self.unabhorred = unabhorred
2213+ self.undeliberateness = undeliberateness
2214+ self.unmixable = unmixable
2215+ self.untruckling = untruckling
2216+ self.vineal = vineal
2217+ }
2218+}
2219+
2220+// MARK: SisteringClass convenience initializers and mutators
2221+
2222+extension SisteringClass {
2223+ convenience init(data: Data) throws {
2224+ let me = try newJSONDecoder().decode(SisteringClass.self, from: data)
2225+ 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)
2226+ }
2227+
2228+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2229+ guard let data = json.data(using: encoding) else {
2230+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2231+ }
2232+ try self.init(data: data)
2233+ }
2234+
2235+ convenience init(fromURL url: URL) throws {
2236+ try self.init(data: try Data(contentsOf: url))
2237+ }
2238+
2239+ func with(
2240+ amphicarpic: JSONNull?? = nil,
2241+ chianti: JSONNull?? = nil,
2242+ frigorific: JSONNull?? = nil,
2243+ haplomi: JSONNull?? = nil,
2244+ hyperkinesis: JSONNull?? = nil,
2245+ laudable: JSONNull?? = nil,
2246+ madwoman: JSONNull?? = nil,
2247+ maimedly: JSONNull?? = nil,
2248+ micropterygidae: JSONNull?? = nil,
2249+ microrhabdus: JSONNull?? = nil,
2250+ nondense: JSONNull?? = nil,
2251+ phlebemphraxis: JSONNull?? = nil,
2252+ redsear: JSONNull?? = nil,
2253+ schismatical: JSONNull?? = nil,
2254+ tartryl: JSONNull?? = nil,
2255+ unabhorred: JSONNull?? = nil,
2256+ undeliberateness: JSONNull?? = nil,
2257+ unmixable: JSONNull?? = nil,
2258+ untruckling: JSONNull?? = nil,
2259+ vineal: JSONNull?? = nil
2260+ ) -> SisteringClass {
2261+ return SisteringClass(
2262+ amphicarpic: amphicarpic ?? self.amphicarpic,
2263+ chianti: chianti ?? self.chianti,
2264+ frigorific: frigorific ?? self.frigorific,
2265+ haplomi: haplomi ?? self.haplomi,
2266+ hyperkinesis: hyperkinesis ?? self.hyperkinesis,
2267+ laudable: laudable ?? self.laudable,
2268+ madwoman: madwoman ?? self.madwoman,
2269+ maimedly: maimedly ?? self.maimedly,
2270+ micropterygidae: micropterygidae ?? self.micropterygidae,
2271+ microrhabdus: microrhabdus ?? self.microrhabdus,
2272+ nondense: nondense ?? self.nondense,
2273+ phlebemphraxis: phlebemphraxis ?? self.phlebemphraxis,
2274+ redsear: redsear ?? self.redsear,
2275+ schismatical: schismatical ?? self.schismatical,
2276+ tartryl: tartryl ?? self.tartryl,
2277+ unabhorred: unabhorred ?? self.unabhorred,
2278+ undeliberateness: undeliberateness ?? self.undeliberateness,
2279+ unmixable: unmixable ?? self.unmixable,
2280+ untruckling: untruckling ?? self.untruckling,
2281+ vineal: vineal ?? self.vineal
2282+ )
2283+ }
2284+
2285+ func jsonData() throws -> Data {
2286+ return try newJSONEncoder().encode(self)
2287+ }
2288+
2289+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2290+ return String(data: try self.jsonData(), encoding: encoding)
2291+ }
2292+}
2293+
2294+// MARK: - Staghunting
2295+final class Staghunting: Codable {
2296+ let calorimetric: Int?
2297+ let canid: Int?
2298+ let catharticalness: Double?
2299+ let chirotherium: Int?
2300+ let disdiapason: String?
2301+ let ditriglyphic: Int?
2302+ let floriferousness: Int?
2303+ let gamelike: Int?
2304+ let grig: Int?
2305+ let homocerc: Bool?
2306+ let interloan: Int?
2307+ let lithotomy: Int?
2308+ let loric: Int?
2309+ let membranocoriaceous: Int?
2310+ let membranogenic: Int?
2311+ let nonbookish: JSONNull?
2312+ let overtrump: Int?
2313+ let scotino: Int?
2314+ let seasonable: Int?
2315+ let sephen: Int?
2316+ let stigmarioid: Int?
2317+ let tired: Int?
2318+ let trifid: Int?
2319+ let undefeatedly: Int?
2320+ let ungirlish: Int?
2321+
2322+ enum CodingKeys: String, CodingKey {
2323+ case calorimetric = "calorimetric"
2324+ case canid = "canid"
2325+ case catharticalness = "catharticalness"
2326+ case chirotherium = "Chirotherium"
2327+ case disdiapason = "disdiapason"
2328+ case ditriglyphic = "ditriglyphic"
2329+ case floriferousness = "floriferousness"
2330+ case gamelike = "gamelike"
2331+ case grig = "grig"
2332+ case homocerc = "homocerc"
2333+ case interloan = "interloan"
2334+ case lithotomy = "lithotomy"
2335+ case loric = "loric"
2336+ case membranocoriaceous = "membranocoriaceous"
2337+ case membranogenic = "membranogenic"
2338+ case nonbookish = "nonbookish"
2339+ case overtrump = "overtrump"
2340+ case scotino = "scotino"
2341+ case seasonable = "seasonable"
2342+ case sephen = "sephen"
2343+ case stigmarioid = "stigmarioid"
2344+ case tired = "tired"
2345+ case trifid = "trifid"
2346+ case undefeatedly = "undefeatedly"
2347+ case ungirlish = "ungirlish"
2348+ }
2349+
2350+ 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?) {
2351+ self.calorimetric = calorimetric
2352+ self.canid = canid
2353+ self.catharticalness = catharticalness
2354+ self.chirotherium = chirotherium
2355+ self.disdiapason = disdiapason
2356+ self.ditriglyphic = ditriglyphic
2357+ self.floriferousness = floriferousness
2358+ self.gamelike = gamelike
2359+ self.grig = grig
2360+ self.homocerc = homocerc
2361+ self.interloan = interloan
2362+ self.lithotomy = lithotomy
2363+ self.loric = loric
2364+ self.membranocoriaceous = membranocoriaceous
2365+ self.membranogenic = membranogenic
2366+ self.nonbookish = nonbookish
2367+ self.overtrump = overtrump
2368+ self.scotino = scotino
2369+ self.seasonable = seasonable
2370+ self.sephen = sephen
2371+ self.stigmarioid = stigmarioid
2372+ self.tired = tired
2373+ self.trifid = trifid
2374+ self.undefeatedly = undefeatedly
2375+ self.ungirlish = ungirlish
2376+ }
2377+}
2378+
2379+// MARK: Staghunting convenience initializers and mutators
2380+
2381+extension Staghunting {
2382+ convenience init(data: Data) throws {
2383+ let me = try newJSONDecoder().decode(Staghunting.self, from: data)
2384+ 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)
2385+ }
2386+
2387+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2388+ guard let data = json.data(using: encoding) else {
2389+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2390+ }
2391+ try self.init(data: data)
2392+ }
2393+
2394+ convenience init(fromURL url: URL) throws {
2395+ try self.init(data: try Data(contentsOf: url))
2396+ }
2397+
2398+ func with(
2399+ calorimetric: Int?? = nil,
2400+ canid: Int?? = nil,
2401+ catharticalness: Double?? = nil,
2402+ chirotherium: Int?? = nil,
2403+ disdiapason: String?? = nil,
2404+ ditriglyphic: Int?? = nil,
2405+ floriferousness: Int?? = nil,
2406+ gamelike: Int?? = nil,
2407+ grig: Int?? = nil,
2408+ homocerc: Bool?? = nil,
2409+ interloan: Int?? = nil,
2410+ lithotomy: Int?? = nil,
2411+ loric: Int?? = nil,
2412+ membranocoriaceous: Int?? = nil,
2413+ membranogenic: Int?? = nil,
2414+ nonbookish: JSONNull?? = nil,
2415+ overtrump: Int?? = nil,
2416+ scotino: Int?? = nil,
2417+ seasonable: Int?? = nil,
2418+ sephen: Int?? = nil,
2419+ stigmarioid: Int?? = nil,
2420+ tired: Int?? = nil,
2421+ trifid: Int?? = nil,
2422+ undefeatedly: Int?? = nil,
2423+ ungirlish: Int?? = nil
2424+ ) -> Staghunting {
2425+ return Staghunting(
2426+ calorimetric: calorimetric ?? self.calorimetric,
2427+ canid: canid ?? self.canid,
2428+ catharticalness: catharticalness ?? self.catharticalness,
2429+ chirotherium: chirotherium ?? self.chirotherium,
2430+ disdiapason: disdiapason ?? self.disdiapason,
2431+ ditriglyphic: ditriglyphic ?? self.ditriglyphic,
2432+ floriferousness: floriferousness ?? self.floriferousness,
2433+ gamelike: gamelike ?? self.gamelike,
2434+ grig: grig ?? self.grig,
2435+ homocerc: homocerc ?? self.homocerc,
2436+ interloan: interloan ?? self.interloan,
2437+ lithotomy: lithotomy ?? self.lithotomy,
2438+ loric: loric ?? self.loric,
2439+ membranocoriaceous: membranocoriaceous ?? self.membranocoriaceous,
2440+ membranogenic: membranogenic ?? self.membranogenic,
2441+ nonbookish: nonbookish ?? self.nonbookish,
2442+ overtrump: overtrump ?? self.overtrump,
2443+ scotino: scotino ?? self.scotino,
2444+ seasonable: seasonable ?? self.seasonable,
2445+ sephen: sephen ?? self.sephen,
2446+ stigmarioid: stigmarioid ?? self.stigmarioid,
2447+ tired: tired ?? self.tired,
2448+ trifid: trifid ?? self.trifid,
2449+ undefeatedly: undefeatedly ?? self.undefeatedly,
2450+ ungirlish: ungirlish ?? self.ungirlish
2451+ )
2452+ }
2453+
2454+ func jsonData() throws -> Data {
2455+ return try newJSONEncoder().encode(self)
2456+ }
2457+
2458+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2459+ return String(data: try self.jsonData(), encoding: encoding)
2460+ }
2461+}
2462+
2463+enum Stagmometer: Codable {
2464+ case string(String)
2465+ case unionArray([Int?])
2466+
2467+ init(from decoder: Decoder) throws {
2468+ let container = try decoder.singleValueContainer()
2469+ if let x = try? container.decode([Int?].self) {
2470+ self = .unionArray(x)
2471+ return
2472+ }
2473+ if let x = try? container.decode(String.self) {
2474+ self = .string(x)
2475+ return
2476+ }
2477+ throw DecodingError.typeMismatch(Stagmometer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Stagmometer"))
2478+ }
2479+
2480+ func encode(to encoder: Encoder) throws {
2481+ var container = encoder.singleValueContainer()
2482+ switch self {
2483+ case .string(let x):
2484+ try container.encode(x)
2485+ case .unionArray(let x):
2486+ try container.encode(x)
2487+ }
2488+ }
2489+}
2490+
2491+enum Stimulability: Codable {
2492+ case bool(Bool)
2493+ case integer(Int)
2494+ case integerMap([String: Int])
2495+
2496+ init(from decoder: Decoder) throws {
2497+ let container = try decoder.singleValueContainer()
2498+ if let x = try? container.decode(Bool.self) {
2499+ self = .bool(x)
2500+ return
2501+ }
2502+ if let x = try? container.decode(Int.self) {
2503+ self = .integer(x)
2504+ return
2505+ }
2506+ if let x = try? container.decode([String: Int].self) {
2507+ self = .integerMap(x)
2508+ return
2509+ }
2510+ throw DecodingError.typeMismatch(Stimulability.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Stimulability"))
2511+ }
2512+
2513+ func encode(to encoder: Encoder) throws {
2514+ var container = encoder.singleValueContainer()
2515+ switch self {
2516+ case .bool(let x):
2517+ try container.encode(x)
2518+ case .integer(let x):
2519+ try container.encode(x)
2520+ case .integerMap(let x):
2521+ try container.encode(x)
2522+ }
2523+ }
2524+}
2525+
2526+enum Strangleable: Codable {
2527+ case double(Double)
2528+ case nullArray([JSONNull?])
2529+
2530+ init(from decoder: Decoder) throws {
2531+ let container = try decoder.singleValueContainer()
2532+ if let x = try? container.decode([JSONNull?].self) {
2533+ self = .nullArray(x)
2534+ return
2535+ }
2536+ if let x = try? container.decode(Double.self) {
2537+ self = .double(x)
2538+ return
2539+ }
2540+ throw DecodingError.typeMismatch(Strangleable.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Strangleable"))
2541+ }
2542+
2543+ func encode(to encoder: Encoder) throws {
2544+ var container = encoder.singleValueContainer()
2545+ switch self {
2546+ case .double(let x):
2547+ try container.encode(x)
2548+ case .nullArray(let x):
2549+ try container.encode(x)
2550+ }
2551+ }
2552+}
2553+
2554+enum StrenuosityElement: Codable {
2555+ case nullArray([JSONNull?])
2556+ case strenuosityClass(StrenuosityClass)
2557+
2558+ init(from decoder: Decoder) throws {
2559+ let container = try decoder.singleValueContainer()
2560+ if let x = try? container.decode([JSONNull?].self) {
2561+ self = .nullArray(x)
2562+ return
2563+ }
2564+ if let x = try? container.decode(StrenuosityClass.self) {
2565+ self = .strenuosityClass(x)
2566+ return
2567+ }
2568+ throw DecodingError.typeMismatch(StrenuosityElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for StrenuosityElement"))
2569+ }
2570+
2571+ func encode(to encoder: Encoder) throws {
2572+ var container = encoder.singleValueContainer()
2573+ switch self {
2574+ case .nullArray(let x):
2575+ try container.encode(x)
2576+ case .strenuosityClass(let x):
2577+ try container.encode(x)
2578+ }
2579+ }
2580+}
2581+
2582+// MARK: - StrenuosityClass
2583+final class StrenuosityClass: Codable {
2584+ let bliss: Int?
2585+ let buccate: Int?
2586+ let bulletproof: Int?
2587+ let catharticalness: Double?
2588+ let chirotherium: Int?
2589+ let crumblingness: Int?
2590+ let disdiapason: String?
2591+ let engagedly: Int?
2592+ let fightable: Int?
2593+ let hoariness: Int?
2594+ let homocerc: Bool?
2595+ let hypopodium: Int?
2596+ let luxurist: Int?
2597+ let mechanician: Int?
2598+ let nonbookish: JSONNull?
2599+ let onopordon: Int?
2600+ let podgily: Int?
2601+ let reformableness: Int?
2602+ let scatterbrains: Int?
2603+ let seminuria: Int?
2604+ let sodomite: Int?
2605+ let tramp: Int?
2606+ let undueness: Int?
2607+ let worthily: Int?
2608+ let yankeeist: Int?
2609+
2610+ enum CodingKeys: String, CodingKey {
2611+ case bliss = "bliss"
2612+ case buccate = "buccate"
2613+ case bulletproof = "bulletproof"
2614+ case catharticalness = "catharticalness"
2615+ case chirotherium = "Chirotherium"
2616+ case crumblingness = "crumblingness"
2617+ case disdiapason = "disdiapason"
2618+ case engagedly = "engagedly"
2619+ case fightable = "fightable"
2620+ case hoariness = "hoariness"
2621+ case homocerc = "homocerc"
2622+ case hypopodium = "hypopodium"
2623+ case luxurist = "luxurist"
2624+ case mechanician = "mechanician"
2625+ case nonbookish = "nonbookish"
2626+ case onopordon = "Onopordon"
2627+ case podgily = "podgily"
2628+ case reformableness = "reformableness"
2629+ case scatterbrains = "scatterbrains"
2630+ case seminuria = "seminuria"
2631+ case sodomite = "Sodomite"
2632+ case tramp = "tramp"
2633+ case undueness = "undueness"
2634+ case worthily = "worthily"
2635+ case yankeeist = "Yankeeist"
2636+ }
2637+
2638+ 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?) {
2639+ self.bliss = bliss
2640+ self.buccate = buccate
2641+ self.bulletproof = bulletproof
2642+ self.catharticalness = catharticalness
2643+ self.chirotherium = chirotherium
2644+ self.crumblingness = crumblingness
2645+ self.disdiapason = disdiapason
2646+ self.engagedly = engagedly
2647+ self.fightable = fightable
2648+ self.hoariness = hoariness
2649+ self.homocerc = homocerc
2650+ self.hypopodium = hypopodium
2651+ self.luxurist = luxurist
2652+ self.mechanician = mechanician
2653+ self.nonbookish = nonbookish
2654+ self.onopordon = onopordon
2655+ self.podgily = podgily
2656+ self.reformableness = reformableness
2657+ self.scatterbrains = scatterbrains
2658+ self.seminuria = seminuria
2659+ self.sodomite = sodomite
2660+ self.tramp = tramp
2661+ self.undueness = undueness
2662+ self.worthily = worthily
2663+ self.yankeeist = yankeeist
2664+ }
2665+}
2666+
2667+// MARK: StrenuosityClass convenience initializers and mutators
2668+
2669+extension StrenuosityClass {
2670+ convenience init(data: Data) throws {
2671+ let me = try newJSONDecoder().decode(StrenuosityClass.self, from: data)
2672+ 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)
2673+ }
2674+
2675+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2676+ guard let data = json.data(using: encoding) else {
2677+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2678+ }
2679+ try self.init(data: data)
2680+ }
2681+
2682+ convenience init(fromURL url: URL) throws {
2683+ try self.init(data: try Data(contentsOf: url))
2684+ }
2685+
2686+ func with(
2687+ bliss: Int?? = nil,
2688+ buccate: Int?? = nil,
2689+ bulletproof: Int?? = nil,
2690+ catharticalness: Double?? = nil,
2691+ chirotherium: Int?? = nil,
2692+ crumblingness: Int?? = nil,
2693+ disdiapason: String?? = nil,
2694+ engagedly: Int?? = nil,
2695+ fightable: Int?? = nil,
2696+ hoariness: Int?? = nil,
2697+ homocerc: Bool?? = nil,
2698+ hypopodium: Int?? = nil,
2699+ luxurist: Int?? = nil,
2700+ mechanician: Int?? = nil,
2701+ nonbookish: JSONNull?? = nil,
2702+ onopordon: Int?? = nil,
2703+ podgily: Int?? = nil,
2704+ reformableness: Int?? = nil,
2705+ scatterbrains: Int?? = nil,
2706+ seminuria: Int?? = nil,
2707+ sodomite: Int?? = nil,
2708+ tramp: Int?? = nil,
2709+ undueness: Int?? = nil,
2710+ worthily: Int?? = nil,
2711+ yankeeist: Int?? = nil
2712+ ) -> StrenuosityClass {
2713+ return StrenuosityClass(
2714+ bliss: bliss ?? self.bliss,
2715+ buccate: buccate ?? self.buccate,
2716+ bulletproof: bulletproof ?? self.bulletproof,
2717+ catharticalness: catharticalness ?? self.catharticalness,
2718+ chirotherium: chirotherium ?? self.chirotherium,
2719+ crumblingness: crumblingness ?? self.crumblingness,
2720+ disdiapason: disdiapason ?? self.disdiapason,
2721+ engagedly: engagedly ?? self.engagedly,
2722+ fightable: fightable ?? self.fightable,
2723+ hoariness: hoariness ?? self.hoariness,
2724+ homocerc: homocerc ?? self.homocerc,
2725+ hypopodium: hypopodium ?? self.hypopodium,
2726+ luxurist: luxurist ?? self.luxurist,
2727+ mechanician: mechanician ?? self.mechanician,
2728+ nonbookish: nonbookish ?? self.nonbookish,
2729+ onopordon: onopordon ?? self.onopordon,
2730+ podgily: podgily ?? self.podgily,
2731+ reformableness: reformableness ?? self.reformableness,
2732+ scatterbrains: scatterbrains ?? self.scatterbrains,
2733+ seminuria: seminuria ?? self.seminuria,
2734+ sodomite: sodomite ?? self.sodomite,
2735+ tramp: tramp ?? self.tramp,
2736+ undueness: undueness ?? self.undueness,
2737+ worthily: worthily ?? self.worthily,
2738+ yankeeist: yankeeist ?? self.yankeeist
2739+ )
2740+ }
2741+
2742+ func jsonData() throws -> Data {
2743+ return try newJSONEncoder().encode(self)
2744+ }
2745+
2746+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2747+ return String(data: try self.jsonData(), encoding: encoding)
2748+ }
2749+}
2750+
2751+enum Tabaxir: Codable {
2752+ case bool(Bool)
2753+ case double(Double)
2754+
2755+ init(from decoder: Decoder) throws {
2756+ let container = try decoder.singleValueContainer()
2757+ if let x = try? container.decode(Bool.self) {
2758+ self = .bool(x)
2759+ return
2760+ }
2761+ if let x = try? container.decode(Double.self) {
2762+ self = .double(x)
2763+ return
2764+ }
2765+ throw DecodingError.typeMismatch(Tabaxir.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Tabaxir"))
2766+ }
2767+
2768+ func encode(to encoder: Encoder) throws {
2769+ var container = encoder.singleValueContainer()
2770+ switch self {
2771+ case .bool(let x):
2772+ try container.encode(x)
2773+ case .double(let x):
2774+ try container.encode(x)
2775+ }
2776+ }
2777+}
2778+
2779+enum Talpiform: Codable {
2780+ case double(Double)
2781+ case quebrachineClass(QuebrachineClass)
2782+ case null
2783+
2784+ init(from decoder: Decoder) throws {
2785+ let container = try decoder.singleValueContainer()
2786+ if let x = try? container.decode(Double.self) {
2787+ self = .double(x)
2788+ return
2789+ }
2790+ if let x = try? container.decode(QuebrachineClass.self) {
2791+ self = .quebrachineClass(x)
2792+ return
2793+ }
2794+ if container.decodeNil() {
2795+ self = .null
2796+ return
2797+ }
2798+ throw DecodingError.typeMismatch(Talpiform.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Talpiform"))
2799+ }
2800+
2801+ func encode(to encoder: Encoder) throws {
2802+ var container = encoder.singleValueContainer()
2803+ switch self {
2804+ case .double(let x):
2805+ try container.encode(x)
2806+ case .quebrachineClass(let x):
2807+ try container.encode(x)
2808+ case .null:
2809+ try container.encodeNil()
2810+ }
2811+ }
2812+}
2813+
2814+enum Thwack: Codable {
2815+ case bool(Bool)
2816+ case double(Double)
2817+ case quebrachineClass(QuebrachineClass)
2818+
2819+ init(from decoder: Decoder) throws {
2820+ let container = try decoder.singleValueContainer()
2821+ if let x = try? container.decode(Bool.self) {
2822+ self = .bool(x)
2823+ return
2824+ }
2825+ if let x = try? container.decode(Double.self) {
2826+ self = .double(x)
2827+ return
2828+ }
2829+ if let x = try? container.decode(QuebrachineClass.self) {
2830+ self = .quebrachineClass(x)
2831+ return
2832+ }
2833+ throw DecodingError.typeMismatch(Thwack.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Thwack"))
2834+ }
2835+
2836+ func encode(to encoder: Encoder) throws {
2837+ var container = encoder.singleValueContainer()
2838+ switch self {
2839+ case .bool(let x):
2840+ try container.encode(x)
2841+ case .double(let x):
2842+ try container.encode(x)
2843+ case .quebrachineClass(let x):
2844+ try container.encode(x)
2845+ }
2846+ }
2847+}
2848+
2849+enum Tortricine: Codable {
2850+ case quebrachineClass(QuebrachineClass)
2851+ case unionArray([Int?])
2852+
2853+ init(from decoder: Decoder) throws {
2854+ let container = try decoder.singleValueContainer()
2855+ if let x = try? container.decode([Int?].self) {
2856+ self = .unionArray(x)
2857+ return
2858+ }
2859+ if let x = try? container.decode(QuebrachineClass.self) {
2860+ self = .quebrachineClass(x)
2861+ return
2862+ }
2863+ throw DecodingError.typeMismatch(Tortricine.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Tortricine"))
2864+ }
2865+
2866+ func encode(to encoder: Encoder) throws {
2867+ var container = encoder.singleValueContainer()
2868+ switch self {
2869+ case .quebrachineClass(let x):
2870+ try container.encode(x)
2871+ case .unionArray(let x):
2872+ try container.encode(x)
2873+ }
2874+ }
2875+}
2876+
2877+enum TruantcyElement: Codable {
2878+ case bool(Bool)
2879+ case truantcyClass(TruantcyClass)
2880+
2881+ init(from decoder: Decoder) throws {
2882+ let container = try decoder.singleValueContainer()
2883+ if let x = try? container.decode(Bool.self) {
2884+ self = .bool(x)
2885+ return
2886+ }
2887+ if let x = try? container.decode(TruantcyClass.self) {
2888+ self = .truantcyClass(x)
2889+ return
2890+ }
2891+ throw DecodingError.typeMismatch(TruantcyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for TruantcyElement"))
2892+ }
2893+
2894+ func encode(to encoder: Encoder) throws {
2895+ var container = encoder.singleValueContainer()
2896+ switch self {
2897+ case .bool(let x):
2898+ try container.encode(x)
2899+ case .truantcyClass(let x):
2900+ try container.encode(x)
2901+ }
2902+ }
2903+}
2904+
2905+// MARK: - TruantcyClass
2906+final class TruantcyClass: Codable {
2907+ let alfiona: JSONNull?
2908+ let ascaridiasis: JSONNull?
2909+ let bungey: JSONNull?
2910+ let catharticalness: Double?
2911+ let ceroxyle: JSONNull?
2912+ let chirotherium: Int?
2913+ let chorology: JSONNull?
2914+ let disdiapason: String?
2915+ let enmarble: JSONNull?
2916+ let epeira: JSONNull?
2917+ let eurylaimi: JSONNull?
2918+ let germination: JSONNull?
2919+ let hallelujah: JSONNull?
2920+ let homocerc: Bool?
2921+ let lev: JSONNull?
2922+ let mouthing: JSONNull?
2923+ let nonbookish: JSONNull?
2924+ let philliloo: JSONNull?
2925+ let planetal: JSONNull?
2926+ let poney: JSONNull?
2927+ let punctualist: JSONNull?
2928+ let returnlessly: JSONNull?
2929+ let skelder: JSONNull?
2930+ let windwaywardly: JSONNull?
2931+ let yuman: JSONNull?
2932+
2933+ enum CodingKeys: String, CodingKey {
2934+ case alfiona = "alfiona"
2935+ case ascaridiasis = "ascaridiasis"
2936+ case bungey = "bungey"
2937+ case catharticalness = "catharticalness"
2938+ case ceroxyle = "ceroxyle"
2939+ case chirotherium = "Chirotherium"
2940+ case chorology = "chorology"
2941+ case disdiapason = "disdiapason"
2942+ case enmarble = "enmarble"
2943+ case epeira = "Epeira"
2944+ case eurylaimi = "Eurylaimi"
2945+ case germination = "germination"
2946+ case hallelujah = "hallelujah"
2947+ case homocerc = "homocerc"
2948+ case lev = "lev"
2949+ case mouthing = "mouthing"
2950+ case nonbookish = "nonbookish"
2951+ case philliloo = "philliloo"
2952+ case planetal = "planetal"
2953+ case poney = "poney"
2954+ case punctualist = "punctualist"
2955+ case returnlessly = "returnlessly"
2956+ case skelder = "skelder"
2957+ case windwaywardly = "windwaywardly"
2958+ case yuman = "Yuman"
2959+ }
2960+
2961+ 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?) {
2962+ self.alfiona = alfiona
2963+ self.ascaridiasis = ascaridiasis
2964+ self.bungey = bungey
2965+ self.catharticalness = catharticalness
2966+ self.ceroxyle = ceroxyle
2967+ self.chirotherium = chirotherium
2968+ self.chorology = chorology
2969+ self.disdiapason = disdiapason
2970+ self.enmarble = enmarble
2971+ self.epeira = epeira
2972+ self.eurylaimi = eurylaimi
2973+ self.germination = germination
2974+ self.hallelujah = hallelujah
2975+ self.homocerc = homocerc
2976+ self.lev = lev
2977+ self.mouthing = mouthing
2978+ self.nonbookish = nonbookish
2979+ self.philliloo = philliloo
2980+ self.planetal = planetal
2981+ self.poney = poney
2982+ self.punctualist = punctualist
2983+ self.returnlessly = returnlessly
2984+ self.skelder = skelder
2985+ self.windwaywardly = windwaywardly
2986+ self.yuman = yuman
2987+ }
2988+}
2989+
2990+// MARK: TruantcyClass convenience initializers and mutators
2991+
2992+extension TruantcyClass {
2993+ convenience init(data: Data) throws {
2994+ let me = try newJSONDecoder().decode(TruantcyClass.self, from: data)
2995+ 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)
2996+ }
2997+
2998+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2999+ guard let data = json.data(using: encoding) else {
3000+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
3001+ }
3002+ try self.init(data: data)
3003+ }
3004+
3005+ convenience init(fromURL url: URL) throws {
3006+ try self.init(data: try Data(contentsOf: url))
3007+ }
3008+
3009+ func with(
3010+ alfiona: JSONNull?? = nil,
3011+ ascaridiasis: JSONNull?? = nil,
3012+ bungey: JSONNull?? = nil,
3013+ catharticalness: Double?? = nil,
3014+ ceroxyle: JSONNull?? = nil,
3015+ chirotherium: Int?? = nil,
3016+ chorology: JSONNull?? = nil,
3017+ disdiapason: String?? = nil,
3018+ enmarble: JSONNull?? = nil,
3019+ epeira: JSONNull?? = nil,
3020+ eurylaimi: JSONNull?? = nil,
3021+ germination: JSONNull?? = nil,
3022+ hallelujah: JSONNull?? = nil,
3023+ homocerc: Bool?? = nil,
3024+ lev: JSONNull?? = nil,
3025+ mouthing: JSONNull?? = nil,
3026+ nonbookish: JSONNull?? = nil,
3027+ philliloo: JSONNull?? = nil,
3028+ planetal: JSONNull?? = nil,
3029+ poney: JSONNull?? = nil,
3030+ punctualist: JSONNull?? = nil,
3031+ returnlessly: JSONNull?? = nil,
3032+ skelder: JSONNull?? = nil,
3033+ windwaywardly: JSONNull?? = nil,
3034+ yuman: JSONNull?? = nil
3035+ ) -> TruantcyClass {
3036+ return TruantcyClass(
3037+ alfiona: alfiona ?? self.alfiona,
3038+ ascaridiasis: ascaridiasis ?? self.ascaridiasis,
3039+ bungey: bungey ?? self.bungey,
3040+ catharticalness: catharticalness ?? self.catharticalness,
3041+ ceroxyle: ceroxyle ?? self.ceroxyle,
3042+ chirotherium: chirotherium ?? self.chirotherium,
3043+ chorology: chorology ?? self.chorology,
3044+ disdiapason: disdiapason ?? self.disdiapason,
3045+ enmarble: enmarble ?? self.enmarble,
3046+ epeira: epeira ?? self.epeira,
3047+ eurylaimi: eurylaimi ?? self.eurylaimi,
3048+ germination: germination ?? self.germination,
3049+ hallelujah: hallelujah ?? self.hallelujah,
3050+ homocerc: homocerc ?? self.homocerc,
3051+ lev: lev ?? self.lev,
3052+ mouthing: mouthing ?? self.mouthing,
3053+ nonbookish: nonbookish ?? self.nonbookish,
3054+ philliloo: philliloo ?? self.philliloo,
3055+ planetal: planetal ?? self.planetal,
3056+ poney: poney ?? self.poney,
3057+ punctualist: punctualist ?? self.punctualist,
3058+ returnlessly: returnlessly ?? self.returnlessly,
3059+ skelder: skelder ?? self.skelder,
3060+ windwaywardly: windwaywardly ?? self.windwaywardly,
3061+ yuman: yuman ?? self.yuman
3062+ )
3063+ }
3064+
3065+ func jsonData() throws -> Data {
3066+ return try newJSONEncoder().encode(self)
3067+ }
3068+
3069+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
3070+ return String(data: try self.jsonData(), encoding: encoding)
3071+ }
3072+}
3073+
3074+enum Unbeginning: Codable {
3075+ case integerMap([String: Int])
3076+ case nullArray([JSONNull?])
3077+ case string(String)
3078+
3079+ init(from decoder: Decoder) throws {
3080+ let container = try decoder.singleValueContainer()
3081+ if let x = try? container.decode([JSONNull?].self) {
3082+ self = .nullArray(x)
3083+ return
3084+ }
3085+ if let x = try? container.decode([String: Int].self) {
3086+ self = .integerMap(x)
3087+ return
3088+ }
3089+ if let x = try? container.decode(String.self) {
3090+ self = .string(x)
3091+ return
3092+ }
3093+ throw DecodingError.typeMismatch(Unbeginning.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unbeginning"))
3094+ }
3095+
3096+ func encode(to encoder: Encoder) throws {
3097+ var container = encoder.singleValueContainer()
3098+ switch self {
3099+ case .integerMap(let x):
3100+ try container.encode(x)
3101+ case .nullArray(let x):
3102+ try container.encode(x)
3103+ case .string(let x):
3104+ try container.encode(x)
3105+ }
3106+ }
3107+}
3108+
3109+enum Undesirability: Codable {
3110+ case integerArray([Int])
3111+ case integerMap([String: Int])
3112+ case string(String)
3113+
3114+ init(from decoder: Decoder) throws {
3115+ let container = try decoder.singleValueContainer()
3116+ if let x = try? container.decode([Int].self) {
3117+ self = .integerArray(x)
3118+ return
3119+ }
3120+ if let x = try? container.decode([String: Int].self) {
3121+ self = .integerMap(x)
3122+ return
3123+ }
3124+ if let x = try? container.decode(String.self) {
3125+ self = .string(x)
3126+ return
3127+ }
3128+ throw DecodingError.typeMismatch(Undesirability.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Undesirability"))
3129+ }
3130+
3131+ func encode(to encoder: Encoder) throws {
3132+ var container = encoder.singleValueContainer()
3133+ switch self {
3134+ case .integerArray(let x):
3135+ try container.encode(x)
3136+ case .integerMap(let x):
3137+ try container.encode(x)
3138+ case .string(let x):
3139+ try container.encode(x)
3140+ }
3141+ }
3142+}
3143+
3144+enum Unerasing: Codable {
3145+ case integer(Int)
3146+ case integerMap([String: Int])
3147+ case nullArray([JSONNull?])
3148+
3149+ init(from decoder: Decoder) throws {
3150+ let container = try decoder.singleValueContainer()
3151+ if let x = try? container.decode(Int.self) {
3152+ self = .integer(x)
3153+ return
3154+ }
3155+ if let x = try? container.decode([JSONNull?].self) {
3156+ self = .nullArray(x)
3157+ return
3158+ }
3159+ if let x = try? container.decode([String: Int].self) {
3160+ self = .integerMap(x)
3161+ return
3162+ }
3163+ throw DecodingError.typeMismatch(Unerasing.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unerasing"))
3164+ }
3165+
3166+ func encode(to encoder: Encoder) throws {
3167+ var container = encoder.singleValueContainer()
3168+ switch self {
3169+ case .integer(let x):
3170+ try container.encode(x)
3171+ case .integerMap(let x):
3172+ try container.encode(x)
3173+ case .nullArray(let x):
3174+ try container.encode(x)
3175+ }
3176+ }
3177+}
3178+
3179+enum Unguentarium: Codable {
3180+ case integer(Int)
3181+ case nullArray([JSONNull?])
3182+ case null
3183+
3184+ init(from decoder: Decoder) throws {
3185+ let container = try decoder.singleValueContainer()
3186+ if let x = try? container.decode(Int.self) {
3187+ self = .integer(x)
3188+ return
3189+ }
3190+ if let x = try? container.decode([JSONNull?].self) {
3191+ self = .nullArray(x)
3192+ return
3193+ }
3194+ if container.decodeNil() {
3195+ self = .null
3196+ return
3197+ }
3198+ throw DecodingError.typeMismatch(Unguentarium.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unguentarium"))
3199+ }
3200+
3201+ func encode(to encoder: Encoder) throws {
3202+ var container = encoder.singleValueContainer()
3203+ switch self {
3204+ case .integer(let x):
3205+ try container.encode(x)
3206+ case .nullArray(let x):
3207+ try container.encode(x)
3208+ case .null:
3209+ try container.encodeNil()
3210+ }
3211+ }
3212+}
3213+
3214+enum UnimpeachablyElement: Codable {
3215+ case bool(Bool)
3216+ case unimpeachablyClass(UnimpeachablyClass)
3217+
3218+ init(from decoder: Decoder) throws {
3219+ let container = try decoder.singleValueContainer()
3220+ if let x = try? container.decode(Bool.self) {
3221+ self = .bool(x)
3222+ return
3223+ }
3224+ if let x = try? container.decode(UnimpeachablyClass.self) {
3225+ self = .unimpeachablyClass(x)
3226+ return
3227+ }
3228+ throw DecodingError.typeMismatch(UnimpeachablyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for UnimpeachablyElement"))
3229+ }
3230+
3231+ func encode(to encoder: Encoder) throws {
3232+ var container = encoder.singleValueContainer()
3233+ switch self {
3234+ case .bool(let x):
3235+ try container.encode(x)
3236+ case .unimpeachablyClass(let x):
3237+ try container.encode(x)
3238+ }
3239+ }
3240+}
3241+
3242+// MARK: - UnimpeachablyClass
3243+final class UnimpeachablyClass: Codable {
3244+ let acerin: Int?
3245+ let bobadil: Int?
3246+ let catharticalness: Double?
3247+ let chirotherium: Int?
3248+ let chlorophylligenous: Int?
3249+ let conversational: Int?
3250+ let demiowl: Int?
3251+ let disdiapason: String?
3252+ let ectorhinal: Int?
3253+ let gamblesomeness: Int?
3254+ let homocerc: Bool?
3255+ let irrorate: Int?
3256+ let kindergartening: Int?
3257+ let lateritic: Int?
3258+ let mespil: Int?
3259+ let misconfiguration: Int?
3260+ let nonbookish: JSONNull?
3261+ let planometry: Int?
3262+ let quiina: Int?
3263+ let robert: Int?
3264+ let rot: Int?
3265+ let subcinctorium: Int?
3266+ let tussocker: Int?
3267+ let ultraproud: Int?
3268+ let unsuggestedness: Int?
3269+
3270+ enum CodingKeys: String, CodingKey {
3271+ case acerin = "acerin"
3272+ case bobadil = "Bobadil"
3273+ case catharticalness = "catharticalness"
3274+ case chirotherium = "Chirotherium"
3275+ case chlorophylligenous = "chlorophylligenous"
3276+ case conversational = "conversational"
3277+ case demiowl = "demiowl"
3278+ case disdiapason = "disdiapason"
3279+ case ectorhinal = "ectorhinal"
3280+ case gamblesomeness = "gamblesomeness"
3281+ case homocerc = "homocerc"
3282+ case irrorate = "irrorate"
3283+ case kindergartening = "kindergartening"
3284+ case lateritic = "lateritic"
3285+ case mespil = "mespil"
3286+ case misconfiguration = "misconfiguration"
3287+ case nonbookish = "nonbookish"
3288+ case planometry = "planometry"
3289+ case quiina = "Quiina"
3290+ case robert = "Robert"
3291+ case rot = "rot"
3292+ case subcinctorium = "subcinctorium"
3293+ case tussocker = "tussocker"
3294+ case ultraproud = "ultraproud"
3295+ case unsuggestedness = "unsuggestedness"
3296+ }
3297+
3298+ 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?) {
3299+ self.acerin = acerin
3300+ self.bobadil = bobadil
3301+ self.catharticalness = catharticalness
3302+ self.chirotherium = chirotherium
3303+ self.chlorophylligenous = chlorophylligenous
3304+ self.conversational = conversational
3305+ self.demiowl = demiowl
3306+ self.disdiapason = disdiapason
3307+ self.ectorhinal = ectorhinal
3308+ self.gamblesomeness = gamblesomeness
3309+ self.homocerc = homocerc
3310+ self.irrorate = irrorate
3311+ self.kindergartening = kindergartening
3312+ self.lateritic = lateritic
3313+ self.mespil = mespil
3314+ self.misconfiguration = misconfiguration
3315+ self.nonbookish = nonbookish
3316+ self.planometry = planometry
3317+ self.quiina = quiina
3318+ self.robert = robert
3319+ self.rot = rot
3320+ self.subcinctorium = subcinctorium
3321+ self.tussocker = tussocker
3322+ self.ultraproud = ultraproud
3323+ self.unsuggestedness = unsuggestedness
3324+ }
3325+}
3326+
3327+// MARK: UnimpeachablyClass convenience initializers and mutators
3328+
3329+extension UnimpeachablyClass {
3330+ convenience init(data: Data) throws {
3331+ let me = try newJSONDecoder().decode(UnimpeachablyClass.self, from: data)
3332+ 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)
3333+ }
3334+
3335+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
3336+ guard let data = json.data(using: encoding) else {
3337+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
3338+ }
3339+ try self.init(data: data)
3340+ }
3341+
3342+ convenience init(fromURL url: URL) throws {
3343+ try self.init(data: try Data(contentsOf: url))
3344+ }
3345+
3346+ func with(
3347+ acerin: Int?? = nil,
3348+ bobadil: Int?? = nil,
3349+ catharticalness: Double?? = nil,
3350+ chirotherium: Int?? = nil,
3351+ chlorophylligenous: Int?? = nil,
3352+ conversational: Int?? = nil,
3353+ demiowl: Int?? = nil,
3354+ disdiapason: String?? = nil,
3355+ ectorhinal: Int?? = nil,
3356+ gamblesomeness: Int?? = nil,
3357+ homocerc: Bool?? = nil,
3358+ irrorate: Int?? = nil,
3359+ kindergartening: Int?? = nil,
3360+ lateritic: Int?? = nil,
3361+ mespil: Int?? = nil,
3362+ misconfiguration: Int?? = nil,
3363+ nonbookish: JSONNull?? = nil,
3364+ planometry: Int?? = nil,
3365+ quiina: Int?? = nil,
3366+ robert: Int?? = nil,
3367+ rot: Int?? = nil,
3368+ subcinctorium: Int?? = nil,
3369+ tussocker: Int?? = nil,
3370+ ultraproud: Int?? = nil,
3371+ unsuggestedness: Int?? = nil
3372+ ) -> UnimpeachablyClass {
3373+ return UnimpeachablyClass(
3374+ acerin: acerin ?? self.acerin,
3375+ bobadil: bobadil ?? self.bobadil,
3376+ catharticalness: catharticalness ?? self.catharticalness,
3377+ chirotherium: chirotherium ?? self.chirotherium,
3378+ chlorophylligenous: chlorophylligenous ?? self.chlorophylligenous,
3379+ conversational: conversational ?? self.conversational,
3380+ demiowl: demiowl ?? self.demiowl,
3381+ disdiapason: disdiapason ?? self.disdiapason,
3382+ ectorhinal: ectorhinal ?? self.ectorhinal,
3383+ gamblesomeness: gamblesomeness ?? self.gamblesomeness,
3384+ homocerc: homocerc ?? self.homocerc,
3385+ irrorate: irrorate ?? self.irrorate,
3386+ kindergartening: kindergartening ?? self.kindergartening,
3387+ lateritic: lateritic ?? self.lateritic,
3388+ mespil: mespil ?? self.mespil,
3389+ misconfiguration: misconfiguration ?? self.misconfiguration,
3390+ nonbookish: nonbookish ?? self.nonbookish,
3391+ planometry: planometry ?? self.planometry,
3392+ quiina: quiina ?? self.quiina,
3393+ robert: robert ?? self.robert,
3394+ rot: rot ?? self.rot,
3395+ subcinctorium: subcinctorium ?? self.subcinctorium,
3396+ tussocker: tussocker ?? self.tussocker,
3397+ ultraproud: ultraproud ?? self.ultraproud,
3398+ unsuggestedness: unsuggestedness ?? self.unsuggestedness
3399+ )
3400+ }
3401+
3402+ func jsonData() throws -> Data {
3403+ return try newJSONEncoder().encode(self)
3404+ }
3405+
3406+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
3407+ return String(data: try self.jsonData(), encoding: encoding)
3408+ }
3409+}
3410+
3411+enum Unmortgaged: Codable {
3412+ case double(Double)
3413+ case integerMap([String: Int])
3414+ case null
3415+
3416+ init(from decoder: Decoder) throws {
3417+ let container = try decoder.singleValueContainer()
3418+ if let x = try? container.decode(Double.self) {
3419+ self = .double(x)
3420+ return
3421+ }
3422+ if let x = try? container.decode([String: Int].self) {
3423+ self = .integerMap(x)
3424+ return
3425+ }
3426+ if container.decodeNil() {
3427+ self = .null
3428+ return
3429+ }
3430+ throw DecodingError.typeMismatch(Unmortgaged.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unmortgaged"))
3431+ }
3432+
3433+ func encode(to encoder: Encoder) throws {
3434+ var container = encoder.singleValueContainer()
3435+ switch self {
3436+ case .double(let x):
3437+ try container.encode(x)
3438+ case .integerMap(let x):
3439+ try container.encode(x)
3440+ case .null:
3441+ try container.encodeNil()
3442+ }
3443+ }
3444+}
3445+
3446+enum Unobstructed: Codable {
3447+ case integer(Int)
3448+ case quebrachineClass(QuebrachineClass)
3449+ case null
3450+
3451+ init(from decoder: Decoder) throws {
3452+ let container = try decoder.singleValueContainer()
3453+ if let x = try? container.decode(Int.self) {
3454+ self = .integer(x)
3455+ return
3456+ }
3457+ if let x = try? container.decode(QuebrachineClass.self) {
3458+ self = .quebrachineClass(x)
3459+ return
3460+ }
3461+ if container.decodeNil() {
3462+ self = .null
3463+ return
3464+ }
3465+ throw DecodingError.typeMismatch(Unobstructed.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unobstructed"))
3466+ }
3467+
3468+ func encode(to encoder: Encoder) throws {
3469+ var container = encoder.singleValueContainer()
3470+ switch self {
3471+ case .integer(let x):
3472+ try container.encode(x)
3473+ case .quebrachineClass(let x):
3474+ try container.encode(x)
3475+ case .null:
3476+ try container.encodeNil()
3477+ }
3478+ }
3479+}
3480+
3481+enum Unreceptivity: Codable {
3482+ case integer(Int)
3483+ case nullArray([JSONNull?])
3484+ case string(String)
3485+
3486+ init(from decoder: Decoder) throws {
3487+ let container = try decoder.singleValueContainer()
3488+ if let x = try? container.decode(Int.self) {
3489+ self = .integer(x)
3490+ return
3491+ }
3492+ if let x = try? container.decode([JSONNull?].self) {
3493+ self = .nullArray(x)
3494+ return
3495+ }
3496+ if let x = try? container.decode(String.self) {
3497+ self = .string(x)
3498+ return
3499+ }
3500+ throw DecodingError.typeMismatch(Unreceptivity.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unreceptivity"))
3501+ }
3502+
3503+ func encode(to encoder: Encoder) throws {
3504+ var container = encoder.singleValueContainer()
3505+ switch self {
3506+ case .integer(let x):
3507+ try container.encode(x)
3508+ case .nullArray(let x):
3509+ try container.encode(x)
3510+ case .string(let x):
3511+ try container.encode(x)
3512+ }
3513+ }
3514+}
3515+
3516+enum Unsatisfactoriness: Codable {
3517+ case bool(Bool)
3518+ case integer(Int)
3519+ case integerArray([Int])
3520+
3521+ init(from decoder: Decoder) throws {
3522+ let container = try decoder.singleValueContainer()
3523+ if let x = try? container.decode(Bool.self) {
3524+ self = .bool(x)
3525+ return
3526+ }
3527+ if let x = try? container.decode(Int.self) {
3528+ self = .integer(x)
3529+ return
3530+ }
3531+ if let x = try? container.decode([Int].self) {
3532+ self = .integerArray(x)
3533+ return
3534+ }
3535+ throw DecodingError.typeMismatch(Unsatisfactoriness.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unsatisfactoriness"))
3536+ }
3537+
3538+ func encode(to encoder: Encoder) throws {
3539+ var container = encoder.singleValueContainer()
3540+ switch self {
3541+ case .bool(let x):
3542+ try container.encode(x)
3543+ case .integer(let x):
3544+ try container.encode(x)
3545+ case .integerArray(let x):
3546+ try container.encode(x)
3547+ }
3548+ }
3549+}
3550+
3551+enum UnstressedElement: Codable {
3552+ case bool(Bool)
3553+ case string(String)
3554+ case unstressedClass(UnstressedClass)
3555+
3556+ init(from decoder: Decoder) throws {
3557+ let container = try decoder.singleValueContainer()
3558+ if let x = try? container.decode(Bool.self) {
3559+ self = .bool(x)
3560+ return
3561+ }
3562+ if let x = try? container.decode(String.self) {
3563+ self = .string(x)
3564+ return
3565+ }
3566+ if let x = try? container.decode(UnstressedClass.self) {
3567+ self = .unstressedClass(x)
3568+ return
3569+ }
3570+ throw DecodingError.typeMismatch(UnstressedElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for UnstressedElement"))
3571+ }
3572+
3573+ func encode(to encoder: Encoder) throws {
3574+ var container = encoder.singleValueContainer()
3575+ switch self {
3576+ case .bool(let x):
3577+ try container.encode(x)
3578+ case .string(let x):
3579+ try container.encode(x)
3580+ case .unstressedClass(let x):
3581+ try container.encode(x)
3582+ }
3583+ }
3584+}
3585+
3586+// MARK: - UnstressedClass
3587+final class UnstressedClass: Codable {
3588+ let alain: JSONNull?
3589+ let amphirhina: JSONNull?
3590+ let antimachinery: JSONNull?
3591+ let coldish: JSONNull?
3592+ let crantara: JSONNull?
3593+ let distinguishing: JSONNull?
3594+ let elytroposis: JSONNull?
3595+ let gentianwort: JSONNull?
3596+ let heliosis: JSONNull?
3597+ let instrumental: JSONNull?
3598+ let introinflection: JSONNull?
3599+ let kala: JSONNull?
3600+ let lincolnian: JSONNull?
3601+ let metad: JSONNull?
3602+ let sarcophilus: JSONNull?
3603+ let swingingly: JSONNull?
3604+ let unconformity: JSONNull?
3605+ let undecreed: JSONNull?
3606+ let venerable: JSONNull?
3607+ let vowellessness: JSONNull?
3608+
3609+ enum CodingKeys: String, CodingKey {
3610+ case alain = "Alain"
3611+ case amphirhina = "Amphirhina"
3612+ case antimachinery = "antimachinery"
3613+ case coldish = "coldish"
3614+ case crantara = "crantara"
3615+ case distinguishing = "distinguishing"
3616+ case elytroposis = "elytroposis"
3617+ case gentianwort = "gentianwort"
3618+ case heliosis = "heliosis"
3619+ case instrumental = "instrumental"
3620+ case introinflection = "introinflection"
3621+ case kala = "kala"
3622+ case lincolnian = "Lincolnian"
3623+ case metad = "metad"
3624+ case sarcophilus = "Sarcophilus"
3625+ case swingingly = "swingingly"
3626+ case unconformity = "unconformity"
3627+ case undecreed = "undecreed"
3628+ case venerable = "venerable"
3629+ case vowellessness = "vowellessness"
3630+ }
3631+
3632+ 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?) {
3633+ self.alain = alain
3634+ self.amphirhina = amphirhina
3635+ self.antimachinery = antimachinery
3636+ self.coldish = coldish
3637+ self.crantara = crantara
3638+ self.distinguishing = distinguishing
3639+ self.elytroposis = elytroposis
3640+ self.gentianwort = gentianwort
3641+ self.heliosis = heliosis
3642+ self.instrumental = instrumental
3643+ self.introinflection = introinflection
3644+ self.kala = kala
3645+ self.lincolnian = lincolnian
3646+ self.metad = metad
3647+ self.sarcophilus = sarcophilus
3648+ self.swingingly = swingingly
3649+ self.unconformity = unconformity
3650+ self.undecreed = undecreed
3651+ self.venerable = venerable
3652+ self.vowellessness = vowellessness
3653+ }
3654+}
3655+
3656+// MARK: UnstressedClass convenience initializers and mutators
3657+
3658+extension UnstressedClass {
3659+ convenience init(data: Data) throws {
3660+ let me = try newJSONDecoder().decode(UnstressedClass.self, from: data)
3661+ 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)
3662+ }
3663+
3664+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
3665+ guard let data = json.data(using: encoding) else {
3666+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
3667+ }
3668+ try self.init(data: data)
3669+ }
3670+
3671+ convenience init(fromURL url: URL) throws {
3672+ try self.init(data: try Data(contentsOf: url))
3673+ }
3674+
3675+ func with(
3676+ alain: JSONNull?? = nil,
3677+ amphirhina: JSONNull?? = nil,
3678+ antimachinery: JSONNull?? = nil,
3679+ coldish: JSONNull?? = nil,
3680+ crantara: JSONNull?? = nil,
3681+ distinguishing: JSONNull?? = nil,
3682+ elytroposis: JSONNull?? = nil,
3683+ gentianwort: JSONNull?? = nil,
3684+ heliosis: JSONNull?? = nil,
3685+ instrumental: JSONNull?? = nil,
3686+ introinflection: JSONNull?? = nil,
3687+ kala: JSONNull?? = nil,
3688+ lincolnian: JSONNull?? = nil,
3689+ metad: JSONNull?? = nil,
3690+ sarcophilus: JSONNull?? = nil,
3691+ swingingly: JSONNull?? = nil,
3692+ unconformity: JSONNull?? = nil,
3693+ undecreed: JSONNull?? = nil,
3694+ venerable: JSONNull?? = nil,
3695+ vowellessness: JSONNull?? = nil
3696+ ) -> UnstressedClass {
3697+ return UnstressedClass(
3698+ alain: alain ?? self.alain,
3699+ amphirhina: amphirhina ?? self.amphirhina,
3700+ antimachinery: antimachinery ?? self.antimachinery,
3701+ coldish: coldish ?? self.coldish,
3702+ crantara: crantara ?? self.crantara,
3703+ distinguishing: distinguishing ?? self.distinguishing,
3704+ elytroposis: elytroposis ?? self.elytroposis,
3705+ gentianwort: gentianwort ?? self.gentianwort,
3706+ heliosis: heliosis ?? self.heliosis,
3707+ instrumental: instrumental ?? self.instrumental,
3708+ introinflection: introinflection ?? self.introinflection,
3709+ kala: kala ?? self.kala,
3710+ lincolnian: lincolnian ?? self.lincolnian,
3711+ metad: metad ?? self.metad,
3712+ sarcophilus: sarcophilus ?? self.sarcophilus,
3713+ swingingly: swingingly ?? self.swingingly,
3714+ unconformity: unconformity ?? self.unconformity,
3715+ undecreed: undecreed ?? self.undecreed,
3716+ venerable: venerable ?? self.venerable,
3717+ vowellessness: vowellessness ?? self.vowellessness
3718+ )
3719+ }
3720+
3721+ func jsonData() throws -> Data {
3722+ return try newJSONEncoder().encode(self)
3723+ }
3724+
3725+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
3726+ return String(data: try self.jsonData(), encoding: encoding)
3727+ }
3728+}
3729+
3730+enum Untasked: Codable {
3731+ case double(Double)
3732+ case integerMap([String: Int])
3733+ case nullArray([JSONNull?])
3734+
3735+ init(from decoder: Decoder) throws {
3736+ let container = try decoder.singleValueContainer()
3737+ if let x = try? container.decode([JSONNull?].self) {
3738+ self = .nullArray(x)
3739+ return
3740+ }
3741+ if let x = try? container.decode(Double.self) {
3742+ self = .double(x)
3743+ return
3744+ }
3745+ if let x = try? container.decode([String: Int].self) {
3746+ self = .integerMap(x)
3747+ return
3748+ }
3749+ throw DecodingError.typeMismatch(Untasked.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Untasked"))
3750+ }
3751+
3752+ func encode(to encoder: Encoder) throws {
3753+ var container = encoder.singleValueContainer()
3754+ switch self {
3755+ case .double(let x):
3756+ try container.encode(x)
3757+ case .integerMap(let x):
3758+ try container.encode(x)
3759+ case .nullArray(let x):
3760+ try container.encode(x)
3761+ }
3762+ }
3763+}
3764+
3765+enum Unvarying: Codable {
3766+ case bool(Bool)
3767+ case double(Double)
3768+ case integerMap([String: Int])
3769+
3770+ init(from decoder: Decoder) throws {
3771+ let container = try decoder.singleValueContainer()
3772+ if let x = try? container.decode(Bool.self) {
3773+ self = .bool(x)
3774+ return
3775+ }
3776+ if let x = try? container.decode(Double.self) {
3777+ self = .double(x)
3778+ return
3779+ }
3780+ if let x = try? container.decode([String: Int].self) {
3781+ self = .integerMap(x)
3782+ return
3783+ }
3784+ throw DecodingError.typeMismatch(Unvarying.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unvarying"))
3785+ }
3786+
3787+ func encode(to encoder: Encoder) throws {
3788+ var container = encoder.singleValueContainer()
3789+ switch self {
3790+ case .bool(let x):
3791+ try container.encode(x)
3792+ case .double(let x):
3793+ try container.encode(x)
3794+ case .integerMap(let x):
3795+ try container.encode(x)
3796+ }
3797+ }
3798+}
3799+
3800+enum Vehemently: Codable {
3801+ case bool(Bool)
3802+ case nullArray([JSONNull?])
3803+ case null
3804+
3805+ init(from decoder: Decoder) throws {
3806+ let container = try decoder.singleValueContainer()
3807+ if let x = try? container.decode(Bool.self) {
3808+ self = .bool(x)
3809+ return
3810+ }
3811+ if let x = try? container.decode([JSONNull?].self) {
3812+ self = .nullArray(x)
3813+ return
3814+ }
3815+ if container.decodeNil() {
3816+ self = .null
3817+ return
3818+ }
3819+ throw DecodingError.typeMismatch(Vehemently.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Vehemently"))
3820+ }
3821+
3822+ func encode(to encoder: Encoder) throws {
3823+ var container = encoder.singleValueContainer()
3824+ switch self {
3825+ case .bool(let x):
3826+ try container.encode(x)
3827+ case .nullArray(let x):
3828+ try container.encode(x)
3829+ case .null:
3830+ try container.encodeNil()
3831+ }
3832+ }
3833+}
3834+
3835+enum Whitepot: Codable {
3836+ case double(Double)
3837+ case quebrachineClass(QuebrachineClass)
3838+
3839+ init(from decoder: Decoder) throws {
3840+ let container = try decoder.singleValueContainer()
3841+ if let x = try? container.decode(Double.self) {
3842+ self = .double(x)
3843+ return
3844+ }
3845+ if let x = try? container.decode(QuebrachineClass.self) {
3846+ self = .quebrachineClass(x)
3847+ return
3848+ }
3849+ throw DecodingError.typeMismatch(Whitepot.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Whitepot"))
3850+ }
3851+
3852+ func encode(to encoder: Encoder) throws {
3853+ var container = encoder.singleValueContainer()
3854+ switch self {
3855+ case .double(let x):
3856+ try container.encode(x)
3857+ case .quebrachineClass(let x):
3858+ try container.encode(x)
3859+ }
3860+ }
3861+}
3862+
3863+enum WrothyElement: Codable {
3864+ case nullArray([JSONNull?])
3865+ case wrothyClass(WrothyClass)
3866+
3867+ init(from decoder: Decoder) throws {
3868+ let container = try decoder.singleValueContainer()
3869+ if let x = try? container.decode([JSONNull?].self) {
3870+ self = .nullArray(x)
3871+ return
3872+ }
3873+ if let x = try? container.decode(WrothyClass.self) {
3874+ self = .wrothyClass(x)
3875+ return
3876+ }
3877+ throw DecodingError.typeMismatch(WrothyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for WrothyElement"))
3878+ }
3879+
3880+ func encode(to encoder: Encoder) throws {
3881+ var container = encoder.singleValueContainer()
3882+ switch self {
3883+ case .nullArray(let x):
3884+ try container.encode(x)
3885+ case .wrothyClass(let x):
3886+ try container.encode(x)
3887+ }
3888+ }
3889+}
3890+
3891+// MARK: - WrothyClass
3892+final class WrothyClass: Codable {
3893+ let aeschynanthus: JSONNull?
3894+ let aquiferous: JSONNull?
3895+ let cheapener: JSONNull?
3896+ let enumeration: JSONNull?
3897+ let ephesine: JSONNull?
3898+ let escadrille: JSONNull?
3899+ let estrous: JSONNull?
3900+ let interestedly: JSONNull?
3901+ let katakinetomer: JSONNull?
3902+ let mortification: JSONNull?
3903+ let morula: JSONNull?
3904+ let orthosymmetrical: JSONNull?
3905+ let overbark: JSONNull?
3906+ let politist: JSONNull?
3907+ let qualified: JSONNull?
3908+ let sphenomalar: JSONNull?
3909+ let throatful: JSONNull?
3910+ let transhumance: JSONNull?
3911+ let triandrian: JSONNull?
3912+ let unbooked: JSONNull?
3913+
3914+ enum CodingKeys: String, CodingKey {
3915+ case aeschynanthus = "Aeschynanthus"
3916+ case aquiferous = "aquiferous"
3917+ case cheapener = "cheapener"
3918+ case enumeration = "enumeration"
3919+ case ephesine = "Ephesine"
3920+ case escadrille = "escadrille"
3921+ case estrous = "estrous"
3922+ case interestedly = "interestedly"
3923+ case katakinetomer = "katakinetomer"
3924+ case mortification = "mortification"
3925+ case morula = "morula"
3926+ case orthosymmetrical = "orthosymmetrical"
3927+ case overbark = "overbark"
3928+ case politist = "politist"
3929+ case qualified = "qualified"
3930+ case sphenomalar = "sphenomalar"
3931+ case throatful = "throatful"
3932+ case transhumance = "transhumance"
3933+ case triandrian = "triandrian"
3934+ case unbooked = "unbooked"
3935+ }
3936+
3937+ 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?) {
3938+ self.aeschynanthus = aeschynanthus
3939+ self.aquiferous = aquiferous
3940+ self.cheapener = cheapener
3941+ self.enumeration = enumeration
3942+ self.ephesine = ephesine
3943+ self.escadrille = escadrille
3944+ self.estrous = estrous
3945+ self.interestedly = interestedly
3946+ self.katakinetomer = katakinetomer
3947+ self.mortification = mortification
3948+ self.morula = morula
3949+ self.orthosymmetrical = orthosymmetrical
3950+ self.overbark = overbark
3951+ self.politist = politist
3952+ self.qualified = qualified
3953+ self.sphenomalar = sphenomalar
3954+ self.throatful = throatful
3955+ self.transhumance = transhumance
3956+ self.triandrian = triandrian
3957+ self.unbooked = unbooked
3958+ }
3959+}
3960+
3961+// MARK: WrothyClass convenience initializers and mutators
3962+
3963+extension WrothyClass {
3964+ convenience init(data: Data) throws {
3965+ let me = try newJSONDecoder().decode(WrothyClass.self, from: data)
3966+ 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)
3967+ }
3968+
3969+ convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
3970+ guard let data = json.data(using: encoding) else {
3971+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
3972+ }
3973+ try self.init(data: data)
3974+ }
3975+
3976+ convenience init(fromURL url: URL) throws {
3977+ try self.init(data: try Data(contentsOf: url))
3978+ }
3979+
3980+ func with(
3981+ aeschynanthus: JSONNull?? = nil,
3982+ aquiferous: JSONNull?? = nil,
3983+ cheapener: JSONNull?? = nil,
3984+ enumeration: JSONNull?? = nil,
3985+ ephesine: JSONNull?? = nil,
3986+ escadrille: JSONNull?? = nil,
3987+ estrous: JSONNull?? = nil,
3988+ interestedly: JSONNull?? = nil,
3989+ katakinetomer: JSONNull?? = nil,
3990+ mortification: JSONNull?? = nil,
3991+ morula: JSONNull?? = nil,
3992+ orthosymmetrical: JSONNull?? = nil,
3993+ overbark: JSONNull?? = nil,
3994+ politist: JSONNull?? = nil,
3995+ qualified: JSONNull?? = nil,
3996+ sphenomalar: JSONNull?? = nil,
3997+ throatful: JSONNull?? = nil,
3998+ transhumance: JSONNull?? = nil,
3999+ triandrian: JSONNull?? = nil,
4000+ unbooked: JSONNull?? = nil
4001+ ) -> WrothyClass {
4002+ return WrothyClass(
4003+ aeschynanthus: aeschynanthus ?? self.aeschynanthus,
4004+ aquiferous: aquiferous ?? self.aquiferous,
4005+ cheapener: cheapener ?? self.cheapener,
4006+ enumeration: enumeration ?? self.enumeration,
4007+ ephesine: ephesine ?? self.ephesine,
4008+ escadrille: escadrille ?? self.escadrille,
4009+ estrous: estrous ?? self.estrous,
4010+ interestedly: interestedly ?? self.interestedly,
4011+ katakinetomer: katakinetomer ?? self.katakinetomer,
4012+ mortification: mortification ?? self.mortification,
4013+ morula: morula ?? self.morula,
4014+ orthosymmetrical: orthosymmetrical ?? self.orthosymmetrical,
4015+ overbark: overbark ?? self.overbark,
4016+ politist: politist ?? self.politist,
4017+ qualified: qualified ?? self.qualified,
4018+ sphenomalar: sphenomalar ?? self.sphenomalar,
4019+ throatful: throatful ?? self.throatful,
4020+ transhumance: transhumance ?? self.transhumance,
4021+ triandrian: triandrian ?? self.triandrian,
4022+ unbooked: unbooked ?? self.unbooked
4023+ )
4024+ }
4025+
4026+ func jsonData() throws -> Data {
4027+ return try newJSONEncoder().encode(self)
4028+ }
4029+
4030+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
4031+ return String(data: try self.jsonData(), encoding: encoding)
4032+ }
4033+}
4034+
4035+// MARK: - Helper functions for creating encoders and decoders
4036+
4037+func newJSONDecoder() -> JSONDecoder {
4038+ let decoder = JSONDecoder()
4039+ decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in
4040+ let container = try decoder.singleValueContainer()
4041+ let dateStr = try container.decode(String.self)
4042+
4043+ let formatter = DateFormatter()
4044+ formatter.calendar = Calendar(identifier: .iso8601)
4045+ formatter.locale = Locale(identifier: "en_US_POSIX")
4046+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
4047+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX"
4048+ if let date = formatter.date(from: dateStr) {
4049+ return date
4050+ }
4051+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX"
4052+ if let date = formatter.date(from: dateStr) {
4053+ return date
4054+ }
4055+ throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date"))
4056+ })
4057+ return decoder
4058+}
4059+
4060+func newJSONEncoder() -> JSONEncoder {
4061+ let encoder = JSONEncoder()
4062+ let formatter = DateFormatter()
4063+ formatter.calendar = Calendar(identifier: .iso8601)
4064+ formatter.locale = Locale(identifier: "en_US_POSIX")
4065+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
4066+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSXXXXX"
4067+ encoder.dateEncodingStrategy = .formatted(formatter)
4068+ return encoder
4069+}
4070+
4071+// MARK: - Encode/decode helpers
4072+
4073+final class JSONNull: Codable, Hashable {
4074+
4075+ public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool {
4076+ return true
4077+ }
4078+
4079+ public func hash(into hasher: inout Hasher) {
4080+ hasher.combine(0)
4081+ }
4082+
4083+ public init() {}
4084+
4085+ public required init(from decoder: Decoder) throws {
4086+ let container = try decoder.singleValueContainer()
4087+ if !container.decodeNil() {
4088+ throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull"))
4089+ }
4090+ }
4091+
4092+ public func encode(to encoder: Encoder) throws {
4093+ var container = encoder.singleValueContainer()
4094+ try container.encodeNil()
4095+ }
4096+}
Aswiftprotocol-hashable--739b516c7897 / quicktype.swift+3,743 −0
@@ -0,0 +1,3743 @@
1+// This file was generated from JSON Schema using quicktype, do not modify it directly.
2+// To parse the JSON, add this file to your project and do:
3+//
4+// let topLevel = try TopLevel(json)
5+
6+//
7+// Hashable or Equatable:
8+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
9+// for types that require the use of JSONAny, nor will the implementation of Hashable be
10+// synthesized for types that have collections (such as arrays or dictionaries).
11+
12+import Foundation
13+
14+// MARK: - TopLevel
15+struct TopLevel: Codable, Hashable {
16+ let protrusive: [Protrusive]
17+ let pulpitism: [PulpitismElement]
18+ let pyodermia: [PyodermiaElement]
19+ let quebrachine: [QuebrachineElement]
20+ let querier: [Querier]
21+ let rebarbative: [Rebarbative]
22+ let reimagine: [Reimagine]
23+ let ressaut: Ressaut
24+ let retrocervical: [Retrocervical]
25+ let revert: [Revert]
26+ let rewrite: [RewriteElement]
27+ let saccoderm: [Saccoderm]
28+ let santir: [SantirElement]
29+ let saprophilous: [Saprophilous]
30+ let saxten: [SaxtenElement]
31+ let scatty: [Scatty?]
32+ let scoffer: [Scoffer]
33+ let scrampum: [Scrampum]
34+ let semantic: Double
35+ let serpentinic: [Serpentinic]
36+ let shadowable: [Shadowable]
37+ let sistering: [SisteringElement]
38+ let staghunting: [Staghunting]
39+ let stagmometer: [Stagmometer]
40+ let stimulability: [Stimulability]
41+ let strangleable: [Strangleable]
42+ let strenuosity: [StrenuosityElement]
43+ let tabaxir: [Tabaxir]
44+ let talpiform: [Talpiform]
45+ let thwack: [Thwack]
46+ let to: [Double?]
47+ let tortricine: [Tortricine]
48+ let truantcy: [TruantcyElement]
49+ let turgesce: [String]
50+ let unbeginning: [Unbeginning]
51+ let underdunged: [Double]
52+ let undesirability: [Undesirability]
53+ let unerasing: [Unerasing]
54+ let unguentarium: [Unguentarium]
55+ let unimpeachably: [UnimpeachablyElement]
56+ let unmortgaged: [Unmortgaged]
57+ let unobstructed: [Unobstructed]
58+ let unreceptivity: [Unreceptivity]
59+ let unsatisfactoriness: [Unsatisfactoriness]
60+ let unsecurity: [Int]
61+ let unstressed: [UnstressedElement]
62+ let untasked: [Untasked]
63+ let unvarying: [Unvarying]
64+ let vehemently: [Vehemently]
65+ let warriorship: [String: Bool]
66+ let whitepot: [Whitepot]
67+ let wrothy: [WrothyElement]
68+
69+ enum CodingKeys: String, CodingKey {
70+ case protrusive = "protrusive"
71+ case pulpitism = "pulpitism"
72+ case pyodermia = "pyodermia"
73+ case quebrachine = "quebrachine"
74+ case querier = "querier"
75+ case rebarbative = "rebarbative"
76+ case reimagine = "reimagine"
77+ case ressaut = "ressaut"
78+ case retrocervical = "retrocervical"
79+ case revert = "revert"
80+ case rewrite = "rewrite"
81+ case saccoderm = "saccoderm"
82+ case santir = "santir"
83+ case saprophilous = "saprophilous"
84+ case saxten = "saxten"
85+ case scatty = "scatty"
86+ case scoffer = "scoffer"
87+ case scrampum = "scrampum"
88+ case semantic = "semantic"
89+ case serpentinic = "serpentinic"
90+ case shadowable = "shadowable"
91+ case sistering = "sistering"
92+ case staghunting = "staghunting"
93+ case stagmometer = "stagmometer"
94+ case stimulability = "stimulability"
95+ case strangleable = "strangleable"
96+ case strenuosity = "strenuosity"
97+ case tabaxir = "tabaxir"
98+ case talpiform = "talpiform"
99+ case thwack = "thwack"
100+ case to = "to"
101+ case tortricine = "tortricine"
102+ case truantcy = "truantcy"
103+ case turgesce = "turgesce"
104+ case unbeginning = "unbeginning"
105+ case underdunged = "underdunged"
106+ case undesirability = "undesirability"
107+ case unerasing = "unerasing"
108+ case unguentarium = "unguentarium"
109+ case unimpeachably = "unimpeachably"
110+ case unmortgaged = "unmortgaged"
111+ case unobstructed = "unobstructed"
112+ case unreceptivity = "unreceptivity"
113+ case unsatisfactoriness = "unsatisfactoriness"
114+ case unsecurity = "unsecurity"
115+ case unstressed = "unstressed"
116+ case untasked = "untasked"
117+ case unvarying = "unvarying"
118+ case vehemently = "vehemently"
119+ case warriorship = "warriorship"
120+ case whitepot = "whitepot"
121+ case wrothy = "wrothy"
122+ }
123+}
124+
125+// MARK: TopLevel convenience initializers and mutators
126+
127+extension TopLevel {
128+ init(data: Data) throws {
129+ self = try newJSONDecoder().decode(TopLevel.self, from: data)
130+ }
131+
132+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
133+ guard let data = json.data(using: encoding) else {
134+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
135+ }
136+ try self.init(data: data)
137+ }
138+
139+ init(fromURL url: URL) throws {
140+ try self.init(data: try Data(contentsOf: url))
141+ }
142+
143+ func with(
144+ protrusive: [Protrusive]? = nil,
145+ pulpitism: [PulpitismElement]? = nil,
146+ pyodermia: [PyodermiaElement]? = nil,
147+ quebrachine: [QuebrachineElement]? = nil,
148+ querier: [Querier]? = nil,
149+ rebarbative: [Rebarbative]? = nil,
150+ reimagine: [Reimagine]? = nil,
151+ ressaut: Ressaut? = nil,
152+ retrocervical: [Retrocervical]? = nil,
153+ revert: [Revert]? = nil,
154+ rewrite: [RewriteElement]? = nil,
155+ saccoderm: [Saccoderm]? = nil,
156+ santir: [SantirElement]? = nil,
157+ saprophilous: [Saprophilous]? = nil,
158+ saxten: [SaxtenElement]? = nil,
159+ scatty: [Scatty?]? = nil,
160+ scoffer: [Scoffer]? = nil,
161+ scrampum: [Scrampum]? = nil,
162+ semantic: Double? = nil,
163+ serpentinic: [Serpentinic]? = nil,
164+ shadowable: [Shadowable]? = nil,
165+ sistering: [SisteringElement]? = nil,
166+ staghunting: [Staghunting]? = nil,
167+ stagmometer: [Stagmometer]? = nil,
168+ stimulability: [Stimulability]? = nil,
169+ strangleable: [Strangleable]? = nil,
170+ strenuosity: [StrenuosityElement]? = nil,
171+ tabaxir: [Tabaxir]? = nil,
172+ talpiform: [Talpiform]? = nil,
173+ thwack: [Thwack]? = nil,
174+ to: [Double?]? = nil,
175+ tortricine: [Tortricine]? = nil,
176+ truantcy: [TruantcyElement]? = nil,
177+ turgesce: [String]? = nil,
178+ unbeginning: [Unbeginning]? = nil,
179+ underdunged: [Double]? = nil,
180+ undesirability: [Undesirability]? = nil,
181+ unerasing: [Unerasing]? = nil,
182+ unguentarium: [Unguentarium]? = nil,
183+ unimpeachably: [UnimpeachablyElement]? = nil,
184+ unmortgaged: [Unmortgaged]? = nil,
185+ unobstructed: [Unobstructed]? = nil,
186+ unreceptivity: [Unreceptivity]? = nil,
187+ unsatisfactoriness: [Unsatisfactoriness]? = nil,
188+ unsecurity: [Int]? = nil,
189+ unstressed: [UnstressedElement]? = nil,
190+ untasked: [Untasked]? = nil,
191+ unvarying: [Unvarying]? = nil,
192+ vehemently: [Vehemently]? = nil,
193+ warriorship: [String: Bool]? = nil,
194+ whitepot: [Whitepot]? = nil,
195+ wrothy: [WrothyElement]? = nil
196+ ) -> TopLevel {
197+ return TopLevel(
198+ protrusive: protrusive ?? self.protrusive,
199+ pulpitism: pulpitism ?? self.pulpitism,
200+ pyodermia: pyodermia ?? self.pyodermia,
201+ quebrachine: quebrachine ?? self.quebrachine,
202+ querier: querier ?? self.querier,
203+ rebarbative: rebarbative ?? self.rebarbative,
204+ reimagine: reimagine ?? self.reimagine,
205+ ressaut: ressaut ?? self.ressaut,
206+ retrocervical: retrocervical ?? self.retrocervical,
207+ revert: revert ?? self.revert,
208+ rewrite: rewrite ?? self.rewrite,
209+ saccoderm: saccoderm ?? self.saccoderm,
210+ santir: santir ?? self.santir,
211+ saprophilous: saprophilous ?? self.saprophilous,
212+ saxten: saxten ?? self.saxten,
213+ scatty: scatty ?? self.scatty,
214+ scoffer: scoffer ?? self.scoffer,
215+ scrampum: scrampum ?? self.scrampum,
216+ semantic: semantic ?? self.semantic,
217+ serpentinic: serpentinic ?? self.serpentinic,
218+ shadowable: shadowable ?? self.shadowable,
219+ sistering: sistering ?? self.sistering,
220+ staghunting: staghunting ?? self.staghunting,
221+ stagmometer: stagmometer ?? self.stagmometer,
222+ stimulability: stimulability ?? self.stimulability,
223+ strangleable: strangleable ?? self.strangleable,
224+ strenuosity: strenuosity ?? self.strenuosity,
225+ tabaxir: tabaxir ?? self.tabaxir,
226+ talpiform: talpiform ?? self.talpiform,
227+ thwack: thwack ?? self.thwack,
228+ to: to ?? self.to,
229+ tortricine: tortricine ?? self.tortricine,
230+ truantcy: truantcy ?? self.truantcy,
231+ turgesce: turgesce ?? self.turgesce,
232+ unbeginning: unbeginning ?? self.unbeginning,
233+ underdunged: underdunged ?? self.underdunged,
234+ undesirability: undesirability ?? self.undesirability,
235+ unerasing: unerasing ?? self.unerasing,
236+ unguentarium: unguentarium ?? self.unguentarium,
237+ unimpeachably: unimpeachably ?? self.unimpeachably,
238+ unmortgaged: unmortgaged ?? self.unmortgaged,
239+ unobstructed: unobstructed ?? self.unobstructed,
240+ unreceptivity: unreceptivity ?? self.unreceptivity,
241+ unsatisfactoriness: unsatisfactoriness ?? self.unsatisfactoriness,
242+ unsecurity: unsecurity ?? self.unsecurity,
243+ unstressed: unstressed ?? self.unstressed,
244+ untasked: untasked ?? self.untasked,
245+ unvarying: unvarying ?? self.unvarying,
246+ vehemently: vehemently ?? self.vehemently,
247+ warriorship: warriorship ?? self.warriorship,
248+ whitepot: whitepot ?? self.whitepot,
249+ wrothy: wrothy ?? self.wrothy
250+ )
251+ }
252+
253+ func jsonData() throws -> Data {
254+ return try newJSONEncoder().encode(self)
255+ }
256+
257+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
258+ return String(data: try self.jsonData(), encoding: encoding)
259+ }
260+}
261+
262+enum Protrusive: Codable, Hashable {
263+ case double(Double)
264+ case unionArray([Int?])
265+
266+ init(from decoder: Decoder) throws {
267+ let container = try decoder.singleValueContainer()
268+ if let x = try? container.decode([Int?].self) {
269+ self = .unionArray(x)
270+ return
271+ }
272+ if let x = try? container.decode(Double.self) {
273+ self = .double(x)
274+ return
275+ }
276+ throw DecodingError.typeMismatch(Protrusive.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Protrusive"))
277+ }
278+
279+ func encode(to encoder: Encoder) throws {
280+ var container = encoder.singleValueContainer()
281+ switch self {
282+ case .double(let x):
283+ try container.encode(x)
284+ case .unionArray(let x):
285+ try container.encode(x)
286+ }
287+ }
288+}
289+
290+enum PulpitismElement: Codable, Hashable {
291+ case double(Double)
292+ case integerArray([Int])
293+ case pulpitismClass(PulpitismClass)
294+
295+ init(from decoder: Decoder) throws {
296+ let container = try decoder.singleValueContainer()
297+ if let x = try? container.decode([Int].self) {
298+ self = .integerArray(x)
299+ return
300+ }
301+ if let x = try? container.decode(Double.self) {
302+ self = .double(x)
303+ return
304+ }
305+ if let x = try? container.decode(PulpitismClass.self) {
306+ self = .pulpitismClass(x)
307+ return
308+ }
309+ throw DecodingError.typeMismatch(PulpitismElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PulpitismElement"))
310+ }
311+
312+ func encode(to encoder: Encoder) throws {
313+ var container = encoder.singleValueContainer()
314+ switch self {
315+ case .double(let x):
316+ try container.encode(x)
317+ case .integerArray(let x):
318+ try container.encode(x)
319+ case .pulpitismClass(let x):
320+ try container.encode(x)
321+ }
322+ }
323+}
324+
325+//
326+// Hashable or Equatable:
327+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
328+// for types that require the use of JSONAny, nor will the implementation of Hashable be
329+// synthesized for types that have collections (such as arrays or dictionaries).
330+
331+// MARK: - PulpitismClass
332+struct PulpitismClass: Codable, Hashable {
333+ let abnet: JSONNull?
334+ let buckhorn: JSONNull?
335+ let calciform: JSONNull?
336+ let chelophore: JSONNull?
337+ let cogitation: JSONNull?
338+ let decreeable: JSONNull?
339+ let despicable: JSONNull?
340+ let isodiazo: JSONNull?
341+ let jadedly: JSONNull?
342+ let leptochlorite: JSONNull?
343+ let nursling: JSONNull?
344+ let palamedean: JSONNull?
345+ let photoheliograph: JSONNull?
346+ let pipewood: JSONNull?
347+ let roberd: JSONNull?
348+ let statable: JSONNull?
349+ let superassume: JSONNull?
350+ let syllabe: JSONNull?
351+ let toughhead: JSONNull?
352+ let underburn: JSONNull?
353+
354+ enum CodingKeys: String, CodingKey {
355+ case abnet = "abnet"
356+ case buckhorn = "buckhorn"
357+ case calciform = "calciform"
358+ case chelophore = "chelophore"
359+ case cogitation = "cogitation"
360+ case decreeable = "decreeable"
361+ case despicable = "despicable"
362+ case isodiazo = "isodiazo"
363+ case jadedly = "jadedly"
364+ case leptochlorite = "leptochlorite"
365+ case nursling = "nursling"
366+ case palamedean = "palamedean"
367+ case photoheliograph = "photoheliograph"
368+ case pipewood = "pipewood"
369+ case roberd = "roberd"
370+ case statable = "statable"
371+ case superassume = "superassume"
372+ case syllabe = "syllabe"
373+ case toughhead = "toughhead"
374+ case underburn = "underburn"
375+ }
376+}
377+
378+// MARK: PulpitismClass convenience initializers and mutators
379+
380+extension PulpitismClass {
381+ init(data: Data) throws {
382+ self = try newJSONDecoder().decode(PulpitismClass.self, from: data)
383+ }
384+
385+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
386+ guard let data = json.data(using: encoding) else {
387+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
388+ }
389+ try self.init(data: data)
390+ }
391+
392+ init(fromURL url: URL) throws {
393+ try self.init(data: try Data(contentsOf: url))
394+ }
395+
396+ func with(
397+ abnet: JSONNull?? = nil,
398+ buckhorn: JSONNull?? = nil,
399+ calciform: JSONNull?? = nil,
400+ chelophore: JSONNull?? = nil,
401+ cogitation: JSONNull?? = nil,
402+ decreeable: JSONNull?? = nil,
403+ despicable: JSONNull?? = nil,
404+ isodiazo: JSONNull?? = nil,
405+ jadedly: JSONNull?? = nil,
406+ leptochlorite: JSONNull?? = nil,
407+ nursling: JSONNull?? = nil,
408+ palamedean: JSONNull?? = nil,
409+ photoheliograph: JSONNull?? = nil,
410+ pipewood: JSONNull?? = nil,
411+ roberd: JSONNull?? = nil,
412+ statable: JSONNull?? = nil,
413+ superassume: JSONNull?? = nil,
414+ syllabe: JSONNull?? = nil,
415+ toughhead: JSONNull?? = nil,
416+ underburn: JSONNull?? = nil
417+ ) -> PulpitismClass {
418+ return PulpitismClass(
419+ abnet: abnet ?? self.abnet,
420+ buckhorn: buckhorn ?? self.buckhorn,
421+ calciform: calciform ?? self.calciform,
422+ chelophore: chelophore ?? self.chelophore,
423+ cogitation: cogitation ?? self.cogitation,
424+ decreeable: decreeable ?? self.decreeable,
425+ despicable: despicable ?? self.despicable,
426+ isodiazo: isodiazo ?? self.isodiazo,
427+ jadedly: jadedly ?? self.jadedly,
428+ leptochlorite: leptochlorite ?? self.leptochlorite,
429+ nursling: nursling ?? self.nursling,
430+ palamedean: palamedean ?? self.palamedean,
431+ photoheliograph: photoheliograph ?? self.photoheliograph,
432+ pipewood: pipewood ?? self.pipewood,
433+ roberd: roberd ?? self.roberd,
434+ statable: statable ?? self.statable,
435+ superassume: superassume ?? self.superassume,
436+ syllabe: syllabe ?? self.syllabe,
437+ toughhead: toughhead ?? self.toughhead,
438+ underburn: underburn ?? self.underburn
439+ )
440+ }
441+
442+ func jsonData() throws -> Data {
443+ return try newJSONEncoder().encode(self)
444+ }
445+
446+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
447+ return String(data: try self.jsonData(), encoding: encoding)
448+ }
449+}
450+
451+enum PyodermiaElement: Codable, Hashable {
452+ case integer(Int)
453+ case pyodermiaClass(PyodermiaClass)
454+
455+ init(from decoder: Decoder) throws {
456+ let container = try decoder.singleValueContainer()
457+ if let x = try? container.decode(Int.self) {
458+ self = .integer(x)
459+ return
460+ }
461+ if let x = try? container.decode(PyodermiaClass.self) {
462+ self = .pyodermiaClass(x)
463+ return
464+ }
465+ throw DecodingError.typeMismatch(PyodermiaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PyodermiaElement"))
466+ }
467+
468+ func encode(to encoder: Encoder) throws {
469+ var container = encoder.singleValueContainer()
470+ switch self {
471+ case .integer(let x):
472+ try container.encode(x)
473+ case .pyodermiaClass(let x):
474+ try container.encode(x)
475+ }
476+ }
477+}
478+
479+//
480+// Hashable or Equatable:
481+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
482+// for types that require the use of JSONAny, nor will the implementation of Hashable be
483+// synthesized for types that have collections (such as arrays or dictionaries).
484+
485+// MARK: - PyodermiaClass
486+struct PyodermiaClass: Codable, Hashable {
487+ let aphoristically: JSONNull?
488+ let apophyllous: JSONNull?
489+ let cognize: JSONNull?
490+ let dermonosology: JSONNull?
491+ let gyppo: JSONNull?
492+ let ither: JSONNull?
493+ let juglandaceous: JSONNull?
494+ let litho: JSONNull?
495+ let macropterous: JSONNull?
496+ let photographer: JSONNull?
497+ let romancing: JSONNull?
498+ let rumness: JSONNull?
499+ let somniloquist: JSONNull?
500+ let stressfully: JSONNull?
501+ let tactically: JSONNull?
502+ let tracheophony: JSONNull?
503+ let unappositely: JSONNull?
504+ let unclothedly: JSONNull?
505+ let unimplied: JSONNull?
506+ let unsyncopated: JSONNull?
507+
508+ enum CodingKeys: String, CodingKey {
509+ case aphoristically = "aphoristically"
510+ case apophyllous = "apophyllous"
511+ case cognize = "cognize"
512+ case dermonosology = "dermonosology"
513+ case gyppo = "Gyppo"
514+ case ither = "ither"
515+ case juglandaceous = "juglandaceous"
516+ case litho = "litho"
517+ case macropterous = "macropterous"
518+ case photographer = "photographer"
519+ case romancing = "romancing"
520+ case rumness = "rumness"
521+ case somniloquist = "somniloquist"
522+ case stressfully = "stressfully"
523+ case tactically = "tactically"
524+ case tracheophony = "tracheophony"
525+ case unappositely = "unappositely"
526+ case unclothedly = "unclothedly"
527+ case unimplied = "unimplied"
528+ case unsyncopated = "unsyncopated"
529+ }
530+}
531+
532+// MARK: PyodermiaClass convenience initializers and mutators
533+
534+extension PyodermiaClass {
535+ init(data: Data) throws {
536+ self = try newJSONDecoder().decode(PyodermiaClass.self, from: data)
537+ }
538+
539+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
540+ guard let data = json.data(using: encoding) else {
541+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
542+ }
543+ try self.init(data: data)
544+ }
545+
546+ init(fromURL url: URL) throws {
547+ try self.init(data: try Data(contentsOf: url))
548+ }
549+
550+ func with(
551+ aphoristically: JSONNull?? = nil,
552+ apophyllous: JSONNull?? = nil,
553+ cognize: JSONNull?? = nil,
554+ dermonosology: JSONNull?? = nil,
555+ gyppo: JSONNull?? = nil,
556+ ither: JSONNull?? = nil,
557+ juglandaceous: JSONNull?? = nil,
558+ litho: JSONNull?? = nil,
559+ macropterous: JSONNull?? = nil,
560+ photographer: JSONNull?? = nil,
561+ romancing: JSONNull?? = nil,
562+ rumness: JSONNull?? = nil,
563+ somniloquist: JSONNull?? = nil,
564+ stressfully: JSONNull?? = nil,
565+ tactically: JSONNull?? = nil,
566+ tracheophony: JSONNull?? = nil,
567+ unappositely: JSONNull?? = nil,
568+ unclothedly: JSONNull?? = nil,
569+ unimplied: JSONNull?? = nil,
570+ unsyncopated: JSONNull?? = nil
571+ ) -> PyodermiaClass {
572+ return PyodermiaClass(
573+ aphoristically: aphoristically ?? self.aphoristically,
574+ apophyllous: apophyllous ?? self.apophyllous,
575+ cognize: cognize ?? self.cognize,
576+ dermonosology: dermonosology ?? self.dermonosology,
577+ gyppo: gyppo ?? self.gyppo,
578+ ither: ither ?? self.ither,
579+ juglandaceous: juglandaceous ?? self.juglandaceous,
580+ litho: litho ?? self.litho,
581+ macropterous: macropterous ?? self.macropterous,
582+ photographer: photographer ?? self.photographer,
583+ romancing: romancing ?? self.romancing,
584+ rumness: rumness ?? self.rumness,
585+ somniloquist: somniloquist ?? self.somniloquist,
586+ stressfully: stressfully ?? self.stressfully,
587+ tactically: tactically ?? self.tactically,
588+ tracheophony: tracheophony ?? self.tracheophony,
589+ unappositely: unappositely ?? self.unappositely,
590+ unclothedly: unclothedly ?? self.unclothedly,
591+ unimplied: unimplied ?? self.unimplied,
592+ unsyncopated: unsyncopated ?? self.unsyncopated
593+ )
594+ }
595+
596+ func jsonData() throws -> Data {
597+ return try newJSONEncoder().encode(self)
598+ }
599+
600+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
601+ return String(data: try self.jsonData(), encoding: encoding)
602+ }
603+}
604+
605+enum QuebrachineElement: Codable, Hashable {
606+ case bool(Bool)
607+ case quebrachineClass(QuebrachineClass)
608+ case null
609+
610+ init(from decoder: Decoder) throws {
611+ let container = try decoder.singleValueContainer()
612+ if let x = try? container.decode(Bool.self) {
613+ self = .bool(x)
614+ return
615+ }
616+ if let x = try? container.decode(QuebrachineClass.self) {
617+ self = .quebrachineClass(x)
618+ return
619+ }
620+ if container.decodeNil() {
621+ self = .null
622+ return
623+ }
624+ throw DecodingError.typeMismatch(QuebrachineElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for QuebrachineElement"))
625+ }
626+
627+ func encode(to encoder: Encoder) throws {
628+ var container = encoder.singleValueContainer()
629+ switch self {
630+ case .bool(let x):
631+ try container.encode(x)
632+ case .quebrachineClass(let x):
633+ try container.encode(x)
634+ case .null:
635+ try container.encodeNil()
636+ }
637+ }
638+}
639+
640+//
641+// Hashable or Equatable:
642+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
643+// for types that require the use of JSONAny, nor will the implementation of Hashable be
644+// synthesized for types that have collections (such as arrays or dictionaries).
645+
646+// MARK: - QuebrachineClass
647+struct QuebrachineClass: Codable, Hashable {
648+ let catharticalness: Double
649+ let chirotherium: Int
650+ let disdiapason: String
651+ let homocerc: Bool
652+ let nonbookish: JSONNull?
653+
654+ enum CodingKeys: String, CodingKey {
655+ case catharticalness = "catharticalness"
656+ case chirotherium = "Chirotherium"
657+ case disdiapason = "disdiapason"
658+ case homocerc = "homocerc"
659+ case nonbookish = "nonbookish"
660+ }
661+}
662+
663+// MARK: QuebrachineClass convenience initializers and mutators
664+
665+extension QuebrachineClass {
666+ init(data: Data) throws {
667+ self = try newJSONDecoder().decode(QuebrachineClass.self, from: data)
668+ }
669+
670+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
671+ guard let data = json.data(using: encoding) else {
672+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
673+ }
674+ try self.init(data: data)
675+ }
676+
677+ init(fromURL url: URL) throws {
678+ try self.init(data: try Data(contentsOf: url))
679+ }
680+
681+ func with(
682+ catharticalness: Double? = nil,
683+ chirotherium: Int? = nil,
684+ disdiapason: String? = nil,
685+ homocerc: Bool? = nil,
686+ nonbookish: JSONNull?? = nil
687+ ) -> QuebrachineClass {
688+ return QuebrachineClass(
689+ catharticalness: catharticalness ?? self.catharticalness,
690+ chirotherium: chirotherium ?? self.chirotherium,
691+ disdiapason: disdiapason ?? self.disdiapason,
692+ homocerc: homocerc ?? self.homocerc,
693+ nonbookish: nonbookish ?? self.nonbookish
694+ )
695+ }
696+
697+ func jsonData() throws -> Data {
698+ return try newJSONEncoder().encode(self)
699+ }
700+
701+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
702+ return String(data: try self.jsonData(), encoding: encoding)
703+ }
704+}
705+
706+enum Querier: Codable, Hashable {
707+ case bool(Bool)
708+ case integerMap([String: Int])
709+
710+ init(from decoder: Decoder) throws {
711+ let container = try decoder.singleValueContainer()
712+ if let x = try? container.decode(Bool.self) {
713+ self = .bool(x)
714+ return
715+ }
716+ if let x = try? container.decode([String: Int].self) {
717+ self = .integerMap(x)
718+ return
719+ }
720+ throw DecodingError.typeMismatch(Querier.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Querier"))
721+ }
722+
723+ func encode(to encoder: Encoder) throws {
724+ var container = encoder.singleValueContainer()
725+ switch self {
726+ case .bool(let x):
727+ try container.encode(x)
728+ case .integerMap(let x):
729+ try container.encode(x)
730+ }
731+ }
732+}
733+
734+enum Rebarbative: Codable, Hashable {
735+ case bool(Bool)
736+ case double(Double)
737+ case integerArray([Int])
738+
739+ init(from decoder: Decoder) throws {
740+ let container = try decoder.singleValueContainer()
741+ if let x = try? container.decode(Bool.self) {
742+ self = .bool(x)
743+ return
744+ }
745+ if let x = try? container.decode([Int].self) {
746+ self = .integerArray(x)
747+ return
748+ }
749+ if let x = try? container.decode(Double.self) {
750+ self = .double(x)
751+ return
752+ }
753+ throw DecodingError.typeMismatch(Rebarbative.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Rebarbative"))
754+ }
755+
756+ func encode(to encoder: Encoder) throws {
757+ var container = encoder.singleValueContainer()
758+ switch self {
759+ case .bool(let x):
760+ try container.encode(x)
761+ case .double(let x):
762+ try container.encode(x)
763+ case .integerArray(let x):
764+ try container.encode(x)
765+ }
766+ }
767+}
768+
769+//
770+// Hashable or Equatable:
771+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
772+// for types that require the use of JSONAny, nor will the implementation of Hashable be
773+// synthesized for types that have collections (such as arrays or dictionaries).
774+
775+// MARK: - Reimagine
776+struct Reimagine: Codable, Hashable {
777+ let adducible: JSONNull?
778+ let anabolin: JSONNull?
779+ let brainy: JSONNull?
780+ let catharticalness: Double?
781+ let chirotherium: Int?
782+ let chrysamine: JSONNull?
783+ let disdiapason: String?
784+ let fluxweed: JSONNull?
785+ let glaucine: JSONNull?
786+ let grobianism: JSONNull?
787+ let hermo: JSONNull?
788+ let hieroglyphist: JSONNull?
789+ let homocerc: Bool?
790+ let icteroid: JSONNull?
791+ let immortal: JSONNull?
792+ let impetulant: JSONNull?
793+ let irrigate: JSONNull?
794+ let myxedema: JSONNull?
795+ let nonbookish: JSONNull?
796+ let onyx: JSONNull?
797+ let repasser: JSONNull?
798+ let septomarginal: JSONNull?
799+ let subdie: JSONNull?
800+ let tibiometatarsal: JSONNull?
801+ let waltzlike: JSONNull?
802+
803+ enum CodingKeys: String, CodingKey {
804+ case adducible = "adducible"
805+ case anabolin = "anabolin"
806+ case brainy = "brainy"
807+ case catharticalness = "catharticalness"
808+ case chirotherium = "Chirotherium"
809+ case chrysamine = "chrysamine"
810+ case disdiapason = "disdiapason"
811+ case fluxweed = "fluxweed"
812+ case glaucine = "glaucine"
813+ case grobianism = "grobianism"
814+ case hermo = "Hermo"
815+ case hieroglyphist = "hieroglyphist"
816+ case homocerc = "homocerc"
817+ case icteroid = "icteroid"
818+ case immortal = "immortal"
819+ case impetulant = "impetulant"
820+ case irrigate = "irrigate"
821+ case myxedema = "myxedema"
822+ case nonbookish = "nonbookish"
823+ case onyx = "onyx"
824+ case repasser = "repasser"
825+ case septomarginal = "septomarginal"
826+ case subdie = "subdie"
827+ case tibiometatarsal = "tibiometatarsal"
828+ case waltzlike = "waltzlike"
829+ }
830+}
831+
832+// MARK: Reimagine convenience initializers and mutators
833+
834+extension Reimagine {
835+ init(data: Data) throws {
836+ self = try newJSONDecoder().decode(Reimagine.self, from: data)
837+ }
838+
839+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
840+ guard let data = json.data(using: encoding) else {
841+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
842+ }
843+ try self.init(data: data)
844+ }
845+
846+ init(fromURL url: URL) throws {
847+ try self.init(data: try Data(contentsOf: url))
848+ }
849+
850+ func with(
851+ adducible: JSONNull?? = nil,
852+ anabolin: JSONNull?? = nil,
853+ brainy: JSONNull?? = nil,
854+ catharticalness: Double?? = nil,
855+ chirotherium: Int?? = nil,
856+ chrysamine: JSONNull?? = nil,
857+ disdiapason: String?? = nil,
858+ fluxweed: JSONNull?? = nil,
859+ glaucine: JSONNull?? = nil,
860+ grobianism: JSONNull?? = nil,
861+ hermo: JSONNull?? = nil,
862+ hieroglyphist: JSONNull?? = nil,
863+ homocerc: Bool?? = nil,
864+ icteroid: JSONNull?? = nil,
865+ immortal: JSONNull?? = nil,
866+ impetulant: JSONNull?? = nil,
867+ irrigate: JSONNull?? = nil,
868+ myxedema: JSONNull?? = nil,
869+ nonbookish: JSONNull?? = nil,
870+ onyx: JSONNull?? = nil,
871+ repasser: JSONNull?? = nil,
872+ septomarginal: JSONNull?? = nil,
873+ subdie: JSONNull?? = nil,
874+ tibiometatarsal: JSONNull?? = nil,
875+ waltzlike: JSONNull?? = nil
876+ ) -> Reimagine {
877+ return Reimagine(
878+ adducible: adducible ?? self.adducible,
879+ anabolin: anabolin ?? self.anabolin,
880+ brainy: brainy ?? self.brainy,
881+ catharticalness: catharticalness ?? self.catharticalness,
882+ chirotherium: chirotherium ?? self.chirotherium,
883+ chrysamine: chrysamine ?? self.chrysamine,
884+ disdiapason: disdiapason ?? self.disdiapason,
885+ fluxweed: fluxweed ?? self.fluxweed,
886+ glaucine: glaucine ?? self.glaucine,
887+ grobianism: grobianism ?? self.grobianism,
888+ hermo: hermo ?? self.hermo,
889+ hieroglyphist: hieroglyphist ?? self.hieroglyphist,
890+ homocerc: homocerc ?? self.homocerc,
891+ icteroid: icteroid ?? self.icteroid,
892+ immortal: immortal ?? self.immortal,
893+ impetulant: impetulant ?? self.impetulant,
894+ irrigate: irrigate ?? self.irrigate,
895+ myxedema: myxedema ?? self.myxedema,
896+ nonbookish: nonbookish ?? self.nonbookish,
897+ onyx: onyx ?? self.onyx,
898+ repasser: repasser ?? self.repasser,
899+ septomarginal: septomarginal ?? self.septomarginal,
900+ subdie: subdie ?? self.subdie,
901+ tibiometatarsal: tibiometatarsal ?? self.tibiometatarsal,
902+ waltzlike: waltzlike ?? self.waltzlike
903+ )
904+ }
905+
906+ func jsonData() throws -> Data {
907+ return try newJSONEncoder().encode(self)
908+ }
909+
910+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
911+ return String(data: try self.jsonData(), encoding: encoding)
912+ }
913+}
914+
915+//
916+// Hashable or Equatable:
917+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
918+// for types that require the use of JSONAny, nor will the implementation of Hashable be
919+// synthesized for types that have collections (such as arrays or dictionaries).
920+
921+// MARK: - Ressaut
922+struct Ressaut: Codable, Hashable {
923+ let apperceptive: String
924+ let cuttoo: String
925+ let douser: String
926+ let drinkproof: String
927+ let forementioned: String
928+ let freesia: String
929+ let genevieve: String
930+ let hyperdiabolical: String
931+ let hypocone: String
932+ let irreverentially: String
933+ let jumart: String
934+ let mimosaceae: String
935+ let mollicrush: String
936+ let nedder: String
937+ let retinasphalt: String
938+ let sough: String
939+ let steading: String
940+ let theopaschitism: String
941+ let undurableness: String
942+ let unmingleable: String
943+
944+ enum CodingKeys: String, CodingKey {
945+ case apperceptive = "apperceptive"
946+ case cuttoo = "cuttoo"
947+ case douser = "douser"
948+ case drinkproof = "drinkproof"
949+ case forementioned = "forementioned"
950+ case freesia = "Freesia"
951+ case genevieve = "Genevieve"
952+ case hyperdiabolical = "hyperdiabolical"
953+ case hypocone = "hypocone"
954+ case irreverentially = "irreverentially"
955+ case jumart = "jumart"
956+ case mimosaceae = "Mimosaceae"
957+ case mollicrush = "mollicrush"
958+ case nedder = "nedder"
959+ case retinasphalt = "retinasphalt"
960+ case sough = "sough"
961+ case steading = "steading"
962+ case theopaschitism = "Theopaschitism"
963+ case undurableness = "undurableness"
964+ case unmingleable = "unmingleable"
965+ }
966+}
967+
968+// MARK: Ressaut convenience initializers and mutators
969+
970+extension Ressaut {
971+ init(data: Data) throws {
972+ self = try newJSONDecoder().decode(Ressaut.self, from: data)
973+ }
974+
975+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
976+ guard let data = json.data(using: encoding) else {
977+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
978+ }
979+ try self.init(data: data)
980+ }
981+
982+ init(fromURL url: URL) throws {
983+ try self.init(data: try Data(contentsOf: url))
984+ }
985+
986+ func with(
987+ apperceptive: String? = nil,
988+ cuttoo: String? = nil,
989+ douser: String? = nil,
990+ drinkproof: String? = nil,
991+ forementioned: String? = nil,
992+ freesia: String? = nil,
993+ genevieve: String? = nil,
994+ hyperdiabolical: String? = nil,
995+ hypocone: String? = nil,
996+ irreverentially: String? = nil,
997+ jumart: String? = nil,
998+ mimosaceae: String? = nil,
999+ mollicrush: String? = nil,
1000+ nedder: String? = nil,
1001+ retinasphalt: String? = nil,
1002+ sough: String? = nil,
1003+ steading: String? = nil,
1004+ theopaschitism: String? = nil,
1005+ undurableness: String? = nil,
1006+ unmingleable: String? = nil
1007+ ) -> Ressaut {
1008+ return Ressaut(
1009+ apperceptive: apperceptive ?? self.apperceptive,
1010+ cuttoo: cuttoo ?? self.cuttoo,
1011+ douser: douser ?? self.douser,
1012+ drinkproof: drinkproof ?? self.drinkproof,
1013+ forementioned: forementioned ?? self.forementioned,
1014+ freesia: freesia ?? self.freesia,
1015+ genevieve: genevieve ?? self.genevieve,
1016+ hyperdiabolical: hyperdiabolical ?? self.hyperdiabolical,
1017+ hypocone: hypocone ?? self.hypocone,
1018+ irreverentially: irreverentially ?? self.irreverentially,
1019+ jumart: jumart ?? self.jumart,
1020+ mimosaceae: mimosaceae ?? self.mimosaceae,
1021+ mollicrush: mollicrush ?? self.mollicrush,
1022+ nedder: nedder ?? self.nedder,
1023+ retinasphalt: retinasphalt ?? self.retinasphalt,
1024+ sough: sough ?? self.sough,
1025+ steading: steading ?? self.steading,
1026+ theopaschitism: theopaschitism ?? self.theopaschitism,
1027+ undurableness: undurableness ?? self.undurableness,
1028+ unmingleable: unmingleable ?? self.unmingleable
1029+ )
1030+ }
1031+
1032+ func jsonData() throws -> Data {
1033+ return try newJSONEncoder().encode(self)
1034+ }
1035+
1036+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1037+ return String(data: try self.jsonData(), encoding: encoding)
1038+ }
1039+}
1040+
1041+enum Retrocervical: Codable, Hashable {
1042+ case integer(Int)
1043+ case unionArray([Int?])
1044+
1045+ init(from decoder: Decoder) throws {
1046+ let container = try decoder.singleValueContainer()
1047+ if let x = try? container.decode(Int.self) {
1048+ self = .integer(x)
1049+ return
1050+ }
1051+ if let x = try? container.decode([Int?].self) {
1052+ self = .unionArray(x)
1053+ return
1054+ }
1055+ throw DecodingError.typeMismatch(Retrocervical.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Retrocervical"))
1056+ }
1057+
1058+ func encode(to encoder: Encoder) throws {
1059+ var container = encoder.singleValueContainer()
1060+ switch self {
1061+ case .integer(let x):
1062+ try container.encode(x)
1063+ case .unionArray(let x):
1064+ try container.encode(x)
1065+ }
1066+ }
1067+}
1068+
1069+enum Revert: Codable, Hashable {
1070+ case bool(Bool)
1071+ case string(String)
1072+
1073+ init(from decoder: Decoder) throws {
1074+ let container = try decoder.singleValueContainer()
1075+ if let x = try? container.decode(Bool.self) {
1076+ self = .bool(x)
1077+ return
1078+ }
1079+ if let x = try? container.decode(String.self) {
1080+ self = .string(x)
1081+ return
1082+ }
1083+ throw DecodingError.typeMismatch(Revert.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Revert"))
1084+ }
1085+
1086+ func encode(to encoder: Encoder) throws {
1087+ var container = encoder.singleValueContainer()
1088+ switch self {
1089+ case .bool(let x):
1090+ try container.encode(x)
1091+ case .string(let x):
1092+ try container.encode(x)
1093+ }
1094+ }
1095+}
1096+
1097+enum RewriteElement: Codable, Hashable {
1098+ case double(Double)
1099+ case nullArray([JSONNull?])
1100+ case rewriteClass(RewriteClass)
1101+
1102+ init(from decoder: Decoder) throws {
1103+ let container = try decoder.singleValueContainer()
1104+ if let x = try? container.decode([JSONNull?].self) {
1105+ self = .nullArray(x)
1106+ return
1107+ }
1108+ if let x = try? container.decode(Double.self) {
1109+ self = .double(x)
1110+ return
1111+ }
1112+ if let x = try? container.decode(RewriteClass.self) {
1113+ self = .rewriteClass(x)
1114+ return
1115+ }
1116+ throw DecodingError.typeMismatch(RewriteElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for RewriteElement"))
1117+ }
1118+
1119+ func encode(to encoder: Encoder) throws {
1120+ var container = encoder.singleValueContainer()
1121+ switch self {
1122+ case .double(let x):
1123+ try container.encode(x)
1124+ case .nullArray(let x):
1125+ try container.encode(x)
1126+ case .rewriteClass(let x):
1127+ try container.encode(x)
1128+ }
1129+ }
1130+}
1131+
1132+//
1133+// Hashable or Equatable:
1134+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
1135+// for types that require the use of JSONAny, nor will the implementation of Hashable be
1136+// synthesized for types that have collections (such as arrays or dictionaries).
1137+
1138+// MARK: - RewriteClass
1139+struct RewriteClass: Codable, Hashable {
1140+ let accountancy: JSONNull?
1141+ let cacotrophic: JSONNull?
1142+ let contest: JSONNull?
1143+ let couthily: JSONNull?
1144+ let falculate: JSONNull?
1145+ let foreseize: JSONNull?
1146+ let hyades: JSONNull?
1147+ let lemnad: JSONNull?
1148+ let monotheistically: JSONNull?
1149+ let nonflying: JSONNull?
1150+ let ptenoglossa: JSONNull?
1151+ let repatch: JSONNull?
1152+ let rodman: JSONNull?
1153+ let strung: JSONNull?
1154+ let titmal: JSONNull?
1155+ let twalpennyworth: JSONNull?
1156+ let unblamable: JSONNull?
1157+ let vertical: JSONNull?
1158+ let whiggification: JSONNull?
1159+ let yardman: JSONNull?
1160+
1161+ enum CodingKeys: String, CodingKey {
1162+ case accountancy = "accountancy"
1163+ case cacotrophic = "cacotrophic"
1164+ case contest = "contest"
1165+ case couthily = "couthily"
1166+ case falculate = "falculate"
1167+ case foreseize = "foreseize"
1168+ case hyades = "Hyades"
1169+ case lemnad = "lemnad"
1170+ case monotheistically = "monotheistically"
1171+ case nonflying = "nonflying"
1172+ case ptenoglossa = "Ptenoglossa"
1173+ case repatch = "repatch"
1174+ case rodman = "rodman"
1175+ case strung = "strung"
1176+ case titmal = "titmal"
1177+ case twalpennyworth = "twalpennyworth"
1178+ case unblamable = "unblamable"
1179+ case vertical = "vertical"
1180+ case whiggification = "Whiggification"
1181+ case yardman = "yardman"
1182+ }
1183+}
1184+
1185+// MARK: RewriteClass convenience initializers and mutators
1186+
1187+extension RewriteClass {
1188+ init(data: Data) throws {
1189+ self = try newJSONDecoder().decode(RewriteClass.self, from: data)
1190+ }
1191+
1192+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1193+ guard let data = json.data(using: encoding) else {
1194+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1195+ }
1196+ try self.init(data: data)
1197+ }
1198+
1199+ init(fromURL url: URL) throws {
1200+ try self.init(data: try Data(contentsOf: url))
1201+ }
1202+
1203+ func with(
1204+ accountancy: JSONNull?? = nil,
1205+ cacotrophic: JSONNull?? = nil,
1206+ contest: JSONNull?? = nil,
1207+ couthily: JSONNull?? = nil,
1208+ falculate: JSONNull?? = nil,
1209+ foreseize: JSONNull?? = nil,
1210+ hyades: JSONNull?? = nil,
1211+ lemnad: JSONNull?? = nil,
1212+ monotheistically: JSONNull?? = nil,
1213+ nonflying: JSONNull?? = nil,
1214+ ptenoglossa: JSONNull?? = nil,
1215+ repatch: JSONNull?? = nil,
1216+ rodman: JSONNull?? = nil,
1217+ strung: JSONNull?? = nil,
1218+ titmal: JSONNull?? = nil,
1219+ twalpennyworth: JSONNull?? = nil,
1220+ unblamable: JSONNull?? = nil,
1221+ vertical: JSONNull?? = nil,
1222+ whiggification: JSONNull?? = nil,
1223+ yardman: JSONNull?? = nil
1224+ ) -> RewriteClass {
1225+ return RewriteClass(
1226+ accountancy: accountancy ?? self.accountancy,
1227+ cacotrophic: cacotrophic ?? self.cacotrophic,
1228+ contest: contest ?? self.contest,
1229+ couthily: couthily ?? self.couthily,
1230+ falculate: falculate ?? self.falculate,
1231+ foreseize: foreseize ?? self.foreseize,
1232+ hyades: hyades ?? self.hyades,
1233+ lemnad: lemnad ?? self.lemnad,
1234+ monotheistically: monotheistically ?? self.monotheistically,
1235+ nonflying: nonflying ?? self.nonflying,
1236+ ptenoglossa: ptenoglossa ?? self.ptenoglossa,
1237+ repatch: repatch ?? self.repatch,
1238+ rodman: rodman ?? self.rodman,
1239+ strung: strung ?? self.strung,
1240+ titmal: titmal ?? self.titmal,
1241+ twalpennyworth: twalpennyworth ?? self.twalpennyworth,
1242+ unblamable: unblamable ?? self.unblamable,
1243+ vertical: vertical ?? self.vertical,
1244+ whiggification: whiggification ?? self.whiggification,
1245+ yardman: yardman ?? self.yardman
1246+ )
1247+ }
1248+
1249+ func jsonData() throws -> Data {
1250+ return try newJSONEncoder().encode(self)
1251+ }
1252+
1253+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1254+ return String(data: try self.jsonData(), encoding: encoding)
1255+ }
1256+}
1257+
1258+enum Saccoderm: Codable, Hashable {
1259+ case integerArray([Int])
1260+ case string(String)
1261+ case null
1262+
1263+ init(from decoder: Decoder) throws {
1264+ let container = try decoder.singleValueContainer()
1265+ if let x = try? container.decode([Int].self) {
1266+ self = .integerArray(x)
1267+ return
1268+ }
1269+ if let x = try? container.decode(String.self) {
1270+ self = .string(x)
1271+ return
1272+ }
1273+ if container.decodeNil() {
1274+ self = .null
1275+ return
1276+ }
1277+ throw DecodingError.typeMismatch(Saccoderm.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Saccoderm"))
1278+ }
1279+
1280+ func encode(to encoder: Encoder) throws {
1281+ var container = encoder.singleValueContainer()
1282+ switch self {
1283+ case .integerArray(let x):
1284+ try container.encode(x)
1285+ case .string(let x):
1286+ try container.encode(x)
1287+ case .null:
1288+ try container.encodeNil()
1289+ }
1290+ }
1291+}
1292+
1293+enum SantirElement: Codable, Hashable {
1294+ case double(Double)
1295+ case santirClass(SantirClass)
1296+
1297+ init(from decoder: Decoder) throws {
1298+ let container = try decoder.singleValueContainer()
1299+ if let x = try? container.decode(Double.self) {
1300+ self = .double(x)
1301+ return
1302+ }
1303+ if let x = try? container.decode(SantirClass.self) {
1304+ self = .santirClass(x)
1305+ return
1306+ }
1307+ throw DecodingError.typeMismatch(SantirElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for SantirElement"))
1308+ }
1309+
1310+ func encode(to encoder: Encoder) throws {
1311+ var container = encoder.singleValueContainer()
1312+ switch self {
1313+ case .double(let x):
1314+ try container.encode(x)
1315+ case .santirClass(let x):
1316+ try container.encode(x)
1317+ }
1318+ }
1319+}
1320+
1321+//
1322+// Hashable or Equatable:
1323+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
1324+// for types that require the use of JSONAny, nor will the implementation of Hashable be
1325+// synthesized for types that have collections (such as arrays or dictionaries).
1326+
1327+// MARK: - SantirClass
1328+struct SantirClass: Codable, Hashable {
1329+ let admiredly: JSONNull?
1330+ let demicaponier: JSONNull?
1331+ let epitympanic: JSONNull?
1332+ let investitor: JSONNull?
1333+ let lupiform: JSONNull?
1334+ let monoflagellate: JSONNull?
1335+ let paleoethnic: JSONNull?
1336+ let prediscountable: JSONNull?
1337+ let rhetoricals: JSONNull?
1338+ let roomth: JSONNull?
1339+ let saccharose: JSONNull?
1340+ let septonasal: JSONNull?
1341+ let serpenticide: JSONNull?
1342+ let setarious: JSONNull?
1343+ let spaework: JSONNull?
1344+ let stylite: JSONNull?
1345+ let suessiones: JSONNull?
1346+ let timelily: JSONNull?
1347+ let unprofaned: JSONNull?
1348+ let vorticular: JSONNull?
1349+
1350+ enum CodingKeys: String, CodingKey {
1351+ case admiredly = "admiredly"
1352+ case demicaponier = "demicaponier"
1353+ case epitympanic = "epitympanic"
1354+ case investitor = "investitor"
1355+ case lupiform = "lupiform"
1356+ case monoflagellate = "monoflagellate"
1357+ case paleoethnic = "paleoethnic"
1358+ case prediscountable = "prediscountable"
1359+ case rhetoricals = "rhetoricals"
1360+ case roomth = "roomth"
1361+ case saccharose = "saccharose"
1362+ case septonasal = "septonasal"
1363+ case serpenticide = "serpenticide"
1364+ case setarious = "setarious"
1365+ case spaework = "spaework"
1366+ case stylite = "stylite"
1367+ case suessiones = "Suessiones"
1368+ case timelily = "timelily"
1369+ case unprofaned = "unprofaned"
1370+ case vorticular = "vorticular"
1371+ }
1372+}
1373+
1374+// MARK: SantirClass convenience initializers and mutators
1375+
1376+extension SantirClass {
1377+ init(data: Data) throws {
1378+ self = try newJSONDecoder().decode(SantirClass.self, from: data)
1379+ }
1380+
1381+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1382+ guard let data = json.data(using: encoding) else {
1383+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1384+ }
1385+ try self.init(data: data)
1386+ }
1387+
1388+ init(fromURL url: URL) throws {
1389+ try self.init(data: try Data(contentsOf: url))
1390+ }
1391+
1392+ func with(
1393+ admiredly: JSONNull?? = nil,
1394+ demicaponier: JSONNull?? = nil,
1395+ epitympanic: JSONNull?? = nil,
1396+ investitor: JSONNull?? = nil,
1397+ lupiform: JSONNull?? = nil,
1398+ monoflagellate: JSONNull?? = nil,
1399+ paleoethnic: JSONNull?? = nil,
1400+ prediscountable: JSONNull?? = nil,
1401+ rhetoricals: JSONNull?? = nil,
1402+ roomth: JSONNull?? = nil,
1403+ saccharose: JSONNull?? = nil,
1404+ septonasal: JSONNull?? = nil,
1405+ serpenticide: JSONNull?? = nil,
1406+ setarious: JSONNull?? = nil,
1407+ spaework: JSONNull?? = nil,
1408+ stylite: JSONNull?? = nil,
1409+ suessiones: JSONNull?? = nil,
1410+ timelily: JSONNull?? = nil,
1411+ unprofaned: JSONNull?? = nil,
1412+ vorticular: JSONNull?? = nil
1413+ ) -> SantirClass {
1414+ return SantirClass(
1415+ admiredly: admiredly ?? self.admiredly,
1416+ demicaponier: demicaponier ?? self.demicaponier,
1417+ epitympanic: epitympanic ?? self.epitympanic,
1418+ investitor: investitor ?? self.investitor,
1419+ lupiform: lupiform ?? self.lupiform,
1420+ monoflagellate: monoflagellate ?? self.monoflagellate,
1421+ paleoethnic: paleoethnic ?? self.paleoethnic,
1422+ prediscountable: prediscountable ?? self.prediscountable,
1423+ rhetoricals: rhetoricals ?? self.rhetoricals,
1424+ roomth: roomth ?? self.roomth,
1425+ saccharose: saccharose ?? self.saccharose,
1426+ septonasal: septonasal ?? self.septonasal,
1427+ serpenticide: serpenticide ?? self.serpenticide,
1428+ setarious: setarious ?? self.setarious,
1429+ spaework: spaework ?? self.spaework,
1430+ stylite: stylite ?? self.stylite,
1431+ suessiones: suessiones ?? self.suessiones,
1432+ timelily: timelily ?? self.timelily,
1433+ unprofaned: unprofaned ?? self.unprofaned,
1434+ vorticular: vorticular ?? self.vorticular
1435+ )
1436+ }
1437+
1438+ func jsonData() throws -> Data {
1439+ return try newJSONEncoder().encode(self)
1440+ }
1441+
1442+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1443+ return String(data: try self.jsonData(), encoding: encoding)
1444+ }
1445+}
1446+
1447+enum Saprophilous: Codable, Hashable {
1448+ case integerMap([String: Int])
1449+ case string(String)
1450+ case null
1451+
1452+ init(from decoder: Decoder) throws {
1453+ let container = try decoder.singleValueContainer()
1454+ if let x = try? container.decode([String: Int].self) {
1455+ self = .integerMap(x)
1456+ return
1457+ }
1458+ if let x = try? container.decode(String.self) {
1459+ self = .string(x)
1460+ return
1461+ }
1462+ if container.decodeNil() {
1463+ self = .null
1464+ return
1465+ }
1466+ throw DecodingError.typeMismatch(Saprophilous.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Saprophilous"))
1467+ }
1468+
1469+ func encode(to encoder: Encoder) throws {
1470+ var container = encoder.singleValueContainer()
1471+ switch self {
1472+ case .integerMap(let x):
1473+ try container.encode(x)
1474+ case .string(let x):
1475+ try container.encode(x)
1476+ case .null:
1477+ try container.encodeNil()
1478+ }
1479+ }
1480+}
1481+
1482+enum SaxtenElement: Codable, Hashable {
1483+ case saxtenClass(SaxtenClass)
1484+ case string(String)
1485+
1486+ init(from decoder: Decoder) throws {
1487+ let container = try decoder.singleValueContainer()
1488+ if let x = try? container.decode(String.self) {
1489+ self = .string(x)
1490+ return
1491+ }
1492+ if let x = try? container.decode(SaxtenClass.self) {
1493+ self = .saxtenClass(x)
1494+ return
1495+ }
1496+ throw DecodingError.typeMismatch(SaxtenElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for SaxtenElement"))
1497+ }
1498+
1499+ func encode(to encoder: Encoder) throws {
1500+ var container = encoder.singleValueContainer()
1501+ switch self {
1502+ case .saxtenClass(let x):
1503+ try container.encode(x)
1504+ case .string(let x):
1505+ try container.encode(x)
1506+ }
1507+ }
1508+}
1509+
1510+//
1511+// Hashable or Equatable:
1512+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
1513+// for types that require the use of JSONAny, nor will the implementation of Hashable be
1514+// synthesized for types that have collections (such as arrays or dictionaries).
1515+
1516+// MARK: - SaxtenClass
1517+struct SaxtenClass: Codable, Hashable {
1518+ let algarrobilla: JSONNull?
1519+ let bowgrace: JSONNull?
1520+ let catharticalness: Double?
1521+ let centaurid: JSONNull?
1522+ let chirotherium: Int?
1523+ let disdiapason: String?
1524+ let flix: JSONNull?
1525+ let germanely: JSONNull?
1526+ let homocerc: Bool?
1527+ let inhume: JSONNull?
1528+ let lepidote: JSONNull?
1529+ let megalochirous: JSONNull?
1530+ let ninepenny: JSONNull?
1531+ let nonbookish: JSONNull?
1532+ let nondeist: JSONNull?
1533+ let nymphaeaceous: JSONNull?
1534+ let parietofrontal: JSONNull?
1535+ let sancyite: JSONNull?
1536+ let subjectivist: JSONNull?
1537+ let tibiad: JSONNull?
1538+ let transonic: JSONNull?
1539+ let tripetalous: JSONNull?
1540+ let trunchman: JSONNull?
1541+ let urger: JSONNull?
1542+ let withdrawnness: JSONNull?
1543+
1544+ enum CodingKeys: String, CodingKey {
1545+ case algarrobilla = "algarrobilla"
1546+ case bowgrace = "bowgrace"
1547+ case catharticalness = "catharticalness"
1548+ case centaurid = "Centaurid"
1549+ case chirotherium = "Chirotherium"
1550+ case disdiapason = "disdiapason"
1551+ case flix = "flix"
1552+ case germanely = "germanely"
1553+ case homocerc = "homocerc"
1554+ case inhume = "inhume"
1555+ case lepidote = "lepidote"
1556+ case megalochirous = "megalochirous"
1557+ case ninepenny = "ninepenny"
1558+ case nonbookish = "nonbookish"
1559+ case nondeist = "nondeist"
1560+ case nymphaeaceous = "nymphaeaceous"
1561+ case parietofrontal = "parietofrontal"
1562+ case sancyite = "sancyite"
1563+ case subjectivist = "subjectivist"
1564+ case tibiad = "tibiad"
1565+ case transonic = "transonic"
1566+ case tripetalous = "tripetalous"
1567+ case trunchman = "trunchman"
1568+ case urger = "urger"
1569+ case withdrawnness = "withdrawnness"
1570+ }
1571+}
1572+
1573+// MARK: SaxtenClass convenience initializers and mutators
1574+
1575+extension SaxtenClass {
1576+ init(data: Data) throws {
1577+ self = try newJSONDecoder().decode(SaxtenClass.self, from: data)
1578+ }
1579+
1580+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1581+ guard let data = json.data(using: encoding) else {
1582+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1583+ }
1584+ try self.init(data: data)
1585+ }
1586+
1587+ init(fromURL url: URL) throws {
1588+ try self.init(data: try Data(contentsOf: url))
1589+ }
1590+
1591+ func with(
1592+ algarrobilla: JSONNull?? = nil,
1593+ bowgrace: JSONNull?? = nil,
1594+ catharticalness: Double?? = nil,
1595+ centaurid: JSONNull?? = nil,
1596+ chirotherium: Int?? = nil,
1597+ disdiapason: String?? = nil,
1598+ flix: JSONNull?? = nil,
1599+ germanely: JSONNull?? = nil,
1600+ homocerc: Bool?? = nil,
1601+ inhume: JSONNull?? = nil,
1602+ lepidote: JSONNull?? = nil,
1603+ megalochirous: JSONNull?? = nil,
1604+ ninepenny: JSONNull?? = nil,
1605+ nonbookish: JSONNull?? = nil,
1606+ nondeist: JSONNull?? = nil,
1607+ nymphaeaceous: JSONNull?? = nil,
1608+ parietofrontal: JSONNull?? = nil,
1609+ sancyite: JSONNull?? = nil,
1610+ subjectivist: JSONNull?? = nil,
1611+ tibiad: JSONNull?? = nil,
1612+ transonic: JSONNull?? = nil,
1613+ tripetalous: JSONNull?? = nil,
1614+ trunchman: JSONNull?? = nil,
1615+ urger: JSONNull?? = nil,
1616+ withdrawnness: JSONNull?? = nil
1617+ ) -> SaxtenClass {
1618+ return SaxtenClass(
1619+ algarrobilla: algarrobilla ?? self.algarrobilla,
1620+ bowgrace: bowgrace ?? self.bowgrace,
1621+ catharticalness: catharticalness ?? self.catharticalness,
1622+ centaurid: centaurid ?? self.centaurid,
1623+ chirotherium: chirotherium ?? self.chirotherium,
1624+ disdiapason: disdiapason ?? self.disdiapason,
1625+ flix: flix ?? self.flix,
1626+ germanely: germanely ?? self.germanely,
1627+ homocerc: homocerc ?? self.homocerc,
1628+ inhume: inhume ?? self.inhume,
1629+ lepidote: lepidote ?? self.lepidote,
1630+ megalochirous: megalochirous ?? self.megalochirous,
1631+ ninepenny: ninepenny ?? self.ninepenny,
1632+ nonbookish: nonbookish ?? self.nonbookish,
1633+ nondeist: nondeist ?? self.nondeist,
1634+ nymphaeaceous: nymphaeaceous ?? self.nymphaeaceous,
1635+ parietofrontal: parietofrontal ?? self.parietofrontal,
1636+ sancyite: sancyite ?? self.sancyite,
1637+ subjectivist: subjectivist ?? self.subjectivist,
1638+ tibiad: tibiad ?? self.tibiad,
1639+ transonic: transonic ?? self.transonic,
1640+ tripetalous: tripetalous ?? self.tripetalous,
1641+ trunchman: trunchman ?? self.trunchman,
1642+ urger: urger ?? self.urger,
1643+ withdrawnness: withdrawnness ?? self.withdrawnness
1644+ )
1645+ }
1646+
1647+ func jsonData() throws -> Data {
1648+ return try newJSONEncoder().encode(self)
1649+ }
1650+
1651+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1652+ return String(data: try self.jsonData(), encoding: encoding)
1653+ }
1654+}
1655+
1656+//
1657+// Hashable or Equatable:
1658+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
1659+// for types that require the use of JSONAny, nor will the implementation of Hashable be
1660+// synthesized for types that have collections (such as arrays or dictionaries).
1661+
1662+// MARK: - Scatty
1663+struct Scatty: Codable, Hashable {
1664+ let aeriferous: JSONNull?
1665+ let antical: JSONNull?
1666+ let antighostism: JSONNull?
1667+ let arcanum: JSONNull?
1668+ let autotrophy: JSONNull?
1669+ let baronial: JSONNull?
1670+ let caffeine: JSONNull?
1671+ let gorgoniacean: JSONNull?
1672+ let heroical: JSONNull?
1673+ let hydropical: JSONNull?
1674+ let mechanology: JSONNull?
1675+ let musicopoetic: JSONNull?
1676+ let officiality: JSONNull?
1677+ let oftentimes: JSONNull?
1678+ let ophthalmotonometer: JSONNull?
1679+ let reflectively: JSONNull?
1680+ let springer: JSONNull?
1681+ let tabasco: JSONNull?
1682+ let teleianthous: JSONNull?
1683+ let uncombated: JSONNull?
1684+
1685+ enum CodingKeys: String, CodingKey {
1686+ case aeriferous = "aeriferous"
1687+ case antical = "antical"
1688+ case antighostism = "antighostism"
1689+ case arcanum = "arcanum"
1690+ case autotrophy = "autotrophy"
1691+ case baronial = "baronial"
1692+ case caffeine = "caffeine"
1693+ case gorgoniacean = "gorgoniacean"
1694+ case heroical = "heroical"
1695+ case hydropical = "hydropical"
1696+ case mechanology = "mechanology"
1697+ case musicopoetic = "musicopoetic"
1698+ case officiality = "officiality"
1699+ case oftentimes = "oftentimes"
1700+ case ophthalmotonometer = "ophthalmotonometer"
1701+ case reflectively = "reflectively"
1702+ case springer = "springer"
1703+ case tabasco = "Tabasco"
1704+ case teleianthous = "teleianthous"
1705+ case uncombated = "uncombated"
1706+ }
1707+}
1708+
1709+// MARK: Scatty convenience initializers and mutators
1710+
1711+extension Scatty {
1712+ init(data: Data) throws {
1713+ self = try newJSONDecoder().decode(Scatty.self, from: data)
1714+ }
1715+
1716+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1717+ guard let data = json.data(using: encoding) else {
1718+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1719+ }
1720+ try self.init(data: data)
1721+ }
1722+
1723+ init(fromURL url: URL) throws {
1724+ try self.init(data: try Data(contentsOf: url))
1725+ }
1726+
1727+ func with(
1728+ aeriferous: JSONNull?? = nil,
1729+ antical: JSONNull?? = nil,
1730+ antighostism: JSONNull?? = nil,
1731+ arcanum: JSONNull?? = nil,
1732+ autotrophy: JSONNull?? = nil,
1733+ baronial: JSONNull?? = nil,
1734+ caffeine: JSONNull?? = nil,
1735+ gorgoniacean: JSONNull?? = nil,
1736+ heroical: JSONNull?? = nil,
1737+ hydropical: JSONNull?? = nil,
1738+ mechanology: JSONNull?? = nil,
1739+ musicopoetic: JSONNull?? = nil,
1740+ officiality: JSONNull?? = nil,
1741+ oftentimes: JSONNull?? = nil,
1742+ ophthalmotonometer: JSONNull?? = nil,
1743+ reflectively: JSONNull?? = nil,
1744+ springer: JSONNull?? = nil,
1745+ tabasco: JSONNull?? = nil,
1746+ teleianthous: JSONNull?? = nil,
1747+ uncombated: JSONNull?? = nil
1748+ ) -> Scatty {
1749+ return Scatty(
1750+ aeriferous: aeriferous ?? self.aeriferous,
1751+ antical: antical ?? self.antical,
1752+ antighostism: antighostism ?? self.antighostism,
1753+ arcanum: arcanum ?? self.arcanum,
1754+ autotrophy: autotrophy ?? self.autotrophy,
1755+ baronial: baronial ?? self.baronial,
1756+ caffeine: caffeine ?? self.caffeine,
1757+ gorgoniacean: gorgoniacean ?? self.gorgoniacean,
1758+ heroical: heroical ?? self.heroical,
1759+ hydropical: hydropical ?? self.hydropical,
1760+ mechanology: mechanology ?? self.mechanology,
1761+ musicopoetic: musicopoetic ?? self.musicopoetic,
1762+ officiality: officiality ?? self.officiality,
1763+ oftentimes: oftentimes ?? self.oftentimes,
1764+ ophthalmotonometer: ophthalmotonometer ?? self.ophthalmotonometer,
1765+ reflectively: reflectively ?? self.reflectively,
1766+ springer: springer ?? self.springer,
1767+ tabasco: tabasco ?? self.tabasco,
1768+ teleianthous: teleianthous ?? self.teleianthous,
1769+ uncombated: uncombated ?? self.uncombated
1770+ )
1771+ }
1772+
1773+ func jsonData() throws -> Data {
1774+ return try newJSONEncoder().encode(self)
1775+ }
1776+
1777+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1778+ return String(data: try self.jsonData(), encoding: encoding)
1779+ }
1780+}
1781+
1782+enum Scoffer: Codable, Hashable {
1783+ case integerMap([String: Int])
1784+ case nullArray([JSONNull?])
1785+ case null
1786+
1787+ init(from decoder: Decoder) throws {
1788+ let container = try decoder.singleValueContainer()
1789+ if let x = try? container.decode([JSONNull?].self) {
1790+ self = .nullArray(x)
1791+ return
1792+ }
1793+ if let x = try? container.decode([String: Int].self) {
1794+ self = .integerMap(x)
1795+ return
1796+ }
1797+ if container.decodeNil() {
1798+ self = .null
1799+ return
1800+ }
1801+ throw DecodingError.typeMismatch(Scoffer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Scoffer"))
1802+ }
1803+
1804+ func encode(to encoder: Encoder) throws {
1805+ var container = encoder.singleValueContainer()
1806+ switch self {
1807+ case .integerMap(let x):
1808+ try container.encode(x)
1809+ case .nullArray(let x):
1810+ try container.encode(x)
1811+ case .null:
1812+ try container.encodeNil()
1813+ }
1814+ }
1815+}
1816+
1817+enum Scrampum: Codable, Hashable {
1818+ case bool(Bool)
1819+ case integerArray([Int])
1820+ case null
1821+
1822+ init(from decoder: Decoder) throws {
1823+ let container = try decoder.singleValueContainer()
1824+ if let x = try? container.decode(Bool.self) {
1825+ self = .bool(x)
1826+ return
1827+ }
1828+ if let x = try? container.decode([Int].self) {
1829+ self = .integerArray(x)
1830+ return
1831+ }
1832+ if container.decodeNil() {
1833+ self = .null
1834+ return
1835+ }
1836+ throw DecodingError.typeMismatch(Scrampum.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Scrampum"))
1837+ }
1838+
1839+ func encode(to encoder: Encoder) throws {
1840+ var container = encoder.singleValueContainer()
1841+ switch self {
1842+ case .bool(let x):
1843+ try container.encode(x)
1844+ case .integerArray(let x):
1845+ try container.encode(x)
1846+ case .null:
1847+ try container.encodeNil()
1848+ }
1849+ }
1850+}
1851+
1852+enum Serpentinic: Codable, Hashable {
1853+ case double(Double)
1854+ case integerArray([Int])
1855+
1856+ init(from decoder: Decoder) throws {
1857+ let container = try decoder.singleValueContainer()
1858+ if let x = try? container.decode([Int].self) {
1859+ self = .integerArray(x)
1860+ return
1861+ }
1862+ if let x = try? container.decode(Double.self) {
1863+ self = .double(x)
1864+ return
1865+ }
1866+ throw DecodingError.typeMismatch(Serpentinic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Serpentinic"))
1867+ }
1868+
1869+ func encode(to encoder: Encoder) throws {
1870+ var container = encoder.singleValueContainer()
1871+ switch self {
1872+ case .double(let x):
1873+ try container.encode(x)
1874+ case .integerArray(let x):
1875+ try container.encode(x)
1876+ }
1877+ }
1878+}
1879+
1880+enum Shadowable: Codable, Hashable {
1881+ case bool(Bool)
1882+ case unionArray([Int?])
1883+
1884+ init(from decoder: Decoder) throws {
1885+ let container = try decoder.singleValueContainer()
1886+ if let x = try? container.decode(Bool.self) {
1887+ self = .bool(x)
1888+ return
1889+ }
1890+ if let x = try? container.decode([Int?].self) {
1891+ self = .unionArray(x)
1892+ return
1893+ }
1894+ throw DecodingError.typeMismatch(Shadowable.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Shadowable"))
1895+ }
1896+
1897+ func encode(to encoder: Encoder) throws {
1898+ var container = encoder.singleValueContainer()
1899+ switch self {
1900+ case .bool(let x):
1901+ try container.encode(x)
1902+ case .unionArray(let x):
1903+ try container.encode(x)
1904+ }
1905+ }
1906+}
1907+
1908+enum SisteringElement: Codable, Hashable {
1909+ case integer(Int)
1910+ case nullArray([JSONNull?])
1911+ case sisteringClass(SisteringClass)
1912+
1913+ init(from decoder: Decoder) throws {
1914+ let container = try decoder.singleValueContainer()
1915+ if let x = try? container.decode(Int.self) {
1916+ self = .integer(x)
1917+ return
1918+ }
1919+ if let x = try? container.decode([JSONNull?].self) {
1920+ self = .nullArray(x)
1921+ return
1922+ }
1923+ if let x = try? container.decode(SisteringClass.self) {
1924+ self = .sisteringClass(x)
1925+ return
1926+ }
1927+ throw DecodingError.typeMismatch(SisteringElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for SisteringElement"))
1928+ }
1929+
1930+ func encode(to encoder: Encoder) throws {
1931+ var container = encoder.singleValueContainer()
1932+ switch self {
1933+ case .integer(let x):
1934+ try container.encode(x)
1935+ case .nullArray(let x):
1936+ try container.encode(x)
1937+ case .sisteringClass(let x):
1938+ try container.encode(x)
1939+ }
1940+ }
1941+}
1942+
1943+//
1944+// Hashable or Equatable:
1945+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
1946+// for types that require the use of JSONAny, nor will the implementation of Hashable be
1947+// synthesized for types that have collections (such as arrays or dictionaries).
1948+
1949+// MARK: - SisteringClass
1950+struct SisteringClass: Codable, Hashable {
1951+ let amphicarpic: JSONNull?
1952+ let chianti: JSONNull?
1953+ let frigorific: JSONNull?
1954+ let haplomi: JSONNull?
1955+ let hyperkinesis: JSONNull?
1956+ let laudable: JSONNull?
1957+ let madwoman: JSONNull?
1958+ let maimedly: JSONNull?
1959+ let micropterygidae: JSONNull?
1960+ let microrhabdus: JSONNull?
1961+ let nondense: JSONNull?
1962+ let phlebemphraxis: JSONNull?
1963+ let redsear: JSONNull?
1964+ let schismatical: JSONNull?
1965+ let tartryl: JSONNull?
1966+ let unabhorred: JSONNull?
1967+ let undeliberateness: JSONNull?
1968+ let unmixable: JSONNull?
1969+ let untruckling: JSONNull?
1970+ let vineal: JSONNull?
1971+
1972+ enum CodingKeys: String, CodingKey {
1973+ case amphicarpic = "amphicarpic"
1974+ case chianti = "Chianti"
1975+ case frigorific = "frigorific"
1976+ case haplomi = "Haplomi"
1977+ case hyperkinesis = "hyperkinesis"
1978+ case laudable = "laudable"
1979+ case madwoman = "madwoman"
1980+ case maimedly = "maimedly"
1981+ case micropterygidae = "Micropterygidae"
1982+ case microrhabdus = "microrhabdus"
1983+ case nondense = "nondense"
1984+ case phlebemphraxis = "phlebemphraxis"
1985+ case redsear = "redsear"
1986+ case schismatical = "schismatical"
1987+ case tartryl = "tartryl"
1988+ case unabhorred = "unabhorred"
1989+ case undeliberateness = "undeliberateness"
1990+ case unmixable = "unmixable"
1991+ case untruckling = "untruckling"
1992+ case vineal = "vineal"
1993+ }
1994+}
1995+
1996+// MARK: SisteringClass convenience initializers and mutators
1997+
1998+extension SisteringClass {
1999+ init(data: Data) throws {
2000+ self = try newJSONDecoder().decode(SisteringClass.self, from: data)
2001+ }
2002+
2003+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2004+ guard let data = json.data(using: encoding) else {
2005+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2006+ }
2007+ try self.init(data: data)
2008+ }
2009+
2010+ init(fromURL url: URL) throws {
2011+ try self.init(data: try Data(contentsOf: url))
2012+ }
2013+
2014+ func with(
2015+ amphicarpic: JSONNull?? = nil,
2016+ chianti: JSONNull?? = nil,
2017+ frigorific: JSONNull?? = nil,
2018+ haplomi: JSONNull?? = nil,
2019+ hyperkinesis: JSONNull?? = nil,
2020+ laudable: JSONNull?? = nil,
2021+ madwoman: JSONNull?? = nil,
2022+ maimedly: JSONNull?? = nil,
2023+ micropterygidae: JSONNull?? = nil,
2024+ microrhabdus: JSONNull?? = nil,
2025+ nondense: JSONNull?? = nil,
2026+ phlebemphraxis: JSONNull?? = nil,
2027+ redsear: JSONNull?? = nil,
2028+ schismatical: JSONNull?? = nil,
2029+ tartryl: JSONNull?? = nil,
2030+ unabhorred: JSONNull?? = nil,
2031+ undeliberateness: JSONNull?? = nil,
2032+ unmixable: JSONNull?? = nil,
2033+ untruckling: JSONNull?? = nil,
2034+ vineal: JSONNull?? = nil
2035+ ) -> SisteringClass {
2036+ return SisteringClass(
2037+ amphicarpic: amphicarpic ?? self.amphicarpic,
2038+ chianti: chianti ?? self.chianti,
2039+ frigorific: frigorific ?? self.frigorific,
2040+ haplomi: haplomi ?? self.haplomi,
2041+ hyperkinesis: hyperkinesis ?? self.hyperkinesis,
2042+ laudable: laudable ?? self.laudable,
2043+ madwoman: madwoman ?? self.madwoman,
2044+ maimedly: maimedly ?? self.maimedly,
2045+ micropterygidae: micropterygidae ?? self.micropterygidae,
2046+ microrhabdus: microrhabdus ?? self.microrhabdus,
2047+ nondense: nondense ?? self.nondense,
2048+ phlebemphraxis: phlebemphraxis ?? self.phlebemphraxis,
2049+ redsear: redsear ?? self.redsear,
2050+ schismatical: schismatical ?? self.schismatical,
2051+ tartryl: tartryl ?? self.tartryl,
2052+ unabhorred: unabhorred ?? self.unabhorred,
2053+ undeliberateness: undeliberateness ?? self.undeliberateness,
2054+ unmixable: unmixable ?? self.unmixable,
2055+ untruckling: untruckling ?? self.untruckling,
2056+ vineal: vineal ?? self.vineal
2057+ )
2058+ }
2059+
2060+ func jsonData() throws -> Data {
2061+ return try newJSONEncoder().encode(self)
2062+ }
2063+
2064+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2065+ return String(data: try self.jsonData(), encoding: encoding)
2066+ }
2067+}
2068+
2069+//
2070+// Hashable or Equatable:
2071+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
2072+// for types that require the use of JSONAny, nor will the implementation of Hashable be
2073+// synthesized for types that have collections (such as arrays or dictionaries).
2074+
2075+// MARK: - Staghunting
2076+struct Staghunting: Codable, Hashable {
2077+ let calorimetric: Int?
2078+ let canid: Int?
2079+ let catharticalness: Double?
2080+ let chirotherium: Int?
2081+ let disdiapason: String?
2082+ let ditriglyphic: Int?
2083+ let floriferousness: Int?
2084+ let gamelike: Int?
2085+ let grig: Int?
2086+ let homocerc: Bool?
2087+ let interloan: Int?
2088+ let lithotomy: Int?
2089+ let loric: Int?
2090+ let membranocoriaceous: Int?
2091+ let membranogenic: Int?
2092+ let nonbookish: JSONNull?
2093+ let overtrump: Int?
2094+ let scotino: Int?
2095+ let seasonable: Int?
2096+ let sephen: Int?
2097+ let stigmarioid: Int?
2098+ let tired: Int?
2099+ let trifid: Int?
2100+ let undefeatedly: Int?
2101+ let ungirlish: Int?
2102+
2103+ enum CodingKeys: String, CodingKey {
2104+ case calorimetric = "calorimetric"
2105+ case canid = "canid"
2106+ case catharticalness = "catharticalness"
2107+ case chirotherium = "Chirotherium"
2108+ case disdiapason = "disdiapason"
2109+ case ditriglyphic = "ditriglyphic"
2110+ case floriferousness = "floriferousness"
2111+ case gamelike = "gamelike"
2112+ case grig = "grig"
2113+ case homocerc = "homocerc"
2114+ case interloan = "interloan"
2115+ case lithotomy = "lithotomy"
2116+ case loric = "loric"
2117+ case membranocoriaceous = "membranocoriaceous"
2118+ case membranogenic = "membranogenic"
2119+ case nonbookish = "nonbookish"
2120+ case overtrump = "overtrump"
2121+ case scotino = "scotino"
2122+ case seasonable = "seasonable"
2123+ case sephen = "sephen"
2124+ case stigmarioid = "stigmarioid"
2125+ case tired = "tired"
2126+ case trifid = "trifid"
2127+ case undefeatedly = "undefeatedly"
2128+ case ungirlish = "ungirlish"
2129+ }
2130+}
2131+
2132+// MARK: Staghunting convenience initializers and mutators
2133+
2134+extension Staghunting {
2135+ init(data: Data) throws {
2136+ self = try newJSONDecoder().decode(Staghunting.self, from: data)
2137+ }
2138+
2139+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2140+ guard let data = json.data(using: encoding) else {
2141+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2142+ }
2143+ try self.init(data: data)
2144+ }
2145+
2146+ init(fromURL url: URL) throws {
2147+ try self.init(data: try Data(contentsOf: url))
2148+ }
2149+
2150+ func with(
2151+ calorimetric: Int?? = nil,
2152+ canid: Int?? = nil,
2153+ catharticalness: Double?? = nil,
2154+ chirotherium: Int?? = nil,
2155+ disdiapason: String?? = nil,
2156+ ditriglyphic: Int?? = nil,
2157+ floriferousness: Int?? = nil,
2158+ gamelike: Int?? = nil,
2159+ grig: Int?? = nil,
2160+ homocerc: Bool?? = nil,
2161+ interloan: Int?? = nil,
2162+ lithotomy: Int?? = nil,
2163+ loric: Int?? = nil,
2164+ membranocoriaceous: Int?? = nil,
2165+ membranogenic: Int?? = nil,
2166+ nonbookish: JSONNull?? = nil,
2167+ overtrump: Int?? = nil,
2168+ scotino: Int?? = nil,
2169+ seasonable: Int?? = nil,
2170+ sephen: Int?? = nil,
2171+ stigmarioid: Int?? = nil,
2172+ tired: Int?? = nil,
2173+ trifid: Int?? = nil,
2174+ undefeatedly: Int?? = nil,
2175+ ungirlish: Int?? = nil
2176+ ) -> Staghunting {
2177+ return Staghunting(
2178+ calorimetric: calorimetric ?? self.calorimetric,
2179+ canid: canid ?? self.canid,
2180+ catharticalness: catharticalness ?? self.catharticalness,
2181+ chirotherium: chirotherium ?? self.chirotherium,
2182+ disdiapason: disdiapason ?? self.disdiapason,
2183+ ditriglyphic: ditriglyphic ?? self.ditriglyphic,
2184+ floriferousness: floriferousness ?? self.floriferousness,
2185+ gamelike: gamelike ?? self.gamelike,
2186+ grig: grig ?? self.grig,
2187+ homocerc: homocerc ?? self.homocerc,
2188+ interloan: interloan ?? self.interloan,
2189+ lithotomy: lithotomy ?? self.lithotomy,
2190+ loric: loric ?? self.loric,
2191+ membranocoriaceous: membranocoriaceous ?? self.membranocoriaceous,
2192+ membranogenic: membranogenic ?? self.membranogenic,
2193+ nonbookish: nonbookish ?? self.nonbookish,
2194+ overtrump: overtrump ?? self.overtrump,
2195+ scotino: scotino ?? self.scotino,
2196+ seasonable: seasonable ?? self.seasonable,
2197+ sephen: sephen ?? self.sephen,
2198+ stigmarioid: stigmarioid ?? self.stigmarioid,
2199+ tired: tired ?? self.tired,
2200+ trifid: trifid ?? self.trifid,
2201+ undefeatedly: undefeatedly ?? self.undefeatedly,
2202+ ungirlish: ungirlish ?? self.ungirlish
2203+ )
2204+ }
2205+
2206+ func jsonData() throws -> Data {
2207+ return try newJSONEncoder().encode(self)
2208+ }
2209+
2210+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2211+ return String(data: try self.jsonData(), encoding: encoding)
2212+ }
2213+}
2214+
2215+enum Stagmometer: Codable, Hashable {
2216+ case string(String)
2217+ case unionArray([Int?])
2218+
2219+ init(from decoder: Decoder) throws {
2220+ let container = try decoder.singleValueContainer()
2221+ if let x = try? container.decode([Int?].self) {
2222+ self = .unionArray(x)
2223+ return
2224+ }
2225+ if let x = try? container.decode(String.self) {
2226+ self = .string(x)
2227+ return
2228+ }
2229+ throw DecodingError.typeMismatch(Stagmometer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Stagmometer"))
2230+ }
2231+
2232+ func encode(to encoder: Encoder) throws {
2233+ var container = encoder.singleValueContainer()
2234+ switch self {
2235+ case .string(let x):
2236+ try container.encode(x)
2237+ case .unionArray(let x):
2238+ try container.encode(x)
2239+ }
2240+ }
2241+}
2242+
2243+enum Stimulability: Codable, Hashable {
2244+ case bool(Bool)
2245+ case integer(Int)
2246+ case integerMap([String: Int])
2247+
2248+ init(from decoder: Decoder) throws {
2249+ let container = try decoder.singleValueContainer()
2250+ if let x = try? container.decode(Bool.self) {
2251+ self = .bool(x)
2252+ return
2253+ }
2254+ if let x = try? container.decode(Int.self) {
2255+ self = .integer(x)
2256+ return
2257+ }
2258+ if let x = try? container.decode([String: Int].self) {
2259+ self = .integerMap(x)
2260+ return
2261+ }
2262+ throw DecodingError.typeMismatch(Stimulability.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Stimulability"))
2263+ }
2264+
2265+ func encode(to encoder: Encoder) throws {
2266+ var container = encoder.singleValueContainer()
2267+ switch self {
2268+ case .bool(let x):
2269+ try container.encode(x)
2270+ case .integer(let x):
2271+ try container.encode(x)
2272+ case .integerMap(let x):
2273+ try container.encode(x)
2274+ }
2275+ }
2276+}
2277+
2278+enum Strangleable: Codable, Hashable {
2279+ case double(Double)
2280+ case nullArray([JSONNull?])
2281+
2282+ init(from decoder: Decoder) throws {
2283+ let container = try decoder.singleValueContainer()
2284+ if let x = try? container.decode([JSONNull?].self) {
2285+ self = .nullArray(x)
2286+ return
2287+ }
2288+ if let x = try? container.decode(Double.self) {
2289+ self = .double(x)
2290+ return
2291+ }
2292+ throw DecodingError.typeMismatch(Strangleable.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Strangleable"))
2293+ }
2294+
2295+ func encode(to encoder: Encoder) throws {
2296+ var container = encoder.singleValueContainer()
2297+ switch self {
2298+ case .double(let x):
2299+ try container.encode(x)
2300+ case .nullArray(let x):
2301+ try container.encode(x)
2302+ }
2303+ }
2304+}
2305+
2306+enum StrenuosityElement: Codable, Hashable {
2307+ case nullArray([JSONNull?])
2308+ case strenuosityClass(StrenuosityClass)
2309+
2310+ init(from decoder: Decoder) throws {
2311+ let container = try decoder.singleValueContainer()
2312+ if let x = try? container.decode([JSONNull?].self) {
2313+ self = .nullArray(x)
2314+ return
2315+ }
2316+ if let x = try? container.decode(StrenuosityClass.self) {
2317+ self = .strenuosityClass(x)
2318+ return
2319+ }
2320+ throw DecodingError.typeMismatch(StrenuosityElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for StrenuosityElement"))
2321+ }
2322+
2323+ func encode(to encoder: Encoder) throws {
2324+ var container = encoder.singleValueContainer()
2325+ switch self {
2326+ case .nullArray(let x):
2327+ try container.encode(x)
2328+ case .strenuosityClass(let x):
2329+ try container.encode(x)
2330+ }
2331+ }
2332+}
2333+
2334+//
2335+// Hashable or Equatable:
2336+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
2337+// for types that require the use of JSONAny, nor will the implementation of Hashable be
2338+// synthesized for types that have collections (such as arrays or dictionaries).
2339+
2340+// MARK: - StrenuosityClass
2341+struct StrenuosityClass: Codable, Hashable {
2342+ let bliss: Int?
2343+ let buccate: Int?
2344+ let bulletproof: Int?
2345+ let catharticalness: Double?
2346+ let chirotherium: Int?
2347+ let crumblingness: Int?
2348+ let disdiapason: String?
2349+ let engagedly: Int?
2350+ let fightable: Int?
2351+ let hoariness: Int?
2352+ let homocerc: Bool?
2353+ let hypopodium: Int?
2354+ let luxurist: Int?
2355+ let mechanician: Int?
2356+ let nonbookish: JSONNull?
2357+ let onopordon: Int?
2358+ let podgily: Int?
2359+ let reformableness: Int?
2360+ let scatterbrains: Int?
2361+ let seminuria: Int?
2362+ let sodomite: Int?
2363+ let tramp: Int?
2364+ let undueness: Int?
2365+ let worthily: Int?
2366+ let yankeeist: Int?
2367+
2368+ enum CodingKeys: String, CodingKey {
2369+ case bliss = "bliss"
2370+ case buccate = "buccate"
2371+ case bulletproof = "bulletproof"
2372+ case catharticalness = "catharticalness"
2373+ case chirotherium = "Chirotherium"
2374+ case crumblingness = "crumblingness"
2375+ case disdiapason = "disdiapason"
2376+ case engagedly = "engagedly"
2377+ case fightable = "fightable"
2378+ case hoariness = "hoariness"
2379+ case homocerc = "homocerc"
2380+ case hypopodium = "hypopodium"
2381+ case luxurist = "luxurist"
2382+ case mechanician = "mechanician"
2383+ case nonbookish = "nonbookish"
2384+ case onopordon = "Onopordon"
2385+ case podgily = "podgily"
2386+ case reformableness = "reformableness"
2387+ case scatterbrains = "scatterbrains"
2388+ case seminuria = "seminuria"
2389+ case sodomite = "Sodomite"
2390+ case tramp = "tramp"
2391+ case undueness = "undueness"
2392+ case worthily = "worthily"
2393+ case yankeeist = "Yankeeist"
2394+ }
2395+}
2396+
2397+// MARK: StrenuosityClass convenience initializers and mutators
2398+
2399+extension StrenuosityClass {
2400+ init(data: Data) throws {
2401+ self = try newJSONDecoder().decode(StrenuosityClass.self, from: data)
2402+ }
2403+
2404+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2405+ guard let data = json.data(using: encoding) else {
2406+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2407+ }
2408+ try self.init(data: data)
2409+ }
2410+
2411+ init(fromURL url: URL) throws {
2412+ try self.init(data: try Data(contentsOf: url))
2413+ }
2414+
2415+ func with(
2416+ bliss: Int?? = nil,
2417+ buccate: Int?? = nil,
2418+ bulletproof: Int?? = nil,
2419+ catharticalness: Double?? = nil,
2420+ chirotherium: Int?? = nil,
2421+ crumblingness: Int?? = nil,
2422+ disdiapason: String?? = nil,
2423+ engagedly: Int?? = nil,
2424+ fightable: Int?? = nil,
2425+ hoariness: Int?? = nil,
2426+ homocerc: Bool?? = nil,
2427+ hypopodium: Int?? = nil,
2428+ luxurist: Int?? = nil,
2429+ mechanician: Int?? = nil,
2430+ nonbookish: JSONNull?? = nil,
2431+ onopordon: Int?? = nil,
2432+ podgily: Int?? = nil,
2433+ reformableness: Int?? = nil,
2434+ scatterbrains: Int?? = nil,
2435+ seminuria: Int?? = nil,
2436+ sodomite: Int?? = nil,
2437+ tramp: Int?? = nil,
2438+ undueness: Int?? = nil,
2439+ worthily: Int?? = nil,
2440+ yankeeist: Int?? = nil
2441+ ) -> StrenuosityClass {
2442+ return StrenuosityClass(
2443+ bliss: bliss ?? self.bliss,
2444+ buccate: buccate ?? self.buccate,
2445+ bulletproof: bulletproof ?? self.bulletproof,
2446+ catharticalness: catharticalness ?? self.catharticalness,
2447+ chirotherium: chirotherium ?? self.chirotherium,
2448+ crumblingness: crumblingness ?? self.crumblingness,
2449+ disdiapason: disdiapason ?? self.disdiapason,
2450+ engagedly: engagedly ?? self.engagedly,
2451+ fightable: fightable ?? self.fightable,
2452+ hoariness: hoariness ?? self.hoariness,
2453+ homocerc: homocerc ?? self.homocerc,
2454+ hypopodium: hypopodium ?? self.hypopodium,
2455+ luxurist: luxurist ?? self.luxurist,
2456+ mechanician: mechanician ?? self.mechanician,
2457+ nonbookish: nonbookish ?? self.nonbookish,
2458+ onopordon: onopordon ?? self.onopordon,
2459+ podgily: podgily ?? self.podgily,
2460+ reformableness: reformableness ?? self.reformableness,
2461+ scatterbrains: scatterbrains ?? self.scatterbrains,
2462+ seminuria: seminuria ?? self.seminuria,
2463+ sodomite: sodomite ?? self.sodomite,
2464+ tramp: tramp ?? self.tramp,
2465+ undueness: undueness ?? self.undueness,
2466+ worthily: worthily ?? self.worthily,
2467+ yankeeist: yankeeist ?? self.yankeeist
2468+ )
2469+ }
2470+
2471+ func jsonData() throws -> Data {
2472+ return try newJSONEncoder().encode(self)
2473+ }
2474+
2475+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2476+ return String(data: try self.jsonData(), encoding: encoding)
2477+ }
2478+}
2479+
2480+enum Tabaxir: Codable, Hashable {
2481+ case bool(Bool)
2482+ case double(Double)
2483+
2484+ init(from decoder: Decoder) throws {
2485+ let container = try decoder.singleValueContainer()
2486+ if let x = try? container.decode(Bool.self) {
2487+ self = .bool(x)
2488+ return
2489+ }
2490+ if let x = try? container.decode(Double.self) {
2491+ self = .double(x)
2492+ return
2493+ }
2494+ throw DecodingError.typeMismatch(Tabaxir.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Tabaxir"))
2495+ }
2496+
2497+ func encode(to encoder: Encoder) throws {
2498+ var container = encoder.singleValueContainer()
2499+ switch self {
2500+ case .bool(let x):
2501+ try container.encode(x)
2502+ case .double(let x):
2503+ try container.encode(x)
2504+ }
2505+ }
2506+}
2507+
2508+enum Talpiform: Codable, Hashable {
2509+ case double(Double)
2510+ case quebrachineClass(QuebrachineClass)
2511+ case null
2512+
2513+ init(from decoder: Decoder) throws {
2514+ let container = try decoder.singleValueContainer()
2515+ if let x = try? container.decode(Double.self) {
2516+ self = .double(x)
2517+ return
2518+ }
2519+ if let x = try? container.decode(QuebrachineClass.self) {
2520+ self = .quebrachineClass(x)
2521+ return
2522+ }
2523+ if container.decodeNil() {
2524+ self = .null
2525+ return
2526+ }
2527+ throw DecodingError.typeMismatch(Talpiform.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Talpiform"))
2528+ }
2529+
2530+ func encode(to encoder: Encoder) throws {
2531+ var container = encoder.singleValueContainer()
2532+ switch self {
2533+ case .double(let x):
2534+ try container.encode(x)
2535+ case .quebrachineClass(let x):
2536+ try container.encode(x)
2537+ case .null:
2538+ try container.encodeNil()
2539+ }
2540+ }
2541+}
2542+
2543+enum Thwack: Codable, Hashable {
2544+ case bool(Bool)
2545+ case double(Double)
2546+ case quebrachineClass(QuebrachineClass)
2547+
2548+ init(from decoder: Decoder) throws {
2549+ let container = try decoder.singleValueContainer()
2550+ if let x = try? container.decode(Bool.self) {
2551+ self = .bool(x)
2552+ return
2553+ }
2554+ if let x = try? container.decode(Double.self) {
2555+ self = .double(x)
2556+ return
2557+ }
2558+ if let x = try? container.decode(QuebrachineClass.self) {
2559+ self = .quebrachineClass(x)
2560+ return
2561+ }
2562+ throw DecodingError.typeMismatch(Thwack.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Thwack"))
2563+ }
2564+
2565+ func encode(to encoder: Encoder) throws {
2566+ var container = encoder.singleValueContainer()
2567+ switch self {
2568+ case .bool(let x):
2569+ try container.encode(x)
2570+ case .double(let x):
2571+ try container.encode(x)
2572+ case .quebrachineClass(let x):
2573+ try container.encode(x)
2574+ }
2575+ }
2576+}
2577+
2578+enum Tortricine: Codable, Hashable {
2579+ case quebrachineClass(QuebrachineClass)
2580+ case unionArray([Int?])
2581+
2582+ init(from decoder: Decoder) throws {
2583+ let container = try decoder.singleValueContainer()
2584+ if let x = try? container.decode([Int?].self) {
2585+ self = .unionArray(x)
2586+ return
2587+ }
2588+ if let x = try? container.decode(QuebrachineClass.self) {
2589+ self = .quebrachineClass(x)
2590+ return
2591+ }
2592+ throw DecodingError.typeMismatch(Tortricine.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Tortricine"))
2593+ }
2594+
2595+ func encode(to encoder: Encoder) throws {
2596+ var container = encoder.singleValueContainer()
2597+ switch self {
2598+ case .quebrachineClass(let x):
2599+ try container.encode(x)
2600+ case .unionArray(let x):
2601+ try container.encode(x)
2602+ }
2603+ }
2604+}
2605+
2606+enum TruantcyElement: Codable, Hashable {
2607+ case bool(Bool)
2608+ case truantcyClass(TruantcyClass)
2609+
2610+ init(from decoder: Decoder) throws {
2611+ let container = try decoder.singleValueContainer()
2612+ if let x = try? container.decode(Bool.self) {
2613+ self = .bool(x)
2614+ return
2615+ }
2616+ if let x = try? container.decode(TruantcyClass.self) {
2617+ self = .truantcyClass(x)
2618+ return
2619+ }
2620+ throw DecodingError.typeMismatch(TruantcyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for TruantcyElement"))
2621+ }
2622+
2623+ func encode(to encoder: Encoder) throws {
2624+ var container = encoder.singleValueContainer()
2625+ switch self {
2626+ case .bool(let x):
2627+ try container.encode(x)
2628+ case .truantcyClass(let x):
2629+ try container.encode(x)
2630+ }
2631+ }
2632+}
2633+
2634+//
2635+// Hashable or Equatable:
2636+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
2637+// for types that require the use of JSONAny, nor will the implementation of Hashable be
2638+// synthesized for types that have collections (such as arrays or dictionaries).
2639+
2640+// MARK: - TruantcyClass
2641+struct TruantcyClass: Codable, Hashable {
2642+ let alfiona: JSONNull?
2643+ let ascaridiasis: JSONNull?
2644+ let bungey: JSONNull?
2645+ let catharticalness: Double?
2646+ let ceroxyle: JSONNull?
2647+ let chirotherium: Int?
2648+ let chorology: JSONNull?
2649+ let disdiapason: String?
2650+ let enmarble: JSONNull?
2651+ let epeira: JSONNull?
2652+ let eurylaimi: JSONNull?
2653+ let germination: JSONNull?
2654+ let hallelujah: JSONNull?
2655+ let homocerc: Bool?
2656+ let lev: JSONNull?
2657+ let mouthing: JSONNull?
2658+ let nonbookish: JSONNull?
2659+ let philliloo: JSONNull?
2660+ let planetal: JSONNull?
2661+ let poney: JSONNull?
2662+ let punctualist: JSONNull?
2663+ let returnlessly: JSONNull?
2664+ let skelder: JSONNull?
2665+ let windwaywardly: JSONNull?
2666+ let yuman: JSONNull?
2667+
2668+ enum CodingKeys: String, CodingKey {
2669+ case alfiona = "alfiona"
2670+ case ascaridiasis = "ascaridiasis"
2671+ case bungey = "bungey"
2672+ case catharticalness = "catharticalness"
2673+ case ceroxyle = "ceroxyle"
2674+ case chirotherium = "Chirotherium"
2675+ case chorology = "chorology"
2676+ case disdiapason = "disdiapason"
2677+ case enmarble = "enmarble"
2678+ case epeira = "Epeira"
2679+ case eurylaimi = "Eurylaimi"
2680+ case germination = "germination"
2681+ case hallelujah = "hallelujah"
2682+ case homocerc = "homocerc"
2683+ case lev = "lev"
2684+ case mouthing = "mouthing"
2685+ case nonbookish = "nonbookish"
2686+ case philliloo = "philliloo"
2687+ case planetal = "planetal"
2688+ case poney = "poney"
2689+ case punctualist = "punctualist"
2690+ case returnlessly = "returnlessly"
2691+ case skelder = "skelder"
2692+ case windwaywardly = "windwaywardly"
2693+ case yuman = "Yuman"
2694+ }
2695+}
2696+
2697+// MARK: TruantcyClass convenience initializers and mutators
2698+
2699+extension TruantcyClass {
2700+ init(data: Data) throws {
2701+ self = try newJSONDecoder().decode(TruantcyClass.self, from: data)
2702+ }
2703+
2704+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2705+ guard let data = json.data(using: encoding) else {
2706+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2707+ }
2708+ try self.init(data: data)
2709+ }
2710+
2711+ init(fromURL url: URL) throws {
2712+ try self.init(data: try Data(contentsOf: url))
2713+ }
2714+
2715+ func with(
2716+ alfiona: JSONNull?? = nil,
2717+ ascaridiasis: JSONNull?? = nil,
2718+ bungey: JSONNull?? = nil,
2719+ catharticalness: Double?? = nil,
2720+ ceroxyle: JSONNull?? = nil,
2721+ chirotherium: Int?? = nil,
2722+ chorology: JSONNull?? = nil,
2723+ disdiapason: String?? = nil,
2724+ enmarble: JSONNull?? = nil,
2725+ epeira: JSONNull?? = nil,
2726+ eurylaimi: JSONNull?? = nil,
2727+ germination: JSONNull?? = nil,
2728+ hallelujah: JSONNull?? = nil,
2729+ homocerc: Bool?? = nil,
2730+ lev: JSONNull?? = nil,
2731+ mouthing: JSONNull?? = nil,
2732+ nonbookish: JSONNull?? = nil,
2733+ philliloo: JSONNull?? = nil,
2734+ planetal: JSONNull?? = nil,
2735+ poney: JSONNull?? = nil,
2736+ punctualist: JSONNull?? = nil,
2737+ returnlessly: JSONNull?? = nil,
2738+ skelder: JSONNull?? = nil,
2739+ windwaywardly: JSONNull?? = nil,
2740+ yuman: JSONNull?? = nil
2741+ ) -> TruantcyClass {
2742+ return TruantcyClass(
2743+ alfiona: alfiona ?? self.alfiona,
2744+ ascaridiasis: ascaridiasis ?? self.ascaridiasis,
2745+ bungey: bungey ?? self.bungey,
2746+ catharticalness: catharticalness ?? self.catharticalness,
2747+ ceroxyle: ceroxyle ?? self.ceroxyle,
2748+ chirotherium: chirotherium ?? self.chirotherium,
2749+ chorology: chorology ?? self.chorology,
2750+ disdiapason: disdiapason ?? self.disdiapason,
2751+ enmarble: enmarble ?? self.enmarble,
2752+ epeira: epeira ?? self.epeira,
2753+ eurylaimi: eurylaimi ?? self.eurylaimi,
2754+ germination: germination ?? self.germination,
2755+ hallelujah: hallelujah ?? self.hallelujah,
2756+ homocerc: homocerc ?? self.homocerc,
2757+ lev: lev ?? self.lev,
2758+ mouthing: mouthing ?? self.mouthing,
2759+ nonbookish: nonbookish ?? self.nonbookish,
2760+ philliloo: philliloo ?? self.philliloo,
2761+ planetal: planetal ?? self.planetal,
2762+ poney: poney ?? self.poney,
2763+ punctualist: punctualist ?? self.punctualist,
2764+ returnlessly: returnlessly ?? self.returnlessly,
2765+ skelder: skelder ?? self.skelder,
2766+ windwaywardly: windwaywardly ?? self.windwaywardly,
2767+ yuman: yuman ?? self.yuman
2768+ )
2769+ }
2770+
2771+ func jsonData() throws -> Data {
2772+ return try newJSONEncoder().encode(self)
2773+ }
2774+
2775+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2776+ return String(data: try self.jsonData(), encoding: encoding)
2777+ }
2778+}
2779+
2780+enum Unbeginning: Codable, Hashable {
2781+ case integerMap([String: Int])
2782+ case nullArray([JSONNull?])
2783+ case string(String)
2784+
2785+ init(from decoder: Decoder) throws {
2786+ let container = try decoder.singleValueContainer()
2787+ if let x = try? container.decode([JSONNull?].self) {
2788+ self = .nullArray(x)
2789+ return
2790+ }
2791+ if let x = try? container.decode([String: Int].self) {
2792+ self = .integerMap(x)
2793+ return
2794+ }
2795+ if let x = try? container.decode(String.self) {
2796+ self = .string(x)
2797+ return
2798+ }
2799+ throw DecodingError.typeMismatch(Unbeginning.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unbeginning"))
2800+ }
2801+
2802+ func encode(to encoder: Encoder) throws {
2803+ var container = encoder.singleValueContainer()
2804+ switch self {
2805+ case .integerMap(let x):
2806+ try container.encode(x)
2807+ case .nullArray(let x):
2808+ try container.encode(x)
2809+ case .string(let x):
2810+ try container.encode(x)
2811+ }
2812+ }
2813+}
2814+
2815+enum Undesirability: Codable, Hashable {
2816+ case integerArray([Int])
2817+ case integerMap([String: Int])
2818+ case string(String)
2819+
2820+ init(from decoder: Decoder) throws {
2821+ let container = try decoder.singleValueContainer()
2822+ if let x = try? container.decode([Int].self) {
2823+ self = .integerArray(x)
2824+ return
2825+ }
2826+ if let x = try? container.decode([String: Int].self) {
2827+ self = .integerMap(x)
2828+ return
2829+ }
2830+ if let x = try? container.decode(String.self) {
2831+ self = .string(x)
2832+ return
2833+ }
2834+ throw DecodingError.typeMismatch(Undesirability.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Undesirability"))
2835+ }
2836+
2837+ func encode(to encoder: Encoder) throws {
2838+ var container = encoder.singleValueContainer()
2839+ switch self {
2840+ case .integerArray(let x):
2841+ try container.encode(x)
2842+ case .integerMap(let x):
2843+ try container.encode(x)
2844+ case .string(let x):
2845+ try container.encode(x)
2846+ }
2847+ }
2848+}
2849+
2850+enum Unerasing: Codable, Hashable {
2851+ case integer(Int)
2852+ case integerMap([String: Int])
2853+ case nullArray([JSONNull?])
2854+
2855+ init(from decoder: Decoder) throws {
2856+ let container = try decoder.singleValueContainer()
2857+ if let x = try? container.decode(Int.self) {
2858+ self = .integer(x)
2859+ return
2860+ }
2861+ if let x = try? container.decode([JSONNull?].self) {
2862+ self = .nullArray(x)
2863+ return
2864+ }
2865+ if let x = try? container.decode([String: Int].self) {
2866+ self = .integerMap(x)
2867+ return
2868+ }
2869+ throw DecodingError.typeMismatch(Unerasing.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unerasing"))
2870+ }
2871+
2872+ func encode(to encoder: Encoder) throws {
2873+ var container = encoder.singleValueContainer()
2874+ switch self {
2875+ case .integer(let x):
2876+ try container.encode(x)
2877+ case .integerMap(let x):
2878+ try container.encode(x)
2879+ case .nullArray(let x):
2880+ try container.encode(x)
2881+ }
2882+ }
2883+}
2884+
2885+enum Unguentarium: Codable, Hashable {
2886+ case integer(Int)
2887+ case nullArray([JSONNull?])
2888+ case null
2889+
2890+ init(from decoder: Decoder) throws {
2891+ let container = try decoder.singleValueContainer()
2892+ if let x = try? container.decode(Int.self) {
2893+ self = .integer(x)
2894+ return
2895+ }
2896+ if let x = try? container.decode([JSONNull?].self) {
2897+ self = .nullArray(x)
2898+ return
2899+ }
2900+ if container.decodeNil() {
2901+ self = .null
2902+ return
2903+ }
2904+ throw DecodingError.typeMismatch(Unguentarium.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unguentarium"))
2905+ }
2906+
2907+ func encode(to encoder: Encoder) throws {
2908+ var container = encoder.singleValueContainer()
2909+ switch self {
2910+ case .integer(let x):
2911+ try container.encode(x)
2912+ case .nullArray(let x):
2913+ try container.encode(x)
2914+ case .null:
2915+ try container.encodeNil()
2916+ }
2917+ }
2918+}
2919+
2920+enum UnimpeachablyElement: Codable, Hashable {
2921+ case bool(Bool)
2922+ case unimpeachablyClass(UnimpeachablyClass)
2923+
2924+ init(from decoder: Decoder) throws {
2925+ let container = try decoder.singleValueContainer()
2926+ if let x = try? container.decode(Bool.self) {
2927+ self = .bool(x)
2928+ return
2929+ }
2930+ if let x = try? container.decode(UnimpeachablyClass.self) {
2931+ self = .unimpeachablyClass(x)
2932+ return
2933+ }
2934+ throw DecodingError.typeMismatch(UnimpeachablyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for UnimpeachablyElement"))
2935+ }
2936+
2937+ func encode(to encoder: Encoder) throws {
2938+ var container = encoder.singleValueContainer()
2939+ switch self {
2940+ case .bool(let x):
2941+ try container.encode(x)
2942+ case .unimpeachablyClass(let x):
2943+ try container.encode(x)
2944+ }
2945+ }
2946+}
2947+
2948+//
2949+// Hashable or Equatable:
2950+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
2951+// for types that require the use of JSONAny, nor will the implementation of Hashable be
2952+// synthesized for types that have collections (such as arrays or dictionaries).
2953+
2954+// MARK: - UnimpeachablyClass
2955+struct UnimpeachablyClass: Codable, Hashable {
2956+ let acerin: Int?
2957+ let bobadil: Int?
2958+ let catharticalness: Double?
2959+ let chirotherium: Int?
2960+ let chlorophylligenous: Int?
2961+ let conversational: Int?
2962+ let demiowl: Int?
2963+ let disdiapason: String?
2964+ let ectorhinal: Int?
2965+ let gamblesomeness: Int?
2966+ let homocerc: Bool?
2967+ let irrorate: Int?
2968+ let kindergartening: Int?
2969+ let lateritic: Int?
2970+ let mespil: Int?
2971+ let misconfiguration: Int?
2972+ let nonbookish: JSONNull?
2973+ let planometry: Int?
2974+ let quiina: Int?
2975+ let robert: Int?
2976+ let rot: Int?
2977+ let subcinctorium: Int?
2978+ let tussocker: Int?
2979+ let ultraproud: Int?
2980+ let unsuggestedness: Int?
2981+
2982+ enum CodingKeys: String, CodingKey {
2983+ case acerin = "acerin"
2984+ case bobadil = "Bobadil"
2985+ case catharticalness = "catharticalness"
2986+ case chirotherium = "Chirotherium"
2987+ case chlorophylligenous = "chlorophylligenous"
2988+ case conversational = "conversational"
2989+ case demiowl = "demiowl"
2990+ case disdiapason = "disdiapason"
2991+ case ectorhinal = "ectorhinal"
2992+ case gamblesomeness = "gamblesomeness"
2993+ case homocerc = "homocerc"
2994+ case irrorate = "irrorate"
2995+ case kindergartening = "kindergartening"
2996+ case lateritic = "lateritic"
2997+ case mespil = "mespil"
2998+ case misconfiguration = "misconfiguration"
2999+ case nonbookish = "nonbookish"
3000+ case planometry = "planometry"
3001+ case quiina = "Quiina"
3002+ case robert = "Robert"
3003+ case rot = "rot"
3004+ case subcinctorium = "subcinctorium"
3005+ case tussocker = "tussocker"
3006+ case ultraproud = "ultraproud"
3007+ case unsuggestedness = "unsuggestedness"
3008+ }
3009+}
3010+
3011+// MARK: UnimpeachablyClass convenience initializers and mutators
3012+
3013+extension UnimpeachablyClass {
3014+ init(data: Data) throws {
3015+ self = try newJSONDecoder().decode(UnimpeachablyClass.self, from: data)
3016+ }
3017+
3018+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
3019+ guard let data = json.data(using: encoding) else {
3020+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
3021+ }
3022+ try self.init(data: data)
3023+ }
3024+
3025+ init(fromURL url: URL) throws {
3026+ try self.init(data: try Data(contentsOf: url))
3027+ }
3028+
3029+ func with(
3030+ acerin: Int?? = nil,
3031+ bobadil: Int?? = nil,
3032+ catharticalness: Double?? = nil,
3033+ chirotherium: Int?? = nil,
3034+ chlorophylligenous: Int?? = nil,
3035+ conversational: Int?? = nil,
3036+ demiowl: Int?? = nil,
3037+ disdiapason: String?? = nil,
3038+ ectorhinal: Int?? = nil,
3039+ gamblesomeness: Int?? = nil,
3040+ homocerc: Bool?? = nil,
3041+ irrorate: Int?? = nil,
3042+ kindergartening: Int?? = nil,
3043+ lateritic: Int?? = nil,
3044+ mespil: Int?? = nil,
3045+ misconfiguration: Int?? = nil,
3046+ nonbookish: JSONNull?? = nil,
3047+ planometry: Int?? = nil,
3048+ quiina: Int?? = nil,
3049+ robert: Int?? = nil,
3050+ rot: Int?? = nil,
3051+ subcinctorium: Int?? = nil,
3052+ tussocker: Int?? = nil,
3053+ ultraproud: Int?? = nil,
3054+ unsuggestedness: Int?? = nil
3055+ ) -> UnimpeachablyClass {
3056+ return UnimpeachablyClass(
3057+ acerin: acerin ?? self.acerin,
3058+ bobadil: bobadil ?? self.bobadil,
3059+ catharticalness: catharticalness ?? self.catharticalness,
3060+ chirotherium: chirotherium ?? self.chirotherium,
3061+ chlorophylligenous: chlorophylligenous ?? self.chlorophylligenous,
3062+ conversational: conversational ?? self.conversational,
3063+ demiowl: demiowl ?? self.demiowl,
3064+ disdiapason: disdiapason ?? self.disdiapason,
3065+ ectorhinal: ectorhinal ?? self.ectorhinal,
3066+ gamblesomeness: gamblesomeness ?? self.gamblesomeness,
3067+ homocerc: homocerc ?? self.homocerc,
3068+ irrorate: irrorate ?? self.irrorate,
3069+ kindergartening: kindergartening ?? self.kindergartening,
3070+ lateritic: lateritic ?? self.lateritic,
3071+ mespil: mespil ?? self.mespil,
3072+ misconfiguration: misconfiguration ?? self.misconfiguration,
3073+ nonbookish: nonbookish ?? self.nonbookish,
3074+ planometry: planometry ?? self.planometry,
3075+ quiina: quiina ?? self.quiina,
3076+ robert: robert ?? self.robert,
3077+ rot: rot ?? self.rot,
3078+ subcinctorium: subcinctorium ?? self.subcinctorium,
3079+ tussocker: tussocker ?? self.tussocker,
3080+ ultraproud: ultraproud ?? self.ultraproud,
3081+ unsuggestedness: unsuggestedness ?? self.unsuggestedness
3082+ )
3083+ }
3084+
3085+ func jsonData() throws -> Data {
3086+ return try newJSONEncoder().encode(self)
3087+ }
3088+
3089+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
3090+ return String(data: try self.jsonData(), encoding: encoding)
3091+ }
3092+}
3093+
3094+enum Unmortgaged: Codable, Hashable {
3095+ case double(Double)
3096+ case integerMap([String: Int])
3097+ case null
3098+
3099+ init(from decoder: Decoder) throws {
3100+ let container = try decoder.singleValueContainer()
3101+ if let x = try? container.decode(Double.self) {
3102+ self = .double(x)
3103+ return
3104+ }
3105+ if let x = try? container.decode([String: Int].self) {
3106+ self = .integerMap(x)
3107+ return
3108+ }
3109+ if container.decodeNil() {
3110+ self = .null
3111+ return
3112+ }
3113+ throw DecodingError.typeMismatch(Unmortgaged.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unmortgaged"))
3114+ }
3115+
3116+ func encode(to encoder: Encoder) throws {
3117+ var container = encoder.singleValueContainer()
3118+ switch self {
3119+ case .double(let x):
3120+ try container.encode(x)
3121+ case .integerMap(let x):
3122+ try container.encode(x)
3123+ case .null:
3124+ try container.encodeNil()
3125+ }
3126+ }
3127+}
3128+
3129+enum Unobstructed: Codable, Hashable {
3130+ case integer(Int)
3131+ case quebrachineClass(QuebrachineClass)
3132+ case null
3133+
3134+ init(from decoder: Decoder) throws {
3135+ let container = try decoder.singleValueContainer()
3136+ if let x = try? container.decode(Int.self) {
3137+ self = .integer(x)
3138+ return
3139+ }
3140+ if let x = try? container.decode(QuebrachineClass.self) {
3141+ self = .quebrachineClass(x)
3142+ return
3143+ }
3144+ if container.decodeNil() {
3145+ self = .null
3146+ return
3147+ }
3148+ throw DecodingError.typeMismatch(Unobstructed.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unobstructed"))
3149+ }
3150+
3151+ func encode(to encoder: Encoder) throws {
3152+ var container = encoder.singleValueContainer()
3153+ switch self {
3154+ case .integer(let x):
3155+ try container.encode(x)
3156+ case .quebrachineClass(let x):
3157+ try container.encode(x)
3158+ case .null:
3159+ try container.encodeNil()
3160+ }
3161+ }
3162+}
3163+
3164+enum Unreceptivity: Codable, Hashable {
3165+ case integer(Int)
3166+ case nullArray([JSONNull?])
3167+ case string(String)
3168+
3169+ init(from decoder: Decoder) throws {
3170+ let container = try decoder.singleValueContainer()
3171+ if let x = try? container.decode(Int.self) {
3172+ self = .integer(x)
3173+ return
3174+ }
3175+ if let x = try? container.decode([JSONNull?].self) {
3176+ self = .nullArray(x)
3177+ return
3178+ }
3179+ if let x = try? container.decode(String.self) {
3180+ self = .string(x)
3181+ return
3182+ }
3183+ throw DecodingError.typeMismatch(Unreceptivity.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unreceptivity"))
3184+ }
3185+
3186+ func encode(to encoder: Encoder) throws {
3187+ var container = encoder.singleValueContainer()
3188+ switch self {
3189+ case .integer(let x):
3190+ try container.encode(x)
3191+ case .nullArray(let x):
3192+ try container.encode(x)
3193+ case .string(let x):
3194+ try container.encode(x)
3195+ }
3196+ }
3197+}
3198+
3199+enum Unsatisfactoriness: Codable, Hashable {
3200+ case bool(Bool)
3201+ case integer(Int)
3202+ case integerArray([Int])
3203+
3204+ init(from decoder: Decoder) throws {
3205+ let container = try decoder.singleValueContainer()
3206+ if let x = try? container.decode(Bool.self) {
3207+ self = .bool(x)
3208+ return
3209+ }
3210+ if let x = try? container.decode(Int.self) {
3211+ self = .integer(x)
3212+ return
3213+ }
3214+ if let x = try? container.decode([Int].self) {
3215+ self = .integerArray(x)
3216+ return
3217+ }
3218+ throw DecodingError.typeMismatch(Unsatisfactoriness.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unsatisfactoriness"))
3219+ }
3220+
3221+ func encode(to encoder: Encoder) throws {
3222+ var container = encoder.singleValueContainer()
3223+ switch self {
3224+ case .bool(let x):
3225+ try container.encode(x)
3226+ case .integer(let x):
3227+ try container.encode(x)
3228+ case .integerArray(let x):
3229+ try container.encode(x)
3230+ }
3231+ }
3232+}
3233+
3234+enum UnstressedElement: Codable, Hashable {
3235+ case bool(Bool)
3236+ case string(String)
3237+ case unstressedClass(UnstressedClass)
3238+
3239+ init(from decoder: Decoder) throws {
3240+ let container = try decoder.singleValueContainer()
3241+ if let x = try? container.decode(Bool.self) {
3242+ self = .bool(x)
3243+ return
3244+ }
3245+ if let x = try? container.decode(String.self) {
3246+ self = .string(x)
3247+ return
3248+ }
3249+ if let x = try? container.decode(UnstressedClass.self) {
3250+ self = .unstressedClass(x)
3251+ return
3252+ }
3253+ throw DecodingError.typeMismatch(UnstressedElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for UnstressedElement"))
3254+ }
3255+
3256+ func encode(to encoder: Encoder) throws {
3257+ var container = encoder.singleValueContainer()
3258+ switch self {
3259+ case .bool(let x):
3260+ try container.encode(x)
3261+ case .string(let x):
3262+ try container.encode(x)
3263+ case .unstressedClass(let x):
3264+ try container.encode(x)
3265+ }
3266+ }
3267+}
3268+
3269+//
3270+// Hashable or Equatable:
3271+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
3272+// for types that require the use of JSONAny, nor will the implementation of Hashable be
3273+// synthesized for types that have collections (such as arrays or dictionaries).
3274+
3275+// MARK: - UnstressedClass
3276+struct UnstressedClass: Codable, Hashable {
3277+ let alain: JSONNull?
3278+ let amphirhina: JSONNull?
3279+ let antimachinery: JSONNull?
3280+ let coldish: JSONNull?
3281+ let crantara: JSONNull?
3282+ let distinguishing: JSONNull?
3283+ let elytroposis: JSONNull?
3284+ let gentianwort: JSONNull?
3285+ let heliosis: JSONNull?
3286+ let instrumental: JSONNull?
3287+ let introinflection: JSONNull?
3288+ let kala: JSONNull?
3289+ let lincolnian: JSONNull?
3290+ let metad: JSONNull?
3291+ let sarcophilus: JSONNull?
3292+ let swingingly: JSONNull?
3293+ let unconformity: JSONNull?
3294+ let undecreed: JSONNull?
3295+ let venerable: JSONNull?
3296+ let vowellessness: JSONNull?
3297+
3298+ enum CodingKeys: String, CodingKey {
3299+ case alain = "Alain"
3300+ case amphirhina = "Amphirhina"
3301+ case antimachinery = "antimachinery"
3302+ case coldish = "coldish"
3303+ case crantara = "crantara"
3304+ case distinguishing = "distinguishing"
3305+ case elytroposis = "elytroposis"
3306+ case gentianwort = "gentianwort"
3307+ case heliosis = "heliosis"
3308+ case instrumental = "instrumental"
3309+ case introinflection = "introinflection"
3310+ case kala = "kala"
3311+ case lincolnian = "Lincolnian"
3312+ case metad = "metad"
3313+ case sarcophilus = "Sarcophilus"
3314+ case swingingly = "swingingly"
3315+ case unconformity = "unconformity"
3316+ case undecreed = "undecreed"
3317+ case venerable = "venerable"
3318+ case vowellessness = "vowellessness"
3319+ }
3320+}
3321+
3322+// MARK: UnstressedClass convenience initializers and mutators
3323+
3324+extension UnstressedClass {
3325+ init(data: Data) throws {
3326+ self = try newJSONDecoder().decode(UnstressedClass.self, from: data)
3327+ }
3328+
3329+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
3330+ guard let data = json.data(using: encoding) else {
3331+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
3332+ }
3333+ try self.init(data: data)
3334+ }
3335+
3336+ init(fromURL url: URL) throws {
3337+ try self.init(data: try Data(contentsOf: url))
3338+ }
3339+
3340+ func with(
3341+ alain: JSONNull?? = nil,
3342+ amphirhina: JSONNull?? = nil,
3343+ antimachinery: JSONNull?? = nil,
3344+ coldish: JSONNull?? = nil,
3345+ crantara: JSONNull?? = nil,
3346+ distinguishing: JSONNull?? = nil,
3347+ elytroposis: JSONNull?? = nil,
3348+ gentianwort: JSONNull?? = nil,
3349+ heliosis: JSONNull?? = nil,
3350+ instrumental: JSONNull?? = nil,
3351+ introinflection: JSONNull?? = nil,
3352+ kala: JSONNull?? = nil,
3353+ lincolnian: JSONNull?? = nil,
3354+ metad: JSONNull?? = nil,
3355+ sarcophilus: JSONNull?? = nil,
3356+ swingingly: JSONNull?? = nil,
3357+ unconformity: JSONNull?? = nil,
3358+ undecreed: JSONNull?? = nil,
3359+ venerable: JSONNull?? = nil,
3360+ vowellessness: JSONNull?? = nil
3361+ ) -> UnstressedClass {
3362+ return UnstressedClass(
3363+ alain: alain ?? self.alain,
3364+ amphirhina: amphirhina ?? self.amphirhina,
3365+ antimachinery: antimachinery ?? self.antimachinery,
3366+ coldish: coldish ?? self.coldish,
3367+ crantara: crantara ?? self.crantara,
3368+ distinguishing: distinguishing ?? self.distinguishing,
3369+ elytroposis: elytroposis ?? self.elytroposis,
3370+ gentianwort: gentianwort ?? self.gentianwort,
3371+ heliosis: heliosis ?? self.heliosis,
3372+ instrumental: instrumental ?? self.instrumental,
3373+ introinflection: introinflection ?? self.introinflection,
3374+ kala: kala ?? self.kala,
3375+ lincolnian: lincolnian ?? self.lincolnian,
3376+ metad: metad ?? self.metad,
3377+ sarcophilus: sarcophilus ?? self.sarcophilus,
3378+ swingingly: swingingly ?? self.swingingly,
3379+ unconformity: unconformity ?? self.unconformity,
3380+ undecreed: undecreed ?? self.undecreed,
3381+ venerable: venerable ?? self.venerable,
3382+ vowellessness: vowellessness ?? self.vowellessness
3383+ )
3384+ }
3385+
3386+ func jsonData() throws -> Data {
3387+ return try newJSONEncoder().encode(self)
3388+ }
3389+
3390+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
3391+ return String(data: try self.jsonData(), encoding: encoding)
3392+ }
3393+}
3394+
3395+enum Untasked: Codable, Hashable {
3396+ case double(Double)
3397+ case integerMap([String: Int])
3398+ case nullArray([JSONNull?])
3399+
3400+ init(from decoder: Decoder) throws {
3401+ let container = try decoder.singleValueContainer()
3402+ if let x = try? container.decode([JSONNull?].self) {
3403+ self = .nullArray(x)
3404+ return
3405+ }
3406+ if let x = try? container.decode(Double.self) {
3407+ self = .double(x)
3408+ return
3409+ }
3410+ if let x = try? container.decode([String: Int].self) {
3411+ self = .integerMap(x)
3412+ return
3413+ }
3414+ throw DecodingError.typeMismatch(Untasked.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Untasked"))
3415+ }
3416+
3417+ func encode(to encoder: Encoder) throws {
3418+ var container = encoder.singleValueContainer()
3419+ switch self {
3420+ case .double(let x):
3421+ try container.encode(x)
3422+ case .integerMap(let x):
3423+ try container.encode(x)
3424+ case .nullArray(let x):
3425+ try container.encode(x)
3426+ }
3427+ }
3428+}
3429+
3430+enum Unvarying: Codable, Hashable {
3431+ case bool(Bool)
3432+ case double(Double)
3433+ case integerMap([String: Int])
3434+
3435+ init(from decoder: Decoder) throws {
3436+ let container = try decoder.singleValueContainer()
3437+ if let x = try? container.decode(Bool.self) {
3438+ self = .bool(x)
3439+ return
3440+ }
3441+ if let x = try? container.decode(Double.self) {
3442+ self = .double(x)
3443+ return
3444+ }
3445+ if let x = try? container.decode([String: Int].self) {
3446+ self = .integerMap(x)
3447+ return
3448+ }
3449+ throw DecodingError.typeMismatch(Unvarying.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unvarying"))
3450+ }
3451+
3452+ func encode(to encoder: Encoder) throws {
3453+ var container = encoder.singleValueContainer()
3454+ switch self {
3455+ case .bool(let x):
3456+ try container.encode(x)
3457+ case .double(let x):
3458+ try container.encode(x)
3459+ case .integerMap(let x):
3460+ try container.encode(x)
3461+ }
3462+ }
3463+}
3464+
3465+enum Vehemently: Codable, Hashable {
3466+ case bool(Bool)
3467+ case nullArray([JSONNull?])
3468+ case null
3469+
3470+ init(from decoder: Decoder) throws {
3471+ let container = try decoder.singleValueContainer()
3472+ if let x = try? container.decode(Bool.self) {
3473+ self = .bool(x)
3474+ return
3475+ }
3476+ if let x = try? container.decode([JSONNull?].self) {
3477+ self = .nullArray(x)
3478+ return
3479+ }
3480+ if container.decodeNil() {
3481+ self = .null
3482+ return
3483+ }
3484+ throw DecodingError.typeMismatch(Vehemently.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Vehemently"))
3485+ }
3486+
3487+ func encode(to encoder: Encoder) throws {
3488+ var container = encoder.singleValueContainer()
3489+ switch self {
3490+ case .bool(let x):
3491+ try container.encode(x)
3492+ case .nullArray(let x):
3493+ try container.encode(x)
3494+ case .null:
3495+ try container.encodeNil()
3496+ }
3497+ }
3498+}
3499+
3500+enum Whitepot: Codable, Hashable {
3501+ case double(Double)
3502+ case quebrachineClass(QuebrachineClass)
3503+
3504+ init(from decoder: Decoder) throws {
3505+ let container = try decoder.singleValueContainer()
3506+ if let x = try? container.decode(Double.self) {
3507+ self = .double(x)
3508+ return
3509+ }
3510+ if let x = try? container.decode(QuebrachineClass.self) {
3511+ self = .quebrachineClass(x)
3512+ return
3513+ }
3514+ throw DecodingError.typeMismatch(Whitepot.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Whitepot"))
3515+ }
3516+
3517+ func encode(to encoder: Encoder) throws {
3518+ var container = encoder.singleValueContainer()
3519+ switch self {
3520+ case .double(let x):
3521+ try container.encode(x)
3522+ case .quebrachineClass(let x):
3523+ try container.encode(x)
3524+ }
3525+ }
3526+}
3527+
3528+enum WrothyElement: Codable, Hashable {
3529+ case nullArray([JSONNull?])
3530+ case wrothyClass(WrothyClass)
3531+
3532+ init(from decoder: Decoder) throws {
3533+ let container = try decoder.singleValueContainer()
3534+ if let x = try? container.decode([JSONNull?].self) {
3535+ self = .nullArray(x)
3536+ return
3537+ }
3538+ if let x = try? container.decode(WrothyClass.self) {
3539+ self = .wrothyClass(x)
3540+ return
3541+ }
3542+ throw DecodingError.typeMismatch(WrothyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for WrothyElement"))
3543+ }
3544+
3545+ func encode(to encoder: Encoder) throws {
3546+ var container = encoder.singleValueContainer()
3547+ switch self {
3548+ case .nullArray(let x):
3549+ try container.encode(x)
3550+ case .wrothyClass(let x):
3551+ try container.encode(x)
3552+ }
3553+ }
3554+}
3555+
3556+//
3557+// Hashable or Equatable:
3558+// The compiler will not be able to synthesize the implementation of Hashable or Equatable
3559+// for types that require the use of JSONAny, nor will the implementation of Hashable be
3560+// synthesized for types that have collections (such as arrays or dictionaries).
3561+
3562+// MARK: - WrothyClass
3563+struct WrothyClass: Codable, Hashable {
3564+ let aeschynanthus: JSONNull?
3565+ let aquiferous: JSONNull?
3566+ let cheapener: JSONNull?
3567+ let enumeration: JSONNull?
3568+ let ephesine: JSONNull?
3569+ let escadrille: JSONNull?
3570+ let estrous: JSONNull?
3571+ let interestedly: JSONNull?
3572+ let katakinetomer: JSONNull?
3573+ let mortification: JSONNull?
3574+ let morula: JSONNull?
3575+ let orthosymmetrical: JSONNull?
3576+ let overbark: JSONNull?
3577+ let politist: JSONNull?
3578+ let qualified: JSONNull?
3579+ let sphenomalar: JSONNull?
3580+ let throatful: JSONNull?
3581+ let transhumance: JSONNull?
3582+ let triandrian: JSONNull?
3583+ let unbooked: JSONNull?
3584+
3585+ enum CodingKeys: String, CodingKey {
3586+ case aeschynanthus = "Aeschynanthus"
3587+ case aquiferous = "aquiferous"
3588+ case cheapener = "cheapener"
3589+ case enumeration = "enumeration"
3590+ case ephesine = "Ephesine"
3591+ case escadrille = "escadrille"
3592+ case estrous = "estrous"
3593+ case interestedly = "interestedly"
3594+ case katakinetomer = "katakinetomer"
3595+ case mortification = "mortification"
3596+ case morula = "morula"
3597+ case orthosymmetrical = "orthosymmetrical"
3598+ case overbark = "overbark"
3599+ case politist = "politist"
3600+ case qualified = "qualified"
3601+ case sphenomalar = "sphenomalar"
3602+ case throatful = "throatful"
3603+ case transhumance = "transhumance"
3604+ case triandrian = "triandrian"
3605+ case unbooked = "unbooked"
3606+ }
3607+}
3608+
3609+// MARK: WrothyClass convenience initializers and mutators
3610+
3611+extension WrothyClass {
3612+ init(data: Data) throws {
3613+ self = try newJSONDecoder().decode(WrothyClass.self, from: data)
3614+ }
3615+
3616+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
3617+ guard let data = json.data(using: encoding) else {
3618+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
3619+ }
3620+ try self.init(data: data)
3621+ }
3622+
3623+ init(fromURL url: URL) throws {
3624+ try self.init(data: try Data(contentsOf: url))
3625+ }
3626+
3627+ func with(
3628+ aeschynanthus: JSONNull?? = nil,
3629+ aquiferous: JSONNull?? = nil,
3630+ cheapener: JSONNull?? = nil,
3631+ enumeration: JSONNull?? = nil,
3632+ ephesine: JSONNull?? = nil,
3633+ escadrille: JSONNull?? = nil,
3634+ estrous: JSONNull?? = nil,
3635+ interestedly: JSONNull?? = nil,
3636+ katakinetomer: JSONNull?? = nil,
3637+ mortification: JSONNull?? = nil,
3638+ morula: JSONNull?? = nil,
3639+ orthosymmetrical: JSONNull?? = nil,
3640+ overbark: JSONNull?? = nil,
3641+ politist: JSONNull?? = nil,
3642+ qualified: JSONNull?? = nil,
3643+ sphenomalar: JSONNull?? = nil,
3644+ throatful: JSONNull?? = nil,
3645+ transhumance: JSONNull?? = nil,
3646+ triandrian: JSONNull?? = nil,
3647+ unbooked: JSONNull?? = nil
3648+ ) -> WrothyClass {
3649+ return WrothyClass(
3650+ aeschynanthus: aeschynanthus ?? self.aeschynanthus,
3651+ aquiferous: aquiferous ?? self.aquiferous,
3652+ cheapener: cheapener ?? self.cheapener,
3653+ enumeration: enumeration ?? self.enumeration,
3654+ ephesine: ephesine ?? self.ephesine,
3655+ escadrille: escadrille ?? self.escadrille,
3656+ estrous: estrous ?? self.estrous,
3657+ interestedly: interestedly ?? self.interestedly,
3658+ katakinetomer: katakinetomer ?? self.katakinetomer,
3659+ mortification: mortification ?? self.mortification,
3660+ morula: morula ?? self.morula,
3661+ orthosymmetrical: orthosymmetrical ?? self.orthosymmetrical,
3662+ overbark: overbark ?? self.overbark,
3663+ politist: politist ?? self.politist,
3664+ qualified: qualified ?? self.qualified,
3665+ sphenomalar: sphenomalar ?? self.sphenomalar,
3666+ throatful: throatful ?? self.throatful,
3667+ transhumance: transhumance ?? self.transhumance,
3668+ triandrian: triandrian ?? self.triandrian,
3669+ unbooked: unbooked ?? self.unbooked
3670+ )
3671+ }
3672+
3673+ func jsonData() throws -> Data {
3674+ return try newJSONEncoder().encode(self)
3675+ }
3676+
3677+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
3678+ return String(data: try self.jsonData(), encoding: encoding)
3679+ }
3680+}
3681+
3682+// MARK: - Helper functions for creating encoders and decoders
3683+
3684+func newJSONDecoder() -> JSONDecoder {
3685+ let decoder = JSONDecoder()
3686+ decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in
3687+ let container = try decoder.singleValueContainer()
3688+ let dateStr = try container.decode(String.self)
3689+
3690+ let formatter = DateFormatter()
3691+ formatter.calendar = Calendar(identifier: .iso8601)
3692+ formatter.locale = Locale(identifier: "en_US_POSIX")
3693+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
3694+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX"
3695+ if let date = formatter.date(from: dateStr) {
3696+ return date
3697+ }
3698+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX"
3699+ if let date = formatter.date(from: dateStr) {
3700+ return date
3701+ }
3702+ throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date"))
3703+ })
3704+ return decoder
3705+}
3706+
3707+func newJSONEncoder() -> JSONEncoder {
3708+ let encoder = JSONEncoder()
3709+ let formatter = DateFormatter()
3710+ formatter.calendar = Calendar(identifier: .iso8601)
3711+ formatter.locale = Locale(identifier: "en_US_POSIX")
3712+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
3713+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSXXXXX"
3714+ encoder.dateEncodingStrategy = .formatted(formatter)
3715+ return encoder
3716+}
3717+
3718+// MARK: - Encode/decode helpers
3719+
3720+class JSONNull: Codable, Hashable {
3721+
3722+ public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool {
3723+ return true
3724+ }
3725+
3726+ public func hash(into hasher: inout Hasher) {
3727+ hasher.combine(0)
3728+ }
3729+
3730+ public init() {}
3731+
3732+ public required init(from decoder: Decoder) throws {
3733+ let container = try decoder.singleValueContainer()
3734+ if !container.decodeNil() {
3735+ throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull"))
3736+ }
3737+ }
3738+
3739+ public func encode(to encoder: Encoder) throws {
3740+ var container = encoder.singleValueContainer()
3741+ try container.encodeNil()
3742+ }
3743+}
Atypescriptprefer-const-values-true--6b26e4d1265c / TopLevel.ts+1,140 −0
@@ -0,0 +1,1140 @@
1+// To parse this data:
2+//
3+// import { Convert, TopLevel } from "./TopLevel";
4+//
5+// const topLevel = Convert.toTopLevel(json);
6+//
7+// These functions will throw an error if the JSON doesn't
8+// match the expected interface, even if the JSON is valid.
9+
10+export interface TopLevel {
11+ protrusive: Protrusive[];
12+ pulpitism: PulpitismElement[];
13+ pyodermia: PyodermiaElement[];
14+ quebrachine: QuebrachineElement[];
15+ querier: Querier[];
16+ rebarbative: Rebarbative[];
17+ reimagine: Reimagine[];
18+ ressaut: Ressaut;
19+ retrocervical: Retrocervical[];
20+ revert: Revert[];
21+ rewrite: RewriteElement[];
22+ saccoderm: Saccoderm[];
23+ santir: SantirElement[];
24+ saprophilous: Saprophilous[];
25+ saxten: SaxtenElement[];
26+ scatty: (Scatty | null)[];
27+ scoffer: Scoffer[];
28+ scrampum: Scrampum[];
29+ semantic: number;
30+ serpentinic: Serpentinic[];
31+ shadowable: Shadowable[];
32+ sistering: SisteringElement[];
33+ staghunting: Staghunting[];
34+ stagmometer: Stagmometer[];
35+ stimulability: Stimulability[];
36+ strangleable: Strangleable[];
37+ strenuosity: StrenuosityElement[];
38+ tabaxir: Tabaxir[];
39+ talpiform: Talpiform[];
40+ thwack: Thwack[];
41+ to: (number | null)[];
42+ tortricine: Tortricine[];
43+ truantcy: TruantcyElement[];
44+ turgesce: string[];
45+ unbeginning: Unbeginning[];
46+ underdunged: number[];
47+ undesirability: Undesirability[];
48+ unerasing: Unerasing[];
49+ unguentarium: Unguentarium[];
50+ unimpeachably: UnimpeachablyElement[];
51+ unmortgaged: Unmortgaged[];
52+ unobstructed: Unobstructed[];
53+ unreceptivity: Unreceptivity[];
54+ unsatisfactoriness: Unsatisfactoriness[];
55+ unsecurity: number[];
56+ unstressed: UnstressedElement[];
57+ untasked: Untasked[];
58+ unvarying: Unvarying[];
59+ vehemently: Vehemently[];
60+ warriorship: { [key: string]: boolean };
61+ whitepot: Whitepot[];
62+ wrothy: WrothyElement[];
63+}
64+
65+export type Protrusive = (number | null)[] | number;
66+
67+export type PulpitismElement = number[] | PulpitismClass | number;
68+
69+export interface PulpitismClass {
70+ abnet: null;
71+ buckhorn: null;
72+ calciform: null;
73+ chelophore: null;
74+ cogitation: null;
75+ decreeable: null;
76+ despicable: null;
77+ isodiazo: null;
78+ jadedly: null;
79+ leptochlorite: null;
80+ nursling: null;
81+ palamedean: null;
82+ photoheliograph: null;
83+ pipewood: null;
84+ roberd: null;
85+ statable: null;
86+ superassume: null;
87+ syllabe: null;
88+ toughhead: null;
89+ underburn: null;
90+}
91+
92+export type PyodermiaElement = PyodermiaClass | number;
93+
94+export interface PyodermiaClass {
95+ Gyppo: null;
96+ aphoristically: null;
97+ apophyllous: null;
98+ cognize: null;
99+ dermonosology: null;
100+ ither: null;
101+ juglandaceous: null;
102+ litho: null;
103+ macropterous: null;
104+ photographer: null;
105+ romancing: null;
106+ rumness: null;
107+ somniloquist: null;
108+ stressfully: null;
109+ tactically: null;
110+ tracheophony: null;
111+ unappositely: null;
112+ unclothedly: null;
113+ unimplied: null;
114+ unsyncopated: null;
115+}
116+
117+export type QuebrachineElement = boolean | QuebrachineClass | null;
118+
119+export interface QuebrachineClass {
120+ Chirotherium: number;
121+ catharticalness: number;
122+ disdiapason: string;
123+ homocerc: boolean;
124+ nonbookish: null;
125+}
126+
127+export type Querier = boolean | { [key: string]: number };
128+
129+export type Rebarbative = number[] | boolean | number;
130+
131+export interface Reimagine {
132+ Chirotherium?: number;
133+ Hermo?: null;
134+ adducible?: null;
135+ anabolin?: null;
136+ brainy?: null;
137+ catharticalness?: number;
138+ chrysamine?: null;
139+ disdiapason?: string;
140+ fluxweed?: null;
141+ glaucine?: null;
142+ grobianism?: null;
143+ hieroglyphist?: null;
144+ homocerc?: boolean;
145+ icteroid?: null;
146+ immortal?: null;
147+ impetulant?: null;
148+ irrigate?: null;
149+ myxedema?: null;
150+ nonbookish?: null;
151+ onyx?: null;
152+ repasser?: null;
153+ septomarginal?: null;
154+ subdie?: null;
155+ tibiometatarsal?: null;
156+ waltzlike?: null;
157+}
158+
159+export interface Ressaut {
160+ Freesia: string;
161+ Genevieve: string;
162+ Mimosaceae: string;
163+ Theopaschitism: string;
164+ apperceptive: string;
165+ cuttoo: string;
166+ douser: string;
167+ drinkproof: string;
168+ forementioned: string;
169+ hyperdiabolical: string;
170+ hypocone: string;
171+ irreverentially: string;
172+ jumart: string;
173+ mollicrush: string;
174+ nedder: string;
175+ retinasphalt: string;
176+ sough: string;
177+ steading: string;
178+ undurableness: string;
179+ unmingleable: string;
180+}
181+
182+export type Retrocervical = (number | null)[] | number;
183+
184+export type Revert = boolean | string;
185+
186+export type RewriteElement = null[] | RewriteClass | number;
187+
188+export interface RewriteClass {
189+ Hyades: null;
190+ Ptenoglossa: null;
191+ Whiggification: null;
192+ accountancy: null;
193+ cacotrophic: null;
194+ contest: null;
195+ couthily: null;
196+ falculate: null;
197+ foreseize: null;
198+ lemnad: null;
199+ monotheistically: null;
200+ nonflying: null;
201+ repatch: null;
202+ rodman: null;
203+ strung: null;
204+ titmal: null;
205+ twalpennyworth: null;
206+ unblamable: null;
207+ vertical: null;
208+ yardman: null;
209+}
210+
211+export type Saccoderm = number[] | null | string;
212+
213+export type SantirElement = SantirClass | number;
214+
215+export interface SantirClass {
216+ Suessiones: null;
217+ admiredly: null;
218+ demicaponier: null;
219+ epitympanic: null;
220+ investitor: null;
221+ lupiform: null;
222+ monoflagellate: null;
223+ paleoethnic: null;
224+ prediscountable: null;
225+ rhetoricals: null;
226+ roomth: null;
227+ saccharose: null;
228+ septonasal: null;
229+ serpenticide: null;
230+ setarious: null;
231+ spaework: null;
232+ stylite: null;
233+ timelily: null;
234+ unprofaned: null;
235+ vorticular: null;
236+}
237+
238+export type Saprophilous = { [key: string]: number } | null | string;
239+
240+export type SaxtenElement = SaxtenClass | string;
241+
242+export interface SaxtenClass {
243+ Centaurid?: null;
244+ Chirotherium?: number;
245+ algarrobilla?: null;
246+ bowgrace?: null;
247+ catharticalness?: number;
248+ disdiapason?: string;
249+ flix?: null;
250+ germanely?: null;
251+ homocerc?: boolean;
252+ inhume?: null;
253+ lepidote?: null;
254+ megalochirous?: null;
255+ ninepenny?: null;
256+ nonbookish?: null;
257+ nondeist?: null;
258+ nymphaeaceous?: null;
259+ parietofrontal?: null;
260+ sancyite?: null;
261+ subjectivist?: null;
262+ tibiad?: null;
263+ transonic?: null;
264+ tripetalous?: null;
265+ trunchman?: null;
266+ urger?: null;
267+ withdrawnness?: null;
268+}
269+
270+export interface Scatty {
271+ Tabasco: null;
272+ aeriferous: null;
273+ antical: null;
274+ antighostism: null;
275+ arcanum: null;
276+ autotrophy: null;
277+ baronial: null;
278+ caffeine: null;
279+ gorgoniacean: null;
280+ heroical: null;
281+ hydropical: null;
282+ mechanology: null;
283+ musicopoetic: null;
284+ officiality: null;
285+ oftentimes: null;
286+ ophthalmotonometer: null;
287+ reflectively: null;
288+ springer: null;
289+ teleianthous: null;
290+ uncombated: null;
291+}
292+
293+export type Scoffer = null[] | { [key: string]: number } | null;
294+
295+export type Scrampum = number[] | boolean | null;
296+
297+export type Serpentinic = number[] | number;
298+
299+export type Shadowable = (number | null)[] | boolean;
300+
301+export type SisteringElement = null[] | SisteringClass | number;
302+
303+export interface SisteringClass {
304+ Chianti: null;
305+ Haplomi: null;
306+ Micropterygidae: null;
307+ amphicarpic: null;
308+ frigorific: null;
309+ hyperkinesis: null;
310+ laudable: null;
311+ madwoman: null;
312+ maimedly: null;
313+ microrhabdus: null;
314+ nondense: null;
315+ phlebemphraxis: null;
316+ redsear: null;
317+ schismatical: null;
318+ tartryl: null;
319+ unabhorred: null;
320+ undeliberateness: null;
321+ unmixable: null;
322+ untruckling: null;
323+ vineal: null;
324+}
325+
326+export interface Staghunting {
327+ Chirotherium?: number;
328+ calorimetric?: number;
329+ canid?: number;
330+ catharticalness?: number;
331+ disdiapason?: string;
332+ ditriglyphic?: number;
333+ floriferousness?: number;
334+ gamelike?: number;
335+ grig?: number;
336+ homocerc?: boolean;
337+ interloan?: number;
338+ lithotomy?: number;
339+ loric?: number;
340+ membranocoriaceous?: number;
341+ membranogenic?: number;
342+ nonbookish?: null;
343+ overtrump?: number;
344+ scotino?: number;
345+ seasonable?: number;
346+ sephen?: number;
347+ stigmarioid?: number;
348+ tired?: number;
349+ trifid?: number;
350+ undefeatedly?: number;
351+ ungirlish?: number;
352+}
353+
354+export type Stagmometer = (number | null)[] | string;
355+
356+export type Stimulability = boolean | number | { [key: string]: number };
357+
358+export type Strangleable = null[] | number;
359+
360+export type StrenuosityElement = null[] | StrenuosityClass;
361+
362+export interface StrenuosityClass {
363+ Chirotherium?: number;
364+ Onopordon?: number;
365+ Sodomite?: number;
366+ Yankeeist?: number;
367+ bliss?: number;
368+ buccate?: number;
369+ bulletproof?: number;
370+ catharticalness?: number;
371+ crumblingness?: number;
372+ disdiapason?: string;
373+ engagedly?: number;
374+ fightable?: number;
375+ hoariness?: number;
376+ homocerc?: boolean;
377+ hypopodium?: number;
378+ luxurist?: number;
379+ mechanician?: number;
380+ nonbookish?: null;
381+ podgily?: number;
382+ reformableness?: number;
383+ scatterbrains?: number;
384+ seminuria?: number;
385+ tramp?: number;
386+ undueness?: number;
387+ worthily?: number;
388+}
389+
390+export type Tabaxir = boolean | number;
391+
392+export type Talpiform = QuebrachineClass | number | null;
393+
394+export type Thwack = boolean | QuebrachineClass | number;
395+
396+export type Tortricine = (number | null)[] | QuebrachineClass;
397+
398+export type TruantcyElement = boolean | TruantcyClass;
399+
400+export interface TruantcyClass {
401+ Chirotherium?: number;
402+ Epeira?: null;
403+ Eurylaimi?: null;
404+ Yuman?: null;
405+ alfiona?: null;
406+ ascaridiasis?: null;
407+ bungey?: null;
408+ catharticalness?: number;
409+ ceroxyle?: null;
410+ chorology?: null;
411+ disdiapason?: string;
412+ enmarble?: null;
413+ germination?: null;
414+ hallelujah?: null;
415+ homocerc?: boolean;
416+ lev?: null;
417+ mouthing?: null;
418+ nonbookish?: null;
419+ philliloo?: null;
420+ planetal?: null;
421+ poney?: null;
422+ punctualist?: null;
423+ returnlessly?: null;
424+ skelder?: null;
425+ windwaywardly?: null;
426+}
427+
428+export type Unbeginning = null[] | { [key: string]: number } | string;
429+
430+export type Undesirability = number[] | { [key: string]: number } | string;
431+
432+export type Unerasing = null[] | number | { [key: string]: number };
433+
434+export type Unguentarium = null[] | number | null;
435+
436+export type UnimpeachablyElement = boolean | UnimpeachablyClass;
437+
438+export interface UnimpeachablyClass {
439+ Bobadil?: number;
440+ Chirotherium?: number;
441+ Quiina?: number;
442+ Robert?: number;
443+ acerin?: number;
444+ catharticalness?: number;
445+ chlorophylligenous?: number;
446+ conversational?: number;
447+ demiowl?: number;
448+ disdiapason?: string;
449+ ectorhinal?: number;
450+ gamblesomeness?: number;
451+ homocerc?: boolean;
452+ irrorate?: number;
453+ kindergartening?: number;
454+ lateritic?: number;
455+ mespil?: number;
456+ misconfiguration?: number;
457+ nonbookish?: null;
458+ planometry?: number;
459+ rot?: number;
460+ subcinctorium?: number;
461+ tussocker?: number;
462+ ultraproud?: number;
463+ unsuggestedness?: number;
464+}
465+
466+export type Unmortgaged = number | { [key: string]: number } | null;
467+
468+export type Unobstructed = QuebrachineClass | number | null;
469+
470+export type Unreceptivity = null[] | number | string;
471+
472+export type Unsatisfactoriness = number[] | boolean | number;
473+
474+export type UnstressedElement = boolean | UnstressedClass | string;
475+
476+export interface UnstressedClass {
477+ Alain: null;
478+ Amphirhina: null;
479+ Lincolnian: null;
480+ Sarcophilus: null;
481+ antimachinery: null;
482+ coldish: null;
483+ crantara: null;
484+ distinguishing: null;
485+ elytroposis: null;
486+ gentianwort: null;
487+ heliosis: null;
488+ instrumental: null;
489+ introinflection: null;
490+ kala: null;
491+ metad: null;
492+ swingingly: null;
493+ unconformity: null;
494+ undecreed: null;
495+ venerable: null;
496+ vowellessness: null;
497+}
498+
499+export type Untasked = null[] | number | { [key: string]: number };
500+
501+export type Unvarying = boolean | number | { [key: string]: number };
502+
503+export type Vehemently = null[] | boolean | null;
504+
505+export type Whitepot = QuebrachineClass | number;
506+
507+export type WrothyElement = null[] | WrothyClass;
508+
509+export interface WrothyClass {
510+ Aeschynanthus: null;
511+ Ephesine: null;
512+ aquiferous: null;
513+ cheapener: null;
514+ enumeration: null;
515+ escadrille: null;
516+ estrous: null;
517+ interestedly: null;
518+ katakinetomer: null;
519+ mortification: null;
520+ morula: null;
521+ orthosymmetrical: null;
522+ overbark: null;
523+ politist: null;
524+ qualified: null;
525+ sphenomalar: null;
526+ throatful: null;
527+ transhumance: null;
528+ triandrian: null;
529+ unbooked: null;
530+}
531+
532+// Converts JSON strings to/from your types
533+// and asserts the results of JSON.parse at runtime
534+export class Convert {
535+ public static toTopLevel(json: string): TopLevel {
536+ return cast(JSON.parse(json), r("TopLevel"));
537+ }
538+
539+ public static topLevelToJson(value: TopLevel): string {
540+ return JSON.stringify(uncast(value, r("TopLevel")), null, 2);
541+ }
542+}
543+
544+function invalidValue(typ: any, val: any, key: any, parent: any = ''): never {
545+ const prettyTyp = prettyTypeName(typ);
546+ const parentText = parent ? ` on ${parent}` : '';
547+ const keyText = key ? ` for key "${key}"` : '';
548+ throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`);
549+}
550+
551+function prettyTypeName(typ: any): string {
552+ if (Array.isArray(typ)) {
553+ if (typ.length === 2 && typ[0] === undefined) {
554+ return `an optional ${prettyTypeName(typ[1])}`;
555+ } else {
556+ return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`;
557+ }
558+ } else if (typeof typ === "object" && typ.literal !== undefined) {
559+ return typ.literal;
560+ } else {
561+ return typeof typ;
562+ }
563+}
564+
565+function jsonToJSProps(typ: any): any {
566+ if (typ.jsonToJS === undefined) {
567+ const map: any = {};
568+ typ.props.forEach((p: any) => map[p.json] = { key: p.js, typ: p.typ });
569+ typ.jsonToJS = map;
570+ }
571+ return typ.jsonToJS;
572+}
573+
574+function jsToJSONProps(typ: any): any {
575+ if (typ.jsToJSON === undefined) {
576+ const map: any = {};
577+ typ.props.forEach((p: any) => map[p.js] = { key: p.json, typ: p.typ });
578+ typ.jsToJSON = map;
579+ }
580+ return typ.jsToJSON;
581+}
582+
583+function transform(val: any, typ: any, getProps: any, key: any = '', parent: any = ''): any {
584+ function transformPrimitive(typ: string, val: any): any {
585+ if (typeof typ === typeof val) return val;
586+ return invalidValue(typ, val, key, parent);
587+ }
588+
589+ function transformUnion(typs: any[], val: any): any {
590+ // val must validate against one typ in typs
591+ const l = typs.length;
592+ for (let i = 0; i < l; i++) {
593+ const typ = typs[i];
594+ try {
595+ return transform(val, typ, getProps);
596+ } catch (_) {}
597+ }
598+ return invalidValue(typs, val, key, parent);
599+ }
600+
601+ function transformEnum(cases: string[], val: any): any {
602+ if (cases.indexOf(val) !== -1) return val;
603+ return invalidValue(cases.map(a => { return l(a); }), val, key, parent);
604+ }
605+
606+ function transformArray(typ: any, val: any): any {
607+ // val must be an array with no invalid elements
608+ if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent);
609+
610+ return val.map(el => transform(el, typ, getProps));
611+ }
612+
613+ function transformDate(val: any): any {
614+ if (val === null) {
615+ return null;
616+ }
617+ const d = new Date(val);
618+ if (isNaN(d.valueOf())) {
619+ return invalidValue(l("Date"), val, key, parent);
620+ }
621+ return d;
622+ }
623+
624+ function transformObject(props: { [k: string]: any }, additional: any, val: any): any {
625+ if (val === null || typeof val !== "object" || Array.isArray(val)) {
626+ return invalidValue(l(ref || "object"), val, key, parent);
627+ }
628+ const result: any = {};
629+ Object.getOwnPropertyNames(props).forEach(key => {
630+ const prop = props[key];
631+ const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined;
632+ result[prop.key] = transform(v, prop.typ, getProps, key, ref);
633+ });
634+ Object.getOwnPropertyNames(val).forEach(key => {
635+ if (!Object.prototype.hasOwnProperty.call(props, key)) {
636+ result[key] = transform(val[key], additional, getProps, key, ref);
637+ }
638+ });
639+ return result;
640+ }
641+
642+ if (typ === "any") return val;
643+ if (typ === null) {
644+ if (val === null) return val;
645+ return invalidValue(typ, val, key, parent);
646+ }
647+ if (typ === false) return invalidValue(typ, val, key, parent);
648+ let ref: any = undefined;
649+ while (typeof typ === "object" && typ.ref !== undefined) {
650+ ref = typ.ref;
651+ typ = typeMap[typ.ref];
652+ }
653+ if (Array.isArray(typ)) return transformEnum(typ, val);
654+ if (typeof typ === "object") {
655+ return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent)
656+ : 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)
657+ : 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)
658+ : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent)
659+ : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val)
660+ : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val)
661+ : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val)
662+ : invalidValue(typ, val, key, parent);
663+ }
664+ // Numbers can be parsed by Date but shouldn't be.
665+ if (typ === Date && typeof val !== "number") return transformDate(val);
666+ return transformPrimitive(typ, val);
667+}
668+
669+function cast<T>(val: any, typ: any): T {
670+ return transform(val, typ, jsonToJSProps);
671+}
672+
673+function uncast<T>(val: T, typ: any): any {
674+ return transform(val, typ, jsToJSONProps);
675+}
676+
677+function l(typ: any) {
678+ return { literal: typ };
679+}
680+
681+function a(typ: any) {
682+ return { arrayItems: typ };
683+}
684+
685+function i(typ: any) {
686+ return { integer: typ };
687+}
688+
689+function p(pattern: any) {
690+ return { pattern };
691+}
692+
693+function s(typ: any, min: any, max: any) {
694+ return { string: typ, min, max };
695+}
696+
697+function n(typ: any, min: any, max: any) {
698+ return { number: typ, min, max };
699+}
700+
701+function u(...typs: any[]) {
702+ return { unionMembers: typs };
703+}
704+
705+function o(props: any[], additional: any) {
706+ return { props, additional };
707+}
708+
709+function m(additional: any) {
710+ const props: any[] = [];
711+ return { props, additional };
712+}
713+
714+function r(name: string) {
715+ return { ref: name };
716+}
717+
718+const typeMap: any = {
719+ "TopLevel": o([
720+ { json: "protrusive", js: "protrusive", typ: a(u(a(u(i(0), null)), 3.14)) },
721+ { json: "pulpitism", js: "pulpitism", typ: a(u(a(i(0)), r("PulpitismClass"), 3.14)) },
722+ { json: "pyodermia", js: "pyodermia", typ: a(u(r("PyodermiaClass"), i(0))) },
723+ { json: "quebrachine", js: "quebrachine", typ: a(u(true, r("QuebrachineClass"), null)) },
724+ { json: "querier", js: "querier", typ: a(u(true, m(i(0)))) },
725+ { json: "rebarbative", js: "rebarbative", typ: a(u(a(i(0)), true, 3.14)) },
726+ { json: "reimagine", js: "reimagine", typ: a(r("Reimagine")) },
727+ { json: "ressaut", js: "ressaut", typ: r("Ressaut") },
728+ { json: "retrocervical", js: "retrocervical", typ: a(u(a(u(i(0), null)), i(0))) },
729+ { json: "revert", js: "revert", typ: a(u(true, "")) },
730+ { json: "rewrite", js: "rewrite", typ: a(u(a(null), r("RewriteClass"), 3.14)) },
731+ { json: "saccoderm", js: "saccoderm", typ: a(u(a(i(0)), null, "")) },
732+ { json: "santir", js: "santir", typ: a(u(r("SantirClass"), 3.14)) },
733+ { json: "saprophilous", js: "saprophilous", typ: a(u(m(i(0)), null, "")) },
734+ { json: "saxten", js: "saxten", typ: a(u(r("SaxtenClass"), "")) },
735+ { json: "scatty", js: "scatty", typ: a(u(r("Scatty"), null)) },
736+ { json: "scoffer", js: "scoffer", typ: a(u(a(null), m(i(0)), null)) },
737+ { json: "scrampum", js: "scrampum", typ: a(u(a(i(0)), true, null)) },
738+ { json: "semantic", js: "semantic", typ: 3.14 },
739+ { json: "serpentinic", js: "serpentinic", typ: a(u(a(i(0)), 3.14)) },
740+ { json: "shadowable", js: "shadowable", typ: a(u(a(u(i(0), null)), true)) },
741+ { json: "sistering", js: "sistering", typ: a(u(a(null), r("SisteringClass"), i(0))) },
742+ { json: "staghunting", js: "staghunting", typ: a(r("Staghunting")) },
743+ { json: "stagmometer", js: "stagmometer", typ: a(u(a(u(i(0), null)), "")) },
744+ { json: "stimulability", js: "stimulability", typ: a(u(true, i(0), m(i(0)))) },
745+ { json: "strangleable", js: "strangleable", typ: a(u(a(null), 3.14)) },
746+ { json: "strenuosity", js: "strenuosity", typ: a(u(a(null), r("StrenuosityClass"))) },
747+ { json: "tabaxir", js: "tabaxir", typ: a(u(true, 3.14)) },
748+ { json: "talpiform", js: "talpiform", typ: a(u(r("QuebrachineClass"), 3.14, null)) },
749+ { json: "thwack", js: "thwack", typ: a(u(true, r("QuebrachineClass"), 3.14)) },
750+ { json: "to", js: "to", typ: a(u(3.14, null)) },
751+ { json: "tortricine", js: "tortricine", typ: a(u(a(u(i(0), null)), r("QuebrachineClass"))) },
752+ { json: "truantcy", js: "truantcy", typ: a(u(true, r("TruantcyClass"))) },
753+ { json: "turgesce", js: "turgesce", typ: a("") },
754+ { json: "unbeginning", js: "unbeginning", typ: a(u(a(null), m(i(0)), "")) },
755+ { json: "underdunged", js: "underdunged", typ: a(3.14) },
756+ { json: "undesirability", js: "undesirability", typ: a(u(a(i(0)), m(i(0)), "")) },
757+ { json: "unerasing", js: "unerasing", typ: a(u(a(null), i(0), m(i(0)))) },
758+ { json: "unguentarium", js: "unguentarium", typ: a(u(a(null), i(0), null)) },
759+ { json: "unimpeachably", js: "unimpeachably", typ: a(u(true, r("UnimpeachablyClass"))) },
760+ { json: "unmortgaged", js: "unmortgaged", typ: a(u(3.14, m(i(0)), null)) },
761+ { json: "unobstructed", js: "unobstructed", typ: a(u(r("QuebrachineClass"), i(0), null)) },
762+ { json: "unreceptivity", js: "unreceptivity", typ: a(u(a(null), i(0), "")) },
763+ { json: "unsatisfactoriness", js: "unsatisfactoriness", typ: a(u(a(i(0)), true, i(0))) },
764+ { json: "unsecurity", js: "unsecurity", typ: a(i(0)) },
765+ { json: "unstressed", js: "unstressed", typ: a(u(true, r("UnstressedClass"), "")) },
766+ { json: "untasked", js: "untasked", typ: a(u(a(null), 3.14, m(i(0)))) },
767+ { json: "unvarying", js: "unvarying", typ: a(u(true, 3.14, m(i(0)))) },
768+ { json: "vehemently", js: "vehemently", typ: a(u(a(null), true, null)) },
769+ { json: "warriorship", js: "warriorship", typ: m(true) },
770+ { json: "whitepot", js: "whitepot", typ: a(u(r("QuebrachineClass"), 3.14)) },
771+ { json: "wrothy", js: "wrothy", typ: a(u(a(null), r("WrothyClass"))) },
772+ ], false),
773+ "PulpitismClass": o([
774+ { json: "abnet", js: "abnet", typ: null },
775+ { json: "buckhorn", js: "buckhorn", typ: null },
776+ { json: "calciform", js: "calciform", typ: null },
777+ { json: "chelophore", js: "chelophore", typ: null },
778+ { json: "cogitation", js: "cogitation", typ: null },
779+ { json: "decreeable", js: "decreeable", typ: null },
780+ { json: "despicable", js: "despicable", typ: null },
781+ { json: "isodiazo", js: "isodiazo", typ: null },
782+ { json: "jadedly", js: "jadedly", typ: null },
783+ { json: "leptochlorite", js: "leptochlorite", typ: null },
784+ { json: "nursling", js: "nursling", typ: null },
785+ { json: "palamedean", js: "palamedean", typ: null },
786+ { json: "photoheliograph", js: "photoheliograph", typ: null },
787+ { json: "pipewood", js: "pipewood", typ: null },
788+ { json: "roberd", js: "roberd", typ: null },
789+ { json: "statable", js: "statable", typ: null },
790+ { json: "superassume", js: "superassume", typ: null },
791+ { json: "syllabe", js: "syllabe", typ: null },
792+ { json: "toughhead", js: "toughhead", typ: null },
793+ { json: "underburn", js: "underburn", typ: null },
794+ ], false),
795+ "PyodermiaClass": o([
796+ { json: "Gyppo", js: "Gyppo", typ: null },
797+ { json: "aphoristically", js: "aphoristically", typ: null },
798+ { json: "apophyllous", js: "apophyllous", typ: null },
799+ { json: "cognize", js: "cognize", typ: null },
800+ { json: "dermonosology", js: "dermonosology", typ: null },
801+ { json: "ither", js: "ither", typ: null },
802+ { json: "juglandaceous", js: "juglandaceous", typ: null },
803+ { json: "litho", js: "litho", typ: null },
804+ { json: "macropterous", js: "macropterous", typ: null },
805+ { json: "photographer", js: "photographer", typ: null },
806+ { json: "romancing", js: "romancing", typ: null },
807+ { json: "rumness", js: "rumness", typ: null },
808+ { json: "somniloquist", js: "somniloquist", typ: null },
809+ { json: "stressfully", js: "stressfully", typ: null },
810+ { json: "tactically", js: "tactically", typ: null },
811+ { json: "tracheophony", js: "tracheophony", typ: null },
812+ { json: "unappositely", js: "unappositely", typ: null },
813+ { json: "unclothedly", js: "unclothedly", typ: null },
814+ { json: "unimplied", js: "unimplied", typ: null },
815+ { json: "unsyncopated", js: "unsyncopated", typ: null },
816+ ], false),
817+ "QuebrachineClass": o([
818+ { json: "Chirotherium", js: "Chirotherium", typ: i(0) },
819+ { json: "catharticalness", js: "catharticalness", typ: 3.14 },
820+ { json: "disdiapason", js: "disdiapason", typ: "" },
821+ { json: "homocerc", js: "homocerc", typ: true },
822+ { json: "nonbookish", js: "nonbookish", typ: null },
823+ ], false),
824+ "Reimagine": o([
825+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
826+ { json: "Hermo", js: "Hermo", typ: u(undefined, null) },
827+ { json: "adducible", js: "adducible", typ: u(undefined, null) },
828+ { json: "anabolin", js: "anabolin", typ: u(undefined, null) },
829+ { json: "brainy", js: "brainy", typ: u(undefined, null) },
830+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
831+ { json: "chrysamine", js: "chrysamine", typ: u(undefined, null) },
832+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
833+ { json: "fluxweed", js: "fluxweed", typ: u(undefined, null) },
834+ { json: "glaucine", js: "glaucine", typ: u(undefined, null) },
835+ { json: "grobianism", js: "grobianism", typ: u(undefined, null) },
836+ { json: "hieroglyphist", js: "hieroglyphist", typ: u(undefined, null) },
837+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
838+ { json: "icteroid", js: "icteroid", typ: u(undefined, null) },
839+ { json: "immortal", js: "immortal", typ: u(undefined, null) },
840+ { json: "impetulant", js: "impetulant", typ: u(undefined, null) },
841+ { json: "irrigate", js: "irrigate", typ: u(undefined, null) },
842+ { json: "myxedema", js: "myxedema", typ: u(undefined, null) },
843+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
844+ { json: "onyx", js: "onyx", typ: u(undefined, null) },
845+ { json: "repasser", js: "repasser", typ: u(undefined, null) },
846+ { json: "septomarginal", js: "septomarginal", typ: u(undefined, null) },
847+ { json: "subdie", js: "subdie", typ: u(undefined, null) },
848+ { json: "tibiometatarsal", js: "tibiometatarsal", typ: u(undefined, null) },
849+ { json: "waltzlike", js: "waltzlike", typ: u(undefined, null) },
850+ ], false),
851+ "Ressaut": o([
852+ { json: "Freesia", js: "Freesia", typ: "" },
853+ { json: "Genevieve", js: "Genevieve", typ: "" },
854+ { json: "Mimosaceae", js: "Mimosaceae", typ: "" },
855+ { json: "Theopaschitism", js: "Theopaschitism", typ: "" },
856+ { json: "apperceptive", js: "apperceptive", typ: "" },
857+ { json: "cuttoo", js: "cuttoo", typ: "" },
858+ { json: "douser", js: "douser", typ: "" },
859+ { json: "drinkproof", js: "drinkproof", typ: "" },
860+ { json: "forementioned", js: "forementioned", typ: "" },
861+ { json: "hyperdiabolical", js: "hyperdiabolical", typ: "" },
862+ { json: "hypocone", js: "hypocone", typ: "" },
863+ { json: "irreverentially", js: "irreverentially", typ: "" },
864+ { json: "jumart", js: "jumart", typ: "" },
865+ { json: "mollicrush", js: "mollicrush", typ: "" },
866+ { json: "nedder", js: "nedder", typ: "" },
867+ { json: "retinasphalt", js: "retinasphalt", typ: "" },
868+ { json: "sough", js: "sough", typ: "" },
869+ { json: "steading", js: "steading", typ: "" },
870+ { json: "undurableness", js: "undurableness", typ: "" },
871+ { json: "unmingleable", js: "unmingleable", typ: "" },
872+ ], false),
873+ "RewriteClass": o([
874+ { json: "Hyades", js: "Hyades", typ: null },
875+ { json: "Ptenoglossa", js: "Ptenoglossa", typ: null },
876+ { json: "Whiggification", js: "Whiggification", typ: null },
877+ { json: "accountancy", js: "accountancy", typ: null },
878+ { json: "cacotrophic", js: "cacotrophic", typ: null },
879+ { json: "contest", js: "contest", typ: null },
880+ { json: "couthily", js: "couthily", typ: null },
881+ { json: "falculate", js: "falculate", typ: null },
882+ { json: "foreseize", js: "foreseize", typ: null },
883+ { json: "lemnad", js: "lemnad", typ: null },
884+ { json: "monotheistically", js: "monotheistically", typ: null },
885+ { json: "nonflying", js: "nonflying", typ: null },
886+ { json: "repatch", js: "repatch", typ: null },
887+ { json: "rodman", js: "rodman", typ: null },
888+ { json: "strung", js: "strung", typ: null },
889+ { json: "titmal", js: "titmal", typ: null },
890+ { json: "twalpennyworth", js: "twalpennyworth", typ: null },
891+ { json: "unblamable", js: "unblamable", typ: null },
892+ { json: "vertical", js: "vertical", typ: null },
893+ { json: "yardman", js: "yardman", typ: null },
894+ ], false),
895+ "SantirClass": o([
896+ { json: "Suessiones", js: "Suessiones", typ: null },
897+ { json: "admiredly", js: "admiredly", typ: null },
898+ { json: "demicaponier", js: "demicaponier", typ: null },
899+ { json: "epitympanic", js: "epitympanic", typ: null },
900+ { json: "investitor", js: "investitor", typ: null },
901+ { json: "lupiform", js: "lupiform", typ: null },
902+ { json: "monoflagellate", js: "monoflagellate", typ: null },
903+ { json: "paleoethnic", js: "paleoethnic", typ: null },
904+ { json: "prediscountable", js: "prediscountable", typ: null },
905+ { json: "rhetoricals", js: "rhetoricals", typ: null },
906+ { json: "roomth", js: "roomth", typ: null },
907+ { json: "saccharose", js: "saccharose", typ: null },
908+ { json: "septonasal", js: "septonasal", typ: null },
909+ { json: "serpenticide", js: "serpenticide", typ: null },
910+ { json: "setarious", js: "setarious", typ: null },
911+ { json: "spaework", js: "spaework", typ: null },
912+ { json: "stylite", js: "stylite", typ: null },
913+ { json: "timelily", js: "timelily", typ: null },
914+ { json: "unprofaned", js: "unprofaned", typ: null },
915+ { json: "vorticular", js: "vorticular", typ: null },
916+ ], false),
917+ "SaxtenClass": o([
918+ { json: "Centaurid", js: "Centaurid", typ: u(undefined, null) },
919+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
920+ { json: "algarrobilla", js: "algarrobilla", typ: u(undefined, null) },
921+ { json: "bowgrace", js: "bowgrace", typ: u(undefined, null) },
922+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
923+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
924+ { json: "flix", js: "flix", typ: u(undefined, null) },
925+ { json: "germanely", js: "germanely", typ: u(undefined, null) },
926+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
927+ { json: "inhume", js: "inhume", typ: u(undefined, null) },
928+ { json: "lepidote", js: "lepidote", typ: u(undefined, null) },
929+ { json: "megalochirous", js: "megalochirous", typ: u(undefined, null) },
930+ { json: "ninepenny", js: "ninepenny", typ: u(undefined, null) },
931+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
932+ { json: "nondeist", js: "nondeist", typ: u(undefined, null) },
933+ { json: "nymphaeaceous", js: "nymphaeaceous", typ: u(undefined, null) },
934+ { json: "parietofrontal", js: "parietofrontal", typ: u(undefined, null) },
935+ { json: "sancyite", js: "sancyite", typ: u(undefined, null) },
936+ { json: "subjectivist", js: "subjectivist", typ: u(undefined, null) },
937+ { json: "tibiad", js: "tibiad", typ: u(undefined, null) },
938+ { json: "transonic", js: "transonic", typ: u(undefined, null) },
939+ { json: "tripetalous", js: "tripetalous", typ: u(undefined, null) },
940+ { json: "trunchman", js: "trunchman", typ: u(undefined, null) },
941+ { json: "urger", js: "urger", typ: u(undefined, null) },
942+ { json: "withdrawnness", js: "withdrawnness", typ: u(undefined, null) },
943+ ], false),
944+ "Scatty": o([
945+ { json: "Tabasco", js: "Tabasco", typ: null },
946+ { json: "aeriferous", js: "aeriferous", typ: null },
947+ { json: "antical", js: "antical", typ: null },
948+ { json: "antighostism", js: "antighostism", typ: null },
949+ { json: "arcanum", js: "arcanum", typ: null },
950+ { json: "autotrophy", js: "autotrophy", typ: null },
951+ { json: "baronial", js: "baronial", typ: null },
952+ { json: "caffeine", js: "caffeine", typ: null },
953+ { json: "gorgoniacean", js: "gorgoniacean", typ: null },
954+ { json: "heroical", js: "heroical", typ: null },
955+ { json: "hydropical", js: "hydropical", typ: null },
956+ { json: "mechanology", js: "mechanology", typ: null },
957+ { json: "musicopoetic", js: "musicopoetic", typ: null },
958+ { json: "officiality", js: "officiality", typ: null },
959+ { json: "oftentimes", js: "oftentimes", typ: null },
960+ { json: "ophthalmotonometer", js: "ophthalmotonometer", typ: null },
961+ { json: "reflectively", js: "reflectively", typ: null },
962+ { json: "springer", js: "springer", typ: null },
963+ { json: "teleianthous", js: "teleianthous", typ: null },
964+ { json: "uncombated", js: "uncombated", typ: null },
965+ ], false),
966+ "SisteringClass": o([
967+ { json: "Chianti", js: "Chianti", typ: null },
968+ { json: "Haplomi", js: "Haplomi", typ: null },
969+ { json: "Micropterygidae", js: "Micropterygidae", typ: null },
970+ { json: "amphicarpic", js: "amphicarpic", typ: null },
971+ { json: "frigorific", js: "frigorific", typ: null },
972+ { json: "hyperkinesis", js: "hyperkinesis", typ: null },
973+ { json: "laudable", js: "laudable", typ: null },
974+ { json: "madwoman", js: "madwoman", typ: null },
975+ { json: "maimedly", js: "maimedly", typ: null },
976+ { json: "microrhabdus", js: "microrhabdus", typ: null },
977+ { json: "nondense", js: "nondense", typ: null },
978+ { json: "phlebemphraxis", js: "phlebemphraxis", typ: null },
979+ { json: "redsear", js: "redsear", typ: null },
980+ { json: "schismatical", js: "schismatical", typ: null },
981+ { json: "tartryl", js: "tartryl", typ: null },
982+ { json: "unabhorred", js: "unabhorred", typ: null },
983+ { json: "undeliberateness", js: "undeliberateness", typ: null },
984+ { json: "unmixable", js: "unmixable", typ: null },
985+ { json: "untruckling", js: "untruckling", typ: null },
986+ { json: "vineal", js: "vineal", typ: null },
987+ ], false),
988+ "Staghunting": o([
989+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
990+ { json: "calorimetric", js: "calorimetric", typ: u(undefined, i(0)) },
991+ { json: "canid", js: "canid", typ: u(undefined, i(0)) },
992+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
993+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
994+ { json: "ditriglyphic", js: "ditriglyphic", typ: u(undefined, i(0)) },
995+ { json: "floriferousness", js: "floriferousness", typ: u(undefined, i(0)) },
996+ { json: "gamelike", js: "gamelike", typ: u(undefined, i(0)) },
997+ { json: "grig", js: "grig", typ: u(undefined, i(0)) },
998+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
999+ { json: "interloan", js: "interloan", typ: u(undefined, i(0)) },
1000+ { json: "lithotomy", js: "lithotomy", typ: u(undefined, i(0)) },
1001+ { json: "loric", js: "loric", typ: u(undefined, i(0)) },
1002+ { json: "membranocoriaceous", js: "membranocoriaceous", typ: u(undefined, i(0)) },
1003+ { json: "membranogenic", js: "membranogenic", typ: u(undefined, i(0)) },
1004+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
1005+ { json: "overtrump", js: "overtrump", typ: u(undefined, i(0)) },
1006+ { json: "scotino", js: "scotino", typ: u(undefined, i(0)) },
1007+ { json: "seasonable", js: "seasonable", typ: u(undefined, i(0)) },
1008+ { json: "sephen", js: "sephen", typ: u(undefined, i(0)) },
1009+ { json: "stigmarioid", js: "stigmarioid", typ: u(undefined, i(0)) },
1010+ { json: "tired", js: "tired", typ: u(undefined, i(0)) },
1011+ { json: "trifid", js: "trifid", typ: u(undefined, i(0)) },
1012+ { json: "undefeatedly", js: "undefeatedly", typ: u(undefined, i(0)) },
1013+ { json: "ungirlish", js: "ungirlish", typ: u(undefined, i(0)) },
1014+ ], false),
1015+ "StrenuosityClass": o([
1016+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
1017+ { json: "Onopordon", js: "Onopordon", typ: u(undefined, i(0)) },
1018+ { json: "Sodomite", js: "Sodomite", typ: u(undefined, i(0)) },
1019+ { json: "Yankeeist", js: "Yankeeist", typ: u(undefined, i(0)) },
1020+ { json: "bliss", js: "bliss", typ: u(undefined, i(0)) },
1021+ { json: "buccate", js: "buccate", typ: u(undefined, i(0)) },
1022+ { json: "bulletproof", js: "bulletproof", typ: u(undefined, i(0)) },
1023+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
1024+ { json: "crumblingness", js: "crumblingness", typ: u(undefined, i(0)) },
1025+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
1026+ { json: "engagedly", js: "engagedly", typ: u(undefined, i(0)) },
1027+ { json: "fightable", js: "fightable", typ: u(undefined, i(0)) },
1028+ { json: "hoariness", js: "hoariness", typ: u(undefined, i(0)) },
1029+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
1030+ { json: "hypopodium", js: "hypopodium", typ: u(undefined, i(0)) },
1031+ { json: "luxurist", js: "luxurist", typ: u(undefined, i(0)) },
1032+ { json: "mechanician", js: "mechanician", typ: u(undefined, i(0)) },
1033+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
1034+ { json: "podgily", js: "podgily", typ: u(undefined, i(0)) },
1035+ { json: "reformableness", js: "reformableness", typ: u(undefined, i(0)) },
1036+ { json: "scatterbrains", js: "scatterbrains", typ: u(undefined, i(0)) },
1037+ { json: "seminuria", js: "seminuria", typ: u(undefined, i(0)) },
1038+ { json: "tramp", js: "tramp", typ: u(undefined, i(0)) },
1039+ { json: "undueness", js: "undueness", typ: u(undefined, i(0)) },
1040+ { json: "worthily", js: "worthily", typ: u(undefined, i(0)) },
1041+ ], false),
1042+ "TruantcyClass": o([
1043+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
1044+ { json: "Epeira", js: "Epeira", typ: u(undefined, null) },
1045+ { json: "Eurylaimi", js: "Eurylaimi", typ: u(undefined, null) },
1046+ { json: "Yuman", js: "Yuman", typ: u(undefined, null) },
1047+ { json: "alfiona", js: "alfiona", typ: u(undefined, null) },
1048+ { json: "ascaridiasis", js: "ascaridiasis", typ: u(undefined, null) },
1049+ { json: "bungey", js: "bungey", typ: u(undefined, null) },
1050+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
1051+ { json: "ceroxyle", js: "ceroxyle", typ: u(undefined, null) },
1052+ { json: "chorology", js: "chorology", typ: u(undefined, null) },
1053+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
1054+ { json: "enmarble", js: "enmarble", typ: u(undefined, null) },
1055+ { json: "germination", js: "germination", typ: u(undefined, null) },
1056+ { json: "hallelujah", js: "hallelujah", typ: u(undefined, null) },
1057+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
1058+ { json: "lev", js: "lev", typ: u(undefined, null) },
1059+ { json: "mouthing", js: "mouthing", typ: u(undefined, null) },
1060+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
1061+ { json: "philliloo", js: "philliloo", typ: u(undefined, null) },
1062+ { json: "planetal", js: "planetal", typ: u(undefined, null) },
1063+ { json: "poney", js: "poney", typ: u(undefined, null) },
1064+ { json: "punctualist", js: "punctualist", typ: u(undefined, null) },
1065+ { json: "returnlessly", js: "returnlessly", typ: u(undefined, null) },
1066+ { json: "skelder", js: "skelder", typ: u(undefined, null) },
1067+ { json: "windwaywardly", js: "windwaywardly", typ: u(undefined, null) },
1068+ ], false),
1069+ "UnimpeachablyClass": o([
1070+ { json: "Bobadil", js: "Bobadil", typ: u(undefined, i(0)) },
1071+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
1072+ { json: "Quiina", js: "Quiina", typ: u(undefined, i(0)) },
1073+ { json: "Robert", js: "Robert", typ: u(undefined, i(0)) },
1074+ { json: "acerin", js: "acerin", typ: u(undefined, i(0)) },
1075+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
1076+ { json: "chlorophylligenous", js: "chlorophylligenous", typ: u(undefined, i(0)) },
1077+ { json: "conversational", js: "conversational", typ: u(undefined, i(0)) },
1078+ { json: "demiowl", js: "demiowl", typ: u(undefined, i(0)) },
1079+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
1080+ { json: "ectorhinal", js: "ectorhinal", typ: u(undefined, i(0)) },
1081+ { json: "gamblesomeness", js: "gamblesomeness", typ: u(undefined, i(0)) },
1082+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
1083+ { json: "irrorate", js: "irrorate", typ: u(undefined, i(0)) },
1084+ { json: "kindergartening", js: "kindergartening", typ: u(undefined, i(0)) },
1085+ { json: "lateritic", js: "lateritic", typ: u(undefined, i(0)) },
1086+ { json: "mespil", js: "mespil", typ: u(undefined, i(0)) },
1087+ { json: "misconfiguration", js: "misconfiguration", typ: u(undefined, i(0)) },
1088+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
1089+ { json: "planometry", js: "planometry", typ: u(undefined, i(0)) },
1090+ { json: "rot", js: "rot", typ: u(undefined, i(0)) },
1091+ { json: "subcinctorium", js: "subcinctorium", typ: u(undefined, i(0)) },
1092+ { json: "tussocker", js: "tussocker", typ: u(undefined, i(0)) },
1093+ { json: "ultraproud", js: "ultraproud", typ: u(undefined, i(0)) },
1094+ { json: "unsuggestedness", js: "unsuggestedness", typ: u(undefined, i(0)) },
1095+ ], false),
1096+ "UnstressedClass": o([
1097+ { json: "Alain", js: "Alain", typ: null },
1098+ { json: "Amphirhina", js: "Amphirhina", typ: null },
1099+ { json: "Lincolnian", js: "Lincolnian", typ: null },
1100+ { json: "Sarcophilus", js: "Sarcophilus", typ: null },
1101+ { json: "antimachinery", js: "antimachinery", typ: null },
1102+ { json: "coldish", js: "coldish", typ: null },
1103+ { json: "crantara", js: "crantara", typ: null },
1104+ { json: "distinguishing", js: "distinguishing", typ: null },
1105+ { json: "elytroposis", js: "elytroposis", typ: null },
1106+ { json: "gentianwort", js: "gentianwort", typ: null },
1107+ { json: "heliosis", js: "heliosis", typ: null },
1108+ { json: "instrumental", js: "instrumental", typ: null },
1109+ { json: "introinflection", js: "introinflection", typ: null },
1110+ { json: "kala", js: "kala", typ: null },
1111+ { json: "metad", js: "metad", typ: null },
1112+ { json: "swingingly", js: "swingingly", typ: null },
1113+ { json: "unconformity", js: "unconformity", typ: null },
1114+ { json: "undecreed", js: "undecreed", typ: null },
1115+ { json: "venerable", js: "venerable", typ: null },
1116+ { json: "vowellessness", js: "vowellessness", typ: null },
1117+ ], false),
1118+ "WrothyClass": o([
1119+ { json: "Aeschynanthus", js: "Aeschynanthus", typ: null },
1120+ { json: "Ephesine", js: "Ephesine", typ: null },
1121+ { json: "aquiferous", js: "aquiferous", typ: null },
1122+ { json: "cheapener", js: "cheapener", typ: null },
1123+ { json: "enumeration", js: "enumeration", typ: null },
1124+ { json: "escadrille", js: "escadrille", typ: null },
1125+ { json: "estrous", js: "estrous", typ: null },
1126+ { json: "interestedly", js: "interestedly", typ: null },
1127+ { json: "katakinetomer", js: "katakinetomer", typ: null },
1128+ { json: "mortification", js: "mortification", typ: null },
1129+ { json: "morula", js: "morula", typ: null },
1130+ { json: "orthosymmetrical", js: "orthosymmetrical", typ: null },
1131+ { json: "overbark", js: "overbark", typ: null },
1132+ { json: "politist", js: "politist", typ: null },
1133+ { json: "qualified", js: "qualified", typ: null },
1134+ { json: "sphenomalar", js: "sphenomalar", typ: null },
1135+ { json: "throatful", js: "throatful", typ: null },
1136+ { json: "transhumance", js: "transhumance", typ: null },
1137+ { json: "triandrian", js: "triandrian", typ: null },
1138+ { json: "unbooked", js: "unbooked", typ: null },
1139+ ], false),
1140+};
Atypescriptprefer-types-true--df33e18681f9 / TopLevel.ts+1,140 −0
@@ -0,0 +1,1140 @@
1+// To parse this data:
2+//
3+// import { Convert, TopLevel } from "./TopLevel";
4+//
5+// const topLevel = Convert.toTopLevel(json);
6+//
7+// These functions will throw an error if the JSON doesn't
8+// match the expected interface, even if the JSON is valid.
9+
10+export type TopLevel = {
11+ protrusive: Protrusive[];
12+ pulpitism: PulpitismElement[];
13+ pyodermia: PyodermiaElement[];
14+ quebrachine: QuebrachineElement[];
15+ querier: Querier[];
16+ rebarbative: Rebarbative[];
17+ reimagine: Reimagine[];
18+ ressaut: Ressaut;
19+ retrocervical: Retrocervical[];
20+ revert: Revert[];
21+ rewrite: RewriteElement[];
22+ saccoderm: Saccoderm[];
23+ santir: SantirElement[];
24+ saprophilous: Saprophilous[];
25+ saxten: SaxtenElement[];
26+ scatty: (Scatty | null)[];
27+ scoffer: Scoffer[];
28+ scrampum: Scrampum[];
29+ semantic: number;
30+ serpentinic: Serpentinic[];
31+ shadowable: Shadowable[];
32+ sistering: SisteringElement[];
33+ staghunting: Staghunting[];
34+ stagmometer: Stagmometer[];
35+ stimulability: Stimulability[];
36+ strangleable: Strangleable[];
37+ strenuosity: StrenuosityElement[];
38+ tabaxir: Tabaxir[];
39+ talpiform: Talpiform[];
40+ thwack: Thwack[];
41+ to: (number | null)[];
42+ tortricine: Tortricine[];
43+ truantcy: TruantcyElement[];
44+ turgesce: string[];
45+ unbeginning: Unbeginning[];
46+ underdunged: number[];
47+ undesirability: Undesirability[];
48+ unerasing: Unerasing[];
49+ unguentarium: Unguentarium[];
50+ unimpeachably: UnimpeachablyElement[];
51+ unmortgaged: Unmortgaged[];
52+ unobstructed: Unobstructed[];
53+ unreceptivity: Unreceptivity[];
54+ unsatisfactoriness: Unsatisfactoriness[];
55+ unsecurity: number[];
56+ unstressed: UnstressedElement[];
57+ untasked: Untasked[];
58+ unvarying: Unvarying[];
59+ vehemently: Vehemently[];
60+ warriorship: { [key: string]: boolean };
61+ whitepot: Whitepot[];
62+ wrothy: WrothyElement[];
63+}
64+
65+export type Protrusive = (number | null)[] | number;
66+
67+export type PulpitismElement = number[] | PulpitismClass | number;
68+
69+export type PulpitismClass = {
70+ abnet: null;
71+ buckhorn: null;
72+ calciform: null;
73+ chelophore: null;
74+ cogitation: null;
75+ decreeable: null;
76+ despicable: null;
77+ isodiazo: null;
78+ jadedly: null;
79+ leptochlorite: null;
80+ nursling: null;
81+ palamedean: null;
82+ photoheliograph: null;
83+ pipewood: null;
84+ roberd: null;
85+ statable: null;
86+ superassume: null;
87+ syllabe: null;
88+ toughhead: null;
89+ underburn: null;
90+}
91+
92+export type PyodermiaElement = PyodermiaClass | number;
93+
94+export type PyodermiaClass = {
95+ Gyppo: null;
96+ aphoristically: null;
97+ apophyllous: null;
98+ cognize: null;
99+ dermonosology: null;
100+ ither: null;
101+ juglandaceous: null;
102+ litho: null;
103+ macropterous: null;
104+ photographer: null;
105+ romancing: null;
106+ rumness: null;
107+ somniloquist: null;
108+ stressfully: null;
109+ tactically: null;
110+ tracheophony: null;
111+ unappositely: null;
112+ unclothedly: null;
113+ unimplied: null;
114+ unsyncopated: null;
115+}
116+
117+export type QuebrachineElement = boolean | QuebrachineClass | null;
118+
119+export type QuebrachineClass = {
120+ Chirotherium: number;
121+ catharticalness: number;
122+ disdiapason: string;
123+ homocerc: boolean;
124+ nonbookish: null;
125+}
126+
127+export type Querier = boolean | { [key: string]: number };
128+
129+export type Rebarbative = number[] | boolean | number;
130+
131+export type Reimagine = {
132+ Chirotherium?: number;
133+ Hermo?: null;
134+ adducible?: null;
135+ anabolin?: null;
136+ brainy?: null;
137+ catharticalness?: number;
138+ chrysamine?: null;
139+ disdiapason?: string;
140+ fluxweed?: null;
141+ glaucine?: null;
142+ grobianism?: null;
143+ hieroglyphist?: null;
144+ homocerc?: boolean;
145+ icteroid?: null;
146+ immortal?: null;
147+ impetulant?: null;
148+ irrigate?: null;
149+ myxedema?: null;
150+ nonbookish?: null;
151+ onyx?: null;
152+ repasser?: null;
153+ septomarginal?: null;
154+ subdie?: null;
155+ tibiometatarsal?: null;
156+ waltzlike?: null;
157+}
158+
159+export type Ressaut = {
160+ Freesia: string;
161+ Genevieve: string;
162+ Mimosaceae: string;
163+ Theopaschitism: string;
164+ apperceptive: string;
165+ cuttoo: string;
166+ douser: string;
167+ drinkproof: string;
168+ forementioned: string;
169+ hyperdiabolical: string;
170+ hypocone: string;
171+ irreverentially: string;
172+ jumart: string;
173+ mollicrush: string;
174+ nedder: string;
175+ retinasphalt: string;
176+ sough: string;
177+ steading: string;
178+ undurableness: string;
179+ unmingleable: string;
180+}
181+
182+export type Retrocervical = (number | null)[] | number;
183+
184+export type Revert = boolean | string;
185+
186+export type RewriteElement = null[] | RewriteClass | number;
187+
188+export type RewriteClass = {
189+ Hyades: null;
190+ Ptenoglossa: null;
191+ Whiggification: null;
192+ accountancy: null;
193+ cacotrophic: null;
194+ contest: null;
195+ couthily: null;
196+ falculate: null;
197+ foreseize: null;
198+ lemnad: null;
199+ monotheistically: null;
200+ nonflying: null;
201+ repatch: null;
202+ rodman: null;
203+ strung: null;
204+ titmal: null;
205+ twalpennyworth: null;
206+ unblamable: null;
207+ vertical: null;
208+ yardman: null;
209+}
210+
211+export type Saccoderm = number[] | null | string;
212+
213+export type SantirElement = SantirClass | number;
214+
215+export type SantirClass = {
216+ Suessiones: null;
217+ admiredly: null;
218+ demicaponier: null;
219+ epitympanic: null;
220+ investitor: null;
221+ lupiform: null;
222+ monoflagellate: null;
223+ paleoethnic: null;
224+ prediscountable: null;
225+ rhetoricals: null;
226+ roomth: null;
227+ saccharose: null;
228+ septonasal: null;
229+ serpenticide: null;
230+ setarious: null;
231+ spaework: null;
232+ stylite: null;
233+ timelily: null;
234+ unprofaned: null;
235+ vorticular: null;
236+}
237+
238+export type Saprophilous = { [key: string]: number } | null | string;
239+
240+export type SaxtenElement = SaxtenClass | string;
241+
242+export type SaxtenClass = {
243+ Centaurid?: null;
244+ Chirotherium?: number;
245+ algarrobilla?: null;
246+ bowgrace?: null;
247+ catharticalness?: number;
248+ disdiapason?: string;
249+ flix?: null;
250+ germanely?: null;
251+ homocerc?: boolean;
252+ inhume?: null;
253+ lepidote?: null;
254+ megalochirous?: null;
255+ ninepenny?: null;
256+ nonbookish?: null;
257+ nondeist?: null;
258+ nymphaeaceous?: null;
259+ parietofrontal?: null;
260+ sancyite?: null;
261+ subjectivist?: null;
262+ tibiad?: null;
263+ transonic?: null;
264+ tripetalous?: null;
265+ trunchman?: null;
266+ urger?: null;
267+ withdrawnness?: null;
268+}
269+
270+export type Scatty = {
271+ Tabasco: null;
272+ aeriferous: null;
273+ antical: null;
274+ antighostism: null;
275+ arcanum: null;
276+ autotrophy: null;
277+ baronial: null;
278+ caffeine: null;
279+ gorgoniacean: null;
280+ heroical: null;
281+ hydropical: null;
282+ mechanology: null;
283+ musicopoetic: null;
284+ officiality: null;
285+ oftentimes: null;
286+ ophthalmotonometer: null;
287+ reflectively: null;
288+ springer: null;
289+ teleianthous: null;
290+ uncombated: null;
291+}
292+
293+export type Scoffer = null[] | { [key: string]: number } | null;
294+
295+export type Scrampum = number[] | boolean | null;
296+
297+export type Serpentinic = number[] | number;
298+
299+export type Shadowable = (number | null)[] | boolean;
300+
301+export type SisteringElement = null[] | SisteringClass | number;
302+
303+export type SisteringClass = {
304+ Chianti: null;
305+ Haplomi: null;
306+ Micropterygidae: null;
307+ amphicarpic: null;
308+ frigorific: null;
309+ hyperkinesis: null;
310+ laudable: null;
311+ madwoman: null;
312+ maimedly: null;
313+ microrhabdus: null;
314+ nondense: null;
315+ phlebemphraxis: null;
316+ redsear: null;
317+ schismatical: null;
318+ tartryl: null;
319+ unabhorred: null;
320+ undeliberateness: null;
321+ unmixable: null;
322+ untruckling: null;
323+ vineal: null;
324+}
325+
326+export type Staghunting = {
327+ Chirotherium?: number;
328+ calorimetric?: number;
329+ canid?: number;
330+ catharticalness?: number;
331+ disdiapason?: string;
332+ ditriglyphic?: number;
333+ floriferousness?: number;
334+ gamelike?: number;
335+ grig?: number;
336+ homocerc?: boolean;
337+ interloan?: number;
338+ lithotomy?: number;
339+ loric?: number;
340+ membranocoriaceous?: number;
341+ membranogenic?: number;
342+ nonbookish?: null;
343+ overtrump?: number;
344+ scotino?: number;
345+ seasonable?: number;
346+ sephen?: number;
347+ stigmarioid?: number;
348+ tired?: number;
349+ trifid?: number;
350+ undefeatedly?: number;
351+ ungirlish?: number;
352+}
353+
354+export type Stagmometer = (number | null)[] | string;
355+
356+export type Stimulability = boolean | number | { [key: string]: number };
357+
358+export type Strangleable = null[] | number;
359+
360+export type StrenuosityElement = null[] | StrenuosityClass;
361+
362+export type StrenuosityClass = {
363+ Chirotherium?: number;
364+ Onopordon?: number;
365+ Sodomite?: number;
366+ Yankeeist?: number;
367+ bliss?: number;
368+ buccate?: number;
369+ bulletproof?: number;
370+ catharticalness?: number;
371+ crumblingness?: number;
372+ disdiapason?: string;
373+ engagedly?: number;
374+ fightable?: number;
375+ hoariness?: number;
376+ homocerc?: boolean;
377+ hypopodium?: number;
378+ luxurist?: number;
379+ mechanician?: number;
380+ nonbookish?: null;
381+ podgily?: number;
382+ reformableness?: number;
383+ scatterbrains?: number;
384+ seminuria?: number;
385+ tramp?: number;
386+ undueness?: number;
387+ worthily?: number;
388+}
389+
390+export type Tabaxir = boolean | number;
391+
392+export type Talpiform = QuebrachineClass | number | null;
393+
394+export type Thwack = boolean | QuebrachineClass | number;
395+
396+export type Tortricine = (number | null)[] | QuebrachineClass;
397+
398+export type TruantcyElement = boolean | TruantcyClass;
399+
400+export type TruantcyClass = {
401+ Chirotherium?: number;
402+ Epeira?: null;
403+ Eurylaimi?: null;
404+ Yuman?: null;
405+ alfiona?: null;
406+ ascaridiasis?: null;
407+ bungey?: null;
408+ catharticalness?: number;
409+ ceroxyle?: null;
410+ chorology?: null;
411+ disdiapason?: string;
412+ enmarble?: null;
413+ germination?: null;
414+ hallelujah?: null;
415+ homocerc?: boolean;
416+ lev?: null;
417+ mouthing?: null;
418+ nonbookish?: null;
419+ philliloo?: null;
420+ planetal?: null;
421+ poney?: null;
422+ punctualist?: null;
423+ returnlessly?: null;
424+ skelder?: null;
425+ windwaywardly?: null;
426+}
427+
428+export type Unbeginning = null[] | { [key: string]: number } | string;
429+
430+export type Undesirability = number[] | { [key: string]: number } | string;
431+
432+export type Unerasing = null[] | number | { [key: string]: number };
433+
434+export type Unguentarium = null[] | number | null;
435+
436+export type UnimpeachablyElement = boolean | UnimpeachablyClass;
437+
438+export type UnimpeachablyClass = {
439+ Bobadil?: number;
440+ Chirotherium?: number;
441+ Quiina?: number;
442+ Robert?: number;
443+ acerin?: number;
444+ catharticalness?: number;
445+ chlorophylligenous?: number;
446+ conversational?: number;
447+ demiowl?: number;
448+ disdiapason?: string;
449+ ectorhinal?: number;
450+ gamblesomeness?: number;
451+ homocerc?: boolean;
452+ irrorate?: number;
453+ kindergartening?: number;
454+ lateritic?: number;
455+ mespil?: number;
456+ misconfiguration?: number;
457+ nonbookish?: null;
458+ planometry?: number;
459+ rot?: number;
460+ subcinctorium?: number;
461+ tussocker?: number;
462+ ultraproud?: number;
463+ unsuggestedness?: number;
464+}
465+
466+export type Unmortgaged = number | { [key: string]: number } | null;
467+
468+export type Unobstructed = QuebrachineClass | number | null;
469+
470+export type Unreceptivity = null[] | number | string;
471+
472+export type Unsatisfactoriness = number[] | boolean | number;
473+
474+export type UnstressedElement = boolean | UnstressedClass | string;
475+
476+export type UnstressedClass = {
477+ Alain: null;
478+ Amphirhina: null;
479+ Lincolnian: null;
480+ Sarcophilus: null;
481+ antimachinery: null;
482+ coldish: null;
483+ crantara: null;
484+ distinguishing: null;
485+ elytroposis: null;
486+ gentianwort: null;
487+ heliosis: null;
488+ instrumental: null;
489+ introinflection: null;
490+ kala: null;
491+ metad: null;
492+ swingingly: null;
493+ unconformity: null;
494+ undecreed: null;
495+ venerable: null;
496+ vowellessness: null;
497+}
498+
499+export type Untasked = null[] | number | { [key: string]: number };
500+
501+export type Unvarying = boolean | number | { [key: string]: number };
502+
503+export type Vehemently = null[] | boolean | null;
504+
505+export type Whitepot = QuebrachineClass | number;
506+
507+export type WrothyElement = null[] | WrothyClass;
508+
509+export type WrothyClass = {
510+ Aeschynanthus: null;
511+ Ephesine: null;
512+ aquiferous: null;
513+ cheapener: null;
514+ enumeration: null;
515+ escadrille: null;
516+ estrous: null;
517+ interestedly: null;
518+ katakinetomer: null;
519+ mortification: null;
520+ morula: null;
521+ orthosymmetrical: null;
522+ overbark: null;
523+ politist: null;
524+ qualified: null;
525+ sphenomalar: null;
526+ throatful: null;
527+ transhumance: null;
528+ triandrian: null;
529+ unbooked: null;
530+}
531+
532+// Converts JSON strings to/from your types
533+// and asserts the results of JSON.parse at runtime
534+export class Convert {
535+ public static toTopLevel(json: string): TopLevel {
536+ return cast(JSON.parse(json), r("TopLevel"));
537+ }
538+
539+ public static topLevelToJson(value: TopLevel): string {
540+ return JSON.stringify(uncast(value, r("TopLevel")), null, 2);
541+ }
542+}
543+
544+function invalidValue(typ: any, val: any, key: any, parent: any = ''): never {
545+ const prettyTyp = prettyTypeName(typ);
546+ const parentText = parent ? ` on ${parent}` : '';
547+ const keyText = key ? ` for key "${key}"` : '';
548+ throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`);
549+}
550+
551+function prettyTypeName(typ: any): string {
552+ if (Array.isArray(typ)) {
553+ if (typ.length === 2 && typ[0] === undefined) {
554+ return `an optional ${prettyTypeName(typ[1])}`;
555+ } else {
556+ return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`;
557+ }
558+ } else if (typeof typ === "object" && typ.literal !== undefined) {
559+ return typ.literal;
560+ } else {
561+ return typeof typ;
562+ }
563+}
564+
565+function jsonToJSProps(typ: any): any {
566+ if (typ.jsonToJS === undefined) {
567+ const map: any = {};
568+ typ.props.forEach((p: any) => map[p.json] = { key: p.js, typ: p.typ });
569+ typ.jsonToJS = map;
570+ }
571+ return typ.jsonToJS;
572+}
573+
574+function jsToJSONProps(typ: any): any {
575+ if (typ.jsToJSON === undefined) {
576+ const map: any = {};
577+ typ.props.forEach((p: any) => map[p.js] = { key: p.json, typ: p.typ });
578+ typ.jsToJSON = map;
579+ }
580+ return typ.jsToJSON;
581+}
582+
583+function transform(val: any, typ: any, getProps: any, key: any = '', parent: any = ''): any {
584+ function transformPrimitive(typ: string, val: any): any {
585+ if (typeof typ === typeof val) return val;
586+ return invalidValue(typ, val, key, parent);
587+ }
588+
589+ function transformUnion(typs: any[], val: any): any {
590+ // val must validate against one typ in typs
591+ const l = typs.length;
592+ for (let i = 0; i < l; i++) {
593+ const typ = typs[i];
594+ try {
595+ return transform(val, typ, getProps);
596+ } catch (_) {}
597+ }
598+ return invalidValue(typs, val, key, parent);
599+ }
600+
601+ function transformEnum(cases: string[], val: any): any {
602+ if (cases.indexOf(val) !== -1) return val;
603+ return invalidValue(cases.map(a => { return l(a); }), val, key, parent);
604+ }
605+
606+ function transformArray(typ: any, val: any): any {
607+ // val must be an array with no invalid elements
608+ if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent);
609+
610+ return val.map(el => transform(el, typ, getProps));
611+ }
612+
613+ function transformDate(val: any): any {
614+ if (val === null) {
615+ return null;
616+ }
617+ const d = new Date(val);
618+ if (isNaN(d.valueOf())) {
619+ return invalidValue(l("Date"), val, key, parent);
620+ }
621+ return d;
622+ }
623+
624+ function transformObject(props: { [k: string]: any }, additional: any, val: any): any {
625+ if (val === null || typeof val !== "object" || Array.isArray(val)) {
626+ return invalidValue(l(ref || "object"), val, key, parent);
627+ }
628+ const result: any = {};
629+ Object.getOwnPropertyNames(props).forEach(key => {
630+ const prop = props[key];
631+ const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined;
632+ result[prop.key] = transform(v, prop.typ, getProps, key, ref);
633+ });
634+ Object.getOwnPropertyNames(val).forEach(key => {
635+ if (!Object.prototype.hasOwnProperty.call(props, key)) {
636+ result[key] = transform(val[key], additional, getProps, key, ref);
637+ }
638+ });
639+ return result;
640+ }
641+
642+ if (typ === "any") return val;
643+ if (typ === null) {
644+ if (val === null) return val;
645+ return invalidValue(typ, val, key, parent);
646+ }
647+ if (typ === false) return invalidValue(typ, val, key, parent);
648+ let ref: any = undefined;
649+ while (typeof typ === "object" && typ.ref !== undefined) {
650+ ref = typ.ref;
651+ typ = typeMap[typ.ref];
652+ }
653+ if (Array.isArray(typ)) return transformEnum(typ, val);
654+ if (typeof typ === "object") {
655+ return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent)
656+ : 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)
657+ : 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)
658+ : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent)
659+ : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val)
660+ : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val)
661+ : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val)
662+ : invalidValue(typ, val, key, parent);
663+ }
664+ // Numbers can be parsed by Date but shouldn't be.
665+ if (typ === Date && typeof val !== "number") return transformDate(val);
666+ return transformPrimitive(typ, val);
667+}
668+
669+function cast<T>(val: any, typ: any): T {
670+ return transform(val, typ, jsonToJSProps);
671+}
672+
673+function uncast<T>(val: T, typ: any): any {
674+ return transform(val, typ, jsToJSONProps);
675+}
676+
677+function l(typ: any) {
678+ return { literal: typ };
679+}
680+
681+function a(typ: any) {
682+ return { arrayItems: typ };
683+}
684+
685+function i(typ: any) {
686+ return { integer: typ };
687+}
688+
689+function p(pattern: any) {
690+ return { pattern };
691+}
692+
693+function s(typ: any, min: any, max: any) {
694+ return { string: typ, min, max };
695+}
696+
697+function n(typ: any, min: any, max: any) {
698+ return { number: typ, min, max };
699+}
700+
701+function u(...typs: any[]) {
702+ return { unionMembers: typs };
703+}
704+
705+function o(props: any[], additional: any) {
706+ return { props, additional };
707+}
708+
709+function m(additional: any) {
710+ const props: any[] = [];
711+ return { props, additional };
712+}
713+
714+function r(name: string) {
715+ return { ref: name };
716+}
717+
718+const typeMap: any = {
719+ "TopLevel": o([
720+ { json: "protrusive", js: "protrusive", typ: a(u(a(u(i(0), null)), 3.14)) },
721+ { json: "pulpitism", js: "pulpitism", typ: a(u(a(i(0)), r("PulpitismClass"), 3.14)) },
722+ { json: "pyodermia", js: "pyodermia", typ: a(u(r("PyodermiaClass"), i(0))) },
723+ { json: "quebrachine", js: "quebrachine", typ: a(u(true, r("QuebrachineClass"), null)) },
724+ { json: "querier", js: "querier", typ: a(u(true, m(i(0)))) },
725+ { json: "rebarbative", js: "rebarbative", typ: a(u(a(i(0)), true, 3.14)) },
726+ { json: "reimagine", js: "reimagine", typ: a(r("Reimagine")) },
727+ { json: "ressaut", js: "ressaut", typ: r("Ressaut") },
728+ { json: "retrocervical", js: "retrocervical", typ: a(u(a(u(i(0), null)), i(0))) },
729+ { json: "revert", js: "revert", typ: a(u(true, "")) },
730+ { json: "rewrite", js: "rewrite", typ: a(u(a(null), r("RewriteClass"), 3.14)) },
731+ { json: "saccoderm", js: "saccoderm", typ: a(u(a(i(0)), null, "")) },
732+ { json: "santir", js: "santir", typ: a(u(r("SantirClass"), 3.14)) },
733+ { json: "saprophilous", js: "saprophilous", typ: a(u(m(i(0)), null, "")) },
734+ { json: "saxten", js: "saxten", typ: a(u(r("SaxtenClass"), "")) },
735+ { json: "scatty", js: "scatty", typ: a(u(r("Scatty"), null)) },
736+ { json: "scoffer", js: "scoffer", typ: a(u(a(null), m(i(0)), null)) },
737+ { json: "scrampum", js: "scrampum", typ: a(u(a(i(0)), true, null)) },
738+ { json: "semantic", js: "semantic", typ: 3.14 },
739+ { json: "serpentinic", js: "serpentinic", typ: a(u(a(i(0)), 3.14)) },
740+ { json: "shadowable", js: "shadowable", typ: a(u(a(u(i(0), null)), true)) },
741+ { json: "sistering", js: "sistering", typ: a(u(a(null), r("SisteringClass"), i(0))) },
742+ { json: "staghunting", js: "staghunting", typ: a(r("Staghunting")) },
743+ { json: "stagmometer", js: "stagmometer", typ: a(u(a(u(i(0), null)), "")) },
744+ { json: "stimulability", js: "stimulability", typ: a(u(true, i(0), m(i(0)))) },
745+ { json: "strangleable", js: "strangleable", typ: a(u(a(null), 3.14)) },
746+ { json: "strenuosity", js: "strenuosity", typ: a(u(a(null), r("StrenuosityClass"))) },
747+ { json: "tabaxir", js: "tabaxir", typ: a(u(true, 3.14)) },
748+ { json: "talpiform", js: "talpiform", typ: a(u(r("QuebrachineClass"), 3.14, null)) },
749+ { json: "thwack", js: "thwack", typ: a(u(true, r("QuebrachineClass"), 3.14)) },
750+ { json: "to", js: "to", typ: a(u(3.14, null)) },
751+ { json: "tortricine", js: "tortricine", typ: a(u(a(u(i(0), null)), r("QuebrachineClass"))) },
752+ { json: "truantcy", js: "truantcy", typ: a(u(true, r("TruantcyClass"))) },
753+ { json: "turgesce", js: "turgesce", typ: a("") },
754+ { json: "unbeginning", js: "unbeginning", typ: a(u(a(null), m(i(0)), "")) },
755+ { json: "underdunged", js: "underdunged", typ: a(3.14) },
756+ { json: "undesirability", js: "undesirability", typ: a(u(a(i(0)), m(i(0)), "")) },
757+ { json: "unerasing", js: "unerasing", typ: a(u(a(null), i(0), m(i(0)))) },
758+ { json: "unguentarium", js: "unguentarium", typ: a(u(a(null), i(0), null)) },
759+ { json: "unimpeachably", js: "unimpeachably", typ: a(u(true, r("UnimpeachablyClass"))) },
760+ { json: "unmortgaged", js: "unmortgaged", typ: a(u(3.14, m(i(0)), null)) },
761+ { json: "unobstructed", js: "unobstructed", typ: a(u(r("QuebrachineClass"), i(0), null)) },
762+ { json: "unreceptivity", js: "unreceptivity", typ: a(u(a(null), i(0), "")) },
763+ { json: "unsatisfactoriness", js: "unsatisfactoriness", typ: a(u(a(i(0)), true, i(0))) },
764+ { json: "unsecurity", js: "unsecurity", typ: a(i(0)) },
765+ { json: "unstressed", js: "unstressed", typ: a(u(true, r("UnstressedClass"), "")) },
766+ { json: "untasked", js: "untasked", typ: a(u(a(null), 3.14, m(i(0)))) },
767+ { json: "unvarying", js: "unvarying", typ: a(u(true, 3.14, m(i(0)))) },
768+ { json: "vehemently", js: "vehemently", typ: a(u(a(null), true, null)) },
769+ { json: "warriorship", js: "warriorship", typ: m(true) },
770+ { json: "whitepot", js: "whitepot", typ: a(u(r("QuebrachineClass"), 3.14)) },
771+ { json: "wrothy", js: "wrothy", typ: a(u(a(null), r("WrothyClass"))) },
772+ ], false),
773+ "PulpitismClass": o([
774+ { json: "abnet", js: "abnet", typ: null },
775+ { json: "buckhorn", js: "buckhorn", typ: null },
776+ { json: "calciform", js: "calciform", typ: null },
777+ { json: "chelophore", js: "chelophore", typ: null },
778+ { json: "cogitation", js: "cogitation", typ: null },
779+ { json: "decreeable", js: "decreeable", typ: null },
780+ { json: "despicable", js: "despicable", typ: null },
781+ { json: "isodiazo", js: "isodiazo", typ: null },
782+ { json: "jadedly", js: "jadedly", typ: null },
783+ { json: "leptochlorite", js: "leptochlorite", typ: null },
784+ { json: "nursling", js: "nursling", typ: null },
785+ { json: "palamedean", js: "palamedean", typ: null },
786+ { json: "photoheliograph", js: "photoheliograph", typ: null },
787+ { json: "pipewood", js: "pipewood", typ: null },
788+ { json: "roberd", js: "roberd", typ: null },
789+ { json: "statable", js: "statable", typ: null },
790+ { json: "superassume", js: "superassume", typ: null },
791+ { json: "syllabe", js: "syllabe", typ: null },
792+ { json: "toughhead", js: "toughhead", typ: null },
793+ { json: "underburn", js: "underburn", typ: null },
794+ ], false),
795+ "PyodermiaClass": o([
796+ { json: "Gyppo", js: "Gyppo", typ: null },
797+ { json: "aphoristically", js: "aphoristically", typ: null },
798+ { json: "apophyllous", js: "apophyllous", typ: null },
799+ { json: "cognize", js: "cognize", typ: null },
800+ { json: "dermonosology", js: "dermonosology", typ: null },
801+ { json: "ither", js: "ither", typ: null },
802+ { json: "juglandaceous", js: "juglandaceous", typ: null },
803+ { json: "litho", js: "litho", typ: null },
804+ { json: "macropterous", js: "macropterous", typ: null },
805+ { json: "photographer", js: "photographer", typ: null },
806+ { json: "romancing", js: "romancing", typ: null },
807+ { json: "rumness", js: "rumness", typ: null },
808+ { json: "somniloquist", js: "somniloquist", typ: null },
809+ { json: "stressfully", js: "stressfully", typ: null },
810+ { json: "tactically", js: "tactically", typ: null },
811+ { json: "tracheophony", js: "tracheophony", typ: null },
812+ { json: "unappositely", js: "unappositely", typ: null },
813+ { json: "unclothedly", js: "unclothedly", typ: null },
814+ { json: "unimplied", js: "unimplied", typ: null },
815+ { json: "unsyncopated", js: "unsyncopated", typ: null },
816+ ], false),
817+ "QuebrachineClass": o([
818+ { json: "Chirotherium", js: "Chirotherium", typ: i(0) },
819+ { json: "catharticalness", js: "catharticalness", typ: 3.14 },
820+ { json: "disdiapason", js: "disdiapason", typ: "" },
821+ { json: "homocerc", js: "homocerc", typ: true },
822+ { json: "nonbookish", js: "nonbookish", typ: null },
823+ ], false),
824+ "Reimagine": o([
825+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
826+ { json: "Hermo", js: "Hermo", typ: u(undefined, null) },
827+ { json: "adducible", js: "adducible", typ: u(undefined, null) },
828+ { json: "anabolin", js: "anabolin", typ: u(undefined, null) },
829+ { json: "brainy", js: "brainy", typ: u(undefined, null) },
830+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
831+ { json: "chrysamine", js: "chrysamine", typ: u(undefined, null) },
832+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
833+ { json: "fluxweed", js: "fluxweed", typ: u(undefined, null) },
834+ { json: "glaucine", js: "glaucine", typ: u(undefined, null) },
835+ { json: "grobianism", js: "grobianism", typ: u(undefined, null) },
836+ { json: "hieroglyphist", js: "hieroglyphist", typ: u(undefined, null) },
837+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
838+ { json: "icteroid", js: "icteroid", typ: u(undefined, null) },
839+ { json: "immortal", js: "immortal", typ: u(undefined, null) },
840+ { json: "impetulant", js: "impetulant", typ: u(undefined, null) },
841+ { json: "irrigate", js: "irrigate", typ: u(undefined, null) },
842+ { json: "myxedema", js: "myxedema", typ: u(undefined, null) },
843+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
844+ { json: "onyx", js: "onyx", typ: u(undefined, null) },
845+ { json: "repasser", js: "repasser", typ: u(undefined, null) },
846+ { json: "septomarginal", js: "septomarginal", typ: u(undefined, null) },
847+ { json: "subdie", js: "subdie", typ: u(undefined, null) },
848+ { json: "tibiometatarsal", js: "tibiometatarsal", typ: u(undefined, null) },
849+ { json: "waltzlike", js: "waltzlike", typ: u(undefined, null) },
850+ ], false),
851+ "Ressaut": o([
852+ { json: "Freesia", js: "Freesia", typ: "" },
853+ { json: "Genevieve", js: "Genevieve", typ: "" },
854+ { json: "Mimosaceae", js: "Mimosaceae", typ: "" },
855+ { json: "Theopaschitism", js: "Theopaschitism", typ: "" },
856+ { json: "apperceptive", js: "apperceptive", typ: "" },
857+ { json: "cuttoo", js: "cuttoo", typ: "" },
858+ { json: "douser", js: "douser", typ: "" },
859+ { json: "drinkproof", js: "drinkproof", typ: "" },
860+ { json: "forementioned", js: "forementioned", typ: "" },
861+ { json: "hyperdiabolical", js: "hyperdiabolical", typ: "" },
862+ { json: "hypocone", js: "hypocone", typ: "" },
863+ { json: "irreverentially", js: "irreverentially", typ: "" },
864+ { json: "jumart", js: "jumart", typ: "" },
865+ { json: "mollicrush", js: "mollicrush", typ: "" },
866+ { json: "nedder", js: "nedder", typ: "" },
867+ { json: "retinasphalt", js: "retinasphalt", typ: "" },
868+ { json: "sough", js: "sough", typ: "" },
869+ { json: "steading", js: "steading", typ: "" },
870+ { json: "undurableness", js: "undurableness", typ: "" },
871+ { json: "unmingleable", js: "unmingleable", typ: "" },
872+ ], false),
873+ "RewriteClass": o([
874+ { json: "Hyades", js: "Hyades", typ: null },
875+ { json: "Ptenoglossa", js: "Ptenoglossa", typ: null },
876+ { json: "Whiggification", js: "Whiggification", typ: null },
877+ { json: "accountancy", js: "accountancy", typ: null },
878+ { json: "cacotrophic", js: "cacotrophic", typ: null },
879+ { json: "contest", js: "contest", typ: null },
880+ { json: "couthily", js: "couthily", typ: null },
881+ { json: "falculate", js: "falculate", typ: null },
882+ { json: "foreseize", js: "foreseize", typ: null },
883+ { json: "lemnad", js: "lemnad", typ: null },
884+ { json: "monotheistically", js: "monotheistically", typ: null },
885+ { json: "nonflying", js: "nonflying", typ: null },
886+ { json: "repatch", js: "repatch", typ: null },
887+ { json: "rodman", js: "rodman", typ: null },
888+ { json: "strung", js: "strung", typ: null },
889+ { json: "titmal", js: "titmal", typ: null },
890+ { json: "twalpennyworth", js: "twalpennyworth", typ: null },
891+ { json: "unblamable", js: "unblamable", typ: null },
892+ { json: "vertical", js: "vertical", typ: null },
893+ { json: "yardman", js: "yardman", typ: null },
894+ ], false),
895+ "SantirClass": o([
896+ { json: "Suessiones", js: "Suessiones", typ: null },
897+ { json: "admiredly", js: "admiredly", typ: null },
898+ { json: "demicaponier", js: "demicaponier", typ: null },
899+ { json: "epitympanic", js: "epitympanic", typ: null },
900+ { json: "investitor", js: "investitor", typ: null },
901+ { json: "lupiform", js: "lupiform", typ: null },
902+ { json: "monoflagellate", js: "monoflagellate", typ: null },
903+ { json: "paleoethnic", js: "paleoethnic", typ: null },
904+ { json: "prediscountable", js: "prediscountable", typ: null },
905+ { json: "rhetoricals", js: "rhetoricals", typ: null },
906+ { json: "roomth", js: "roomth", typ: null },
907+ { json: "saccharose", js: "saccharose", typ: null },
908+ { json: "septonasal", js: "septonasal", typ: null },
909+ { json: "serpenticide", js: "serpenticide", typ: null },
910+ { json: "setarious", js: "setarious", typ: null },
911+ { json: "spaework", js: "spaework", typ: null },
912+ { json: "stylite", js: "stylite", typ: null },
913+ { json: "timelily", js: "timelily", typ: null },
914+ { json: "unprofaned", js: "unprofaned", typ: null },
915+ { json: "vorticular", js: "vorticular", typ: null },
916+ ], false),
917+ "SaxtenClass": o([
918+ { json: "Centaurid", js: "Centaurid", typ: u(undefined, null) },
919+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
920+ { json: "algarrobilla", js: "algarrobilla", typ: u(undefined, null) },
921+ { json: "bowgrace", js: "bowgrace", typ: u(undefined, null) },
922+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
923+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
924+ { json: "flix", js: "flix", typ: u(undefined, null) },
925+ { json: "germanely", js: "germanely", typ: u(undefined, null) },
926+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
927+ { json: "inhume", js: "inhume", typ: u(undefined, null) },
928+ { json: "lepidote", js: "lepidote", typ: u(undefined, null) },
929+ { json: "megalochirous", js: "megalochirous", typ: u(undefined, null) },
930+ { json: "ninepenny", js: "ninepenny", typ: u(undefined, null) },
931+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
932+ { json: "nondeist", js: "nondeist", typ: u(undefined, null) },
933+ { json: "nymphaeaceous", js: "nymphaeaceous", typ: u(undefined, null) },
934+ { json: "parietofrontal", js: "parietofrontal", typ: u(undefined, null) },
935+ { json: "sancyite", js: "sancyite", typ: u(undefined, null) },
936+ { json: "subjectivist", js: "subjectivist", typ: u(undefined, null) },
937+ { json: "tibiad", js: "tibiad", typ: u(undefined, null) },
938+ { json: "transonic", js: "transonic", typ: u(undefined, null) },
939+ { json: "tripetalous", js: "tripetalous", typ: u(undefined, null) },
940+ { json: "trunchman", js: "trunchman", typ: u(undefined, null) },
941+ { json: "urger", js: "urger", typ: u(undefined, null) },
942+ { json: "withdrawnness", js: "withdrawnness", typ: u(undefined, null) },
943+ ], false),
944+ "Scatty": o([
945+ { json: "Tabasco", js: "Tabasco", typ: null },
946+ { json: "aeriferous", js: "aeriferous", typ: null },
947+ { json: "antical", js: "antical", typ: null },
948+ { json: "antighostism", js: "antighostism", typ: null },
949+ { json: "arcanum", js: "arcanum", typ: null },
950+ { json: "autotrophy", js: "autotrophy", typ: null },
951+ { json: "baronial", js: "baronial", typ: null },
952+ { json: "caffeine", js: "caffeine", typ: null },
953+ { json: "gorgoniacean", js: "gorgoniacean", typ: null },
954+ { json: "heroical", js: "heroical", typ: null },
955+ { json: "hydropical", js: "hydropical", typ: null },
956+ { json: "mechanology", js: "mechanology", typ: null },
957+ { json: "musicopoetic", js: "musicopoetic", typ: null },
958+ { json: "officiality", js: "officiality", typ: null },
959+ { json: "oftentimes", js: "oftentimes", typ: null },
960+ { json: "ophthalmotonometer", js: "ophthalmotonometer", typ: null },
961+ { json: "reflectively", js: "reflectively", typ: null },
962+ { json: "springer", js: "springer", typ: null },
963+ { json: "teleianthous", js: "teleianthous", typ: null },
964+ { json: "uncombated", js: "uncombated", typ: null },
965+ ], false),
966+ "SisteringClass": o([
967+ { json: "Chianti", js: "Chianti", typ: null },
968+ { json: "Haplomi", js: "Haplomi", typ: null },
969+ { json: "Micropterygidae", js: "Micropterygidae", typ: null },
970+ { json: "amphicarpic", js: "amphicarpic", typ: null },
971+ { json: "frigorific", js: "frigorific", typ: null },
972+ { json: "hyperkinesis", js: "hyperkinesis", typ: null },
973+ { json: "laudable", js: "laudable", typ: null },
974+ { json: "madwoman", js: "madwoman", typ: null },
975+ { json: "maimedly", js: "maimedly", typ: null },
976+ { json: "microrhabdus", js: "microrhabdus", typ: null },
977+ { json: "nondense", js: "nondense", typ: null },
978+ { json: "phlebemphraxis", js: "phlebemphraxis", typ: null },
979+ { json: "redsear", js: "redsear", typ: null },
980+ { json: "schismatical", js: "schismatical", typ: null },
981+ { json: "tartryl", js: "tartryl", typ: null },
982+ { json: "unabhorred", js: "unabhorred", typ: null },
983+ { json: "undeliberateness", js: "undeliberateness", typ: null },
984+ { json: "unmixable", js: "unmixable", typ: null },
985+ { json: "untruckling", js: "untruckling", typ: null },
986+ { json: "vineal", js: "vineal", typ: null },
987+ ], false),
988+ "Staghunting": o([
989+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
990+ { json: "calorimetric", js: "calorimetric", typ: u(undefined, i(0)) },
991+ { json: "canid", js: "canid", typ: u(undefined, i(0)) },
992+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
993+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
994+ { json: "ditriglyphic", js: "ditriglyphic", typ: u(undefined, i(0)) },
995+ { json: "floriferousness", js: "floriferousness", typ: u(undefined, i(0)) },
996+ { json: "gamelike", js: "gamelike", typ: u(undefined, i(0)) },
997+ { json: "grig", js: "grig", typ: u(undefined, i(0)) },
998+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
999+ { json: "interloan", js: "interloan", typ: u(undefined, i(0)) },
1000+ { json: "lithotomy", js: "lithotomy", typ: u(undefined, i(0)) },
1001+ { json: "loric", js: "loric", typ: u(undefined, i(0)) },
1002+ { json: "membranocoriaceous", js: "membranocoriaceous", typ: u(undefined, i(0)) },
1003+ { json: "membranogenic", js: "membranogenic", typ: u(undefined, i(0)) },
1004+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
1005+ { json: "overtrump", js: "overtrump", typ: u(undefined, i(0)) },
1006+ { json: "scotino", js: "scotino", typ: u(undefined, i(0)) },
1007+ { json: "seasonable", js: "seasonable", typ: u(undefined, i(0)) },
1008+ { json: "sephen", js: "sephen", typ: u(undefined, i(0)) },
1009+ { json: "stigmarioid", js: "stigmarioid", typ: u(undefined, i(0)) },
1010+ { json: "tired", js: "tired", typ: u(undefined, i(0)) },
1011+ { json: "trifid", js: "trifid", typ: u(undefined, i(0)) },
1012+ { json: "undefeatedly", js: "undefeatedly", typ: u(undefined, i(0)) },
1013+ { json: "ungirlish", js: "ungirlish", typ: u(undefined, i(0)) },
1014+ ], false),
1015+ "StrenuosityClass": o([
1016+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
1017+ { json: "Onopordon", js: "Onopordon", typ: u(undefined, i(0)) },
1018+ { json: "Sodomite", js: "Sodomite", typ: u(undefined, i(0)) },
1019+ { json: "Yankeeist", js: "Yankeeist", typ: u(undefined, i(0)) },
1020+ { json: "bliss", js: "bliss", typ: u(undefined, i(0)) },
1021+ { json: "buccate", js: "buccate", typ: u(undefined, i(0)) },
1022+ { json: "bulletproof", js: "bulletproof", typ: u(undefined, i(0)) },
1023+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
1024+ { json: "crumblingness", js: "crumblingness", typ: u(undefined, i(0)) },
1025+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
1026+ { json: "engagedly", js: "engagedly", typ: u(undefined, i(0)) },
1027+ { json: "fightable", js: "fightable", typ: u(undefined, i(0)) },
1028+ { json: "hoariness", js: "hoariness", typ: u(undefined, i(0)) },
1029+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
1030+ { json: "hypopodium", js: "hypopodium", typ: u(undefined, i(0)) },
1031+ { json: "luxurist", js: "luxurist", typ: u(undefined, i(0)) },
1032+ { json: "mechanician", js: "mechanician", typ: u(undefined, i(0)) },
1033+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
1034+ { json: "podgily", js: "podgily", typ: u(undefined, i(0)) },
1035+ { json: "reformableness", js: "reformableness", typ: u(undefined, i(0)) },
1036+ { json: "scatterbrains", js: "scatterbrains", typ: u(undefined, i(0)) },
1037+ { json: "seminuria", js: "seminuria", typ: u(undefined, i(0)) },
1038+ { json: "tramp", js: "tramp", typ: u(undefined, i(0)) },
1039+ { json: "undueness", js: "undueness", typ: u(undefined, i(0)) },
1040+ { json: "worthily", js: "worthily", typ: u(undefined, i(0)) },
1041+ ], false),
1042+ "TruantcyClass": o([
1043+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
1044+ { json: "Epeira", js: "Epeira", typ: u(undefined, null) },
1045+ { json: "Eurylaimi", js: "Eurylaimi", typ: u(undefined, null) },
1046+ { json: "Yuman", js: "Yuman", typ: u(undefined, null) },
1047+ { json: "alfiona", js: "alfiona", typ: u(undefined, null) },
1048+ { json: "ascaridiasis", js: "ascaridiasis", typ: u(undefined, null) },
1049+ { json: "bungey", js: "bungey", typ: u(undefined, null) },
1050+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
1051+ { json: "ceroxyle", js: "ceroxyle", typ: u(undefined, null) },
1052+ { json: "chorology", js: "chorology", typ: u(undefined, null) },
1053+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
1054+ { json: "enmarble", js: "enmarble", typ: u(undefined, null) },
1055+ { json: "germination", js: "germination", typ: u(undefined, null) },
1056+ { json: "hallelujah", js: "hallelujah", typ: u(undefined, null) },
1057+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
1058+ { json: "lev", js: "lev", typ: u(undefined, null) },
1059+ { json: "mouthing", js: "mouthing", typ: u(undefined, null) },
1060+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
1061+ { json: "philliloo", js: "philliloo", typ: u(undefined, null) },
1062+ { json: "planetal", js: "planetal", typ: u(undefined, null) },
1063+ { json: "poney", js: "poney", typ: u(undefined, null) },
1064+ { json: "punctualist", js: "punctualist", typ: u(undefined, null) },
1065+ { json: "returnlessly", js: "returnlessly", typ: u(undefined, null) },
1066+ { json: "skelder", js: "skelder", typ: u(undefined, null) },
1067+ { json: "windwaywardly", js: "windwaywardly", typ: u(undefined, null) },
1068+ ], false),
1069+ "UnimpeachablyClass": o([
1070+ { json: "Bobadil", js: "Bobadil", typ: u(undefined, i(0)) },
1071+ { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) },
1072+ { json: "Quiina", js: "Quiina", typ: u(undefined, i(0)) },
1073+ { json: "Robert", js: "Robert", typ: u(undefined, i(0)) },
1074+ { json: "acerin", js: "acerin", typ: u(undefined, i(0)) },
1075+ { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) },
1076+ { json: "chlorophylligenous", js: "chlorophylligenous", typ: u(undefined, i(0)) },
1077+ { json: "conversational", js: "conversational", typ: u(undefined, i(0)) },
1078+ { json: "demiowl", js: "demiowl", typ: u(undefined, i(0)) },
1079+ { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") },
1080+ { json: "ectorhinal", js: "ectorhinal", typ: u(undefined, i(0)) },
1081+ { json: "gamblesomeness", js: "gamblesomeness", typ: u(undefined, i(0)) },
1082+ { json: "homocerc", js: "homocerc", typ: u(undefined, true) },
1083+ { json: "irrorate", js: "irrorate", typ: u(undefined, i(0)) },
1084+ { json: "kindergartening", js: "kindergartening", typ: u(undefined, i(0)) },
1085+ { json: "lateritic", js: "lateritic", typ: u(undefined, i(0)) },
1086+ { json: "mespil", js: "mespil", typ: u(undefined, i(0)) },
1087+ { json: "misconfiguration", js: "misconfiguration", typ: u(undefined, i(0)) },
1088+ { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) },
1089+ { json: "planometry", js: "planometry", typ: u(undefined, i(0)) },
1090+ { json: "rot", js: "rot", typ: u(undefined, i(0)) },
1091+ { json: "subcinctorium", js: "subcinctorium", typ: u(undefined, i(0)) },
1092+ { json: "tussocker", js: "tussocker", typ: u(undefined, i(0)) },
1093+ { json: "ultraproud", js: "ultraproud", typ: u(undefined, i(0)) },
1094+ { json: "unsuggestedness", js: "unsuggestedness", typ: u(undefined, i(0)) },
1095+ ], false),
1096+ "UnstressedClass": o([
1097+ { json: "Alain", js: "Alain", typ: null },
1098+ { json: "Amphirhina", js: "Amphirhina", typ: null },
1099+ { json: "Lincolnian", js: "Lincolnian", typ: null },
1100+ { json: "Sarcophilus", js: "Sarcophilus", typ: null },
1101+ { json: "antimachinery", js: "antimachinery", typ: null },
1102+ { json: "coldish", js: "coldish", typ: null },
1103+ { json: "crantara", js: "crantara", typ: null },
1104+ { json: "distinguishing", js: "distinguishing", typ: null },
1105+ { json: "elytroposis", js: "elytroposis", typ: null },
1106+ { json: "gentianwort", js: "gentianwort", typ: null },
1107+ { json: "heliosis", js: "heliosis", typ: null },
1108+ { json: "instrumental", js: "instrumental", typ: null },
1109+ { json: "introinflection", js: "introinflection", typ: null },
1110+ { json: "kala", js: "kala", typ: null },
1111+ { json: "metad", js: "metad", typ: null },
1112+ { json: "swingingly", js: "swingingly", typ: null },
1113+ { json: "unconformity", js: "unconformity", typ: null },
1114+ { json: "undecreed", js: "undecreed", typ: null },
1115+ { json: "venerable", js: "venerable", typ: null },
1116+ { json: "vowellessness", js: "vowellessness", typ: null },
1117+ ], false),
1118+ "WrothyClass": o([
1119+ { json: "Aeschynanthus", js: "Aeschynanthus", typ: null },
1120+ { json: "Ephesine", js: "Ephesine", typ: null },
1121+ { json: "aquiferous", js: "aquiferous", typ: null },
1122+ { json: "cheapener", js: "cheapener", typ: null },
1123+ { json: "enumeration", js: "enumeration", typ: null },
1124+ { json: "escadrille", js: "escadrille", typ: null },
1125+ { json: "estrous", js: "estrous", typ: null },
1126+ { json: "interestedly", js: "interestedly", typ: null },
1127+ { json: "katakinetomer", js: "katakinetomer", typ: null },
1128+ { json: "mortification", js: "mortification", typ: null },
1129+ { json: "morula", js: "morula", typ: null },
1130+ { json: "orthosymmetrical", js: "orthosymmetrical", typ: null },
1131+ { json: "overbark", js: "overbark", typ: null },
1132+ { json: "politist", js: "politist", typ: null },
1133+ { json: "qualified", js: "qualified", typ: null },
1134+ { json: "sphenomalar", js: "sphenomalar", typ: null },
1135+ { json: "throatful", js: "throatful", typ: null },
1136+ { json: "transhumance", js: "transhumance", typ: null },
1137+ { json: "triandrian", js: "triandrian", typ: null },
1138+ { json: "unbooked", js: "unbooked", typ: null },
1139+ ], false),
1140+};
Test case

test/inputs/json/samples/pokedex.json

1 generated file · +0 −283
Dtypescriptprefer-types-true--df33e18681f9 / TopLevel.ts+0 −283
@@ -1,283 +0,0 @@
1-// To parse this data:
2-//
3-// import { Convert, TopLevel } from "./TopLevel";
4-//
5-// const topLevel = Convert.toTopLevel(json);
6-//
7-// These functions will throw an error if the JSON doesn't
8-// match the expected interface, even if the JSON is valid.
9-
10-export type TopLevel = {
11- pokemon: Pokemon[];
12-}
13-
14-export type Pokemon = {
15- avg_spawns: number;
16- candy: string;
17- candy_count?: number;
18- egg: Egg;
19- height: string;
20- id: number;
21- img: string;
22- multipliers: number[] | null;
23- name: string;
24- next_evolution?: Evolution[];
25- num: string;
26- prev_evolution?: Evolution[];
27- spawn_chance: number;
28- spawn_time: string;
29- type: Type[];
30- weaknesses: Type[];
31- weight: string;
32-}
33-
34-export type Egg = "2 km" | "Not in Eggs" | "5 km" | "10 km" | "Omanyte Candy";
35-
36-export type Evolution = {
37- name: string;
38- num: string;
39-}
40-
41-export type Type = "Fire" | "Ice" | "Flying" | "Psychic" | "Water" | "Ground" | "Rock" | "Electric" | "Grass" | "Fighting" | "Poison" | "Bug" | "Fairy" | "Ghost" | "Dark" | "Steel" | "Dragon" | "Normal";
42-
43-// Converts JSON strings to/from your types
44-// and asserts the results of JSON.parse at runtime
45-export class Convert {
46- public static toTopLevel(json: string): TopLevel {
47- return cast(JSON.parse(json), r("TopLevel"));
48- }
49-
50- public static topLevelToJson(value: TopLevel): string {
51- return JSON.stringify(uncast(value, r("TopLevel")), null, 2);
52- }
53-}
54-
55-function invalidValue(typ: any, val: any, key: any, parent: any = ''): never {
56- const prettyTyp = prettyTypeName(typ);
57- const parentText = parent ? ` on ${parent}` : '';
58- const keyText = key ? ` for key "${key}"` : '';
59- throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`);
60-}
61-
62-function prettyTypeName(typ: any): string {
63- if (Array.isArray(typ)) {
64- if (typ.length === 2 && typ[0] === undefined) {
65- return `an optional ${prettyTypeName(typ[1])}`;
66- } else {
67- return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`;
68- }
69- } else if (typeof typ === "object" && typ.literal !== undefined) {
70- return typ.literal;
71- } else {
72- return typeof typ;
73- }
74-}
75-
76-function jsonToJSProps(typ: any): any {
77- if (typ.jsonToJS === undefined) {
78- const map: any = {};
79- typ.props.forEach((p: any) => map[p.json] = { key: p.js, typ: p.typ });
80- typ.jsonToJS = map;
81- }
82- return typ.jsonToJS;
83-}
84-
85-function jsToJSONProps(typ: any): any {
86- if (typ.jsToJSON === undefined) {
87- const map: any = {};
88- typ.props.forEach((p: any) => map[p.js] = { key: p.json, typ: p.typ });
89- typ.jsToJSON = map;
90- }
91- return typ.jsToJSON;
92-}
93-
94-function transform(val: any, typ: any, getProps: any, key: any = '', parent: any = ''): any {
95- function transformPrimitive(typ: string, val: any): any {
96- if (typeof typ === typeof val) return val;
97- return invalidValue(typ, val, key, parent);
98- }
99-
100- function transformUnion(typs: any[], val: any): any {
101- // val must validate against one typ in typs
102- const l = typs.length;
103- for (let i = 0; i < l; i++) {
104- const typ = typs[i];
105- try {
106- return transform(val, typ, getProps);
107- } catch (_) {}
108- }
109- return invalidValue(typs, val, key, parent);
110- }
111-
112- function transformEnum(cases: string[], val: any): any {
113- if (cases.indexOf(val) !== -1) return val;
114- return invalidValue(cases.map(a => { return l(a); }), val, key, parent);
115- }
116-
117- function transformArray(typ: any, val: any): any {
118- // val must be an array with no invalid elements
119- if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent);
120-
121- return val.map(el => transform(el, typ, getProps));
122- }
123-
124- function transformDate(val: any): any {
125- if (val === null) {
126- return null;
127- }
128- const d = new Date(val);
129- if (isNaN(d.valueOf())) {
130- return invalidValue(l("Date"), val, key, parent);
131- }
132- return d;
133- }
134-
135- function transformObject(props: { [k: string]: any }, additional: any, val: any): any {
136- if (val === null || typeof val !== "object" || Array.isArray(val)) {
137- return invalidValue(l(ref || "object"), val, key, parent);
138- }
139- const result: any = {};
140- Object.getOwnPropertyNames(props).forEach(key => {
141- const prop = props[key];
142- const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined;
143- result[prop.key] = transform(v, prop.typ, getProps, key, ref);
144- });
145- Object.getOwnPropertyNames(val).forEach(key => {
146- if (!Object.prototype.hasOwnProperty.call(props, key)) {
147- result[key] = transform(val[key], additional, getProps, key, ref);
148- }
149- });
150- return result;
151- }
152-
153- if (typ === "any") return val;
154- if (typ === null) {
155- if (val === null) return val;
156- return invalidValue(typ, val, key, parent);
157- }
158- if (typ === false) return invalidValue(typ, val, key, parent);
159- let ref: any = undefined;
160- while (typeof typ === "object" && typ.ref !== undefined) {
161- ref = typ.ref;
162- typ = typeMap[typ.ref];
163- }
164- if (Array.isArray(typ)) return transformEnum(typ, val);
165- if (typeof typ === "object") {
166- return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent)
167- : 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)
168- : 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)
169- : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent)
170- : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val)
171- : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val)
172- : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val)
173- : invalidValue(typ, val, key, parent);
174- }
175- // Numbers can be parsed by Date but shouldn't be.
176- if (typ === Date && typeof val !== "number") return transformDate(val);
177- return transformPrimitive(typ, val);
178-}
179-
180-function cast<T>(val: any, typ: any): T {
181- return transform(val, typ, jsonToJSProps);
182-}
183-
184-function uncast<T>(val: T, typ: any): any {
185- return transform(val, typ, jsToJSONProps);
186-}
187-
188-function l(typ: any) {
189- return { literal: typ };
190-}
191-
192-function a(typ: any) {
193- return { arrayItems: typ };
194-}
195-
196-function i(typ: any) {
197- return { integer: typ };
198-}
199-
200-function p(pattern: any) {
201- return { pattern };
202-}
203-
204-function s(typ: any, min: any, max: any) {
205- return { string: typ, min, max };
206-}
207-
208-function n(typ: any, min: any, max: any) {
209- return { number: typ, min, max };
210-}
211-
212-function u(...typs: any[]) {
213- return { unionMembers: typs };
214-}
215-
216-function o(props: any[], additional: any) {
217- return { props, additional };
218-}
219-
220-function m(additional: any) {
221- const props: any[] = [];
222- return { props, additional };
223-}
224-
225-function r(name: string) {
226- return { ref: name };
227-}
228-
229-const typeMap: any = {
230- "TopLevel": o([
231- { json: "pokemon", js: "pokemon", typ: a(r("Pokemon")) },
232- ], false),
233- "Pokemon": o([
234- { json: "avg_spawns", js: "avg_spawns", typ: 3.14 },
235- { json: "candy", js: "candy", typ: "" },
236- { json: "candy_count", js: "candy_count", typ: u(undefined, i(0)) },
237- { json: "egg", js: "egg", typ: r("Egg") },
238- { json: "height", js: "height", typ: "" },
239- { json: "id", js: "id", typ: i(0) },
240- { json: "img", js: "img", typ: "" },
241- { json: "multipliers", js: "multipliers", typ: u(a(3.14), null) },
242- { json: "name", js: "name", typ: "" },
243- { json: "next_evolution", js: "next_evolution", typ: u(undefined, a(r("Evolution"))) },
244- { json: "num", js: "num", typ: "" },
245- { json: "prev_evolution", js: "prev_evolution", typ: u(undefined, a(r("Evolution"))) },
246- { json: "spawn_chance", js: "spawn_chance", typ: 3.14 },
247- { json: "spawn_time", js: "spawn_time", typ: "" },
248- { json: "type", js: "type", typ: a(r("Type")) },
249- { json: "weaknesses", js: "weaknesses", typ: a(r("Type")) },
250- { json: "weight", js: "weight", typ: "" },
251- ], false),
252- "Evolution": o([
253- { json: "name", js: "name", typ: "" },
254- { json: "num", js: "num", typ: "" },
255- ], false),
256- "Egg": [
257- "2 km",
258- "Not in Eggs",
259- "5 km",
260- "10 km",
261- "Omanyte Candy",
262- ],
263- "Type": [
264- "Fire",
265- "Ice",
266- "Flying",
267- "Psychic",
268- "Water",
269- "Ground",
270- "Rock",
271- "Electric",
272- "Grass",
273- "Fighting",
274- "Poison",
275- "Bug",
276- "Fairy",
277- "Ghost",
278- "Dark",
279- "Steel",
280- "Dragon",
281- "Normal",
282- ],
283-};
Test case

test/inputs/json/samples/simple-object.json

2 generated files · +0 −201
Dswiftfinal-classes-true__struct-or-class-class--d3c62ec7414d / quicktype.swift+0 −101
@@ -1,101 +0,0 @@
1-// This file was generated from JSON Schema using quicktype, do not modify it directly.
2-// To parse the JSON, add this file to your project and do:
3-//
4-// let topLevel = try TopLevel(json)
5-
6-import Foundation
7-
8-// MARK: - TopLevel
9-final class TopLevel: Codable {
10- let date: Int
11- let title: String
12- let validity: Bool
13-
14- enum CodingKeys: String, CodingKey {
15- case date = "date"
16- case title = "title"
17- case validity = "validity"
18- }
19-
20- init(date: Int, title: String, validity: Bool) {
21- self.date = date
22- self.title = title
23- self.validity = validity
24- }
25-}
26-
27-// MARK: TopLevel convenience initializers and mutators
28-
29-extension TopLevel {
30- convenience init(data: Data) throws {
31- let me = try newJSONDecoder().decode(TopLevel.self, from: data)
32- self.init(date: me.date, title: me.title, validity: me.validity)
33- }
34-
35- convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws {
36- guard let data = json.data(using: encoding) else {
37- throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
38- }
39- try self.init(data: data)
40- }
41-
42- convenience init(fromURL url: URL) throws {
43- try self.init(data: try Data(contentsOf: url))
44- }
45-
46- func with(
47- date: Int? = nil,
48- title: String? = nil,
49- validity: Bool? = nil
50- ) -> TopLevel {
51- return TopLevel(
52- date: date ?? self.date,
53- title: title ?? self.title,
54- validity: validity ?? self.validity
55- )
56- }
57-
58- func jsonData() throws -> Data {
59- return try newJSONEncoder().encode(self)
60- }
61-
62- func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
63- return String(data: try self.jsonData(), encoding: encoding)
64- }
65-}
66-
67-// MARK: - Helper functions for creating encoders and decoders
68-
69-func newJSONDecoder() -> JSONDecoder {
70- let decoder = JSONDecoder()
71- decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in
72- let container = try decoder.singleValueContainer()
73- let dateStr = try container.decode(String.self)
74-
75- let formatter = DateFormatter()
76- formatter.calendar = Calendar(identifier: .iso8601)
77- formatter.locale = Locale(identifier: "en_US_POSIX")
78- formatter.timeZone = TimeZone(secondsFromGMT: 0)
79- formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX"
80- if let date = formatter.date(from: dateStr) {
81- return date
82- }
83- formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX"
84- if let date = formatter.date(from: dateStr) {
85- return date
86- }
87- throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date"))
88- })
89- return decoder
90-}
91-
92-func newJSONEncoder() -> JSONEncoder {
93- let encoder = JSONEncoder()
94- let formatter = DateFormatter()
95- formatter.calendar = Calendar(identifier: .iso8601)
96- formatter.locale = Locale(identifier: "en_US_POSIX")
97- formatter.timeZone = TimeZone(secondsFromGMT: 0)
98- formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSXXXXX"
99- encoder.dateEncodingStrategy = .formatted(formatter)
100- return encoder
101-}
Dswiftprotocol-hashable--739b516c7897 / quicktype.swift+0 −100
@@ -1,100 +0,0 @@
1-// This file was generated from JSON Schema using quicktype, do not modify it directly.
2-// To parse the JSON, add this file to your project and do:
3-//
4-// let topLevel = try TopLevel(json)
5-
6-//
7-// Hashable or Equatable:
8-// The compiler will not be able to synthesize the implementation of Hashable or Equatable
9-// for types that require the use of JSONAny, nor will the implementation of Hashable be
10-// synthesized for types that have collections (such as arrays or dictionaries).
11-
12-import Foundation
13-
14-// MARK: - TopLevel
15-struct TopLevel: Codable, Hashable {
16- let date: Int
17- let title: String
18- let validity: Bool
19-
20- enum CodingKeys: String, CodingKey {
21- case date = "date"
22- case title = "title"
23- case validity = "validity"
24- }
25-}
26-
27-// MARK: TopLevel convenience initializers and mutators
28-
29-extension TopLevel {
30- init(data: Data) throws {
31- self = try newJSONDecoder().decode(TopLevel.self, from: data)
32- }
33-
34- init(_ json: String, using encoding: String.Encoding = .utf8) throws {
35- guard let data = json.data(using: encoding) else {
36- throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
37- }
38- try self.init(data: data)
39- }
40-
41- init(fromURL url: URL) throws {
42- try self.init(data: try Data(contentsOf: url))
43- }
44-
45- func with(
46- date: Int? = nil,
47- title: String? = nil,
48- validity: Bool? = nil
49- ) -> TopLevel {
50- return TopLevel(
51- date: date ?? self.date,
52- title: title ?? self.title,
53- validity: validity ?? self.validity
54- )
55- }
56-
57- func jsonData() throws -> Data {
58- return try newJSONEncoder().encode(self)
59- }
60-
61- func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
62- return String(data: try self.jsonData(), encoding: encoding)
63- }
64-}
65-
66-// MARK: - Helper functions for creating encoders and decoders
67-
68-func newJSONDecoder() -> JSONDecoder {
69- let decoder = JSONDecoder()
70- decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in
71- let container = try decoder.singleValueContainer()
72- let dateStr = try container.decode(String.self)
73-
74- let formatter = DateFormatter()
75- formatter.calendar = Calendar(identifier: .iso8601)
76- formatter.locale = Locale(identifier: "en_US_POSIX")
77- formatter.timeZone = TimeZone(secondsFromGMT: 0)
78- formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX"
79- if let date = formatter.date(from: dateStr) {
80- return date
81- }
82- formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX"
83- if let date = formatter.date(from: dateStr) {
84- return date
85- }
86- throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date"))
87- })
88- return decoder
89-}
90-
91-func newJSONEncoder() -> JSONEncoder {
92- let encoder = JSONEncoder()
93- let formatter = DateFormatter()
94- formatter.calendar = Calendar(identifier: .iso8601)
95- formatter.locale = Locale(identifier: "en_US_POSIX")
96- formatter.timeZone = TimeZone(secondsFromGMT: 0)
97- formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSXXXXX"
98- encoder.dateEncodingStrategy = .formatted(formatter)
99- return encoder
100-}
No generated files match these filters.